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

"""

PyTrilinos.LOCA.Abstract is the python interface to namespace Abstract
of the Trilinos continuation algorithm package LOCA:

    http://trilinos.sandia.gov/packages/nox

The purpose of LOCA.Abstract is to provide abstract continuation
problem base classes.  The python version of LOCA.Abstract supports
the following classes:

    * Group                - Compatiblity class for AbstractGroup hierarchy
    * TransposeSolveGroup  - Abstract group interface class for solving the
                             transpose of the Jacobian
    * Iterator             - Abstract interface for implementing iteration
    * Factory              - Abstract interface for providing a user-defined
                             factory

"""


from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_Abstract')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_Abstract')
    _Abstract = swig_import_helper()
    del swig_import_helper
elif _swig_python_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('_Abstract', [dirname(__file__)])
        except ImportError:
            import _Abstract
            return _Abstract
        try:
            _mod = imp.load_module('_Abstract', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _Abstract = swig_import_helper()
    del swig_import_helper
else:
    import _Abstract
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            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("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

try:
    import weakref
    weakref_proxy = weakref.proxy
except __builtin__.Exception:
    weakref_proxy = lambda x: x


import PyTrilinos.Teuchos
import PyTrilinos.NOX.Abstract
import MultiContinuation
import Homotopy
import TimeDependent
import TurningPoint.MooreSpence
import TurningPoint.MinimallyAugmented
import Pitchfork.MooreSpence
import Pitchfork.MinimallyAugmented
import Hopf.MooreSpence
import Hopf.MinimallyAugmented
import PhaseTransition
class Group(Homotopy.AbstractGroup, TurningPoint.MinimallyAugmented.FiniteDifferenceGroup, Pitchfork.MinimallyAugmented.AbstractGroup, Hopf.MinimallyAugmented.FiniteDifferenceGroup, PhaseTransition.AbstractGroup):
    """Proxy of C++ LOCA::Abstract::Group class."""

    __swig_setmethods__ = {}
    for _s in [Homotopy.AbstractGroup, TurningPoint.MinimallyAugmented.FiniteDifferenceGroup, Pitchfork.MinimallyAugmented.AbstractGroup, Hopf.MinimallyAugmented.FiniteDifferenceGroup, PhaseTransition.AbstractGroup]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Group, name, value)
    __swig_getmethods__ = {}
    for _s in [Homotopy.AbstractGroup, TurningPoint.MinimallyAugmented.FiniteDifferenceGroup, Pitchfork.MinimallyAugmented.AbstractGroup, Hopf.MinimallyAugmented.FiniteDifferenceGroup, PhaseTransition.AbstractGroup]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Group, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _Abstract.delete_Group

    def augmentJacobianForHomotopy(self, *args):
        """augmentJacobianForHomotopy(Group self, double a, double b) -> NOX::Abstract::Group::ReturnType"""
        return _Abstract.Group_augmentJacobianForHomotopy(self, *args)


    def computeShiftedMatrix(self, *args):
        """computeShiftedMatrix(Group self, double alpha, double beta) -> NOX::Abstract::Group::ReturnType"""
        return _Abstract.Group_computeShiftedMatrix(self, *args)


    def applyShiftedMatrix(self, *args):
        """applyShiftedMatrix(Group self, Vector input, Vector loca_result) -> NOX::Abstract::Group::ReturnType"""
        return _Abstract.Group_applyShiftedMatrix(self, *args)


    def applyShiftedMatrixMultiVector(self, *args):
        """applyShiftedMatrixMultiVector(Group self, MultiVector input, MultiVector loca_result) -> NOX::Abstract::Group::ReturnType"""
        return _Abstract.Group_applyShiftedMatrixMultiVector(self, *args)


    def applyShiftedMatrixInverseMultiVector(self, *args):
        """applyShiftedMatrixInverseMultiVector(Group self, ParameterList params, MultiVector input, MultiVector loca_result) -> NOX::Abstract::Group::ReturnType"""
        return _Abstract.Group_applyShiftedMatrixInverseMultiVector(self, *args)


    def computeSecondShiftedMatrix(self, *args):
        """computeSecondShiftedMatrix(Group self, double alpha, double beta) -> NOX::Abstract::Group::ReturnType"""
        return _Abstract.Group_computeSecondShiftedMatrix(self, *args)


    def applySecondShiftedMatrix(self, *args):
        """applySecondShiftedMatrix(Group self, Vector input, Vector loca_result) -> NOX::Abstract::Group::ReturnType"""
        return _Abstract.Group_applySecondShiftedMatrix(self, *args)


    def applySecondShiftedMatrixMultiVector(self, *args):
        """applySecondShiftedMatrixMultiVector(Group self, MultiVector input, MultiVector loca_result) -> NOX::Abstract::Group::ReturnType"""
        return _Abstract.Group_applySecondShiftedMatrixMultiVector(self, *args)


    def isComplex(self, *args):
        """isComplex(Group self) -> bool"""
        return _Abstract.Group_isComplex(self, *args)


    def computeComplex(self, *args):
        """computeComplex(Group self, double frequency) -> NOX::Abstract::Group::ReturnType"""
        return _Abstract.Group_computeComplex(self, *args)


    def applyComplex(self, *args):
        """applyComplex(Group self, Vector input_real, Vector input_imag, Vector result_real, Vector result_imag) -> NOX::Abstract::Group::ReturnType"""
        return _Abstract.Group_applyComplex(self, *args)


    def applyComplexMultiVector(self, *args):
        """applyComplexMultiVector(Group self, MultiVector input_real, MultiVector input_imag, MultiVector result_real, MultiVector result_imag) -> NOX::Abstract::Group::ReturnType"""
        return _Abstract.Group_applyComplexMultiVector(self, *args)


    def applyComplexInverseMultiVector(self, *args):
        """applyComplexInverseMultiVector(Group self, ParameterList params, MultiVector input_real, MultiVector input_imag, MultiVector result_real, MultiVector result_imag) -> NOX::Abstract::Group::ReturnType"""
        return _Abstract.Group_applyComplexInverseMultiVector(self, *args)


    def applyComplexTranspose(self, *args):
        """applyComplexTranspose(Group self, Vector input_real, Vector input_imag, Vector result_real, Vector result_imag) -> NOX::Abstract::Group::ReturnType"""
        return _Abstract.Group_applyComplexTranspose(self, *args)


    def applyComplexTransposeMultiVector(self, *args):
        """applyComplexTransposeMultiVector(Group self, MultiVector input_real, MultiVector input_imag, MultiVector result_real, MultiVector result_imag) -> NOX::Abstract::Group::ReturnType"""
        return _Abstract.Group_applyComplexTransposeMultiVector(self, *args)


    def applyComplexTransposeInverseMultiVector(self, *args):
        """applyComplexTransposeInverseMultiVector(Group self, ParameterList params, MultiVector input_real, MultiVector input_imag, MultiVector result_real, MultiVector result_imag) -> NOX::Abstract::Group::ReturnType"""
        return _Abstract.Group_applyComplexTransposeInverseMultiVector(self, *args)


    def copy(self, *args):
        """copy(Group self, Group source)"""
        return _Abstract.Group_copy(self, *args)


    def setParamsMulti(self, *args):
        """setParamsMulti(Group self, std::vector< int,std::allocator< int > > const & paramIDs, NOX::Abstract::MultiVector::DenseMatrix const & vals)"""
        return _Abstract.Group_setParamsMulti(self, *args)


    def notifyCompletedStep(self, *args):
        """notifyCompletedStep(Group self)"""
        return _Abstract.Group_notifyCompletedStep(self, *args)


    def computeFreeEnergy(self, *args):
        """computeFreeEnergy(Group self) -> double"""
        return _Abstract.Group_computeFreeEnergy(self, *args)

Group_swigregister = _Abstract.Group_swigregister
Group_swigregister(Group)

class TransposeSolveGroup(PyTrilinos.NOX.Abstract.Group):
    """Proxy of C++ LOCA::Abstract::TransposeSolveGroup class."""

    __swig_setmethods__ = {}
    for _s in [PyTrilinos.NOX.Abstract.Group]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TransposeSolveGroup, name, value)
    __swig_getmethods__ = {}
    for _s in [PyTrilinos.NOX.Abstract.Group]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TransposeSolveGroup, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _Abstract.delete_TransposeSolveGroup

    def applyJacobianTransposeInverse(self, *args):
        """applyJacobianTransposeInverse(TransposeSolveGroup self, ParameterList params, Vector input, Vector loca_result) -> NOX::Abstract::Group::ReturnType"""
        return _Abstract.TransposeSolveGroup_applyJacobianTransposeInverse(self, *args)


    def applyJacobianTransposeInverseMultiVector(self, *args):
        """applyJacobianTransposeInverseMultiVector(TransposeSolveGroup self, ParameterList params, MultiVector input, MultiVector loca_result) -> NOX::Abstract::Group::ReturnType"""
        return _Abstract.TransposeSolveGroup_applyJacobianTransposeInverseMultiVector(self, *args)

TransposeSolveGroup_swigregister = _Abstract.TransposeSolveGroup_swigregister
TransposeSolveGroup_swigregister(TransposeSolveGroup)

class Iterator(_object):
    """Proxy of C++ LOCA::Abstract::Iterator class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Iterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Iterator, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    LastIteration = _Abstract.Iterator_LastIteration
    Finished = _Abstract.Iterator_Finished
    Failed = _Abstract.Iterator_Failed
    NotFinished = _Abstract.Iterator_NotFinished
    Successful = _Abstract.Iterator_Successful
    Unsuccessful = _Abstract.Iterator_Unsuccessful
    Provisional = _Abstract.Iterator_Provisional
    __swig_destroy__ = _Abstract.delete_Iterator

    def resetIterator(self, *args):
        """resetIterator(Iterator self, ParameterList p) -> bool"""
        return _Abstract.Iterator_resetIterator(self, *args)


    def getIteratorStatus(self, *args):
        """getIteratorStatus(Iterator self) -> LOCA::Abstract::Iterator::IteratorStatus"""
        return _Abstract.Iterator_getIteratorStatus(self, *args)


    def getStepNumber(self, *args):
        """getStepNumber(Iterator self) -> int"""
        return _Abstract.Iterator_getStepNumber(self, *args)


    def getNumFailedSteps(self, *args):
        """getNumFailedSteps(Iterator self) -> int"""
        return _Abstract.Iterator_getNumFailedSteps(self, *args)


    def getNumTotalSteps(self, *args):
        """getNumTotalSteps(Iterator self) -> int"""
        return _Abstract.Iterator_getNumTotalSteps(self, *args)


    def run(self, *args):
        """run(Iterator self) -> LOCA::Abstract::Iterator::IteratorStatus"""
        return _Abstract.Iterator_run(self, *args)

Iterator_swigregister = _Abstract.Iterator_swigregister
Iterator_swigregister(Iterator)

class Factory(_object):
    """Proxy of C++ LOCA::Abstract::Factory class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Factory, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Factory, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _Abstract.delete_Factory

    def init(self, *args):
        """init(Factory self, Teuchos::RCP< LOCA::GlobalData > const & global_data)"""
        return _Abstract.Factory_init(self, *args)


    def createPredictorStrategy(self, *args):
        """createPredictorStrategy(Factory self, std::string const & strategyName, Teuchos::RCP< LOCA::Parameter::SublistParser > const & topParams, Teuchos::RCP< Teuchos::ParameterList > const & predictorParams, Teuchos::RCP< LOCA::MultiPredictor::AbstractStrategy > & strategy) -> bool"""
        return _Abstract.Factory_createPredictorStrategy(self, *args)


    def createContinuationStrategy(self, *args):
        """createContinuationStrategy(Factory self, std::string const & strategyName, Teuchos::RCP< LOCA::Parameter::SublistParser > const & topParams, Teuchos::RCP< Teuchos::ParameterList > const & stepperParams, Teuchos::RCP< LOCA::MultiContinuation::AbstractGroup > const & grp, Teuchos::RCP< LOCA::MultiPredictor::AbstractStrategy > const & pred, std::vector< int,std::allocator< int > > const & paramIDs, Teuchos::RCP< LOCA::MultiContinuation::AbstractStrategy > & strategy) -> bool"""
        return _Abstract.Factory_createContinuationStrategy(self, *args)


    def createBifurcationStrategy(self, *args):
        """createBifurcationStrategy(Factory self, std::string const & strategyName, Teuchos::RCP< LOCA::Parameter::SublistParser > const & topParams, Teuchos::RCP< Teuchos::ParameterList > const & bifurcationParams, Teuchos::RCP< LOCA::MultiContinuation::AbstractGroup > const & grp, Teuchos::RCP< LOCA::MultiContinuation::AbstractGroup > & strategy) -> bool"""
        return _Abstract.Factory_createBifurcationStrategy(self, *args)


    def createStepSizeStrategy(self, *args):
        """createStepSizeStrategy(Factory self, std::string const & strategyName, Teuchos::RCP< LOCA::Parameter::SublistParser > const & topParams, Teuchos::RCP< Teuchos::ParameterList > const & stepsizeParams, Teuchos::RCP< LOCA::StepSize::AbstractStrategy > & strategy) -> bool"""
        return _Abstract.Factory_createStepSizeStrategy(self, *args)


    def createBorderedSolverStrategy(self, *args):
        """createBorderedSolverStrategy(Factory self, std::string const & strategyName, Teuchos::RCP< LOCA::Parameter::SublistParser > const & topParams, Teuchos::RCP< Teuchos::ParameterList > const & solverParams, Teuchos::RCP< LOCA::BorderedSolver::AbstractStrategy > & strategy) -> bool"""
        return _Abstract.Factory_createBorderedSolverStrategy(self, *args)


    def createEigensolverStrategy(self, *args):
        """createEigensolverStrategy(Factory self, std::string const & strategyName, Teuchos::RCP< LOCA::Parameter::SublistParser > const & topParams, Teuchos::RCP< Teuchos::ParameterList > const & eigenParams, Teuchos::RCP< LOCA::Eigensolver::AbstractStrategy > & strategy) -> bool"""
        return _Abstract.Factory_createEigensolverStrategy(self, *args)


    def createEigenvalueSortStrategy(self, *args):
        """createEigenvalueSortStrategy(Factory self, std::string const & strategyName, Teuchos::RCP< LOCA::Parameter::SublistParser > const & topParams, Teuchos::RCP< Teuchos::ParameterList > const & eigenParams, Teuchos::RCP< LOCA::EigenvalueSort::AbstractStrategy > & strategy) -> bool"""
        return _Abstract.Factory_createEigenvalueSortStrategy(self, *args)


    def createSaveEigenDataStrategy(self, *args):
        """createSaveEigenDataStrategy(Factory self, std::string const & strategyName, Teuchos::RCP< LOCA::Parameter::SublistParser > const & topParams, Teuchos::RCP< Teuchos::ParameterList > const & eigenParams, Teuchos::RCP< LOCA::SaveEigenData::AbstractStrategy > & strategy) -> bool"""
        return _Abstract.Factory_createSaveEigenDataStrategy(self, *args)


    def createAnasaziOperatorStrategy(self, *args):
        """createAnasaziOperatorStrategy(Factory self, std::string const & strategyName, Teuchos::RCP< LOCA::Parameter::SublistParser > const & topParams, Teuchos::RCP< Teuchos::ParameterList > const & eigenParams, Teuchos::RCP< Teuchos::ParameterList > const & solverParams, Teuchos::RCP< NOX::Abstract::Group > const & grp, Teuchos::RCP< LOCA::AnasaziOperator::AbstractStrategy > & strategy) -> bool"""
        return _Abstract.Factory_createAnasaziOperatorStrategy(self, *args)


    def createMooreSpenceTurningPointSolverStrategy(self, *args):
        """createMooreSpenceTurningPointSolverStrategy(Factory self, std::string const & strategyName, Teuchos::RCP< LOCA::Parameter::SublistParser > const & topParams, Teuchos::RCP< Teuchos::ParameterList > const & solverParams, Teuchos::RCP< LOCA::TurningPoint::MooreSpence::SolverStrategy > & strategy) -> bool"""
        return _Abstract.Factory_createMooreSpenceTurningPointSolverStrategy(self, *args)


    def createMooreSpencePitchforkSolverStrategy(self, *args):
        """createMooreSpencePitchforkSolverStrategy(Factory self, std::string const & strategyName, Teuchos::RCP< LOCA::Parameter::SublistParser > const & topParams, Teuchos::RCP< Teuchos::ParameterList > const & solverParams, Teuchos::RCP< LOCA::Pitchfork::MooreSpence::SolverStrategy > & strategy) -> bool"""
        return _Abstract.Factory_createMooreSpencePitchforkSolverStrategy(self, *args)


    def createMooreSpenceHopfSolverStrategy(self, *args):
        """createMooreSpenceHopfSolverStrategy(Factory self, std::string const & strategyName, Teuchos::RCP< LOCA::Parameter::SublistParser > const & topParams, Teuchos::RCP< Teuchos::ParameterList > const & solverParams, Teuchos::RCP< LOCA::Hopf::MooreSpence::SolverStrategy > & strategy) -> bool"""
        return _Abstract.Factory_createMooreSpenceHopfSolverStrategy(self, *args)

Factory_swigregister = _Abstract.Factory_swigregister
Factory_swigregister(Factory)

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


