# 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 _diffusion
else:
    import _diffusion

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.property
import ooflib.SWIG.engine.symmmatrix
import ooflib.SWIG.engine.outputval
import ooflib.SWIG.engine.fieldindex
import ooflib.SWIG.engine.planarity
import ooflib.SWIG.engine.IO.propertyoutput
import ooflib.SWIG.engine.mastercoord
class IsoDiffusion(ooflib.SWIG.engine.property.Property):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, reg, name, kappa):
        _diffusion.IsoDiffusion_swiginit(self, _diffusion.new_IsoDiffusion(reg, name, kappa))
    __swig_destroy__ = _diffusion.delete_IsoDiffusion

# Register IsoDiffusion in _diffusion:
_diffusion.IsoDiffusion_swigregister(IsoDiffusion)
class AnisoDiffusion(ooflib.SWIG.engine.property.Property):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, reg, name, k):
        _diffusion.AnisoDiffusion_swiginit(self, _diffusion.new_AnisoDiffusion(reg, name, k))
    __swig_destroy__ = _diffusion.delete_AnisoDiffusion

# Register AnisoDiffusion in _diffusion:
_diffusion.AnisoDiffusion_swigregister(AnisoDiffusion)
class Mobility(ooflib.SWIG.engine.property.Property):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, reg, name):
        _diffusion.Mobility_swiginit(self, _diffusion.new_Mobility(reg, name))
    __swig_destroy__ = _diffusion.delete_Mobility

# Register Mobility in _diffusion:
_diffusion.Mobility_swigregister(Mobility)
class AtomFluxJumpTest(ooflib.SWIG.engine.property.Property):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, _self, arg3, arg4):
        _diffusion.AtomFluxJumpTest_swiginit(self, _diffusion.new_AtomFluxJumpTest(_self, arg3, arg4))
    __swig_destroy__ = _diffusion.delete_AtomFluxJumpTest

# Register AtomFluxJumpTest in _diffusion:
_diffusion.AtomFluxJumpTest_swigregister(AtomFluxJumpTest)
# -*- 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 runtimeflags

from ooflib.common import utils
from ooflib.common.IO import parameter
from ooflib.engine import problem
from ooflib.engine import propertyregistration
from ooflib.SWIG.engine import symmmatrix

from ooflib.engine.IO import interfaceparameters

from ooflib.EXTENSIONS.diffusion import diff_problem


PropertyRegistration = propertyregistration.PropertyRegistration

## ISOTROPIC

reg = PropertyRegistration(
    'Migration:Diffusivity:Isotropic',
    IsoDiffusion,
    97,
    params=[parameter.FloatParameter('D',
                                     1.0, tip=parameter.emptyTipString)],
    propertyType="Diffusivity",
    tip="Isotropic diffusivity."
    )

reg.fluxInfo(fluxes=[diff_problem.Atom_Flux],
             fields=[diff_problem.Concentration],
             time_derivs=[0])


## TRICLINIC

reg = PropertyRegistration(
    'Migration:Diffusivity:Anisotropic:Triclinic',
    AnisoDiffusion,
    105,
    [symmmatrix.TriclinicRank2TensorParameter(
    'D',
    symmmatrix.TriclinicRank2Tensor(xx=1.0, yy=1.0, zz=1.0),
    tip=parameter.emptyTipString)],
    propertyType="Diffusivity",
    tip="Triclinic diffusivity"
    )

reg.fluxInfo(fluxes=[diff_problem.Atom_Flux],
             fields=[diff_problem.Concentration],
             time_derivs=[0])


## MONOCLINIC

reg = PropertyRegistration(
    'Migration:Diffusivity:Anisotropic:Monoclinic',
    AnisoDiffusion,
    104,
    [symmmatrix.MonoclinicRank2TensorParameter(
    'D',
    symmmatrix.MonoclinicRank2Tensor(xx=1.0, yy=1.0, zz=1.0),
    tip=parameter.emptyTipString)],
    propertyType="Diffusivity",
    tip="Monoclinic diffusivity."
    )

reg.fluxInfo(fluxes=[diff_problem.Atom_Flux],
             fields=[diff_problem.Concentration],
             time_derivs=[0])


## ORTHORHOMBIC

reg = PropertyRegistration(
    'Migration:Diffusivity:Anisotropic:Orthorhombic',
    AnisoDiffusion,
    103,
    [symmmatrix.OrthorhombicRank2TensorParameter(
    'D',
    symmmatrix.OrthorhombicRank2Tensor(xx=1.0, yy=1.0, zz=1.0),
    tip=parameter.emptyTipString)],
    propertyType="Diffusivity",
    tip="Orthorhombic diffusivity."
    )

reg.fluxInfo(fluxes=[diff_problem.Atom_Flux],
             fields=[diff_problem.Concentration],
             time_derivs=[0])


## TETRAGONAL

reg = PropertyRegistration(
    'Migration:Diffusivity:Anisotropic:Tetragonal',
    AnisoDiffusion,
    101,
    [symmmatrix.TetragonalRank2TensorParameter(
    'D',
    symmmatrix.TetragonalRank2Tensor(xx=1.0, zz=0.5),
    tip=parameter.emptyTipString)],
    propertyType="Diffusivity",
    tip="Tetragonal diffusivity."
    )

reg.fluxInfo(fluxes=[diff_problem.Atom_Flux],
             fields=[diff_problem.Concentration],
             time_derivs=[0])


## TRIGONAL

reg = PropertyRegistration(
    'Migration:Diffusivity:Anisotropic:Trigonal',
    AnisoDiffusion,
    102,
    [symmmatrix.TrigonalRank2TensorParameter(
    'D',
    symmmatrix.TrigonalRank2Tensor(xx=1.0, zz=0.5),
    tip=parameter.emptyTipString)],
    propertyType="Diffusivity",
    tip="Trigonal diffusivity."
    )

reg.fluxInfo(fluxes=[diff_problem.Atom_Flux],
             fields=[diff_problem.Concentration],
             time_derivs=[0])


## HEXAGONAL

reg = PropertyRegistration(
    'Migration:Diffusivity:Anisotropic:Hexagonal',
    AnisoDiffusion,
    100,
    [symmmatrix.HexagonalRank2TensorParameter(
    'D',
    symmmatrix.HexagonalRank2Tensor(xx=1.0, zz=0.5),
    tip=parameter.emptyTipString)],
    propertyType="Diffusivity",
    tip="Hexagonal diffusivity."
    )

reg.fluxInfo(fluxes=[diff_problem.Atom_Flux],
             fields=[diff_problem.Concentration],
             time_derivs=[0])


## CUBIC

reg = PropertyRegistration(
    'Migration:Diffusivity:Anisotropic:Cubic',
    AnisoDiffusion,
    99,
    [symmmatrix.CubicRank2TensorParameter(
            'D',
            symmmatrix.CubicRank2Tensor(xx=1.0),
            tip=parameter.emptyTipString)],
    propertyType="Diffusivity",
    tip="Cubic diffusivity."
)

reg.fluxInfo(fluxes=[diff_problem.Atom_Flux],
             fields=[diff_problem.Concentration],
             time_derivs=[0])



reg = PropertyRegistration(
    'Migration:Mobility:Mobility',
    Mobility,
    101,
    propertyType="Mobility",
    tip="Mobility."
    )


reg.eqnInfo(equations=[diff_problem.AtomBalanceEquation],
            fields=[diff_problem.Concentration],
            time_derivs=[1])


# Diffusion surface property.
if runtimeflags.surface_mode:

    reg = propertyregistration.PropertyRegistration(
        'Migration:Interface:FluxJump', AtomFluxJumpTest,
        315,
        [
        parameter.FloatParameter('coef', 0.01, tip="value of the coefficient"),
        ],
        propertyType="_interfaces_flux_surfacetest",
        interfaceCompatibility=interfaceparameters.COMPATIBILITY_INTERFACE_ONLY,
        interfaceDiscontinuousFields=[diff_problem.Concentration],
        tip="Testing, testing.")


#     reg.fluxInfo(fluxes=[diff_problem.Atom_Flux],
#                  fields=[diff_problem.Concentration],
#                  time_derivs=[0])

    reg.eqnInfo(equations=[diff_problem.AtomBalanceEquation],
                fields=[diff_problem.Concentration],
                time_derivs=[0])



