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

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _equation
else:
    import _equation

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


import ooflib.SWIG.engine.csubproblem
import ooflib.SWIG.common.coord
import ooflib.SWIG.common.doublevec
import ooflib.SWIG.common.lock
import ooflib.SWIG.engine.element
import ooflib.SWIG.engine.edge
import ooflib.SWIG.engine.field
import ooflib.SWIG.engine.femesh
import ooflib.SWIG.common.cmicrostructure
import ooflib.SWIG.common.pixelgroup
import ooflib.SWIG.common.pixelattribute
import ooflib.SWIG.common.timestamp
import ooflib.SWIG.engine.node
import ooflib.SWIG.engine.pointdata
import ooflib.SWIG.engine.material
import ooflib.SWIG.common.abstractimage
import ooflib.SWIG.common.ccolor
import ooflib.SWIG.engine.property
import ooflib.SWIG.engine.meshiterator
import ooflib.SWIG.engine.fieldindex
import ooflib.SWIG.engine.planarity
import ooflib.SWIG.engine.freedom
import ooflib.SWIG.engine.outputval
import ooflib.SWIG.engine.mastercoord
import ooflib.SWIG.engine.elementnodeiterator
import ooflib.SWIG.engine.gausspoint
import ooflib.SWIG.engine.flux
import ooflib.SWIG.engine.linearizedsystem
import ooflib.SWIG.engine.sparsemat
import ooflib.SWIG.engine.nodalequation
class Equation(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def name(self):
        return _equation.Equation_name(self)

    def objectid(self):
        return _equation.Equation_objectid(self)

    def dim(self):
        return _equation.Equation_dim(self)

    def ndof(self):
        return _equation.Equation_ndof(self)

    def nodaleqn(self, arg2, arg3):
        return _equation.Equation_nodaleqn(self, arg2, arg3)

    def is_active(self, arg2):
        return _equation.Equation_is_active(self, arg2)

    def allow_boundary_conditions(self):
        return _equation.Equation_allow_boundary_conditions(self)

    @staticmethod
    def getEquation(arg1):
        return _equation.Equation_getEquation(arg1)

    def c_components(self):
        return _equation.Equation_c_components(self)

    def getIndex(self, arg2):
        return _equation.Equation_getIndex(self, arg2)

    def __eq__(self, other):
        return _equation.Equation___eq__(self, other)
    __swig_destroy__ = _equation.delete_Equation

# Register Equation in _equation:
_equation.Equation_swigregister(Equation)
class FluxEquation(Equation):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def fluxname(self):
        return _equation.FluxEquation_fluxname(self)

    def flux(self):
        return _equation.FluxEquation_flux(self)
    __swig_destroy__ = _equation.delete_FluxEquation

# Register FluxEquation in _equation:
_equation.FluxEquation_swigregister(FluxEquation)
class NaturalEquation(Equation):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, name, dim):
        _equation.NaturalEquation_swiginit(self, _equation.new_NaturalEquation(name, dim))

        finishConstruction(self)



    __swig_destroy__ = _equation.delete_NaturalEquation

# Register NaturalEquation in _equation:
_equation.NaturalEquation_swigregister(NaturalEquation)
class DivergenceEquation(FluxEquation):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, name, flux, dim):
        _equation.DivergenceEquation_swiginit(self, _equation.new_DivergenceEquation(name, flux, dim))

        finishConstruction(self)



    __swig_destroy__ = _equation.delete_DivergenceEquation

# Register DivergenceEquation in _equation:
_equation.DivergenceEquation_swigregister(DivergenceEquation)
class PlaneFluxEquation(FluxEquation):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, name, flux, dim):
        _equation.PlaneFluxEquation_swiginit(self, _equation.new_PlaneFluxEquation(name, flux, dim))

        finishConstruction(self)



    __swig_destroy__ = _equation.delete_PlaneFluxEquation

# Register PlaneFluxEquation in _equation:
_equation.PlaneFluxEquation_swigregister(PlaneFluxEquation)

def countEquations():
    return _equation.countEquations()

def getEquationByIndex(arg1):
    return _equation.getEquationByIndex(arg1)
# -*- python -*-

# This software was produced by NIST, an agency of the U.S. government,
# and by statute is not subject to copyright in the United States.
# Recipients of this software assume all responsibilities associated
# with its operation, modification and maintenance. However, to
# facilitate maintenance we ask that before distributing modified
# versions of this software, you first contact the authors at
# oof_manager@nist.gov.

from ooflib.common import debug
from ooflib.common import utils
from ooflib.SWIG.common import switchboard

def _Equation___hash_(self):
    return self.objectid()

Equation.__hash__ = _Equation___hash_

# Equations are sometimes stored in an OrderedSet and need to have
# __lt__ defined.

def _Equation___lt__(self, other):
    try:
        return self.objectid() < other.objectid()
    except:
        return NotImplemented

Equation.__lt__ = _Equation___lt__

def _Equation___hash__(self):
    return self.objectid()

Equation.__hash__ = _Equation___hash__

Equation.__repr__ = Equation.name


DivergenceEquation.__repr__ = DivergenceEquation.name

PlaneFluxEquation.__repr__ = PlaneFluxEquation.name

def allEquations():
    for indx in range(countEquations()):
        yield getEquationByIndex(indx)

# getEquation(name) returns the equation with the given name.
# Equation.getEquation is a static C++ method.
getEquation = Equation.getEquation
utils.OOFdefine('getEquation', Equation.getEquation)

# finishConstruction is called after the swigged constructors for all
# of the Equation subclasses.  It's installed by %pythonappend lines in
# equation.swg.
def finishConstruction(eqn):
    utils.OOFdefine(eqn.name(), eqn)
    switchboard.notify("new equation")

#=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=#

def _Equation_components(self):
    comps = self.c_components() # a swigged generic ComponentsP object
    beginp = comps.begin()      # generic ComponentIteratorP object
    endp = comps.end()
    while beginp != endp:
        yield beginp.current()  # derived FieldIndex class object
        beginp.increment()

Equation.components = _Equation_components


