python-openturns 1.3-3 / usr / lib / python2.7 / 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):
    """Proxy of C++ swig::SwigPyIterator class"""
    __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):
        """value(SwigPyIterator self) -> PyObject *"""
        return _analytical.SwigPyIterator_value(self)

    def incr(self, n=1):
        """
        incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        incr(SwigPyIterator self) -> SwigPyIterator
        """
        return _analytical.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """
        decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        decr(SwigPyIterator self) -> SwigPyIterator
        """
        return _analytical.SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _analytical.SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _analytical.SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(SwigPyIterator self) -> SwigPyIterator"""
        return _analytical.SwigPyIterator_copy(self)

    def next(self):
        """next(SwigPyIterator self) -> PyObject *"""
        return _analytical.SwigPyIterator_next(self)

    def __next__(self):
        """__next__(SwigPyIterator self) -> PyObject *"""
        return _analytical.SwigPyIterator___next__(self)

    def previous(self):
        """previous(SwigPyIterator self) -> PyObject *"""
        return _analytical.SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _analytical.SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _analytical.SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _analytical.SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _analytical.SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _analytical.SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _analytical.SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        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.common
import openturns.typ
import openturns.wrapper
class TestResult(openturns.common.PersistentObject):
    """Proxy of C++ OT::TestResult class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TestResult, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TestResult, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _analytical.TestResult_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(TestResult self) -> OT::String"""
        return _analytical.TestResult_getClassName(self)

    def setDescription(self, *args):
        """setDescription(TestResult self, Description description)"""
        return _analytical.TestResult_setDescription(self, *args)

    def getDescription(self):
        """getDescription(TestResult self) -> Description"""
        return _analytical.TestResult_getDescription(self)

    def __repr__(self):
        """__repr__(TestResult self) -> OT::String"""
        return _analytical.TestResult___repr__(self)

    def getBinaryQualityMeasure(self):
        """getBinaryQualityMeasure(TestResult self) -> OT::Bool"""
        return _analytical.TestResult_getBinaryQualityMeasure(self)

    def getPValue(self):
        """getPValue(TestResult self) -> OT::NumericalScalar"""
        return _analytical.TestResult_getPValue(self)

    def getThreshold(self):
        """getThreshold(TestResult self) -> OT::NumericalScalar"""
        return _analytical.TestResult_getThreshold(self)

    def getTestType(self):
        """getTestType(TestResult self) -> OT::String"""
        return _analytical.TestResult_getTestType(self)

    def __eq__(self, *args):
        """__eq__(TestResult self, TestResult other) -> OT::Bool"""
        return _analytical.TestResult___eq__(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::TestResult self) -> TestResult
        __init__(OT::TestResult self, OT::String const & type, OT::Bool const binMeasure, OT::NumericalScalar const pVal, 
            OT::NumericalScalar const pThreshold) -> TestResult
        __init__(OT::TestResult self, TestResult other) -> TestResult
        __init__(OT::TestResult self, PyObject * pyObj) -> TestResult
        """
        this = _analytical.new_TestResult(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _analytical.delete_TestResult
    __del__ = lambda self : None;
TestResult_swigregister = _analytical.TestResult_swigregister
TestResult_swigregister(TestResult)

def TestResult_GetClassName():
  """TestResult_GetClassName() -> OT::String"""
  return _analytical.TestResult_GetClassName()

import openturns.base
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):
    """Proxy of C++ OT::AnalyticalResult class"""
    __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():
        """GetClassName() -> OT::String"""
        return _analytical.AnalyticalResult_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(AnalyticalResult self) -> OT::String"""
        return _analytical.AnalyticalResult_getClassName(self)

    def getStandardSpaceDesignPoint(self):
        """getStandardSpaceDesignPoint(AnalyticalResult self) -> NumericalPoint"""
        return _analytical.AnalyticalResult_getStandardSpaceDesignPoint(self)

    def setStandardSpaceDesignPoint(self, *args):
        """setStandardSpaceDesignPoint(AnalyticalResult self, NumericalPoint standardSpaceDesignPoint)"""
        return _analytical.AnalyticalResult_setStandardSpaceDesignPoint(self, *args)

    def getPhysicalSpaceDesignPoint(self):
        """getPhysicalSpaceDesignPoint(AnalyticalResult self) -> NumericalPoint"""
        return _analytical.AnalyticalResult_getPhysicalSpaceDesignPoint(self)

    def getLimitStateVariable(self):
        """getLimitStateVariable(AnalyticalResult self) -> Event"""
        return _analytical.AnalyticalResult_getLimitStateVariable(self)

    def getIsStandardPointOriginInFailureSpace(self):
        """getIsStandardPointOriginInFailureSpace(AnalyticalResult self) -> OT::Bool"""
        return _analytical.AnalyticalResult_getIsStandardPointOriginInFailureSpace(self)

    def setIsStandardPointOriginInFailureSpace(self, *args):
        """setIsStandardPointOriginInFailureSpace(AnalyticalResult self, OT::Bool const isStandardPointOriginInFailureSpace)"""
        return _analytical.AnalyticalResult_setIsStandardPointOriginInFailureSpace(self, *args)

    def getMeanPointInStandardEventDomain(self):
        """getMeanPointInStandardEventDomain(AnalyticalResult self) -> NumericalPoint"""
        return _analytical.AnalyticalResult_getMeanPointInStandardEventDomain(self)

    def setMeanPointInStandardEventDomain(self, *args):
        """setMeanPointInStandardEventDomain(AnalyticalResult self, NumericalPoint meanPointInStandardEventDomain)"""
        return _analytical.AnalyticalResult_setMeanPointInStandardEventDomain(self, *args)

    def getImportanceFactors(self, classical=False):
        """
        getImportanceFactors(AnalyticalResult self, OT::Bool const classical=False) -> NumericalPointWithDescription
        getImportanceFactors(AnalyticalResult self) -> NumericalPointWithDescription
        """
        return _analytical.AnalyticalResult_getImportanceFactors(self, classical)

    def drawImportanceFactors(self, classical=False):
        """
        drawImportanceFactors(AnalyticalResult self, OT::Bool const classical=False) -> Graph
        drawImportanceFactors(AnalyticalResult self) -> Graph
        """
        return _analytical.AnalyticalResult_drawImportanceFactors(self, classical)

    def getHasoferReliabilityIndex(self):
        """getHasoferReliabilityIndex(AnalyticalResult self) -> OT::NumericalScalar"""
        return _analytical.AnalyticalResult_getHasoferReliabilityIndex(self)

    def getHasoferReliabilityIndexSensitivity(self):
        """getHasoferReliabilityIndexSensitivity(AnalyticalResult self) -> NumericalPointWithDescriptionCollection"""
        return _analytical.AnalyticalResult_getHasoferReliabilityIndexSensitivity(self)

    def getOptimizationResult(self):
        """getOptimizationResult(AnalyticalResult self) -> NearestPointAlgorithmImplementationResult"""
        return _analytical.AnalyticalResult_getOptimizationResult(self)

    def setOptimizationResult(self, *args):
        """setOptimizationResult(AnalyticalResult self, NearestPointAlgorithmImplementationResult optimizationResult)"""
        return _analytical.AnalyticalResult_setOptimizationResult(self, *args)

    def drawHasoferReliabilityIndexSensitivity(self, *args):
        """
        drawHasoferReliabilityIndexSensitivity(AnalyticalResult self, OT::NumericalScalar width=OT::ResourceMap::GetAsNumericalScalar( "AnalyticalResult-DefaultWidth" )) -> GraphCollection
        drawHasoferReliabilityIndexSensitivity(AnalyticalResult self) -> GraphCollection
        """
        return _analytical.AnalyticalResult_drawHasoferReliabilityIndexSensitivity(self, *args)

    def __repr__(self):
        """__repr__(AnalyticalResult self) -> OT::String"""
        return _analytical.AnalyticalResult___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::AnalyticalResult self, NumericalPoint standardSpaceDesignPoint, Event limitStateVariable, OT::Bool const isStandardPointOriginInFailureSpace, 
            OT::String const & name=DefaultName) -> AnalyticalResult
        __init__(OT::AnalyticalResult self, NumericalPoint standardSpaceDesignPoint, Event limitStateVariable, OT::Bool const isStandardPointOriginInFailureSpace) -> AnalyticalResult
        __init__(OT::AnalyticalResult self) -> AnalyticalResult
        __init__(OT::AnalyticalResult self, AnalyticalResult other) -> AnalyticalResult
        """
        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)

def AnalyticalResult_GetClassName():
  """AnalyticalResult_GetClassName() -> OT::String"""
  return _analytical.AnalyticalResult_GetClassName()

class Analytical(openturns.common.PersistentObject):
    """Proxy of C++ OT::Analytical class"""
    __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():
        """GetClassName() -> OT::String"""
        return _analytical.Analytical_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Analytical self) -> OT::String"""
        return _analytical.Analytical_getClassName(self)

    def getPhysicalStartingPoint(self):
        """getPhysicalStartingPoint(Analytical self) -> NumericalPoint"""
        return _analytical.Analytical_getPhysicalStartingPoint(self)

    def setPhysicalStartingPoint(self, *args):
        """setPhysicalStartingPoint(Analytical self, NumericalPoint physicalStartingPoint)"""
        return _analytical.Analytical_setPhysicalStartingPoint(self, *args)

    def getEvent(self):
        """getEvent(Analytical self) -> Event"""
        return _analytical.Analytical_getEvent(self)

    def setEvent(self, *args):
        """setEvent(Analytical self, Event event)"""
        return _analytical.Analytical_setEvent(self, *args)

    def getNearestPointAlgorithm(self):
        """getNearestPointAlgorithm(Analytical self) -> NearestPointAlgorithm"""
        return _analytical.Analytical_getNearestPointAlgorithm(self)

    def setNearestPointAlgorithm(self, *args):
        """setNearestPointAlgorithm(Analytical self, NearestPointAlgorithm nearestPointAlgorithm)"""
        return _analytical.Analytical_setNearestPointAlgorithm(self, *args)

    def getAnalyticalResult(self):
        """getAnalyticalResult(Analytical self) -> AnalyticalResult"""
        return _analytical.Analytical_getAnalyticalResult(self)

    def __repr__(self):
        """__repr__(Analytical self) -> OT::String"""
        return _analytical.Analytical___repr__(self)

    def run(self):
        """run(Analytical self)"""
        return _analytical.Analytical_run(self)

    def __init__(self, *args): 
        """
        __init__(OT::Analytical self, NearestPointAlgorithm nearestPointAlgorithm, Event compositeEvent, NumericalPoint physicalStartingPoint) -> Analytical
        __init__(OT::Analytical self, Analytical other) -> Analytical
        """
        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)

def Analytical_GetClassName():
  """Analytical_GetClassName() -> OT::String"""
  return _analytical.Analytical_GetClassName()

class FORMResult(AnalyticalResult):
    """Proxy of C++ OT::FORMResult class"""
    __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():
        """GetClassName() -> OT::String"""
        return _analytical.FORMResult_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(FORMResult self) -> OT::String"""
        return _analytical.FORMResult_getClassName(self)

    def getEventProbability(self):
        """getEventProbability(FORMResult self) -> OT::NumericalScalar"""
        return _analytical.FORMResult_getEventProbability(self)

    def getGeneralisedReliabilityIndex(self):
        """getGeneralisedReliabilityIndex(FORMResult self) -> OT::NumericalScalar"""
        return _analytical.FORMResult_getGeneralisedReliabilityIndex(self)

    def getEventProbabilitySensitivity(self):
        """getEventProbabilitySensitivity(FORMResult self) -> NumericalPointWithDescriptionCollection"""
        return _analytical.FORMResult_getEventProbabilitySensitivity(self)

    def drawEventProbabilitySensitivity(self, *args):
        """
        drawEventProbabilitySensitivity(FORMResult self, OT::NumericalScalar width=OT::ResourceMap::GetAsNumericalScalar("AnalyticalResult-DefaultWidth")) -> GraphCollection
        drawEventProbabilitySensitivity(FORMResult self) -> GraphCollection
        """
        return _analytical.FORMResult_drawEventProbabilitySensitivity(self, *args)

    def __repr__(self):
        """__repr__(FORMResult self) -> OT::String"""
        return _analytical.FORMResult___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::FORMResult self, NumericalPoint standardSpaceDesignPoint, Event limitStateVariable, OT::Bool const isStandardPointOriginInFailureSpace, 
            OT::String const & name=DefaultName) -> FORMResult
        __init__(OT::FORMResult self, NumericalPoint standardSpaceDesignPoint, Event limitStateVariable, OT::Bool const isStandardPointOriginInFailureSpace) -> FORMResult
        __init__(OT::FORMResult self) -> FORMResult
        __init__(OT::FORMResult self, FORMResult other) -> FORMResult
        """
        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)

def FORMResult_GetClassName():
  """FORMResult_GetClassName() -> OT::String"""
  return _analytical.FORMResult_GetClassName()

class FORM(Analytical):
    """Proxy of C++ OT::FORM class"""
    __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():
        """GetClassName() -> OT::String"""
        return _analytical.FORM_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(FORM self) -> OT::String"""
        return _analytical.FORM_getClassName(self)

    def getResult(self):
        """getResult(FORM self) -> FORMResult"""
        return _analytical.FORM_getResult(self)

    def setResult(self, *args):
        """setResult(FORM self, FORMResult formResult)"""
        return _analytical.FORM_setResult(self, *args)

    def __repr__(self):
        """__repr__(FORM self) -> OT::String"""
        return _analytical.FORM___repr__(self)

    def run(self):
        """run(FORM self)"""
        return _analytical.FORM_run(self)

    def __init__(self, *args): 
        """
        __init__(OT::FORM self) -> FORM
        __init__(OT::FORM self, NearestPointAlgorithm nearestPointAlgorithm, Event event, NumericalPoint physicalStartingPoint) -> FORM
        __init__(OT::FORM self, FORM other) -> FORM
        """
        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)

def FORM_GetClassName():
  """FORM_GetClassName() -> OT::String"""
  return _analytical.FORM_GetClassName()

class SORMResult(AnalyticalResult):
    """Proxy of C++ OT::SORMResult class"""
    __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():
        """GetClassName() -> OT::String"""
        return _analytical.SORMResult_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(SORMResult self) -> OT::String"""
        return _analytical.SORMResult_getClassName(self)

    def getEventProbabilityBreitung(self):
        """getEventProbabilityBreitung(SORMResult self) -> OT::NumericalScalar"""
        return _analytical.SORMResult_getEventProbabilityBreitung(self)

    def getEventProbabilityHohenBichler(self):
        """getEventProbabilityHohenBichler(SORMResult self) -> OT::NumericalScalar"""
        return _analytical.SORMResult_getEventProbabilityHohenBichler(self)

    def getEventProbabilityTvedt(self):
        """getEventProbabilityTvedt(SORMResult self) -> OT::NumericalScalar"""
        return _analytical.SORMResult_getEventProbabilityTvedt(self)

    def getGeneralisedReliabilityIndexBreitung(self):
        """getGeneralisedReliabilityIndexBreitung(SORMResult self) -> OT::NumericalScalar"""
        return _analytical.SORMResult_getGeneralisedReliabilityIndexBreitung(self)

    def getGeneralisedReliabilityIndexHohenBichler(self):
        """getGeneralisedReliabilityIndexHohenBichler(SORMResult self) -> OT::NumericalScalar"""
        return _analytical.SORMResult_getGeneralisedReliabilityIndexHohenBichler(self)

    def getGeneralisedReliabilityIndexTvedt(self):
        """getGeneralisedReliabilityIndexTvedt(SORMResult self) -> OT::NumericalScalar"""
        return _analytical.SORMResult_getGeneralisedReliabilityIndexTvedt(self)

    def getSortedCurvatures(self):
        """getSortedCurvatures(SORMResult self) -> NumericalPoint"""
        return _analytical.SORMResult_getSortedCurvatures(self)

    def __repr__(self):
        """__repr__(SORMResult self) -> OT::String"""
        return _analytical.SORMResult___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(SORMResult self, OT::String const & offset="") -> OT::String
        __str__(SORMResult self) -> OT::String
        """
        return _analytical.SORMResult___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::SORMResult self, NumericalPoint standardSpaceDesignPoint, Event limitStateVariable, OT::Bool const isStandardPointOriginInFailureSpace, 
            OT::String const & name=DefaultName) -> SORMResult
        __init__(OT::SORMResult self, NumericalPoint standardSpaceDesignPoint, Event limitStateVariable, OT::Bool const isStandardPointOriginInFailureSpace) -> SORMResult
        __init__(OT::SORMResult self) -> SORMResult
        __init__(OT::SORMResult self, SORMResult other) -> SORMResult
        """
        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)

def SORMResult_GetClassName():
  """SORMResult_GetClassName() -> OT::String"""
  return _analytical.SORMResult_GetClassName()

class SORM(Analytical):
    """Proxy of C++ OT::SORM class"""
    __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():
        """GetClassName() -> OT::String"""
        return _analytical.SORM_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(SORM self) -> OT::String"""
        return _analytical.SORM_getClassName(self)

    def getResult(self):
        """getResult(SORM self) -> SORMResult"""
        return _analytical.SORM_getResult(self)

    def setResult(self, *args):
        """setResult(SORM self, SORMResult sormResult)"""
        return _analytical.SORM_setResult(self, *args)

    def __repr__(self):
        """__repr__(SORM self) -> OT::String"""
        return _analytical.SORM___repr__(self)

    def run(self):
        """run(SORM self)"""
        return _analytical.SORM_run(self)

    def __init__(self, *args): 
        """
        __init__(OT::SORM self) -> SORM
        __init__(OT::SORM self, NearestPointAlgorithm nearestPointAlgorithm, Event event, NumericalPoint physicalStartingPoint) -> SORM
        __init__(OT::SORM self, SORM other) -> SORM
        """
        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)

def SORM_GetClassName():
  """SORM_GetClassName() -> OT::String"""
  return _analytical.SORM_GetClassName()

class StrongMaximumTest(openturns.common.PersistentObject):
    """Proxy of C++ OT::StrongMaximumTest class"""
    __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():
        """GetClassName() -> OT::String"""
        return _analytical.StrongMaximumTest_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(StrongMaximumTest self) -> OT::String"""
        return _analytical.StrongMaximumTest_getClassName(self)

    def getStandardSpaceDesignPoint(self):
        """getStandardSpaceDesignPoint(StrongMaximumTest self) -> NumericalPoint"""
        return _analytical.StrongMaximumTest_getStandardSpaceDesignPoint(self)

    def getEvent(self):
        """getEvent(StrongMaximumTest self) -> StandardEvent"""
        return _analytical.StrongMaximumTest_getEvent(self)

    def getImportanceLevel(self):
        """getImportanceLevel(StrongMaximumTest self) -> OT::NumericalScalar"""
        return _analytical.StrongMaximumTest_getImportanceLevel(self)

    def getAccuracyLevel(self):
        """getAccuracyLevel(StrongMaximumTest self) -> OT::NumericalScalar"""
        return _analytical.StrongMaximumTest_getAccuracyLevel(self)

    def getConfidenceLevel(self):
        """getConfidenceLevel(StrongMaximumTest self) -> OT::NumericalScalar"""
        return _analytical.StrongMaximumTest_getConfidenceLevel(self)

    def getDesignPointVicinity(self):
        """getDesignPointVicinity(StrongMaximumTest self) -> OT::NumericalScalar"""
        return _analytical.StrongMaximumTest_getDesignPointVicinity(self)

    def getPointNumber(self):
        """getPointNumber(StrongMaximumTest self) -> OT::UnsignedLong"""
        return _analytical.StrongMaximumTest_getPointNumber(self)

    def getDeltaEpsilon(self):
        """getDeltaEpsilon(StrongMaximumTest self) -> OT::NumericalScalar"""
        return _analytical.StrongMaximumTest_getDeltaEpsilon(self)

    def run(self):
        """run(StrongMaximumTest self)"""
        return _analytical.StrongMaximumTest_run(self)

    def getNearDesignPointVerifyingEventPoints(self):
        """getNearDesignPointVerifyingEventPoints(StrongMaximumTest self) -> NumericalSample"""
        return _analytical.StrongMaximumTest_getNearDesignPointVerifyingEventPoints(self)

    def getFarDesignPointVerifyingEventPoints(self):
        """getFarDesignPointVerifyingEventPoints(StrongMaximumTest self) -> NumericalSample"""
        return _analytical.StrongMaximumTest_getFarDesignPointVerifyingEventPoints(self)

    def getNearDesignPointViolatingEventPoints(self):
        """getNearDesignPointViolatingEventPoints(StrongMaximumTest self) -> NumericalSample"""
        return _analytical.StrongMaximumTest_getNearDesignPointViolatingEventPoints(self)

    def getFarDesignPointViolatingEventPoints(self):
        """getFarDesignPointViolatingEventPoints(StrongMaximumTest self) -> NumericalSample"""
        return _analytical.StrongMaximumTest_getFarDesignPointViolatingEventPoints(self)

    def getNearDesignPointVerifyingEventValues(self):
        """getNearDesignPointVerifyingEventValues(StrongMaximumTest self) -> NumericalSample"""
        return _analytical.StrongMaximumTest_getNearDesignPointVerifyingEventValues(self)

    def getFarDesignPointVerifyingEventValues(self):
        """getFarDesignPointVerifyingEventValues(StrongMaximumTest self) -> NumericalSample"""
        return _analytical.StrongMaximumTest_getFarDesignPointVerifyingEventValues(self)

    def getNearDesignPointViolatingEventValues(self):
        """getNearDesignPointViolatingEventValues(StrongMaximumTest self) -> NumericalSample"""
        return _analytical.StrongMaximumTest_getNearDesignPointViolatingEventValues(self)

    def getFarDesignPointViolatingEventValues(self):
        """getFarDesignPointViolatingEventValues(StrongMaximumTest self) -> NumericalSample"""
        return _analytical.StrongMaximumTest_getFarDesignPointViolatingEventValues(self)

    def __repr__(self):
        """__repr__(StrongMaximumTest self) -> OT::String"""
        return _analytical.StrongMaximumTest___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::StrongMaximumTest self) -> StrongMaximumTest
        __init__(OT::StrongMaximumTest self, StandardEvent event, NumericalPoint standardSpaceDesignPoint, OT::NumericalScalar const importanceLevel, 
            OT::NumericalScalar const accuracyLevel, OT::NumericalScalar const confidenceLevel) -> StrongMaximumTest
        __init__(OT::StrongMaximumTest self, StandardEvent event, NumericalPoint standardSpaceDesignPoint, OT::NumericalScalar const importanceLevel, 
            OT::NumericalScalar const accuracyLevel, OT::UnsignedLong const pointNumber) -> StrongMaximumTest
        __init__(OT::StrongMaximumTest self, StrongMaximumTest other) -> StrongMaximumTest
        """
        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)

def StrongMaximumTest_GetClassName():
  """StrongMaximumTest_GetClassName() -> OT::String"""
  return _analytical.StrongMaximumTest_GetClassName()

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