python3-openturns 1.5-7build2 / usr / lib / python3 / dist-packages / openturns / analytical.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.12
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.




"""
Analytical uncertainty propagation algorithms.
"""


from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_analytical', [dirname(__file__)])
        except ImportError:
            import _analytical
            return _analytical
        if fp is not None:
            try:
                _mod = imp.load_module('_analytical', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _analytical = swig_import_helper()
    del swig_import_helper
else:
    import _analytical
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


class SwigPyIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _analytical.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self): return _analytical.SwigPyIterator_value(self)
    def incr(self, n=1): return _analytical.SwigPyIterator_incr(self, n)
    def decr(self, n=1): return _analytical.SwigPyIterator_decr(self, n)
    def distance(self, *args): return _analytical.SwigPyIterator_distance(self, *args)
    def equal(self, *args): return _analytical.SwigPyIterator_equal(self, *args)
    def copy(self): return _analytical.SwigPyIterator_copy(self)
    def next(self): return _analytical.SwigPyIterator_next(self)
    def __next__(self): return _analytical.SwigPyIterator___next__(self)
    def previous(self): return _analytical.SwigPyIterator_previous(self)
    def advance(self, *args): return _analytical.SwigPyIterator_advance(self, *args)
    def __eq__(self, *args): return _analytical.SwigPyIterator___eq__(self, *args)
    def __ne__(self, *args): return _analytical.SwigPyIterator___ne__(self, *args)
    def __iadd__(self, *args): return _analytical.SwigPyIterator___iadd__(self, *args)
    def __isub__(self, *args): return _analytical.SwigPyIterator___isub__(self, *args)
    def __add__(self, *args): return _analytical.SwigPyIterator___add__(self, *args)
    def __sub__(self, *args): return _analytical.SwigPyIterator___sub__(self, *args)
    def __iter__(self): return self
SwigPyIterator_swigregister = _analytical.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

GCC_VERSION = _analytical.GCC_VERSION
class TestFailed:
    """TestFailed is used to raise an uniform exception in tests."""

    __type = "TestFailed"

    def __init__(self, reason=""):
        self.reason = reason

    def type(self):
        return TestFailed.__type

    def what(self):
        return self.reason

    def __str__(self):
        return TestFailed.__type + ": " + self.reason

    def __lshift__(self, ch):
        self.reason += ch
        return self

import openturns.base
import openturns.common
import openturns.wrapper
import openturns.typ
import openturns.statistics
import openturns.graph
import openturns.func
import openturns.geom
import openturns.diff
import openturns.optim
import openturns.solver
import openturns.algo
import openturns.experiment
import openturns.model_copula
import openturns.metamodel
import openturns.weightedexperiment
import openturns.orthogonalbasis
import openturns.randomvector
import openturns.transformation
class AnalyticalResult(openturns.common.PersistentObject):
    """
    Analytical result.

    Available constructors:
        AnalyticalResult()

        AnalyticalResult(*designPoint, limitStateVariable, isInFailureSpace*)

    Notes
    -----
    Structure created by the method run() of a :class:`~openturns.Analytical`
    and obtained thanks to the method getAnalyticalResult().

    Parameters
    ----------
    designPoint : float sequence
        Design point in the standard space resulting from the optimization
        algorithm.
    limitStateVariable : :class:`~openturns.Event`
        Event of which the probability is calculated.
    isInFailureSpace : bool
        Indicates whether the origin of the standard space is in the failure space.
    """
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AnalyticalResult, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AnalyticalResult, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _analytical.AnalyticalResult_getClassName(self)

    ELLIPTICAL = _analytical.AnalyticalResult_ELLIPTICAL
    CLASSICAL = _analytical.AnalyticalResult_CLASSICAL
    PHYSICAL = _analytical.AnalyticalResult_PHYSICAL
    def getStandardSpaceDesignPoint(self):
        """
        Accessor to the design point in the standard space.

        Returns
        -------
        designPoint : float sequence
            Design point in the standard space resulting from the optimization
            algorithm.
        """
        return _analytical.AnalyticalResult_getStandardSpaceDesignPoint(self)

    def setStandardSpaceDesignPoint(self, *args):
        """
        Accessor to the design point in the standard space.

        Returns
        -------
        designPoint : float sequence
            Design point in the standard space resulting from the optimization
            algorithm.
        """
        return _analytical.AnalyticalResult_setStandardSpaceDesignPoint(self, *args)

    def getPhysicalSpaceDesignPoint(self):
        """
        Accessor to the design point in the physical space.

        Returns
        -------
        designPoint : float sequence
            Design point in the physical space resulting from the optimization
            algorithm.
        """
        return _analytical.AnalyticalResult_getPhysicalSpaceDesignPoint(self)

    def getLimitStateVariable(self):
        """
        Accessor to the event of which the probability is calculated.

        Returns
        -------
        limitStateVariable : :class:`~openturns.Event`
            Event of which the probability is calculated.
        """
        return _analytical.AnalyticalResult_getLimitStateVariable(self)

    def getIsStandardPointOriginInFailureSpace(self):
        """
        Accessor to know if the standard point origin is in the failure space.

        Returns
        -------
        isInFailureSpace : bool
            Indicates whether the origin of the standard space is in the failure space.
        """
        return _analytical.AnalyticalResult_getIsStandardPointOriginInFailureSpace(self)

    def setIsStandardPointOriginInFailureSpace(self, *args):
        """
        Accessor to specify if the standard point origin is in the failure space.

        Parameters
        ----------
        isInFailureSpace : bool
            Indicates whether the origin of the standard space is in the failure space.
        """
        return _analytical.AnalyticalResult_setIsStandardPointOriginInFailureSpace(self, *args)

    def getMeanPointInStandardEventDomain(self):
        """
        Accessor to the mean point in the standard event domain.

        Returns
        -------
        meanPoint : float sequence
            Mean point of the standard space distribution restricted to the event
            domain:
            :math:`\\displaystyle \\frac{1}{E_1(-\\beta)}\\int_{\\beta}^{\\infty} u_1 p_1(u_1)du_1`
            where :math:`E_1` is the spheric univariate distribution of the standard
            space and :math:`\\beta` the reliability index.
        """
        return _analytical.AnalyticalResult_getMeanPointInStandardEventDomain(self)

    def setMeanPointInStandardEventDomain(self, *args):
        """
        Accessor to the mean point in the standard event domain.

        Parameters
        ----------
        meanPoint : float sequence
            Mean point of the standard space distribution restricted to the event
            domain:
            :math:`\\displaystyle \\frac{1}{E_1(-\\beta)}\\int_{\\beta}^{\\infty} u_1 p_1(u_1)du_1`
            where :math:`E_1` is the spheric univariate distribution of the standard
            space and :math:`\\beta` the reliability index.
        """
        return _analytical.AnalyticalResult_setMeanPointInStandardEventDomain(self, *args)

    def getImportanceFactors(self, *args):
        """
        Accessor to the importance factors.

        Parameters
        ----------
        type : int, optional
            By default, the importance factors are evaluated as the square of the
            co-factors of the design point in the U-space.
            When `AnalyticalResult.CLASSICAL` they are evaluated as the square of the co-factors
            of the design point in the Y-space.
            When `AnalyticalResult.PHYSICAL`, the importance factors are evaluated
            as the square of the physical sensitivities.

        Notes
        -----
        If the importance factors are evaluated as the square of the
        co-factors of the design point in the U-space:

        .. math::

            \\alpha_i^2 = \\frac{(u_i^*)^2}
                              {\\beta_{HL}^2}

        If the importance factors are evaluated as the square of the co-factors of the
        design point in the Y-space:

        .. math::

            \\alpha_i^2 = \\frac{(y_i^*)^2}
                              {\\|\\vect{y}^*\\|^2}

        where

        .. math::

            Y^* = \\left(
                  \\begin{array}{c}
                      E^{-1}\\circ F_1(X_1^*) \\\\
                      E^{-1}\\circ F_2(X_2^*) \\\\
                      \\vdots \\\\
                      E^{-1}\\circ F_n(X_n^*)
                  \\end{array}
                  \\right)

        with :math:`\\vect{X}^*` is the design point in the physical space and E
        the univariate standard CDF of the elliptical space. In the case where the
        input distribution of :math:`\\vect{X}` has an elliptical copula
        :math:`C_E`, then :math:`E` has the same type as :math:`C_E`.
        In the case where the input distribution of :math:`\\vect{X}` has a copula
        :math:`C` which is not elliptical, then :math:`E=\\Phi` where :math:`\\Phi`
        is the CDF of the standard normal.

        If the importance factors are evaluated as the square of the physical sensitivities:

        .. math::
            \\alpha_i^2 = \\displaystyle \\frac{s_i^2}{{\\|s\\|}^2}

        where

        .. math::
            s_i = \\displaystyle \\frac{\\partial \\beta}{\\partial x_i} (x^*) = \\sum_{j=1}^n \\frac{\\partial \\beta}{\\partial u_i} \\frac{\\partial u_j}{\\partial x_i} (x^*)

        Returns
        -------
        factors : float sequence with description for each component
            List of the importance factors.
        """
        return _analytical.AnalyticalResult_getImportanceFactors(self, *args)

    def drawImportanceFactors(self, *args):
        """
        Draw the importance factors.

        Parameters
        ----------
        type : int, optional
            See :meth:`getImportanceFactors`

        Returns
        -------
        graph : :class:`~openturns.Graph`
            Pie of the importance factors of the probabilistic variables.
        """
        return _analytical.AnalyticalResult_drawImportanceFactors(self, *args)

    def getHasoferReliabilityIndex(self):
        """
        Accessor to the Hasofer Reliability Index.

        Returns
        -------
        index : float
            Hasofer Reliability Index.
        """
        return _analytical.AnalyticalResult_getHasoferReliabilityIndex(self)

    def getHasoferReliabilityIndexSensitivity(self):
        """
        Accessor to the sensitivities of the Hasofer Reliability Index.

        Returns
        -------
        sensitivity : :class:`~openturns.Sensitivity`
            Sensitivities of the Hasofer Reliability Index to the parameters of the
            probabilistic input vector (marginals and dependence structure).
        """
        return _analytical.AnalyticalResult_getHasoferReliabilityIndexSensitivity(self)

    def getOptimizationResult(self):
        """
        Accessor to the result of the optimization problem.

        Returns
        -------
        result : :class:`~openturns.NearestPointAlgorithmImplementationResult`
            Contains the design point in the standard space and information concerning
            the convergence of the optimization algorithm.
        """
        return _analytical.AnalyticalResult_getOptimizationResult(self)

    def setOptimizationResult(self, *args):
        """
        Accessor to the result of the optimization problem.

        Returns
        -------
        result : :class:`~openturns.NearestPointAlgorithmImplementationResult`
            Contains the design point in the standard space and information concerning
            the convergence of the optimization algorithm.
        """
        return _analytical.AnalyticalResult_setOptimizationResult(self, *args)

    def drawHasoferReliabilityIndexSensitivity(self, *args):
        """
        Draw the sensitivity of the Hasofer Reliability Index.

        Parameters
        ----------
        width : float, optional
            Value to calculate the shift position of the :class:`~openturns.BarPlot`.
            By default it is 1.0.

        Returns
        -------
        graphCollection : list of two :class:`~openturns.Graph` containing a barplot
            The first graph drawing the sensitivity of the Hasofer Reliability Index to
            the parameters of the marginals of the probabilistic input vector.
            The second graph drawing the sensitivity of the Hasofer Reliability Index
            to the parameters of the dependence structure of the probabilistic input
            vector.
        """
        return _analytical.AnalyticalResult_drawHasoferReliabilityIndexSensitivity(self, *args)

    def __repr__(self): return _analytical.AnalyticalResult___repr__(self)
    def __init__(self, *args): 
        this = _analytical.new_AnalyticalResult(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _analytical.delete_AnalyticalResult
    __del__ = lambda self : None;
AnalyticalResult_swigregister = _analytical.AnalyticalResult_swigregister
AnalyticalResult_swigregister(AnalyticalResult)

class Analytical(openturns.common.PersistentObject):
    """
    Base class to find the design point.

    Available constructors:
        Analytical(*nearestPointAlgorithm, event, physicalStartingPoint*)

    Parameters
    ----------
    nearestPointAlgorithm : :class:`~openturns.NearestPointAlgorithm`
        Optimization algorithm used to research the design point.
    event : :class:`~openturns.Event`
        Failure event.
    physicalStartingPoint : float sequence
        Starting point of the optimization algorithm, declared in the physical
        space.

    Notes
    -----
    An event is defined as follows:
    :math:`\\cD_f = \\{\\vect{X} \\in \\Rset^n \\, / \\, g(\\vect{X},\\vect{d}) \\le 0\\}`
    where :math:`\\vect{X}` denotes a random input vector, representing the sources
    of uncertainties, :math:`\\vect{d}` is a determinist vector, representing the
    fixed variables and :math:`g(\\vect{X},\\vect{d})` is the limit state function of
    the model.
    The probability content of the event :math:`\\cD_f`:

    .. math::

        P_f = \\int_{g(\\vect{X},\\vect{d})\\le 0}f_\\vect{X}(\\vect{x})d\\vect{x}

    may be evaluated with the :class:`~openturns.FORM` or :class:`~openturns.SORM`
    methods.

    In order to evaluate an approximation of :math:`P_f`, these analytical methods
    uses the Nataf isoprobabilistic transformation which maps the probabilistic
    model in terms of :math:`\\vect{X}` onto an equivalent model in terms of
    :math:`n` independant standard normal random :math:`\\vect{U}`. In that new
    :math:`\\vect{u}`-space, the event has the new expression defined from the
    transformed limit state function of the model
    :math:`G : \\cD_f = \\{\\vect{U} \\in \\Rset^n \\, / \\, G(\\vect{U}\\,,\\,\\vect{d}) \\le 0\\}`
    and its boundary: :math:`\\{\\vect{U} \\in \\Rset^n \\, / \\,G(\\vect{U}\\,,\\,\\vect{d}) = 0\\}`.

    These analytical methods rely on the assumption that most of the contribution
    to :math:`P_f` comes from points located in the vicinity of a particular point
    :math:`P^*`, the **design point**, defined in the :math:`\\vect{u}`-space as the
    point located on the limit state surface and of maximal likelihood.
    Given the probabilistic caracteristics of the :math:`\\vect{u}`-space,
    :math:`P^*` has a geometrical interpretation: it is the point located on the
    event boundary and at minimal distance from the center of the
    :math:`\\vect{u}`-space. Thus, the design point :math:`P^*` is the result of a
    constrained optimization problem.

    See also
    --------
    FORM, SORM, StrongMaximumTest

    Examples
    --------
    >>> import openturns as ot
    >>> myFunction = ot.NumericalMathFunction(['E', 'F', 'L', 'I'], ['d'], ['-F*L^3/(3*E*I)'])
    >>> myDistribution = ot.Normal([50., 1., 10., 5.], [1.]*4, ot.IdentityMatrix(4))
    >>> vect = ot.RandomVector(myDistribution)
    >>> output = ot.RandomVector(myFunction, vect)
    >>> myEvent = ot.Event(output, ot.Less(), -3.0)
    >>> # We create a NearestPoint algorithm
    >>> myCobyla = ot.Cobyla()
    >>> myAlgo = ot.Analytical(myCobyla, myEvent, [50., 1., 10., 5.])
    """
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Analytical, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Analytical, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _analytical.Analytical_getClassName(self)

    def getPhysicalStartingPoint(self):
        """
        Accessor to the starting point of the optimization algorithm.

        Returns
        -------
        point : float sequence
            Starting point of the optimization algorithm, declared in the physical
            space.
        """
        return _analytical.Analytical_getPhysicalStartingPoint(self)

    def setPhysicalStartingPoint(self, *args):
        """
        Accessor to the starting point of the optimization algorithm.

        Parameters
        ----------
        point : float sequence
            Starting point of the optimization algorithm, declared in the physical
            space.
        """
        return _analytical.Analytical_setPhysicalStartingPoint(self, *args)

    def getEvent(self):
        """
        Accessor to the event of which the probability is calculated.

        Returns
        -------
        event : :class:`~openturns.Event`
            Event of which the probability is calculated.
        """
        return _analytical.Analytical_getEvent(self)

    def setEvent(self, *args):
        """
        Accessor to the event of which the probability is calculated.

        Parameters
        ----------
        event : :class:`~openturns.Event`
            Event of which the probability is calculated.
        """
        return _analytical.Analytical_setEvent(self, *args)

    def getNearestPointAlgorithm(self):
        """
        Accessor to the optimization algorithm used to find the design point.

        Returns
        -------
        algorithm : :class:`~openturns.NearestPointAlgorithm`
             Optimization algorithm used to research the design point.
        """
        return _analytical.Analytical_getNearestPointAlgorithm(self)

    def setNearestPointAlgorithm(self, *args):
        """
        Accessor to the optimization algorithm used to find the design point.

        Parameters
        ----------
        algorithm : :class:`~openturns.NearestPointAlgorithm`
             Optimization algorithm used to research the design point.
        """
        return _analytical.Analytical_setNearestPointAlgorithm(self, *args)

    def getAnalyticalResult(self):
        """
        Accessor to the result.

        Returns
        -------
        result : :class:`~openturns.AnalyticalResult`
            Result structure which contains the results of the optimisation problem.
        """
        return _analytical.Analytical_getAnalyticalResult(self)

    def __repr__(self): return _analytical.Analytical___repr__(self)
    def run(self):
        """
        Perform the research of the design point.

        Notes
        -----
        Performs the research of the design point and creates a
        :class:`~openturns.AnalyticalResult`, the structure result which is
        accessible with the method getAnalyticalResult.

        See also
        --------
        getAnalyticalResult
        """
        return _analytical.Analytical_run(self)

    def __init__(self, *args): 
        this = _analytical.new_Analytical(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _analytical.delete_Analytical
    __del__ = lambda self : None;
Analytical_swigregister = _analytical.Analytical_swigregister
Analytical_swigregister(Analytical)

class FORMResult(AnalyticalResult):
    __swig_setmethods__ = {}
    for _s in [AnalyticalResult]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FORMResult, name, value)
    __swig_getmethods__ = {}
    for _s in [AnalyticalResult]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FORMResult, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _analytical.FORMResult_getClassName(self)

    def getEventProbability(self): return _analytical.FORMResult_getEventProbability(self)
    def getGeneralisedReliabilityIndex(self): return _analytical.FORMResult_getGeneralisedReliabilityIndex(self)
    def getEventProbabilitySensitivity(self): return _analytical.FORMResult_getEventProbabilitySensitivity(self)
    def drawEventProbabilitySensitivity(self, *args): return _analytical.FORMResult_drawEventProbabilitySensitivity(self, *args)
    def __repr__(self): return _analytical.FORMResult___repr__(self)
    def __init__(self, *args): 
        this = _analytical.new_FORMResult(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _analytical.delete_FORMResult
    __del__ = lambda self : None;
FORMResult_swigregister = _analytical.FORMResult_swigregister
FORMResult_swigregister(FORMResult)

class FORM(Analytical):
    __swig_setmethods__ = {}
    for _s in [Analytical]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FORM, name, value)
    __swig_getmethods__ = {}
    for _s in [Analytical]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FORM, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _analytical.FORM_getClassName(self)

    def getResult(self): return _analytical.FORM_getResult(self)
    def setResult(self, *args): return _analytical.FORM_setResult(self, *args)
    def __repr__(self): return _analytical.FORM___repr__(self)
    def run(self):
        """
        Perform the research of the design point.

        Notes
        -----
        Performs the research of the design point and creates a
        :class:`~openturns.AnalyticalResult`, the structure result which is
        accessible with the method getAnalyticalResult.

        See also
        --------
        getAnalyticalResult
        """
        return _analytical.FORM_run(self)

    def __init__(self, *args): 
        this = _analytical.new_FORM(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _analytical.delete_FORM
    __del__ = lambda self : None;
FORM_swigregister = _analytical.FORM_swigregister
FORM_swigregister(FORM)

class SORMResult(AnalyticalResult):
    __swig_setmethods__ = {}
    for _s in [AnalyticalResult]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SORMResult, name, value)
    __swig_getmethods__ = {}
    for _s in [AnalyticalResult]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SORMResult, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _analytical.SORMResult_getClassName(self)

    def getEventProbabilityBreitung(self): return _analytical.SORMResult_getEventProbabilityBreitung(self)
    def getEventProbabilityHohenBichler(self): return _analytical.SORMResult_getEventProbabilityHohenBichler(self)
    def getEventProbabilityTvedt(self): return _analytical.SORMResult_getEventProbabilityTvedt(self)
    def getGeneralisedReliabilityIndexBreitung(self): return _analytical.SORMResult_getGeneralisedReliabilityIndexBreitung(self)
    def getGeneralisedReliabilityIndexHohenBichler(self): return _analytical.SORMResult_getGeneralisedReliabilityIndexHohenBichler(self)
    def getGeneralisedReliabilityIndexTvedt(self): return _analytical.SORMResult_getGeneralisedReliabilityIndexTvedt(self)
    def getSortedCurvatures(self): return _analytical.SORMResult_getSortedCurvatures(self)
    def __repr__(self): return _analytical.SORMResult___repr__(self)
    def __str__(self, offset=""): return _analytical.SORMResult___str__(self, offset)
    def __init__(self, *args): 
        this = _analytical.new_SORMResult(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _analytical.delete_SORMResult
    __del__ = lambda self : None;
SORMResult_swigregister = _analytical.SORMResult_swigregister
SORMResult_swigregister(SORMResult)

class SORM(Analytical):
    __swig_setmethods__ = {}
    for _s in [Analytical]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SORM, name, value)
    __swig_getmethods__ = {}
    for _s in [Analytical]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SORM, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _analytical.SORM_getClassName(self)

    def getResult(self): return _analytical.SORM_getResult(self)
    def setResult(self, *args): return _analytical.SORM_setResult(self, *args)
    def __repr__(self): return _analytical.SORM___repr__(self)
    def run(self):
        """
        Perform the research of the design point.

        Notes
        -----
        Performs the research of the design point and creates a
        :class:`~openturns.AnalyticalResult`, the structure result which is
        accessible with the method getAnalyticalResult.

        See also
        --------
        getAnalyticalResult
        """
        return _analytical.SORM_run(self)

    def __init__(self, *args): 
        this = _analytical.new_SORM(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _analytical.delete_SORM
    __del__ = lambda self : None;
SORM_swigregister = _analytical.SORM_swigregister
SORM_swigregister(SORM)

class StrongMaximumTest(openturns.common.PersistentObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StrongMaximumTest, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, StrongMaximumTest, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _analytical.StrongMaximumTest_getClassName(self)

    def getStandardSpaceDesignPoint(self): return _analytical.StrongMaximumTest_getStandardSpaceDesignPoint(self)
    def getEvent(self): return _analytical.StrongMaximumTest_getEvent(self)
    def getImportanceLevel(self): return _analytical.StrongMaximumTest_getImportanceLevel(self)
    def getAccuracyLevel(self): return _analytical.StrongMaximumTest_getAccuracyLevel(self)
    def getConfidenceLevel(self): return _analytical.StrongMaximumTest_getConfidenceLevel(self)
    def getDesignPointVicinity(self): return _analytical.StrongMaximumTest_getDesignPointVicinity(self)
    def getPointNumber(self): return _analytical.StrongMaximumTest_getPointNumber(self)
    def getDeltaEpsilon(self): return _analytical.StrongMaximumTest_getDeltaEpsilon(self)
    def run(self): return _analytical.StrongMaximumTest_run(self)
    def getNearDesignPointVerifyingEventPoints(self): return _analytical.StrongMaximumTest_getNearDesignPointVerifyingEventPoints(self)
    def getFarDesignPointVerifyingEventPoints(self): return _analytical.StrongMaximumTest_getFarDesignPointVerifyingEventPoints(self)
    def getNearDesignPointViolatingEventPoints(self): return _analytical.StrongMaximumTest_getNearDesignPointViolatingEventPoints(self)
    def getFarDesignPointViolatingEventPoints(self): return _analytical.StrongMaximumTest_getFarDesignPointViolatingEventPoints(self)
    def getNearDesignPointVerifyingEventValues(self): return _analytical.StrongMaximumTest_getNearDesignPointVerifyingEventValues(self)
    def getFarDesignPointVerifyingEventValues(self): return _analytical.StrongMaximumTest_getFarDesignPointVerifyingEventValues(self)
    def getNearDesignPointViolatingEventValues(self): return _analytical.StrongMaximumTest_getNearDesignPointViolatingEventValues(self)
    def getFarDesignPointViolatingEventValues(self): return _analytical.StrongMaximumTest_getFarDesignPointViolatingEventValues(self)
    def __repr__(self): return _analytical.StrongMaximumTest___repr__(self)
    def __init__(self, *args): 
        this = _analytical.new_StrongMaximumTest(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _analytical.delete_StrongMaximumTest
    __del__ = lambda self : None;
StrongMaximumTest_swigregister = _analytical.StrongMaximumTest_swigregister
StrongMaximumTest_swigregister(StrongMaximumTest)

# This file is compatible with both classic and new-style classes.