iron.py

Go to the documentation of this file.

"""OpenCMISS-Iron

OpenCMISS (Open Continuum Mechanics, Imaging, Signal processing and System
identification) is a mathematical modelling environment that enables the
application of finite element analysis techniques to a variety of complex
bioengineering problems.

OpenCMISS-Iron is the computational backend component of OpenCMISS.
This Python module wraps the underlying OpenCMISS-Iron Fortran library.

http://www.opencmiss.org
"""

from . import _iron_python
import signal
from ._utils import (CMFEError, CMFEType, Enum,
    wrap_cmiss_routine as _wrap_routine)


class Basis(CMFEType):
    """Contains information about a basis function.
    """

    def __init__(self):
        """Initialise a null cmfe_BasisType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_Basis_Initialise, None)

    def CollapsedXiGet(self, collapsedXiSize):
        """Returns the collapsed Xi flags of a basis identified by an object.

        :param collapsedXiSize: Size of collapsedXi to allocate.
        :returns: collapsedXi. collapsedXi(ni). On return, the collapsed Xi parameter for the ni'th Xi direction. Will be a value from the BasisXiCollapse enum.
        :rtype: Array of ints
        """

        basis = self
        return _wrap_routine(_iron_python.cmfe_Basis_CollapsedXiGet, [basis, collapsedXiSize])

    def CollapsedXiSet(self, collapsedXi):
        """Sets/changes the collapsed Xi flags of a basis identified by an object.

        :param collapsedXi: collapsedXi(ni). The collapsed Xi parameter for the ni'th Xi direction to set. Must be a value from the BasisXiCollapse enum.
        :type collapsedXi: Array of ints
        :rtype: None
        """

        basis = self
        return _wrap_routine(_iron_python.cmfe_Basis_CollapsedXiSet, [basis, collapsedXi])

    def CreateFinish(self):
        """Finishes the creation of a new basis identified by an object.

        :rtype: None
        """

        basis = self
        return _wrap_routine(_iron_python.cmfe_Basis_CreateFinish, [basis])

    def CreateStart(self, userNumber):
        """Starts the creation of a new basis for a basis identified by an object.

        :param userNumber: The user number of the basis to start the creation of.
        :type userNumber: int
        :rtype: None
        """

        basis = self
        return _wrap_routine(_iron_python.cmfe_Basis_CreateStart, [userNumber, basis])

    def Destroy(self):
        """Destroys a basis identified by an object.

        :rtype: None
        """

        basis = self
        return _wrap_routine(_iron_python.cmfe_Basis_Destroy, [basis])

    def Finalise(self):
        """Finalises a cmfe_BasisType object.

        :rtype: None
        """

        cmfe_Basis = self
        return _wrap_routine(_iron_python.cmfe_Basis_Finalise, [cmfe_Basis])

    def InterpolationXiGet(self, interpolationXiSize):
        """Get the interpolation type in each xi directions for a basis indentified by an object.

        :param interpolationXiSize: Size of interpolationXi to allocate.
        :returns: interpolationXi. The interpolation xi parameters for each Xi direction. Will be a value from the BasisInterpolationSpecifications enum.
        :rtype: Array of ints
        """

        basis = self
        return _wrap_routine(_iron_python.cmfe_Basis_InterpolationXiGet, [basis, interpolationXiSize])

    def InterpolationXiSet(self, interpolationXi):
        """Sets/changes the interpolation type in each xi directions for a basis indentified by an object.

        :param interpolationXi: The interpolation xi parameters for each Xi direction. Must be a value from the BasisInterpolationSpecifications enum.
        :type interpolationXi: Array of ints
        :rtype: None
        """

        basis = self
        return _wrap_routine(_iron_python.cmfe_Basis_InterpolationXiSet, [basis, interpolationXi])

    def NumberOfLocalNodesGet(self):
        """Returns the number of local nodes in a basis identified by an object.

        :returns: numberOfLocalNodes. The number of local nodes in the specified basis.
        :rtype: int
        """

        basis = self
        return _wrap_routine(_iron_python.cmfe_Basis_NumberOfLocalNodesGet, [basis])

    def NumberOfXiGet(self):
        """Returns the number of Xi directions in a basis identified by an object.

        :returns: numberOfXi. The number of xi directions in the specified basis.
        :rtype: int
        """

        basis = self
        return _wrap_routine(_iron_python.cmfe_Basis_NumberOfXiGet, [basis])

    def NumberOfXiSet(self, numberOfXi):
        """Sets/changes the number of Xi directions in a basis identified by an object.

        :param numberOfXi: The number of xi directions in the specified basis to set.
        :type numberOfXi: int
        :rtype: None
        """

        basis = self
        return _wrap_routine(_iron_python.cmfe_Basis_NumberOfXiSet, [basis, numberOfXi])

    def QuadratureLocalFaceGaussEvaluateSet(self, faceGaussEvaluate):
        """Sets/changes the local face Gauss scheme calculation, on a basis identified by an object.

        :param faceGaussEvaluate: The type of quadrature in the specified basis to set.
        :type faceGaussEvaluate: bool
        :rtype: None
        """

        basis = self
        return _wrap_routine(_iron_python.cmfe_Basis_QuadratureLocalFaceGaussEvaluateSet, [basis, faceGaussEvaluate])

    def QuadratureMultipleGaussXiGet(self, quadratureScheme, GaussPoints, GaussXiSizes):
        """Returns the xi positions of Gauss points on a basis quadrature identified by an object.

        :param quadratureScheme: The quadrature scheme to return the Gauss xi positions for.
        :type quadratureScheme: int
        :param GaussPoints: The Gauss points to return the element xi positions for.
        :type GaussPoints: Array of ints
        :param GaussXiSizes: Tuple of dimensions of GaussXi to allocate, with length 2.
        :returns: GaussXi. GaussXi(Gauss_point,xi_direction) the Gauss xi positions for the specified quadrature scheme.
        :rtype: 2d array of floats
        """

        basis = self
        return _wrap_routine(_iron_python.cmfe_Basis_QuadratureMultipleGaussXiGet, [basis, quadratureScheme, GaussPoints, GaussXiSizes])

    def QuadratureNumberOfGaussXiGet(self, numberOfGaussXiSize):
        """Returns the number Gauss points in each Xi directions for a basis quadrature identified by an object.

        :param numberOfGaussXiSize: Size of numberOfGaussXi to allocate.
        :returns: numberOfGaussXi. The number of Gauss points in each Xi directions in the specified basis.
        :rtype: Array of ints
        """

        basis = self
        return _wrap_routine(_iron_python.cmfe_Basis_QuadratureNumberOfGaussXiGet, [basis, numberOfGaussXiSize])

    def QuadratureNumberOfGaussXiSet(self, numberOfGaussXi):
        """Sets the number Gauss points in each Xi directions for a basis quadrature identified by an object.

        :param numberOfGaussXi: The number of Gauss points in each Xi directions in the specified basis to set.
        :type numberOfGaussXi: Array of ints
        :rtype: None
        """

        basis = self
        return _wrap_routine(_iron_python.cmfe_Basis_QuadratureNumberOfGaussXiSet, [basis, numberOfGaussXi])

    def QuadratureOrderGet(self):
        """Returns the the order of quadrature for a basis quadrature identified by an object.

        :returns: quadratureOrder. The order of quadrature in the specified basis.
        :rtype: int
        """

        basis = self
        return _wrap_routine(_iron_python.cmfe_Basis_QuadratureOrderGet, [basis])

    def QuadratureOrderSet(self, quadratureOrder):
        """Sets/changes the the order of quadrature for a basis quadrature identified by an object.

        :param quadratureOrder: The order of quadrature in the specified basis to set.
        :type quadratureOrder: int
        :rtype: None
        """

        basis = self
        return _wrap_routine(_iron_python.cmfe_Basis_QuadratureOrderSet, [basis, quadratureOrder])

    def QuadratureSingleGaussXiGet(self, quadratureScheme, GaussPoint, GaussXiSize):
        """Returns the xi position of a Gauss point on a basis quadrature identified by an object.

        :param quadratureScheme: The quadrature scheme to return the Gauss xi positions for.
        :type quadratureScheme: int
        :param GaussPoint: The Gauss point to return the element xi positions for.
        :type GaussPoint: int
        :param GaussXiSize: Size of GaussXi to allocate.
        :returns: GaussXi. GaussXi(xi_direction) the xi position of the specified Gauss point for the specified quadrature scheme.
        :rtype: Array of floats
        """

        basis = self
        return _wrap_routine(_iron_python.cmfe_Basis_QuadratureSingleGaussXiGet, [basis, quadratureScheme, GaussPoint, GaussXiSize])

    def QuadratureTypeGet(self):
        """Returns the the type of quadrature for a basis quadrature identified by an object.

        :returns: quadratureType. The type of quadrature in the specified basis. Will be a value from the QuadratureTypes enum.
        :rtype: int
        """

        basis = self
        return _wrap_routine(_iron_python.cmfe_Basis_QuadratureTypeGet, [basis])

    def QuadratureTypeSet(self, quadratureType):
        """Sets/changes the the type of quadrature for a basis quadrature identified by an object.

        :param quadratureType: The type of quadrature in the specified basis to set. Must be a value from the QuadratureTypes enum.
        :type quadratureType: int
        :rtype: None
        """

        basis = self
        return _wrap_routine(_iron_python.cmfe_Basis_QuadratureTypeSet, [basis, quadratureType])

    def TypeGet(self):
        """Returns the type of a basis identified by an object.

        :returns: basisType. The type of the specified basis. Will be a value from the BasisTypes enum.
        :rtype: int
        """

        basis = self
        return _wrap_routine(_iron_python.cmfe_Basis_TypeGet, [basis])

    def TypeSet(self, basisType):
        """Sets/changes the type of a basis identified by an object.

        :param basisType: The type of the specified basis to set. Must be a value from the BasisTypes enum.
        :type basisType: int
        :rtype: None
        """

        basis = self
        return _wrap_routine(_iron_python.cmfe_Basis_TypeSet, [basis, basisType])

    interpolationXi = property(InterpolationXiGet, InterpolationXiSet, None, """The interpolation type in each xi directions for a basis indentified by an object.""")

    quadratureNumberOfGaussXi = property(QuadratureNumberOfGaussXiGet, QuadratureNumberOfGaussXiSet, None, """The number Gauss points in each Xi directions for a basis quadrature identified by an object.""")

    quadratureLocalFaceGaussEvaluate = property(None, QuadratureLocalFaceGaussEvaluateSet, None, """The local face Gauss scheme calculation, on a basis identified by an object.""")

    quadratureType = property(QuadratureTypeGet, QuadratureTypeSet, None, """The the type of quadrature for a basis quadrature identified by an object.""")

    collapsedXi = property(CollapsedXiGet, CollapsedXiSet, None, """The collapsed Xi flags of a basis identified by an object.""")

    numberOfXi = property(NumberOfXiGet, NumberOfXiSet, None, """The number of Xi directions in a basis identified by an object.""")

    type = property(TypeGet, TypeSet, None, """The type of a basis identified by an object.""")

    numberOfLocalNodes = property(NumberOfLocalNodesGet, None, None, """The number of local nodes in a basis identified by an object.""")

    quadratureOrder = property(QuadratureOrderGet, QuadratureOrderSet, None, """The the order of quadrature for a basis quadrature identified by an object.""")


class BoundaryConditions(CMFEType):
    """Contains information on the boundary conditions for the equations set.
    """

    def __init__(self):
        """Initialise a null cmfe_BoundaryConditionsType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_BoundaryConditions_Initialise, None)

    def AddConstant(self, field, variableType, componentNumber, condition, value):
        """Adds to the value of the specified constant and sets this as a boundary condition on the specified constant for boundary conditions identified by an object.

        :param field: The dependent field to set the boundary condition on.
        :type field: Field
        :param variableType: The variable type of the dependent field to set the boundary condition at. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param componentNumber: The component number of the dependent field to set the boundary condition at.
        :type componentNumber: int
        :param condition: The boundary condition type to set. Must be a value from the BoundaryConditionsTypes enum.
        :type condition: int
        :param value: The value of the boundary condition to add.
        :type value: float
        :rtype: None
        """

        boundaryConditions = self
        return _wrap_routine(_iron_python.cmfe_BoundaryConditions_AddConstant, [boundaryConditions, field, variableType, componentNumber, condition, value])

    def AddElement(self, field, variableType, elementUserNumber, componentNumber, condition, value):
        """Adds to the value of the specified element and sets this as a boundary condition on the specified element for boundary conditions identified by an object.

        :param field: The dependent field to set the boundary condition on.
        :type field: Field
        :param variableType: The variable type of the dependent field to add the boundary condition at. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param elementUserNumber: The user number of the element to add the boundary conditions for.
        :type elementUserNumber: int
        :param componentNumber: The component number of the dependent field to set the boundary condition at.
        :type componentNumber: int
        :param condition: The boundary condition type to set. Must be a value from the BoundaryConditionsTypes enum.
        :type condition: int
        :param value: The value of the boundary condition to add.
        :type value: float
        :rtype: None
        """

        boundaryConditions = self
        return _wrap_routine(_iron_python.cmfe_BoundaryConditions_AddElement, [boundaryConditions, field, variableType, elementUserNumber, componentNumber, condition, value])

    def AddNode(self, field, variableType, versionNumber, derivativeNumber, nodeUserNumber, componentNumber, condition, value):
        """Adds to the value of the specified node and sets this as a boundary condition on the specified node for boundary conditions identified by an object.

        :param field: The dependent field to set the boundary condition on.
        :type field: Field
        :param variableType: The variable type of the dependent field to add the boundary condition at. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param versionNumber: The user number of the node derivative version to add the boundary conditions for.
        :type versionNumber: int
        :param derivativeNumber: The user number of the node derivative to add the boundary conditions for.
        :type derivativeNumber: int
        :param nodeUserNumber: The user number of the node to add the boundary conditions for.
        :type nodeUserNumber: int
        :param componentNumber: The component number of the dependent field to set the boundary condition at.
        :type componentNumber: int
        :param condition: The boundary condition type to set. Must be a value from the BoundaryConditionsTypes enum.
        :type condition: int
        :param value: The value of the boundary condition to add.
        :type value: float
        :rtype: None
        """

        boundaryConditions = self
        return _wrap_routine(_iron_python.cmfe_BoundaryConditions_AddNode, [boundaryConditions, field, variableType, versionNumber, derivativeNumber, nodeUserNumber, componentNumber, condition, value])

    def ConstrainNodeDofsEqual(self, field, fieldVariableType, versionNumber, derivativeNumber, component, nodes, coefficient):
        """Constrain multiple nodal equations dependent field DOFs to be a single solver DOF in the solver equations

        :param field: The equations dependent field containing the field DOFs to be constrained.
        :type field: Field
        :param fieldVariableType: The field variable type of the DOFs to be constrained. Must be a value from the FieldVariableTypes enum.
        :type fieldVariableType: int
        :param versionNumber: The derivative version number.
        :type versionNumber: int
        :param derivativeNumber: The derivative number.
        :type derivativeNumber: int
        :param component: The field component number of the DOFs to be constrained.
        :type component: int
        :param nodes: The user numbers of the nodes to be constrained to be equal.
        :type nodes: Array of ints
        :param coefficient: The coefficient of constraint, applied to all but the first node.
        :type coefficient: float
        :rtype: None
        """

        boundaryConditions = self
        return _wrap_routine(_iron_python.cmfe_BoundaryConditions_ConstrainNodeDofsEqual, [boundaryConditions, field, fieldVariableType, versionNumber, derivativeNumber, component, nodes, coefficient])

    def Destroy(self):
        """Destroys boundary conditions identified by an object.

        :rtype: None
        """

        boundaryConditions = self
        return _wrap_routine(_iron_python.cmfe_BoundaryConditions_Destroy, [boundaryConditions])

    def Finalise(self):
        """Finalises a cmfe_BoundaryConditionsType object.

        :rtype: None
        """

        cmfe_BoundaryConditions = self
        return _wrap_routine(_iron_python.cmfe_BoundaryConditions_Finalise, [cmfe_BoundaryConditions])

    def NeumannSparsityTypeSet(self, sparsityType):
        """Sets the Neumann integration matrix sparsity type for the boundary conditions

        :param sparsityType: The sparsity type for the Neumann integration matrices. Must be a value from the BoundaryConditionSparsityTypes enum.
        :type sparsityType: int
        :rtype: None
        """

        boundaryConditions = self
        return _wrap_routine(_iron_python.cmfe_BoundaryConditions_NeumannSparsityTypeSet, [boundaryConditions, sparsityType])

    def SetConstant(self, field, variableType, componentNumber, condition, value):
        """Sets the value of the specified constant and sets this as a boundary condition on the specified constant for boundary conditions identified by an object.

        :param field: The dependent field to set the boundary condition on.
        :type field: Field
        :param variableType: The variable type of the dependent field to set the boundary condition at. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param componentNumber: The component number of the dependent field to set the boundary condition at.
        :type componentNumber: int
        :param condition: The boundary condition type to set. Must be a value from the BoundaryConditionsTypes enum.
        :type condition: int
        :param value: The value of the boundary condition to set.
        :type value: float
        :rtype: None
        """

        boundaryConditions = self
        return _wrap_routine(_iron_python.cmfe_BoundaryConditions_SetConstant, [boundaryConditions, field, variableType, componentNumber, condition, value])

    def SetElement(self, field, variableType, elementUserNumber, componentNumber, condition, value):
        """Sets the value of the specified element and sets this as a boundary condition on the specified elements for boundary conditions identified by an object.

        :param field: The dependent field to set the boundary condition on.
        :type field: Field
        :param variableType: The variable type of the dependent field to set the boundary condition at. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param elementUserNumber: The user number of the element to set the boundary conditions for.
        :type elementUserNumber: int
        :param componentNumber: The component number of the dependent field to set the boundary condition at.
        :type componentNumber: int
        :param condition: The boundary condition type to set. Must be a value from the BoundaryConditionsTypes enum.
        :type condition: int
        :param value: The value of the boundary condition to set.
        :type value: float
        :rtype: None
        """

        boundaryConditions = self
        return _wrap_routine(_iron_python.cmfe_BoundaryConditions_SetElement, [boundaryConditions, field, variableType, elementUserNumber, componentNumber, condition, value])

    def SetNode(self, field, variableType, versionNumber, derivativeNumber, nodeUserNumber, componentNumber, condition, value):
        """Sets the value of the specified node and sets this as a boundary condition on the specified node for boundary conditions identified by an object.

        :param field: The dependent field to set the boundary condition on.
        :type field: Field
        :param variableType: The variable type of the dependent field to set the boundary condition at. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param versionNumber: The user number of the node derivative version to set the boundary conditions for.
        :type versionNumber: int
        :param derivativeNumber: The user number of the node derivative to set the boundary conditions for.
        :type derivativeNumber: int
        :param nodeUserNumber: The user number of the node to set the boundary conditions for.
        :type nodeUserNumber: int
        :param componentNumber: The component number of the dependent field to set the boundary condition at.
        :type componentNumber: int
        :param condition: The boundary condition type to set. Must be a value from the BoundaryConditionsTypes enum.
        :type condition: int
        :param value: The value of the boundary condition to set.
        :type value: float
        :rtype: None
        """

        boundaryConditions = self
        return _wrap_routine(_iron_python.cmfe_BoundaryConditions_SetNode, [boundaryConditions, field, variableType, versionNumber, derivativeNumber, nodeUserNumber, componentNumber, condition, value])

    neumannSparsityType = property(None, NeumannSparsityTypeSet, None, """The Neumann integration matrix sparsity type for the boundary conditions""")


class CellMLEquations(CMFEType):
    """Contains information about the CellML equations for a solver.
    """

    def __init__(self):
        """Initialise a null cmfe_CellMLEquationsType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_CellMLEquations_Initialise, None)

    def CellMLAdd(self, CellML):
        """Adds a CellML environment to CellML equations identified by an object.

        :param CellML: The CellML environment to add.
        :type CellML: CellML
        :returns: CellMLIndex. The index of the added CellML environment.
        :rtype: int
        """

        CellMLEquations = self
        return _wrap_routine(_iron_python.cmfe_CellMLEquations_CellMLAdd, [CellMLEquations, CellML])

    def Finalise(self):
        """Finalises a cmfe_CellMLEquationsType object.

        :rtype: None
        """

        cmfe_CellMLEquations = self
        return _wrap_routine(_iron_python.cmfe_CellMLEquations_Finalise, [cmfe_CellMLEquations])


class CellML(CMFEType):
    """Contains information on a CellML environment.
    """

    def __init__(self):
        """Initialise a null cmfe_CellMLType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_CellML_Initialise, None)

    def CreateCellMLToFieldMap(self, CellMLModelUserNumber, variableID, CellMLParameterSet, field, variableType, componentNumber, fieldParameterSet):
        """Defines a CellML model variable to field variable component map by object.

        :param CellMLModelUserNumber: The user number of the CellML model to map from.
        :type CellMLModelUserNumber: int
        :param variableID: The of the CellML variable in the given model to map from.
        :type variableID: string
        :param CellMLParameterSet: The CellML variable parameter set to map from.
        :type CellMLParameterSet: int
        :param field: The field to map to.
        :type field: Field
        :param variableType: The field variable type to map to.
        :type variableType: int
        :param componentNumber: The field variable component number to.
        :type componentNumber: int
        :param fieldParameterSet: The field variable parameter set to map to.
        :type fieldParameterSet: int
        :rtype: None
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_CreateCellMLToFieldMap, [CellML, CellMLModelUserNumber, variableID, CellMLParameterSet, field, variableType, componentNumber, fieldParameterSet])

    def CreateFieldToCellMLMap(self, field, variableType, componentNumber, fieldParameterSet, CellMLModelUserNumber, variableID, CellMLParameterSet):
        """Defines a field variable component to CellML model variable map by object.

        :param field: The field to map from.
        :type field: Field
        :param variableType: The field variable to map from.
        :type variableType: int
        :param componentNumber: The component number to map from the given field variable.
        :type componentNumber: int
        :param fieldParameterSet: The field variable parameter set to map from.
        :type fieldParameterSet: int
        :param CellMLModelUserNumber: The user number of the CellML model to map to.
        :type CellMLModelUserNumber: int
        :param variableID: The of the CellML variable in the given model to map to.
        :type variableID: string
        :param CellMLParameterSet: The CellML variable parameter set to map to.
        :type CellMLParameterSet: int
        :rtype: None
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_CreateFieldToCellMLMap, [CellML, field, variableType, componentNumber, fieldParameterSet, CellMLModelUserNumber, variableID, CellMLParameterSet])

    def CreateFinish(self):
        """Finish the creation of a CellML environment identified by an object.

        :rtype: None
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_CreateFinish, [CellML])

    def CreateStart(self, CellMLUserNumber, region):
        """Start the creation of a CellML environment identified by an object.

        :param CellMLUserNumber: The user number of the CellML enviroment to start creating.
        :type CellMLUserNumber: int
        :param region: The region containing the field to start the CellML enviroment creation on.
        :type region: Region
        :rtype: None
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_CreateStart, [CellMLUserNumber, region, CellML])

    def Destroy(self):
        """Destroy a CellML environment identified by an object.

        :rtype: None
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_Destroy, [CellML])

    def FieldComponentGet(self, CellMLModelUserNumber, CellMLFieldType, variableID):
        """Returns the field component number that corresponds to a character string variable ID for a CellML environment identified by an object.

        :param CellMLModelUserNumber: The user number of the CellML model to map from.
        :type CellMLModelUserNumber: int
        :param CellMLFieldType: The type of CellML field to get the component for. Must be a value from the CellMLFieldTypes enum.
        :type CellMLFieldType: int
        :param variableID: The ID to get the corresponding field component for.
        :type variableID: string
        :returns: fieldComponent. The field component corresponding to the ID.
        :rtype: int
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_FieldComponentGet, [CellML, CellMLModelUserNumber, CellMLFieldType, variableID])

    def FieldMapsCreateFinish(self):
        """Finish the creation of field maps for a CellML environment identified by an object.

        :rtype: None
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_FieldMapsCreateFinish, [CellML])

    def FieldMapsCreateStart(self):
        """Start the creation of field maps for a CellML environment identified by an object.

        :rtype: None
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_FieldMapsCreateStart, [CellML])

    def Finalise(self):
        """Finalises a cmfe_CellMLType object.

        :rtype: None
        """

        cmfe_CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_Finalise, [cmfe_CellML])

    def Generate(self):
        """Validiate and instantiate a CellML environment identified by an object.

        :rtype: None
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_Generate, [CellML])

    def IntermediateFieldCreateFinish(self):
        """Finish the creation of CellML intermediate field for a CellML environment identified by an object.

        :rtype: None
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_IntermediateFieldCreateFinish, [CellML])

    def IntermediateFieldCreateStart(self, CellMLIntermediateFieldUserNumber, field):
        """Start the creation of CellML intermediate field for a CellML environment identified by an object.

        :param CellMLIntermediateFieldUserNumber: The user number of the CellML intermediate field to start creating.
        :type CellMLIntermediateFieldUserNumber: int
        :param field: On return, the created CellML intermediate field.
        :type field: Field
        :rtype: None
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_IntermediateFieldCreateStart, [CellML, CellMLIntermediateFieldUserNumber, field])

    def IntermediateFieldGet(self, field):
        """Returns the CellML intermediate field for a CellML environment identified by an object.

        :param field: On return, the CellML intermediate field.
        :type field: Field
        :rtype: None
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_IntermediateFieldGet, [CellML, field])

    def ModelImport(self, URI):
        """Imports a specified CellML model as specified by a character URI into a CellML environment identified by an object.

        :param URI: The URI of the CellML model to import.
        :type URI: string
        :returns: modelIndex. The index of the imported model.
        :rtype: int
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_ModelImport, [CellML, URI])

    def ModelsFieldCreateFinish(self):
        """Finish the creation of CellML models field for a CellML environment identified by an object.

        :rtype: None
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_ModelsFieldCreateFinish, [CellML])

    def ModelsFieldCreateStart(self, CellMLModelsFieldUserNumber, field):
        """Start the creation of CellML models field for a CellML environment identified by an object.

        :param CellMLModelsFieldUserNumber: The user number of the CellML models field to start creating.
        :type CellMLModelsFieldUserNumber: int
        :param field: On return, the created CellML models field.
        :type field: Field
        :rtype: None
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_ModelsFieldCreateStart, [CellML, CellMLModelsFieldUserNumber, field])

    def ModelsFieldGet(self, field):
        """Returns the CellML models field for a CellML environment identified by an object.

        :param field: On return, the CellML models field. Must not be associated on entry.
        :type field: Field
        :rtype: None
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_ModelsFieldGet, [CellML, field])

    def ParametersFieldCreateFinish(self):
        """Finish the creation of CellML parameters field for a CellML environment identified by an object.

        :rtype: None
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_ParametersFieldCreateFinish, [CellML])

    def ParametersFieldCreateStart(self, CellMLParametersFieldUserNumber, field):
        """Start the creation of CellML parameters field for a CellML environment identified by an object.

        :param CellMLParametersFieldUserNumber: The user number of the CellML parameters field to start creating.
        :type CellMLParametersFieldUserNumber: int
        :param field: On return, the created CellML parameters field.
        :type field: Field
        :rtype: None
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_ParametersFieldCreateStart, [CellML, CellMLParametersFieldUserNumber, field])

    def ParametersFieldGet(self, field):
        """Returns the CellML parameters field for a CellML environment identified by an object.

        :param field: On return, the CellML parameters field.
        :type field: Field
        :rtype: None
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_ParametersFieldGet, [CellML, field])

    def StateFieldCreateFinish(self):
        """Finish the creation of CellML state field for a CellML environment identified by an object.

        :rtype: None
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_StateFieldCreateFinish, [CellML])

    def StateFieldCreateStart(self, CellMLStateFieldUserNumber, field):
        """Start the creation of CellML state field for a CellML environment identified by an object.

        :param CellMLStateFieldUserNumber: The user number of the CellML state field to start creating.
        :type CellMLStateFieldUserNumber: int
        :param field: On return, the created CellML state field.
        :type field: Field
        :rtype: None
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_StateFieldCreateStart, [CellML, CellMLStateFieldUserNumber, field])

    def StateFieldGet(self, field):
        """Returns the CellML state field for a CellML environment identified by an object.

        :param field: On return, the CellML state field.
        :type field: Field
        :rtype: None
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_StateFieldGet, [CellML, field])

    def VariableSetAsKnown(self, CellMLModelUserNumber, variableID):
        """Sets a CellML model variable to be known by object.

        :param CellMLModelUserNumber: The user number of the CellML model in which to find the given variable.
        :type CellMLModelUserNumber: int
        :param variableID: The CellML variable to set as known (in the format 'component_name/variable_name').
        :type variableID: string
        :rtype: None
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_VariableSetAsKnown, [CellML, CellMLModelUserNumber, variableID])

    def VariableSetAsWanted(self, CellMLModelUserNumber, variableID):
        """Sets a CellML model variable to be wanted by object.

        :param CellMLModelUserNumber: The user number of the CellML model in which to find the given variable.
        :type CellMLModelUserNumber: int
        :param variableID: The CellML variable to set as wanted (in the format 'component_name/variable_name').
        :type variableID: string
        :rtype: None
        """

        CellML = self
        return _wrap_routine(_iron_python.cmfe_CellML_VariableSetAsWanted, [CellML, CellMLModelUserNumber, variableID])

    modelsField = property(ModelsFieldGet, None, None, """The CellML models field for a CellML environment identified by an object.""")

    parametersField = property(ParametersFieldGet, None, None, """The CellML parameters field for a CellML environment identified by an object.""")

    intermediateField = property(IntermediateFieldGet, None, None, """The CellML intermediate field for a CellML environment identified by an object.""")

    stateField = property(StateFieldGet, None, None, """The CellML state field for a CellML environment identified by an object.""")


class ComputationalWorkGroup(CMFEType):
    """Contains information on a computational work group
    """

    def __init__(self):
        """Initialise a null cmfe_ComputationalWorkGroupType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_ComputationalWorkGroup_Initialise, None)

    def CreateFinish(self):
        """GENERATE THE HIERARCHY COMPUTATIONAL ENVIRONMENT BASED ON WORK GROUP TREE

        :rtype: None
        """

        worldWorkGroup = self
        return _wrap_routine(_iron_python.cmfe_ComputationalWorkGroup_CreateFinish, [worldWorkGroup])

    def CreateStart(self, numberComputationalNodes):
        """CREATE THE HIGHEST LEVEL WORK GROUP (DEFAULT: GROUP_WORLD)

        :param numberComputationalNodes:
        :type numberComputationalNodes: int
        :rtype: None
        """

        worldWorkGroup = self
        return _wrap_routine(_iron_python.cmfe_ComputationalWorkGroup_CreateStart, [worldWorkGroup, numberComputationalNodes])

    def SubgroupAdd(self, numberComputationalNodes, addedWorkGroup):
        """ADD WORK SUB-GROUP TO THE PARENT GROUP BASED ON THE COMPUTATIONAL REQUIREMENTS (CALLED BY THE USER)

        :param numberComputationalNodes:
        :type numberComputationalNodes: int
        :param addedWorkGroup:
        :type addedWorkGroup: ComputationalWorkGroup
        :rtype: None
        """

        parentWorkGroup = self
        return _wrap_routine(_iron_python.cmfe_ComputationalWorkGroup_SubgroupAdd, [parentWorkGroup, numberComputationalNodes, addedWorkGroup])


class ControlLoop(CMFEType):
    """Contains information on a control loop.
    """

    def __init__(self):
        """Initialise a null cmfe_ControlLoopType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_ControlLoop_Initialise, None)

    def AbsoluteToleranceSet(self, absoluteTolerance):
        """Sets/changes the maximum iterations for a while control loop identified by an object.

        :param absoluteTolerance: The absolute tolerance value for a control loop.
        :type absoluteTolerance: float
        :rtype: None
        """

        controlLoop = self
        return _wrap_routine(_iron_python.cmfe_ControlLoop_AbsoluteToleranceSet, [controlLoop, absoluteTolerance])

    def ControlLoopGet(self, controlLoopIdentifiers):
        """Returns the specified control loop as indexed by the control loop identifiers from the control loop root.

        :param controlLoopIdentifiers: The control loop identifiers.
        :type controlLoopIdentifiers: Array of ints
        :returns: controlLoop. The specified control loop.
        :rtype: ControlLoop
        """

        controlLoopRoot = self
        return _wrap_routine(_iron_python.cmfe_ControlLoop_ControlLoopGet, [controlLoopRoot, controlLoopIdentifiers])

    def CurrentTimesGet(self):
        """Gets the current time parameters for a time control loop identified by an object.

        :returns: (The current time of the time control loop, The current time increment of the time control loop)
        :rtype: tuple. (float, float)
        """

        controlLoop = self
        return _wrap_routine(_iron_python.cmfe_ControlLoop_CurrentTimesGet, [controlLoop])

    def Destroy(self):
        """Destroys a control loop identified by an object.

        :rtype: None
        """

        controlLoop = self
        return _wrap_routine(_iron_python.cmfe_ControlLoop_Destroy, [controlLoop])

    def Finalise(self):
        """Finalises a cmfe_ControlLoopType object.

        :rtype: None
        """

        cmfe_ControlLoop = self
        return _wrap_routine(_iron_python.cmfe_ControlLoop_Finalise, [cmfe_ControlLoop])

    def IterationsSet(self, startIteration, stopIteration, iterationIncrement):
        """Sets/changes the iteration parameters for a fixed control loop identified by an object.

        :param startIteration: The start iteration of the fixed control loop to set.
        :type startIteration: int
        :param stopIteration: The stop iteration of the fixed control loop to set.
        :type stopIteration: int
        :param iterationIncrement: The iteration increment of the fixed control loop to set.
        :type iterationIncrement: int
        :rtype: None
        """

        controlLoop = self
        return _wrap_routine(_iron_python.cmfe_ControlLoop_IterationsSet, [controlLoop, startIteration, stopIteration, iterationIncrement])

    def LabelGet(self):
        """Returns the character string label for a control loop identified by an object.

        :returns: label. The region label.
        :rtype: string
        """

        controlLoop = self
        return _wrap_routine(_iron_python.cmfe_ControlLoop_LabelGet, [controlLoop])

    def LabelSet(self, label):
        """Sets/changes the character string label for a control loop identified by an object.

        :param label: The control loop label to set.
        :type label: string
        :rtype: None
        """

        controlLoop = self
        return _wrap_routine(_iron_python.cmfe_ControlLoop_LabelSet, [controlLoop, label])

    def LoadOutputSet(self, outputFrequency):
        """Sets/changes the output parameters for a load control loop identified by an object.

        :param outputFrequency: The output frequency modulo to set.
        :type outputFrequency: int
        :rtype: None
        """

        controlLoop = self
        return _wrap_routine(_iron_python.cmfe_ControlLoop_LoadOutputSet, [controlLoop, outputFrequency])

    def MaximumIterationsSet(self, maximumIterations):
        """Sets/changes the maximum iterations for a while control loop identified by an object.

        :param maximumIterations: The maximum iterations of the while control loop to set.
        :type maximumIterations: int
        :rtype: None
        """

        controlLoop = self
        return _wrap_routine(_iron_python.cmfe_ControlLoop_MaximumIterationsSet, [controlLoop, maximumIterations])

    def NumberOfIterationsGet(self):
        """Gets the number of iterations for a time control loop identified by an object.

        :returns: numberOfIterations. The number of iterations
        :rtype: int
        """

        controlLoop = self
        return _wrap_routine(_iron_python.cmfe_ControlLoop_NumberOfIterationsGet, [controlLoop])

    def NumberOfIterationsSet(self, numberOfIterations):
        """Sets the number of iterations for a time control loop identified by an object.

        :param numberOfIterations: The number of iterations to set
        :type numberOfIterations: int
        :rtype: None
        """

        controlLoop = self
        return _wrap_routine(_iron_python.cmfe_ControlLoop_NumberOfIterationsSet, [controlLoop, numberOfIterations])

    def NumberOfSubLoopsGet(self):
        """Returns the number of sub-control loops for a control loop identified by an object.

        :returns: numberOfSubLoops. The number of sub loops for the specified control loop.
        :rtype: int
        """

        controlLoop = self
        return _wrap_routine(_iron_python.cmfe_ControlLoop_NumberOfSubLoopsGet, [controlLoop])

    def NumberOfSubLoopsSet(self, numberOfSubLoops):
        """Sets/changes the number of sub-control loops for a control loop identified by an object. \todo is this really public???

        :param numberOfSubLoops: The number of sub loops for the specified control loop.
        :type numberOfSubLoops: int
        :rtype: None
        """

        controlLoop = self
        return _wrap_routine(_iron_python.cmfe_ControlLoop_NumberOfSubLoopsSet, [controlLoop, numberOfSubLoops])

    def OutputTypeGet(self):
        """Returns the output type for a control loop identified by an object.

        :returns: outputType. The output type of the control loop. Will be a value from the ControlLoopOutputTypes enum.
        :rtype: int
        """

        controlLoop = self
        return _wrap_routine(_iron_python.cmfe_ControlLoop_OutputTypeGet, [controlLoop])

    def OutputTypeSet(self, outputType):
        """Sets the output type for a control loop identified by an object.

        :param outputType: The output type to set. Must be a value from the ControlLoopOutputTypes enum.
        :type outputType: int
        :rtype: None
        """

        controlLoop = self
        return _wrap_routine(_iron_python.cmfe_ControlLoop_OutputTypeSet, [controlLoop, outputType])

    def TimeInputSet(self, inputOption):
        """Sets/changes the input parameters for a time control loop identified by an object.

        :param inputOption: The output frequency modulo to set.
        :type inputOption: int
        :rtype: None
        """

        controlLoop = self
        return _wrap_routine(_iron_python.cmfe_ControlLoop_TimeInputSet, [controlLoop, inputOption])

    def TimeOutputSet(self, outputFrequency):
        """Sets/changes the output parameters for a time control loop identified by an object.

        :param outputFrequency: The output frequency modulo to set.
        :type outputFrequency: int
        :rtype: None
        """

        controlLoop = self
        return _wrap_routine(_iron_python.cmfe_ControlLoop_TimeOutputSet, [controlLoop, outputFrequency])

    def TimesGet(self):
        """Returns the time parameters for a time control loop identified by an object.

        :returns: (The start time for the time control loop, The stop time for the time control loop, The time increment for the time control loop, The current time for the time control loop, The iteration number for the current loop, The iteration number for the time control loop)
        :rtype: tuple. (float, float, float, float, int, int)
        """

        controlLoop = self
        return _wrap_routine(_iron_python.cmfe_ControlLoop_TimesGet, [controlLoop])

    def TimesSet(self, startTime, stopTime, timeIncrement):
        """Sets/changes the time parameters for a time control loop identified by an object.

        :param startTime: The start time for the time control loop to set.
        :type startTime: float
        :param stopTime: The stop time for the time control loop to set.
        :type stopTime: float
        :param timeIncrement: The time increment for the time control loop to set.
        :type timeIncrement: float
        :rtype: None
        """

        controlLoop = self
        return _wrap_routine(_iron_python.cmfe_ControlLoop_TimesSet, [controlLoop, startTime, stopTime, timeIncrement])

    def TypeSet(self, loopType):
        """Sets/changes the loop type for a control loop identified by an object. \todo is this really public???

        :param loopType: The type of control loop to set. Must be a value from the ProblemControlLoopTypes enum.
        :type loopType: int
        :rtype: None
        """

        controlLoop = self
        return _wrap_routine(_iron_python.cmfe_ControlLoop_TypeSet, [controlLoop, loopType])

    numberOfIterations = property(NumberOfIterationsGet, NumberOfIterationsSet, None, """The number of iterations for a time control loop identified by an object.""")

    absoluteTolerance = property(None, AbsoluteToleranceSet, None, """The maximum iterations for a while control loop identified by an object.""")

    timeOutput = property(None, TimeOutputSet, None, """The output parameters for a time control loop identified by an object.""")

    timeInput = property(None, TimeInputSet, None, """The input parameters for a time control loop identified by an object.""")

    outputType = property(OutputTypeGet, OutputTypeSet, None, """The output type for a control loop identified by an object.""")

    label = property(LabelGet, LabelSet, None, """The character string label for a control loop identified by an object.""")

    loadOutput = property(None, LoadOutputSet, None, """The output parameters for a load control loop identified by an object.""")

    numberOfSubLoops = property(NumberOfSubLoopsGet, NumberOfSubLoopsSet, None, """The number of sub-control loops for a control loop identified by an object.""")

    type = property(None, TypeSet, None, """The loop type for a control loop identified by an object. \todo is this really public???""")

    maximumIterations = property(None, MaximumIterationsSet, None, """The maximum iterations for a while control loop identified by an object.""")


class CoordinateSystem(CMFEType):
    """Contains information on a coordinate system.
    """

    def __init__(self):
        """Initialise a null cmfe_CoordinateSystemType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_CoordinateSystem_Initialise, None)

    def CreateFinish(self):
        """Finishes the creation of a coordinate system identified by an object.

        :rtype: None
        """

        coordinateSystem = self
        return _wrap_routine(_iron_python.cmfe_CoordinateSystem_CreateFinish, [coordinateSystem])

    def CreateStart(self, coordinateSystemUserNumber):
        """Starts the creation of a coordinate system identified by an object.

        :param coordinateSystemUserNumber: The user number of the coordinate system to start creating.
        :type coordinateSystemUserNumber: int
        :rtype: None
        """

        coordinateSystem = self
        return _wrap_routine(_iron_python.cmfe_CoordinateSystem_CreateStart, [coordinateSystemUserNumber, coordinateSystem])

    def Destroy(self):
        """Destroys a coordinate system identified by an object.

        :rtype: None
        """

        coordinateSystem = self
        return _wrap_routine(_iron_python.cmfe_CoordinateSystem_Destroy, [coordinateSystem])

    def DimensionGet(self):
        """Returns the dimension of a coordinate system identified by an object.

        :returns: coordinateSystemDimension. The dimension of the coordinate system.
        :rtype: int
        """

        coordinateSystem = self
        return _wrap_routine(_iron_python.cmfe_CoordinateSystem_DimensionGet, [coordinateSystem])

    def DimensionSet(self, coordinateSystemDimension):
        """Sets/changes the dimension of a coordinate system identified by an object.

        :param coordinateSystemDimension: The dimension of the coordinate system to set.
        :type coordinateSystemDimension: int
        :rtype: None
        """

        coordinateSystem = self
        return _wrap_routine(_iron_python.cmfe_CoordinateSystem_DimensionSet, [coordinateSystem, coordinateSystemDimension])

    def Finalise(self):
        """Finalises a cmfe_CoordinateSystemType object.

        :rtype: None
        """

        cmfe_CoordinateSystem = self
        return _wrap_routine(_iron_python.cmfe_CoordinateSystem_Finalise, [cmfe_CoordinateSystem])

    def FocusGet(self):
        """Returns the focus of a coordinate system identified by an object.

        :returns: focus. The focus of the coordinate system.
        :rtype: float
        """

        coordinateSystem = self
        return _wrap_routine(_iron_python.cmfe_CoordinateSystem_FocusGet, [coordinateSystem])

    def FocusSet(self, focus):
        """Sets/changes the focus of a coordinate system identified by an object.

        :param focus: The focus of the coordinate system to set.
        :type focus: float
        :rtype: None
        """

        coordinateSystem = self
        return _wrap_routine(_iron_python.cmfe_CoordinateSystem_FocusSet, [coordinateSystem, focus])

    def OrientationGet(self, orientationSizes):
        """Returns the orientation of a coordinate system identified by an object.

        :param orientationSizes: Tuple of dimensions of orientation to allocate, with length 2.
        :returns: orientation. The orientation of the coordinate system.
        :rtype: 2d array of floats
        """

        coordinateSystem = self
        return _wrap_routine(_iron_python.cmfe_CoordinateSystem_OrientationGet, [coordinateSystem, orientationSizes])

    def OrientationSet(self, orientation):
        """Sets/changes the orientation of a coordinate system identified by an object.

        :param orientation: The orientation of the coordinate system to set.
        :type orientation: 2d array of floats
        :rtype: None
        """

        coordinateSystem = self
        return _wrap_routine(_iron_python.cmfe_CoordinateSystem_OrientationSet, [coordinateSystem, orientation])

    def OriginGet(self, originSize):
        """Returns the origin of a coordinate system identified by an object.

        :param originSize: Size of origin to allocate.
        :returns: origin. The origin of the coordinate system.
        :rtype: Array of floats
        """

        coordinateSystem = self
        return _wrap_routine(_iron_python.cmfe_CoordinateSystem_OriginGet, [coordinateSystem, originSize])

    def OriginSet(self, origin):
        """Sets/changes the origin of a coordinate system identified by an object.

        :param origin: The origin of the coordinate system to set.
        :type origin: Array of floats
        :rtype: None
        """

        coordinateSystem = self
        return _wrap_routine(_iron_python.cmfe_CoordinateSystem_OriginSet, [coordinateSystem, origin])

    def RadialInterpolationGet(self):
        """Returns the radial interpolation type of a coordinate system identified by an object.

        :returns: radialInterpolationType. The radial interpolation type of the coordinate system. Will be a value from the CoordinateRadialInterpolations enum.
        :rtype: int
        """

        coordinateSystem = self
        return _wrap_routine(_iron_python.cmfe_CoordinateSystem_RadialInterpolationGet, [coordinateSystem])

    def RadialInterpolationSet(self, radialInterpolationType):
        """Sets/changes the radial interpolation type of a coordinate system identified by an object.

        :param radialInterpolationType: The radial interpolation type of the coordinate system to set. Must be a value from the CoordinateRadialInterpolations enum.
        :type radialInterpolationType: int
        :rtype: None
        """

        coordinateSystem = self
        return _wrap_routine(_iron_python.cmfe_CoordinateSystem_RadialInterpolationSet, [coordinateSystem, radialInterpolationType])

    def TypeGet(self):
        """Returns the type of a coordinate system identified by an object.

        :returns: coordinateSystemType. The type of the coordinate system. Will be a value from the CoordinateSystemTypes enum.
        :rtype: int
        """

        coordinateSystem = self
        return _wrap_routine(_iron_python.cmfe_CoordinateSystem_TypeGet, [coordinateSystem])

    def TypeSet(self, coordinateSystemType):
        """Sets/changes the type of a coordinate system identified by an object.

        :param coordinateSystemType: The type of the coordinate system to set. Must be a value from the CoordinateSystemTypes enum.
        :type coordinateSystemType: int
        :rtype: None
        """

        coordinateSystem = self
        return _wrap_routine(_iron_python.cmfe_CoordinateSystem_TypeSet, [coordinateSystem, coordinateSystemType])

    origin = property(OriginGet, OriginSet, None, """The origin of a coordinate system identified by an object.""")

    radialInterpolation = property(RadialInterpolationGet, RadialInterpolationSet, None, """The radial interpolation type of a coordinate system identified by an object.""")

    orientation = property(OrientationGet, OrientationSet, None, """The orientation of a coordinate system identified by an object.""")

    focus = property(FocusGet, FocusSet, None, """The focus of a coordinate system identified by an object.""")

    type = property(TypeGet, TypeSet, None, """The type of a coordinate system identified by an object.""")

    dimension = property(DimensionGet, DimensionSet, None, """The dimension of a coordinate system identified by an object.""")


class DataPoints(CMFEType):
    """Contains information on the data points defined on a region.
    """

    def __init__(self):
        """Initialise a null cmfe_DataPointsType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_DataPoints_Initialise, None)

    def CreateFinish(self):
        """Finishes the creation of a data points in a region for data points identified by an object.

        :rtype: None
        """

        dataPoints = self
        return _wrap_routine(_iron_python.cmfe_DataPoints_CreateFinish, [dataPoints])

    def CreateStartInterface(self, interface, numberOfDataPoints):
        """Starts the creation of a data points in a region for data points identified by an object.

        :param interface: The interface to start the creation of data points on.
        :type interface: Interface
        :param numberOfDataPoints: The number of data points to create.
        :type numberOfDataPoints: int
        :rtype: None
        """

        dataPoints = self
        return _wrap_routine(_iron_python.cmfe_DataPoints_CreateStartInterface, [interface, numberOfDataPoints, dataPoints])

    def CreateStart(self, region, numberOfDataPoints):
        """Starts the creation of a data points in a region for data points identified by an object.

        :param region: The region to start the creation of data points on.
        :type region: Region
        :param numberOfDataPoints: The number of data points to create.
        :type numberOfDataPoints: int
        :rtype: None
        """

        dataPoints = self
        return _wrap_routine(_iron_python.cmfe_DataPoints_CreateStart, [region, numberOfDataPoints, dataPoints])

    def Destroy(self):
        """Destroys the data points in a region for data points identified by an object.

        :rtype: None
        """

        dataPoints = self
        return _wrap_routine(_iron_python.cmfe_DataPoints_Destroy, [dataPoints])

    def Finalise(self):
        """Finalises a cmfe_DataPointsType object.

        :rtype: None
        """

        cmfe_DataPoints = self
        return _wrap_routine(_iron_python.cmfe_DataPoints_Finalise, [cmfe_DataPoints])

    def LabelGet(self, dataPointGlobalNumber):
        """Returns the character label for a data point in a set of data points identified by an object.

        :param dataPointGlobalNumber: The global number of the data points to get the label for.
        :type dataPointGlobalNumber: int
        :returns: label. The label for the data point.
        :rtype: string
        """

        dataPoints = self
        return _wrap_routine(_iron_python.cmfe_DataPoints_LabelGet, [dataPoints, dataPointGlobalNumber])

    def LabelSet(self, dataPointGlobalNumber, label):
        """Sets/changes the character label for a data point in a set of data points identified by an object.

        :param dataPointGlobalNumber: The global number of the data points to set the label for.
        :type dataPointGlobalNumber: int
        :param label: The label for the data point to set.
        :type label: string
        :rtype: None
        """

        dataPoints = self
        return _wrap_routine(_iron_python.cmfe_DataPoints_LabelSet, [dataPoints, dataPointGlobalNumber, label])

    def NumberOfDataPointsGet(self):
        """Returns the number of data points

        :returns: numberOfDataPoints. The number of data points
        :rtype: int
        """

        dataPoints = self
        return _wrap_routine(_iron_python.cmfe_DataPoints_NumberOfDataPointsGet, [dataPoints])

    def UserNumberGet(self, dataPointGlobalNumber):
        """Returns the user number for a data point in a set of data points identified by an object.

        :param dataPointGlobalNumber: The global number of the data points to get the data point user number for.
        :type dataPointGlobalNumber: int
        :returns: dataPointUserNumber. The user number for the data point.
        :rtype: int
        """

        dataPoints = self
        return _wrap_routine(_iron_python.cmfe_DataPoints_UserNumberGet, [dataPoints, dataPointGlobalNumber])

    def UserNumberSet(self, dataPointGlobalNumber, dataPointUserNumber):
        """Sets/changes the user number for a data point in a set of data points identified by an object.

        :param dataPointGlobalNumber: The global number of the data points to set the data point user number for.
        :type dataPointGlobalNumber: int
        :param dataPointUserNumber: The user number for the data point to set.
        :type dataPointUserNumber: int
        :rtype: None
        """

        dataPoints = self
        return _wrap_routine(_iron_python.cmfe_DataPoints_UserNumberSet, [dataPoints, dataPointGlobalNumber, dataPointUserNumber])

    def ValuesGet(self, dataPointGlobalNumber, dataPointValuesSize):
        """Returns the values for a data point in a set of data points identified by an object.

        :param dataPointGlobalNumber: The global number of the data points to get the data point user number for.
        :type dataPointGlobalNumber: int
        :param dataPointValuesSize: Size of dataPointValues to allocate.
        :returns: dataPointValues. The values for the data point.
        :rtype: Array of floats
        """

        dataPoints = self
        return _wrap_routine(_iron_python.cmfe_DataPoints_ValuesGet, [dataPoints, dataPointGlobalNumber, dataPointValuesSize])

    def ValuesSet(self, dataPointGlobalNumber, dataPointValues):
        """Sets/changes the values for a data point in a set of data points identified by an object.

        :param dataPointGlobalNumber: The global number of the data points to set the data point user number for.
        :type dataPointGlobalNumber: int
        :param dataPointValues: The values for the data point to set.
        :type dataPointValues: Array of floats
        :rtype: None
        """

        dataPoints = self
        return _wrap_routine(_iron_python.cmfe_DataPoints_ValuesSet, [dataPoints, dataPointGlobalNumber, dataPointValues])

    def WeightsGet(self, dataPointGlobalNumber, dataPointWeightsSize):
        """Returns the weights for a data point in a set of data points identified by an object.

        :param dataPointGlobalNumber: The global number of the data points to get the data point user number for.
        :type dataPointGlobalNumber: int
        :param dataPointWeightsSize: Size of dataPointWeights to allocate.
        :returns: dataPointWeights. The weights for the data point.
        :rtype: Array of floats
        """

        dataPoints = self
        return _wrap_routine(_iron_python.cmfe_DataPoints_WeightsGet, [dataPoints, dataPointGlobalNumber, dataPointWeightsSize])

    def WeightsSet(self, dataPointGlobalNumber, dataPointWeights):
        """Sets/changes the weights for a data point in a set of data points identified by an object.

        :param dataPointGlobalNumber: The global number of the data points to set the data point user number for.
        :type dataPointGlobalNumber: int
        :param dataPointWeights: The weights for the data point to set.
        :type dataPointWeights: Array of floats
        :rtype: None
        """

        dataPoints = self
        return _wrap_routine(_iron_python.cmfe_DataPoints_WeightsSet, [dataPoints, dataPointGlobalNumber, dataPointWeights])

    numberOfDataPoints = property(NumberOfDataPointsGet, None, None, """The number of data points""")


class DataProjection(CMFEType):
    """Contains information about a data projection.
    """

    def __init__(self):
        """Initialise a null cmfe_DataProjectionType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_DataProjection_Initialise, None)

    def AbsoluteToleranceGet(self):
        """Returns the absolute tolerance of data projection identified an object.

        :returns: absoluteTolerance. On exit, the absolute tolerance of the specified data projection
        :rtype: float
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_AbsoluteToleranceGet, [dataProjection])

    def AbsoluteToleranceSet(self, absoluteTolerance):
        """Sets/changes the absolute tolerance of data projection identified an object.

        :param absoluteTolerance: the absolute tolerance to set
        :type absoluteTolerance: float
        :rtype: None
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_AbsoluteToleranceSet, [dataProjection, absoluteTolerance])

    def CreateFinish(self):
        """Finishes the creation of a new data projection identified by an object.

        :rtype: None
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_CreateFinish, [dataProjection])

    def CreateStart(self, dataProjectionUserNumber, dataPoints, mesh):
        """Starts the creation of a new data projection for a data projection identified by an object.

        :param dataProjectionUserNumber: The data projection user number.
        :type dataProjectionUserNumber: int
        :param dataPoints: The data points to be projected
        :type dataPoints: DataPoints
        :param mesh: The mesh where data points is projected on
        :type mesh: Mesh
        :rtype: None
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_CreateStart, [dataProjectionUserNumber, dataPoints, mesh, dataProjection])

    def DataPointsPositionEvaluate(self, field, fieldVariableType):
        """Evaluate the data points position in a field based on data projection, identified by object

        :param field: The field to interpolate
        :type field: Field
        :param fieldVariableType: The field variable type to be interpolated
        :type fieldVariableType: int
        :rtype: None
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_DataPointsPositionEvaluate, [dataProjection, field, fieldVariableType])

    def DataPointsProjectionEvaluate(self, projectionField):
        """Evaluate a data projection identified by an object.

        :param projectionField: The field data points is projected on
        :type projectionField: Field
        :rtype: None
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_DataPointsProjectionEvaluate, [dataProjection, projectionField])

    def Destroy(self):
        """Destroys a data projection identified by an object.

        :rtype: None
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_Destroy, [dataProjection])

    def ElementSet(self, dataPointNumber, elementNumber):
        """Sets/changes the starting xi of data projection identified an object.

        :param dataPointNumber: The data point number to set xi position for
        :type dataPointNumber: int
        :param elementNumber: the element number to set
        :type elementNumber: int
        :rtype: None
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_ElementSet, [dataProjection, dataPointNumber, elementNumber])

    def Finalise(self):
        """Finalises a cmfe_DataProjectionType object.

        :rtype: None
        """

        cmfe_DataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_Finalise, [cmfe_DataProjection])

    def LabelGet(self):
        """Gets the character string label of a data projection identified an object.

        :returns: label. the label to get
        :rtype: string
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_LabelGet, [dataProjection])

    def LabelSet(self, label):
        """Sets/changes the character string label of a data projection identified an object.

        :param label: the label to set
        :type label: string
        :rtype: None
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_LabelSet, [dataProjection, label])

    def MaximumIterationUpdateGet(self):
        """Returns the relative tolerance of data projection identified an object.

        :returns: maximumIterationUpdate. On exit, the maximum iteration update of the specified data projection
        :rtype: float
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_MaximumIterationUpdateGet, [dataProjection])

    def MaximumIterationUpdateSet(self, maximumIterationUpdate):
        """Sets/changes the relative tolerance of data projection identified an object.

        :param maximumIterationUpdate: the maximum iteration update to set
        :type maximumIterationUpdate: float
        :rtype: None
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_MaximumIterationUpdateSet, [dataProjection, maximumIterationUpdate])

    def MaximumNumberOfIterationsGet(self):
        """Returns the maximum number of iterations of data projection identified an object.

        :returns: maximumNumberOfIterations. On exit, the maximum number of iterations of the specified data projection
        :rtype: int
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_MaximumNumberOfIterationsGet, [dataProjection])

    def MaximumNumberOfIterationsSet(self, maximumNumberOfIterations):
        """Sets/changes the maximum number of iterations of data projection identified an object.

        :param maximumNumberOfIterations: the maximum number of iterations to set
        :type maximumNumberOfIterations: int
        :rtype: None
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_MaximumNumberOfIterationsSet, [dataProjection, maximumNumberOfIterations])

    def NumberOfClosestElementsGet(self):
        """Returns the number of closest elements of data projection identified an object.

        :returns: numberOfClosestElements. On exit, the number of closest elements of the specified data projection
        :rtype: int
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_NumberOfClosestElementsGet, [dataProjection])

    def NumberOfClosestElementsSet(self, numberOfClosestElements):
        """Sets/changes the number of closest elements of data projection identified an object.

        :param numberOfClosestElements: the number of closest elements to set
        :type numberOfClosestElements: int
        :rtype: None
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_NumberOfClosestElementsSet, [dataProjection, numberOfClosestElements])

    def ProjectionCandidatesSet(self, candidateElements, localFaceLineNumbers):
        """Evaluate the data points position in a field based on data projection, identified by object

        :param candidateElements: The candidate element for the projection
        :type candidateElements: Array of ints
        :param localFaceLineNumbers: The local face/line number for the candidate elements
        :type localFaceLineNumbers: Array of ints
        :rtype: None
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_ProjectionCandidatesSet, [dataProjection, candidateElements, localFaceLineNumbers])

    def ProjectionTypeGet(self):
        """Returns the projection type of data projection identified an object.

        :returns: projectionType. On exit, the projection type of the specified data projection
        :rtype: int
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_ProjectionTypeGet, [dataProjection])

    def ProjectionTypeSet(self, projectionType):
        """Sets/changes the projection type of data projection identified an object.

        :param projectionType: the projection type to set
        :type projectionType: int
        :rtype: None
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_ProjectionTypeSet, [dataProjection, projectionType])

    def RelativeToleranceGet(self):
        """Returns the relative tolerance of data projection identified an object.

        :returns: relativeTolerance. On exit, the absolute relative tolerance of the specified data projection
        :rtype: float
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_RelativeToleranceGet, [dataProjection])

    def RelativeToleranceSet(self, relativeTolerance):
        """Sets/changes the relative tolerance of data projection identified an object.

        :param relativeTolerance: the absolute relative tolerance to set
        :type relativeTolerance: float
        :rtype: None
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_RelativeToleranceSet, [dataProjection, relativeTolerance])

    def ResultDistanceGet(self, dataPointUserNumber):
        """Returns the projection distance for a data point in a set of data points identified by an object.

        :param dataPointUserNumber: The user number of the data points to get attributes for.
        :type dataPointUserNumber: int
        :returns: ProjectionDistance. The projection distance for the data point.
        :rtype: float
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_ResultDistanceGet, [dataProjection, dataPointUserNumber])

    def ResultElementFaceNumberGet(self, dataPointUserNumber):
        """Returns the projection element face number for a data point in a set of data points identified by an object.

        :param dataPointUserNumber: The user number of the data points to get attributes for.
        :type dataPointUserNumber: int
        :returns: ProjectionElementFaceNumber. The projection element face number for the data point.
        :rtype: int
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_ResultElementFaceNumberGet, [dataProjection, dataPointUserNumber])

    def ResultElementLineNumberGet(self, dataPointUserNumber):
        """Returns the projection element line number for a data point in a set of data points identified by an object.

        :param dataPointUserNumber: The user number of the data points to get attributes for.
        :type dataPointUserNumber: int
        :returns: ProjectionElementLineNumber. The projection element line number for the data point.
        :rtype: int
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_ResultElementLineNumberGet, [dataProjection, dataPointUserNumber])

    def ResultElementNumberGet(self, dataPointUserNumber):
        """Returns the projection element number for a data point in a set of data points identified by an object.

        :param dataPointUserNumber: The user number of the data points to get attributes for.
        :type dataPointUserNumber: int
        :returns: ProjectionElementNumber. The projection element number for the data point.
        :rtype: int
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_ResultElementNumberGet, [dataProjection, dataPointUserNumber])

    def ResultExitTagGet(self, dataPointUserNumber):
        """Returns the projection exit tag for a data point in a set of data points identified by an object.

        :param dataPointUserNumber: The user number of the data points to get attributes for.
        :type dataPointUserNumber: int
        :returns: ProjectionExitTag. The projection exit tag for the data point.
        :rtype: int
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_ResultExitTagGet, [dataProjection, dataPointUserNumber])

    def ResultProjectionVectorGet(self, dataPointUserNumber, projectionVectorSize):
        """Returns the projection vector for a data point in a set of data points identified by an object.

        :param dataPointUserNumber: The user number of the data points to get attributes for.
        :type dataPointUserNumber: int
        :param projectionVectorSize: Size of projectionVector to allocate.
        :returns: projectionVector. The projection vector for the data point.
        :rtype: Array of floats
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_ResultProjectionVectorGet, [dataProjection, dataPointUserNumber, projectionVectorSize])

    def ResultXiGet(self, dataPointUserNumber, ProjectionXiSize):
        """Returns the projection xi for a data point in a set of data points identified by an object.

        :param dataPointUserNumber: The user number of the data points to get attributes for.
        :type dataPointUserNumber: int
        :param ProjectionXiSize: Size of ProjectionXi to allocate.
        :returns: ProjectionXi. The projection xi for the data point.
        :rtype: Array of floats
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_ResultXiGet, [dataProjection, dataPointUserNumber, ProjectionXiSize])

    def ResultXiSet(self, dataPointUserNumber, ProjectionXi):
        """Sets the projection xi for a data point in a set of data points identified by an object.

        :param dataPointUserNumber: The user number of the data points to set attributes for
        :type dataPointUserNumber: int
        :param ProjectionXi: On return, the projection xi for the data point.
        :type ProjectionXi: Array of floats
        :rtype: None
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_ResultXiSet, [dataProjection, dataPointUserNumber, ProjectionXi])

    def StartingXiGet(self, startingXiSize):
        """Returns the starting xi of data projection identified an object.

        :param startingXiSize: Size of startingXi to allocate.
        :returns: startingXi. On exit, the absolute starting xi of the specified data projection
        :rtype: Array of floats
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_StartingXiGet, [dataProjection, startingXiSize])

    def StartingXiSet(self, startingXi):
        """Sets/changes the starting xi of data projection identified an object.

        :param startingXi: the absolute starting xi to set
        :type startingXi: Array of floats
        :rtype: None
        """

        dataProjection = self
        return _wrap_routine(_iron_python.cmfe_DataProjection_StartingXiSet, [dataProjection, startingXi])

    maximumNumberOfIterations = property(MaximumNumberOfIterationsGet, MaximumNumberOfIterationsSet, None, """The maximum number of iterations of data projection identified an object.""")

    absoluteTolerance = property(AbsoluteToleranceGet, AbsoluteToleranceSet, None, """The absolute tolerance of data projection identified an object.""")

    label = property(LabelGet, LabelSet, None, """The character string label of a data projection identified an object.""")

    maximumIterationUpdate = property(MaximumIterationUpdateGet, MaximumIterationUpdateSet, None, """The relative tolerance of data projection identified an object.""")

    numberOfClosestElements = property(NumberOfClosestElementsGet, NumberOfClosestElementsSet, None, """The number of closest elements of data projection identified an object.""")

    projectionType = property(ProjectionTypeGet, ProjectionTypeSet, None, """The projection type of data projection identified an object.""")

    startingXi = property(StartingXiGet, StartingXiSet, None, """The starting xi of data projection identified an object.""")

    relativeTolerance = property(RelativeToleranceGet, RelativeToleranceSet, None, """The relative tolerance of data projection identified an object.""")


class Decomposition(CMFEType):
    """Contains information on the mesh decomposition.
    """

    def __init__(self):
        """Initialise a null cmfe_DecompositionType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_Decomposition_Initialise, None)

    def CalculateFacesSet(self, calculateFacesFlag):
        """Sets whether faces should be calculated

        :param calculateFacesFlag: Boolean to determine whether to set faces to be calculated.
        :type calculateFacesFlag: bool
        :rtype: None
        """

        decomposition = self
        return _wrap_routine(_iron_python.cmfe_Decomposition_CalculateFacesSet, [decomposition, calculateFacesFlag])

    def CalculateLinesSet(self, calculateLinesFlag):
        """Sets whether lines should be calculated

        :param calculateLinesFlag: Boolean to determine whether to set lines to be calculated.
        :type calculateLinesFlag: bool
        :rtype: None
        """

        decomposition = self
        return _wrap_routine(_iron_python.cmfe_Decomposition_CalculateLinesSet, [decomposition, calculateLinesFlag])

    def CreateFinish(self):
        """Finishes the creation of a domain decomposition for a decomposition identified by an object.

        :rtype: None
        """

        decomposition = self
        return _wrap_routine(_iron_python.cmfe_Decomposition_CreateFinish, [decomposition])

    def CreateStart(self, decompositionUserNumber, mesh):
        """Starts the creation of a domain decomposition for a decomposition identified by an object.

        :param decompositionUserNumber: The user number of the decomposition to create.
        :type decompositionUserNumber: int
        :param mesh: The mesh to create the decomposition for.
        :type mesh: Mesh
        :rtype: None
        """

        decomposition = self
        return _wrap_routine(_iron_python.cmfe_Decomposition_CreateStart, [decompositionUserNumber, mesh, decomposition])

    def Destroy(self):
        """Destroys a decomposition identified by an object.

        :rtype: None
        """

        decomposition = self
        return _wrap_routine(_iron_python.cmfe_Decomposition_Destroy, [decomposition])

    def ElementDomainCalculate(self):
        """Calculates the element domains for a decomposition identified by an object.

        :rtype: None
        """

        decomposition = self
        return _wrap_routine(_iron_python.cmfe_Decomposition_ElementDomainCalculate, [decomposition])

    def ElementDomainGet(self, elementUserNumber):
        """Returns the domain for a given element in a decomposition identified by an object.

        :param elementUserNumber: The user number of the element to get the domain for.
        :type elementUserNumber: int
        :returns: domain. The computational domain of the element.
        :rtype: int
        """

        decomposition = self
        return _wrap_routine(_iron_python.cmfe_Decomposition_ElementDomainGet, [decomposition, elementUserNumber])

    def ElementDomainSet(self, elementUserNumber, domain):
        """Sets/changes the domain for a given element in a decomposition identified by an object.

        :param elementUserNumber: The user number of the element to set the domain for.
        :type elementUserNumber: int
        :param domain: The computational domain of the element to set.
        :type domain: int
        :rtype: None
        """

        decomposition = self
        return _wrap_routine(_iron_python.cmfe_Decomposition_ElementDomainSet, [decomposition, elementUserNumber, domain])

    def Finalise(self):
        """Finalises a cmfe_DecompositionType object.

        :rtype: None
        """

        cmfe_Decomposition = self
        return _wrap_routine(_iron_python.cmfe_Decomposition_Finalise, [cmfe_Decomposition])

    def MeshComponentGet(self):
        """Returns the mesh component number used for the decomposition of a mesh for a decomposition identified by an object.

        :returns: meshComponentNumber. The mesh component number for the decomposition.
        :rtype: int
        """

        decomposition = self
        return _wrap_routine(_iron_python.cmfe_Decomposition_MeshComponentGet, [decomposition])

    def MeshComponentSet(self, meshComponentNumber):
        """Sets/changes the mesh component number used for the decomposition of a mesh for a decomposition identified by an object.

        :param meshComponentNumber: The mesh component number for the decomposition to set.
        :type meshComponentNumber: int
        :rtype: None
        """

        decomposition = self
        return _wrap_routine(_iron_python.cmfe_Decomposition_MeshComponentSet, [decomposition, meshComponentNumber])

    def NodeDomainGet(self, nodeUserNumber, meshComponentNumber):
        """Returns the domain for a given node in a decomposition identified by an object. \todo Maybe swap Node and MeshComponent?

        :param nodeUserNumber: The user number of the node to get the domain for.
        :type nodeUserNumber: int
        :param meshComponentNumber: The user number of the mesh component to get the domain for.
        :type meshComponentNumber: int
        :returns: domain. The computational domain of the node.
        :rtype: int
        """

        decomposition = self
        return _wrap_routine(_iron_python.cmfe_Decomposition_NodeDomainGet, [decomposition, nodeUserNumber, meshComponentNumber])

    def NumberOfDomainsGet(self):
        """Returns the number of domains for a decomposition identified by an object.

        :returns: numberOfDomains. The number of domains in the decomposition.
        :rtype: int
        """

        decomposition = self
        return _wrap_routine(_iron_python.cmfe_Decomposition_NumberOfDomainsGet, [decomposition])

    def NumberOfDomainsSet(self, numberOfDomains):
        """Sets/changes the number of domains for a decomposition identified by an object.

        :param numberOfDomains: The number of domains in the decomposition to set.
        :type numberOfDomains: int
        :rtype: None
        """

        decomposition = self
        return _wrap_routine(_iron_python.cmfe_Decomposition_NumberOfDomainsSet, [decomposition, numberOfDomains])

    def TopologyDataProjectionCalculate(self):
        """Calculates the decomposition topology for data points

        :rtype: None
        """

        decomposition = self
        return _wrap_routine(_iron_python.cmfe_Decomposition_TopologyDataProjectionCalculate, [decomposition])

    def TopologyElementDataPointLocalNumberGet(self, elementNumber, dataPointIndex):
        """Gets the local data point number for data points projected on an element

        :param elementNumber: The element number to get the data point for
        :type elementNumber: int
        :param dataPointIndex: The data point index to get the number for
        :type dataPointIndex: int
        :returns: dataPointLocalNumber. The data point local number to retu
        :rtype: int
        """

        decomposition = self
        return _wrap_routine(_iron_python.cmfe_Decomposition_TopologyElementDataPointLocalNumberGet, [decomposition, elementNumber, dataPointIndex])

    def TopologyElementDataPointUserNumberGet(self, elementNumber, dataPointIndex):
        """Gets the user data point number for data points projected on an element

        :param elementNumber: The element number to get the data point for
        :type elementNumber: int
        :param dataPointIndex: The data point index to get the number for
        :type dataPointIndex: int
        :returns: dataPointUserNumber. The data point user number to retu
        :rtype: int
        """

        decomposition = self
        return _wrap_routine(_iron_python.cmfe_Decomposition_TopologyElementDataPointUserNumberGet, [decomposition, elementNumber, dataPointIndex])

    def TopologyNumberOfElementDataPointsGet(self, elementNumber):
        """Gets the number of data points projected on an element

        :param elementNumber: The element number to get the data point for
        :type elementNumber: int
        :returns: numberOfDataPoints. The data point local number to return
        :rtype: int
        """

        decomposition = self
        return _wrap_routine(_iron_python.cmfe_Decomposition_TopologyNumberOfElementDataPointsGet, [decomposition, elementNumber])

    def TypeGet(self):
        """Returns the type of a decomposition identified by an object.

        :returns: decompositionType. The type of the decomposition.
        :rtype: int
        """

        decomposition = self
        return _wrap_routine(_iron_python.cmfe_Decomposition_TypeGet, [decomposition])

    def TypeSet(self, decompositionType):
        """Sets/changes the type of a decomposition identified by an object.

        :param decompositionType: The type of the decomposition to set.
        :type decompositionType: int
        :rtype: None
        """

        decomposition = self
        return _wrap_routine(_iron_python.cmfe_Decomposition_TypeSet, [decomposition, decompositionType])

    def WorldWorkGroupSet(self, worldWorkGroup):
        """Set the working group tree in order to performe mesh decomposition

        :param worldWorkGroup:
        :type worldWorkGroup: ComputationalWorkGroup
        :rtype: None
        """

        decomposition = self
        return _wrap_routine(_iron_python.cmfe_Decomposition_WorldWorkGroupSet, [decomposition, worldWorkGroup])

    worldWorkGroup = property(None, WorldWorkGroupSet, None, """The working group tree in order to performe mesh decomposition""")

    calculateFaces = property(None, CalculateFacesSet, None, """Whether faces should be calculated""")

    type = property(TypeGet, TypeSet, None, """The type of a decomposition identified by an object.""")

    calculateLines = property(None, CalculateLinesSet, None, """Whether lines should be calculated""")

    numberOfDomains = property(NumberOfDomainsGet, NumberOfDomainsSet, None, """The number of domains for a decomposition identified by an object.""")

    meshComponent = property(MeshComponentGet, MeshComponentSet, None, """The mesh component number used for the decomposition of a mesh for a decomposition identified by an object.""")


class DistributedMatrix(CMFEType):
    """A matrix that may be distributed across multiple computational nodes
    and may use sparse or full storage.
    """

    def __init__(self):
        """Initialise a null cmfe_DistributedMatrixType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_DistributedMatrix_Initialise, None)

    def DataGetDP(self):
        """Get the data array for this matrix on this computational node

        :param dataSize: Size of data to allocate.
        :returns: data. The matrix data
        :rtype: Array of floats
        """

        matrix = self
        return _wrap_routine(_iron_python.cmfe_DistributedMatrix_DataGetDP, [matrix])

    def DataGetIntg(self):
        """Get the data array for this matrix on this computational node

        :param dataSize: Size of data to allocate.
        :returns: data. The matrix data
        :rtype: Array of ints
        """

        matrix = self
        return _wrap_routine(_iron_python.cmfe_DistributedMatrix_DataGetIntg, [matrix])

    def DataGetL(self):
        """Get the data array for this matrix on this computational node

        :param dataSize: Size of data to allocate.
        :returns: data. The matrix data
        :rtype: Array of bools
        """

        matrix = self
        return _wrap_routine(_iron_python.cmfe_DistributedMatrix_DataGetL, [matrix])

    def DataGetSP(self):
        """Get the data array for this matrix on this computational node

        :param dataSize: Size of data to allocate.
        :returns: data. The matrix data
        :rtype: Array of floats
        """

        matrix = self
        return _wrap_routine(_iron_python.cmfe_DistributedMatrix_DataGetSP, [matrix])

    def DataRestoreDP(self, data):
        """Restore the data array for this matrix once it has finished being used

        :param data: On entry, a pointer to the matrix data. On return, a nullified pointer.
        :type data: Array of floats
        :rtype: None
        """

        matrix = self
        return _wrap_routine(_iron_python.cmfe_DistributedMatrix_DataRestoreDP, [matrix, data])

    def DataRestoreIntg(self, data):
        """Restore the data array for this matrix once it has finished being used

        :param data: On entry, a pointer to the matrix data. On return, a nullified pointer.
        :type data: Array of ints
        :rtype: None
        """

        matrix = self
        return _wrap_routine(_iron_python.cmfe_DistributedMatrix_DataRestoreIntg, [matrix, data])

    def DataRestoreL(self, data):
        """Restore the data array for this matrix once it has finished being used

        :param data: On entry, a pointer to the matrix data. On return, a nullified pointer.
        :type data: Array of bools
        :rtype: None
        """

        matrix = self
        return _wrap_routine(_iron_python.cmfe_DistributedMatrix_DataRestoreL, [matrix, data])

    def DataRestoreSP(self, data):
        """Restore the data array for this matrix once it has finished being used

        :param data: On entry, a pointer to the matrix data. On return, a nullified pointer.
        :type data: Array of floats
        :rtype: None
        """

        matrix = self
        return _wrap_routine(_iron_python.cmfe_DistributedMatrix_DataRestoreSP, [matrix, data])

    def DataTypeGet(self):
        """Get the data type of a distributed matrix

        :returns: dataType. The matrix data type. Will be a value from the MatrixVectorDataTypes enum.
        :rtype: int
        """

        matrix = self
        return _wrap_routine(_iron_python.cmfe_DistributedMatrix_DataTypeGet, [matrix])

    def DimensionsGet(self):
        """Get the dimensions of a distributed matrix on this computational node

        :returns: (The number of rows for this computational node, The number of columns)
        :rtype: tuple. (int, int)
        """

        matrix = self
        return _wrap_routine(_iron_python.cmfe_DistributedMatrix_DimensionsGet, [matrix])

    def StorageLocationsGet(self):
        """Get the row indices and column indices for a sparse matrix

        :param rowIndicesSize: Size of rowIndices to allocate.
        :param columnIndicesSize: Size of columnIndices to allocate.
        :returns: (The matrix storage row indices, The matrix storage column indices)
        :rtype: tuple. (Array of ints, Array of ints)
        """

        matrix = self
        return _wrap_routine(_iron_python.cmfe_DistributedMatrix_StorageLocationsGet, [matrix])

    def StorageTypeGet(self):
        """Get the storage type for a distributed matrix

        :returns: storageType. The matrix storage type. Will be a value from the MatrixStorageTypes enum.
        :rtype: int
        """

        matrix = self
        return _wrap_routine(_iron_python.cmfe_DistributedMatrix_StorageTypeGet, [matrix])

    dataType = property(DataTypeGet, None, None, """The data type of a distributed matrix""")

    storageType = property(StorageTypeGet, None, None, """The storage type for a distributed matrix""")


class DistributedVector(CMFEType):
    """A vector that may be distributed across multiple computational nodes
    """

    def __init__(self):
        """Initialise a null cmfe_DistributedVectorType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_DistributedVector_Initialise, None)

    def DataGetDP(self):
        """Get the data array for this vector on this computational node

        :param dataSize: Size of data to allocate.
        :returns: data. The vector data
        :rtype: Array of floats
        """

        vector = self
        return _wrap_routine(_iron_python.cmfe_DistributedVector_DataGetDP, [vector])

    def DataGetIntg(self):
        """Get the data array for this vector on this computational node

        :param dataSize: Size of data to allocate.
        :returns: data. The vector data
        :rtype: Array of ints
        """

        vector = self
        return _wrap_routine(_iron_python.cmfe_DistributedVector_DataGetIntg, [vector])

    def DataGetL(self):
        """Get the data array for this vector on this computational node

        :param dataSize: Size of data to allocate.
        :returns: data. The vector data
        :rtype: Array of bools
        """

        vector = self
        return _wrap_routine(_iron_python.cmfe_DistributedVector_DataGetL, [vector])

    def DataGetSP(self):
        """Get the data array for this vector on this computational node

        :param dataSize: Size of data to allocate.
        :returns: data. The vector data
        :rtype: Array of floats
        """

        vector = self
        return _wrap_routine(_iron_python.cmfe_DistributedVector_DataGetSP, [vector])

    def DataRestoreDP(self, data):
        """Restore the data array for this vector once it has finished being used

        :param data: On entry, a pointer to the vector data. On return, a nullified pointer.
        :type data: Array of floats
        :rtype: None
        """

        vector = self
        return _wrap_routine(_iron_python.cmfe_DistributedVector_DataRestoreDP, [vector, data])

    def DataRestoreIntg(self, data):
        """Restore the data array for this vector once it has finished being used

        :param data: On entry, a pointer to the vector data. On return, a nullified pointer.
        :type data: Array of ints
        :rtype: None
        """

        vector = self
        return _wrap_routine(_iron_python.cmfe_DistributedVector_DataRestoreIntg, [vector, data])

    def DataRestoreL(self, data):
        """Restore the data array for this vector once it has finished being used

        :param data: On entry, a pointer to the vector data. On return, a nullified pointer.
        :type data: Array of bools
        :rtype: None
        """

        vector = self
        return _wrap_routine(_iron_python.cmfe_DistributedVector_DataRestoreL, [vector, data])

    def DataRestoreSP(self, data):
        """Restore the data array for this vector once it has finished being used

        :param data: On entry, a pointer to the vector data. On return, a nullified pointer.
        :type data: Array of floats
        :rtype: None
        """

        vector = self
        return _wrap_routine(_iron_python.cmfe_DistributedVector_DataRestoreSP, [vector, data])

    def DataTypeGet(self):
        """Get the data type of a distributed vector

        :returns: dataType. The vector data type. Will be a value from the MatrixVectorDataTypes enum.
        :rtype: int
        """

        vector = self
        return _wrap_routine(_iron_python.cmfe_DistributedVector_DataTypeGet, [vector])

    dataType = property(DataTypeGet, None, None, """The data type of a distributed vector""")


class EquationsSet(CMFEType):
    """Contains information on an equations set defined on a region.
    """

    def __init__(self):
        """Initialise a null cmfe_EquationsSetType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_EquationsSet_Initialise, None)

    def AnalyticCreateFinish(self):
        """Finish the creation of a analytic solution for an equations set identified by an object.

        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_AnalyticCreateFinish, [equationsSet])

    def AnalyticCreateStart(self, analyticFunctionType, analyticFieldUserNumber, analyticField):
        """Start the creation of an analytic solution for an equations set identified by an object.

        :param analyticFunctionType: The analytic function type to use. Must be a value from the EquationsSetAnalyticFunctionTypes enum.
        :type analyticFunctionType: int
        :param analyticFieldUserNumber: The user number of the field for the analytic function
        :type analyticFieldUserNumber: int
        :param analyticField: If associated on entry, the user created analytic field which has the same user number as the specified analytic field user number. If not associated on entry, on return, the created analytic field for the equations set.
        :type analyticField: Field
        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_AnalyticCreateStart, [equationsSet, analyticFunctionType, analyticFieldUserNumber, analyticField])

    def AnalyticDestroy(self):
        """Destroy the analytic solution for an equations set identified by an object.

        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_AnalyticDestroy, [equationsSet])

    def AnalyticEvaluate(self):
        """Evaluates the current analytic solution for an equations set identified by an object.

        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_AnalyticEvaluate, [equationsSet])

    def AnalyticTimeGet(self):
        """Returns the analytic time for an equations set identified by an object.

        :returns: time. The analytic time for the equations set.
        :rtype: float
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_AnalyticTimeGet, [equationsSet])

    def AnalyticTimeSet(self, time):
        """Sets/changes the analytic time for an equations set identified by an object.

        :param time: The analytic time to set.
        :type time: float
        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_AnalyticTimeSet, [equationsSet, time])

    def AnalyticUserParamGet(self, paramIdx):
        """Sets the analytic problem user parameter

        :param paramIdx: The index of the analytic user parameter to set
        :type paramIdx: int
        :returns: param. Value of the parameter to set
        :rtype: float
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_AnalyticUserParamGet, [equationsSet, paramIdx])

    def AnalyticUserParamSet(self, paramIdx, param):
        """Sets the analytic problem user parameter

        :param paramIdx: The index of the analytic user parameter to set
        :type paramIdx: int
        :param param: Value of the parameter to set
        :type param: float
        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_AnalyticUserParamSet, [equationsSet, paramIdx, param])

    def CreateFinish(self):
        """Finish the creation of an equations set identified by an object.

        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_CreateFinish, [equationsSet])

    def CreateStart(self, equationsSetUserNumber, region, geomFibreField, equationsSetSpecification, equationsSetFieldUserNumber, equationsSetFieldField):
        """Start the creation of an equations set identified by an object.

        :param equationsSetUserNumber: The user number of the equations set to be created.
        :type equationsSetUserNumber: int
        :param region: The region to create the equations set on.
        :type region: Region
        :param geomFibreField: The Geometric/Fibre field for the creation of the equations set.
        :type geomFibreField: Field
        :param equationsSetSpecification: The equations set specification array, containing the equations class, type etc
        :type equationsSetSpecification: Array of ints
        :param equationsSetFieldUserNumber: The user number of the equations set field
        :type equationsSetFieldUserNumber: int
        :param equationsSetFieldField: On return, a pointer to the equations set field
        :type equationsSetFieldField: Field
        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_CreateStart, [equationsSetUserNumber, region, geomFibreField, equationsSetSpecification, equationsSetFieldUserNumber, equationsSetFieldField, equationsSet])

    def DependentCreateFinish(self):
        """Finish the creation of dependent variables for an equations set identified by an object.

        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_DependentCreateFinish, [equationsSet])

    def DependentCreateStart(self, dependentFieldUserNumber, dependentField):
        """Start the creation of dependent variables for an equations set identified by an object.

        :param dependentFieldUserNumber: The user number of the dependent field.
        :type dependentFieldUserNumber: int
        :param dependentField: If associated on entry, the user created dependent field which has the same user number as the specified dependent field user number. If not associated on entry, on return, the created dependent field for the equations set.
        :type dependentField: Field
        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_DependentCreateStart, [equationsSet, dependentFieldUserNumber, dependentField])

    def DependentDestroy(self):
        """Destroy the dependent variables for an equations set identified by an object.

        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_DependentDestroy, [equationsSet])

    def DerivedCreateFinish(self):
        """Finish the creation of derived variables for an equations set identified by an object.

        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_DerivedCreateFinish, [equationsSet])

    def DerivedCreateStart(self, derivedFieldUserNumber, derivedField):
        """Start the creation of derived variables for an equations set identified by an object.

        :param derivedFieldUserNumber: The user number of the derived field.
        :type derivedFieldUserNumber: int
        :param derivedField: If associated on entry, the user created derived field which has the same user number as the specified derived field user number. If not associated on entry, on return, the created derived field for the equations set.
        :type derivedField: Field
        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_DerivedCreateStart, [equationsSet, derivedFieldUserNumber, derivedField])

    def DerivedDestroy(self):
        """Destroy the derived variables for an equations set identified by an object.

        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_DerivedDestroy, [equationsSet])

    def DerivedVariableCalculate(self, derivedType):
        """Calculates a derived field value for the equations set and stores the result in the derived field previously set up

        :param derivedType: The derived field type to calculate. Must be a value from the EquationsSetDerivedTypes enum.
        :type derivedType: int
        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_DerivedVariableCalculate, [equationsSet, derivedType])

    def DerivedVariableSet(self, derivedType, fieldVariableType):
        """Sets the field variable type of the derived field to be used to store a derived variable

        :param derivedType: The derived field type to calculate. Must be a value from the EquationsSetDerivedTypes enum.
        :type derivedType: int
        :param fieldVariableType: The field variable type to store the calculated values in.
        :type fieldVariableType: int
        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_DerivedVariableSet, [equationsSet, derivedType, fieldVariableType])

    def Destroy(self):
        """Destroy an equations set identified by an object.

        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_Destroy, [equationsSet])

    def EquationsCreateFinish(self):
        """Finish the creation of equations for an equations set identified by an object.

        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_EquationsCreateFinish, [equationsSet])

    def EquationsCreateStart(self, equations):
        """Start the creation of equations for an equations set identified by an object.

        :param equations: On return, the created equations.
        :type equations: Equations
        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_EquationsCreateStart, [equationsSet, equations])

    def EquationsDestroy(self):
        """Destroy the equations for an equations set identified by an object.

        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_EquationsDestroy, [equationsSet])

    def Finalise(self):
        """Finalises a cmfe_EquationsSetType object.

        :rtype: None
        """

        cmfe_EquationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_Finalise, [cmfe_EquationsSet])

    def IndependentCreateFinish(self):
        """Finish the creation of independent variables for an equations set identified by an object.

        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_IndependentCreateFinish, [equationsSet])

    def IndependentCreateStart(self, independentFieldUserNumber, independentField):
        """Start the creation of independent variables for an equations set identified by an object.

        :param independentFieldUserNumber: The user number of the dependent field.
        :type independentFieldUserNumber: int
        :param independentField: If associated on entry, the user created independent field which has the same user number as the specified independent field user number. If not associated on entry, on return, the created independent field for the equations set.
        :type independentField: Field
        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_IndependentCreateStart, [equationsSet, independentFieldUserNumber, independentField])

    def IndependentDestroy(self):
        """Destroy the independent variables for an equations set identified by an object.

        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_IndependentDestroy, [equationsSet])

    def MaterialsCreateFinish(self):
        """Finish the creation of materials for an equations set identified by an object.

        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_MaterialsCreateFinish, [equationsSet])

    def MaterialsCreateStart(self, materialsFieldUserNumber, materialsField):
        """Start the creation of materials for an equations set identified by an object.

        :param materialsFieldUserNumber: The user number of the materials field.
        :type materialsFieldUserNumber: int
        :param materialsField: If associated on entry, the user created materials field which has the same user number as the specified materials field user number. If not associated on entry, on return, the created materials field for the equations set.
        :type materialsField: Field
        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_MaterialsCreateStart, [equationsSet, materialsFieldUserNumber, materialsField])

    def MaterialsDestroy(self):
        """Destroy the materials for an equations set identified by an object.

        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_MaterialsDestroy, [equationsSet])

    def SolutionMethodGet(self):
        """Returns the solution method for an equations set identified by an object.

        :returns: solutionMethod. The solution method. Will be a value from the EquationsSetSolutionMethods enum.
        :rtype: int
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_SolutionMethodGet, [equationsSet])

    def SolutionMethodSet(self, solutionMethod):
        """Sets/changes the solution method for an equations set identified by an object.

        :param solutionMethod: The solution method to set. Must be a value from the EquationsSetSolutionMethods enum.
        :type solutionMethod: int
        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_SolutionMethodSet, [equationsSet, solutionMethod])

    def SourceCreateFinish(self):
        """Finish the creation of a source for an equations set identified by an object.

        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_SourceCreateFinish, [equationsSet])

    def SourceCreateStart(self, sourceFieldUserNumber, sourceField):
        """Start the creation of a source for an equations set identified by an object.

        :param sourceFieldUserNumber: The user number of the source field.
        :type sourceFieldUserNumber: int
        :param sourceField: If associated on entry, the user created source field which has the same user number as the specified source field user number. If not associated on entry, on return, the created source field for the equations set.
        :type sourceField: Field
        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_SourceCreateStart, [equationsSet, sourceFieldUserNumber, sourceField])

    def SourceDestroy(self):
        """Destroy the source for an equations set identified by an object.

        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_SourceDestroy, [equationsSet])

    def SpecificationGet(self, equationsSetSpecification):
        """Returns the equations set specification array for an equations set identified by an object.

        :param equationsSetSpecification: On return, the equations set specification array. Must be allocated and large enough to contain the specification on entry.
        :type equationsSetSpecification: Array of ints
        :rtype: None
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_SpecificationGet, [equationsSet, equationsSetSpecification])

    def SpecificationSizeGet(self):
        """Returns the size of the equations set specification array for an equations set identified by an object.

        :returns: specificationSize. The size of the equations set specification array.
        :rtype: int
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_SpecificationSizeGet, [equationsSet])

    def TensorInterpolateXi(self, tensorEvaluateType, userElementNumber, xi, valuesSizes):
        """Evaluate a tensor at a given element xi location, for an equations set identified by an object.

        :param tensorEvaluateType: The type of tensor to evaluate.
        :type tensorEvaluateType: int
        :param userElementNumber: The user element number of the field to interpolate.
        :type userElementNumber: int
        :param xi: The element xi to interpolate the field at.
        :type xi: Array of floats
        :param valuesSizes: Tuple of dimensions of values to allocate, with length 2.
        :returns: values. The interpolated strain tensor values.
        :rtype: 2d array of floats
        """

        equationsSet = self
        return _wrap_routine(_iron_python.cmfe_EquationsSet_TensorInterpolateXi, [equationsSet, tensorEvaluateType, userElementNumber, xi, valuesSizes])

    specificationSize = property(SpecificationSizeGet, None, None, """The size of the equations set specification array for an equations set identified by an object.""")

    analyticTime = property(AnalyticTimeGet, AnalyticTimeSet, None, """The analytic time for an equations set identified by an object.""")

    solutionMethod = property(SolutionMethodGet, SolutionMethodSet, None, """The solution method for an equations set identified by an object.""")

    specification = property(SpecificationGet, None, None, """The equations set specification array for an equations set identified by an object.""")


class Equations(CMFEType):
    """Contains information about the equations in an equations set.
    """

    def __init__(self):
        """Initialise a null cmfe_EquationsType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_Equations_Initialise, None)

    def Destroy(self):
        """Destroy equations for equations identified by an object.

        :rtype: None
        """

        equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_Destroy, [equations])

    def DynamicMatrixGet(self, matrixIndex, matrix):
        """Get a dynamic equations matrix from equations using the dynamic matrix index

        :param matrixIndex: The number of the dynamic matrix to get
        :type matrixIndex: int
        :param matrix: On return, the requested dynamic matrix
        :type matrix: DistributedMatrix
        :rtype: None
        """

        equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_DynamicMatrixGet, [equations, matrixIndex, matrix])

    def DynamicMatrixGetByType(self, matrixType, matrix):
        """Get a dynamic equations matrix from equations using the dynamic matrix type

        :param matrixType: The type of the dynamic matrix to get. Must be a value from the EquationsSetDynamicMatrixTypes enum.
        :type matrixType: int
        :param matrix: On return, the requested dynamic matrix
        :type matrix: DistributedMatrix
        :rtype: None
        """

        equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_DynamicMatrixGetByType, [equations, matrixType, matrix])

    def DynamicMatrixTypeGet(self, matrixIndex):
        """Get the type of a dynamic matrix from equations set equations

        :param matrixIndex: The number of the dynamic matrix to get the type of
        :type matrixIndex: int
        :returns: matrixType. The dynamic matrix type. Will be a value from the EquationsSetDynamicMatrixTypes enum.
        :rtype: int
        """

        equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_DynamicMatrixTypeGet, [equations, matrixIndex])

    def Finalise(self):
        """Finalises a cmfe_EquationsType object.

        :rtype: None
        """

        cmfe_Equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_Finalise, [cmfe_Equations])

    def JacobianMatricesTypesSet(self, jacobianTypes):
        """Setting Jacobian matrix evaluation type

        :param jacobianTypes: The type of Jacobian evaluation. Must be a value from the EquationsJacobianCalculated enum.
        :type jacobianTypes: int
        :rtype: None
        """

        equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_JacobianMatricesTypesSet, [equations, jacobianTypes])

    def JacobianMatrixGet(self, residualIndex, variableType, matrix):
        """Get a Jacobian matrix from the equations

        :param residualIndex: The index of the residual vector to get the Jacobian matrix for
        :type residualIndex: int
        :param variableType: The field variable type that the residual is differentiated with respect to for this Jacobian. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param matrix: On return, the requested Jacobian matrix
        :type matrix: DistributedMatrix
        :rtype: None
        """

        equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_JacobianMatrixGet, [equations, residualIndex, variableType, matrix])

    def LinearMatrixGet(self, matrixIndex, matrix):
        """Get a linear equations matrix from the equations

        :param matrixIndex: The number of the linear matrix to get
        :type matrixIndex: int
        :param matrix: On return, the requested linear matrix
        :type matrix: DistributedMatrix
        :rtype: None
        """

        equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_LinearMatrixGet, [equations, matrixIndex, matrix])

    def LinearityTypeGet(self):
        """Gets the linearity type for equations identified by an object.

        :returns: linearityType. The linearity type of the equations. Will be a value from the EquationsLinearityTypes enum.
        :rtype: int
        """

        equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_LinearityTypeGet, [equations])

    def LumpingTypeGet(self):
        """Gets the lumping type for equations identified by an object.

        :returns: lumpingType. The lumping type of the equations. Will be a value from the EquationsLumpingTypes enum.
        :rtype: int
        """

        equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_LumpingTypeGet, [equations])

    def LumpingTypeSet(self, lumpingType):
        """Sets/changes the lumping type for equations identified by an object.

        :param lumpingType: The lumping type of the equations to set. Must be a value from the EquationsLumpingTypes enum.
        :type lumpingType: int
        :rtype: None
        """

        equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_LumpingTypeSet, [equations, lumpingType])

    def NumberOfDynamicMatricesGet(self):
        """Get the number of dynamic matrices in the equations

        :returns: numberOfMatrices. The number of dynamic matrices
        :rtype: int
        """

        equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_NumberOfDynamicMatricesGet, [equations])

    def NumberOfJacobianMatricesGet(self):
        """Get the number of Jacobian matrices in the equations

        :returns: numberOfMatrices. The number of Jacobian matrices
        :rtype: int
        """

        equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_NumberOfJacobianMatricesGet, [equations])

    def NumberOfLinearMatricesGet(self):
        """Get the number of linear matrices in the equations

        :returns: numberOfMatrices. The number of linear matrices
        :rtype: int
        """

        equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_NumberOfLinearMatricesGet, [equations])

    def OutputTypeGet(self):
        """Gets the output type for equations identified by an object.

        :returns: outputType. The output type of the equations. Will be a value from the EquationsOutputTypes enum.
        :rtype: int
        """

        equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_OutputTypeGet, [equations])

    def OutputTypeSet(self, outputType):
        """Sets/changes the output type for equations identified by an object.

        :param outputType: The output type of the equations to set. Must be a value from the EquationsOutputTypes enum.
        :type outputType: int
        :rtype: None
        """

        equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_OutputTypeSet, [equations, outputType])

    def ResidualNumberOfVariablesGet(self, residualIndex):
        """Get the number of field variables that contribute to the residual vector

        :param residualIndex: The index of the residual vector to get the number of variables for
        :type residualIndex: int
        :returns: numberOfVariables. The number of variables that contribute to the residual vector
        :rtype: int
        """

        equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_ResidualNumberOfVariablesGet, [equations, residualIndex])

    def ResidualVariablesGet(self, residualIndex, residualVariablesSize):
        """Get the field variables that contribute to the residual vector

        :param residualIndex: The index of the residual vector to get the variables for
        :type residualIndex: int
        :param residualVariablesSize: Size of residualVariables to allocate.
        :returns: residualVariables. residualVariables(varIdx). On return, the field variable type for the varIdx'th residual variable. Will be a value from the FieldVariableTypes enum.
        :rtype: Array of ints
        """

        equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_ResidualVariablesGet, [equations, residualIndex, residualVariablesSize])

    def ResidualVectorGet(self, residualIndex, residualVector):
        """Get a residual vector for equations

        :param residualIndex: The index of the residual vector to get
        :type residualIndex: int
        :param residualVector: On return, the residual vector for the equations
        :type residualVector: DistributedVector
        :rtype: None
        """

        equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_ResidualVectorGet, [equations, residualIndex, residualVector])

    def RhsVectorGet(self, rhsVector):
        """Get the right hand side vector for equations

        :param rhsVector: On return, the right hand side vector for the equations
        :type rhsVector: DistributedVector
        :rtype: None
        """

        equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_RhsVectorGet, [equations, rhsVector])

    def SourceVectorGet(self, sourceVector):
        """Get the source vector for equations

        :param sourceVector: On return, the source vector for the equations
        :type sourceVector: DistributedVector
        :rtype: None
        """

        equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_SourceVectorGet, [equations, sourceVector])

    def SparsityTypeGet(self):
        """Gets the sparsity type for equations identified by an object.

        :returns: sparsityType. The sparsity type of the equations. Will be a value from the EquationsSparsityTypes enum.
        :rtype: int
        """

        equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_SparsityTypeGet, [equations])

    def SparsityTypeSet(self, sparsityType):
        """Sets/changes the sparsity type for equations identified by an object.

        :param sparsityType: The sparsity type of the equations to set. Must be a value from the EquationsSparsityTypes enum.
        :type sparsityType: int
        :rtype: None
        """

        equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_SparsityTypeSet, [equations, sparsityType])

    def TimeDependenceTypeGet(self):
        """Gets the time dependence type for equations identified by an object.

        :returns: timeDependenceType. The time dependence type of the equations. Will be a value from the EquationsTimeDependenceTypes enum.
        :rtype: int
        """

        equations = self
        return _wrap_routine(_iron_python.cmfe_Equations_TimeDependenceTypeGet, [equations])

    rhsVector = property(RhsVectorGet, None, None, """The right hand side vector for equations""")

    timeDependenceType = property(TimeDependenceTypeGet, None, None, """The time dependence type for equations identified by an object.""")

    sourceVector = property(SourceVectorGet, None, None, """The source vector for equations""")

    outputType = property(OutputTypeGet, OutputTypeSet, None, """The output type for equations identified by an object.""")

    sparsityType = property(SparsityTypeGet, SparsityTypeSet, None, """The sparsity type for equations identified by an object.""")

    linearityType = property(LinearityTypeGet, None, None, """The linearity type for equations identified by an object.""")

    jacobianMatricesTypes = property(None, JacobianMatricesTypesSet, None, """Setting Jacobian matrix evaluation type""")

    numberOfJacobianMatrices = property(NumberOfJacobianMatricesGet, None, None, """The number of Jacobian matrices in the equations""")

    numberOfDynamicMatrices = property(NumberOfDynamicMatricesGet, None, None, """The number of dynamic matrices in the equations""")

    lumpingType = property(LumpingTypeGet, LumpingTypeSet, None, """The lumping type for equations identified by an object.""")

    numberOfLinearMatrices = property(NumberOfLinearMatricesGet, None, None, """The number of linear matrices in the equations""")


class FieldMLIO(CMFEType):
    """Provides input and output of fields through the FieldML API
    """

    def __init__(self):
        """Initialise a null cmfe_FieldMLIOType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_FieldMLIO_Initialise, None)

    def Finalise(self):
        """Finalises a Fieldml context.

        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldMLIO_Finalise, [fieldml])

    def GetSession(self):
        """Get the session handle from a Fieldml context.

        :returns: sessionHandle. The session handle.
        :rtype: int
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldMLIO_GetSession, [fieldml])

    def InputBasisCreateStartNum(self, evaluatorName, userNumber):
        """Create a basis using the given FieldML evaluator.

        :param evaluatorName: The name of the argument evaluator to create the basis from.
        :type evaluatorName: string
        :param userNumber: The user number to assign to the new basis.
        :type userNumber: int
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_InputBasisCreateStartNum, [fieldml, evaluatorName, userNumber])

    def InputBasisCreateStart(self, evaluatorName, userNumber, basis):
        """Create a basis using the given FieldML evaluator.

        :param evaluatorName: The name of the argument evaluator to create the basis from.
        :type evaluatorName: string
        :param userNumber: The user number to assign to the new basis.
        :type userNumber: int
        :param basis: On return, the newly created basis.
        :type basis: Basis
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_InputBasisCreateStart, [fieldml, evaluatorName, userNumber, basis])

    def InputCoordinateSystemCreateStartNum(self, evaluatorName, userNumber):
        """Create a coordinate system using the given FieldML evaluator.

        :param evaluatorName: The name of the argument evaluator to create the coordinate system from.
        :type evaluatorName: string
        :param userNumber: The user number to assign to the new coordinate system.
        :type userNumber: int
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_InputCoordinateSystemCreateStartNum, [fieldml, evaluatorName, userNumber])

    def InputCoordinateSystemCreateStart(self, evaluatorName, coordinateSystem, userNumber):
        """Create a coordinate system using the given FieldML evaluator.

        :param evaluatorName: The name of the argument evaluator to create the coordinate system from.
        :type evaluatorName: string
        :param coordinateSystem: On return, the newly created coordinate system.
        :type coordinateSystem: CoordinateSystem
        :param userNumber: The user number to assign to the new coordinate system.
        :type userNumber: int
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_InputCoordinateSystemCreateStart, [fieldml, evaluatorName, coordinateSystem, userNumber])

    def InputCreateFromFile(self, filename):
        """Initialise the given FieldML context using the given FieldML XML file.

        :param filename: The FieldML XML file to parse.
        :type filename: string
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_InputCreateFromFile, [filename, fieldml])

    def InputCreateMeshComponentNum(self, regionNumber, meshNumber, componentNumber, evaluatorName):
        """Use the given FieldML evaluator as a template to create a component on the mesh identified by the given user number.

        :param regionNumber: The user number of the region in which the mesh component is to be created.
        :type regionNumber: int
        :param meshNumber: The user number of the mesh for which the mesh component is to be created.
        :type meshNumber: int
        :param componentNumber: The number of the mesh component to create.
        :type componentNumber: int
        :param evaluatorName: The name of the argument evaluator to create the basis from.
        :type evaluatorName: string
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_InputCreateMeshComponentNum, [fieldml, regionNumber, meshNumber, componentNumber, evaluatorName])

    def InputCreateMeshComponent(self, mesh, componentNumber, evaluatorName):
        """Use the given FieldML evaluator as a template to create a component on the given mesh.

        :param mesh: The mesh for which to create the mesh component.
        :type mesh: Mesh
        :param componentNumber: The number of the mesh component to create.
        :type componentNumber: int
        :param evaluatorName: The name of the argument evaluator to create the mesh from.
        :type evaluatorName: string
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_InputCreateMeshComponent, [fieldml, mesh, componentNumber, evaluatorName])

    def InputFieldCreateStartNum(self, regionNumber, meshNumber, decompositionNumber, fieldNumber, variableType, evaluatorName):
        """Create a field with the given user number using the given FieldML evaluator.

        :param regionNumber: The user number of the region in which to create the field.
        :type regionNumber: int
        :param meshNumber: The user number of the mesh to use when creating the field.
        :type meshNumber: int
        :param decompositionNumber: The user number of the decomposition to use when creating the field.
        :type decompositionNumber: int
        :param fieldNumber: The user number to assign to the new field.
        :type fieldNumber: int
        :param variableType: The OpenCMISS variable type.
        :type variableType: int
        :param evaluatorName: The name of the argument evaluator to create the field from.
        :type evaluatorName: string
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_InputFieldCreateStartNum, [fieldml, regionNumber, meshNumber, decompositionNumber, fieldNumber, variableType, evaluatorName])

    def InputFieldCreateStart(self, region, decomposition, fieldNumber, field, variableType, evaluatorName):
        """Create a field using the given FieldML evaluator.

        :param region: The region in which the field is to be created.
        :type region: Region
        :param decomposition: The decomposition to use when creating the field.
        :type decomposition: Decomposition
        :param fieldNumber: The user number to assign to the new field.
        :type fieldNumber: int
        :param field: On return, the newly created field.
        :type field: Field
        :param variableType: The OpenCMISS variable type.
        :type variableType: int
        :param evaluatorName: The name of the argument evaluator to create the field from.
        :type evaluatorName: string
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_InputFieldCreateStart, [fieldml, region, decomposition, fieldNumber, field, variableType, evaluatorName])

    def InputFieldParametersUpdateNum(self, regionNumber, fieldNumber, evaluatorName, variableType, setType):
        """Update the DOF parameters of field with the given user number, using the given FieldML evaluator.

        :param regionNumber: The user number of the region of the field for which parameters are to be updated.
        :type regionNumber: int
        :param fieldNumber: The user number of the field for which parameters are to be updated.
        :type fieldNumber: int
        :param evaluatorName: The name of the argument evaluator to get the parameters from.
        :type evaluatorName: string
        :param variableType: The OpenCMISS variable type.
        :type variableType: int
        :param setType: The parameter set type.
        :type setType: int
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_InputFieldParametersUpdateNum, [fieldml, regionNumber, fieldNumber, evaluatorName, variableType, setType])

    def InputFieldParametersUpdate(self, field, evaluatorName, variableType, setType):
        """Update the DOF parameters of the given field, using the given FieldML evaluator.

        :param field: On return, the field object.
        :type field: Field
        :param evaluatorName: The name of the argument evaluator to get the parameters from.
        :type evaluatorName: string
        :param variableType: The OpenCMISS variable type.
        :type variableType: int
        :param setType: The parameter set type.
        :type setType: int
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_InputFieldParametersUpdate, [fieldml, field, evaluatorName, variableType, setType])

    def InputMeshCreateStartNum(self, meshArgumentName, meshNumber, regionNumber):
        """Creates a mesh with the given user number using the given FieldML evaluator.

        :param meshArgumentName: The name of the mesh argument evaluator to create a mesh from.
        :type meshArgumentName: string
        :param meshNumber: The user number to assign to the new mesh.
        :type meshNumber: int
        :param regionNumber: The user number of the region in which to create the mesh.
        :type regionNumber: int
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_InputMeshCreateStartNum, [fieldml, meshArgumentName, meshNumber, regionNumber])

    def InputMeshCreateStart(self, meshArgumentName, mesh, meshNumber, region):
        """Creates a mesh using the given FieldML evaluator.

        :param meshArgumentName: The name of the argument evaluator to create a mesh from.
        :type meshArgumentName: string
        :param mesh: On return, the newly created mesh.
        :type mesh: Mesh
        :param meshNumber: The user number to assign to the new mesh.
        :type meshNumber: int
        :param region: The region in which to create the mesh.
        :type region: Region
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_InputMeshCreateStart, [fieldml, meshArgumentName, mesh, meshNumber, region])

    def InputNodesCreateStartNum(self, nodesArgumentName, regionNumber, nodes):
        """Creates a region's nodes using the given FieldML evaluator.

        :param nodesArgumentName: The name of the argument evaluator to create the nodes from.
        :type nodesArgumentName: string
        :param regionNumber: The user number of the region to create to the nodes in.
        :type regionNumber: int
        :param nodes: On return, the newly created nodes.
        :type nodes: Nodes
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_InputNodesCreateStartNum, [fieldml, nodesArgumentName, regionNumber, nodes])

    def InputNodesCreateStart(self, nodesArgumentName, region, nodes):
        """Creates a region's nodes using the given FieldML evaluator.

        :param nodesArgumentName: The name of the argument evaluator to create the basis from.
        :type nodesArgumentName: string
        :param region: The user number of the region to create to the nodes in.
        :type region: Region
        :param nodes: On return, the newly created nodes.
        :type nodes: Nodes
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_InputNodesCreateStart, [fieldml, nodesArgumentName, region, nodes])

    def OutputAddFieldComponentsNum(self, typeHandle, baseName, dofFormat, regionNumber, fieldNumber, fieldComponentNumbers, variableType, setType):
        """Add the field with the given user number to the current FieldML context, only including the given components.

        :param typeHandle: The FieldML type to assign to the new FieldML field.
        :type typeHandle: int
        :param baseName: The prefix to use when naming automatically created FieldML objects in the context.
        :type baseName: string
        :param dofFormat: The name of the format to use when writing dof data.
        :type dofFormat: string
        :param regionNumber: The user number of the region owning the field to add.
        :type regionNumber: int
        :param fieldNumber: The user number of the field whose components are to be added.
        :type fieldNumber: int
        :param fieldComponentNumbers: The component numbers to add.
        :type fieldComponentNumbers: Array of ints
        :param variableType: The variable type of the field to add to the FieldML context.
        :type variableType: int
        :param setType: The parameter set type.
        :type setType: int
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_OutputAddFieldComponentsNum, [fieldml, typeHandle, baseName, dofFormat, regionNumber, fieldNumber, fieldComponentNumbers, variableType, setType])

    def OutputAddFieldComponents(self, typeHandle, baseName, dofFormat, field, fieldComponentNumbers, variableType, setType):
        """Add the given field to the current FieldML context, only including the given components.

        :param typeHandle: The FieldML type to assign to the new FieldML field.
        :type typeHandle: int
        :param baseName: The prefix to use when naming automatically created FieldML objects in the context.
        :type baseName: string
        :param dofFormat: The name of the format to use when writing dof data.
        :type dofFormat: string
        :param field: The field whose components are to be added.
        :type field: Field
        :param fieldComponentNumbers:
        :type fieldComponentNumbers: Array of ints
        :param variableType: The variable type of the field to add to the FieldML context.
        :type variableType: int
        :param setType: The parameter set type.
        :type setType: int
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_OutputAddFieldComponents, [fieldml, typeHandle, baseName, dofFormat, field, fieldComponentNumbers, variableType, setType])

    def OutputAddFieldNoTypeNum(self, baseName, dofFormat, regionNumber, fieldNumber, variableType, setType):
        """Add the field with the given user number to the given FieldML context. The FieldML type will be inferred.

        :param baseName: The prefix to use when naming automatically created FieldML objects in the context.
        :type baseName: string
        :param dofFormat: The name of the format to use when writing dof data.
        :type dofFormat: string
        :param regionNumber: The user number of the region containing the field to add to the FieldML context.
        :type regionNumber: int
        :param fieldNumber: The user number of the field to add to the FieldML context.
        :type fieldNumber: int
        :param variableType: The variable type of the field to add to the FieldML context.
        :type variableType: int
        :param setType: The parameter set type.
        :type setType: int
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_OutputAddFieldNoTypeNum, [fieldml, baseName, dofFormat, regionNumber, fieldNumber, variableType, setType])

    def OutputAddFieldNoType(self, baseName, dofFormat, field, variableType, setType):
        """Add the given field to the given FieldML context. The FieldML type will be inferred.

        :param baseName: The prefix to use when naming automatically created FieldML objects in the context.
        :type baseName: string
        :param dofFormat: The name of the format to use when writing dof data.
        :type dofFormat: string
        :param field: The field to add.
        :type field: Field
        :param variableType: The variable type of the field to add.
        :type variableType: int
        :param setType: The parameter set type.
        :type setType: int
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_OutputAddFieldNoType, [fieldml, baseName, dofFormat, field, variableType, setType])

    def OutputAddFieldWithTypeNum(self, baseName, dofFormat, regionNumber, fieldNumber, variableType, setType, typeHandle):
        """Add the given field to the given FieldML context, using the given FieldML type.

        :param baseName: The prefix to use when naming automatically created FieldML objects in the context.
        :type baseName: string
        :param dofFormat: The name of the format to use when writing dof data.
        :type dofFormat: string
        :param regionNumber: The user number of the region owning the field to add.
        :type regionNumber: int
        :param fieldNumber: The user number of the field to add.
        :type fieldNumber: int
        :param variableType: The variable type of the field to add to the FieldML context.
        :type variableType: int
        :param setType: The parameter set type.
        :type setType: int
        :param typeHandle: The FieldML type to assign to the new FieldML field.
        :type typeHandle: int
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_OutputAddFieldWithTypeNum, [fieldml, baseName, dofFormat, regionNumber, fieldNumber, variableType, setType, typeHandle])

    def OutputAddFieldWithType(self, baseName, dofFormat, field, variableType, setType, typeHandle):
        """Add the given field to the given FieldML context, using the given FieldML type.

        :param baseName: The prefix to use when naming automatically created FieldML objects in the context.
        :type baseName: string
        :param dofFormat: The name of the format to use when writing dof data.
        :type dofFormat: string
        :param field: The field to add to the FieldML context.
        :type field: Field
        :param variableType: The variable type of the field to add to the FieldML context.
        :type variableType: int
        :param setType: The parameter set type.
        :type setType: int
        :param typeHandle: The FieldML type to assign to the new FieldML field.
        :type typeHandle: int
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_OutputAddFieldWithType, [fieldml, baseName, dofFormat, field, variableType, setType, typeHandle])

    def OutputAddImport(self, name):
        """Import a FieldML object from the library into the current session.

        :param name: The name of the object to import.
        :type name: string
        :returns: handle. A handle to the newly imported FieldML object.
        :rtype: int
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_OutputAddImport, [fieldml, name])

    def OutputCreateNum(self, regionNumber, meshNumber, location, baseName, connectivityFormat):
        """Initialise the given FieldML context using the mesh with the given user number.

        :param regionNumber: The user number of the region owning the mesh to use when initialising the FieldML context.
        :type regionNumber: int
        :param meshNumber: The user number of the mesh to use when initialising the FieldML context.
        :type meshNumber: int
        :param location: The root directory in which associated data files should be created.
        :type location: string
        :param baseName: The prefix to use when naming automatically created FieldML objects in the context.
        :type baseName: string
        :param connectivityFormat: The name of the format to use when writing connectivity data.
        :type connectivityFormat: string
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_OutputCreateNum, [regionNumber, meshNumber, location, baseName, connectivityFormat, fieldml])

    def OutputCreate(self, mesh, location, baseName, connectivityFormat):
        """Initialise the given FieldML context using the given mesh.

        :param mesh: The mesh to use when initialising the FieldML context.
        :type mesh: Mesh
        :param location: The root directory in which associated data files should be created.
        :type location: string
        :param baseName: The prefix to use when naming automatically created FieldML objects in the context.
        :type baseName: string
        :param connectivityFormat: The name of the format to use when writing connectivity data.
        :type connectivityFormat: string
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_OutputCreate, [mesh, location, baseName, connectivityFormat, fieldml])

    def OutputWrite(self, filename):
        """Write the FieldML document managed by the given context to a file with the given name.

        :param filename: The name of the file to write the FieldML document to.
        :type filename: string
        :rtype: None
        """

        fieldml = self
        return _wrap_routine(_iron_python.cmfe_FieldML_OutputWrite, [fieldml, filename])


class Field(CMFEType):
    """Contains information for a field defined on a region.
    """

    def __init__(self):
        """Initialise a null cmfe_FieldType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_Field_Initialise, None)

    def ComponentInterpolationGet(self, variableType, componentNumber):
        """Returns the interpolation type for a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to get the interpolation type for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param componentNumber: The component number of the field variable to get the interpolation type for.
        :type componentNumber: int
        :returns: interpolationType. The interpolation type. Will be a value from the FieldInterpolationTypes enum.
        :rtype: int
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ComponentInterpolationGet, [field, variableType, componentNumber])

    def ComponentInterpolationSet(self, variableType, componentNumber, interpolationType):
        """Sets/changes the interpolation type for a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to set the interpolation type for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param componentNumber: The component number of the field variable to set the interpolation type for.
        :type componentNumber: int
        :param interpolationType: The interpolation type to set. Must be a value from the FieldInterpolationTypes enum.
        :type interpolationType: int
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ComponentInterpolationSet, [field, variableType, componentNumber, interpolationType])

    def ComponentLabelGet(self, variableType, componentNumber):
        """Returns the character string label for a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to get the label for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param componentNumber: The component number of the field variable to get the label for.
        :type componentNumber: int
        :returns: label. The field variable component label.
        :rtype: string
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ComponentLabelGet, [field, variableType, componentNumber])

    def ComponentLabelSet(self, variableType, componentNumber, label):
        """Sets/changes the character string label for a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to set the label for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param componentNumber: The component number of the field variable to set the label for.
        :type componentNumber: int
        :param label: The field variable component label to set.
        :type label: string
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ComponentLabelSet, [field, variableType, componentNumber, label])

    def ComponentMeshComponentGet(self, variableType, componentNumber):
        """Returns the mesh component number for a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to get the mesh component number for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param componentNumber: The component number of the field variable to get the mesh component number for.
        :type componentNumber: int
        :returns: meshComponent. The mesh component number.
        :rtype: int
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ComponentMeshComponentGet, [field, variableType, componentNumber])

    def ComponentMeshComponentSet(self, variableType, componentNumber, meshComponent):
        """Sets/changes the mesh component number for a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to set the mesh component number for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param componentNumber: The component number of the field variable to set the mesh component number for.
        :type componentNumber: int
        :param meshComponent: The mesh component number to set.
        :type meshComponent: int
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ComponentMeshComponentSet, [field, variableType, componentNumber, meshComponent])

    def ComponentValuesInitialiseDP(self, variableType, fieldSetType, componentNumber, value):
        """Initialises the values of parameter set of a field variable component to a double precision constant value for a field identified by an object.

        :param variableType: The variable type of the field to initialise the field variable component for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to initialise the field variable component for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param componentNumber: The component number of the field variable to initialise the field variable component for.
        :type componentNumber: int
        :param value: The value to initialise the parameter set for.
        :type value: float
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ComponentValuesInitialiseDP, [field, variableType, fieldSetType, componentNumber, value])

    def ComponentValuesInitialiseIntg(self, variableType, fieldSetType, componentNumber, value):
        """Initialises the values of parameter set of a field variable component to an integer constant value for a field identified by an object.

        :param variableType: The variable type of the field to initialise the field variable component for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to initialise the field variable component for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param componentNumber: The component number of the field variable to initialise the field variable component for.
        :type componentNumber: int
        :param value: The value to initialise the parameter set for.
        :type value: int
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ComponentValuesInitialiseIntg, [field, variableType, fieldSetType, componentNumber, value])

    def ComponentValuesInitialiseL(self, variableType, fieldSetType, componentNumber, value):
        """Initialises the values of parameter set of a field variable component to a logical constant value for a field identified by an object.

        :param variableType: The variable type of the field to initialise the field variable component for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to initialise the field variable component for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param componentNumber: The component number of the field variable to initialise the field variable component for.
        :type componentNumber: int
        :param value: The value to initialise the parameter set for.
        :type value: bool
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ComponentValuesInitialiseL, [field, variableType, fieldSetType, componentNumber, value])

    def ComponentValuesInitialiseSP(self, variableType, fieldSetType, componentNumber, value):
        """Initialises the values of parameter set of a field variable component to a single precision constant value for a field identified by an object.

        :param variableType: The variable type of the field to initialise the field variable component for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to initialise the field variable component for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param componentNumber: The component number of the field variable to initialise the field variable component for.
        :type componentNumber: int
        :param value: The value to initialise the parameter set for.
        :type value: float
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ComponentValuesInitialiseSP, [field, variableType, fieldSetType, componentNumber, value])

    def CreateFinish(self):
        """Finishes the creation of a field identified by an object.

        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_CreateFinish, [field])

    def CreateStartInterface(self, fieldUserNumber, interface):
        """Starts the creation of a field on an interface identified by an object.

        :param fieldUserNumber: The user number of the field to start the creation of.
        :type fieldUserNumber: int
        :param interface: The interface to create the field on.
        :type interface: Interface
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_CreateStartInterface, [fieldUserNumber, interface, field])

    def CreateStart(self, fieldUserNumber, region):
        """Starts the creation of a field on a region identified by an object.

        :param fieldUserNumber: The user number of the field to start the creation of.
        :type fieldUserNumber: int
        :param region: The region to create the field on.
        :type region: Region
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_CreateStart, [fieldUserNumber, region, field])

    def DOFOrderTypeGet(self, variableType):
        """Returns the DOF Order type for a field variable for a field identified by an object.

        :param variableType: The variable type of the field to get the DOF order type for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :returns: DOFOrderType. The field variable DOF order type. Will be a value from the FieldDOFOrderTypes enum.
        :rtype: int
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_DOFOrderTypeGet, [field, variableType])

    def DOFOrderTypeSet(self, variableType, DOFOrderType):
        """Sets/changes the DOF Order type for a field variable for a field identified by an object.

        :param variableType: The variable type of the field to set the DOF order type for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param DOFOrderType: The field variable DOF order type to set. Must be a value from the FieldDOFOrderTypes enum.
        :type DOFOrderType: int
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_DOFOrderTypeSet, [field, variableType, DOFOrderType])

    def DataProjectionSet(self, dataProjection):
        """Sets/changes the data projection for a field identified by an object.

        :param dataProjection: The data projection for the field to set.
        :type dataProjection: DataProjection
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_DataProjectionSet, [field, dataProjection])

    def DataTypeGet(self, variableType):
        """Returns the data type for a field variable for a field identified by an object.

        :param variableType: The variable type of the field to get the data type for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :returns: dataType. The field variable data type. Will be a value from the FieldDataTypes enum.
        :rtype: int
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_DataTypeGet, [field, variableType])

    def DataTypeSet(self, variableType, dataType):
        """Sets/changes the data type for a field variable for a field identified by an object.

        :param variableType: The variable type of the field to set the data type for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param dataType: The field variable data type to set. Must be a value from the FieldDataTypes enum.
        :type dataType: int
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_DataTypeSet, [field, variableType, dataType])

    def DependentTypeGet(self):
        """Returns the dependent type for a field identified by an object.

        :returns: dependentType. The field dependent type. Will be a value from the FieldDependentTypes enum.
        :rtype: int
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_DependentTypeGet, [field])

    def DependentTypeSet(self, dependentType):
        """Sets/changes the dependent type for a field identified by an object.

        :param dependentType: The field dependent type to set. Must be a value from the FieldDependentTypes enum.
        :type dependentType: int
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_DependentTypeSet, [field, dependentType])

    def Destroy(self):
        """Destroys a field identified by an object.

        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_Destroy, [field])

    def DimensionGet(self, variableType):
        """Returns the dimension for a field identified by an object.

        :param variableType: The variable type of the field to get the dimension for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :returns: dimension. The field dimension. Will be a value from the FieldDimension enum.
        :rtype: int
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_DimensionGet, [field, variableType])

    def DimensionSet(self, variableType, dimension):
        """Sets/changes the dimension for a field identified by an object.

        :param variableType: The variable type of the field to get the dimension for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param dimension: The field dimension to set. Must be a value from the FieldDimension enum.
        :type dimension: int
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_DimensionSet, [field, variableType, dimension])

    def Finalise(self):
        """Finalises a cmfe_FieldType object.

        :rtype: None
        """

        cmfe_Field = self
        return _wrap_routine(_iron_python.cmfe_Field_Finalise, [cmfe_Field])

    def GeometricFieldGet(self, geometricField):
        """Returns the geometric field for a field identified by an object.

        :param geometricField: On return, the geometric field for the field.
        :type geometricField: Field
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_GeometricFieldGet, [field, geometricField])

    def GeometricFieldSet(self, geometricField):
        """Sets/changes the geometric field for a field identified by an object.

        :param geometricField: The geometric field for the field to set.
        :type geometricField: Field
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_GeometricFieldSet, [field, geometricField])

    def GeometricParametersElementLineLengthGet(self, elementNumber, elementLineNumber):
        """Gets the line length between nodes of a geometric field for a given element number and element basis line number by an object.

        :param elementNumber: The element to get the line length for
        :type elementNumber: int
        :param elementLineNumber: The element basis line to get the length for
        :type elementLineNumber: int
        :returns: lineLength. The line length of the chosen element line number
        :rtype: float
        """

        geometricField = self
        return _wrap_routine(_iron_python.cmfe_Field_GeometricParametersElementLineLengthGet, [geometricField, elementNumber, elementLineNumber])

    def GeometricParametersElementVolumeGet(self, elementNumber):
        """Gets the volume for a given element number by an object.

        :param elementNumber: The element to get the volume for
        :type elementNumber: int
        :returns: elementVolume. The volume of the chosen element
        :rtype: float
        """

        geometricField = self
        return _wrap_routine(_iron_python.cmfe_Field_GeometricParametersElementVolumeGet, [geometricField, elementNumber])

    def LabelGet(self):
        """Returns the character string label for a field identified by an object.

        :returns: label. The field label.
        :rtype: string
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_LabelGet, [field])

    def LabelSet(self, label):
        """Sets/changes the character string label for a field identified by an object.

        :param label: The field label to set.
        :type label: string
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_LabelSet, [field, label])

    def MeshDecompositionGet(self, meshDecomposition):
        """Returns the mesh decomposition for a field identified by an object.

        :param meshDecomposition: On return, the mesh decomposition for the field.
        :type meshDecomposition: Decomposition
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_MeshDecompositionGet, [field, meshDecomposition])

    def MeshDecompositionSet(self, meshDecomposition):
        """Sets/changes the mesh decomposition for a field identified by an object.

        :param meshDecomposition: The mesh decomposition for the field to set.
        :type meshDecomposition: Decomposition
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_MeshDecompositionSet, [field, meshDecomposition])

    def NumberOfComponentsGet(self, variableType):
        """Returns the number of components for a field variable for a field identified by an object.

        :param variableType: The variable type of the dependent field to get the number of components for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :returns: numberOfComponents. The number of components in the field variable.
        :rtype: int
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_NumberOfComponentsGet, [field, variableType])

    def NumberOfComponentsSet(self, variableType, numberOfComponents):
        """Sets/changes the number of components for a field variable for a field identified by an object.

        :param variableType: The variable type of the dependent field to set the number of components for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param numberOfComponents: The number of components in the field variable to set.
        :type numberOfComponents: int
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_NumberOfComponentsSet, [field, variableType, numberOfComponents])

    def NumberOfVariablesGet(self):
        """Returns the number of variables for a field identified by an object.

        :returns: numberOfVariables. The number of variables in the field.
        :rtype: int
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_NumberOfVariablesGet, [field])

    def NumberOfVariablesSet(self, numberOfVariables):
        """Sets/changes the number of variables for a field identified by an object.

        :param numberOfVariables: The number of variables in the field to set.
        :type numberOfVariables: int
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_NumberOfVariablesSet, [field, numberOfVariables])

    def ParameterSetAddConstantDP(self, variableType, fieldSetType, componentNumber, value):
        """Adds the given double precision value to the given parameter set for the constant of the field variable component for a field identified by an object.

        :param variableType: The variable type of the field to add the constant to the field parameter set for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to add the constant to the field parameter set for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param componentNumber: The component number of the field variable to add the constant to the field parameter set for.
        :type componentNumber: int
        :param value: The value to add to the field parameter set.
        :type value: float
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddConstantDP, [field, variableType, fieldSetType, componentNumber, value])

    def ParameterSetAddConstantIntg(self, variableType, fieldSetType, componentNumber, value):
        """Adds the given integer value to the given parameter set for the constant of the field variable component for a field identified by an object.

        :param variableType: The variable type of the field to add the constant to the field parameter set for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to add the constant to the field parameter set for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param componentNumber: The component number of the field variable to add the constant to the field parameter set for.
        :type componentNumber: int
        :param value: The value to add to the field parameter set.
        :type value: int
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddConstantIntg, [field, variableType, fieldSetType, componentNumber, value])

    def ParameterSetAddConstantL(self, variableType, fieldSetType, componentNumber, value):
        """Adds the given logical value to the given parameter set for the constant of the field variable component for a field identified by an object.

        :param variableType: The variable type of the field to add the constant to the field parameter set for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to add the constant to the field parameter set for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param componentNumber: The component number of the field variable to add the constant to the field parameter set for.
        :type componentNumber: int
        :param value: The value to add to the field parameter set.
        :type value: bool
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddConstantL, [field, variableType, fieldSetType, componentNumber, value])

    def ParameterSetAddConstantSP(self, variableType, fieldSetType, componentNumber, value):
        """Adds the given single precision value to the given parameter set for the constant of the field variable component for a field identified by an object.

        :param variableType: The variable type of the field to add the constant to the field parameter set for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to add the constant to the field parameter set for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param componentNumber: The component number of the field variable to add the constant to the field parameter set for.
        :type componentNumber: int
        :param value: The value to add to the field parameter set.
        :type value: float
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddConstantSP, [field, variableType, fieldSetType, componentNumber, value])

    def ParameterSetAddElementDP(self, variableType, fieldSetType, userElementNumber, componentNumber, value):
        """Adds the given double precision value to an element in the given parameter set for field variable component for a field identified by an object.

        :param variableType: The variable type of the field to add the value to the element in the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to add the value to the element. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param userElementNumber: The user element number to add the value to.
        :type userElementNumber: int
        :param componentNumber: The component number of the field variable to add the value to the element to in the field parameter set.
        :type componentNumber: int
        :param value: The value to add to the element in the field parameter set.
        :type value: float
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddElementDP, [field, variableType, fieldSetType, userElementNumber, componentNumber, value])

    def ParameterSetAddElementIntg(self, variableType, fieldSetType, userElementNumber, componentNumber, value):
        """Adds the given integer value to an element in the given parameter set for field variable component for a field identified by an object.

        :param variableType: The variable type of the field to add the value to the element in the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to add the value to the element. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param userElementNumber: The user element number to add the value to.
        :type userElementNumber: int
        :param componentNumber: The component number of the field variable to add the value to the element to in the field parameter set.
        :type componentNumber: int
        :param value: The value to add to the element in the field parameter set.
        :type value: int
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddElementIntg, [field, variableType, fieldSetType, userElementNumber, componentNumber, value])

    def ParameterSetAddElementL(self, variableType, fieldSetType, userElementNumber, componentNumber, value):
        """Adds the given logical value to an element in the given parameter set for field variable component for a field identified by an object.

        :param variableType: The variable type of the field to add the value to the element in the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to add the value to the element. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param userElementNumber: The user element number to add the value to.
        :type userElementNumber: int
        :param componentNumber: The component number of the field variable to add the value to the element to in the field parameter set.
        :type componentNumber: int
        :param value: The value to add to the element in the field parameter set.
        :type value: bool
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddElementL, [field, variableType, fieldSetType, userElementNumber, componentNumber, value])

    def ParameterSetAddElementSP(self, variableType, fieldSetType, userElementNumber, componentNumber, value):
        """Adds the given single precision value to an element in the given parameter set for field variable component for a field identified by an object.

        :param variableType: The variable type of the field to add the value to the element in the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to add the value to the element. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param userElementNumber: The user element number to add the value to.
        :type userElementNumber: int
        :param componentNumber: The component number of the field variable to add the value to the element to in the field parameter set.
        :type componentNumber: int
        :param value: The value to add to the element in the field parameter set.
        :type value: float
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddElementSP, [field, variableType, fieldSetType, userElementNumber, componentNumber, value])

    def ParameterSetAddNodeDP(self, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value):
        """Adds the given double precision value to an node in the given parameter set for field variable component for a field identified by an object.

        :param variableType: The variable type of the field to add the value to the node in the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to add the value to the node. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param versionNumber: The node derivative version number of the node to add the value to.
        :type versionNumber: int
        :param derivativeNumber: The node derivative number of the node to add the value to.
        :type derivativeNumber: int
        :param userNodeNumber: The user node number to add the value to.
        :type userNodeNumber: int
        :param componentNumber: The component number of the field variable to add the value to the node to in the field parameter set.
        :type componentNumber: int
        :param value: The value to add to the node in the field parameter set.
        :type value: float
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddNodeDP, [field, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value])

    def ParameterSetAddNodeIntg(self, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value):
        """Adds the given integer value to an node in the given parameter set for field variable component for a field identified by an object.

        :param variableType: The variable type of the field to add the value to the node in the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to add the value to the node. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param versionNumber: The node derivative version number of the node to add the value to.
        :type versionNumber: int
        :param derivativeNumber: The node derivative number of the node to add the value to.
        :type derivativeNumber: int
        :param userNodeNumber: The user node number to add the value to.
        :type userNodeNumber: int
        :param componentNumber: The component number of the field variable to add the value to the node to in the field parameter set.
        :type componentNumber: int
        :param value: The value to add to the node in the field parameter set.
        :type value: int
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddNodeIntg, [field, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value])

    def ParameterSetAddNodeL(self, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value):
        """Adds the given logical value to an node in the given parameter set for field variable component for a field identified by an object.

        :param variableType: The variable type of the field to add the value to the node in the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to add the value to the node. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param versionNumber: The node derivative version number of the node to add the value to.
        :type versionNumber: int
        :param derivativeNumber: The node derivative number of the node to add the value to.
        :type derivativeNumber: int
        :param userNodeNumber: The user node number to add the value to.
        :type userNodeNumber: int
        :param componentNumber: The component number of the field variable to add the value to the node to in the field parameter set.
        :type componentNumber: int
        :param value: The value to add to the node in the field parameter set.
        :type value: bool
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddNodeL, [field, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value])

    def ParameterSetAddNodeSP(self, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value):
        """Adds the given single precision value to an node in the given parameter set for field variable component for a field identified by an object.

        :param variableType: The variable type of the field to add the value to the node in the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to add the value to the node. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param versionNumber: The node derivative version number of the node to add the value to.
        :type versionNumber: int
        :param derivativeNumber: The node derivative number of the node to add the value to.
        :type derivativeNumber: int
        :param userNodeNumber: The user node number to add the value to.
        :type userNodeNumber: int
        :param componentNumber: The component number of the field variable to add the value to the node to in the field parameter set.
        :type componentNumber: int
        :param value: The value to add to the node in the field parameter set.
        :type value: float
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddNodeSP, [field, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value])

    def ParameterSetCreate(self, variableType, fieldSetType):
        """Creates a new parameter set of type set type for a field variable for a field identified by an object.

        :param variableType: The variable type of the field to create the parameter set on. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to create. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetCreate, [field, variableType, fieldSetType])

    def ParameterSetDataGetDP(self, variableType, fieldSetType):
        """Returns a pointer to the specified field parameter set local double precision data array for a field identified by an object. The pointer must be restored with a call to OpenCMISS::Iron::cmfe_Field_ParameterSetDataRestore call. Note: the values can be used for read operations but a field parameter set update or add calls must be used to change any values.

        :param variableType: The variable type of the field to get the parameter set data for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the parameter set data to get. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param parametersSize: Size of parameters to allocate.
        :returns: parameters. A pointer to the parameter set data.
        :rtype: Array of floats
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetDataGetDP, [field, variableType, fieldSetType])

    def ParameterSetDataGetIntg(self, variableType, fieldSetType):
        """Returns a pointer to the specified field parameter set local integer data array for a field identified by an object. The pointer must be restored with a call to OpenCMISS::Iron::cmfe_Field_ParameterSetDataRestore call. Note: the values can be used for read operations but a field parameter set update or add calls must be used to change any values.

        :param variableType: The variable type of the field to get the parameter set data for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the parameter set data to get. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param parametersSize: Size of parameters to allocate.
        :returns: parameters. A pointer to the parameter set data.
        :rtype: Array of ints
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetDataGetIntg, [field, variableType, fieldSetType])

    def ParameterSetDataGetL(self, variableType, fieldSetType):
        """Returns a pointer to the specified field parameter set local logical data array for a field identified by an object. The pointer must be restored with a call to OpenCMISS::Iron::cmfe_Field_ParameterSetDataRestore call. Note: the values can be used for read operations but a field parameter set update or add calls must be used to change any values.

        :param variableType: The variable type of the field to get the parameter set data for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the parameter set data to get. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param parametersSize: Size of parameters to allocate.
        :returns: parameters. A pointer to the parameter set data.
        :rtype: Array of bools
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetDataGetL, [field, variableType, fieldSetType])

    def ParameterSetDataGetSP(self, variableType, fieldSetType):
        """Returns a pointer to the specified field parameter set local single precision data array for a field identified by an object. The pointer must be restored with a call to OpenCMISS::Iron::cmfe_Field_ParameterSetDataRestore call. Note: the values can be used for read operations but a field parameter set update or add calls must be used to change any values.

        :param variableType: The variable type of the field to get the parameter set data for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the parameter set data to get. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param parametersSize: Size of parameters to allocate.
        :returns: parameters. A pointer to the parameter set data.
        :rtype: Array of floats
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetDataGetSP, [field, variableType, fieldSetType])

    def ParameterSetDataRestoreDP(self, variableType, fieldSetType, parameters):
        """Restores the specified field variable parameter set local double precision array that was obtained with an OpenCMISS::Iron::cmfe_Field_ParameterSetDataGet call for a field that is specified with an object.

        :param variableType: The variable type of the field to restore the parameter set data for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the parameter set data to restore. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param parameters: A pointer to the parameter set data to restore. On return this pointer is null.
        :type parameters: Array of floats
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetDataRestoreDP, [field, variableType, fieldSetType, parameters])

    def ParameterSetDataRestoreIntg(self, variableType, fieldSetType, parameters):
        """Restores the specified field variable parameter set local integer array that was obtained with an OpenCMISS::Iron::cmfe_Field_ParameterSetDataGet call for a field that is specified with an object.

        :param variableType: The variable type of the field to restore the parameter set data for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the parameter set data to restore. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param parameters: A pointer to the parameter set data to restore. On return this pointer is null.
        :type parameters: Array of ints
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetDataRestoreIntg, [field, variableType, fieldSetType, parameters])

    def ParameterSetDataRestoreL(self, variableType, fieldSetType, parameters):
        """Restores the specified field variable parameter set local logical array that was obtained with an OpenCMISS::Iron::cmfe_Field_ParameterSetDataGet call for a field that is specified with an object.

        :param variableType: The variable type of the field to restore the parameter set data for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the parameter set data to restore. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param parameters: A pointer to the parameter set data to restore. On return this pointer is null.
        :type parameters: Array of bools
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetDataRestoreL, [field, variableType, fieldSetType, parameters])

    def ParameterSetDataRestoreSP(self, variableType, fieldSetType, parameters):
        """Restores the specified field variable parameter set local single precision array that was obtained with an OpenCMISS::Iron::cmfe_Field_ParameterSetDataGet call for a field that is specified with an object.

        :param variableType: The variable type of the field to restore the parameter set data for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the parameter set data to restore. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param parameters: A pointer to the parameter set data to restore.
        :type parameters: Array of floats
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetDataRestoreSP, [field, variableType, fieldSetType, parameters])

    def ParameterSetDestroy(self, variableType, fieldSetType):
        """Destroys the specified parameter set type for a field variable for a field identified by an object.

        :param variableType: The variable type of the field to destroy the parameter set for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to destroy. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetDestroy, [field, variableType, fieldSetType])

    def ParameterSetGetConstantDP(self, variableType, fieldSetType, componentNumber):
        """Returns from the given parameter set a double precision value for the specified constant of a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to get the constant value from the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to get the constant value from. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param componentNumber: The component number of the field variable to get the constant value from the field parameter set.
        :type componentNumber: int
        :returns: value. The value from the field parameter set.
        :rtype: float
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetConstantDP, [field, variableType, fieldSetType, componentNumber])

    def ParameterSetGetConstantIntg(self, variableType, fieldSetType, componentNumber):
        """Returns from the given parameter set an integer value for the specified constant of a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to get the constant value from the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to get the constant value from. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param componentNumber: The component number of the field variable to get the constant value from the field parameter set.
        :type componentNumber: int
        :returns: value. The value from the field parameter set.
        :rtype: int
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetConstantIntg, [field, variableType, fieldSetType, componentNumber])

    def ParameterSetGetConstantL(self, variableType, fieldSetType, componentNumber):
        """Returns from the given parameter set a logical value for the specified constant of a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to get the constant value from the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to get the constant value from. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param componentNumber: The component number of the field variable to get the constant value from the field parameter set.
        :type componentNumber: int
        :returns: value. The value from the field parameter set.
        :rtype: bool
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetConstantL, [field, variableType, fieldSetType, componentNumber])

    def ParameterSetGetConstantSP(self, variableType, fieldSetType, componentNumber):
        """Returns from the given parameter set a single precision value for the specified constant of a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to get the constant value from the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to get the constant value from. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param componentNumber: The component number of the field variable to get the constant value from the field parameter set.
        :type componentNumber: int
        :returns: value. The value from the field parameter set.
        :rtype: float
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetConstantSP, [field, variableType, fieldSetType, componentNumber])

    def ParameterSetGetDataPointDP(self, variableType, fieldSetType, userDataPointNumber, componentNumber):
        """Returns from the given parameter set a double precision value for the specified constant of a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to get the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to get the data point value from. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param userDataPointNumber: The user data point number to get the value for
        :type userDataPointNumber: int
        :param componentNumber: The component number of the field variable to get the data point value from the field parameter set.
        :type componentNumber: int
        :returns: value. The value from the field parameter set.
        :rtype: float
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetDataPointDP, [field, variableType, fieldSetType, userDataPointNumber, componentNumber])

    def ParameterSetGetDataPointIntg(self, variableType, fieldSetType, userDataPointNumber, componentNumber):
        """Returns from the given parameter set a integer value for the specified constant of a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to get the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to get the data point value from. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param userDataPointNumber: The user data point number to get the value for
        :type userDataPointNumber: int
        :param componentNumber: The component number of the field variable to get the data point value from the field parameter set.
        :type componentNumber: int
        :returns: value. The value from the field parameter set.
        :rtype: int
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetDataPointIntg, [field, variableType, fieldSetType, userDataPointNumber, componentNumber])

    def ParameterSetGetDataPointL(self, variableType, fieldSetType, userDataPointNumber, componentNumber):
        """Returns from the given parameter set a logical value for the specified constant of a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to get the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to get the data point value from. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param userDataPointNumber: The user data point number to get the value for
        :type userDataPointNumber: int
        :param componentNumber: The component number of the field variable to get the data point value from the field parameter set.
        :type componentNumber: int
        :returns: value. The value from the field parameter set.
        :rtype: bool
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetDataPointL, [field, variableType, fieldSetType, userDataPointNumber, componentNumber])

    def ParameterSetGetDataPointSP(self, variableType, fieldSetType, userDataPointNumber, componentNumber):
        """Returns from the given parameter set a single precision value for the specified constant of a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to get the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to get the data point value from. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param userDataPointNumber: The user data point number to get the value for
        :type userDataPointNumber: int
        :param componentNumber: The component number of the field variable to get the data point value from the field parameter set.
        :type componentNumber: int
        :returns: value. The value from the field parameter set.
        :rtype: float
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetDataPointSP, [field, variableType, fieldSetType, userDataPointNumber, componentNumber])

    def ParameterSetGetElementDP(self, variableType, fieldSetType, userElementNumber, componentNumber):
        """Returns from the given parameter set a double precision value for the specified element of a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to get the element value from the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to get the element value from. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param userElementNumber: The user element number to get the value from the field parameter set.
        :type userElementNumber: int
        :param componentNumber: The component number of the field variable to get the element value from the field parameter set.
        :type componentNumber: int
        :returns: value. The value from the field parameter set.
        :rtype: float
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetElementDP, [field, variableType, fieldSetType, userElementNumber, componentNumber])

    def ParameterSetGetElementIntg(self, variableType, fieldSetType, userElementNumber, componentNumber):
        """Returns from the given parameter set an integer value for the specified element of a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to get the element value from the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to get the element value from. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param userElementNumber: The user element number to get the value from the field parameter set.
        :type userElementNumber: int
        :param componentNumber: The component number of the field variable to get the element value from the field parameter set.
        :type componentNumber: int
        :returns: value. The value from the field parameter set.
        :rtype: int
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetElementIntg, [field, variableType, fieldSetType, userElementNumber, componentNumber])

    def ParameterSetGetElementL(self, variableType, fieldSetType, userElementNumber, componentNumber):
        """Returns from the given parameter set a logical value for the specified element of a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to get the element value from the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to get the element value from. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param userElementNumber: The user element number to get the value from the field parameter set.
        :type userElementNumber: int
        :param componentNumber: The component number of the field variable to get the element value from the field parameter set.
        :type componentNumber: int
        :returns: value. The value from the field parameter set.
        :rtype: bool
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetElementL, [field, variableType, fieldSetType, userElementNumber, componentNumber])

    def ParameterSetGetElementSP(self, variableType, fieldSetType, userElementNumber, componentNumber):
        """Returns from the given parameter set a single precision value for the specified element of a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to get the element value from the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to get the element value from. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param userElementNumber: The user element number to get the value from the field parameter set.
        :type userElementNumber: int
        :param componentNumber: The component number of the field variable to get the element value from the field parameter set.
        :type componentNumber: int
        :returns: value. The value from the field parameter set.
        :rtype: float
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetElementSP, [field, variableType, fieldSetType, userElementNumber, componentNumber])

    def ParameterSetGetGaussPointDP(self, variableType, fieldSetType, gaussPointNumber, userElementNumber, componentNumber):
        """Returns from the given parameter set a double precision value for the specified element of a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to get the element value from the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to get the element value from. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param gaussPointNumber: The gauss point number number to get the value from the field parameter set.
        :type gaussPointNumber: int
        :param userElementNumber: The user element number to get the value from the field parameter set.
        :type userElementNumber: int
        :param componentNumber: The component number of the field variable to get the element value from the field parameter set.
        :type componentNumber: int
        :returns: VALUE. The value from the field parameter set.
        :rtype: float
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetGaussPointDP, [field, variableType, fieldSetType, gaussPointNumber, userElementNumber, componentNumber])

    def ParameterSetGetNodeDP(self, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber):
        """Returns from the given parameter set a double precision value for the specified node and derivative of a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to get the nodal value from the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to get the nodal value from. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param versionNumber: The derivative version number to get the value from the field parameter set.
        :type versionNumber: int
        :param derivativeNumber: The derivative number to get the value from the field parameter set.
        :type derivativeNumber: int
        :param userNodeNumber: The user node number to get the value from the field parameter set.
        :type userNodeNumber: int
        :param componentNumber: The component number of the field variable to get the nodal value from the field parameter set.
        :type componentNumber: int
        :returns: value. The value from the field parameter set.
        :rtype: float
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetNodeDP, [field, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber])

    def ParameterSetGetNodeIntg(self, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber):
        """Returns from the given parameter set an integer value for the specified node and derivative of a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to get the nodal value from the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to get the nodal value from. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param versionNumber: The derivative version number to get the value from the field parameter set.
        :type versionNumber: int
        :param derivativeNumber: The derivative number to get the value from the field parameter set.
        :type derivativeNumber: int
        :param userNodeNumber: The user node number to get the value from the field parameter set.
        :type userNodeNumber: int
        :param componentNumber: The component number of the field variable to get the nodal value from the field parameter set.
        :type componentNumber: int
        :returns: value. The value from the field parameter set.
        :rtype: int
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetNodeIntg, [field, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber])

    def ParameterSetGetNodeL(self, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber):
        """Returns from the given parameter set a logical value for the specified node and derivative of a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to get the nodal value from the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to get the nodal value from. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param versionNumber: The derivative version number to get the value from the field parameter set.
        :type versionNumber: int
        :param derivativeNumber: The derivative number to get the value from the field parameter set.
        :type derivativeNumber: int
        :param userNodeNumber: The user node number to get the value from the field parameter set.
        :type userNodeNumber: int
        :param componentNumber: The component number of the field variable to get the nodal value from the field parameter set.
        :type componentNumber: int
        :returns: value. The value from the field parameter set.
        :rtype: bool
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetNodeL, [field, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber])

    def ParameterSetGetNodeSP(self, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber):
        """Returns from the given parameter set a single precision value for the specified node and derivative of a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to get the nodal value from the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to get the nodal value from. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param versionNumber: The derivative version number to get the value from the field parameter set.
        :type versionNumber: int
        :param derivativeNumber: The derivative number to get the value from the field parameter set.
        :type derivativeNumber: int
        :param userNodeNumber: The user node number to get the value from the field parameter set.
        :type userNodeNumber: int
        :param componentNumber: The component number of the field variable to get the nodal value from the field parameter set.
        :type componentNumber: int
        :returns: value. The value from the field parameter set.
        :rtype: float
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetNodeSP, [field, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber])

    def ParameterSetInterpolateMultipleGaussDP(self, variableType, fieldSetType, derivativeNumber, userElementNumber, quadratureScheme, GaussPoints, valuesSizes):
        """Interpolates the given parameter set at a specified set of Gauss points for the specified element and derviative and returns double precision values for a field identified by an object. If no Gauss points are specified then all Gauss points are interpolated.

        :param variableType: The variable type of the field to update the constant value for the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update the constant value for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param derivativeNumber: The derivative number of the field to interpolate.
        :type derivativeNumber: int
        :param userElementNumber: The user element number of the field variable component to update for the field parameter set.
        :type userElementNumber: int
        :param quadratureScheme: The quadrature scheme to interpolate the field for.
        :type quadratureScheme: int
        :param GaussPoints: The Gauss points to interpolate the field at.
        :type GaussPoints: Array of ints
        :param valuesSizes: Tuple of dimensions of values to allocate, with length 2.
        :returns: values. The interpolated values.
        :rtype: 2d array of floats
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetInterpolateMultipleGaussDP, [field, variableType, fieldSetType, derivativeNumber, userElementNumber, quadratureScheme, GaussPoints, valuesSizes])

    def ParameterSetInterpolateMultipleXiDP(self, variableType, fieldSetType, derivativeNumber, userElementNumber, xi, valuesSizes):
        """Interpolates the given parameter set at a specified set of xi locations for the specified element and derviative and returns double precision values for a field identified by an object.

        :param variableType: The variable type of the field to interpolate. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to interpolate. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param derivativeNumber: The derivative number of the field to interpolate.
        :type derivativeNumber: int
        :param userElementNumber: The user element number of the field to interpolate.
        :type userElementNumber: int
        :param xi: The sets of element xi to interpolate the field at.
        :type xi: 2d array of floats
        :param valuesSizes: Tuple of dimensions of values to allocate, with length 2.
        :returns: values. The interpolated values.
        :rtype: 2d array of floats
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetInterpolateMultipleXiDP, [field, variableType, fieldSetType, derivativeNumber, userElementNumber, xi, valuesSizes])

    def ParameterSetInterpolateSingleGaussDP(self, variableType, fieldSetType, derivativeNumber, userElementNumber, quadratureScheme, GaussPoint, valuesSize):
        """Interpolates the given parameter set at a specified Gauss point for the specified element and derviative and returns double precision values for a field identified by an object.

        :param variableType: The variable type of the field to update the constant value for the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update the constant value for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param derivativeNumber: The derivative number of the field to interpolate.
        :type derivativeNumber: int
        :param userElementNumber: The user element number of the field variable component to update for the field parameter set.
        :type userElementNumber: int
        :param quadratureScheme: The quadrature scheme to interpolate the field for.
        :type quadratureScheme: int
        :param GaussPoint: The Gauss point to interpolate the field at.
        :type GaussPoint: int
        :param valuesSize: Size of values to allocate.
        :returns: values. The interpolated values.
        :rtype: Array of floats
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetInterpolateSingleGaussDP, [field, variableType, fieldSetType, derivativeNumber, userElementNumber, quadratureScheme, GaussPoint, valuesSize])

    def ParameterSetInterpolateSingleXiDP(self, variableType, fieldSetType, derivativeNumber, userElementNumber, xi, valuesSize):
        """Interpolates the given parameter set at a specified xi location for the specified element and derviative and returns double precision values for a field identified by an object.

        :param variableType: The variable type of the field to interpolate. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to interpolate. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param derivativeNumber: The derivative number of the field to interpolate.
        :type derivativeNumber: int
        :param userElementNumber: The user element number of the field to interpolate.
        :type userElementNumber: int
        :param xi: The element xi to interpolate the field at.
        :type xi: Array of floats
        :param valuesSize: Size of values to allocate.
        :returns: values. The interpolated values.
        :rtype: Array of floats
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetInterpolateSingleXiDP, [field, variableType, fieldSetType, derivativeNumber, userElementNumber, xi, valuesSize])

    def ParameterSetNodeNumberOfScaleFactorDofsGet(self, variableType, meshComponentNumber):
        """Gets the number of scale factor dofs, identified by an object.

        :param variableType: The field variable type to get the number of scale factor dofs for
        :type variableType: int
        :param meshComponentNumber: The mesh component number of the field to get the number of scale factor dofs for
        :type meshComponentNumber: int
        :returns: numberOfScaleFactorsDofs. The number of scale factor dofs
        :rtype: int
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetNodeNumberOfScaleFactorDofsGet, [field, variableType, meshComponentNumber])

    def ParameterSetNodeScaleFactorGet(self, variableType, versionNumber, derivativeNumber, nodeUserNumber, componentNumber):
        """Gets the scale factor for a particular node identified by an object.

        :param variableType: The field variable type to get the scale factor for
        :type variableType: int
        :param versionNumber: The user number of the node derivative version to get the scale factor for
        :type versionNumber: int
        :param derivativeNumber: The user number of the node derivative to get the scale factor for
        :type derivativeNumber: int
        :param nodeUserNumber: The user number of the node to get the scale factor for
        :type nodeUserNumber: int
        :param componentNumber: The component number of the field to get the scale factor for
        :type componentNumber: int
        :returns: scaleFactor. The scale factor of the specified node
        :rtype: float
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetNodeScaleFactorGet, [field, variableType, versionNumber, derivativeNumber, nodeUserNumber, componentNumber])

    def ParameterSetNodeScaleFactorSet(self, variableType, versionNumber, derivativeNumber, nodeUserNumber, componentNumber, scaleFactor):
        """Sets the scale factor for a particular node identified by an object.

        :param variableType: The field variable type to set the scale factor for
        :type variableType: int
        :param versionNumber: The user number of the node derivative version to set the scale factor for
        :type versionNumber: int
        :param derivativeNumber: The user number of the node derivative to set the scale factor for
        :type derivativeNumber: int
        :param nodeUserNumber: The user number of the node to set the scale factor for
        :type nodeUserNumber: int
        :param componentNumber: The component number of the field to set the scale factor for
        :type componentNumber: int
        :param scaleFactor: The scale factor of the specified node
        :type scaleFactor: float
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetNodeScaleFactorSet, [field, variableType, versionNumber, derivativeNumber, nodeUserNumber, componentNumber, scaleFactor])

    def ParameterSetNodeScaleFactorsGet(self, variableType, meshComponentNumber, scaleFactorsSize):
        """Gets the scale factors for all nodes identified by an object.

        :param variableType: The field variable type to get the scale factor for
        :type variableType: int
        :param meshComponentNumber: The mesh omponent number of the field to set the scale factor for
        :type meshComponentNumber: int
        :param scaleFactorsSize: Size of scaleFactors to allocate.
        :returns: scaleFactors. The scale factors
        :rtype: Array of floats
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetNodeScaleFactorsGet, [field, variableType, meshComponentNumber, scaleFactorsSize])

    def ParameterSetNodeScaleFactorsSet(self, variableType, meshComponentNumber, scaleFactors):
        """Sets the scale factors for all nodes identified by an object.

        :param variableType: The field variable type to set the scale factor for
        :type variableType: int
        :param meshComponentNumber: The component number of the field to set the scale factor for
        :type meshComponentNumber: int
        :param scaleFactors: The scale factors
        :type scaleFactors: Array of floats
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetNodeScaleFactorsSet, [field, variableType, meshComponentNumber, scaleFactors])

    def ParameterSetUpdateConstantDP(self, variableType, fieldSetType, componentNumber, value):
        """Updates the given parameter set with the given double precision value for the constant of the field variable component for a field identified by an object.

        :param variableType: The variable type of the field to update the constant value for the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update the constant value for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param componentNumber: The component number of the field variable to update the constant value for the field parameter set.
        :type componentNumber: int
        :param value: The value for the field parameter set to update.
        :type value: float
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateConstantDP, [field, variableType, fieldSetType, componentNumber, value])

    def ParameterSetUpdateConstantIntg(self, variableType, fieldSetType, componentNumber, value):
        """Updates the given parameter set with the given integer value for the constant of the field variable component for a field identified by an object.

        :param variableType: The variable type of the field to update the constant value for the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update the constant value for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param componentNumber: The component number of the field variable to update the constant value for the field parameter set.
        :type componentNumber: int
        :param value: The value for the field parameter set to update.
        :type value: int
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateConstantIntg, [field, variableType, fieldSetType, componentNumber, value])

    def ParameterSetUpdateConstantL(self, variableType, fieldSetType, componentNumber, value):
        """Updates the given parameter set with the given logical value for the constant of the field variable component for a field identified by an object.

        :param variableType: The variable type of the field to update the constant value for the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update the constant value for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param componentNumber: The component number of the field variable to update the constant value for the field parameter set.
        :type componentNumber: int
        :param value: The value for the field parameter set to update.
        :type value: bool
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateConstantL, [field, variableType, fieldSetType, componentNumber, value])

    def ParameterSetUpdateConstantSP(self, variableType, fieldSetType, componentNumber, value):
        """Updates the given parameter set with the given single precision value for the constant of the field variable component for a field identified by an object.

        :param variableType: The variable type of the field to update the constant value for the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update the constant value for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param componentNumber: The component number of the field variable to update the constant value for the field parameter set.
        :type componentNumber: int
        :param value: The value for the field parameter set to update.
        :type value: float
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateConstantSP, [field, variableType, fieldSetType, componentNumber, value])

    def ParameterSetUpdateDataPointDP(self, variableType, fieldSetType, userDataPointNumber, componentNumber, value):
        """Update the given parameter set a double precision value for the specified constant of a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to update the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update the data point value from. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param userDataPointNumber: The user data point number to update the value for
        :type userDataPointNumber: int
        :param componentNumber: The component number of the field variable to update the data point value from the field parameter set.
        :type componentNumber: int
        :param value: The value for the field parameter set to update
        :type value: float
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateDataPointDP, [field, variableType, fieldSetType, userDataPointNumber, componentNumber, value])

    def ParameterSetUpdateDataPointIntg(self, variableType, fieldSetType, userDataPointNumber, componentNumber, value):
        """Update the given parameter set a integer value for the specified constant of a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to update the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update the data point value from. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param userDataPointNumber: The user data point number to update the value for
        :type userDataPointNumber: int
        :param componentNumber: The component number of the field variable to update the data point value from the field parameter set.
        :type componentNumber: int
        :param value: The value for the field parameter set to update
        :type value: int
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateDataPointIntg, [field, variableType, fieldSetType, userDataPointNumber, componentNumber, value])

    def ParameterSetUpdateDataPointL(self, variableType, fieldSetType, userDataPointNumber, componentNumber, value):
        """Update the given parameter set a logical value for the specified constant of a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to update the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update the data point value from. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param userDataPointNumber: The user data point number to update the value for
        :type userDataPointNumber: int
        :param componentNumber: The component number of the field variable to update the data point value from the field parameter set.
        :type componentNumber: int
        :param value: The value for the field parameter set to update
        :type value: bool
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateDataPointL, [field, variableType, fieldSetType, userDataPointNumber, componentNumber, value])

    def ParameterSetUpdateDataPointSP(self, variableType, fieldSetType, userDataPointNumber, componentNumber, value):
        """Update the given parameter set a single precision value for the specified constant of a field variable component for a field identified by an object.

        :param variableType: The variable type of the field to update the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update the data point value from. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param userDataPointNumber: The user data point number to update the value for
        :type userDataPointNumber: int
        :param componentNumber: The component number of the field variable to update the data point value from the field parameter set.
        :type componentNumber: int
        :param value: The value for the field parameter set to update
        :type value: float
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateDataPointSP, [field, variableType, fieldSetType, userDataPointNumber, componentNumber, value])

    def ParameterSetUpdateElementDP(self, variableType, fieldSetType, userElementNumber, componentNumber, value):
        """Updates the given parameter set with the given double precision value for the element of the field variable component for a field identified by an object.

        :param variableType: The variable type of the field to update the constant value for the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update the constant value for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param userElementNumber: The user element number of the field variable component to update for the field parameter set.
        :type userElementNumber: int
        :param componentNumber: The component number of the field variable to update the constant value for the field parameter set.
        :type componentNumber: int
        :param value: The value for the field parameter set to update.
        :type value: float
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateElementDP, [field, variableType, fieldSetType, userElementNumber, componentNumber, value])

    def ParameterSetUpdateElementDataPointDP(self, variableType, fieldSetType, elementNumber, dataPointIndex, componentNumber, value):
        """Updates the given parameter set with the given double precision value for the element data point of the field variable component for a field identified by an object.

        :param variableType: The variable type of the field to update the constant value for the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update the constant value for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param elementNumber: The user element number to update the data point for.
        :type elementNumber: int
        :param dataPointIndex: The index of the data point for the data points projected on this element.
        :type dataPointIndex: int
        :param componentNumber: The component number of the field variable to update the constant value for the field parameter set.
        :type componentNumber: int
        :param value: The value for the field parameter set to update.
        :type value: float
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateElementDataPointDP, [field, variableType, fieldSetType, elementNumber, dataPointIndex, componentNumber, value])

    def ParameterSetUpdateElementIntg(self, variableType, fieldSetType, userElementNumber, componentNumber, value):
        """Updates the given parameter set with the given integer value for the element of the field variable component for a field identified by an object.

        :param variableType: The variable type of the field to update the constant value for the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update the constant value for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param userElementNumber: The user element number of the field variable component to update for the field parameter set.
        :type userElementNumber: int
        :param componentNumber: The component number of the field variable to update the constant value for the field parameter set.
        :type componentNumber: int
        :param value: The value for the field parameter set to update.
        :type value: int
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateElementIntg, [field, variableType, fieldSetType, userElementNumber, componentNumber, value])

    def ParameterSetUpdateElementL(self, variableType, fieldSetType, userElementNumber, componentNumber, value):
        """Updates the given parameter set with the given logical value for the element of the field variable component for a field identified by an object.

        :param variableType: The variable type of the field to update the constant value for the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update the constant value for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param userElementNumber: The user element number of the field variable component to update for the field parameter set.
        :type userElementNumber: int
        :param componentNumber: The component number of the field variable to update the constant value for the field parameter set.
        :type componentNumber: int
        :param value: The value for the field parameter set to update.
        :type value: bool
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateElementL, [field, variableType, fieldSetType, userElementNumber, componentNumber, value])

    def ParameterSetUpdateElementSP(self, variableType, fieldSetType, userElementNumber, componentNumber, value):
        """Updates the given parameter set with the given single precision value for the element of the field variable component for a field identified by an object.

        :param variableType: The variable type of the field to update the constant value for the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update the constant value for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param userElementNumber: The user element number of the field variable component to update for the field parameter set.
        :type userElementNumber: int
        :param componentNumber: The component number of the field variable to update the constant value for the field parameter set.
        :type componentNumber: int
        :param value: The value for the field parameter set to update.
        :type value: float
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateElementSP, [field, variableType, fieldSetType, userElementNumber, componentNumber, value])

    def ParameterSetUpdateFinish(self, variableType, fieldSetType):
        """Finishes the parameter set update for a field variable for a field identified by an object.

        :param variableType: The variable type of the field to finish the parameter set update for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type to finish the update for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateFinish, [field, variableType, fieldSetType])

    def ParameterSetUpdateGaussPointDP(self, variableType, fieldSetType, gaussPointNumber, userElementNumber, componentNumber, value):
        """Updates the given parameter set with the given double precision value for the element Gauss point of the field variable component for a field identified by an object.

        :param variableType: The variable type of the field to update the Gauss point value for the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update the Gauss point value for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param gaussPointNumber: The user element number of the field variable component to update for the field parameter set.
        :type gaussPointNumber: int
        :param userElementNumber: The user element number of the field variable component to update for the field parameter set.
        :type userElementNumber: int
        :param componentNumber: The component number of the field variable to update the Gauss point value for the field parameter set.
        :type componentNumber: int
        :param value: The value for the field parameter set to update.
        :type value: float
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateGaussPointDP, [field, variableType, fieldSetType, gaussPointNumber, userElementNumber, componentNumber, value])

    def ParameterSetUpdateGaussPointIntg(self, variableType, fieldSetType, gaussPointNumber, userElementNumber, componentNumber, value):
        """Updates the given parameter set with the given integer value for the element Gauss point of the field variable component for a field identified by an object.

        :param variableType: The variable type of the field to update the Gauss point value for the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update the Gauss point value for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param gaussPointNumber: The user element number of the field variable component to update for the field parameter set.
        :type gaussPointNumber: int
        :param userElementNumber: The user element number of the field variable component to update for the field parameter set.
        :type userElementNumber: int
        :param componentNumber: The component number of the field variable to update the Gauss point value for the field parameter set.
        :type componentNumber: int
        :param value: The value for the field parameter set to update.
        :type value: int
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateGaussPointIntg, [field, variableType, fieldSetType, gaussPointNumber, userElementNumber, componentNumber, value])

    def ParameterSetUpdateGaussPointL(self, variableType, fieldSetType, gaussPointNumber, userElementNumber, componentNumber, value):
        """Updates the given parameter set with the given logical value for the element Gauss point of the field variable component for a field identified by an object.

        :param variableType: The variable type of the field to update the Gauss point value for the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update the Gauss point value for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param gaussPointNumber: The user element number of the field variable component to update for the field parameter set.
        :type gaussPointNumber: int
        :param userElementNumber: The user element number of the field variable component to update for the field parameter set.
        :type userElementNumber: int
        :param componentNumber: The component number of the field variable to update the Gauss point value for the field parameter set.
        :type componentNumber: int
        :param value: The value for the field parameter set to update.
        :type value: bool
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateGaussPointL, [field, variableType, fieldSetType, gaussPointNumber, userElementNumber, componentNumber, value])

    def ParameterSetUpdateGaussPointSP(self, variableType, fieldSetType, gaussPointNumber, userElementNumber, componentNumber, value):
        """Updates the given parameter set with the given single precision value for the element Gauss point of the field variable component for a field identified by an object.

        :param variableType: The variable type of the field to update the Gauss point value for the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update the Gauss point value for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param gaussPointNumber: The user element number of the field variable component to update for the field parameter set.
        :type gaussPointNumber: int
        :param userElementNumber: The user element number of the field variable component to update for the field parameter set.
        :type userElementNumber: int
        :param componentNumber: The component number of the field variable to update the Gauss point value for the field parameter set.
        :type componentNumber: int
        :param value: The value for the field parameter set to update.
        :type value: float
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateGaussPointSP, [field, variableType, fieldSetType, gaussPointNumber, userElementNumber, componentNumber, value])

    def ParameterSetUpdateLocalDofsDP(self, variableType, fieldSetType, values):
        """Updates the given parameter set with the given values for all local dofs of the field variable identified by an object..

        :param variableType: The variable type of the field to update values for the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update values for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param values: The values to update the field parameter set to.
        :type values: Array of floats
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateLocalDofsDP, [field, variableType, fieldSetType, values])

    def ParameterSetUpdateNodeDP(self, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value):
        """:param variableType: The variable type of the field to update the nodal value for the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update the nodal value for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param versionNumber: The derivative version number of the field variable component to update for the field parameter set.
        :type versionNumber: int
        :param derivativeNumber: The derivative number of the field variable component to update for the field parameter set.
        :type derivativeNumber: int
        :param userNodeNumber: The user node number of the field variable component to update for the field parameter set.
        :type userNodeNumber: int
        :param componentNumber: The component number of the field variable to update the nodal value for the field parameter set.
        :type componentNumber: int
        :param value: The value to update the field parameter set to.
        :type value: float
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateNodeDP, [field, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value])

    def ParameterSetUpdateNodeIntg(self, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value):
        """:param variableType: The variable type of the field to update the nodal value for the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update the nodal value for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param versionNumber: The derivative version number of the field variable component to update for the field parameter set.
        :type versionNumber: int
        :param derivativeNumber: The derivative number of the field variable component to update for the field parameter set.
        :type derivativeNumber: int
        :param userNodeNumber: The user node number of the field variable component to update for the field parameter set.
        :type userNodeNumber: int
        :param componentNumber: The component number of the field variable to update the nodal value for the field parameter set.
        :type componentNumber: int
        :param value: The value to update the field parameter set to.
        :type value: int
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateNodeIntg, [field, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value])

    def ParameterSetUpdateNodeL(self, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value):
        """:param variableType: The variable type of the field to update the nodal value for the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update the nodal value for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param versionNumber: The derivative version number of the field variable component to update for the field parameter set.
        :type versionNumber: int
        :param derivativeNumber: The derivative number of the field variable component to update for the field parameter set.
        :type derivativeNumber: int
        :param userNodeNumber: The user node number of the field variable component to update for the field parameter set.
        :type userNodeNumber: int
        :param componentNumber: The component number of the field variable to update the nodal value for the field parameter set.
        :type componentNumber: int
        :param value: The value to update the field parameter set to.
        :type value: bool
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateNodeL, [field, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value])

    def ParameterSetUpdateNodeSP(self, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value):
        """:param variableType: The variable type of the field to update the nodal value for the field parameter set. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type of the field to update the nodal value for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :param versionNumber: The derivative version number of the field variable component to update for the field parameter set.
        :type versionNumber: int
        :param derivativeNumber: The derivative number of the field variable component to update for the field parameter set.
        :type derivativeNumber: int
        :param userNodeNumber: The user node number of the field variable component to update for the field parameter set.
        :type userNodeNumber: int
        :param componentNumber: The component number of the field variable to update the nodal value for the field parameter set.
        :type componentNumber: int
        :param value: The value to update the field parameter set to.
        :type value: float
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateNodeSP, [field, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value])

    def ParameterSetUpdateStart(self, variableType, fieldSetType):
        """Starts the parameter set update for a field variable for a field identified by an object.

        :param variableType: The variable type of the field to start the parameter set update for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param fieldSetType: The parameter set type to start the update for. Must be a value from the FieldParameterSetTypes enum.
        :type fieldSetType: int
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateStart, [field, variableType, fieldSetType])

    def ParametersToFieldParametersComponentCopy(self, fromVariableType, fromParameterSetType, fromComponentNumber, toField, toVariableType, toParameterSetType, toComponentNumber):
        """Copy the parameters from the parameter set of a component of a field variable to the paramters of a parameter set of
        a component of another field variable, where both fields are objects.

        :param fromVariableType: The field variable type to copy from
        :type fromVariableType: int
        :param fromParameterSetType: The field parameter set type to copy from
        :type fromParameterSetType: int
        :param fromComponentNumber: The field variable component number to copy from
        :type fromComponentNumber: int
        :param toField: The field to copy to
        :type toField: Field
        :param toVariableType: The field variable type to copy to
        :type toVariableType: int
        :param toParameterSetType: The parameter set type to copy to
        :type toParameterSetType: int
        :param toComponentNumber: The field variable component to copy to
        :type toComponentNumber: int
        :rtype: None
        """

        fromField = self
        return _wrap_routine(_iron_python.cmfe_Field_ParametersToFieldParametersComponentCopy, [fromField, fromVariableType, fromParameterSetType, fromComponentNumber, toField, toVariableType, toParameterSetType, toComponentNumber])

    def PositionNormalTangentCalculateNode(self, variableType, componentNumber, localNodeNumber, positionSize, normalSize, tangentsSizes):
        """Returns the position, normal and tangents for a field node for a field identified by an object.

        :param variableType: The variable type of the field to get the interpolation type for. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param componentNumber: The component number of the field variable to get the data type for.
        :type componentNumber: int
        :param localNodeNumber: The local node number of the field variable to get the data type for.
        :type localNodeNumber: int
        :param positionSize: Size of position to allocate.
        :param normalSize: Size of normal to allocate.
        :param tangentsSizes: Tuple of dimensions of tangents to allocate, with length 2.
        :returns: (Actual useful outputs, Actual useful outputs, Actual useful outputs)
        :rtype: tuple. (Array of floats, Array of floats, 2d array of floats)
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_PositionNormalTangentCalculateNode, [field, variableType, componentNumber, localNodeNumber, positionSize, normalSize, tangentsSizes])

    def ScalingTypeGet(self):
        """Returns the scaling type for a field identified by an object.

        :returns: scalingType. The field scaling type. Will be a value from the FieldScalingTypes enum.
        :rtype: int
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ScalingTypeGet, [field])

    def ScalingTypeSet(self, scalingType):
        """Sets/changes the scaling type for a field identified by an object.

        :param scalingType: The field scaling type to set. Must be a value from the FieldScalingTypes enum.
        :type scalingType: int
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_ScalingTypeSet, [field, scalingType])

    def TypeGet(self):
        """Returns the type for a field identified by an object.

        :returns: fieldType. The field type. Will be a value from the FieldTypes enum.
        :rtype: int
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_TypeGet, [field])

    def TypeSet(self, fieldType):
        """Sets/changes the type for a field identified by an object.

        :param fieldType: The field type to set. Must be a value from the FieldTypes enum.
        :type fieldType: int
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_TypeSet, [field, fieldType])

    def VariableLabelGet(self, variableType):
        """Returns the character string label for a field variable for a field identified by an object.

        :param variableType: The variable type of the field to get the field variable label. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :returns: label. The field variable label.
        :rtype: string
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_VariableLabelGet, [field, variableType])

    def VariableLabelSet(self, variableType, label):
        """Sets/changes the character string label for a field variable for a field identified by an object.

        :param variableType: The variable type of the field to set the field variable label. Must be a value from the FieldVariableTypes enum.
        :type variableType: int
        :param label: The field variable label to set.
        :type label: string
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_VariableLabelSet, [field, variableType, label])

    def VariableTypesGet(self, variableTypesSize):
        """Returns the variable types for a field identified by an object.

        :param variableTypesSize: Size of variableTypes to allocate.
        :returns: variableTypes. variableTypes(variable_idx). On return, the field variable types for the variable_idx'th field variable. Will be a value from the FieldVariableTypes enum.
        :rtype: Array of ints
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_VariableTypesGet, [field, variableTypesSize])

    def VariableTypesSet(self, variableTypes):
        """Sets/changes the variable types for a field identified by an object.

        :param variableTypes: variableTypes(variable_idx). The field variable types for the variable_idx'th field variable to set. Must be a value from the FieldVariableTypes enum.
        :type variableTypes: Array of ints
        :rtype: None
        """

        field = self
        return _wrap_routine(_iron_python.cmfe_Field_VariableTypesSet, [field, variableTypes])

    dependentType = property(DependentTypeGet, DependentTypeSet, None, """The dependent type for a field identified by an object.""")

    variableTypes = property(VariableTypesGet, VariableTypesSet, None, """The variable types for a field identified by an object.""")

    dataProjection = property(None, DataProjectionSet, None, """The data projection for a field identified by an object.""")

    numberOfVariables = property(NumberOfVariablesGet, NumberOfVariablesSet, None, """The number of variables for a field identified by an object.""")

    label = property(LabelGet, LabelSet, None, """The character string label for a field identified by an object.""")

    meshDecomposition = property(MeshDecompositionGet, MeshDecompositionSet, None, """The mesh decomposition for a field identified by an object.""")

    scalingType = property(ScalingTypeGet, ScalingTypeSet, None, """The scaling type for a field identified by an object.""")

    type = property(TypeGet, TypeSet, None, """The type for a field identified by an object.""")

    geometricField = property(GeometricFieldGet, GeometricFieldSet, None, """The geometric field for a field identified by an object.""")


class Fields(CMFEType):
    """Contains information for a fields defined on a region.
    """

    def __init__(self):
        """Initialise a null cmfe_FieldsType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_Fields_Initialise, None)

    def CreateInterface(self, interface):
        """Creates a cmfe_FieldsType object for an inteface by an object reference.

        :param interface: The interface to get the fields from
        :type interface: Interface
        :rtype: None
        """

        fields = self
        return _wrap_routine(_iron_python.cmfe_Fields_CreateInterface, [interface, fields])

    def CreateRegion(self, region):
        """Creates a cmfe_FieldsType object for a region by an object reference.

        :param region: The region to get the fields from
        :type region: Region
        :rtype: None
        """

        fields = self
        return _wrap_routine(_iron_python.cmfe_Fields_CreateRegion, [region, fields])

    def ElementsExport(self, fileName, method):
        """Export element information for fields set identified by an object. \todo number method

        :param fileName: The file name to export the elements to
        :type fileName: string
        :param method: The export method to use.
        :type method: string
        :rtype: None
        """

        fields = self
        return _wrap_routine(_iron_python.cmfe_Fields_ElementsExport, [fields, fileName, method])

    def Finalise(self):
        """Finalises a cmfe_FieldsType object.

        :rtype: None
        """

        cmfe_Fields = self
        return _wrap_routine(_iron_python.cmfe_Fields_Finalise, [cmfe_Fields])

    def NodesExport(self, fileName, method):
        """Export nodal information for fields set identified by an object. \todo number method

        :param fileName: The file name to export the nodes to
        :type fileName: string
        :param method: The export method to use.
        :type method: string
        :rtype: None
        """

        fields = self
        return _wrap_routine(_iron_python.cmfe_Fields_NodesExport, [fields, fileName, method])


class GeneratedMesh(CMFEType):
    """Contains information on a generated mesh.
    """

    def __init__(self):
        """Initialise a null cmfe_GeneratedMeshType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_GeneratedMesh_Initialise, None)

    def BaseVectorsSet(self, baseVectors):
        """Sets/changes the base vectors for a generated mesh identified by an object.

        :param baseVectors: baseVectors(coordinate_idx,xi_idx). The base vectors to set.
        :type baseVectors: 2d array of floats
        :rtype: None
        """

        generatedMesh = self
        return _wrap_routine(_iron_python.cmfe_GeneratedMesh_BaseVectorsSet, [generatedMesh, baseVectors])

    def BasisGet(self, bases):
        """Returns the basis for a generated mesh identified by an object.

        :param bases: On return, the array of bases.
        :type bases: Array of Basis objects
        :rtype: None
        """

        generatedMesh = self
        return _wrap_routine(_iron_python.cmfe_GeneratedMesh_BasisGet, [generatedMesh, bases])

    def BasisSet(self, bases):
        """Sets/changes the basis for a generated mesh identified by an object.

        :param bases: The bases to set.
        :type bases: Array of Basis objects
        :rtype: None
        """

        generatedMesh = self
        return _wrap_routine(_iron_python.cmfe_GeneratedMesh_BasisSet, [generatedMesh, bases])

    def CreateFinish(self, meshUserNumber, mesh):
        """Finishes the creation of a generated mesh identified by an object.

        :param meshUserNumber: The user number of the mesh to generate.
        :type meshUserNumber: int
        :param mesh: On return, the generated mesh.
        :type mesh: Mesh
        :rtype: None
        """

        generatedMesh = self
        return _wrap_routine(_iron_python.cmfe_GeneratedMesh_CreateFinish, [generatedMesh, meshUserNumber, mesh])

    def CreateStartInterface(self, generatedMeshUserNumber, interface):
        """Starts the creation of a generated mesh on an interface identified by an object.

        :param generatedMeshUserNumber: The user number of the generated mesh to create.
        :type generatedMeshUserNumber: int
        :param interface: The interface to created generated mesh in.
        :type interface: Interface
        :rtype: None
        """

        generatedMesh = self
        return _wrap_routine(_iron_python.cmfe_GeneratedMesh_CreateStartInterface, [generatedMeshUserNumber, interface, generatedMesh])

    def CreateStart(self, generatedMeshUserNumber, region):
        """Starts the creation of a generated mesh on a region identified by an object.

        :param generatedMeshUserNumber: The user number of the generated mesh to create.
        :type generatedMeshUserNumber: int
        :param region: The region to created generated mesh in.
        :type region: Region
        :rtype: None
        """

        generatedMesh = self
        return _wrap_routine(_iron_python.cmfe_GeneratedMesh_CreateStart, [generatedMeshUserNumber, region, generatedMesh])

    def Destroy(self):
        """Destroys a generated mesh identified by an object.

        :rtype: None
        """

        generatedMesh = self
        return _wrap_routine(_iron_python.cmfe_GeneratedMesh_Destroy, [generatedMesh])

    def ExtentGet(self, extentSize):
        """Returns the extent for a generated mesh identified by an object.

        :param extentSize: Size of extent to allocate.
        :returns: extent. extent(i). On return, the extent for the i'th dimension of the generated mesh.
        :rtype: Array of floats
        """

        generatedMesh = self
        return _wrap_routine(_iron_python.cmfe_GeneratedMesh_ExtentGet, [generatedMesh, extentSize])

    def ExtentSet(self, extent):
        """Sets/changes the extent for a generated mesh identified by an object.

        :param extent: extent(i). the extent for the i'th dimension of the generated mesh to set.
        :type extent: Array of floats
        :rtype: None
        """

        generatedMesh = self
        return _wrap_routine(_iron_python.cmfe_GeneratedMesh_ExtentSet, [generatedMesh, extent])

    def Finalise(self):
        """Finalises a cmfe_GeneratedMeshType object.

        :rtype: None
        """

        cmfe_GeneratedMesh = self
        return _wrap_routine(_iron_python.cmfe_GeneratedMesh_Finalise, [cmfe_GeneratedMesh])

    def GeometricParametersCalculate(self, field):
        """Calculates and sets the geometric field parameters for a generated mesh identified by an object.

        :param field: The field to calculate the geometric parameters for
        :type field: Field
        :rtype: None
        """

        generatedMesh = self
        return _wrap_routine(_iron_python.cmfe_GeneratedMesh_GeometricParametersCalculate, [generatedMesh, field])

    def NumberOfElementsGet(self, numberOfElementsSize):
        """Returns the number of elements for a generated mesh identified by an object.

        :param numberOfElementsSize: Size of numberOfElements to allocate.
        :returns: numberOfElements. numberOfElements(i). On return, the number of elements in the i'th dimension of the generated mesh.
        :rtype: Array of ints
        """

        generatedMesh = self
        return _wrap_routine(_iron_python.cmfe_GeneratedMesh_NumberOfElementsGet, [generatedMesh, numberOfElementsSize])

    def NumberOfElementsSet(self, numberOfElements):
        """Sets/changes the number of elements for a generated mesh identified by an object.

        :param numberOfElements: numberOfElements(i). The number of elements in the i'th dimension of the generated mesh to set.
        :type numberOfElements: Array of ints
        :rtype: None
        """

        generatedMesh = self
        return _wrap_routine(_iron_python.cmfe_GeneratedMesh_NumberOfElementsSet, [generatedMesh, numberOfElements])

    def OriginGet(self, originSize):
        """Returns the origin of a generated mesh identified by an object.

        :param originSize: Size of origin to allocate.
        :returns: origin. origin(i). On return, the origin of the i'th dimension of the generated mesh.
        :rtype: Array of floats
        """

        generatedMesh = self
        return _wrap_routine(_iron_python.cmfe_GeneratedMesh_OriginGet, [generatedMesh, originSize])

    def OriginSet(self, origin):
        """Sets/changes the origin of a generated mesh identified by an object.

        :param origin: origin(i). The origin of the i'th dimension of the generated mesh to set.
        :type origin: Array of floats
        :rtype: None
        """

        generatedMesh = self
        return _wrap_routine(_iron_python.cmfe_GeneratedMesh_OriginSet, [generatedMesh, origin])

    def TypeGet(self):
        """Returns the type of a generated mesh identified by an object.

        :returns: generatedMeshType. The type of the generated mesh. Will be a value from the GeneratedMeshTypes enum.
        :rtype: int
        """

        generatedMesh = self
        return _wrap_routine(_iron_python.cmfe_GeneratedMesh_TypeGet, [generatedMesh])

    def TypeSet(self, generatedMeshType):
        """Sets/changes the type of a generated mesh identified by an object.

        :param generatedMeshType: The type of the generated mesh to set. Must be a value from the GeneratedMeshTypes enum.
        :type generatedMeshType: int
        :rtype: None
        """

        generatedMesh = self
        return _wrap_routine(_iron_python.cmfe_GeneratedMesh_TypeSet, [generatedMesh, generatedMeshType])

    origin = property(OriginGet, OriginSet, None, """The origin of a generated mesh identified by an object.""")

    basis = property(BasisGet, BasisSet, None, """The basis for a generated mesh identified by an object.""")

    baseVectors = property(None, BaseVectorsSet, None, """The base vectors for a generated mesh identified by an object.""")

    extent = property(ExtentGet, ExtentSet, None, """The extent for a generated mesh identified by an object.""")

    type = property(TypeGet, TypeSet, None, """The type of a generated mesh identified by an object.""")

    numberOfElements = property(NumberOfElementsGet, NumberOfElementsSet, None, """The number of elements for a generated mesh identified by an object.""")


class History(CMFEType):
    """Contains information about a history file for a control loop.
    """

    def __init__(self):
        """Initialise a null cmfe_HistoryType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_History_Initialise, None)

    def Finalise(self):
        """Finalises a cmfe_HistoryType object.

        :rtype: None
        """

        cmfe_History = self
        return _wrap_routine(_iron_python.cmfe_History_Finalise, [cmfe_History])


class InterfaceCondition(CMFEType):
    """Contains information about an interface condition.
    """

    def __init__(self):
        """Initialise a null cmfe_InterfaceConditionType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_InterfaceCondition_Initialise, None)

    def CreateFinish(self):
        """Finishes the creation of an interface condition identified by an object.

        :rtype: None
        """

        interfaceCondition = self
        return _wrap_routine(_iron_python.cmfe_InterfaceCondition_CreateFinish, [interfaceCondition])

    def CreateStart(self, interfaceConditionUserNumber, interface, geometricField):
        """Starts the creation of an interface condition identified by an object.

        :param interfaceConditionUserNumber: The user number of the interface conditon to start the creation of.
        :type interfaceConditionUserNumber: int
        :param interface: The interface to create the interface on.
        :type interface: Interface
        :param geometricField: The geometric field for the interface condition.
        :type geometricField: Field
        :rtype: None
        """

        interfaceCondition = self
        return _wrap_routine(_iron_python.cmfe_InterfaceCondition_CreateStart, [interfaceConditionUserNumber, interface, geometricField, interfaceCondition])

    def DependentVariableAdd(self, meshIndex, equationsSet, variableType):
        """Adds a dependent field variable to an interface condition identified by an object.

        :param meshIndex: The mesh index of the interface condition interface for which the dependent variable is added.
        :type meshIndex: int
        :param equationsSet: The equations set containg the dependent variable to add.
        :type equationsSet: EquationsSet
        :param variableType: The variable type of the dependent variable to add.
        :type variableType: int
        :rtype: None
        """

        interfaceCondition = self
        return _wrap_routine(_iron_python.cmfe_InterfaceCondition_DependentVariableAdd, [interfaceCondition, meshIndex, equationsSet, variableType])

    def Destroy(self):
        """Destroys an interface condition identified by an object.

        :rtype: None
        """

        interfaceCondition = self
        return _wrap_routine(_iron_python.cmfe_InterfaceCondition_Destroy, [interfaceCondition])

    def EquationsCreateFinish(self):
        """Finishes the creation of interface equations for an interface condition identified by an object.

        :rtype: None
        """

        interfaceCondition = self
        return _wrap_routine(_iron_python.cmfe_InterfaceCondition_EquationsCreateFinish, [interfaceCondition])

    def EquationsCreateStart(self, interfaceEquations):
        """Starts the creation of interface equations for an interface condition identified by an object.

        :param interfaceEquations: On return, the created interface equations.
        :type interfaceEquations: InterfaceEquations
        :rtype: None
        """

        interfaceCondition = self
        return _wrap_routine(_iron_python.cmfe_InterfaceCondition_EquationsCreateStart, [interfaceCondition, interfaceEquations])

    def EquationsDestroy(self):
        """Destroys the interface equations for an interface condition identified by an object.

        :rtype: None
        """

        interfaceCondition = self
        return _wrap_routine(_iron_python.cmfe_InterfaceCondition_EquationsDestroy, [interfaceCondition])

    def Finalise(self):
        """Finalises a cmfe_InterfaceConditionType object.

        :rtype: None
        """

        cmfe_InterfaceCondition = self
        return _wrap_routine(_iron_python.cmfe_InterfaceCondition_Finalise, [cmfe_InterfaceCondition])

    def IntegrationTypeGet(self):
        """Gets the integration type for an interface condition identified by an object.

        :returns: interfaceConditionIntegrationType. The interface condition integration type. Will be a value from the InterfaceConditionIntegrationTypes enum.
        :rtype: int
        """

        interfaceCondition = self
        return _wrap_routine(_iron_python.cmfe_InterfaceCondition_IntegrationTypeGet, [interfaceCondition])

    def IntegrationTypeSet(self, interfaceConditionIntegrationType):
        """Sets/changes the integration type for an interface condition identified by an object.

        :param interfaceConditionIntegrationType: On return, the interface condition integration type. Must be a value from the InterfaceConditionIntegrationTypes enum.
        :type interfaceConditionIntegrationType: int
        :rtype: None
        """

        interfaceCondition = self
        return _wrap_routine(_iron_python.cmfe_InterfaceCondition_IntegrationTypeSet, [interfaceCondition, interfaceConditionIntegrationType])

    def LagrangeFieldCreateFinish(self):
        """Finishes the creation of a Lagrange multiplier field for an interface condition identified by an object.

        :rtype: None
        """

        interfaceCondition = self
        return _wrap_routine(_iron_python.cmfe_InterfaceCondition_LagrangeFieldCreateFinish, [interfaceCondition])

    def LagrangeFieldCreateStart(self, lagrangeFieldUserNumber, lagrangeField):
        """Starts the creation of a Lagrange multiplier field for an interface condition identified by an object.

        :param lagrangeFieldUserNumber: The user number of the Lagrange field.
        :type lagrangeFieldUserNumber: int
        :param lagrangeField: If associated on entry, the user created Lagrange field which has the same user number as the specified Lagrange field user number. If not associated on entry, on return, the created Lagrange field for the interface condition.
        :type lagrangeField: Field
        :rtype: None
        """

        interfaceCondition = self
        return _wrap_routine(_iron_python.cmfe_InterfaceCondition_LagrangeFieldCreateStart, [interfaceCondition, lagrangeFieldUserNumber, lagrangeField])

    def MethodGet(self):
        """Gets the method for an interface condition identified by an object.

        :returns: interfaceConditionMethod. The interface condition method. Will be a value from the InterfaceConditionMethods enum.
        :rtype: int
        """

        interfaceCondition = self
        return _wrap_routine(_iron_python.cmfe_InterfaceCondition_MethodGet, [interfaceCondition])

    def MethodSet(self, interfaceConditionMethod):
        """Sets/changes the method for an interface condition identified by an object.

        :param interfaceConditionMethod: The interface condition method to set. Must be a value from the InterfaceConditionMethods enum.
        :type interfaceConditionMethod: int
        :rtype: None
        """

        interfaceCondition = self
        return _wrap_routine(_iron_python.cmfe_InterfaceCondition_MethodSet, [interfaceCondition, interfaceConditionMethod])

    def OperatorGet(self):
        """Gets the operator for an interface condition identified by an object.

        :returns: interfaceConditionOperator. The interface condition operator. Will be a value from the InterfaceConditionOperator enum.
        :rtype: int
        """

        interfaceCondition = self
        return _wrap_routine(_iron_python.cmfe_InterfaceCondition_OperatorGet, [interfaceCondition])

    def OperatorSet(self, interfaceConditionOperator):
        """Sets/changes the operator for an interface condition identified by an object.

        :param interfaceConditionOperator: The interface condition operator to set. Must be a value from the InterfaceConditionOperator enum.
        :type interfaceConditionOperator: int
        :rtype: None
        """

        interfaceCondition = self
        return _wrap_routine(_iron_python.cmfe_InterfaceCondition_OperatorSet, [interfaceCondition, interfaceConditionOperator])

    def PenaltyFieldCreateFinish(self):
        """Finishes the creation of a penalty field for an interface condition identified by an object.

        :rtype: None
        """

        InterfaceCondition = self
        return _wrap_routine(_iron_python.cmfe_InterfaceCondition_PenaltyFieldCreateFinish, [InterfaceCondition])

    def PenaltyFieldCreateStart(self, PenaltyFieldUserNumber, PenaltyField):
        """Starts the creation of a penalty field for an interface condition identified by an object.

        :param PenaltyFieldUserNumber: The user number of the penalty field.
        :type PenaltyFieldUserNumber: int
        :param PenaltyField: If associated on entry, the user created penalty field which has the same user number as the specified penalty field user number. If not associated on entry, on return, the created penalty field for the interface condition.
        :type PenaltyField: Field
        :rtype: None
        """

        InterfaceCondition = self
        return _wrap_routine(_iron_python.cmfe_InterfaceCondition_PenaltyFieldCreateStart, [InterfaceCondition, PenaltyFieldUserNumber, PenaltyField])

    operator = property(OperatorGet, OperatorSet, None, """The operator for an interface condition identified by an object.""")

    integrationType = property(IntegrationTypeGet, IntegrationTypeSet, None, """The integration type for an interface condition identified by an object.""")

    method = property(MethodGet, MethodSet, None, """The method for an interface condition identified by an object.""")


class InterfaceEquations(CMFEType):
    """Contains information about an interface condition.
    """

    def __init__(self):
        """Initialise a null cmfe_InterfaceEquationsType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_InterfaceEquations_Initialise, None)

    def Finalise(self):
        """Finalises a cmfe_InterfaceEquationsType object.

        :rtype: None
        """

        cmfe_InterfaceEquations = self
        return _wrap_routine(_iron_python.cmfe_InterfaceEquations_Finalise, [cmfe_InterfaceEquations])

    def OutputTypeGet(self):
        """Gets the output type for an interface equations identified by an object.

        :returns: outputType. The interface equations output type. Will be a value from the EquationsOutputType enum.
        :rtype: int
        """

        interfaceEquations = self
        return _wrap_routine(_iron_python.cmfe_InterfaceEquations_OutputTypeGet, [interfaceEquations])

    def OutputTypeSet(self, outputType):
        """Sets/changes the output type for an interface equations identified by an object.

        :param outputType: The interface equations output type to set. Must be a value from the EquationsOutputTypes enum.
        :type outputType: int
        :rtype: None
        """

        interfaceEquations = self
        return _wrap_routine(_iron_python.cmfe_InterfaceEquations_OutputTypeSet, [interfaceEquations, outputType])

    def SparsityGet(self):
        """Gets the sparsity type for an interface equations identified by an object.

        :returns: sparsityType. The interface equations sparsity type. Will be a value from the EquationsSparsityType enum.
        :rtype: int
        """

        interfaceEquations = self
        return _wrap_routine(_iron_python.cmfe_InterfaceEquations_SparsityGet, [interfaceEquations])

    def SparsitySet(self, sparsityType):
        """Sets/changes the sparsity type for an interface equations identified by an object.

        :param sparsityType: The interface equations sparsity type to set. Must be a value from the EquationsSparsityTypes enum.
        :type sparsityType: int
        :rtype: None
        """

        interfaceEquations = self
        return _wrap_routine(_iron_python.cmfe_InterfaceEquations_SparsitySet, [interfaceEquations, sparsityType])

    sparsity = property(SparsityGet, SparsitySet, None, """The sparsity type for an interface equations identified by an object.""")

    outputType = property(OutputTypeGet, OutputTypeSet, None, """The output type for an interface equations identified by an object.""")


class InterfaceMeshConnectivity(CMFEType):
    """Contains information on an interfaces meshes connectivity.
    """

    def __init__(self):
        """Initialise a null cmfe_InterfaceMeshConnectivityType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_InterfaceMeshConnectivity_Initialise, None)

    def BasisSet(self, interfaceMappingBasis):
        """Sets the basis for the mesh connectivity

        :param interfaceMappingBasis: The interface mesh connectivity basis
        :type interfaceMappingBasis: Basis
        :rtype: None
        """

        interfaceMeshConnectivity = self
        return _wrap_routine(_iron_python.cmfe_InterfaceMeshConnectivity_BasisSet, [interfaceMeshConnectivity, interfaceMappingBasis])

    def CreateFinish(self):
        """Finishes the creation of an interface meshes connectivity identified by an object.

        :rtype: None
        """

        interfaceMeshConnectivity = self
        return _wrap_routine(_iron_python.cmfe_InterfaceMeshConnectivity_CreateFinish, [interfaceMeshConnectivity])

    def CreateStart(self, interface, interfaceMesh):
        """Starts the creation of an interface meshes connectivity identified by an object.

        :param interface: The interface to start the creation of the meshes connectivity for
        :type interface: Interface
        :param interfaceMesh:
        :type interfaceMesh: Mesh
        :rtype: None
        """

        interfaceMeshConnectivity = self
        return _wrap_routine(_iron_python.cmfe_InterfaceMeshConnectivity_CreateStart, [interface, interfaceMesh, interfaceMeshConnectivity])

    def Destroy(self):
        """Destroys an interface meshes connectivity identified by an object.

        :rtype: None
        """

        interfaceMeshConnectivity = self
        return _wrap_routine(_iron_python.cmfe_InterfaceMeshConnectivity_Destroy, [interfaceMeshConnectivity])

    def ElementNumberSet(self, interfaceElementNumber, coupledMeshIndexNumber, coupledMeshElementNumber):
        """Sets the connectivity between an element in a coupled mesh to an element in the interface mesh

        :param interfaceElementNumber: The interface mesh element number to which the specified coupled mesh element would be connected
        :type interfaceElementNumber: int
        :param coupledMeshIndexNumber: The index of the coupled mesh at the interface to set the element connectivity for
        :type coupledMeshIndexNumber: int
        :param coupledMeshElementNumber: The coupled mesh element to be connected to the interface
        :type coupledMeshElementNumber: int
        :rtype: None
        """

        interfaceMeshConnectivity = self
        return _wrap_routine(_iron_python.cmfe_InterfaceMeshConnectivity_ElementNumberSet, [interfaceMeshConnectivity, interfaceElementNumber, coupledMeshIndexNumber, coupledMeshElementNumber])

    def ElementXiSet(self, interfaceElementNumber, coupledMeshIndexNumber, coupledMeshElementNumber, interfaceMeshLocalNodeNumber, interfaceMeshComponentNodeNumber, xi):
        """Sets the mapping from an xi position of a coupled mesh element to a node of an interface mesh element

        :param interfaceElementNumber: The interface mesh element number to which the specified coupled mesh element would be connected
        :type interfaceElementNumber: int
        :param coupledMeshIndexNumber: The index of the coupled mesh at the interface to set the element connectivity for
        :type coupledMeshIndexNumber: int
        :param coupledMeshElementNumber: The coupled mesh element to define the element xi connectivity from
        :type coupledMeshElementNumber: int
        :param interfaceMeshLocalNodeNumber: The interface mesh node to assign the coupled mesh element xi to
        :type interfaceMeshLocalNodeNumber: int
        :param interfaceMeshComponentNodeNumber: The interface mesh node's component to assign the coupled mesh element xi to
        :type interfaceMeshComponentNodeNumber: int
        :param xi: The xi value for the xi_idx'th xi direction in the coupled mesh element.
        :type xi: Array of floats
        :rtype: None
        """

        interfaceMeshConnectivity = self
        return _wrap_routine(_iron_python.cmfe_InterfaceMeshConnectivity_ElementXiSet, [interfaceMeshConnectivity, interfaceElementNumber, coupledMeshIndexNumber, coupledMeshElementNumber, interfaceMeshLocalNodeNumber, interfaceMeshComponentNodeNumber, xi])

    def Finalise(self):
        """Finalises a cmfe_InterfaceMeshConnectivityType object.

        :rtype: None
        """

        cmfe_InterfaceMeshConnectivity = self
        return _wrap_routine(_iron_python.cmfe_InterfaceMeshConnectivity_Finalise, [cmfe_InterfaceMeshConnectivity])

    def NodeNumberSet(self, interfaceNodeNumbers, firstCoupledMeshIndexNumber, firstCoupledMeshNodeNumbers, secondCoupledMeshIndexNumber, secondCoupledMeshNodeNumbers):
        """Sets the connectivity between nodes in coupled meshes to nodes in the interface mesh

        :param interfaceNodeNumbers: The interface mesh node numbers to which the specified coupled mesh nodes would be connected
        :type interfaceNodeNumbers: Array of ints
        :param firstCoupledMeshIndexNumber: The index of the coupled meshes at the interface to set the node connectivity for
        :type firstCoupledMeshIndexNumber: int
        :param firstCoupledMeshNodeNumbers: The coupled meshes nodes to be connected to the interface
        :type firstCoupledMeshNodeNumbers: Array of ints
        :param secondCoupledMeshIndexNumber: The index of the coupled meshes at the interface to set the node connectivity for
        :type secondCoupledMeshIndexNumber: int
        :param secondCoupledMeshNodeNumbers: The coupled meshes nodes to be connected to the interface
        :type secondCoupledMeshNodeNumbers: Array of ints
        :rtype: None
        """

        interfaceMeshConnectivity = self
        return _wrap_routine(_iron_python.cmfe_InterfaceMeshConnectivity_NodeNumberSet, [interfaceMeshConnectivity, interfaceNodeNumbers, firstCoupledMeshIndexNumber, firstCoupledMeshNodeNumbers, secondCoupledMeshIndexNumber, secondCoupledMeshNodeNumbers])

    basis = property(None, BasisSet, None, """The basis for the mesh connectivity""")


class InterfacePointsConnectivity(CMFEType):
    """Contains information on an interfaces points connectivity.
    """

    def __init__(self):
        """Initialise a null cmfe_InterfacePointsConnectivityType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_InterfacePointsConnectivity_Initialise, None)

    def CreateFinish(self):
        """Finishes the creation of an interface meshes connectivity identified by an object.

        :rtype: None
        """

        interfacePointsConnectivity = self
        return _wrap_routine(_iron_python.cmfe_InterfacePointsConnectivity_CreateFinish, [interfacePointsConnectivity])

    def CreateStart(self, interface, interfaceMesh):
        """Starts the creation of an interface points connectivity identified by an object.

        :param interface: The interface to start the creation of the meshes connectivity for
        :type interface: Interface
        :param interfaceMesh:
        :type interfaceMesh: Mesh
        :rtype: None
        """

        interfacePointsConnectivity = self
        return _wrap_routine(_iron_python.cmfe_InterfacePointsConnectivity_CreateStart, [interface, interfaceMesh, interfacePointsConnectivity])

    def Destroy(self):
        """Destroys an interface points connectivity identified by an object.

        :rtype: None
        """

        interfacePointsConnectivity = self
        return _wrap_routine(_iron_python.cmfe_InterfacePointsConnectivity_Destroy, [interfacePointsConnectivity])

    def ElementNumberGet(self, interfaceDataPointIndexNumber, coupledMeshIndexNumber, meshComponentNumber):
        """Gets coupled mesh element number that the data point in the interface is connected to

        :param interfaceDataPointIndexNumber: The index of the interface data point, i.e.user defined global number
        :type interfaceDataPointIndexNumber: int
        :param coupledMeshIndexNumber: The index number of the coupled mesh
        :type coupledMeshIndexNumber: int
        :param meshComponentNumber: The mesh component number of the interface mesh that points connectivity is associated to
        :type meshComponentNumber: int
        :returns: coupledMeshElementNumber. The element number where the data point is projected to.
        :rtype: int
        """

        interfacePointsConnectivity = self
        return _wrap_routine(_iron_python.cmfe_InterfacePointsConnectivity_ElementNumberGet, [interfacePointsConnectivity, interfaceDataPointIndexNumber, coupledMeshIndexNumber, meshComponentNumber])

    def ElementNumberSet(self, interfaceDataPointIndexNumber, coupledMeshIndexNumber, coupledMeshElementNumber, meshComponentNumber):
        """Sets coupled mesh element number that the data point in the interface is connected to

        :param interfaceDataPointIndexNumber: The index of the interface data point, i.e.user defined global number
        :type interfaceDataPointIndexNumber: int
        :param coupledMeshIndexNumber: The index number of the coupled mesh
        :type coupledMeshIndexNumber: int
        :param coupledMeshElementNumber: The element number where the data point is projected to.
        :type coupledMeshElementNumber: int
        :param meshComponentNumber: The mesh component number to set the points connectivity element number for
        :type meshComponentNumber: int
        :rtype: None
        """

        interfacePointsConnectivity = self
        return _wrap_routine(_iron_python.cmfe_InterfacePointsConnectivity_ElementNumberSet, [interfacePointsConnectivity, interfaceDataPointIndexNumber, coupledMeshIndexNumber, coupledMeshElementNumber, meshComponentNumber])

    def Finalise(self):
        """Finalise a cmfe_InterfaceMeshConnectivityType object.

        :rtype: None
        """

        cmfe_InterfacePointsConnectivity = self
        return _wrap_routine(_iron_python.cmfe_InterfacePointsConnectivity_Finalise, [cmfe_InterfacePointsConnectivity])

    def PointXiGet(self, interfaceDataPointIndexNumber, coupledMeshIndexNumber, xiSize):
        """Gets the xi coordinate mapping between the interface data points and xi coordinates in a coupled region mesh

        :param interfaceDataPointIndexNumber: The index of the interface data point, i.e.user defined global number
        :type interfaceDataPointIndexNumber: int
        :param coupledMeshIndexNumber: The index number of the coupled mesh
        :type coupledMeshIndexNumber: int
        :param xiSize: Size of xi to allocate.
        :returns: xi. xi(xiIdx). The full xi location in the coupled mesh that the data point is connected to
        :rtype: Array of floats
        """

        interfacePointsConnectivity = self
        return _wrap_routine(_iron_python.cmfe_InterfacePointsConnectivity_PointXiGet, [interfacePointsConnectivity, interfaceDataPointIndexNumber, coupledMeshIndexNumber, xiSize])

    def PointXiSet(self, interfaceDataPointIndexNumber, coupledMeshIndexNumber, xi):
        """Sets the xi coordinate mapping between the interface data points and xi coordinates in a coupled region mesh

        :param interfaceDataPointIndexNumber: The index of the interface data point, i.e.user defined global number
        :type interfaceDataPointIndexNumber: int
        :param coupledMeshIndexNumber: The index number of the coupled mesh
        :type coupledMeshIndexNumber: int
        :param xi: xi(xiIdx). The full xi location in the coupled mesh that the data point is connected to
        :type xi: Array of floats
        :rtype: None
        """

        interfacePointsConnectivity = self
        return _wrap_routine(_iron_python.cmfe_InterfacePointsConnectivity_PointXiSet, [interfacePointsConnectivity, interfaceDataPointIndexNumber, coupledMeshIndexNumber, xi])

    def UpdateFromProjection(self, dataProjection, coupledMeshIndex):
        """Update points connectivity with projection results, data projection identified by object

        :param dataProjection: The data projection to update points connectivity with
        :type dataProjection: DataProjection
        :param coupledMeshIndex: The mesh index of the the points connectivity to be updated
        :type coupledMeshIndex: int
        :rtype: None
        """

        pointsConnectivity = self
        return _wrap_routine(_iron_python.cmfe_InterfacePointsConnectivity_UpdateFromProjection, [pointsConnectivity, dataProjection, coupledMeshIndex])


class Interface(CMFEType):
    """Contains information about an interface.
    """

    def __init__(self):
        """Initialise a null cmfe_InterfaceType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_Interface_Initialise, None)

    def CoordinateSystemGet(self, CoordinateSystem):
        """Returns the coordinate system for an interface identified by an object.

        :param CoordinateSystem: On return, the interface coordinate system.
        :type CoordinateSystem: CoordinateSystem
        :rtype: None
        """

        Interface = self
        return _wrap_routine(_iron_python.cmfe_Interface_CoordinateSystemGet, [Interface, CoordinateSystem])

    def CoordinateSystemSet(self, coordinateSystem):
        """Sets/changes the coordinate system for an interface identified by an object.

        :param coordinateSystem: The coordinate system to set.
        :type coordinateSystem: CoordinateSystem
        :rtype: None
        """

        interface = self
        return _wrap_routine(_iron_python.cmfe_Interface_CoordinateSystemSet, [interface, coordinateSystem])

    def CreateFinish(self):
        """Finishes the creation of an interface identified by an object.

        :rtype: None
        """

        interface = self
        return _wrap_routine(_iron_python.cmfe_Interface_CreateFinish, [interface])

    def CreateStart(self, interfaceUserNumber, region):
        """Starts the creation of an interface identified by an object.

        :param interfaceUserNumber: The user number of the field to start the creation of.
        :type interfaceUserNumber: int
        :param region: The region to create the interface on.
        :type region: Region
        :rtype: None
        """

        interface = self
        return _wrap_routine(_iron_python.cmfe_Interface_CreateStart, [interfaceUserNumber, region, interface])

    def Destroy(self):
        """Destroys an interface identified by an object.

        :rtype: None
        """

        interface = self
        return _wrap_routine(_iron_python.cmfe_Interface_Destroy, [interface])

    def Finalise(self):
        """Finalises a cmfe_InterfaceType object.

        :rtype: None
        """

        cmfe_Interface = self
        return _wrap_routine(_iron_python.cmfe_Interface_Finalise, [cmfe_Interface])

    def LabelGet(self):
        """Returns the character string label for an interface identified by an object.

        :returns: label. The region label.
        :rtype: string
        """

        interface = self
        return _wrap_routine(_iron_python.cmfe_Interface_LabelGet, [interface])

    def LabelSet(self, label):
        """Sets/changes the character string label for an interface identified by an object.

        :param label: The interface label to set.
        :type label: string
        :rtype: None
        """

        interface = self
        return _wrap_routine(_iron_python.cmfe_Interface_LabelSet, [interface, label])

    def MeshAdd(self, mesh):
        """Adds a mesh to be coupled in an interface identified by an object.

        :param mesh: The mesh to add to the interface.
        :type mesh: Mesh
        :returns: meshIndex. The mesh index of the mesh in the list of coupled meshes in the interface.
        :rtype: int
        """

        interface = self
        return _wrap_routine(_iron_python.cmfe_Interface_MeshAdd, [interface, mesh])

    def NodesGet(self, nodes):
        """Returns the nodes for a interface identified by an object.

        :param nodes: On return, the interfaces nodes.
        :type nodes: Nodes
        :rtype: None
        """

        interface = self
        return _wrap_routine(_iron_python.cmfe_Interface_NodesGet, [interface, nodes])

    nodes = property(NodesGet, None, None, """The nodes for a interface identified by an object.""")

    coordinateSystem = property(CoordinateSystemGet, CoordinateSystemSet, None, """The coordinate system for an interface identified by an object.""")

    label = property(LabelGet, LabelSet, None, """The character string label for an interface identified by an object.""")


class MeshElements(CMFEType):
    """Contains information on a mesh elements defined in a mesh
    """

    def __init__(self):
        """Initialise a null cmfe_MeshElementsType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_MeshElements_Initialise, None)

    def AdjacentElementGet(self, globalElementNumber, adjacentElementXi):
        """Returns the adjacent element number of a mesh identified by an object.

        :param globalElementNumber: The global element number to get the adjacent element for !\todo this should be a user number
        :type globalElementNumber: int
        :param adjacentElementXi: The xi coordinate direction to get the adjacent element for  Note that -xiCoordinateDirection gives the adjacent element before the element in the xiCoordinateDirection'th direction and +xiCoordinateDirection gives the adjacent element after the element in the xiCoordinateDirection'th direction. The xiCoordinateDirection=0 index will give the information on the current element.
        :type adjacentElementXi: int
        :returns: adjacentElement. The adjacent element number in the specified xi coordinate direction. Return 0 if the specified element has no adjacent elements in the specified xi coordinate direction.
        :rtype: int
        """

        meshElements = self
        return _wrap_routine(_iron_python.cmfe_MeshElements_AdjacentElementGet, [meshElements, globalElementNumber, adjacentElementXi])

    def BasisGet(self, globalElementNumber, basis):
        """Returns the basis for an element in a mesh identified by an object. \todo should the global element number be a user number?

        :param globalElementNumber: The global element number to get the basis for.
        :type globalElementNumber: int
        :param basis: On return, the basis for the element.
        :type basis: Basis
        :rtype: None
        """

        meshElements = self
        return _wrap_routine(_iron_python.cmfe_MeshElements_BasisGet, [meshElements, globalElementNumber, basis])

    def BasisSet(self, globalElementNumber, basis):
        """Sets/changes the basis for an element in a mesh identified by an object. \todo should the global element number be a user number?

        :param globalElementNumber: The global element number to set the basis for.
        :type globalElementNumber: int
        :param basis: The basis for the element to set.
        :type basis: Basis
        :rtype: None
        """

        meshElements = self
        return _wrap_routine(_iron_python.cmfe_MeshElements_BasisSet, [meshElements, globalElementNumber, basis])

    def CreateFinish(self):
        """Finishes creating elements for a mesh component of a mesh identified by an object.

        :rtype: None
        """

        meshElements = self
        return _wrap_routine(_iron_python.cmfe_MeshElements_CreateFinish, [meshElements])

    def CreateStart(self, mesh, meshComponentNumber, basis):
        """Starts creating elements for a mesh component of a mesh identified by an object.

        :param mesh: The mesh to start the creation of elements for.
        :type mesh: Mesh
        :param meshComponentNumber: The mesh component number of the mesh to start creating the elements for.
        :type meshComponentNumber: int
        :param basis: The default basis to use for the elements.
        :type basis: Basis
        :rtype: None
        """

        meshElements = self
        return _wrap_routine(_iron_python.cmfe_MeshElements_CreateStart, [mesh, meshComponentNumber, basis, meshElements])

    def Finalise(self):
        """Finalises a cmfe_MeshElementsType object.

        :rtype: None
        """

        cmfe_MeshElements = self
        return _wrap_routine(_iron_python.cmfe_MeshElements_Finalise, [cmfe_MeshElements])

    def LocalElementNodeVersionSet(self, globalElementNumber, versionNumber, derivativeNumber, localElementNodeNumber):
        """Sets/changes the element nodes for an element in a mesh identified by an object. \todo should the global element number be a user number?

        :param globalElementNumber: The global element number to set the element nodes for.
        :type globalElementNumber: int
        :param versionNumber: The version number of the specified element node to set.
        :type versionNumber: int
        :param derivativeNumber: The derivative number of the specified element node to set.
        :type derivativeNumber: int
        :param localElementNodeNumber: The local element node to set a version for.
        :type localElementNodeNumber: int
        :rtype: None
        """

        meshElements = self
        return _wrap_routine(_iron_python.cmfe_MeshElements_LocalElementNodeVersionSet, [meshElements, globalElementNumber, versionNumber, derivativeNumber, localElementNodeNumber])

    def NodesGet(self, globalElementNumber, elementUserNodesSize):
        """Returns the element nodes for an element in a mesh identified by an object. \todo should the global element number be a user number?

        :param globalElementNumber: The global element number to get the element nodes for.
        :type globalElementNumber: int
        :param elementUserNodesSize: Size of elementUserNodes to allocate.
        :returns: elementUserNodes. elementUserNodes(i). On return, the user node number number of the i'th element node.
        :rtype: Array of ints
        """

        meshElements = self
        return _wrap_routine(_iron_python.cmfe_MeshElements_NodesGet, [meshElements, globalElementNumber, elementUserNodesSize])

    def NodesSet(self, globalElementNumber, elementUserNodes):
        """Sets/changes the element nodes for an element in a mesh identified by an object. \todo should the global element number be a user number?

        :param globalElementNumber: The global element number to set the element nodes for.
        :type globalElementNumber: int
        :param elementUserNodes: elementUserNodes(i). The user node number number of the i'th element node to set.
        :type elementUserNodes: Array of ints
        :rtype: None
        """

        meshElements = self
        return _wrap_routine(_iron_python.cmfe_MeshElements_NodesSet, [meshElements, globalElementNumber, elementUserNodes])

    def UserNodeVersionSet(self, globalElementNumber, versionNumber, derivativeNumber, userNodeNumber):
        """Sets/changes the element nodes for an element in a mesh identified by an object. \todo should the global element number be a user number?

        :param globalElementNumber: The global element number to set the element nodes for.
        :type globalElementNumber: int
        :param versionNumber: The version number of the specified element node to set.
        :type versionNumber: int
        :param derivativeNumber: The derivative number of the specified element node to set.
        :type derivativeNumber: int
        :param userNodeNumber: The user node number to set a version for.
        :type userNodeNumber: int
        :rtype: None
        """

        meshElements = self
        return _wrap_routine(_iron_python.cmfe_MeshElements_UserNodeVersionSet, [meshElements, globalElementNumber, versionNumber, derivativeNumber, userNodeNumber])

    def UserNumberGet(self, elementGlobalNumber):
        """Returns the element user number for an element in a mesh identified by an object.

        :param elementGlobalNumber: The global element number to get the element user number for.
        :type elementGlobalNumber: int
        :returns: elementUserNumber. The element user number.
        :rtype: int
        """

        meshElements = self
        return _wrap_routine(_iron_python.cmfe_MeshElements_UserNumberGet, [meshElements, elementGlobalNumber])

    def UserNumberSet(self, elementGlobalNumber, elementUserNumber):
        """Sets/changes the element user number for an element in a mesh identified by an object.

        :param elementGlobalNumber: The global element number to set the element user number for.
        :type elementGlobalNumber: int
        :param elementUserNumber: The element user number to set.
        :type elementUserNumber: int
        :rtype: None
        """

        meshElements = self
        return _wrap_routine(_iron_python.cmfe_MeshElements_UserNumberSet, [meshElements, elementGlobalNumber, elementUserNumber])

    def UserNumbersAllSet(self, elementUserNumbers):
        """Sets/changes the element user numbers for all elements in a mesh identified by an object.

        :param elementUserNumbers: The element user numbers to set.
        :type elementUserNumbers: Array of ints
        :rtype: None
        """

        meshElements = self
        return _wrap_routine(_iron_python.cmfe_MeshElements_UserNumbersAllSet, [meshElements, elementUserNumbers])

    userNumbersAll = property(None, UserNumbersAllSet, None, """The element user numbers for all elements in a mesh identified by an object.""")


class MeshEmbedding(CMFEType):
    """Contains information on an embedded mesh
    """

    def __init__(self):
        """Initialise a null cmfe_MeshEmbeddingType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_MeshEmbedding_Initialise, None)

    def Create(self, parentMesh, childMesh):
        """Creates a mesh embedding

        :param parentMesh: The parent and child meshes
        :type parentMesh: Mesh
        :param childMesh: The parent and child meshes
        :type childMesh: Mesh
        :rtype: None
        """

        meshEmbedding = self
        return _wrap_routine(_iron_python.cmfe_MeshEmbedding_Create, [meshEmbedding, parentMesh, childMesh])

    def PullGaussPointData(self, parentField, parentComponent, childField, childComponent):
        """:param parentField: Fields associated with parent and child mesh to get/set data from
        :type parentField: Field
        :param parentComponent: Component numbers in respective fields
        :type parentComponent: int
        :param childField: Fields associated with parent and child mesh to get/set data from
        :type childField: Field
        :param childComponent: Component numbers in respective fields
        :type childComponent: int
        :rtype: None
        """

        meshEmbedding = self
        return _wrap_routine(_iron_python.cmfe_MeshEmbedding_PullGaussPointData, [meshEmbedding, parentField, parentComponent, childField, childComponent])

    def PushData(self, parentField, parentComponent, childField, childComponent):
        """Pushes data to embedded mesh. Will generally be used at library and not API level. /TODO: Parameter set etc, function name?

        :param parentField: Fields associated with parent and child mesh to get/set data from
        :type parentField: Field
        :param parentComponent: Component numbers in respective fields
        :type parentComponent: int
        :param childField: Fields associated with parent and child mesh to get/set data from
        :type childField: Field
        :param childComponent: Component numbers in respective fields
        :type childComponent: int
        :rtype: None
        """

        meshEmbedding = self
        return _wrap_routine(_iron_python.cmfe_MeshEmbedding_PushData, [meshEmbedding, parentField, parentComponent, childField, childComponent])

    def SetChildNodePosition(self, elementNumber, nodeNumbers, xiCoords):
        """Sets the embedded nodes for one parent element

        :param elementNumber: Parent element number
        :type elementNumber: int
        :param nodeNumbers: Node numbers in child mesh
        :type nodeNumbers: Array of ints
        :param xiCoords: Xi coordinates of embedded nodes wrt parent element
        :type xiCoords: 2d array of floats
        :rtype: None
        """

        meshEmbedding = self
        return _wrap_routine(_iron_python.cmfe_MeshEmbedding_SetChildNodePosition, [meshEmbedding, elementNumber, nodeNumbers, xiCoords])

    def SetGaussPointData(self, parentElementNumber, gaussPointNumber, parentXiCoords, childElementNumber, childXiCoords):
        """:param parentElementNumber: Parent element number
        :type parentElementNumber: int
        :param gaussPointNumber: Gauss point number in this element
        :type gaussPointNumber: int
        :param parentXiCoords: Xi coordinates of embedded nodes wrt parent element
        :type parentXiCoords: Array of floats
        :param childElementNumber: Child element number
        :type childElementNumber: int
        :param childXiCoords: Xi coordinates of embedded nodes wrt Child element
        :type childXiCoords: Array of floats
        :rtype: None
        """

        meshEmbedding = self
        return _wrap_routine(_iron_python.cmfe_MeshEmbedding_SetGaussPointData, [meshEmbedding, parentElementNumber, gaussPointNumber, parentXiCoords, childElementNumber, childXiCoords])


class MeshNodes(CMFEType):
    """Contains information on a mesh nodes defined in a mesh
    """

    def __init__(self):
        """Initialise a null cmfe_MeshNodesType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_MeshNodes_Initialise, None)

    def DerivativesGet(self, userNodeNumber, derivativesSize):
        """Returns the derivatives for a node in a mesh identified by an object.

        :param userNodeNumber: The user node number to get the derivatives at a node for.
        :type userNodeNumber: int
        :param derivativesSize: Size of derivatives to allocate.
        :returns: derivatives. The derivatives at a node in a mesh.
        :rtype: Array of ints
        """

        meshNodes = self
        return _wrap_routine(_iron_python.cmfe_MeshNodes_DerivativesGet, [meshNodes, userNodeNumber, derivativesSize])

    def Finalise(self):
        """Finalises a cmfe_MeshNodesType object.

        :rtype: None
        """

        cmfe_MeshNodes = self
        return _wrap_routine(_iron_python.cmfe_MeshNodes_Finalise, [cmfe_MeshNodes])

    def NumberOfDerivativesGet(self, userNodeNumber):
        """Returns the number of derivatives for a node in a mesh identified by an object.

        :param userNodeNumber: The user node number to get the number of derivatives at a node for.
        :type userNodeNumber: int
        :returns: numberOfDerivatives. The number of derivatives at a node in a mesh.
        :rtype: int
        """

        meshNodes = self
        return _wrap_routine(_iron_python.cmfe_MeshNodes_NumberOfDerivativesGet, [meshNodes, userNodeNumber])

    def NumberOfNodesGet(self):
        """Returns the number of derivatives for a node in a mesh identified by an object.

        :returns: numberOfNodes. The number of nodes in a mesh.
        :rtype: int
        """

        meshNodes = self
        return _wrap_routine(_iron_python.cmfe_MeshNodes_NumberOfNodesGet, [meshNodes])

    def NumberOfVersionsGet(self, derivativeNumber, userNodeNumber):
        """Returns the number of versions for an node in a mesh identified by an object.

        :param derivativeNumber: The derivative number of a node to get the number of versions for.
        :type derivativeNumber: int
        :param userNodeNumber: The user node number to get the number of versions at a node for.
        :type userNodeNumber: int
        :returns: numberOfVersions. The number of derivatives at the specified node and derivative in a mesh.
        :rtype: int
        """

        meshNodes = self
        return _wrap_routine(_iron_python.cmfe_MeshNodes_NumberOfVersionsGet, [meshNodes, derivativeNumber, userNodeNumber])

    numberOfNodes = property(NumberOfNodesGet, None, None, """The number of derivatives for a node in a mesh identified by an object.""")


class Mesh(CMFEType):
    """Contains information on a mesh defined on a region.
    """

    def __init__(self):
        """Initialise a null cmfe_MeshType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_Mesh_Initialise, None)

    def CreateFinish(self):
        """Finishes the creation of a mesh for a mesh identified by an object.

        :rtype: None
        """

        mesh = self
        return _wrap_routine(_iron_python.cmfe_Mesh_CreateFinish, [mesh])

    def CreateStartInterface(self, meshUserNumber, interface, numberOfDimensions):
        """Starts the creation of a mesh for a mesh identified by an object.

        :param meshUserNumber: The user number of the mesh to start the creation of.
        :type meshUserNumber: int
        :param interface: The interface containing the mesh to start the creation of.
        :type interface: Interface
        :param numberOfDimensions: The number of dimensions for the mesh.
        :type numberOfDimensions: int
        :rtype: None
        """

        mesh = self
        return _wrap_routine(_iron_python.cmfe_Mesh_CreateStartInterface, [meshUserNumber, interface, numberOfDimensions, mesh])

    def CreateStart(self, meshUserNumber, region, numberOfDimensions):
        """Starts the creation of a mesh for a mesh identified by an object.

        :param meshUserNumber: The user number of the mesh to start the creation of.
        :type meshUserNumber: int
        :param region: The region containing the mesh to start the creation of.
        :type region: Region
        :param numberOfDimensions: The number of dimensions for the mesh.
        :type numberOfDimensions: int
        :rtype: None
        """

        mesh = self
        return _wrap_routine(_iron_python.cmfe_Mesh_CreateStart, [meshUserNumber, region, numberOfDimensions, mesh])

    def Destroy(self):
        """Destroys a mesh identified by an object.

        :rtype: None
        """

        mesh = self
        return _wrap_routine(_iron_python.cmfe_Mesh_Destroy, [mesh])

    def ElementExists(self, meshComponentNumber, elementUserNumber):
        """Checks if the given element exists on the given mesh component.

        :param meshComponentNumber: The mesh component number to check the element for.
        :type meshComponentNumber: int
        :param elementUserNumber: The user number of the element to check.
        :type elementUserNumber: int
        :returns: elementExists. True if the element exists, false otherwise.
        :rtype: bool
        """

        mesh = self
        return _wrap_routine(_iron_python.cmfe_Mesh_ElementExists, [mesh, meshComponentNumber, elementUserNumber])

    def ElementsGet(self, meshComponentNumber, meshElements):
        """:param meshComponentNumber: The mesh component number to get the elements for.
        :type meshComponentNumber: int
        :param meshElements: The mesh elements.
        :type meshElements: MeshElements
        :rtype: None
        """

        mesh = self
        return _wrap_routine(_iron_python.cmfe_Mesh_ElementsGet, [mesh, meshComponentNumber, meshElements])

    def Finalise(self):
        """Finalises a cmfe_MeshType object.

        :rtype: None
        """

        cmfe_Mesh = self
        return _wrap_routine(_iron_python.cmfe_Mesh_Finalise, [cmfe_Mesh])

    def NodeExists(self, meshComponentNumber, nodeUserNumber):
        """Checks if the given node exists on the given mesh component.

        :param meshComponentNumber: The mesh component number to check the node for.
        :type meshComponentNumber: int
        :param nodeUserNumber: The user number of the node to check.
        :type nodeUserNumber: int
        :returns: nodeExists. True if the node exists, false otherwise.
        :rtype: bool
        """

        mesh = self
        return _wrap_routine(_iron_python.cmfe_Mesh_NodeExists, [mesh, meshComponentNumber, nodeUserNumber])

    def NodesGet(self, meshComponentNumber, meshNodes):
        """Returns the mesh nodes for a mesh component on a mesh identified by an object.

        :param meshComponentNumber: The mesh component number to get the nodes for.
        :type meshComponentNumber: int
        :param meshNodes: On return, the mesh nodes.
        :type meshNodes: MeshNodes
        :rtype: None
        """

        mesh = self
        return _wrap_routine(_iron_python.cmfe_Mesh_NodesGet, [mesh, meshComponentNumber, meshNodes])

    def NumberOfComponentsGet(self):
        """Returns the number of components in a mesh identified by an object.

        :returns: numberOfComponents. The number of components in the mesh.
        :rtype: int
        """

        mesh = self
        return _wrap_routine(_iron_python.cmfe_Mesh_NumberOfComponentsGet, [mesh])

    def NumberOfComponentsSet(self, numberOfComponents):
        """Sets/changes the number of components in a mesh identified by an object.

        :param numberOfComponents: The number of components in the mesh to set.
        :type numberOfComponents: int
        :rtype: None
        """

        mesh = self
        return _wrap_routine(_iron_python.cmfe_Mesh_NumberOfComponentsSet, [mesh, numberOfComponents])

    def NumberOfElementsGet(self):
        """Returns the number of elements in a mesh identified by an object.

        :returns: numberOfElements. The number of elements in the mesh.
        :rtype: int
        """

        mesh = self
        return _wrap_routine(_iron_python.cmfe_Mesh_NumberOfElementsGet, [mesh])

    def NumberOfElementsSet(self, numberOfElements):
        """Sets/changes the number of elements in a mesh identified by an object.

        :param numberOfElements: The number of elements in the mesh to set.
        :type numberOfElements: int
        :rtype: None
        """

        mesh = self
        return _wrap_routine(_iron_python.cmfe_Mesh_NumberOfElementsSet, [mesh, numberOfElements])

    def SurroundingElementsCalculateSet(self, surroundingElementsCalculateFlag):
        """Sets/changes the surrounding elements calculate flag.

        :param surroundingElementsCalculateFlag: Boolean flag to determine whether to calculate surrounding elements.
        :type surroundingElementsCalculateFlag: bool
        :rtype: None
        """

        mesh = self
        return _wrap_routine(_iron_python.cmfe_Mesh_SurroundingElementsCalculateSet, [mesh, surroundingElementsCalculateFlag])

    def TopologyDataPointsCalculateProjection(self, DataProjection):
        """Calculate mesh data points topology identified by object based on projection

        :param DataProjection: The data projection
        :type DataProjection: DataProjection
        :rtype: None
        """

        Mesh = self
        return _wrap_routine(_iron_python.cmfe_Mesh_TopologyDataPointsCalculateProjection, [Mesh, DataProjection])

    numberOfComponents = property(NumberOfComponentsGet, NumberOfComponentsSet, None, """The number of components in a mesh identified by an object.""")

    surroundingElementsCalculate = property(None, SurroundingElementsCalculateSet, None, """The surrounding elements calculate flag.""")

    numberOfElements = property(NumberOfElementsGet, NumberOfElementsSet, None, """The number of elements in a mesh identified by an object.""")


class Nodes(CMFEType):
    """Contains information on the nodes defined on a region.
    """

    def __init__(self):
        """Initialise a null cmfe_NodesType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_Nodes_Initialise, None)

    def CreateFinish(self):
        """Finishes the creation of a nodes in a region for nodes identified by an object.

        :rtype: None
        """

        nodes = self
        return _wrap_routine(_iron_python.cmfe_Nodes_CreateFinish, [nodes])

    def CreateStartInterface(self, interface, numberOfNodes):
        """Starts the creation of a nodes in a region for nodes identified by an object.

        :param interface: The interface to start the creation of nodes on.
        :type interface: Interface
        :param numberOfNodes: The number of nodes to create.
        :type numberOfNodes: int
        :rtype: None
        """

        nodes = self
        return _wrap_routine(_iron_python.cmfe_Nodes_CreateStartInterface, [interface, numberOfNodes, nodes])

    def CreateStart(self, region, numberOfNodes):
        """Starts the creation of a nodes in a region for nodes identified by an object.

        :param region: The region to start the creation of nodes on.
        :type region: Region
        :param numberOfNodes: The number of nodes to create.
        :type numberOfNodes: int
        :rtype: None
        """

        nodes = self
        return _wrap_routine(_iron_python.cmfe_Nodes_CreateStart, [region, numberOfNodes, nodes])

    def Destroy(self):
        """Destroys the nodes in a region for nodes identified by an object.

        :rtype: None
        """

        nodes = self
        return _wrap_routine(_iron_python.cmfe_Nodes_Destroy, [nodes])

    def Finalise(self):
        """Finalises a cmfe_NodesType object.

        :rtype: None
        """

        cmfe_Nodes = self
        return _wrap_routine(_iron_python.cmfe_Nodes_Finalise, [cmfe_Nodes])

    def LabelGet(self, nodeGlobalNumber):
        """Returns the character label for a node in a set of nodes identified by an object. \todo should this be user number??

        :param nodeGlobalNumber: The global number of the nodes to get the label for.
        :type nodeGlobalNumber: int
        :returns: label. The label for the node.
        :rtype: string
        """

        nodes = self
        return _wrap_routine(_iron_python.cmfe_Nodes_LabelGet, [nodes, nodeGlobalNumber])

    def LabelSet(self, nodeGlobalNumber, label):
        """Sets/changes the character label for a node in a set of nodes identified by an object. \todo should this be user number??

        :param nodeGlobalNumber: The global number of the nodes to set the label for.
        :type nodeGlobalNumber: int
        :param label: The label for the node to set.
        :type label: string
        :rtype: None
        """

        nodes = self
        return _wrap_routine(_iron_python.cmfe_Nodes_LabelSet, [nodes, nodeGlobalNumber, label])

    def NumberOfNodesGet(self):
        """Returns the number of nodes

        :returns: numberOfNodes. The number of nodes
        :rtype: int
        """

        nodes = self
        return _wrap_routine(_iron_python.cmfe_Nodes_NumberOfNodesGet, [nodes])

    def UserNumberGet(self, nodeGlobalNumber):
        """Returns the user number for a node in a set of nodes identified by an object. \todo should this be user number??

        :param nodeGlobalNumber: The global number of the nodes to get the node user number for.
        :type nodeGlobalNumber: int
        :returns: nodeUserNumber. The user number for the node.
        :rtype: int
        """

        nodes = self
        return _wrap_routine(_iron_python.cmfe_Nodes_UserNumberGet, [nodes, nodeGlobalNumber])

    def UserNumberSet(self, nodeGlobalNumber, nodeUserNumber):
        """Sets/changes the user number for a node in a set of nodes identified by an object. \todo should this be user number??

        :param nodeGlobalNumber: The global number of the nodes to set the node user number for.
        :type nodeGlobalNumber: int
        :param nodeUserNumber: The user number for the node to set.
        :type nodeUserNumber: int
        :rtype: None
        """

        nodes = self
        return _wrap_routine(_iron_python.cmfe_Nodes_UserNumberSet, [nodes, nodeGlobalNumber, nodeUserNumber])

    def UserNumbersAllSet(self, nodeUserNumbers):
        """Sets/changes the user numbers for a set of nodes identified by an object.

        :param nodeUserNumbers: The user numbers for the nodes to set.
        :type nodeUserNumbers: Array of ints
        :rtype: None
        """

        nodes = self
        return _wrap_routine(_iron_python.cmfe_Nodes_UserNumbersAllSet, [nodes, nodeUserNumbers])

    userNumbersAll = property(None, UserNumbersAllSet, None, """The user numbers for a set of nodes identified by an object.""")

    numberOfNodes = property(NumberOfNodesGet, None, None, """The number of nodes""")


class Problem(CMFEType):
    """Contains information for a problem.
    """

    def __init__(self):
        """Initialise a null cmfe_ProblemType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_Problem_Initialise, None)

    def CellMLEquationsCreateFinish(self):
        """Finishes the creation of CellML equations for problem identified by an object.

        :rtype: None
        """

        problem = self
        return _wrap_routine(_iron_python.cmfe_Problem_CellMLEquationsCreateFinish, [problem])

    def CellMLEquationsCreateStart(self):
        """Starts the creation of CellML equations for problem identified by an object.

        :rtype: None
        """

        problem = self
        return _wrap_routine(_iron_python.cmfe_Problem_CellMLEquationsCreateStart, [problem])

    def CellMLEquationsGet(self, controlLoopIdentifiers, solverIndex, CellMLEquations):
        """Returns the CellML equations from a problem identified by an object.

        :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the CellML equations for.
        :type controlLoopIdentifiers: Array of ints
        :param solverIndex: The solver index to get the CellML equations for.
        :type solverIndex: int
        :param CellMLEquations: On return, the specified CellML equations.
        :type CellMLEquations: CellMLEquations
        :rtype: None
        """

        problem = self
        return _wrap_routine(_iron_python.cmfe_Problem_CellMLEquationsGet, [problem, controlLoopIdentifiers, solverIndex, CellMLEquations])

    def ControlLoopCreateFinish(self):
        """Finishes the creation of a control loop on a problem identified by an object.

        :rtype: None
        """

        problem = self
        return _wrap_routine(_iron_python.cmfe_Problem_ControlLoopCreateFinish, [problem])

    def ControlLoopCreateStart(self):
        """Starts the creation of a control loop on a problem identified by an object.

        :rtype: None
        """

        problem = self
        return _wrap_routine(_iron_python.cmfe_Problem_ControlLoopCreateStart, [problem])

    def ControlLoopDestroy(self):
        """Destroys the control loops on a problem identified by an object.

        :rtype: None
        """

        problem = self
        return _wrap_routine(_iron_python.cmfe_Problem_ControlLoopDestroy, [problem])

    def ControlLoopGet(self, controlLoopIdentifiers, controlLoop):
        """Returns a control loop from a problem identified by an object.

        :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the control loop for.
        :type controlLoopIdentifiers: Array of ints
        :param controlLoop: On return, the specified problem control loop.
        :type controlLoop: ControlLoop
        :rtype: None
        """

        problem = self
        return _wrap_routine(_iron_python.cmfe_Problem_ControlLoopGet, [problem, controlLoopIdentifiers, controlLoop])

    def CreateFinish(self):
        """Finishes the creation of a problem identified by an object.

        :rtype: None
        """

        problem = self
        return _wrap_routine(_iron_python.cmfe_Problem_CreateFinish, [problem])

    def CreateStart(self, problemUserNumber, problemSpecification):
        """Starts the creation of a problem identified by an object.

        :param problemUserNumber: The user number of the problem to start the creation of.
        :type problemUserNumber: int
        :param problemSpecification: The problem specification array, containt the problem class, type etc
        :type problemSpecification: Array of ints
        :rtype: None
        """

        problem = self
        return _wrap_routine(_iron_python.cmfe_Problem_CreateStart, [problemUserNumber, problemSpecification, problem])

    def Destroy(self):
        """Destroys a problem identified by an object.

        :rtype: None
        """

        problem = self
        return _wrap_routine(_iron_python.cmfe_Problem_Destroy, [problem])

    def Finalise(self):
        """Finalises a cmfe_ProblemType object.

        :rtype: None
        """

        cmfe_Problem = self
        return _wrap_routine(_iron_python.cmfe_Problem_Finalise, [cmfe_Problem])

    def Solve(self):
        """Solves a problem identified by an object.

        :rtype: None
        """

        problem = self
        return _wrap_routine(_iron_python.cmfe_Problem_Solve, [problem])

    def SolverEquationsCreateFinish(self):
        """Finishes the creation of solver equations for problem identified by an object.

        :rtype: None
        """

        problem = self
        return _wrap_routine(_iron_python.cmfe_Problem_SolverEquationsCreateFinish, [problem])

    def SolverEquationsCreateStart(self):
        """Starts the creation of solver equations for problem identified by an object.

        :rtype: None
        """

        problem = self
        return _wrap_routine(_iron_python.cmfe_Problem_SolverEquationsCreateStart, [problem])

    def SolverEquationsDestroy(self):
        """Destroys the solver equations for problem identified by an object.

        :rtype: None
        """

        problem = self
        return _wrap_routine(_iron_python.cmfe_Problem_SolverEquationsDestroy, [problem])

    def SolverEquationsGet(self, controlLoopIdentifiers, solverIndex, solverEquations):
        """Returns the solver equations from a problem identified by an object.

        :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the solver equations for.
        :type controlLoopIdentifiers: Array of ints
        :param solverIndex: The solver index to get the solver equations for.
        :type solverIndex: int
        :param solverEquations: On return, the specified solver equations.
        :type solverEquations: SolverEquations
        :rtype: None
        """

        problem = self
        return _wrap_routine(_iron_python.cmfe_Problem_SolverEquationsGet, [problem, controlLoopIdentifiers, solverIndex, solverEquations])

    def SolverGet(self, controlLoopIdentifiers, solverIndex, solver):
        """Returns a solver from a problem identified by an object.

        :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the solver for.
        :type controlLoopIdentifiers: Array of ints
        :param solverIndex: The solver index to get the solver for.
        :type solverIndex: int
        :param solver: On return, the specified solver.
        :type solver: Solver
        :rtype: None
        """

        problem = self
        return _wrap_routine(_iron_python.cmfe_Problem_SolverGet, [problem, controlLoopIdentifiers, solverIndex, solver])

    def SolversCreateFinish(self):
        """Finishes the creation of solvers for problem identified by an object.

        :rtype: None
        """

        problem = self
        return _wrap_routine(_iron_python.cmfe_Problem_SolversCreateFinish, [problem])

    def SolversCreateStart(self):
        """Starts the creation of solvers for problem identified by an object.

        :rtype: None
        """

        problem = self
        return _wrap_routine(_iron_python.cmfe_Problem_SolversCreateStart, [problem])

    def SolversDestroy(self):
        """Destroys the solvers for problem identified by an object.

        :rtype: None
        """

        problem = self
        return _wrap_routine(_iron_python.cmfe_Problem_SolversDestroy, [problem])

    def SpecificationGet(self, problemSpecification):
        """Returns the specification array for a problem identified by an object.

        :param problemSpecification: On return, the problem specification array. Must be allocated and large enough to contain the specification on entry.
        :type problemSpecification: Array of ints
        :rtype: None
        """

        problem = self
        return _wrap_routine(_iron_python.cmfe_Problem_SpecificationGet, [problem, problemSpecification])

    def SpecificationSizeGet(self):
        """Returns the size of the specification array for a problem identified by an object.

        :returns: specificationSize. The size of the problem specification array.
        :rtype: int
        """

        problem = self
        return _wrap_routine(_iron_python.cmfe_Problem_SpecificationSizeGet, [problem])

    specification = property(SpecificationGet, None, None, """The specification array for a problem identified by an object.""")

    specificationSize = property(SpecificationSizeGet, None, None, """The size of the specification array for a problem identified by an object.""")


class Quadrature(CMFEType):
    """Contains information for a particular quadrature scheme for a basis.
    """

    def __init__(self):
        """Initialise a null cmfe_QuadratureType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_Quadrature_Initialise, None)

    def Finalise(self):
        """Finalises a cmfe_QuadratureType object.

        :rtype: None
        """

        cmfe_Quadrature = self
        return _wrap_routine(_iron_python.cmfe_Quadrature_Finalise, [cmfe_Quadrature])


class Region(CMFEType):
    """Contains information for a region.
    """

    def __init__(self):
        """Initialise a null cmfe_RegionType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_Region_Initialise, None)

    def CoordinateSystemGet(self, coordinateSystem):
        """Returns the coordinate system for a region identified by an object.

        :param coordinateSystem: On return, the regions coordinate system.
        :type coordinateSystem: CoordinateSystem
        :rtype: None
        """

        region = self
        return _wrap_routine(_iron_python.cmfe_Region_CoordinateSystemGet, [region, coordinateSystem])

    def CoordinateSystemSet(self, coordinateSystem):
        """Sets/changes the coordinate system for a region identified by an object.

        :param coordinateSystem: The coordinate system to set.
        :type coordinateSystem: CoordinateSystem
        :rtype: None
        """

        region = self
        return _wrap_routine(_iron_python.cmfe_Region_CoordinateSystemSet, [region, coordinateSystem])

    def CreateFinish(self):
        """Finishes the creation of a region identified by an object.

        :rtype: None
        """

        region = self
        return _wrap_routine(_iron_python.cmfe_Region_CreateFinish, [region])

    def CreateStart(self, regionUserNumber, parentRegion):
        """Starts the creation of a region identified by an object.

        :param regionUserNumber: The user number of the region to start the creation of.
        :type regionUserNumber: int
        :param parentRegion: The parent region to  to start the creation of the region in.
        :type parentRegion: Region
        :rtype: None
        """

        region = self
        return _wrap_routine(_iron_python.cmfe_Region_CreateStart, [regionUserNumber, parentRegion, region])

    def DataPointsGet(self, dataPoints):
        """Returns the data points for a region identified by an object.

        :param dataPoints: On return, the regions data points.
        :type dataPoints: DataPoints
        :rtype: None
        """

        region = self
        return _wrap_routine(_iron_python.cmfe_Region_DataPointsGet, [region, dataPoints])

    def Destroy(self):
        """Destroys a region identified by an object.

        :rtype: None
        """

        region = self
        return _wrap_routine(_iron_python.cmfe_Region_Destroy, [region])

    def Finalise(self):
        """Finalises a cmfe_RegionType object.

        :rtype: None
        """

        cmfe_Region = self
        return _wrap_routine(_iron_python.cmfe_Region_Finalise, [cmfe_Region])

    def LabelGet(self):
        """Returns the character string label for a region identified by an object.

        :returns: label. The region label.
        :rtype: string
        """

        region = self
        return _wrap_routine(_iron_python.cmfe_Region_LabelGet, [region])

    def LabelSet(self, label):
        """Sets/changes the character string label for a region identified by an object.

        :param label: The region label to set.
        :type label: string
        :rtype: None
        """

        region = self
        return _wrap_routine(_iron_python.cmfe_Region_LabelSet, [region, label])

    def NodesGet(self, nodes):
        """Returns the nodes for a region identified by an object.

        :param nodes: On return, the regions nodes.
        :type nodes: Nodes
        :rtype: None
        """

        region = self
        return _wrap_routine(_iron_python.cmfe_Region_NodesGet, [region, nodes])

    dataPoints = property(DataPointsGet, None, None, """The data points for a region identified by an object.""")

    nodes = property(NodesGet, None, None, """The nodes for a region identified by an object.""")

    coordinateSystem = property(CoordinateSystemGet, CoordinateSystemSet, None, """The coordinate system for a region identified by an object.""")

    label = property(LabelGet, LabelSet, None, """The character string label for a region identified by an object.""")


class SolverEquations(CMFEType):
    """Contains information about the solver equations for a solver.
    """

    def __init__(self):
        """Initialise a null cmfe_SolverEquationsType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_SolverEquations_Initialise, None)

    def BoundaryConditionsAnalytic(self):
        """Set boundary conditions for solver equations according to the analytic equations.

        :rtype: None
        """

        solverEquations = self
        return _wrap_routine(_iron_python.cmfe_SolverEquations_BoundaryConditionsAnalytic, [solverEquations])

    def BoundaryConditionsCreateFinish(self):
        """Finish the creation of the boundary conditions for the solver equations

        :rtype: None
        """

        solverEquations = self
        return _wrap_routine(_iron_python.cmfe_SolverEquations_BoundaryConditionsCreateFinish, [solverEquations])

    def BoundaryConditionsCreateStart(self, boundaryConditions):
        """Start the creation of the boundary conditions for the solver equations

        :param boundaryConditions: On return, the created boundary conditions.
        :type boundaryConditions: BoundaryConditions
        :rtype: None
        """

        solverEquations = self
        return _wrap_routine(_iron_python.cmfe_SolverEquations_BoundaryConditionsCreateStart, [solverEquations, boundaryConditions])

    def BoundaryConditionsGet(self, boundaryConditions):
        """Get the boundary conditions for solver equations

        :param boundaryConditions: On return, The boundary conditions for the specified solver equations.
        :type boundaryConditions: BoundaryConditions
        :rtype: None
        """

        solverEquations = self
        return _wrap_routine(_iron_python.cmfe_SolverEquations_BoundaryConditionsGet, [solverEquations, boundaryConditions])

    def EquationsSetAdd(self, equationsSet):
        """Adds equations sets to solver equations identified by an object.

        :param equationsSet: The equations set to add.
        :type equationsSet: EquationsSet
        :returns: equationsSetIndex. The index of the added equations set in the solver equations.
        :rtype: int
        """

        solverEquations = self
        return _wrap_routine(_iron_python.cmfe_SolverEquations_EquationsSetAdd, [solverEquations, equationsSet])

    def Finalise(self):
        """Finalises a cmfe_SolverEquationsType object.

        :rtype: None
        """

        cmfe_SolverEquations = self
        return _wrap_routine(_iron_python.cmfe_SolverEquations_Finalise, [cmfe_SolverEquations])

    def InterfaceConditionAdd(self, interfaceCondition):
        """Adds an interface condition to solver equations identified by an object.

        :param interfaceCondition: The interface condition to add.
        :type interfaceCondition: InterfaceCondition
        :returns: interfaceConditionIndex. The index of the added interface condition in the solver equations.
        :rtype: int
        """

        solverEquations = self
        return _wrap_routine(_iron_python.cmfe_SolverEquations_InterfaceConditionAdd, [solverEquations, interfaceCondition])

    def JacobianMatrixGet(self, matrix):
        """Get the Jacobian matrix from the solver equations matrices for nonlinear solver equations

        :param matrix: On return, the solver equations Jacobian matrix
        :type matrix: DistributedMatrix
        :rtype: None
        """

        solverEquations = self
        return _wrap_routine(_iron_python.cmfe_SolverEquations_JacobianMatrixGet, [solverEquations, matrix])

    def MatrixGet(self, matrixIndex, matrix):
        """Get a solver matrix from the solver equations matrices

        :param matrixIndex: The solver matrix index to get
        :type matrixIndex: int
        :param matrix: On return, the requested solver matrix
        :type matrix: DistributedMatrix
        :rtype: None
        """

        solverEquations = self
        return _wrap_routine(_iron_python.cmfe_SolverEquations_MatrixGet, [solverEquations, matrixIndex, matrix])

    def NumberOfMatricesGet(self):
        """Get the number of solver matrices for the solver equations

        :returns: numberOfMatrices. The number of matrices for the solver equations
        :rtype: int
        """

        solverEquations = self
        return _wrap_routine(_iron_python.cmfe_SolverEquations_NumberOfMatricesGet, [solverEquations])

    def ResidualVectorGet(self, residualVector):
        """Get the residual vector from the solver equations for nonlinear problems

        :param residualVector: On return, the solver residual vector
        :type residualVector: DistributedVector
        :rtype: None
        """

        solverEquations = self
        return _wrap_routine(_iron_python.cmfe_SolverEquations_ResidualVectorGet, [solverEquations, residualVector])

    def RhsVectorGet(self, rhsVector):
        """Get the right hand side vector from the solver equations

        :param rhsVector: On return, the solver right hand side vector
        :type rhsVector: DistributedVector
        :rtype: None
        """

        solverEquations = self
        return _wrap_routine(_iron_python.cmfe_SolverEquations_RhsVectorGet, [solverEquations, rhsVector])

    def SparsityTypeSet(self, sparsityType):
        """Sets/changes the sparsity type for solver equations identified by an object.

        :param sparsityType: The sparsity type to set. Must be a value from the SolverEquationsSparsityTypes enum.
        :type sparsityType: int
        :rtype: None
        """

        solverEquations = self
        return _wrap_routine(_iron_python.cmfe_SolverEquations_SparsityTypeSet, [solverEquations, sparsityType])

    def VectorGet(self, matrixIndex, vector):
        """Get the vector assiciated with a solver matrix from the solver equations matrices

        :param matrixIndex: The solver matrix index to get the vector for
        :type matrixIndex: int
        :param vector: On return, the requested solver matrix vector
        :type vector: DistributedVector
        :rtype: None
        """

        solverEquations = self
        return _wrap_routine(_iron_python.cmfe_SolverEquations_VectorGet, [solverEquations, matrixIndex, vector])

    rhsVector = property(RhsVectorGet, None, None, """The right hand side vector from the solver equations""")

    boundaryConditions = property(BoundaryConditionsGet, None, None, """The boundary conditions for solver equations""")

    jacobianMatrix = property(JacobianMatrixGet, None, None, """The Jacobian matrix from the solver equations matrices for nonlinear solver equations""")

    numberOfMatrices = property(NumberOfMatricesGet, None, None, """The number of solver matrices for the solver equations""")

    residualVector = property(ResidualVectorGet, None, None, """The residual vector from the solver equations for nonlinear problems""")

    sparsityType = property(None, SparsityTypeSet, None, """The sparsity type for solver equations identified by an object.""")


class Solver(CMFEType):
    """Contains information about a solver.
    """

    def __init__(self):
        """Initialise a null cmfe_SolverType"""

        self.cmiss_type = _wrap_routine(_iron_python.cmfe_Solver_Initialise, None)

    def CellMLEquationsGet(self, CellMLEquations):
        """Returns the CellML equations for a solver identified by an object.

        :param CellMLEquations: On return, the CellML equations for the solver.
        :type CellMLEquations: CellMLEquations
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_CellMLEquationsGet, [solver, CellMLEquations])

    def DAEEulerSolverTypeGet(self):
        """Returns the solve type for an Euler differential-algebraic equation solver identified by an object.

        :returns: DAEEulerSolverType. The DAE Euler solver type. Will be a value from the EulerDAESolverTypes enum.
        :rtype: int
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_DAEEulerSolverTypeGet, [solver])

    def DAEEulerSolverTypeSet(self, DAEEulerSolverType):
        """Sets/changes the solve type for an Euler differential-algebraic equation solver identified by an object.

        :param DAEEulerSolverType: The DAE Euler solver type to set. Must be a value from the EulerDAESolverTypes enum.
        :type DAEEulerSolverType: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_DAEEulerSolverTypeSet, [solver, DAEEulerSolverType])

    def DAESolverTypeGet(self):
        """Returns the solve type for an differential-algebraic equation solver identified by an object.

        :returns: DAESolverType. The DAE solver type. Will be a value from the DAESolverTypes enum.
        :rtype: int
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_DAESolverTypeGet, [solver])

    def DAESolverTypeSet(self, DAESolverType):
        """Sets/changes the solve type for an differential-algebraic equation solver identified by an object.

        :param DAESolverType: The DAE solver type to set. Must be a value from the DAESolverTypes enum.
        :type DAESolverType: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_DAESolverTypeSet, [solver, DAESolverType])

    def DAETimeStepSet(self, timeStep):
        """Sets/changes the (initial) time step for an differential-algebraic equation solver identified by an object.

        :param timeStep: The (initial) time step for the differential-algebraic solver.
        :type timeStep: float
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_DAETimeStepSet, [solver, timeStep])

    def DAETimesSet(self, startTime, endTime):
        """Sets/changes the times for an differential-algebraic equation solver identified by an object.

        :param startTime: The start time for the differential-algebraic solver.
        :type startTime: float
        :param endTime: The end time for the differential-algebraic solver.
        :type endTime: float
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_DAETimesSet, [solver, startTime, endTime])

    def DynamicDegreeGet(self):
        """Returns the degree of the polynomial used to interpolate time for a dynamic solver identified by an object.

        :returns: degree. The dynamic degree. Will be a value from the DynamicDegreeTypes enum.
        :rtype: int
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_DynamicDegreeGet, [solver])

    def DynamicDegreeSet(self, degree):
        """Sets/changes the degree of the polynomial used to interpolate time for a dynamic solver identified by an object.

        :param degree: The dynamic degree to set. Must be a value from the DynamicDegreeTypes enum.
        :type degree: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_DynamicDegreeSet, [solver, degree])

    def DynamicLinearSolverGet(self, linearSolver):
        """Returns the linear solver associated with a linear dynamic solver identified by an object.

        :param linearSolver: On return, the dynamic linear solver.
        :type linearSolver: Solver
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_DynamicLinearSolverGet, [solver, linearSolver])

    def DynamicLinearityTypeGet(self):
        """Returns the linearity type for a dynamic solver identified by an object.

        :returns: linearityType. The dynamic linearity type. Will be a value from the DynamicLinearityTypes enum.
        :rtype: int
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_DynamicLinearityTypeGet, [solver])

    def DynamicNonlinearSolverGet(self, nonlinearSolver):
        """Returns the nonlinear solver associated with a nonlinear dynamic solver identified by an object.

        :param nonlinearSolver: On return, the dynamic nonlinear solver.
        :type nonlinearSolver: Solver
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_DynamicNonlinearSolverGet, [solver, nonlinearSolver])

    def DynamicSchemeSet(self, scheme):
        """Sets/changes the scheme for a dynamic solver identified by an object.

        :param scheme: The dynamic scheme to set. Must be a value from the DynamicSchemeTypes enum.
        :type scheme: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_DynamicSchemeSet, [solver, scheme])

    def DynamicThetaSet(self, thetas):
        """Sets/changes the theta for a dynamic solver identified by an object.

        :param thetas: thetas(i). The i'th dynamic theta to set.
        :type thetas: Array of floats
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_DynamicThetaSet, [solver, thetas])

    def DynamicTimesSet(self, currentTime, timeIncrement):
        """Sets/changes the times for a dynamic solver identified by an object.

        :param currentTime: The current time to set.
        :type currentTime: float
        :param timeIncrement: The time increment to set.
        :type timeIncrement: float
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_DynamicTimesSet, [solver, currentTime, timeIncrement])

    def Finalise(self):
        """Finalises a cmfe_SolverType object.

        :rtype: None
        """

        cmfe_Solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_Finalise, [cmfe_Solver])

    def GeometricTransformationArbitraryPathSet(self, arbitraryPath):
        """Sets the arbitrary path logical for a geometric transformation solver identified by an object.

        :param arbitraryPath: .TRUE. if the the transformation has an arbitrary path, .FALSE. if the path is uni-directional
        :type arbitraryPath: bool
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_GeometricTransformationArbitraryPathSet, [solver, arbitraryPath])

    def GeometricTransformationClear(self):
        """Clear transformation for a geometric transformation solver identified by an object.

        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_GeometricTransformationClear, [solver])

    def GeometricTransformationFieldSet(self, field, variableType):
        """Sets the field for a geometric transformation solver identified by an object.

        :param field: The field for the solver to set.
        :type field: Field
        :param variableType: The field variable type to set the transformation for
        :type variableType: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_GeometricTransformationFieldSet, [solver, field, variableType])

    def GeometricTransformationMatrixSet(self, matrix, loadIncrementIdx):
        """Sets the full transformation matrix vector at a specific load increment for a geometric transformation solver identified by an object.

        :param matrix: The full transformation matrix to set
        :type matrix: 2d array of floats
        :param loadIncrementIdx: The load increment index to set the matrix for.
        :type loadIncrementIdx: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_GeometricTransformationMatrixSet, [solver, matrix, loadIncrementIdx])

    def GeometricTransformationNoLoadIncrementsSet(self, numberOfIncrements):
        """Sets the arbitrary path logical for a geometric transformation solver identified by an object.

        :param numberOfIncrements: The number of load increments to apply the transformation
        :type numberOfIncrements: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_GeometricTransformationNoLoadIncrementsSet, [solver, numberOfIncrements])

    def GeometricTransformationRotationSet(self, pivotPoint, axis, angle, loadIncrementIdx):
        """Sets the rotation at a specific load increment for a geometric transformation solver identified by an object.

        :param pivotPoint: The pivot point to rotate about
        :type pivotPoint: Array of floats
        :param axis: The axis to  to rotate around
        :type axis: Array of floats
        :param angle: The angle to rotate
        :type angle: float
        :param loadIncrementIdx: The load increment index to set the rotation for.
        :type loadIncrementIdx: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_GeometricTransformationRotationSet, [solver, pivotPoint, axis, angle, loadIncrementIdx])

    def GeometricTransformationScalingsSet(self, scalings):
        """Sets the scalings for a geometric transformation solver identified by an object.

        :param scalings: The scalings to set
        :type scalings: Array of floats
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_GeometricTransformationScalingsSet, [solver, scalings])

    def GeometricTransformationTranslationSet(self, translation, loadIncrementIdx):
        """Sets the translation vector at a specific load increment for a geometric transformation solver identified by an object.

        :param translation: The translation components to set
        :type translation: Array of floats
        :param loadIncrementIdx: The load increment index to set the translation for.
        :type loadIncrementIdx: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_GeometricTransformationTranslationSet, [solver, translation, loadIncrementIdx])

    def LabelGet(self):
        """Returns the character string label for a solver identified by an object.

        :returns: label. The solver label.
        :rtype: string
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_LabelGet, [solver])

    def LabelSet(self, label):
        """Sets/changes the character string label for a solver identified by an object.

        :param label: The solver label to set.
        :type label: string
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_LabelSet, [solver, label])

    def LibraryTypeGet(self):
        """Returns the library type for a solver identified by an object.

        :returns: libraryType. The library type for the solver. Will be a value from the SolverLibraries enum.
        :rtype: int
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_LibraryTypeGet, [solver])

    def LibraryTypeSet(self, libraryType):
        """Sets/changes the library type for a solver identified by an object.

        :param libraryType: The library type for the solver to set. Must be a value from the SolverLibraries enum.
        :type libraryType: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_LibraryTypeSet, [solver, libraryType])

    def LinearDirectTypeSet(self, directSolverType):
        """Sets/changes the type of direct linear solver for a solver identified by an object.

        :param directSolverType: The type of the direct linear solver to set. Must be a value from the DirectLinearSolverTypes enum.
        :type directSolverType: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_LinearDirectTypeSet, [solver, directSolverType])

    def LinearIterativeAbsoluteToleranceSet(self, absoluteTolerance):
        """Sets/changes the maximum absolute tolerance for an iterative linear solver identified by an object.

        :param absoluteTolerance: The absolute tolerance for the iterative linear solver to set.
        :type absoluteTolerance: float
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_LinearIterativeAbsoluteToleranceSet, [solver, absoluteTolerance])

    def LinearIterativeDivergenceToleranceSet(self, divergenceTolerance):
        """Sets/changes the maximum divergence tolerance for an iterative linear solver identified by an object.

        :param divergenceTolerance: The divergence tolerance for the iterative linear solver to set.
        :type divergenceTolerance: float
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_LinearIterativeDivergenceToleranceSet, [solver, divergenceTolerance])

    def LinearIterativeGMRESRestartSet(self, GMRESRestart):
        """Sets/changes the GMRES restart value for a GMRES iterative linear solver identified by an object.

        :param GMRESRestart: The GMRES restart value to set.
        :type GMRESRestart: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_LinearIterativeGMRESRestartSet, [solver, GMRESRestart])

    def LinearIterativeMaximumIterationsSet(self, maximumIterations):
        """Sets/changes the maximum number of iterations for an iterative linear solver identified by an object.

        :param maximumIterations: The maximum iterations to set.
        :type maximumIterations: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_LinearIterativeMaximumIterationsSet, [solver, maximumIterations])

    def LinearIterativePreconditionerTypeSet(self, preconditionerType):
        """Sets/changes the preconditioner type for an iterative linear solver identified by an object.

        :param preconditionerType: The preconditioner type to set. Must be a value from the IterativePreconditionerTypes enum.
        :type preconditionerType: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_LinearIterativePreconditionerTypeSet, [solver, preconditionerType])

    def LinearIterativeRelativeToleranceSet(self, relativeTolerance):
        """Sets/changes the maximum relative tolerance for an iterative linear solver identified by an object.

        :param relativeTolerance: The relative tolerance for the iterative linear solver to set.
        :type relativeTolerance: float
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_LinearIterativeRelativeToleranceSet, [solver, relativeTolerance])

    def LinearIterativeTypeSet(self, iterativeSolverType):
        """Sets/changes the type for an iterative linear solver identified by an object.

        :param iterativeSolverType: The iterative solver type to set. Must be a value from the IterativeLinearSolverTypes enum.
        :type iterativeSolverType: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_LinearIterativeTypeSet, [solver, iterativeSolverType])

    def LinearTypeSet(self, linearSolverType):
        """Sets/changes the type for a linear solver identified by an object.

        :param linearSolverType: The linear solver type to set. Must be a value from the LinearSolverTypes enum.
        :type linearSolverType: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_LinearTypeSet, [solver, linearSolverType])

    def MumpsSetCntl(self, icntl, val):
        """Sets/changes the MUMPS CNTL(icntl)=val real/complex control parameters through the PETSc-MUMPS interface. Must be called after the boundary conditions have been set up.

        :param icntl: The MUMPS CNTL integer control parameter
        :type icntl: int
        :param val: The MUMPS CNTL real value to set: CNTL(icntl)=val
        :type val: float
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_MumpsSetCntl, [solver, icntl, val])

    def MumpsSetIcntl(self, icntl, ivalue):
        """Sets/changes the MUMPS ICNTL(icntl)=ivalue integer control parameters through the PETSc-MUMPS interface. Must be called after the boundary conditions have been set up.

        :param icntl: The MUMPS ICNTL integer control parameter
        :type icntl: int
        :param ivalue: The MUMPS ICNTL integer value to set: ICNTL(icntl)=ivalue
        :type ivalue: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_MumpsSetIcntl, [solver, icntl, ivalue])

    def NewtonAbsoluteToleranceSet(self, absoluteTolerance):
        """Sets/changes the absolute tolerance for a Newton solver identified by an object.

        :param absoluteTolerance: The absolute tolerance for the Newton solver to set.
        :type absoluteTolerance: float
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_NewtonAbsoluteToleranceSet, [solver, absoluteTolerance])

    def NewtonCellMLSolverGet(self, CellMLSolver):
        """Returns the CellML solver associated with a Newton solver identified by an object.

        :param CellMLSolver: On return, the Newton CellML solver.
        :type CellMLSolver: Solver
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_NewtonCellMLSolverGet, [solver, CellMLSolver])

    def NewtonConvergenceTestTypeSet(self, convergenceTestType):
        """Sets/changes the convergence test type for a Newton solver identified by an object.

        :param convergenceTestType: The convergence test type for the Newton solver to set.
        :type convergenceTestType: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_NewtonConvergenceTestTypeSet, [solver, convergenceTestType])

    def NewtonJacobianCalculationTypeSet(self, jacobianCalculationType):
        """Sets/changes the Jacobian calculation type for a Newton solver identified by an object.

        :param jacobianCalculationType: The Jacobian calculation type for the Newton solver to set. Must be a value from the JacobianCalculationTypes enum.
        :type jacobianCalculationType: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_NewtonJacobianCalculationTypeSet, [solver, jacobianCalculationType])

    def NewtonLineSearchAlphaSet(self, alpha):
        """Sets/changes the line search alpha for a Newton line search solver identified by an object.

        :param alpha: The alpha for the Newton line search solver to set.
        :type alpha: float
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_NewtonLineSearchAlphaSet, [solver, alpha])

    def NewtonLineSearchMaxStepSet(self, maxStep):
        """Sets/changes the line search maximum step for a Newton line search solver identified by an object.

        :param maxStep: The maximum step for the Newton line search solver to set.
        :type maxStep: float
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_NewtonLineSearchMaxStepSet, [solver, maxStep])

    def NewtonLineSearchMonitorOutputSet(self, monitorLinesearchFlag):
        """Enables/disables output monitoring for a nonlinear Newton line search solver identified by an object.

        :param monitorLinesearchFlag: Flag to determine whether to enable/disable linsearch monitor output.
        :type monitorLinesearchFlag: bool
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_NewtonLineSearchMonitorOutputSet, [solver, monitorLinesearchFlag])

    def NewtonLineSearchStepTolSet(self, stepTol):
        """Sets/changes the line search step tolerance for a Newton line search solver identified by an object.

        :param stepTol: The step tolerance for the Newton line search solver to set.
        :type stepTol: float
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_NewtonLineSearchStepTolSet, [solver, stepTol])

    def NewtonLineSearchTypeSet(self, lineSearchType):
        """Sets/changes the type of line search for a Newton line search solver identified by an object.

        :param lineSearchType: The type of line search for the Newton line search solver to set. Must be a value from the NewtonLineSearchTypes enum.
        :type lineSearchType: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_NewtonLineSearchTypeSet, [solver, lineSearchType])

    def NewtonLinearSolverGet(self, linearSolver):
        """Returns the linear solver associated with a Newton solver identified by an object.

        :param linearSolver: On return, the Newton linear solver.
        :type linearSolver: Solver
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_NewtonLinearSolverGet, [solver, linearSolver])

    def NewtonMaximumFunctionEvaluationsSet(self, maximumFunctionEvaluations):
        """Sets/changes the maximum number of function evaluations for a Newton solver identified by an object.

        :param maximumFunctionEvaluations: The maximum number of function evaluations for the Newton solver to set.
        :type maximumFunctionEvaluations: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_NewtonMaximumFunctionEvaluationsSet, [solver, maximumFunctionEvaluations])

    def NewtonMaximumIterationsSet(self, maximumIterations):
        """Sets/changes the maximum number of iterations for a Newton solver identified by an object.

        :param maximumIterations: The maximum number of iterations for the Newton solver to set.
        :type maximumIterations: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_NewtonMaximumIterationsSet, [solver, maximumIterations])

    def NewtonRelativeToleranceSet(self, relativeTolerance):
        """Sets/changes the relative tolerance for a Newton solver identified by an object.

        :param relativeTolerance: The relative tolerance for the Newton solver to set.
        :type relativeTolerance: float
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_NewtonRelativeToleranceSet, [solver, relativeTolerance])

    def NewtonSolutionToleranceSet(self, solutionTolerance):
        """Sets/changes the solution tolerance for a Newton solver identified by an object.

        :param solutionTolerance: The solution tolerance for the Newton solver to set.
        :type solutionTolerance: float
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_NewtonSolutionToleranceSet, [solver, solutionTolerance])

    def NewtonTrustRegionDelta0Set(self, delta0):
        """Sets/changes the delta0 for a Newton trust region solver identified by an object.

        :param delta0: The delta0 for the Newton trust region solver to set.
        :type delta0: float
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_NewtonTrustRegionDelta0Set, [solver, delta0])

    def NewtonTrustRegionToleranceSet(self, tolerance):
        """Sets/changes the tolerance for a Newton trust region solver identified by an object.

        :param tolerance: The tolerance for the Newton trust region solver to set.
        :type tolerance: float
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_NewtonTrustRegionToleranceSet, [solver, tolerance])

    def NewtonTypeSet(self, newtonSolveType):
        """Sets/changes the type of a Newton solver identified by an object.

        :param newtonSolveType: The type of the Newton solver to set. Must be a value from the NewtonSolverTypes enum.
        :type newtonSolveType: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_NewtonTypeSet, [solver, newtonSolveType])

    def NonlinearTypeSet(self, nonlinearSolveType):
        """Sets/changes the type of a nonlinear solver identified by an object.

        :param nonlinearSolveType: The type of the nonlinear solver to set. Must be a value from the NonlinearSolverTypes enum.
        :type nonlinearSolveType: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_NonlinearTypeSet, [solver, nonlinearSolveType])

    def OutputTypeSet(self, outputType):
        """Sets/changes the output type for a solver identified by an object.

        :param outputType: The type of solver output to set. Must be a value from the SolverOutputTypes enum.
        :type outputType: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_OutputTypeSet, [solver, outputType])

    def QuasiNewtonAbsoluteToleranceSet(self, absoluteTolerance):
        """Sets/changes the absolute tolerance for a Quasi-Newton solver identified by an object.

        :param absoluteTolerance: The absolute tolerance for the Quasi-Newton solver to set.
        :type absoluteTolerance: float
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonAbsoluteToleranceSet, [solver, absoluteTolerance])

    def QuasiNewtonCellMLSolverGet(self, CellMLSolver):
        """Returns the CellML solver associated with a Quasi-Newton solver identified by an object.

        :param CellMLSolver: On return, the Quasi-Newton CellML solver.
        :type CellMLSolver: Solver
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonCellMLSolverGet, [solver, CellMLSolver])

    def QuasiNewtonConvergenceTestTypeSet(self, convergenceTestType):
        """Sets/changes the convergence test type for a Quasi-Newton solver identified by an object.

        :param convergenceTestType: The convergence test type for the Quasi-Newton solver to set.
        :type convergenceTestType: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonConvergenceTestTypeSet, [solver, convergenceTestType])

    def QuasiNewtonJacobianCalculationTypeSet(self, jacobianCalculationType):
        """Sets/changes the Jacobian calculation type for a Quasi-Newton solver identified by an object.

        :param jacobianCalculationType: The Jacobian calculation type for the Quasi-Newton solver to set. Must be a value from the JacobianCalculationTypes enum.
        :type jacobianCalculationType: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonJacobianCalculationTypeSet, [solver, jacobianCalculationType])

    def QuasiNewtonLineSearchMaxStepSet(self, maxStep):
        """Sets/changes the line search maximum step for a Quasi-Newton line search solver identified by an object.

        :param maxStep: The maximum step for the Quasi-Newton line search solver to set.
        :type maxStep: float
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonLineSearchMaxStepSet, [solver, maxStep])

    def QuasiNewtonLineSearchMonitorOutputSet(self, monitorLinesearchFlag):
        """Enables/disables output monitoring for a nonlinear Quasi-Newton line search solver identified by an object.

        :param monitorLinesearchFlag: Flag to determine whether to enable/disable linsearch monitor output.
        :type monitorLinesearchFlag: bool
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonLineSearchMonitorOutputSet, [solver, monitorLinesearchFlag])

    def QuasiNewtonLineSearchStepTolSet(self, stepTol):
        """Sets/changes the line search step tolerance for a Quasi-Newton line search solver identified by an object.

        :param stepTol: The step tolerance for the Quasi-Newton line search solver to set.
        :type stepTol: float
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonLineSearchStepTolSet, [solver, stepTol])

    def QuasiNewtonLineSearchTypeSet(self, lineSearchType):
        """Sets/changes the type of line search for a Quasi-Newton line search solver identified by an object.

        :param lineSearchType: The type of line search for the Quasi-Newton line search solver to set. Must be a value from the QuasiNewtonLineSearchTypes enum.
        :type lineSearchType: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonLineSearchTypeSet, [solver, lineSearchType])

    def QuasiNewtonLinearSolverGet(self, linearSolver):
        """Returns the linear solver associated with a Quasi-Newton solver identified by an object.

        :param linearSolver: On return, the Quasi-Newton linear solver.
        :type linearSolver: Solver
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonLinearSolverGet, [solver, linearSolver])

    def QuasiNewtonMaximumFunctionEvaluationsSet(self, maximumFunctionEvaluations):
        """Sets/changes the maximum number of function evaluations for a Quasi-Newton solver identified by an object.

        :param maximumFunctionEvaluations: The maximum number of function evaluations for the Quasi-Newton solver to set.
        :type maximumFunctionEvaluations: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonMaximumFunctionEvaluationsSet, [solver, maximumFunctionEvaluations])

    def QuasiNewtonMaximumIterationsSet(self, maximumIterations):
        """Sets/changes the maximum number of iterations for a Quasi-Newton solver identified by an object.

        :param maximumIterations: The maximum number of iterations for the Quasi-Newton solver to set.
        :type maximumIterations: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonMaximumIterationsSet, [solver, maximumIterations])

    def QuasiNewtonRelativeToleranceSet(self, relativeTolerance):
        """Sets/changes the relative tolerance for a Quasi-Newton solver identified by an object.

        :param relativeTolerance: The relative tolerance for the Quasi-Newton solver to set.
        :type relativeTolerance: float
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonRelativeToleranceSet, [solver, relativeTolerance])

    def QuasiNewtonRestartSet(self, quasiNewtonRestart):
        """Sets/changes the restart of a Quasi-Newton solver identified by an object.

        :param quasiNewtonRestart: The restart of the Quasi-Newton solver to set.
        :type quasiNewtonRestart: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonRestartSet, [solver, quasiNewtonRestart])

    def QuasiNewtonRestartTypeSet(self, quasiNewtonRestartType):
        """Sets/changes the restart type of a Quasi-Newton solver identified by an object.

        :param quasiNewtonRestartType: The restart type of the Quasi-Newton solver to set. Must be a value from the QuasiNewtonRestartTypes enum.
        :type quasiNewtonRestartType: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonRestartTypeSet, [solver, quasiNewtonRestartType])

    def QuasiNewtonScaleTypeSet(self, quasiNewtonScaleType):
        """Sets/changes the scale type of a Quasi-Newton solver identified by an object.

        :param quasiNewtonScaleType: The scale type of the Quasi-Newton solver to set. Must be a value from the QuasiNewtonScaleTypes enum.
        :type quasiNewtonScaleType: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonScaleTypeSet, [solver, quasiNewtonScaleType])

    def QuasiNewtonSolutionToleranceSet(self, solutionTolerance):
        """Sets/changes the solution tolerance for a Quasi-Newton solver identified by an object.

        :param solutionTolerance: The solution tolerance for the Quasi-Newton solver to set.
        :type solutionTolerance: float
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonSolutionToleranceSet, [solver, solutionTolerance])

    def QuasiNewtonSolveTypeSet(self, quasiNewtonSolveType):
        """Sets/changes the type of a Quasi-Newton solver identified by an object.

        :param quasiNewtonSolveType: The type of the Quasi-Newton solver to set. Must be a value from the QuasiNewtonSolverTypes enum.
        :type quasiNewtonSolveType: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonSolveTypeSet, [solver, quasiNewtonSolveType])

    def QuasiNewtonTrustRegionDelta0Set(self, delta0):
        """Sets/changes the delta0 for a Quasi-Newton trust region solver identified by an object.

        :param delta0: The delta0 for the Quasi-Newton trust region solver to set.
        :type delta0: float
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonTrustRegionDelta0Set, [solver, delta0])

    def QuasiNewtonTrustRegionToleranceSet(self, tolerance):
        """Sets/changes the tolerance for a Quasi-Newton trust region solver identified by an object.

        :param tolerance: The tolerance for the Quasi-Newton trust region solver to set.
        :type tolerance: float
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonTrustRegionToleranceSet, [solver, tolerance])

    def QuasiNewtonTypeSet(self, quasiNewtonType):
        """Sets/changes the type of a Quasi-Newton solver identified by an object.

        :param quasiNewtonType: The Quasi-Newton type to set. Must be a value from the QuasiNewtonTypes enum.
        :type quasiNewtonType: int
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonTypeSet, [solver, quasiNewtonType])

    def SolverEquationsGet(self, solverEquations):
        """Returns the solver equations for a solver identified by an object.

        :param solverEquations: On return, the solver equations for the solver.
        :type solverEquations: SolverEquations
        :rtype: None
        """

        solver = self
        return _wrap_routine(_iron_python.cmfe_Solver_SolverEquationsGet, [solver, solverEquations])

    newtonConvergenceTestType = property(None, NewtonConvergenceTestTypeSet, None, """The convergence test type for a Newton solver identified by an object.""")

    geometricTransformationArbitraryPath = property(None, GeometricTransformationArbitraryPathSet, None, """The arbitrary path logical for a geometric transformation solver identified by an object.""")

    newtonTrustRegionDelta0 = property(None, NewtonTrustRegionDelta0Set, None, """The delta0 for a Newton trust region solver identified by an object.""")

    newtonRelativeTolerance = property(None, NewtonRelativeToleranceSet, None, """The relative tolerance for a Newton solver identified by an object.""")

    quasiNewtonType = property(None, QuasiNewtonTypeSet, None, """The type of a Quasi-Newton solver identified by an object.""")

    quasiNewtonSolutionTolerance = property(None, QuasiNewtonSolutionToleranceSet, None, """The solution tolerance for a Quasi-Newton solver identified by an object.""")

    label = property(LabelGet, LabelSet, None, """The character string label for a solver identified by an object.""")

    quasiNewtonRestartType = property(None, QuasiNewtonRestartTypeSet, None, """The restart type of a Quasi-Newton solver identified by an object.""")

    quasiNewtonAbsoluteTolerance = property(None, QuasiNewtonAbsoluteToleranceSet, None, """The absolute tolerance for a Quasi-Newton solver identified by an object.""")

    quasiNewtonLinearSolver = property(QuasiNewtonLinearSolverGet, None, None, """The linear solver associated with a Quasi-Newton solver identified by an object.""")

    geometricTransformationNoLoadIncrements = property(None, GeometricTransformationNoLoadIncrementsSet, None, """The arbitrary path logical for a geometric transformation solver identified by an object.""")

    newtonLineSearchStepTol = property(None, NewtonLineSearchStepTolSet, None, """The line search step tolerance for a Newton line search solver identified by an object.""")

    newtonJacobianCalculationType = property(None, NewtonJacobianCalculationTypeSet, None, """The Jacobian calculation type for a Newton solver identified by an object.""")

    linearIterativeDivergenceTolerance = property(None, LinearIterativeDivergenceToleranceSet, None, """The maximum divergence tolerance for an iterative linear solver identified by an object.""")

    newtonLineSearchMaxStep = property(None, NewtonLineSearchMaxStepSet, None, """The line search maximum step for a Newton line search solver identified by an object.""")

    quasiNewtonRelativeTolerance = property(None, QuasiNewtonRelativeToleranceSet, None, """The relative tolerance for a Quasi-Newton solver identified by an object.""")

    dynamicLinearityType = property(DynamicLinearityTypeGet, None, None, """The linearity type for a dynamic solver identified by an object.""")

    newtonMaximumFunctionEvaluations = property(None, NewtonMaximumFunctionEvaluationsSet, None, """The maximum number of function evaluations for a Newton solver identified by an object.""")

    quasiNewtonConvergenceTestType = property(None, QuasiNewtonConvergenceTestTypeSet, None, """The convergence test type for a Quasi-Newton solver identified by an object.""")

    linearType = property(None, LinearTypeSet, None, """The type for a linear solver identified by an object.""")

    dAETimeStep = property(None, DAETimeStepSet, None, """The (initial) time step for an differential-algebraic equation solver identified by an object.""")

    geometricTransformationScalings = property(None, GeometricTransformationScalingsSet, None, """The scalings for a geometric transformation solver identified by an object.""")

    libraryType = property(LibraryTypeGet, LibraryTypeSet, None, """The library type for a solver identified by an object.""")

    outputType = property(None, OutputTypeSet, None, """The output type for a solver identified by an object.""")

    linearIterativePreconditionerType = property(None, LinearIterativePreconditionerTypeSet, None, """The preconditioner type for an iterative linear solver identified by an object.""")

    quasiNewtonCellMLSolver = property(QuasiNewtonCellMLSolverGet, None, None, """The CellML solver associated with a Quasi-Newton solver identified by an object.""")

    dynamicLinearSolver = property(DynamicLinearSolverGet, None, None, """The linear solver associated with a linear dynamic solver identified by an object.""")

    newtonLinearSolver = property(NewtonLinearSolverGet, None, None, """The linear solver associated with a Newton solver identified by an object.""")

    linearIterativeRelativeTolerance = property(None, LinearIterativeRelativeToleranceSet, None, """The maximum relative tolerance for an iterative linear solver identified by an object.""")

    quasiNewtonLineSearchMonitorOutput = property(None, QuasiNewtonLineSearchMonitorOutputSet, None, """Enables/disables output monitoring for a nonlinear Quasi-Newton line search solver identified by an object.""")

    quasiNewtonLineSearchMaxStep = property(None, QuasiNewtonLineSearchMaxStepSet, None, """The line search maximum step for a Quasi-Newton line search solver identified by an object.""")

    newtonMaximumIterations = property(None, NewtonMaximumIterationsSet, None, """The maximum number of iterations for a Newton solver identified by an object.""")

    newtonCellMLSolver = property(NewtonCellMLSolverGet, None, None, """The CellML solver associated with a Newton solver identified by an object.""")

    dynamicDegree = property(DynamicDegreeGet, DynamicDegreeSet, None, """The degree of the polynomial used to interpolate time for a dynamic solver identified by an object.""")

    quasiNewtonTrustRegionDelta0 = property(None, QuasiNewtonTrustRegionDelta0Set, None, """The delta0 for a Quasi-Newton trust region solver identified by an object.""")

    linearIterativeType = property(None, LinearIterativeTypeSet, None, """The type for an iterative linear solver identified by an object.""")

    newtonLineSearchMonitorOutput = property(None, NewtonLineSearchMonitorOutputSet, None, """Enables/disables output monitoring for a nonlinear Newton line search solver identified by an object.""")

    quasiNewtonJacobianCalculationType = property(None, QuasiNewtonJacobianCalculationTypeSet, None, """The Jacobian calculation type for a Quasi-Newton solver identified by an object.""")

    quasiNewtonSolveType = property(None, QuasiNewtonSolveTypeSet, None, """The type of a Quasi-Newton solver identified by an object.""")

    quasiNewtonTrustRegionTolerance = property(None, QuasiNewtonTrustRegionToleranceSet, None, """The tolerance for a Quasi-Newton trust region solver identified by an object.""")

    dynamicScheme = property(None, DynamicSchemeSet, None, """The scheme for a dynamic solver identified by an object.""")

    newtonLineSearchAlpha = property(None, NewtonLineSearchAlphaSet, None, """The line search alpha for a Newton line search solver identified by an object.""")

    dynamicTheta = property(None, DynamicThetaSet, None, """The theta for a dynamic solver identified by an object.""")

    newtonSolutionTolerance = property(None, NewtonSolutionToleranceSet, None, """The solution tolerance for a Newton solver identified by an object.""")

    linearIterativeAbsoluteTolerance = property(None, LinearIterativeAbsoluteToleranceSet, None, """The maximum absolute tolerance for an iterative linear solver identified by an object.""")

    cellMLEquations = property(CellMLEquationsGet, None, None, """The CellML equations for a solver identified by an object.""")

    dAEEulerSolverType = property(DAEEulerSolverTypeGet, DAEEulerSolverTypeSet, None, """The solve type for an Euler differential-algebraic equation solver identified by an object.""")

    dAESolverType = property(DAESolverTypeGet, DAESolverTypeSet, None, """The solve type for an differential-algebraic equation solver identified by an object.""")

    newtonAbsoluteTolerance = property(None, NewtonAbsoluteToleranceSet, None, """The absolute tolerance for a Newton solver identified by an object.""")

    dynamicNonlinearSolver = property(DynamicNonlinearSolverGet, None, None, """The nonlinear solver associated with a nonlinear dynamic solver identified by an object.""")

    quasiNewtonMaximumIterations = property(None, QuasiNewtonMaximumIterationsSet, None, """The maximum number of iterations for a Quasi-Newton solver identified by an object.""")

    nonlinearType = property(None, NonlinearTypeSet, None, """The type of a nonlinear solver identified by an object.""")

    quasiNewtonScaleType = property(None, QuasiNewtonScaleTypeSet, None, """The scale type of a Quasi-Newton solver identified by an object.""")

    linearIterativeMaximumIterations = property(None, LinearIterativeMaximumIterationsSet, None, """The maximum number of iterations for an iterative linear solver identified by an object.""")

    quasiNewtonLineSearchStepTol = property(None, QuasiNewtonLineSearchStepTolSet, None, """The line search step tolerance for a Quasi-Newton line search solver identified by an object.""")

    quasiNewtonRestart = property(None, QuasiNewtonRestartSet, None, """The restart of a Quasi-Newton solver identified by an object.""")

    solverEquations = property(SolverEquationsGet, None, None, """The solver equations for a solver identified by an object.""")

    linearDirectType = property(None, LinearDirectTypeSet, None, """The type of direct linear solver for a solver identified by an object.""")

    linearIterativeGMRESRestart = property(None, LinearIterativeGMRESRestartSet, None, """The GMRES restart value for a GMRES iterative linear solver identified by an object.""")

    quasiNewtonMaximumFunctionEvaluations = property(None, QuasiNewtonMaximumFunctionEvaluationsSet, None, """The maximum number of function evaluations for a Quasi-Newton solver identified by an object.""")

    newtonTrustRegionTolerance = property(None, NewtonTrustRegionToleranceSet, None, """The tolerance for a Newton trust region solver identified by an object.""")

    newtonLineSearchType = property(None, NewtonLineSearchTypeSet, None, """The type of line search for a Newton line search solver identified by an object.""")

    quasiNewtonLineSearchType = property(None, QuasiNewtonLineSearchTypeSet, None, """The type of line search for a Quasi-Newton line search solver identified by an object.""")

    newtonType = property(None, NewtonTypeSet, None, """The type of a Newton solver identified by an object.""")


def AnalyticAnalysis_AbsoluteErrorGetConstantNum(regionUserNumber, fieldUserNumber, variableType, componentNumber):
    """Get absolute error value for the constant in a field specified by a user number compared to the analytic value.

    :param regionUserNumber: The user number of the region containing the field for analytic error analysis.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to calculate the analytic error analysis for.
    :type fieldUserNumber: int
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: value. The absolute error
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_AbsoluteErrorGetConstantNum, [regionUserNumber, fieldUserNumber, variableType, componentNumber])


def AnalyticAnalysis_AbsoluteErrorGetConstant(field, variableType, componentNumber):
    """Get absolute error value for the constant in a field identified by an object compared to the analytic value.

    :param field: The dependent field to calculate the analytic error analysis for.
    :type field: Field
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: VALUE. The absolute error
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_AbsoluteErrorGetConstant, [field, variableType, componentNumber])


def AnalyticAnalysis_AbsoluteErrorGetElementNum(regionUserNumber, fieldUserNumber, variableType, elementNumber, componentNumber):
    """Get absolute error value for the element in a field specified by a user number compared to the analytic value.

    :param regionUserNumber: The user number of the region containing the field for analytic error analysis.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to calculate the analytic error analysis for.
    :type fieldUserNumber: int
    :param variableType: variable type
    :type variableType: int
    :param elementNumber: element number
    :type elementNumber: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: value. The absolute error
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_AbsoluteErrorGetElementNum, [regionUserNumber, fieldUserNumber, variableType, elementNumber, componentNumber])


def AnalyticAnalysis_AbsoluteErrorGetElement(field, variableType, elementNumber, componentNumber):
    """Get absolute error value for the element in a field identified by an object compared to the analytic value.

    :param field: The dependent field to calculate the analytic error analysis for.
    :type field: Field
    :param variableType: variable type
    :type variableType: int
    :param elementNumber: element number
    :type elementNumber: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: VALUE. The absolute error
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_AbsoluteErrorGetElement, [field, variableType, elementNumber, componentNumber])


def AnalyticAnalysis_AbsoluteErrorGetNodeNum(regionUserNumber, fieldUserNumber, variableType, versionNumber, derivativeNumber, nodeNumber, componentNumber):
    """Get absolute error value for the node in a field specified by a user number compared to the analytic value.

    :param regionUserNumber: The user number of the region containing the field for analytic error analysis.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to calculate the analytic error analysis for.
    :type fieldUserNumber: int
    :param variableType: variable type
    :type variableType: int
    :param versionNumber: derivative version number
    :type versionNumber: int
    :param derivativeNumber: derivative number
    :type derivativeNumber: int
    :param nodeNumber: node number
    :type nodeNumber: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: value. The absolute error
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_AbsoluteErrorGetNodeNum, [regionUserNumber, fieldUserNumber, variableType, versionNumber, derivativeNumber, nodeNumber, componentNumber])


def AnalyticAnalysis_AbsoluteErrorGetNode(field, variableType, versionNumber, derivativeNumber, nodeNumber, componentNumber):
    """Get absolute error value for the node in a field identified by an object compared to the analytic value.

    :param field: The dependent field to calculate the analytic error analysis for.
    :type field: Field
    :param variableType: variable type
    :type variableType: int
    :param versionNumber: derivative version number
    :type versionNumber: int
    :param derivativeNumber: derivative number
    :type derivativeNumber: int
    :param nodeNumber: node number
    :type nodeNumber: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: value. The absolute error
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_AbsoluteErrorGetNode, [field, variableType, versionNumber, derivativeNumber, nodeNumber, componentNumber])


def AnalyticAnalysis_IntegralAbsoluteErrorGetNum(regionUserNumber, fieldUserNumber, variableType, componentNumber):
    """Get integral value for the absolute errors.

    :param regionUserNumber: The user number of the region containing the field for analytic error analysis.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to calculate the analytic error analysis for.
    :type fieldUserNumber: int
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: (The integral value, Ghost integral value)
    :rtype: tuple. (Array of floats, Array of floats)
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_IntegralAbsoluteErrorGetNum, [regionUserNumber, fieldUserNumber, variableType, componentNumber])


def AnalyticAnalysis_IntegralAbsoluteErrorGet(field, variableType, componentNumber):
    """Get integral value for the absolute errors.

    :param field: The dependent field to calculate the analytic error analysis for.
    :type field: Field
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: (The integral value, Ghost integral value)
    :rtype: tuple. (Array of floats, Array of floats)
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_IntegralAbsoluteErrorGet, [field, variableType, componentNumber])


def AnalyticAnalysis_IntegralAnalyticValueGetNum(regionUserNumber, fieldUserNumber, variableType, componentNumber):
    """Get integral value for the analytic values.

    :param regionUserNumber: The user number of the region containing the field for analytic error analysis.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to calculate the analytic error analysis for.
    :type fieldUserNumber: int
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: (The integral value, Ghost integral value)
    :rtype: tuple. (Array of floats, Array of floats)
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_IntegralAnalyticValueGetNum, [regionUserNumber, fieldUserNumber, variableType, componentNumber])


def AnalyticAnalysis_IntegralAnalyticValueGet(field, variableType, componentNumber):
    """Get integral value for the analytic values.

    :param field: The dependent field to calculate the analytic error analysis for.
    :type field: Field
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: (The integral value, Ghost integral value)
    :rtype: tuple. (Array of floats, Array of floats)
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_IntegralAnalyticValueGet, [field, variableType, componentNumber])


def AnalyticAnalysis_IntegralNIDErrorGetNum(regionUserNumber, fieldUserNumber, variableType, componentNumber):
    """Get integral value for the nid error.

    :param regionUserNumber: The user number of the region containing the field for analytic error analysis.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to calculate the analytic error analysis for.
    :type fieldUserNumber: int
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: (The integral value, Ghost integral value)
    :rtype: tuple. (Array of floats, Array of floats)
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_IntegralNIDErrorGetNum, [regionUserNumber, fieldUserNumber, variableType, componentNumber])


def AnalyticAnalysis_IntegralNIDErrorGet(field, variableType, componentNumber):
    """Get integral value for the nid error.

    :param field: The dependent field to calculate the analytic error analysis for.
    :type field: Field
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: (The integral value, Ghost integral value)
    :rtype: tuple. (Array of floats, Array of floats)
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_IntegralNIDErrorGet, [field, variableType, componentNumber])


def AnalyticAnalysis_IntegralNIDNumericalValueGetNum(regionUserNumber, fieldUserNumber, variableType, componentNumber):
    """Get integral value for the nid numerical.

    :param regionUserNumber: The user number of the region containing the field for analytic error analysis.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to calculate the analytic error analysis for.
    :type fieldUserNumber: int
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: (The integral value, Ghost integral value)
    :rtype: tuple. (Array of floats, Array of floats)
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_IntegralNIDNumericalValueGetNum, [regionUserNumber, fieldUserNumber, variableType, componentNumber])


def AnalyticAnalysis_IntegralNIDNumericalValueGet(field, variableType, componentNumber):
    """Get integral value for the nid numerical.

    :param field: The dependent field to calculate the analytic error analysis for.
    :type field: Field
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: (The integral value, Ghost integral value)
    :rtype: tuple. (Array of floats, Array of floats)
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_IntegralNIDNumericalValueGet, [field, variableType, componentNumber])


def AnalyticAnalysis_IntegralNumericalValueGetNum(regionUserNumber, fieldUserNumber, variableType, componentNumber):
    """Get integral value for the numerical values.

    :param regionUserNumber: The user number of the region containing the field for analytic error analysis.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to calculate the analytic error analysis for.
    :type fieldUserNumber: int
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: (The integral value, Ghost integral value)
    :rtype: tuple. (Array of floats, Array of floats)
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_IntegralNumericalValueGetNum, [regionUserNumber, fieldUserNumber, variableType, componentNumber])


def AnalyticAnalysis_IntegralNumericalValueGet(field, variableType, componentNumber):
    """Get integral value for the numerical values.

    :param field: The dependent field to calculate the analytic error analysis for.
    :type field: Field
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: (The integral value, Ghost integral value)
    :rtype: tuple. (Array of floats, Array of floats)
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_IntegralNumericalValueGet, [field, variableType, componentNumber])


def AnalyticAnalysis_IntegralPercentageErrorGetNum(regionUserNumber, fieldUserNumber, variableType, componentNumber):
    """Get integral value for the percentage errors.

    :param regionUserNumber: The user number of the region containing the field for analytic error analysis.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to calculate the analytic error analysis for.
    :type fieldUserNumber: int
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: (The integral value, Ghost integral value)
    :rtype: tuple. (Array of floats, Array of floats)
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_IntegralPercentageErrorGetNum, [regionUserNumber, fieldUserNumber, variableType, componentNumber])


def AnalyticAnalysis_IntegralPercentageErrorGet(field, variableType, componentNumber):
    """Get integral value for the percentage errors.

    :param field: The dependent field to calculate the analytic error analysis for.
    :type field: Field
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: (The integral value, Ghost integral value)
    :rtype: tuple. (Array of floats, Array of floats)
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_IntegralPercentageErrorGet, [field, variableType, componentNumber])


def AnalyticAnalysis_IntegralRelativeErrorGetNum(regionUserNumber, fieldUserNumber, variableType, componentNumber):
    """Get integral value for the relative error.

    :param regionUserNumber: The user number of the region containing the field for analytic error analysis.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to calculate the analytic error analysis for.
    :type fieldUserNumber: int
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: (The integral value, Ghost integral value)
    :rtype: tuple. (Array of floats, Array of floats)
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_IntegralRelativeErrorGetNum, [regionUserNumber, fieldUserNumber, variableType, componentNumber])


def AnalyticAnalysis_IntegralRelativeErrorGet(field, variableType, componentNumber):
    """Get integral value for the relative error.

    :param field: The dependent field to calculate the analytic error analysis for.
    :type field: Field
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: (The integral value, Ghost integral value)
    :rtype: tuple. (Array of floats, Array of floats)
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_IntegralRelativeErrorGet, [field, variableType, componentNumber])


def AnalyticAnalysis_OutputNum(regionUserNumber, fieldUserNumber, fileName):
    """Output the analytic error analysis for a field specified by a user number compared to the analytic values parameter set.

    :param regionUserNumber: The user number of the region containing the field for analytic error analysis.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to calculate the analytic error analysis for.
    :type fieldUserNumber: int
    :param fileName: If not empty, the filename to output the analytic analysis to. If empty, the analysis will be output to the standard output.
    :type fileName: string
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_OutputNum, [regionUserNumber, fieldUserNumber, fileName])


def AnalyticAnalysis_Output(field, fileName):
    """Output the analytic error analysis for a field identified by an object compared to the analytic values parameter set.

    :param field: The dependent field to calculate the analytic error analysis for.
    :type field: Field
    :param fileName: If not empty, the filename to output the analytic analysis to. If empty, the analysis will be output to the standard output.
    :type fileName: string
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_Output, [field, fileName])


def AnalyticAnalysis_PercentageErrorGetConstantNum(regionUserNumber, fieldUserNumber, variableType, componentNumber):
    """Get percentage error value for the constant in a field specified by a user number compared to the analytic value.

    :param regionUserNumber: The user number of the region containing the field for analytic error analysis.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to calculate the analytic error analysis for.
    :type fieldUserNumber: int
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: value. The percentage error
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_PercentageErrorGetConstantNum, [regionUserNumber, fieldUserNumber, variableType, componentNumber])


def AnalyticAnalysis_PercentageErrorGetConstant(field, variableType, componentNumber):
    """Get percentage error value for the constant in a field identified by an object compared to the analytic value.

    :param field: The dependent field to calculate the analytic error analysis for.
    :type field: Field
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: VALUE. The percentage error
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_PercentageErrorGetConstant, [field, variableType, componentNumber])


def AnalyticAnalysis_PercentageErrorGetElementNum(regionUserNumber, fieldUserNumber, variableType, elementNumber, componentNumber):
    """Get percentage error value for the element in a field specified by a user number compared to the analytic value.

    :param regionUserNumber: The user number of the region containing the field for analytic error analysis.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to calculate the analytic error analysis for.
    :type fieldUserNumber: int
    :param variableType: variable type
    :type variableType: int
    :param elementNumber: element number
    :type elementNumber: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: value. The percentage error
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_PercentageErrorGetElementNum, [regionUserNumber, fieldUserNumber, variableType, elementNumber, componentNumber])


def AnalyticAnalysis_PercentageErrorGetElement(field, variableType, elementNumber, componentNumber):
    """Get percentage error value for the element in a field identified by an object compared to the analytic value.

    :param field: The dependent field to calculate the analytic error analysis for.
    :type field: Field
    :param variableType: variable type
    :type variableType: int
    :param elementNumber: element number
    :type elementNumber: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: VALUE. The percentage error
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_PercentageErrorGetElement, [field, variableType, elementNumber, componentNumber])


def AnalyticAnalysis_PercentageErrorGetNodeNum(regionUserNumber, fieldUserNumber, variableType, versionNumber, derivativeNumber, nodeNumber, componentNumber):
    """Get percentage error value for the node in a field specified by a user number compared to the analytic value.

    :param regionUserNumber: The user number of the region containing the field for analytic error analysis.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to calculate the analytic error analysis for.
    :type fieldUserNumber: int
    :param variableType: variable type
    :type variableType: int
    :param versionNumber: derivative version number
    :type versionNumber: int
    :param derivativeNumber: derivative number
    :type derivativeNumber: int
    :param nodeNumber: node number
    :type nodeNumber: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: value. The percentage error
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_PercentageErrorGetNodeNum, [regionUserNumber, fieldUserNumber, variableType, versionNumber, derivativeNumber, nodeNumber, componentNumber])


def AnalyticAnalysis_PercentageErrorGetNode(field, variableType, versionNumber, derivativeNumber, nodeNumber, componentNumber):
    """Get percentage error value for the node in a field identified by an object compared to the analytic value.

    :param field: The dependent field to calculate the analytic error analysis for.
    :type field: Field
    :param variableType: variable type
    :type variableType: int
    :param versionNumber: derivative version number
    :type versionNumber: int
    :param derivativeNumber: derivative number
    :type derivativeNumber: int
    :param nodeNumber: node number
    :type nodeNumber: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: value. The percentage error
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_PercentageErrorGetNode, [field, variableType, versionNumber, derivativeNumber, nodeNumber, componentNumber])


def AnalyticAnalysis_RMSErrorGetElementNum(regionUserNumber, fieldUserNumber, variableType, componentNumber, errorType):
    """Get rms error value for elements in a field compared to the analytic value.

    :param regionUserNumber: The user number of the region containing the field for analytic error analysis.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to calculate the analytic error analysis for.
    :type fieldUserNumber: int
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :param errorType: error type
    :type errorType: int
    :returns: (The local error, The local ghost error, The global error)
    :rtype: tuple. (float, float, float)
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_RMSErrorGetElementNum, [regionUserNumber, fieldUserNumber, variableType, componentNumber, errorType])


def AnalyticAnalysis_RMSErrorGetElement(field, variableType, componentNumber, errorType):
    """Get relative error value for the constant in a field identified by an object compared to the analytic value.

    :param field: The dependent field to calculate the analytic error analysis for.
    :type field: Field
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :param errorType: error type
    :type errorType: int
    :returns: (The local error, The local ghost error, The global error)
    :rtype: tuple. (float, float, float)
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_RMSErrorGetElement, [field, variableType, componentNumber, errorType])


def AnalyticAnalysis_RMSErrorGetNodeNum(regionUserNumber, fieldUserNumber, variableType, componentNumber, errorType):
    """Get rms error value for nodes in a field compared to the analytic value.

    :param regionUserNumber: The user number of the region containing the field for analytic error analysis.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to calculate the analytic error analysis for.
    :type fieldUserNumber: int
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :param errorType: error type
    :type errorType: int
    :returns: (The local error, The local ghost error, The global error)
    :rtype: tuple. (Array of floats, Array of floats, Array of floats)
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_RMSErrorGetNodeNum, [regionUserNumber, fieldUserNumber, variableType, componentNumber, errorType])


def AnalyticAnalysis_RMSErrorGetNode(field, variableType, componentNumber, errorType):
    """Get rms error value for nodes in a field identified by an object compared to the analytic value.

    :param field: The dependent field to calculate the analytic error analysis for.
    :type field: Field
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :param errorType: error type
    :type errorType: int
    :returns: (The local error, The local ghost error, The global error)
    :rtype: tuple. (Array of floats, Array of floats, Array of floats)
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_RMSErrorGetNode, [field, variableType, componentNumber, errorType])


def AnalyticAnalysis_RelativeErrorGetConstantNum(regionUserNumber, fieldUserNumber, variableType, componentNumber):
    """Get relative error value for the constant in a field specified by a user number compared to the analytic value.

    :param regionUserNumber: The user number of the region containing the field for analytic error analysis.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to calculate the analytic error analysis for.
    :type fieldUserNumber: int
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: value. The relative error
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_RelativeErrorGetConstantNum, [regionUserNumber, fieldUserNumber, variableType, componentNumber])


def AnalyticAnalysis_RelativeErrorGetConstant(field, variableType, componentNumber):
    """Get relative error value for the constant in a field identified by an object compared to the analytic value.

    :param field: The dependent field to calculate the analytic error analysis for.
    :type field: Field
    :param variableType: variable type
    :type variableType: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: VALUE. The relative error
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_RelativeErrorGetConstant, [field, variableType, componentNumber])


def AnalyticAnalysis_RelativeErrorGetElementNum(regionUserNumber, fieldUserNumber, variableType, elementNumber, componentNumber):
    """Get relative error value for the element in a field specified by a user number compared to the analytic value.

    :param regionUserNumber: The user number of the region containing the field for analytic error analysis.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to calculate the analytic error analysis for.
    :type fieldUserNumber: int
    :param variableType: variable type
    :type variableType: int
    :param elementNumber: element number
    :type elementNumber: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: value. The relative error
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_RelativeErrorGetElementNum, [regionUserNumber, fieldUserNumber, variableType, elementNumber, componentNumber])


def AnalyticAnalysis_RelativeErrorGetElement(field, variableType, elementNumber, componentNumber):
    """Get relative error value for the element in a field identified by an object compared to the analytic value.

    :param field: The dependent field to calculate the analytic error analysis for.
    :type field: Field
    :param variableType: variable type
    :type variableType: int
    :param elementNumber: element number
    :type elementNumber: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: VALUE. The relative error
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_RelativeErrorGetElement, [field, variableType, elementNumber, componentNumber])


def AnalyticAnalysis_RelativeErrorGetNodeNum(regionUserNumber, fieldUserNumber, variableType, versionNumber, derivativeNumber, nodeNumber, componentNumber):
    """Get relative error value for the node in a field specified by a user number compared to the analytic value.

    :param regionUserNumber: The user number of the region containing the field for analytic error analysis.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to calculate the analytic error analysis for.
    :type fieldUserNumber: int
    :param variableType: variable type
    :type variableType: int
    :param versionNumber: derivative version number
    :type versionNumber: int
    :param derivativeNumber: derivative number
    :type derivativeNumber: int
    :param nodeNumber: node number
    :type nodeNumber: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: value. The relative error
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_RelativeErrorGetNodeNum, [regionUserNumber, fieldUserNumber, variableType, versionNumber, derivativeNumber, nodeNumber, componentNumber])


def AnalyticAnalysis_RelativeErrorGetNode(field, variableType, versionNumber, derivativeNumber, nodeNumber, componentNumber):
    """Get relative error value for the node in a field identified by an object compared to the analytic value.

    :param field: The dependent field to calculate the analytic error analysis for.
    :type field: Field
    :param variableType: variable type
    :type variableType: int
    :param versionNumber: derivative version number
    :type versionNumber: int
    :param derivativeNumber: derivative number
    :type derivativeNumber: int
    :param nodeNumber: node number
    :type nodeNumber: int
    :param componentNumber: component number
    :type componentNumber: int
    :returns: value. The relative error
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_AnalyticAnalysis_RelativeErrorGetNode, [field, variableType, versionNumber, derivativeNumber, nodeNumber, componentNumber])


def Basis_CollapsedXiGetNum(userNumber, collapsedXiSize):
    """Returns the collapsed Xi flags of a basis identified by a user number.

    :param userNumber: The user number of the basis to get the collapsed Xi flags for.
    :type userNumber: int
    :param collapsedXiSize: Size of collapsedXi to allocate.
    :returns: collapsedXi. collapsedXi(ni). On return, the collapsed Xi parameter for the ni'th Xi direction. Will be a value from the BasisXiCollapse enum.
    :rtype: Array of ints
    """

    return _wrap_routine(_iron_python.cmfe_Basis_CollapsedXiGetNum, [userNumber, collapsedXiSize])


def Basis_CollapsedXiSetNum(userNumber, collapsedXi):
    """Sets/changes the collapsed Xi flags of a basis identified by a user number.

    :param userNumber: The user number of the basis to set the collapsed Xi flags for.
    :type userNumber: int
    :param collapsedXi: collapsedXi(ni). The collapsed Xi parameter for the ni'th Xi direction to set. Must be a value from the BasisXiCollapse enum.
    :type collapsedXi: Array of ints
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Basis_CollapsedXiSetNum, [userNumber, collapsedXi])


def Basis_CreateFinishNum(userNumber):
    """Finishes the creation of a new basis identified by a user number.

    :param userNumber: The user number of the basis to finish the creation of.
    :type userNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Basis_CreateFinishNum, [userNumber])


def Basis_CreateStartNum(userNumber):
    """Starts the creation of a new basis for a basis identified by a user number.

    :param userNumber: The user number of the basis to start the creation of.
    :type userNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Basis_CreateStartNum, [userNumber])


def Basis_DestroyNum(userNumber):
    """Destroys a basis identified by its basis user number.

    :param userNumber: The user number of the basis to destroy.
    :type userNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Basis_DestroyNum, [userNumber])


def Basis_InterpolationXiGetNum(userNumber, interpolationXiSize):
    """Get the interpolation type in each xi directions for a basis identified by a user number.

    :param userNumber: The user number of the basis to get the interpolation xi for.
    :type userNumber: int
    :param interpolationXiSize: Size of interpolationXi to allocate.
    :returns: interpolationXi. The interpolation xi parameters for each Xi direction. Will be a value from the BasisInterpolationSpecifications enum.
    :rtype: Array of ints
    """

    return _wrap_routine(_iron_python.cmfe_Basis_InterpolationXiGetNum, [userNumber, interpolationXiSize])


def Basis_InterpolationXiSetNum(userNumber, interpolationXi):
    """Sets/changes the interpolation type in each xi directions for a basis identified by a user number.

    :param userNumber: The user number of the basis to get the interpolation xi for.
    :type userNumber: int
    :param interpolationXi: The interpolation xi parameters for each Xi direction. Must be a value from the BasisInterpolationSpecifications enum.
    :type interpolationXi: Array of ints
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Basis_InterpolationXiSetNum, [userNumber, interpolationXi])


def Basis_NumberOfLocalNodesGetNum(userNumber):
    """Returns the number of local nodes in a basis identified by a user number.

    :param userNumber: The user number of the basis to get the interpolation xi for.
    :type userNumber: int
    :returns: numberOfLocalNodes. The number of local nodes in the specified basis.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Basis_NumberOfLocalNodesGetNum, [userNumber])


def Basis_NumberOfXiGetNum(userNumber):
    """Returns the number of Xi directions in a basis identified by a user number.

    :param userNumber: The user number of the basis to get the number xi for.
    :type userNumber: int
    :returns: numberOfXi. The number of xi directions in the specified basis.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Basis_NumberOfXiGetNum, [userNumber])


def Basis_NumberOfXiSetNum(userNumber, numberOfXi):
    """Sets/changes the number of Xi directions in a basis identified by a user number.

    :param userNumber: The user number of the basis to set the number xi for.
    :type userNumber: int
    :param numberOfXi: The number of xi directions in the specified basis to set.
    :type numberOfXi: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Basis_NumberOfXiSetNum, [userNumber, numberOfXi])


def Basis_QuadratureLocalFaceGaussEvaluateSetNum(userNumber, faceGaussEvaluate):
    """Sets/changes the local face Gauss scheme calculation, on a basis identified by a user number.

    :param userNumber: The user number of the basis to get the quadrature type for.
    :type userNumber: int
    :param faceGaussEvaluate: The value to set face Gauss evaluation flag to.
    :type faceGaussEvaluate: bool
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Basis_QuadratureLocalFaceGaussEvaluateSetNum, [userNumber, faceGaussEvaluate])


def Basis_QuadratureMultipleGaussXiGetNum(userNumber, quadratureScheme, GaussPoints, GaussXiSizes):
    """Returns the xi positions of Gauss points on a basis quadrature identified by a user number.

    :param userNumber: The user number of the basis to get the Gauss Xi positions for.
    :type userNumber: int
    :param quadratureScheme: The quadrature scheme to return the Gauss positions for.
    :type quadratureScheme: int
    :param GaussPoints: The Gauss points to return the element xi positions for.
    :type GaussPoints: Array of ints
    :param GaussXiSizes: Tuple of dimensions of GaussXi to allocate, with length 2.
    :returns: GaussXi. GaussXi(Gauss_point,xi_direction) the Gauss xi positions for the specified quadrature scheme.
    :rtype: 2d array of floats
    """

    return _wrap_routine(_iron_python.cmfe_Basis_QuadratureMultipleGaussXiGetNum, [userNumber, quadratureScheme, GaussPoints, GaussXiSizes])


def Basis_QuadratureNumberOfGaussXiGetNum(userNumber, numberOfGaussXiSize):
    """Returns the number of Gauss points in each Xi directions for a basis quadrature identified by a user number.

    :param userNumber: The user number of the basis to get the number of Gauss Xi for.
    :type userNumber: int
    :param numberOfGaussXiSize: Size of numberOfGaussXi to allocate.
    :returns: numberOfGaussXi. The number of Gauss points in each Xi directions in the specified basis.
    :rtype: Array of ints
    """

    return _wrap_routine(_iron_python.cmfe_Basis_QuadratureNumberOfGaussXiGetNum, [userNumber, numberOfGaussXiSize])


def Basis_QuadratureNumberOfGaussXiSetNum(userNumber, numberOfGaussXi):
    """Sets/changes the number of Gauss points in each Xi directions for a basis quadrature identified by a user number.

    :param userNumber: The user number of the basis to set the number of Gauss Xi for.
    :type userNumber: int
    :param numberOfGaussXi: The number of Gauss points in each Xi directions in the specified basis to set.
    :type numberOfGaussXi: Array of ints
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Basis_QuadratureNumberOfGaussXiSetNum, [userNumber, numberOfGaussXi])


def Basis_QuadratureOrderGetNum(userNumber):
    """Returns the order of quadrature a basis quadrature identified by a user number.

    :param userNumber: The user number of the basis to get the quadrature order for.
    :type userNumber: int
    :returns: quadratureOrder. The order of quadrature in the specified basis.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Basis_QuadratureOrderGetNum, [userNumber])


def Basis_QuadratureOrderSetNum(userNumber, quadratureOrder):
    """Sets/changes the order of quadrature a basis quadrature identified by a user number.

    :param userNumber: The user number of the basis to set the quadrature order for.
    :type userNumber: int
    :param quadratureOrder: The order of quadrature in the specified basis to set.
    :type quadratureOrder: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Basis_QuadratureOrderSetNum, [userNumber, quadratureOrder])


def Basis_QuadratureSingleGaussXiGetNum(userNumber, quadratureScheme, GaussPoint, GaussXiSize):
    """Returns the xi position of a Gauss point on a basis quadrature identified by a user number.

    :param userNumber: The user number of the basis to get the Gauss Xi positions for.
    :type userNumber: int
    :param quadratureScheme: The quadrature scheme to return the Gauss positions for.
    :type quadratureScheme: int
    :param GaussPoint: The Gauss point to return the element xi positions for.
    :type GaussPoint: int
    :param GaussXiSize: Size of GaussXi to allocate.
    :returns: GaussXi. GaussXi(xi_direction) the xi position of the specified Gauss point for the specified quadrature scheme.
    :rtype: Array of floats
    """

    return _wrap_routine(_iron_python.cmfe_Basis_QuadratureSingleGaussXiGetNum, [userNumber, quadratureScheme, GaussPoint, GaussXiSize])


def Basis_QuadratureTypeGetNum(userNumber):
    """Returns the type of quadrature a basis quadrature identified by a user number.

    :param userNumber: The user number of the basis to get the quadrature type for.
    :type userNumber: int
    :returns: quadratureType. The type of quadrature in the specified basis. Will be a value from the QuadratureTypes enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Basis_QuadratureTypeGetNum, [userNumber])


def Basis_QuadratureTypeSetNum(userNumber, quadratureType):
    """Sets/changes the type of quadrature a basis quadrature identified by a user number.

    :param userNumber: The user number of the basis to get the quadrature type for.
    :type userNumber: int
    :param quadratureType: The type of quadrature in the specified basis to set. Must be a value from the QuadratureTypes enum.
    :type quadratureType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Basis_QuadratureTypeSetNum, [userNumber, quadratureType])


def Basis_TypeGetNum(userNumber):
    """Returns the type of a basis identified by a user number.

    :param userNumber: The user number of the basis to get the type for.
    :type userNumber: int
    :returns: basisType. The type of the specified basis. Will be a value from the BasisTypes enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Basis_TypeGetNum, [userNumber])


def Basis_TypeSetNum(userNumber, basisType):
    """Sets/changes the type of a basis identified by a user number.

    :param userNumber: The user number of the basis to set the type for.
    :type userNumber: int
    :param basisType: The type of the specified basis to set. Must be a value from the BasisTypes enum.
    :type basisType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Basis_TypeSetNum, [userNumber, basisType])


def BioelectricsFiniteElasticity_UpdateGeometricField(controlLoop, calcClosestGaussPoint):
    """Update the bioelectrics geometric field by interpolating the finite elasticity geometric field

    :param controlLoop: The bioelectrics control loop
    :type controlLoop: ControlLoop
    :param calcClosestGaussPoint:
    :type calcClosestGaussPoint: bool
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_BioelectricsFiniteElasticity_UpdateGeometricField, [controlLoop, calcClosestGaussPoint])


def BoundaryConditions_AddConstantNum(regionUserNumber, problemUserNumber, controlLoopIdentifiers, solverIndex, fieldUserNumber, variableType, componentNumber, condition, value):
    """Adds to the value of the specified constant and sets this as a boundary condition on the specified constant for boundary conditions identified by a user number.

    :param regionUserNumber: The user number of the region containing the dependent field to add the boundary conditions for.
    :type regionUserNumber: int
    :param problemUserNumber: The user number of the problem containing the solver equations to add the boundary conditions for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the solver equations boundary conditions for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the solver equations for.
    :type solverIndex: int
    :param fieldUserNumber: The user number of the dependent field for the boundary condition.
    :type fieldUserNumber: int
    :param variableType: The variable type of the dependent field to add the boundary condition at. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param componentNumber: The component number of the dependent field to add the boundary condition at.
    :type componentNumber: int
    :param condition: The boundary condition type to set. Must be a value from the BoundaryConditionsTypes enum.
    :type condition: int
    :param value: The value of the boundary condition to add.
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_BoundaryConditions_AddConstantNum, [regionUserNumber, problemUserNumber, controlLoopIdentifiers, solverIndex, fieldUserNumber, variableType, componentNumber, condition, value])


def BoundaryConditions_AddElementNum(regionUserNumber, problemUserNumber, controlLoopIdentifiers, solverIndex, fieldUserNumber, variableType, elementUserNumber, componentNumber, condition, value):
    """Adds the value to the specified element and sets this as a boundary condition on the specified element for boundary conditions identified by a user number.

    :param regionUserNumber: The user number of the region containing the equations set to add the boundary conditions for.
    :type regionUserNumber: int
    :param problemUserNumber: The user number of the problem containing the solver equations to destroy the boundary conditions for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the solver equations boundary conditions for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the solver equations for.
    :type solverIndex: int
    :param fieldUserNumber: The user number of the dependent field for the boundary condition.
    :type fieldUserNumber: int
    :param variableType: The variable type of the dependent field to add the boundary condition at. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param elementUserNumber: The user number of the element to add the boundary conditions for.
    :type elementUserNumber: int
    :param componentNumber: The component number of the dependent field to add the boundary condition at.
    :type componentNumber: int
    :param condition: The boundary condition type to set. Must be a value from the BoundaryConditionsTypes enum.
    :type condition: int
    :param value: The value of the boundary condition to add.
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_BoundaryConditions_AddElementNum, [regionUserNumber, problemUserNumber, controlLoopIdentifiers, solverIndex, fieldUserNumber, variableType, elementUserNumber, componentNumber, condition, value])


def BoundaryConditions_AddNodeNum(regionUserNumber, problemUserNumber, controlLoopIdentifiers, solverIndex, fieldUserNumber, variableType, versionNumber, derivativeNumber, nodeUserNumber, componentNumber, condition, value):
    """Adds the value to the specified node and sets this as a boundary condition on the specified node for boundary conditions identified by a user number.

    :param regionUserNumber: The user number of the region containing the equations set to add the boundary conditions for.
    :type regionUserNumber: int
    :param problemUserNumber: The user number of the problem containing the solver equations to destroy the boundary conditions for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the solver equations boundary conditions for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the solver equations for.
    :type solverIndex: int
    :param fieldUserNumber: The user number of the dependent field for the boundary condition.
    :type fieldUserNumber: int
    :param variableType: The variable type of the dependent field to add the boundary condition at. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param versionNumber: The user number of the node derivative version to add the boundary conditions for.
    :type versionNumber: int
    :param derivativeNumber: The user number of the node derivative to add the boundary conditions for.
    :type derivativeNumber: int
    :param nodeUserNumber: The user number of the node to add the boundary conditions for.
    :type nodeUserNumber: int
    :param componentNumber: The component number of the dependent field to add the boundary condition at.
    :type componentNumber: int
    :param condition: The boundary condition type to set. Must be a value from the BoundaryConditionsTypes enum.
    :type condition: int
    :param value: The value of the boundary condition to add.
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_BoundaryConditions_AddNodeNum, [regionUserNumber, problemUserNumber, controlLoopIdentifiers, solverIndex, fieldUserNumber, variableType, versionNumber, derivativeNumber, nodeUserNumber, componentNumber, condition, value])


def BoundaryConditions_ConstrainNodeDofsEqualNum(regionUserNumber, problemUserNumber, controlLoopIdentifier, solverIndex, fieldUserNumber, fieldVariableType, versionNumber, derivativeNumber, component, nodes, coefficient):
    """Constrain multiple nodal equations dependent field DOFs to be a single solver DOF in the solver equations

    :param regionUserNumber: The user number of the region containing the field DOFs to constrain.
    :type regionUserNumber: int
    :param problemUserNumber: The user number of the problem containing the solver equations.
    :type problemUserNumber: int
    :param controlLoopIdentifier: The control loop identifier to get the solver equations.
    :type controlLoopIdentifier: int
    :param solverIndex: The solver index of the solver equations.
    :type solverIndex: int
    :param fieldUserNumber: The user number of the dependent field containing the DOFs to contrain.
    :type fieldUserNumber: int
    :param fieldVariableType: The variable type of the dependent field containing the DOFs to constrain. Must be a value from the FieldVariableTypes enum.
    :type fieldVariableType: int
    :param versionNumber: The derivative version number.
    :type versionNumber: int
    :param derivativeNumber: The derivative number.
    :type derivativeNumber: int
    :param component: The field component number of the DOFs to be constrained.
    :type component: int
    :param nodes: The user numbers of the nodes to be constrained to be equal.
    :type nodes: Array of ints
    :param coefficient: The coefficient of constraint, applied to all but the first node.
    :type coefficient: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_BoundaryConditions_ConstrainNodeDofsEqualNum, [regionUserNumber, problemUserNumber, controlLoopIdentifier, solverIndex, fieldUserNumber, fieldVariableType, versionNumber, derivativeNumber, component, nodes, coefficient])


def BoundaryConditions_DestroyNum(problemUserNumber, controlLoopIdentifiers, solverIndex):
    """Destroys the boundary conditions for solver equations identified by a control loop identifier.

    :param problemUserNumber: The user number of the problem containing the solver equations to destroy the boundary conditions for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the solver equations boundary conditions for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the solver equations for.
    :type solverIndex: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_BoundaryConditions_DestroyNum, [problemUserNumber, controlLoopIdentifiers, solverIndex])


def BoundaryConditions_NeumannSparsityTypeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, sparsityType):
    """Sets the Neumann integration matrix sparsity for boundary conditions identified by a control loop identifier.

    :param problemUserNumber: The user number of the problem containing the solver equations to destroy the boundary conditions for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the solver equations boundary conditions for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the solver equations for.
    :type solverIndex: int
    :param sparsityType: The sparsity type for the Neumann integration matrices. Must be a value from the BoundaryConditionSparsityTypes enum.
    :type sparsityType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_BoundaryConditions_NeumannSparsityTypeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, sparsityType])


def BoundaryConditions_SetConstantNum(regionUserNumber, problemUserNumber, controlLoopIdentifiers, solverIndex, variableType, fieldUserNumber, componentNumber, condition, value):
    """Sets the value of the specified constant as a boundary condition on the specified constant for boundary conditions identified by a user number.

    :param regionUserNumber: The user number of the region containing the equations set to set the boundary conditions for.
    :type regionUserNumber: int
    :param problemUserNumber: The user number of the problem containing the solver equations to destroy the boundary conditions for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the solver equations boundary conditions for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the solver equations for.
    :type solverIndex: int
    :param variableType: The variable type of the dependent field to set the boundary condition at. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldUserNumber: The user number of the dependent field for the boundary condition.
    :type fieldUserNumber: int
    :param componentNumber: The component number of the dependent field to set the boundary condition at.
    :type componentNumber: int
    :param condition: The boundary condition type to set. Must be a value from the BoundaryConditionsTypes enum.
    :type condition: int
    :param value: The value of the boundary condition to set.
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_BoundaryConditions_SetConstantNum, [regionUserNumber, problemUserNumber, controlLoopIdentifiers, solverIndex, variableType, fieldUserNumber, componentNumber, condition, value])


def BoundaryConditions_SetElementNum(regionUserNumber, problemUserNumber, controlLoopIdentifiers, solverIndex, fieldUserNumber, variableType, elementUserNumber, componentNumber, condition, value):
    """Sets the value of the specified element as a boundary condition on the specified element for boundary conditions identified by a user number.

    :param regionUserNumber: The user number of the region containing the equations set to set the boundary conditions for.
    :type regionUserNumber: int
    :param problemUserNumber: The user number of the problem containing the solver equations to destroy the boundary conditions for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the solver equations boundary conditions for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the solver equations for.
    :type solverIndex: int
    :param fieldUserNumber: The user number of the dependent field for the boundary condition.
    :type fieldUserNumber: int
    :param variableType: The variable type of the dependent field to set the boundary condition at. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param elementUserNumber: The user number of the element to set the boundary conditions for.
    :type elementUserNumber: int
    :param componentNumber: The component number of the dependent field to set the boundary condition at.
    :type componentNumber: int
    :param condition: The boundary condition type to set. Must be a value from the BoundaryConditionsTypes enum.
    :type condition: int
    :param value: The value of the boundary condition to set.
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_BoundaryConditions_SetElementNum, [regionUserNumber, problemUserNumber, controlLoopIdentifiers, solverIndex, fieldUserNumber, variableType, elementUserNumber, componentNumber, condition, value])


def BoundaryConditions_SetNodeNum(regionUserNumber, problemUserNumber, controlLoopIdentifiers, solverIndex, fieldUserNumber, variableType, versionNumber, derivativeNumber, nodeUserNumber, componentNumber, condition, value):
    """Sets the value of the specified node as a boundary condition on the specified node for boundary conditions identified by a user number.

    :param regionUserNumber: The user number of the region containing the equations set to set the boundary conditions for.
    :type regionUserNumber: int
    :param problemUserNumber: The user number of the problem containing the solver equations to destroy the boundary conditions for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the solver equations boundary conditions for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the solver equations for.
    :type solverIndex: int
    :param fieldUserNumber: The user number of the dependent field for the boundary condition.
    :type fieldUserNumber: int
    :param variableType: The variable type of the dependent field to set the boundary condition at. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param versionNumber: The user number of the node derivative version to set the boundary conditions for.
    :type versionNumber: int
    :param derivativeNumber: The user number of the node derivative to set the boundary conditions for.
    :type derivativeNumber: int
    :param nodeUserNumber: The user number of the node to set the boundary conditions for.
    :type nodeUserNumber: int
    :param componentNumber: The component number of the dependent field to set the boundary condition at.
    :type componentNumber: int
    :param condition: The boundary condition type to set. Must be a value from the BoundaryConditionsTypes enum.
    :type condition: int
    :param value: The value of the boundary condition to set.
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_BoundaryConditions_SetNodeNum, [regionUserNumber, problemUserNumber, controlLoopIdentifiers, solverIndex, fieldUserNumber, variableType, versionNumber, derivativeNumber, nodeUserNumber, componentNumber, condition, value])


def CellMLEquations_CellMLAddNum(problemUserNumber, controlLoopIdentifiers, solverIndex, regionUserNumber, CellMLUserNumber):
    """Adds a CellML environment to CellML equations identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to add the CellML environment for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to add the CellML environment for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to add the CellML environment for.
    :type solverIndex: int
    :param regionUserNumber: The user number of the region containing the CellML environment.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML environment to add.
    :type CellMLUserNumber: int
    :returns: CellMLIndex. The index of the added CellML environment.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_CellMLEquations_CellMLAddNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, regionUserNumber, CellMLUserNumber])


def CellML_CreateCellMLToFieldMapNum(regionUserNumber, CellMLUserNumber, CellMLModelUserNumber, variableID, CellMLParameterSet, fieldUserNumber, variableType, componentNumber, fieldParameterSet):
    """Defines a CellML model variable to field variable component map by user number

    :param regionUserNumber: The user number of the region containing the CellML enviroment.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML enviroment.
    :type CellMLUserNumber: int
    :param CellMLModelUserNumber: The user number of the CellML model to map fom.
    :type CellMLModelUserNumber: int
    :param variableID: The of the CellML variable in the given model to map from.
    :type variableID: string
    :param CellMLParameterSet: The CellML variable parameter set to map from.
    :type CellMLParameterSet: int
    :param fieldUserNumber: The user number of the field to map to
    :type fieldUserNumber: int
    :param variableType: The field variable type to map to.
    :type variableType: int
    :param componentNumber: The field variable component number to map to.
    :type componentNumber: int
    :param fieldParameterSet: The field variable parameter set to map to.
    :type fieldParameterSet: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CellML_CreateCellMLToFieldMapNum, [regionUserNumber, CellMLUserNumber, CellMLModelUserNumber, variableID, CellMLParameterSet, fieldUserNumber, variableType, componentNumber, fieldParameterSet])


def CellML_CreateFieldToCellMLMapNum(regionUserNumber, CellMLUserNumber, fieldUserNumber, variableType, componentNumber, fieldParameterSet, CellMLModelUserNumber, variableID, CellMLParameterSet):
    """Defines a field variable component to CellML model variable map by user number.

    :param regionUserNumber: The user number of the region containing the CellML enviroment.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML enviroment.
    :type CellMLUserNumber: int
    :param fieldUserNumber: The user number of the field to map from.
    :type fieldUserNumber: int
    :param variableType: The field variable type to map from.
    :type variableType: int
    :param componentNumber: The field variable component number to map from.
    :type componentNumber: int
    :param fieldParameterSet: The field variable parameter set to map from.
    :type fieldParameterSet: int
    :param CellMLModelUserNumber: The user number of the CellML model to map to.
    :type CellMLModelUserNumber: int
    :param variableID: The of the CellML variable in the given model to map to.
    :type variableID: string
    :param CellMLParameterSet: The CellML variable parameter set to map to.
    :type CellMLParameterSet: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CellML_CreateFieldToCellMLMapNum, [regionUserNumber, CellMLUserNumber, fieldUserNumber, variableType, componentNumber, fieldParameterSet, CellMLModelUserNumber, variableID, CellMLParameterSet])


def CellML_CreateFinishNum(regionUserNumber, CellMLUserNumber):
    """Finishes the creation of a CellML environment identified by a user number.

    :param regionUserNumber: The user number of the region containing the CellML environment.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML enviroment to finish creating.
    :type CellMLUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CellML_CreateFinishNum, [regionUserNumber, CellMLUserNumber])


def CellML_CreateStartNum(CellMLUserNumber, regionUserNumber):
    """Starts the creation of a CellML environment identified by a user number.

    :param CellMLUserNumber: The user number of the CellML enviroment to start creating.
    :type CellMLUserNumber: int
    :param regionUserNumber: The user number of the Region containing the field to start the CellML enviroment creation on.
    :type regionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CellML_CreateStartNum, [CellMLUserNumber, regionUserNumber])


def CellML_DestroyNum(regionUserNumber, CellMLUserNumber):
    """Destroys a CellML environment identified by a user number.

    :param regionUserNumber: The user number of the region containing the CellML enviroment to destroy.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML enviroment to destroy.
    :type CellMLUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CellML_DestroyNum, [regionUserNumber, CellMLUserNumber])


def CellML_FieldComponentGetNum(regionUserNumber, CellMLUserNumber, CellMLModelUserNumber, CellMLFieldType, variableID):
    """Returns the field component number that corresponds to a character string VariableID for a CellML environment identified by a user number.

    :param regionUserNumber: The user number of the region containing the CellML environment.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML enviroment to get the field component for.
    :type CellMLUserNumber: int
    :param CellMLModelUserNumber: The user number of the CellML model to map fom.
    :type CellMLModelUserNumber: int
    :param CellMLFieldType: The type of CellML field to get the component for. Must be a value from the CellMLFieldTypes enum.
    :type CellMLFieldType: int
    :param variableID: The variable ID to get the corresponding field component for.
    :type variableID: string
    :returns: fieldComponent. The field component corresponding to the ID.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_CellML_FieldComponentGetNum, [regionUserNumber, CellMLUserNumber, CellMLModelUserNumber, CellMLFieldType, variableID])


def CellML_FieldMapsCreateFinishNum(regionUserNumber, CellMLUserNumber):
    """Finishes the creation of field maps for a CellML environment identified by a user number.

    :param regionUserNumber: The user number of the region containing the CellML environment.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML enviroment to finish creating.
    :type CellMLUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CellML_FieldMapsCreateFinishNum, [regionUserNumber, CellMLUserNumber])


def CellML_FieldMapsCreateStartNum(regionUserNumber, CellMLUserNumber):
    """Starts the creation of field maps for a CellML environment identified by a user number.

    :param regionUserNumber: The user number of the Region containing the CellML enviroment.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML enviroment to start creating the maps for.
    :type CellMLUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CellML_FieldMapsCreateStartNum, [regionUserNumber, CellMLUserNumber])


def CellML_GenerateNum(regionUserNumber, CellMLUserNumber):
    """Validiate and instantiate a CellML environment identified by a user number.

    :param regionUserNumber: The user number of the region containing the CellML environment.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML enviroment to generate.
    :type CellMLUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CellML_GenerateNum, [regionUserNumber, CellMLUserNumber])


def CellML_IntermediateFieldCreateFinishNum(regionUserNumber, CellMLUserNumber):
    """Finishes the creation of CellML intermediate field for a CellML environment identified by a user number.

    :param regionUserNumber: The user number of the region containing the CellML environment.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML enviroment to finish creating the intermediate field for.
    :type CellMLUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CellML_IntermediateFieldCreateFinishNum, [regionUserNumber, CellMLUserNumber])


def CellML_IntermediateFieldCreateStartNum(regionUserNumber, CellMLUserNumber, CellMLIntermediateFieldUserNumber):
    """Starts the creation of CellML intermediate field for a CellML environment identified by a user number.

    :param regionUserNumber: The user number of the region containing the CellML environment.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML environment to start creating the intermediate field for.
    :type CellMLUserNumber: int
    :param CellMLIntermediateFieldUserNumber: The user number of the CellML intermediate field to start creating.
    :type CellMLIntermediateFieldUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CellML_IntermediateFieldCreateStartNum, [regionUserNumber, CellMLUserNumber, CellMLIntermediateFieldUserNumber])


def CellML_IntermediateFieldGetNum(regionUserNumber, CellMLUserNumber):
    """Returns the CellML intermediate field for a CellML environment identified by a user number.

    :param regionUserNumber: The user number of the region containing the CellML environment.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML enviroment to get the CellML intermediate field for.
    :type CellMLUserNumber: int
    :returns: CellMLIntermediateFieldUserNumber. The user number of the CellML intermediate field.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_CellML_IntermediateFieldGetNum, [regionUserNumber, CellMLUserNumber])


def CellML_ModelImportNum(regionUserNumber, CellMLUserNumber, URI):
    """Imports a specified CellML model as specified by a character URI into a CellML environment identified by a user number.

    :param regionUserNumber: The user number of the region containing the CellML enviroment to import the model into.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML enviroment to import the model into.
    :type CellMLUserNumber: int
    :param URI: The URI of the CellML model to import.
    :type URI: string
    :returns: modelIndex. The index of the imported model.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_CellML_ModelImportNum, [regionUserNumber, CellMLUserNumber, URI])


def CellML_ModelsFieldCreateFinishNum(regionUserNumber, CellMLUserNumber):
    """Finishes the creation of CellML models field for a CellML environment identified by a user number.

    :param regionUserNumber: The user number of the region containing the CellML enviroment to finish creating.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML enviroment to finish creating the models field for.
    :type CellMLUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CellML_ModelsFieldCreateFinishNum, [regionUserNumber, CellMLUserNumber])


def CellML_ModelsFieldCreateStartNum(regionUserNumber, CellMLUserNumber, CellMLModelsFieldUserNumber):
    """Starts the creation of CellML models field for a CellML environment identified by a user number.

    :param regionUserNumber: The user number of the region containing the CellML enviroment.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML environment to start creating the models field for.
    :type CellMLUserNumber: int
    :param CellMLModelsFieldUserNumber: The user number of the CellML models field to start creating.
    :type CellMLModelsFieldUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CellML_ModelsFieldCreateStartNum, [regionUserNumber, CellMLUserNumber, CellMLModelsFieldUserNumber])


def CellML_ModelsFieldGetNum(regionUserNumber, CellMLUserNumber):
    """Returns the CellML models field for a CellML environment identified by a user number.

    :param regionUserNumber: The user number of the region containing the CellML enviroment to get the CellML models field for.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML enviroment to get the CellML models field for.
    :type CellMLUserNumber: int
    :returns: CellMLModelsFieldUserNumber. The user number of the CellML models field.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_CellML_ModelsFieldGetNum, [regionUserNumber, CellMLUserNumber])


def CellML_ParametersFieldCreateFinishNum(regionUserNumber, CellMLUserNumber):
    """Finishes the creation of CellML parameters field for a CellML environment identified by a user number.

    :param regionUserNumber: The user number of the region containing the CellML environment.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML enviroment to finish creating the parameters field for.
    :type CellMLUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CellML_ParametersFieldCreateFinishNum, [regionUserNumber, CellMLUserNumber])


def CellML_ParametersFieldCreateStartNum(regionUserNumber, CellMLUserNumber, CellMLParametersFieldUserNumber):
    """Starts the creation of CellML parameters field for a CellML environment identified by a user number.

    :param regionUserNumber: The user number of the region containing the CellML environment.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML environment to start creating the parameters field for.
    :type CellMLUserNumber: int
    :param CellMLParametersFieldUserNumber: The user number of the CellML parameters field to start creating.
    :type CellMLParametersFieldUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CellML_ParametersFieldCreateStartNum, [regionUserNumber, CellMLUserNumber, CellMLParametersFieldUserNumber])


def CellML_ParametersFieldGetNum(regionUserNumber, CellMLUserNumber):
    """Returns the CellML parameters field for a CellML environment identified by a user number.

    :param regionUserNumber: The user number of the region containing the CellML environment.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML enviroment to get the CellML parameters field for.
    :type CellMLUserNumber: int
    :returns: CellMLParametersFieldUserNumber. The user number of the CellML parameters field.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_CellML_ParametersFieldGetNum, [regionUserNumber, CellMLUserNumber])


def CellML_StateFieldCreateFinishNum(regionUserNumber, CellMLUserNumber):
    """Finishes the creation of CellML state field for a CellML environment identified by a user number.

    :param regionUserNumber: The user number of the region containing the CellML environment.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML enviroment to finish creating the state field for.
    :type CellMLUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CellML_StateFieldCreateFinishNum, [regionUserNumber, CellMLUserNumber])


def CellML_StateFieldCreateStartNum(regionUserNumber, CellMLUserNumber, CellMLStateFieldUserNumber):
    """Starts the creation of CellML state field for a CellML environment identified by a user number.

    :param regionUserNumber: The user number of the region containing the CellML environment.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML environment to start creating the state field for.
    :type CellMLUserNumber: int
    :param CellMLStateFieldUserNumber: The user number of the CellML state field to start creating.
    :type CellMLStateFieldUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CellML_StateFieldCreateStartNum, [regionUserNumber, CellMLUserNumber, CellMLStateFieldUserNumber])


def CellML_StateFieldGetNum(regionUserNumber, CellMLUserNumber):
    """Returns the CellML state field for a CellML environment identified by a user number.

    :param regionUserNumber: The user number of the region containing the CellML environment.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML enviroment to get the CellML state field for.
    :type CellMLUserNumber: int
    :returns: CellMLStateFieldUserNumber. The user number of the CellML state field.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_CellML_StateFieldGetNum, [regionUserNumber, CellMLUserNumber])


def CellML_VariableSetAsKnownNum(regionUserNumber, CellMLUserNumber, CellMLModelUserNumber, variableID):
    """Sets a CellML model variable to be known by user number.

    :param regionUserNumber: The user number of the region containing the CellML enviroment.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML enviroment.
    :type CellMLUserNumber: int
    :param CellMLModelUserNumber: The user number of the CellML model in which to find the given variable.
    :type CellMLModelUserNumber: int
    :param variableID: The CellML variable to set as known (in the format 'component_name/variable_name').
    :type variableID: string
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CellML_VariableSetAsKnownNum, [regionUserNumber, CellMLUserNumber, CellMLModelUserNumber, variableID])


def CellML_VariableSetAsWantedNum(regionUserNumber, CellMLUserNumber, CellMLModelUserNumber, variableID):
    """Sets a CellML model variable to be wanted by user number.

    :param regionUserNumber: The user number of the region containing the CellML enviroment.
    :type regionUserNumber: int
    :param CellMLUserNumber: The user number of the CellML enviroment.
    :type CellMLUserNumber: int
    :param CellMLModelUserNumber: The user number of the CellML model in which to find the given variable.
    :type CellMLModelUserNumber: int
    :param variableID: The CellML variable to set as wanted (in the format 'component_name/variable_name').
    :type variableID: string
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CellML_VariableSetAsWantedNum, [regionUserNumber, CellMLUserNumber, CellMLModelUserNumber, variableID])


def ComputationalNodeNumberGet():
    """Returns the computational node number of the running process.

    :returns: nodeNumber. The computational node number.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_ComputationalNodeNumberGet, [])


def ComputationalNumberOfNodesGet():
    """Returns the number of computational nodes for the running process.

    :returns: numberOfNodes. The number of computational nodes.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_ComputationalNumberOfNodesGet, [])


def ControlLoop_AbsoluteToleranceSetNum(problemUserNumber, controlLoopIdentifiers, absoluteTolerance):
    """Sets/changes the maximum iterations for a while control loop identified by user numbers.

    :param problemUserNumber: The user number of the problem to set the maximum iterations for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: The control loop identifiers.
    :type controlLoopIdentifiers: Array of ints
    :param absoluteTolerance: The absolute tolerance value for a control loop.
    :type absoluteTolerance: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_ControlLoop_AbsoluteToleranceSetNum, [problemUserNumber, controlLoopIdentifiers, absoluteTolerance])


def ControlLoop_ControlLoopGetNum(problemUserNumber, controlLoopRootIdentifiers, controlLoopIdentifiers, controlLoop):
    """Returns the specified control loop as indexed by the control loop identifier from the control loop root identified by user numbers.

    :param problemUserNumber: The user number of the problem to get the control loop for.
    :type problemUserNumber: int
    :param controlLoopRootIdentifiers: The root control loop identifiers.
    :type controlLoopRootIdentifiers: Array of ints
    :param controlLoopIdentifiers: The control loop identifiers.
    :type controlLoopIdentifiers: Array of ints
    :param controlLoop: On return, the specified control loop.
    :type controlLoop: ControlLoop
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_ControlLoop_ControlLoopGetNum, [problemUserNumber, controlLoopRootIdentifiers, controlLoopIdentifiers, controlLoop])


def ControlLoop_CurrentTimesGetNum(problemUserNumber, controlLoopIdentifiers):
    """Gets the current time parameters for a time control loop identified by user numbers.

    :param problemUserNumber: The user number of the problem to get the control loop for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the control loop for.
    :type controlLoopIdentifiers: Array of ints
    :returns: (The current time of the time control loop, The current time increment of the time control loop)
    :rtype: tuple. (float, float)
    """

    return _wrap_routine(_iron_python.cmfe_ControlLoop_CurrentTimesGetNum, [problemUserNumber, controlLoopIdentifiers])


def ControlLoop_DestroyNum(problemUserNumber, controlLoopIdentifiers):
    """Destroys a control loop identified by user numbers.

    :param problemUserNumber: The user number of the problem to destroy the control loop for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: The control loop identifiers.
    :type controlLoopIdentifiers: Array of ints
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_ControlLoop_DestroyNum, [problemUserNumber, controlLoopIdentifiers])


def ControlLoop_IterationsSetNum(problemUserNumber, controlLoopIdentifiers, startIteration, stopIteration, iterationIncrement):
    """Sets/changes the iteration parameters for a fixed control loop identified by user numbers.

    :param problemUserNumber: The user number of the problem to set the iteration parameters for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: The control loop identifiers.
    :type controlLoopIdentifiers: Array of ints
    :param startIteration: The start iteration of the fixed control loop to set.
    :type startIteration: int
    :param stopIteration: The stop iteration of the fixed control loop to set.
    :type stopIteration: int
    :param iterationIncrement: The iteration increment of the fixed control loop to set.
    :type iterationIncrement: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_ControlLoop_IterationsSetNum, [problemUserNumber, controlLoopIdentifiers, startIteration, stopIteration, iterationIncrement])


def ControlLoop_LabelGetNum(problemUserNumber, controlLoopIdentifiers):
    """Returns the character string label for a control loop identified by an user number.

    :param problemUserNumber: The user number of the problem to set the label for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: The control loop identifiers.
    :type controlLoopIdentifiers: Array of ints
    :returns: label. The control loop label.
    :rtype: string
    """

    return _wrap_routine(_iron_python.cmfe_ControlLoop_LabelGetNum, [problemUserNumber, controlLoopIdentifiers])


def ControlLoop_LabelSetNum(problemUserNumber, controlLoopIdentifiers, label):
    """Sets/changes the character string label for a control loop identified by an user number.

    :param problemUserNumber: The user number of the problem to set the label for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: The control loop identifiers.
    :type controlLoopIdentifiers: Array of ints
    :param label: The region label to set.
    :type label: string
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_ControlLoop_LabelSetNum, [problemUserNumber, controlLoopIdentifiers, label])


def ControlLoop_MaximumIterationsSetNum(problemUserNumber, controlLoopIdentifiers, maximumIterations):
    """Sets/changes the maximum iterations for a while control loop identified by user numbers.

    :param problemUserNumber: The user number of the problem to set the maximum iterations for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: The control loop identifiers.
    :type controlLoopIdentifiers: Array of ints
    :param maximumIterations: The maximum iterations of the while control loop to set.
    :type maximumIterations: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_ControlLoop_MaximumIterationsSetNum, [problemUserNumber, controlLoopIdentifiers, maximumIterations])


def ControlLoop_NumberOfIterationsGetNum(problemUserNumber, controlLoopIdentifiers):
    """Gets the number of iterations for a time control loop identified by user numbers.

    :param problemUserNumber: The user number of the problem to get the number of iterations for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: The control loop identifiers to get the number of iterations for.
    :type controlLoopIdentifiers: Array of ints
    :returns: numberOfIterations. The number of iterations
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_ControlLoop_NumberOfIterationsGetNum, [problemUserNumber, controlLoopIdentifiers])


def ControlLoop_NumberOfIterationsSetNum(problemUserNumber, controlLoopIdentifiers, numberOfIterations):
    """Sets the number of iterations for a time control loop identified by user numbers.

    :param problemUserNumber: The user number of the problem to set the number of iterations for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: The control loop identifiers to set the number of iterations for.
    :type controlLoopIdentifiers: Array of ints
    :param numberOfIterations: The number of iterations to set
    :type numberOfIterations: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_ControlLoop_NumberOfIterationsSetNum, [problemUserNumber, controlLoopIdentifiers, numberOfIterations])


def ControlLoop_NumberOfSubLoopsGetNum(problemUserNumber, controlLoopIdentifiers):
    """Returns the number of sub-control loops for a control loop identified by user numbers.

    :param problemUserNumber: The user number of the problem to get the number of sub loops for for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: The control loop identifiers.
    :type controlLoopIdentifiers: Array of ints
    :returns: numberOfSubLoops. The number of sub loops for the specified control loop.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_ControlLoop_NumberOfSubLoopsGetNum, [problemUserNumber, controlLoopIdentifiers])


def ControlLoop_NumberOfSubLoopsSetNum(problemUserNumber, controlLoopIdentifiers, numberOfSubLoops):
    """Sets/changes the number of sub-control loops for a control loop identified by user numbers. \todo is this really public???

    :param problemUserNumber: The user number of the problem to set the number of sub loops for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: The control loop identifiers.
    :type controlLoopIdentifiers: Array of ints
    :param numberOfSubLoops: The number of sub loops for the specified control loop to set.
    :type numberOfSubLoops: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_ControlLoop_NumberOfSubLoopsSetNum, [problemUserNumber, controlLoopIdentifiers, numberOfSubLoops])


def ControlLoop_OutputTypeGetNum(problemUserNumber, controlLoopIdentifiers):
    """Returns the output type for a control loop identified by user numbers.

    :param problemUserNumber: The user number of the problem to get the output type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: The control loop identifiers to get the output type for.
    :type controlLoopIdentifiers: Array of ints
    :returns: outputType. The output type of the control loop. Will be a value from the ControlLoopOutputTypes enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_ControlLoop_OutputTypeGetNum, [problemUserNumber, controlLoopIdentifiers])


def ControlLoop_OutputTypeSetNum(problemUserNumber, controlLoopIdentifiers, outputType):
    """Sets the output type for a control loop identified by user numbers.

    :param problemUserNumber: The user number of the problem to set the output type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: The control loop identifiers to set the output type for.
    :type controlLoopIdentifiers: Array of ints
    :param outputType: The output type to set. Must be a value from the ControlLoopOutputTypes enum.
    :type outputType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_ControlLoop_OutputTypeSetNum, [problemUserNumber, controlLoopIdentifiers, outputType])


def ControlLoop_TimeInputSetNum(problemUserNumber, controlLoopIdentifiers, inputOption):
    """Sets/changes the input parameters for a time control loop identified by user numbers.

    :param problemUserNumber: The user number of the problem to get the output parameters for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: The control loop identifier.
    :type controlLoopIdentifiers: Array of ints
    :param inputOption: The output frequency modulo to set.
    :type inputOption: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_ControlLoop_TimeInputSetNum, [problemUserNumber, controlLoopIdentifiers, inputOption])


def ControlLoop_TimeOutputSetNum(problemUserNumber, controlLoopIdentifiers, outputFrequency):
    """Sets/changes the output parameters for a time control loop identified by user numbers.

    :param problemUserNumber: The user number of the problem to get the output parameters for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: The control loop identifier.
    :type controlLoopIdentifiers: Array of ints
    :param outputFrequency: The output frequency modulo to set.
    :type outputFrequency: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_ControlLoop_TimeOutputSetNum, [problemUserNumber, controlLoopIdentifiers, outputFrequency])


def ControlLoop_TimesGetNum(problemUserNumber, controlLoopIdentifiers):
    """Returns the time parameters for a time control loop identified by user numbers.

    :param problemUserNumber: The user number of the problem to get the time parameters for for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: The control loop identifier.
    :type controlLoopIdentifiers: Array of ints
    :returns: (The start time for the time control loop, The stop time for the time control loop, The time increment for the time control loop, The current time for the time control loop, The iteration number for the current loop, The iteration number for the time control loop)
    :rtype: tuple. (float, float, float, float, int, int)
    """

    return _wrap_routine(_iron_python.cmfe_ControlLoop_TimesGetNum, [problemUserNumber, controlLoopIdentifiers])


def ControlLoop_TimesSetNum(problemUserNumber, controlLoopIdentifiers, startTime, stopTime, timeIncrement):
    """Sets/changes the time parameters for a time control loop identified by user numbers.

    :param problemUserNumber: The user number of the problem to get the time parameters for for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: The control loop identifier.
    :type controlLoopIdentifiers: Array of ints
    :param startTime: The start time for the time control loop to set.
    :type startTime: float
    :param stopTime: The stop time for the time control loop to set.
    :type stopTime: float
    :param timeIncrement: The time increment for the time control loop to set.
    :type timeIncrement: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_ControlLoop_TimesSetNum, [problemUserNumber, controlLoopIdentifiers, startTime, stopTime, timeIncrement])


def ControlLoop_TypeSetNum(problemUserNumber, controlLoopIdentifiers, loopType):
    """Sets/changes the loop type for a control loop identified by user numbers. \todo is this really public???

    :param problemUserNumber: The user number of the problem to set the loop type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: The control loop identifiers.
    :type controlLoopIdentifiers: Array of ints
    :param loopType: The type of control loop to set. Must be a value from the ProblemControlLoopTypes enum.
    :type loopType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_ControlLoop_TypeSetNum, [problemUserNumber, controlLoopIdentifiers, loopType])


def CoordinateSystem_CreateFinishNum(coordinateSystemUserNumber):
    """Finishes the creation of a coordinate system identified by a user number.

    :param coordinateSystemUserNumber: The user number of the coordinate system to finish creating.
    :type coordinateSystemUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CoordinateSystem_CreateFinishNum, [coordinateSystemUserNumber])


def CoordinateSystem_CreateStartNum(coordinateSystemUserNumber):
    """Starts the creation of a coordinate system identified by a user number.

    :param coordinateSystemUserNumber: The user number of the coordinate system to start creating.
    :type coordinateSystemUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CoordinateSystem_CreateStartNum, [coordinateSystemUserNumber])


def CoordinateSystem_DestroyNum(coordinateSystemUserNumber):
    """Destroys a coordinate system identified by a user number.

    :param coordinateSystemUserNumber: The user number of the coordinate system to destroy.
    :type coordinateSystemUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CoordinateSystem_DestroyNum, [coordinateSystemUserNumber])


def CoordinateSystem_DimensionGetNum(coordinateSystemUserNumber):
    """Returns the dimension of a coordinate system identified by a user number.

    :param coordinateSystemUserNumber: The user number of the coordinate system to get the dimension for.
    :type coordinateSystemUserNumber: int
    :returns: coordinateSystemDimension. The dimension of the coordinate system
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_CoordinateSystem_DimensionGetNum, [coordinateSystemUserNumber])


def CoordinateSystem_DimensionSetNum(coordinateSystemUserNumber, coordinateSystemDimension):
    """Sets/changes the dimension of a coordinate system identified by a user number.

    :param coordinateSystemUserNumber: The user number of the coordinate system to set the dimension for.
    :type coordinateSystemUserNumber: int
    :param coordinateSystemDimension: The dimension of the coordinate system to set.
    :type coordinateSystemDimension: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CoordinateSystem_DimensionSetNum, [coordinateSystemUserNumber, coordinateSystemDimension])


def CoordinateSystem_FocusGetNum(coordinateSystemUserNumber):
    """Returns the focus of a coordinate system identified by a user number.

    :param coordinateSystemUserNumber: The user number of the coordinate system to get the focus for.
    :type coordinateSystemUserNumber: int
    :returns: focus. The focus of the coordinate system
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_CoordinateSystem_FocusGetNum, [coordinateSystemUserNumber])


def CoordinateSystem_FocusSetNum(coordinateSystemUserNumber, focus):
    """Sets/changes the focus of a coordinate system identified by a user number.

    :param coordinateSystemUserNumber: The user number of the coordinate system to set the focus for.
    :type coordinateSystemUserNumber: int
    :param focus: The focus of the coordinate system to set.
    :type focus: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CoordinateSystem_FocusSetNum, [coordinateSystemUserNumber, focus])


def CoordinateSystem_OrientationGetNum(coordinateSystemUserNumber, orientationSizes):
    """Returns the orientation of a coordinate system identified by a user number.

    :param coordinateSystemUserNumber: The user number of the coordinate system to get the orientation for.
    :type coordinateSystemUserNumber: int
    :param orientationSizes: Tuple of dimensions of orientation to allocate, with length 2.
    :returns: orientation. The orientation of the coordinate system.
    :rtype: 2d array of floats
    """

    return _wrap_routine(_iron_python.cmfe_CoordinateSystem_OrientationGetNum, [coordinateSystemUserNumber, orientationSizes])


def CoordinateSystem_OrientationSetNum(coordinateSystemUserNumber, orientation):
    """Sets/changes the orientation of a coordinate system identified by a user number.

    :param coordinateSystemUserNumber: The user number of the coordinate system to set the orientation for.
    :type coordinateSystemUserNumber: int
    :param orientation: The orientation of the coordinate system to set.
    :type orientation: 2d array of floats
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CoordinateSystem_OrientationSetNum, [coordinateSystemUserNumber, orientation])


def CoordinateSystem_OriginGetNum(coordinateSystemUserNumber, originSize):
    """Returns the origin of a coordinate system identified by a user number.

    :param coordinateSystemUserNumber: The user number of the coordinate system to get the origin for.
    :type coordinateSystemUserNumber: int
    :param originSize: Size of origin to allocate.
    :returns: origin. The orign of the coordinate system.
    :rtype: Array of floats
    """

    return _wrap_routine(_iron_python.cmfe_CoordinateSystem_OriginGetNum, [coordinateSystemUserNumber, originSize])


def CoordinateSystem_OriginSetNum(coordinateSystemUserNumber, origin):
    """Sets/changes the origin of a coordinate system identified by a user number.

    :param coordinateSystemUserNumber: The user number of the coordinate system to set the origin for.
    :type coordinateSystemUserNumber: int
    :param origin: The orign of the coordinate system to set.
    :type origin: Array of floats
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CoordinateSystem_OriginSetNum, [coordinateSystemUserNumber, origin])


def CoordinateSystem_RadialInterpolationGetNum(coordinateSystemUserNumber):
    """Returns the radial interpolation type of a coordinate system identified by a user number.

    :param coordinateSystemUserNumber: The user number of the coordinate system to get the radial interpolation for.
    :type coordinateSystemUserNumber: int
    :returns: radialInterpolationType. The radial interpolation type of the coordinate system. Will be a value from the CoordinateRadialInterpolations enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_CoordinateSystem_RadialInterpolationGetNum, [coordinateSystemUserNumber])


def CoordinateSystem_RadialInterpolationSetNum(coordinateSystemUserNumber, radialInterpolationType):
    """Sets/changes the radial interpolation type of a coordinate system identified by a user number.

    :param coordinateSystemUserNumber: The user number of the coordinate system to set the radial interpolation for.
    :type coordinateSystemUserNumber: int
    :param radialInterpolationType: The radial interpolation type of the coordinate system to set. Must be a value from the CoordinateRadialInterpolations enum.
    :type radialInterpolationType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CoordinateSystem_RadialInterpolationSetNum, [coordinateSystemUserNumber, radialInterpolationType])


def CoordinateSystem_TypeGetNum(coordinateSystemUserNumber):
    """Returns the type of a coordinate system identified by a user number.

    :param coordinateSystemUserNumber: The user number of the coordinate system to get the type for.
    :type coordinateSystemUserNumber: int
    :returns: coordinateSystemType. The type of the coordinate system. Will be a value from the CoordinateSystemTypes enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_CoordinateSystem_TypeGetNum, [coordinateSystemUserNumber])


def CoordinateSystem_TypeSetNum(coordinateSystemUserNumber, coordinateSystemType):
    """Sets/changes the type of a coordinate system identified by a user number.

    :param coordinateSystemUserNumber: The user number of the coordinate system to set the type for.
    :type coordinateSystemUserNumber: int
    :param coordinateSystemType: The type of the coordinate system to set. Must be a value from the CoordinateSystemTypes enum.
    :type coordinateSystemType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_CoordinateSystem_TypeSetNum, [coordinateSystemUserNumber, coordinateSystemType])


def DataPoints_CreateFinishNum(regionUserNumber):
    """Finishes the process of creating data points in a region for data points identified by user number.

    :param regionUserNumber: The user number of the region containing the data points to finish the creation of.
    :type regionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataPoints_CreateFinishNum, [regionUserNumber])


def DataPoints_CreateStartNum(regionUserNumber, numberOfDataPoints):
    """Starts the process of creating data points in a region for data points identified by user number.

    :param regionUserNumber: The user number of the region containing the data points to start the creation of.
    :type regionUserNumber: int
    :param numberOfDataPoints: The number of data points to create.
    :type numberOfDataPoints: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataPoints_CreateStartNum, [regionUserNumber, numberOfDataPoints])


def DataPoints_DestroyNum(regionUserNumber):
    """Destroys the data points in a region for data points identified by user number.

    :param regionUserNumber: The user number of the region containing the data points to destroy.
    :type regionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataPoints_DestroyNum, [regionUserNumber])


def DataPoints_LabelGetNum(regionUserNumber, dataPointGlobalNumber):
    """Returns the character label for a data point in a set of data points identified by user number.

    :param regionUserNumber: The user number of the region containing the data points to get the label for.
    :type regionUserNumber: int
    :param dataPointGlobalNumber: The global number of the data points to get the label for.
    :type dataPointGlobalNumber: int
    :returns: label. The label for the data point.
    :rtype: string
    """

    return _wrap_routine(_iron_python.cmfe_DataPoints_LabelGetNum, [regionUserNumber, dataPointGlobalNumber])


def DataPoints_LabelSetNum(regionUserNumber, dataPointGlobalNumber, label):
    """Sets/changes the character label for a data point in a set of data points identified by user number.

    :param regionUserNumber: The user number of the region containing the data points to set the label for.
    :type regionUserNumber: int
    :param dataPointGlobalNumber: The global number of the data points to set the label for.
    :type dataPointGlobalNumber: int
    :param label: The label for the data point to set.
    :type label: string
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataPoints_LabelSetNum, [regionUserNumber, dataPointGlobalNumber, label])


def DataPoints_NumberOfDataPointsGetNum(regionUserNumber):
    """Returns the number of data points

    :param regionUserNumber: The user number of the region containing the data points to get data point count for.
    :type regionUserNumber: int
    :returns: numberOfDataPoints. The number of data points
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_DataPoints_NumberOfDataPointsGetNum, [regionUserNumber])


def DataPoints_UserNumberGetNum(regionUserNumber, dataPointGlobalNumber):
    """Returns the user number for a data point in a set of data points identified by user number.

    :param regionUserNumber: The user number of the region containing the data points to get the data point user number for.
    :type regionUserNumber: int
    :param dataPointGlobalNumber: The global number of the data points to get the data point user number for.
    :type dataPointGlobalNumber: int
    :returns: dataPointUserNumber. The user number for the data point.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_DataPoints_UserNumberGetNum, [regionUserNumber, dataPointGlobalNumber])


def DataPoints_UserNumberSetNum(regionUserNumber, dataPointGlobalNumber, dataPointUserNumber):
    """Sets/changes the user number for a data point in a set of data points identified by user number.

    :param regionUserNumber: The user number of the region containing the data points to set the data point user number for.
    :type regionUserNumber: int
    :param dataPointGlobalNumber: The global number of the data points to set the data point user number for.
    :type dataPointGlobalNumber: int
    :param dataPointUserNumber: The user number for the data point to set.
    :type dataPointUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataPoints_UserNumberSetNum, [regionUserNumber, dataPointGlobalNumber, dataPointUserNumber])


def DataPoints_ValuesGetNum(regionUserNumber, dataPointGlobalNumber, dataPointValuesSize):
    """Returns the values for a data point in a set of data points identified by user number.

    :param regionUserNumber: The user number of the region containing the data points to get the data point user number for.
    :type regionUserNumber: int
    :param dataPointGlobalNumber: The global number of the data points to get the data point values for.
    :type dataPointGlobalNumber: int
    :param dataPointValuesSize: Size of dataPointValues to allocate.
    :returns: dataPointValues. The values for the data point.
    :rtype: Array of floats
    """

    return _wrap_routine(_iron_python.cmfe_DataPoints_ValuesGetNum, [regionUserNumber, dataPointGlobalNumber, dataPointValuesSize])


def DataPoints_ValuesSetNum(regionUserNumber, dataPointGlobalNumber, dataPointValues):
    """Sets/changes the values for a data point in a set of data points identified by user number.

    :param regionUserNumber: The user number of the region containing the data points to set the data point user number for.
    :type regionUserNumber: int
    :param dataPointGlobalNumber: The global number of the data points to set the data point user number for.
    :type dataPointGlobalNumber: int
    :param dataPointValues: The values for the data point to set.
    :type dataPointValues: Array of floats
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataPoints_ValuesSetNum, [regionUserNumber, dataPointGlobalNumber, dataPointValues])


def DataPoints_WeightsGetNum(regionUserNumber, dataPointGlobalNumber, dataPointWeightsSize):
    """Returns the weights for a data point in a set of data points identified by user number.

    :param regionUserNumber: The user number of the region containing the data points to get the data point user number for.
    :type regionUserNumber: int
    :param dataPointGlobalNumber: The global number of the data points to get the data point user number for.
    :type dataPointGlobalNumber: int
    :param dataPointWeightsSize: Size of dataPointWeights to allocate.
    :returns: dataPointWeights. The weights for the data point.
    :rtype: Array of floats
    """

    return _wrap_routine(_iron_python.cmfe_DataPoints_WeightsGetNum, [regionUserNumber, dataPointGlobalNumber, dataPointWeightsSize])


def DataPoints_WeightsSetNum(regionUserNumber, dataPointGlobalNumber, dataPointWeights):
    """Sets/changes the weights for a data point in a set of data points identified by user number.

    :param regionUserNumber: The user number of the region containing the data points to set the data point user number for.
    :type regionUserNumber: int
    :param dataPointGlobalNumber: The global number of the data points to set the data point user number for.
    :type dataPointGlobalNumber: int
    :param dataPointWeights: The weights for the data point to set.
    :type dataPointWeights: Array of floats
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataPoints_WeightsSetNum, [regionUserNumber, dataPointGlobalNumber, dataPointWeights])


def DataProjection_AbsoluteToleranceGetNum(dataProjectionUserNumber, regionUserNumber):
    """Returns the absolute tolerance of data projection identified by a region user number.

    :param dataProjectionUserNumber: The data projection user number of the data projection to get starting xi for.
    :type dataProjectionUserNumber: int
    :param regionUserNumber: The region user number of the data projection to get tolerance for.
    :type regionUserNumber: int
    :returns: absoluteTolerance. On exit, the absolute tolerance of the specified data projection
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_AbsoluteToleranceGetNum, [dataProjectionUserNumber, regionUserNumber])


def DataProjection_AbsoluteToleranceSetNum(dataProjectionUserNumber, regionUserNumber, absoluteTolerance):
    """Sets/changes the absolute tolerance of data projection identified by a region user number.

    :param dataProjectionUserNumber: The data projection user number of the data projection to get starting xi for.
    :type dataProjectionUserNumber: int
    :param regionUserNumber: The region use number of data projection to set tolerance for.
    :type regionUserNumber: int
    :param absoluteTolerance: the absolute tolerance to set
    :type absoluteTolerance: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_AbsoluteToleranceSetNum, [dataProjectionUserNumber, regionUserNumber, absoluteTolerance])


def DataProjection_CreateFinishNum(dataProjectionUserNumber, regionUserNumber):
    """Finishes the creation of a new data projection identified by a region user number.

    :param dataProjectionUserNumber: The data projection user number of the data projection to get starting xi for.
    :type dataProjectionUserNumber: int
    :param regionUserNumber: The user number of the region containing the data points which associates to the data projection to finish the creation of.
    :type regionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_CreateFinishNum, [dataProjectionUserNumber, regionUserNumber])


def DataProjection_CreateStartNum(dataProjectionUserNumber, dataPointRegionUserNumber, meshUserNumber, meshRegionUserNumber):
    """Starts the creation of a new data projection for a data projection identified by a region user number.

    :param dataProjectionUserNumber: The data projection user number.
    :type dataProjectionUserNumber: int
    :param dataPointRegionUserNumber: The region user number of the data points to be projected.
    :type dataPointRegionUserNumber: int
    :param meshUserNumber: The field user number of the geometric field data points are be projected on.
    :type meshUserNumber: int
    :param meshRegionUserNumber: The region user number of the geometric field data points are be projected on.
    :type meshRegionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_CreateStartNum, [dataProjectionUserNumber, dataPointRegionUserNumber, meshUserNumber, meshRegionUserNumber])


def DataProjection_DataPointsPositionEvaluateInterfaceNum(dataProjectionUserNumber, parentRegionUserNumber, interfaceUserNumber, fieldUserNumber, fieldVariableType):
    """Evaluate the data points position in a field based on data projection in an interface, identified by user number

    :param dataProjectionUserNumber: The data projection user number of the data projection
    :type dataProjectionUserNumber: int
    :param parentRegionUserNumber: The parent region number of the interface for the data projection
    :type parentRegionUserNumber: int
    :param interfaceUserNumber: The interface number for the data projection
    :type interfaceUserNumber: int
    :param fieldUserNumber: The field user number of the field to be interpolated
    :type fieldUserNumber: int
    :param fieldVariableType: The field variable type to be interpolated
    :type fieldVariableType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_DataPointsPositionEvaluateInterfaceNum, [dataProjectionUserNumber, parentRegionUserNumber, interfaceUserNumber, fieldUserNumber, fieldVariableType])


def DataProjection_DataPointsPositionEvaluateRegionNum(dataProjectionUserNumber, regionUserNumber, fieldUserNumber, fieldVariableType):
    """Evaluate the data points position in a field based on data projection in a region, identified by user number

    :param dataProjectionUserNumber: The data projection user number of the data projection
    :type dataProjectionUserNumber: int
    :param regionUserNumber: The region user number of the data projection and field
    :type regionUserNumber: int
    :param fieldUserNumber: The field user number of the field to be interpolated
    :type fieldUserNumber: int
    :param fieldVariableType: The field variable type to be interpolated
    :type fieldVariableType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_DataPointsPositionEvaluateRegionNum, [dataProjectionUserNumber, regionUserNumber, fieldUserNumber, fieldVariableType])


def DataProjection_DataPointsProjectionEvaluateNum(dataProjectionUserNumber, dataPointsRegionUserNumber, projectionFieldUserNumber, projectionFieldRegionUserNumber):
    """Evaluate a data projection identified by a region user number.

    :param dataProjectionUserNumber: The data projection user number of the data projection to get starting xi for.
    :type dataProjectionUserNumber: int
    :param dataPointsRegionUserNumber: The region user number of the data projection to evaluate.
    :type dataPointsRegionUserNumber: int
    :param projectionFieldUserNumber: The field user number of the field data points are be projected on.
    :type projectionFieldUserNumber: int
    :param projectionFieldRegionUserNumber: The region user number of the field data points are be projected on.
    :type projectionFieldRegionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_DataPointsProjectionEvaluateNum, [dataProjectionUserNumber, dataPointsRegionUserNumber, projectionFieldUserNumber, projectionFieldRegionUserNumber])


def DataProjection_DestroyNum(dataProjectionUserNumber, regionUserNumber):
    """Destroys a data projection identified by region user number.

    :param dataProjectionUserNumber: The data projection user number of the data projection to get starting xi for.
    :type dataProjectionUserNumber: int
    :param regionUserNumber: The region user number of the data projection to destroy.
    :type regionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_DestroyNum, [dataProjectionUserNumber, regionUserNumber])


def DataProjection_ElementSetInterfaceNum(dataProjectionUserNumber, parentRegionUserNumber, interfaceUserNumber, dataPointNumber, elementNumber):
    """Sets/changes the starting xi of data projection identified by a region user number.

    :param dataProjectionUserNumber: The data projection user number of the data projection to get starting xi for.
    :type dataProjectionUserNumber: int
    :param parentRegionUserNumber: The user number of the parent region.
    :type parentRegionUserNumber: int
    :param interfaceUserNumber: The user number of the interface.
    :type interfaceUserNumber: int
    :param dataPointNumber: The data point number to set xi position for
    :type dataPointNumber: int
    :param elementNumber: the element number to set
    :type elementNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_ElementSetInterfaceNum, [dataProjectionUserNumber, parentRegionUserNumber, interfaceUserNumber, dataPointNumber, elementNumber])


def DataProjection_ElementSetRegionNum(dataProjectionUserNumber, regionUserNumber, dataPointNumber, elementNumber):
    """Sets/changes the starting xi of data projection identified by a region user number.

    :param dataProjectionUserNumber: The data projection user number of the data projection to get starting xi for.
    :type dataProjectionUserNumber: int
    :param regionUserNumber: The region user number of data projection to set starting xi for.
    :type regionUserNumber: int
    :param dataPointNumber: The data point number to set xi position for
    :type dataPointNumber: int
    :param elementNumber: the element number to set
    :type elementNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_ElementSetRegionNum, [dataProjectionUserNumber, regionUserNumber, dataPointNumber, elementNumber])


def DataProjection_LabelGetCInterfaceNum(dataProjectionUserNumber, parentRegionUserNumber, interfaceUserNumber):
    """Get the character string label of a data projection identified by a region user number.

    :param dataProjectionUserNumber: The data projection user number of the data projection to get the label for.
    :type dataProjectionUserNumber: int
    :param parentRegionUserNumber: The user number of the parent region.
    :type parentRegionUserNumber: int
    :param interfaceUserNumber: The user number of the interface.
    :type interfaceUserNumber: int
    :returns: label. the label to get
    :rtype: string
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_LabelGetCInterfaceNum, [dataProjectionUserNumber, parentRegionUserNumber, interfaceUserNumber])


def DataProjection_LabelGetCRegionNum(dataProjectionUserNumber, regionUserNumber):
    """Get the character string label of a data projection identified by a region user number.

    :param dataProjectionUserNumber: The data projection user number of the data projection to get the label for.
    :type dataProjectionUserNumber: int
    :param regionUserNumber: The region user number of data projection to get the label for.
    :type regionUserNumber: int
    :returns: label. the label to get
    :rtype: string
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_LabelGetCRegionNum, [dataProjectionUserNumber, regionUserNumber])


def DataProjection_LabelSetCInterfaceNum(dataProjectionUserNumber, parentRegionUserNumber, interfaceUserNumber, label):
    """Sets/changes the character string label of a data projection identified by a region user number.

    :param dataProjectionUserNumber: The data projection user number of the data projection to set the label for.
    :type dataProjectionUserNumber: int
    :param parentRegionUserNumber: The user number of the parent region.
    :type parentRegionUserNumber: int
    :param interfaceUserNumber: The user number of the interface.
    :type interfaceUserNumber: int
    :param label: the label to set
    :type label: string
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_LabelSetCInterfaceNum, [dataProjectionUserNumber, parentRegionUserNumber, interfaceUserNumber, label])


def DataProjection_LabelSetCRegionNum(dataProjectionUserNumber, regionUserNumber, label):
    """Sets/changes the character string label of a data projection identified by a region user number.

    :param dataProjectionUserNumber: The data projection user number of the data projection to set the label for.
    :type dataProjectionUserNumber: int
    :param regionUserNumber: The region user number of data projection to set the label for.
    :type regionUserNumber: int
    :param label: the label to set
    :type label: string
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_LabelSetCRegionNum, [dataProjectionUserNumber, regionUserNumber, label])


def DataProjection_MaximumIterationUpdateGetNum(dataProjectionUserNumber, regionUserNumber):
    """Returns the relative tolerance of data projection identified by a region user number.

    :param dataProjectionUserNumber: The data projection user number of the data projection to get starting xi for.
    :type dataProjectionUserNumber: int
    :param regionUserNumber: The region user number of the data projection to get tolerance for.
    :type regionUserNumber: int
    :returns: maximumIterationUpdate. On exit, the maximum iteration update of the specified data projection
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_MaximumIterationUpdateGetNum, [dataProjectionUserNumber, regionUserNumber])


def DataProjection_MaximumIterationUpdateSetNum(dataProjectionUserNumber, regionUserNumber, maximumIterationUpdate):
    """Sets/changes the relative tolerance of data projection identified by a region user number.

    :param dataProjectionUserNumber: The data projection user number of the data projection to get starting xi for.
    :type dataProjectionUserNumber: int
    :param regionUserNumber: The region use number of data projection to set tolerance for.
    :type regionUserNumber: int
    :param maximumIterationUpdate: the maximum iteration update to set
    :type maximumIterationUpdate: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_MaximumIterationUpdateSetNum, [dataProjectionUserNumber, regionUserNumber, maximumIterationUpdate])


def DataProjection_MaximumNumberOfIterationsGetNum(dataProjectionUserNumber, regionUserNumber):
    """Returns the maximum number of iterations of data projection identified by a region user number.

    :param dataProjectionUserNumber: The data projection user number of the data projection to get starting xi for.
    :type dataProjectionUserNumber: int
    :param regionUserNumber: The region user number of the data projection to get maximum number of iterations for.
    :type regionUserNumber: int
    :returns: maximumNumberOfIterations. On exit, the maximum number of iterations of the specified data projection
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_MaximumNumberOfIterationsGetNum, [dataProjectionUserNumber, regionUserNumber])


def DataProjection_MaximumNumberOfIterationsSetNum(dataProjectionUserNumber, regionUserNumber, maximumNumberOfIterations):
    """Sets/changes the maximum number of iterations of data projection identified by a region user number.

    :param dataProjectionUserNumber: The data projection user number of the data projection to get starting xi for.
    :type dataProjectionUserNumber: int
    :param regionUserNumber: The region use number of data projection to set maximum number of iterations for.
    :type regionUserNumber: int
    :param maximumNumberOfIterations: the maximum number of iterations to set
    :type maximumNumberOfIterations: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_MaximumNumberOfIterationsSetNum, [dataProjectionUserNumber, regionUserNumber, maximumNumberOfIterations])


def DataProjection_NumberOfClosestElementsGetNum(dataProjectionUserNumber, regionUserNumber):
    """Returns the number of closest elements of data projection identified by a region user number.

    :param dataProjectionUserNumber: The data projection user number of the data projection to get starting xi for.
    :type dataProjectionUserNumber: int
    :param regionUserNumber: The region user number of the data projection to get number of closest elements for.
    :type regionUserNumber: int
    :returns: numberOfClosestElements. On exit, the number of closest elements of the specified data projection
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_NumberOfClosestElementsGetNum, [dataProjectionUserNumber, regionUserNumber])


def DataProjection_NumberOfClosestElementsSetNum(dataProjectionUserNumber, regionUserNumber, numberOfClosestElements):
    """Sets/changes the number of closest elements of data projection identified by a region user number.

    :param dataProjectionUserNumber: The data projection user number of the data projection to get starting xi for.
    :type dataProjectionUserNumber: int
    :param regionUserNumber: The region use number of data projection to set number of closest elements for.
    :type regionUserNumber: int
    :param numberOfClosestElements: the number of closest elements to set
    :type numberOfClosestElements: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_NumberOfClosestElementsSetNum, [dataProjectionUserNumber, regionUserNumber, numberOfClosestElements])


def DataProjection_ProjectionCandidatesSetInterfaceNum(dataProjectionUserNumber, parentRegionUserNumber, interfaceUserNumber, candidateElements, localFaceLineNumbers):
    """Evaluate the data points position in a field based on data projection in an interface, identified by user number

    :param dataProjectionUserNumber: The data projection user number of the data projection
    :type dataProjectionUserNumber: int
    :param parentRegionUserNumber: The parent region number of the interface for the data projection
    :type parentRegionUserNumber: int
    :param interfaceUserNumber: The interface number for the data projection
    :type interfaceUserNumber: int
    :param candidateElements: The candidate element for the projection
    :type candidateElements: Array of ints
    :param localFaceLineNumbers: The local face/line number for the candidate elements
    :type localFaceLineNumbers: Array of ints
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_ProjectionCandidatesSetInterfaceNum, [dataProjectionUserNumber, parentRegionUserNumber, interfaceUserNumber, candidateElements, localFaceLineNumbers])


def DataProjection_ProjectionCandidatesSetRegionNum(dataProjectionUserNumber, regionUserNumber, candidateElements, localFaceLineNumbers):
    """Evaluate the data points position in a field based on data projection in a region, identified by user number

    :param dataProjectionUserNumber: The data projection user number of the data projection
    :type dataProjectionUserNumber: int
    :param regionUserNumber: The region user number of the data projection and field
    :type regionUserNumber: int
    :param candidateElements: The candidate element for the projection
    :type candidateElements: Array of ints
    :param localFaceLineNumbers: The local face/line number for the candidate elements
    :type localFaceLineNumbers: Array of ints
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_ProjectionCandidatesSetRegionNum, [dataProjectionUserNumber, regionUserNumber, candidateElements, localFaceLineNumbers])


def DataProjection_ProjectionTypeGetNum(dataProjectionUserNumber, regionUserNumber):
    """Returns the projection type of data projection identified by a region user number.

    :param dataProjectionUserNumber: The data projection user number of the data projection to get starting xi for.
    :type dataProjectionUserNumber: int
    :param regionUserNumber: The region user number of the data projection to get projection type for.
    :type regionUserNumber: int
    :returns: projectionType. On exit, the projection type of the specified data projection
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_ProjectionTypeGetNum, [dataProjectionUserNumber, regionUserNumber])


def DataProjection_ProjectionTypeSetNum(dataProjectionUserNumber, regionUserNumber, projectionType):
    """Sets/changes the projection type of data projection identified by a region user number.

    :param dataProjectionUserNumber: The data projection user number of the data projection to get starting xi for.
    :type dataProjectionUserNumber: int
    :param regionUserNumber: The region use number of data projection to set projection type for.
    :type regionUserNumber: int
    :param projectionType: the projection type to set
    :type projectionType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_ProjectionTypeSetNum, [dataProjectionUserNumber, regionUserNumber, projectionType])


def DataProjection_RelativeToleranceGetNum(dataProjectionUserNumber, regionUserNumber):
    """Returns the relative tolerance of data projection identified by a data projection user number and a region user number.

    :param dataProjectionUserNumber: The data projection user number of the data projection to get starting xi for.
    :type dataProjectionUserNumber: int
    :param regionUserNumber: The region user number of the data projection to get relative tolerance for.
    :type regionUserNumber: int
    :returns: relativeTolerance. On exit, the absolute relative tolerance of the specified data projection
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_RelativeToleranceGetNum, [dataProjectionUserNumber, regionUserNumber])


def DataProjection_RelativeToleranceSetNum(dataProjectionUserNumber, regionUserNumber, relativeTolerance):
    """Sets/changes the relative tolerance of data projection identified by a data projection user number and a region user number.

    :param dataProjectionUserNumber: The data projection user number of the data projection to get starting xi for.
    :type dataProjectionUserNumber: int
    :param regionUserNumber: The region use number of data projection to set relative tolerance for.
    :type regionUserNumber: int
    :param relativeTolerance: the absolute relative tolerance to set
    :type relativeTolerance: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_RelativeToleranceSetNum, [dataProjectionUserNumber, regionUserNumber, relativeTolerance])


def DataProjection_ResultDistanceGetNum(regionUserNumber, dataProjectionUserNumber, dataPointUserNumber):
    """Returns the projection distance for a data point in a set of data points identified by user number.

    :param regionUserNumber: The user number of the region containing the data points to get attributes for.
    :type regionUserNumber: int
    :param dataProjectionUserNumber: The user number of the data projection containing the data points to get attributes for.
    :type dataProjectionUserNumber: int
    :param dataPointUserNumber: The user number of the data points to get attributes for.
    :type dataPointUserNumber: int
    :returns: ProjectionDistance. The projection distance for the data point.
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_ResultDistanceGetNum, [regionUserNumber, dataProjectionUserNumber, dataPointUserNumber])


def DataProjection_ResultElementFaceNumberGetNum(regionUserNumber, dataProjectionUserNumber, dataPointUserNumber):
    """Returns the projection element face number for a data point in a set of data points identified by user number.

    :param regionUserNumber: The user number of the region containing the data points to get attributes for.
    :type regionUserNumber: int
    :param dataProjectionUserNumber: The user number of the data projection containing the data points to get attributes for.
    :type dataProjectionUserNumber: int
    :param dataPointUserNumber: The user number of the data points to get attributes for.
    :type dataPointUserNumber: int
    :returns: ProjectionElementFaceNumber. The projection element face number for the data point.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_ResultElementFaceNumberGetNum, [regionUserNumber, dataProjectionUserNumber, dataPointUserNumber])


def DataProjection_ResultElementLineNumberGetNum(regionUserNumber, dataProjectionUserNumber, dataPointUserNumber):
    """Returns the projection element line number for a data point in a set of data points identified by user number.

    :param regionUserNumber: The user number of the region containing the data points to get attributes for.
    :type regionUserNumber: int
    :param dataProjectionUserNumber: The user number of the data projection containing the data points to get attributes for.
    :type dataProjectionUserNumber: int
    :param dataPointUserNumber: The user number of the data points to get attributes for.
    :type dataPointUserNumber: int
    :returns: ProjectionElementLineNumber. The projection element line number for the data point.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_ResultElementLineNumberGetNum, [regionUserNumber, dataProjectionUserNumber, dataPointUserNumber])


def DataProjection_ResultElementNumberGetNum(regionUserNumber, dataProjectionUserNumber, dataPointUserNumber):
    """Returns the projection element number for a data point in a set of data points identified by user number.

    :param regionUserNumber: The user number of the region containing the data points to get attributes for.
    :type regionUserNumber: int
    :param dataProjectionUserNumber: The user number of the data projection containing the data points to get attributes for.
    :type dataProjectionUserNumber: int
    :param dataPointUserNumber: The user number of the data points to get attributes for.
    :type dataPointUserNumber: int
    :returns: ProjectionElementNumber. The projection element number for the data point.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_ResultElementNumberGetNum, [regionUserNumber, dataProjectionUserNumber, dataPointUserNumber])


def DataProjection_ResultExitTagGetNum(regionUserNumber, dataProjectionUserNumber, dataPointUserNumber):
    """Returns the projection exit tag for a data point in a set of data points identified by user number.

    :param regionUserNumber: The user number of the region containing the data points to get attributes for.
    :type regionUserNumber: int
    :param dataProjectionUserNumber: The user number of the data projection containing the data points to get attributes for.
    :type dataProjectionUserNumber: int
    :param dataPointUserNumber: The user number of the data points to get attributes for.
    :type dataPointUserNumber: int
    :returns: ProjectionExitTag. The projection exit tag for the data point.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_ResultExitTagGetNum, [regionUserNumber, dataProjectionUserNumber, dataPointUserNumber])


def DataProjection_ResultProjectionVectorGetNum(regionUserNumber, dataProjectionUserNumber, dataPointUserNumber, projectionVectorSize):
    """Returns the projection vector for a data point in a set of data points identified by user number.

    :param regionUserNumber: The user number of the region containing the data points to get attributes for.
    :type regionUserNumber: int
    :param dataProjectionUserNumber: The user number of the data projection containing the data points to get attributes for.
    :type dataProjectionUserNumber: int
    :param dataPointUserNumber: The user number of the data points to get attributes for.
    :type dataPointUserNumber: int
    :param projectionVectorSize: Size of projectionVector to allocate.
    :returns: projectionVector. The projection vector for the data point.
    :rtype: Array of floats
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_ResultProjectionVectorGetNum, [regionUserNumber, dataProjectionUserNumber, dataPointUserNumber, projectionVectorSize])


def DataProjection_ResultXiGetNum(regionUserNumber, dataProjectionUserNumber, dataPointUserNumber, ProjectionXiSize):
    """Returns the projection xi for a data point in a set of data points identified by user number.

    :param regionUserNumber: The user number of the region containing the data points to get attributes for.
    :type regionUserNumber: int
    :param dataProjectionUserNumber: The user number of the data projection containing the data points to get attributes for.
    :type dataProjectionUserNumber: int
    :param dataPointUserNumber: The user number of the data points to get attributes for.
    :type dataPointUserNumber: int
    :param ProjectionXiSize: Size of ProjectionXi to allocate.
    :returns: ProjectionXi. The projection xi for the data point.
    :rtype: Array of floats
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_ResultXiGetNum, [regionUserNumber, dataProjectionUserNumber, dataPointUserNumber, ProjectionXiSize])


def DataProjection_ResultXiSetNum(regionUserNumber, dataProjectionUserNumber, dataPointUserNumber, ProjectionXi):
    """Sets the projection xi for a data point in a set of data points identified by user number.

    :param regionUserNumber: The user number of the region containing the data points to set attributes for.
    :type regionUserNumber: int
    :param dataProjectionUserNumber: The user number of the data projection containing the data points to set attributes for.
    :type dataProjectionUserNumber: int
    :param dataPointUserNumber: The user number of the data points to set attributes for.
    :type dataPointUserNumber: int
    :param ProjectionXi: On return, the projection xi for the data point.
    :type ProjectionXi: Array of floats
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_ResultXiSetNum, [regionUserNumber, dataProjectionUserNumber, dataPointUserNumber, ProjectionXi])


def DataProjection_StartingXiGetNum(dataProjectionUserNumber, regionUserNumber, startingXiSize):
    """Returns the starting xi of data projection identified by a data projection user number and region user number.

    :param dataProjectionUserNumber: The data projection user number of the data projection to get starting xi for.
    :type dataProjectionUserNumber: int
    :param regionUserNumber: The region user number of the data projection to get starting xi for.
    :type regionUserNumber: int
    :param startingXiSize: Size of startingXi to allocate.
    :returns: startingXi. On exit, the absolute starting xi of the specified data projection
    :rtype: Array of floats
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_StartingXiGetNum, [dataProjectionUserNumber, regionUserNumber, startingXiSize])


def DataProjection_StartingXiSetNum(dataProjectionUserNumber, regionUserNumber, startingXi):
    """Sets/changes the starting xi of data projection identified by a region user number.

    :param dataProjectionUserNumber: The data projection user number of the data projection to get starting xi for.
    :type dataProjectionUserNumber: int
    :param regionUserNumber: The region use number of data projection to set starting xi for.
    :type regionUserNumber: int
    :param startingXi: the absolute starting xi to set
    :type startingXi: Array of floats
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DataProjection_StartingXiSetNum, [dataProjectionUserNumber, regionUserNumber, startingXi])


def Decomposition_CalculateFacesSetNum(regionUserNumber, meshUserNumber, decompositionUserNumber, calculateFacesFlag):
    """Sets whether faces should be calculated

    :param regionUserNumber: The user number of the region.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh.
    :type meshUserNumber: int
    :param decompositionUserNumber: The user number of the decomposition to set the decomposition type for.
    :type decompositionUserNumber: int
    :param calculateFacesFlag: Boolean to determine whether to set faces to be calculated.
    :type calculateFacesFlag: bool
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Decomposition_CalculateFacesSetNum, [regionUserNumber, meshUserNumber, decompositionUserNumber, calculateFacesFlag])


def Decomposition_CalculateLinesSetNum(regionUserNumber, meshUserNumber, decompositionUserNumber, calculateLinesFlag):
    """Sets whether lines should be calculated

    :param regionUserNumber: The user number of the region.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh.
    :type meshUserNumber: int
    :param decompositionUserNumber: The user number of the decomposition to set the calculate lines flag for.
    :type decompositionUserNumber: int
    :param calculateLinesFlag: Boolean to determine whether to set lines to be calculated.
    :type calculateLinesFlag: bool
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Decomposition_CalculateLinesSetNum, [regionUserNumber, meshUserNumber, decompositionUserNumber, calculateLinesFlag])


def Decomposition_CreateFinishNum(regionUserNumber, meshUserNumber, decompositionUserNumber):
    """Finishes the creation of a domain decomposition for a decomposition identified by a user number.

    :param regionUserNumber: The user number of the region containing the mesh to finish the decomposition for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to finish the decomposition for.
    :type meshUserNumber: int
    :param decompositionUserNumber: The user number of the decomposition to finish.
    :type decompositionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Decomposition_CreateFinishNum, [regionUserNumber, meshUserNumber, decompositionUserNumber])


def Decomposition_CreateStartNum(decompositionUserNumber, regionUserNumber, meshUserNumber):
    """Starts the creation of a domain decomposition for a decomposition identified by a user number.

    :param decompositionUserNumber: The user number of the decomposition to create.
    :type decompositionUserNumber: int
    :param regionUserNumber: The user number of the region containing the mesh to create the decomposition for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to create the decomposition for.
    :type meshUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Decomposition_CreateStartNum, [decompositionUserNumber, regionUserNumber, meshUserNumber])


def Decomposition_DestroyNum(regionUserNumber, meshUserNumber, decompositionUserNumber):
    """Destroys a decomposition identified by a user number.

    :param regionUserNumber: The user number of the region containing the mesh to destroy the decomposition for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to destroy the decomposition for.
    :type meshUserNumber: int
    :param decompositionUserNumber: The user number of the decomposition to destroy.
    :type decompositionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Decomposition_DestroyNum, [regionUserNumber, meshUserNumber, decompositionUserNumber])


def Decomposition_ElementDomainCalculateNum(regionUserNumber, meshUserNumber, decompositionUserNumber):
    """Calculates the element domains for a decomposition identified by a user number.

    :param regionUserNumber: The user number of the region containing the mesh to calculate the element domains for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to calculate the element domains for.
    :type meshUserNumber: int
    :param decompositionUserNumber: The user number of the decomposition to calculate the element domains for.
    :type decompositionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Decomposition_ElementDomainCalculateNum, [regionUserNumber, meshUserNumber, decompositionUserNumber])


def Decomposition_ElementDomainGetNum(regionUserNumber, meshUserNumber, decompositionUserNumber, elementUserNumber):
    """Returns the domain for a given element in a decomposition identified by a user number.

    :param regionUserNumber: The user number of the region containing the mesh to get the element domain for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to get the element domain for.
    :type meshUserNumber: int
    :param decompositionUserNumber: The user number of the decomposition to get the element domain for.
    :type decompositionUserNumber: int
    :param elementUserNumber: The user number of the element to get the domain for.
    :type elementUserNumber: int
    :returns: domain. The computational domain of the element.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Decomposition_ElementDomainGetNum, [regionUserNumber, meshUserNumber, decompositionUserNumber, elementUserNumber])


def Decomposition_ElementDomainSetNum(regionUserNumber, meshUserNumber, decompositionUserNumber, elementUserNumber, domain):
    """Sets/changes the domain for a given element in a decomposition identified by a user number.

    :param regionUserNumber: The user number of the region containing the mesh to set the element domain for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to set the element domain for.
    :type meshUserNumber: int
    :param decompositionUserNumber: The user number of the decomposition to set the element domain for.
    :type decompositionUserNumber: int
    :param elementUserNumber: The user number of the element to set the domain for.
    :type elementUserNumber: int
    :param domain: The computational domain of the element to set.
    :type domain: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Decomposition_ElementDomainSetNum, [regionUserNumber, meshUserNumber, decompositionUserNumber, elementUserNumber, domain])


def Decomposition_MeshComponentGetNum(regionUserNumber, meshUserNumber, decompositionUserNumber):
    """Returns the mesh component number used for the decomposition of a mesh for a decomposition identified by a user number.

    :param regionUserNumber: The user number of the region containing the mesh to get the decomposition mesh component for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to get the decomposition mesh component for.
    :type meshUserNumber: int
    :param decompositionUserNumber: The user number of the decomposition to get the mesh component for.
    :type decompositionUserNumber: int
    :returns: meshComponentNumber. The mesh component number for the decomposition.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Decomposition_MeshComponentGetNum, [regionUserNumber, meshUserNumber, decompositionUserNumber])


def Decomposition_MeshComponentSetNum(regionUserNumber, meshUserNumber, decompositionUserNumber, meshComponentNumber):
    """Sets/changes the mesh component number used for the decomposition of a mesh for a decomposition identified by a user number.

    :param regionUserNumber: The user number of the region containing the mesh to set the decomposition mesh component for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to set the decomposition mesh component for.
    :type meshUserNumber: int
    :param decompositionUserNumber: The user number of the decomposition to set the mesh component for.
    :type decompositionUserNumber: int
    :param meshComponentNumber: The mesh component number for the decomposition to set.
    :type meshComponentNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Decomposition_MeshComponentSetNum, [regionUserNumber, meshUserNumber, decompositionUserNumber, meshComponentNumber])


def Decomposition_NodeDomainGetNum(regionUserNumber, meshUserNumber, decompositionUserNumber, nodeUserNumber, meshComponentNumber):
    """Returns the domain for a given node in a decomposition identified by a user number.

    :param regionUserNumber: The user number of the region containing the mesh to get the node domain for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to get the node domain for.
    :type meshUserNumber: int
    :param decompositionUserNumber: The user number of the decomposition to get the node domain for.
    :type decompositionUserNumber: int
    :param nodeUserNumber: The user number of the node to get the domain for.
    :type nodeUserNumber: int
    :param meshComponentNumber: The user number of the mesh component to get the domain for.
    :type meshComponentNumber: int
    :returns: domain. The computational domain of the node.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Decomposition_NodeDomainGetNum, [regionUserNumber, meshUserNumber, decompositionUserNumber, nodeUserNumber, meshComponentNumber])


def Decomposition_NumberOfDomainsGetNum(regionUserNumber, meshUserNumber, decompositionUserNumber):
    """Returns the number of domains for a decomposition identified by a user number.

    :param regionUserNumber: The user number of the region containing the mesh to get the number of domains for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to get the number of domains for.
    :type meshUserNumber: int
    :param decompositionUserNumber: The user number of the decomposition to get the number of domains for.
    :type decompositionUserNumber: int
    :returns: numberOfDomains. The number of domains in the decomposition.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Decomposition_NumberOfDomainsGetNum, [regionUserNumber, meshUserNumber, decompositionUserNumber])


def Decomposition_NumberOfDomainsSetNum(regionUserNumber, meshUserNumber, decompositionUserNumber, numberOfDomains):
    """Sets/changes the number of domains for a decomposition identified by a user number.

    :param regionUserNumber: The user number of the region containing the mesh to set the number of domains for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to set the number of domains for.
    :type meshUserNumber: int
    :param decompositionUserNumber: The user number of the decomposition to set the number of domains for.
    :type decompositionUserNumber: int
    :param numberOfDomains: The number of domains in the decomposition to set.
    :type numberOfDomains: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Decomposition_NumberOfDomainsSetNum, [regionUserNumber, meshUserNumber, decompositionUserNumber, numberOfDomains])


def Decomposition_TypeGetNum(regionUserNumber, meshUserNumber, decompositionUserNumber):
    """Returns the type of a decomposition identified by a user number.

    :param regionUserNumber: The user number of the region containing the mesh to get the decomposition type for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to get the decomposition type for.
    :type meshUserNumber: int
    :param decompositionUserNumber: The user number of the decomposition to get the decomposition type for.
    :type decompositionUserNumber: int
    :returns: decompositionType. The type of the decomposition.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Decomposition_TypeGetNum, [regionUserNumber, meshUserNumber, decompositionUserNumber])


def Decomposition_TypeSetNum(regionUserNumber, meshUserNumber, decompositionUserNumber, decompositionType):
    """Sets/changes the type of a decomposition identified by a user number.

    :param regionUserNumber: The user number of the region containing the mesh to set the decomposition type for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to set the decomposition type for.
    :type meshUserNumber: int
    :param decompositionUserNumber: The user number of the decomposition to set the decomposition type for.
    :type decompositionUserNumber: int
    :param decompositionType: The type of the decomposition to set.
    :type decompositionType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Decomposition_TypeSetNum, [regionUserNumber, meshUserNumber, decompositionUserNumber, decompositionType])


def DiagnosticsSetOff():
    """Sets diagnostics off

    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DiagnosticsSetOff, [])


def DiagnosticsSetOn(diagType, levelList, diagFilename, routineList):
    """Sets diagnostics on

    :param diagType: The type of diagnostics to set on. Must be a value from the DiagnosticTypes enum.
    :type diagType: int
    :param levelList: The list of diagnostic levels to set on.
    :type levelList: Array of ints
    :param diagFilename: If present the name of the file to output diagnostic information to. If omitted the diagnostic output is sent to the screen.
    :type diagFilename: string
    :param routineList: The list of routines to set diagnostics on in.
    :type routineList: Array of strings
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_DiagnosticsSetOn, [diagType, levelList, diagFilename, routineList])


def EquationsSet_AnalyticCreateFinishNum(regionUserNumber, equationsSetUserNumber):
    """Finish the creation of a analytic solution for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to finish.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to finish the creation of.
    :type equationsSetUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_AnalyticCreateFinishNum, [regionUserNumber, equationsSetUserNumber])


def EquationsSet_AnalyticCreateStartNum(regionUserNumber, equationsSetUserNumber, analyticFunctionType, analyticFieldUserNumber):
    """Start the creation of a analytic solution for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to finish.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to finish the creation of.
    :type equationsSetUserNumber: int
    :param analyticFunctionType: The analytic function type to use. Must be a value from the EquationsSetAnalyticFunctionTypes enum.
    :type analyticFunctionType: int
    :param analyticFieldUserNumber: The user number of the field for the analytic function
    :type analyticFieldUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_AnalyticCreateStartNum, [regionUserNumber, equationsSetUserNumber, analyticFunctionType, analyticFieldUserNumber])


def EquationsSet_AnalyticDestroyNum(regionUserNumber, equationsSetUserNumber):
    """Destroy the analytic solution for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to destroy.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to destroy.
    :type equationsSetUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_AnalyticDestroyNum, [regionUserNumber, equationsSetUserNumber])


def EquationsSet_AnalyticEvaluateNum(regionUserNumber, equationsSetUserNumber):
    """Evaluates the current analytic solution for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to evaluate.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to evaluate.
    :type equationsSetUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_AnalyticEvaluateNum, [regionUserNumber, equationsSetUserNumber])


def EquationsSet_AnalyticTimeGetNum(regionUserNumber, equationsSetUserNumber):
    """Returns the analytic time for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set get the analytic time for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to get the analytic time get.
    :type equationsSetUserNumber: int
    :returns: time. The analytic time for the equations set.
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_AnalyticTimeGetNum, [regionUserNumber, equationsSetUserNumber])


def EquationsSet_AnalyticTimeSetNum(regionUserNumber, equationsSetUserNumber, time):
    """Sets/changes the analytic time for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set get the analytic time for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to get the analytic time get.
    :type equationsSetUserNumber: int
    :param time: The analytic time to set.
    :type time: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_AnalyticTimeSetNum, [regionUserNumber, equationsSetUserNumber, time])


def EquationsSet_AnalyticUserParamGetNum(regionUserNumber, equationsSetUserNumber, paramIdx):
    """Sets the analytic problem user parameter

    :param regionUserNumber: The user number of the Region containing the equations set
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set
    :type equationsSetUserNumber: int
    :param paramIdx: The index of the analytic user parameter to set
    :type paramIdx: int
    :returns: param. Value of the parameter to set
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_AnalyticUserParamGetNum, [regionUserNumber, equationsSetUserNumber, paramIdx])


def EquationsSet_AnalyticUserParamSetNum(regionUserNumber, equationsSetUserNumber, paramIdx, param):
    """Sets the analytic problem user parameter

    :param regionUserNumber: The user number of the Region containing the equations set
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set
    :type equationsSetUserNumber: int
    :param paramIdx: The index of the analytic user parameter to set
    :type paramIdx: int
    :param param: Value of the parameter to set
    :type param: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_AnalyticUserParamSetNum, [regionUserNumber, equationsSetUserNumber, paramIdx, param])


def EquationsSet_CreateFinishNum(regionUserNumber, equationsSetUserNumber):
    """Finish the creation of an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to finish.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to finish the creation of.
    :type equationsSetUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_CreateFinishNum, [regionUserNumber, equationsSetUserNumber])


def EquationsSet_CreateStartNum(equationsSetUserNumber, regionUserNumber, geomFibreFieldUserNumber, equationsSetSpecification, equationsSetFieldUserNumber):
    """Start the creation of an equations set identified by a user number.

    :param equationsSetUserNumber: The user number of the equations set to be created.
    :type equationsSetUserNumber: int
    :param regionUserNumber: The user number of the region to start the creation of an equations set on.
    :type regionUserNumber: int
    :param geomFibreFieldUserNumber: The user number of the Geometric/Fibre field for the equations set.
    :type geomFibreFieldUserNumber: int
    :param equationsSetSpecification: The equations set specification array, containing the equations class, type etc
    :type equationsSetSpecification: Array of ints
    :param equationsSetFieldUserNumber: The user number of the equations set field
    :type equationsSetFieldUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_CreateStartNum, [equationsSetUserNumber, regionUserNumber, geomFibreFieldUserNumber, equationsSetSpecification, equationsSetFieldUserNumber])


def EquationsSet_DependentCreateFinishNum(regionUserNumber, equationsSetUserNumber):
    """Finish the creation of dependent variables for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to finish the creation of dependent variables for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to finish the creation of dependent variables for.
    :type equationsSetUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_DependentCreateFinishNum, [regionUserNumber, equationsSetUserNumber])


def EquationsSet_DependentCreateStartNum(regionUserNumber, equationsSetUserNumber, dependentFieldUserNumber):
    """Start the creation of dependent variables for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to start the creation of dependent variables for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to start the creation of dependent variables for.
    :type equationsSetUserNumber: int
    :param dependentFieldUserNumber: The user number of the dependent field.
    :type dependentFieldUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_DependentCreateStartNum, [regionUserNumber, equationsSetUserNumber, dependentFieldUserNumber])


def EquationsSet_DependentDestroyNum(regionUserNumber, equationsSetUserNumber):
    """Destroy the dependent variables for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to destroy the dependent variables for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to destroy the dependent variables for.
    :type equationsSetUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_DependentDestroyNum, [regionUserNumber, equationsSetUserNumber])


def EquationsSet_DerivedCreateFinishNum(regionUserNumber, equationsSetUserNumber):
    """Finish the creation of derived variables for an equations set identified by a user number.

    :param regionUserNumber: The user number of the region containing the equations set to finish the creation of derived variables for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to finish the creation of derived variables for.
    :type equationsSetUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_DerivedCreateFinishNum, [regionUserNumber, equationsSetUserNumber])


def EquationsSet_DerivedCreateStartNum(regionUserNumber, equationsSetUserNumber, derivedFieldUserNumber):
    """Start the creation of derived variables for an equations set identified by a user number.

    :param regionUserNumber: The user number of the region containing the equations set to start the creation of derived variables for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to start the creation of derived variables for.
    :type equationsSetUserNumber: int
    :param derivedFieldUserNumber: The user number of the derived field.
    :type derivedFieldUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_DerivedCreateStartNum, [regionUserNumber, equationsSetUserNumber, derivedFieldUserNumber])


def EquationsSet_DerivedDestroyNum(regionUserNumber, equationsSetUserNumber):
    """Destroy the derived variables for an equations set identified by a user number.

    :param regionUserNumber: The user number of the region containing the equations set to destroy the derived variables for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to destroy the derived variables for.
    :type equationsSetUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_DerivedDestroyNum, [regionUserNumber, equationsSetUserNumber])


def EquationsSet_DerivedVariableCalculateNum(regionUserNumber, equationsSetUserNumber, derivedType):
    """Calculates a derived field value for the equations set and stores the result in the derived field previously set up

    :param regionUserNumber: The user number of the region containing the equations set.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to calculate the output for.
    :type equationsSetUserNumber: int
    :param derivedType: The derived variable type to calculate. Must be a value from the EquationsSetDerivedTypes enum.
    :type derivedType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_DerivedVariableCalculateNum, [regionUserNumber, equationsSetUserNumber, derivedType])


def EquationsSet_DerivedVariableSetNum(regionUserNumber, equationsSetUserNumber, derivedType, fieldVariableType):
    """Sets the field variable type of the derived field to be used to store a derived variable

    :param regionUserNumber: The user number of the region containing the equations set.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to calculate the output for.
    :type equationsSetUserNumber: int
    :param derivedType: The derived variable type to calculate. Must be a value from the EquationsSetDerivedTypes enum.
    :type derivedType: int
    :param fieldVariableType: The field variable type to store the calculated values in.
    :type fieldVariableType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_DerivedVariableSetNum, [regionUserNumber, equationsSetUserNumber, derivedType, fieldVariableType])


def EquationsSet_DestroyNum(regionUserNumber, equationsSetUserNumber):
    """Destroy an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to destory.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to destroy.
    :type equationsSetUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_DestroyNum, [regionUserNumber, equationsSetUserNumber])


def EquationsSet_EquationsCreateFinishNum(regionUserNumber, equationsSetUserNumber):
    """Finish the creation of equations for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to finish the creation of equations for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to finish the creation of equations for.
    :type equationsSetUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_EquationsCreateFinishNum, [regionUserNumber, equationsSetUserNumber])


def EquationsSet_EquationsCreateStartNum(regionUserNumber, equationsSetUserNumber):
    """Start the creation of equations for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to start the creation of equations for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to start the creation of equations for.
    :type equationsSetUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_EquationsCreateStartNum, [regionUserNumber, equationsSetUserNumber])


def EquationsSet_EquationsDestroyNum(regionUserNumber, equationsSetUserNumber):
    """Destroy the equations for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to destroy the equations for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to destroy the equations for.
    :type equationsSetUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_EquationsDestroyNum, [regionUserNumber, equationsSetUserNumber])


def EquationsSet_IndependentCreateFinishNum(regionUserNumber, equationsSetUserNumber):
    """Finish the creation of independent variables for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to finish the creation of independent variables for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to finish the creation of independent variables for.
    :type equationsSetUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_IndependentCreateFinishNum, [regionUserNumber, equationsSetUserNumber])


def EquationsSet_IndependentCreateStartNum(regionUserNumber, equationsSetUserNumber, independentFieldUserNumber):
    """Start the creation of independent variables for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to start the creation of independent variables for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to start the creation of independent variables for.
    :type equationsSetUserNumber: int
    :param independentFieldUserNumber: The user number of the independent field.
    :type independentFieldUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_IndependentCreateStartNum, [regionUserNumber, equationsSetUserNumber, independentFieldUserNumber])


def EquationsSet_IndependentDestroyNum(regionUserNumber, equationsSetUserNumber):
    """Destroy the independent variables for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to destroy the independent variables for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to destroy the independent variables for.
    :type equationsSetUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_IndependentDestroyNum, [regionUserNumber, equationsSetUserNumber])


def EquationsSet_MaterialsCreateFinishNum(regionUserNumber, equationsSetUserNumber):
    """Finish the creation of materials for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to finish the creation of materials for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to finish the creation of materials for.
    :type equationsSetUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_MaterialsCreateFinishNum, [regionUserNumber, equationsSetUserNumber])


def EquationsSet_MaterialsCreateStartNum(regionUserNumber, equationsSetUserNumber, materialsFieldUserNumber):
    """Start the creation of materials for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to start the creation of materials for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to start the creation of materials for.
    :type equationsSetUserNumber: int
    :param materialsFieldUserNumber: The user number of the materials field.
    :type materialsFieldUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_MaterialsCreateStartNum, [regionUserNumber, equationsSetUserNumber, materialsFieldUserNumber])


def EquationsSet_MaterialsDestroyNum(regionUserNumber, equationsSetUserNumber):
    """Destroy the materials for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to destroy the materials for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to destroy the materials for.
    :type equationsSetUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_MaterialsDestroyNum, [regionUserNumber, equationsSetUserNumber])


def EquationsSet_SolutionMethodGetNum(regionUserNumber, equationsSetUserNumber):
    """Returns the solution method for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to get the solution method for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to get the solution method for.
    :type equationsSetUserNumber: int
    :returns: solutionMethod. The solution method. Will be a value from the EquationsSetSolutionMethods enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_SolutionMethodGetNum, [regionUserNumber, equationsSetUserNumber])


def EquationsSet_SolutionMethodSetNum(regionUserNumber, equationsSetUserNumber, solutionMethod):
    """Sets/changes the solution method for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to set the solution method for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to set the solution method for.
    :type equationsSetUserNumber: int
    :param solutionMethod: The solution method to set. Must be a value from the EquationsSetSolutionMethods enum.
    :type solutionMethod: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_SolutionMethodSetNum, [regionUserNumber, equationsSetUserNumber, solutionMethod])


def EquationsSet_SourceCreateFinishNum(regionUserNumber, equationsSetUserNumber):
    """Finish the creation of a source for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to finish the creation of a source for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to finish the creation of a source for.
    :type equationsSetUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_SourceCreateFinishNum, [regionUserNumber, equationsSetUserNumber])


def EquationsSet_SourceCreateStartNum(regionUserNumber, equationsSetUserNumber, sourceFieldUserNumber):
    """Start the creation of a source for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to start the creation of a source for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to start the creation of a source for.
    :type equationsSetUserNumber: int
    :param sourceFieldUserNumber: The user number of the source field.
    :type sourceFieldUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_SourceCreateStartNum, [regionUserNumber, equationsSetUserNumber, sourceFieldUserNumber])


def EquationsSet_SourceDestroyNum(regionUserNumber, equationsSetUserNumber):
    """Destroy the source for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to destroy the source for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to destroy the source for.
    :type equationsSetUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_SourceDestroyNum, [regionUserNumber, equationsSetUserNumber])


def EquationsSet_SpecificationGetNum(regionUserNumber, equationsSetUserNumber, equationsSetSpecification):
    """Returns the equations set specification array for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to get the specification for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to get the specification for.
    :type equationsSetUserNumber: int
    :param equationsSetSpecification: On return, the equations set specification array. Must be allocated and large enough to contain the specification on entry.
    :type equationsSetSpecification: Array of ints
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_SpecificationGetNum, [regionUserNumber, equationsSetUserNumber, equationsSetSpecification])


def EquationsSet_SpecificationSizeGetNum(regionUserNumber, equationsSetUserNumber):
    """Returns the size of the equations set specification array for an equations set identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations set to get the specification size for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to get the specification size for.
    :type equationsSetUserNumber: int
    :returns: specificationSize. The size of the equations set specification array.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_SpecificationSizeGetNum, [regionUserNumber, equationsSetUserNumber])


def EquationsSet_TensorInterpolateXiNum(regionUserNumber, equationsSetUserNumber, tensorEvaluateType, userElementNumber, xi, valuesSizes):
    """Evaluate a tensor at a given element xi location, for an equations set identified by a user number.

    :param regionUserNumber: The user number of the region containing the equations set.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to evalaute the tensor for.
    :type equationsSetUserNumber: int
    :param tensorEvaluateType: The type of tensor to evaluate.
    :type tensorEvaluateType: int
    :param userElementNumber: The user element number of the field to interpolate.
    :type userElementNumber: int
    :param xi: The element xi to interpolate the field at.
    :type xi: Array of floats
    :param valuesSizes: Tuple of dimensions of values to allocate, with length 2.
    :returns: values. The interpolated tensor values.
    :rtype: 2d array of floats
    """

    return _wrap_routine(_iron_python.cmfe_EquationsSet_TensorInterpolateXiNum, [regionUserNumber, equationsSetUserNumber, tensorEvaluateType, userElementNumber, xi, valuesSizes])


def Equations_DestroyNum(regionUserNumber, equationsSetUserNumber):
    """Destroys equations for equations identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations to destroy.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to destroy the equations for.
    :type equationsSetUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Equations_DestroyNum, [regionUserNumber, equationsSetUserNumber])


def Equations_LinearityTypeGetNum(regionUserNumber, equationsSetUserNumber):
    """Gets the linearity type for equations identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations to get the linearity type for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to get the linearity type for.
    :type equationsSetUserNumber: int
    :returns: linearityType. The linearity type of the equations. Will be a value from the EquationsLinearityTypes enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Equations_LinearityTypeGetNum, [regionUserNumber, equationsSetUserNumber])


def Equations_LumpingTypeGetNum(regionUserNumber, equationsSetUserNumber):
    """Gets the lumping type for equations identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations to get the lumping type for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to get the lumping type for.
    :type equationsSetUserNumber: int
    :returns: lumpingType. The lumping type of the equations. Will be a value from the EquationsLumpingTypes enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Equations_LumpingTypeGetNum, [regionUserNumber, equationsSetUserNumber])


def Equations_LumpingTypeSetNum(regionUserNumber, equationsSetUserNumber, lumpingType):
    """Sets/changes the lumping type for equations identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations to set the lumping type for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to set the lumping type for.
    :type equationsSetUserNumber: int
    :param lumpingType: The lumping type of the equations to set. Must be a value from the EquationsLumpingTypes enum.
    :type lumpingType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Equations_LumpingTypeSetNum, [regionUserNumber, equationsSetUserNumber, lumpingType])


def Equations_OutputTypeGetNum(regionUserNumber, equationsSetUserNumber):
    """Gets the output type for equations identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations to get the output type for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to get the output type for.
    :type equationsSetUserNumber: int
    :returns: outputType. The output type of the equations. Will be a value from the EquationsOutputTypes enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Equations_OutputTypeGetNum, [regionUserNumber, equationsSetUserNumber])


def Equations_OutputTypeSetNum(regionUserNumber, equationsSetUserNumber, outputType):
    """Sets/changes the output type for equations identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations to set the output type for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to set the output type for.
    :type equationsSetUserNumber: int
    :param outputType: The output type of the equations to set. Must be a value from the EquationsOutputTypes enum.
    :type outputType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Equations_OutputTypeSetNum, [regionUserNumber, equationsSetUserNumber, outputType])


def Equations_SparsityTypeGetNum(regionUserNumber, equationsSetUserNumber):
    """Gets the sparsity type for equations identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations to get the sparsity type for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to get the sparsity type for.
    :type equationsSetUserNumber: int
    :returns: sparsityType. The sparsity type of the equations. Will be a value from the EquationsSparsityTypes enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Equations_SparsityTypeGetNum, [regionUserNumber, equationsSetUserNumber])


def Equations_SparsityTypeSetNum(regionUserNumber, equationsSetUserNumber, sparsityType):
    """Sets/changes the sparsity type for equations identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations to set the sparsity type for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to set the sparsity type for.
    :type equationsSetUserNumber: int
    :param sparsityType: The sparsity type of the equations to set. Must be a value from the EquationsSparsityTypes enum.
    :type sparsityType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Equations_SparsityTypeSetNum, [regionUserNumber, equationsSetUserNumber, sparsityType])


def Equations_TimeDependenceTypeGetNum(regionUserNumber, equationsSetUserNumber):
    """Gets the time dependence type for equations identified by a user number.

    :param regionUserNumber: The user number of the Region containing the equations to get the time dependence type for.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to get the time dependence type for.
    :type equationsSetUserNumber: int
    :returns: timeDependenceType. The time dependence type of the equations. Will be a value from the EquationsTimeDependenceTypes enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Equations_TimeDependenceTypeGetNum, [regionUserNumber, equationsSetUserNumber])


def ErrorHandlingModeGet():
    """Returns the error handling mode for OpenCMISS

    :returns: errorHandlingMode. The error handling mode. Will be a value from the CMISSErrorHandlingModes enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_ErrorHandlingModeGet, [])


def ErrorHandlingModeSet(errorHandlingMode):
    """Sets the error handling mode for OpenCMISS

    :param errorHandlingMode: The error handling mode to set. Must be a value from the CMISSErrorHandlingModes enum.
    :type errorHandlingMode: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_ErrorHandlingModeSet, [errorHandlingMode])


def ExtractErrorMessage():
    """Extracts the most recent error string for OpenCMISS

    :returns: errorMessage. The extracted error message.
    :rtype: string
    """

    return _wrap_routine(_iron_python.cmfe_ExtractErrorMessage, [])


def Field_ComponentInterpolationGetNum(regionUserNumber, fieldUserNumber, variableType, componentNumber):
    """Returns the interpolation type for a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the interpolation type for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the interpolation type for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the interpolation type for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param componentNumber: The component number of the field variable to get the interpolation type for.
    :type componentNumber: int
    :returns: interpolationType. The interpolation type. Will be a value from the FieldInterpolationTypes enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Field_ComponentInterpolationGetNum, [regionUserNumber, fieldUserNumber, variableType, componentNumber])


def Field_ComponentInterpolationSetNum(regionUserNumber, fieldUserNumber, variableType, componentNumber, interpolationType):
    """Sets/changes the interpolation type for a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to set the interpolation type for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to set the interpolation type for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to set the interpolation type for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param componentNumber: The component number of the field variable to set the interpolation type for.
    :type componentNumber: int
    :param interpolationType: The interpolation type to set. Must be a value from the FieldInterpolationTypes enum.
    :type interpolationType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ComponentInterpolationSetNum, [regionUserNumber, fieldUserNumber, variableType, componentNumber, interpolationType])


def Field_ComponentLabelGetNum(regionUserNumber, fieldUserNumber, variableType, componentNumber):
    """Returns the character string label for a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the label for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the label for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the label for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param componentNumber: The component number of the field variable to get the label for.
    :type componentNumber: int
    :returns: label. The field variable component label.
    :rtype: string
    """

    return _wrap_routine(_iron_python.cmfe_Field_ComponentLabelGetNum, [regionUserNumber, fieldUserNumber, variableType, componentNumber])


def Field_ComponentLabelSetNum(regionUserNumber, fieldUserNumber, variableType, componentNumber, label):
    """Sets/changes the character string label for a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to set the label for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to set the label for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to set the label for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param componentNumber: The component number of the field variable to set the label for.
    :type componentNumber: int
    :param label: The field variable component label to set.
    :type label: string
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ComponentLabelSetNum, [regionUserNumber, fieldUserNumber, variableType, componentNumber, label])


def Field_ComponentMeshComponentGetNum(regionUserNumber, fieldUserNumber, variableType, componentNumber):
    """Returns the mesh component number for a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the mesh component number for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the mesh component number for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the mesh component number for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param componentNumber: The component number of the field variable to get the mesh component number for.
    :type componentNumber: int
    :returns: meshComponent. The mesh component number.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Field_ComponentMeshComponentGetNum, [regionUserNumber, fieldUserNumber, variableType, componentNumber])


def Field_ComponentMeshComponentSetNum(regionUserNumber, fieldUserNumber, variableType, componentNumber, meshComponent):
    """Sets/changes the mesh component number for a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to set the mesh component number for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to set the mesh component number for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to set the mesh component number for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param componentNumber: The component number of the field variable to set the mesh component number for.
    :type componentNumber: int
    :param meshComponent: The mesh component number to set.
    :type meshComponent: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ComponentMeshComponentSetNum, [regionUserNumber, fieldUserNumber, variableType, componentNumber, meshComponent])


def Field_ComponentValuesInitialiseDPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value):
    """Initialises the values of parameter set of a field variable component to a double precision constant value for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to initialise the field variable component for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to initialise the field variable component for for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to initialise the field variable component for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to initialise the field variable component for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param componentNumber: The component number of the field variable to initialise the field variable component for.
    :type componentNumber: int
    :param value: The value to initialise the parameter set for.
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ComponentValuesInitialiseDPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value])


def Field_ComponentValuesInitialiseIntgNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value):
    """Initialises the values of parameter set of a field variable component to an integer constant value for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to initialise the field variable component for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to initialise the field variable component for for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to initialise the field variable component for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to initialise the field variable component for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param componentNumber: The component number of the field variable to initialise the field variable component for.
    :type componentNumber: int
    :param value: The value to initialise the parameter set for.
    :type value: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ComponentValuesInitialiseIntgNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value])


def Field_ComponentValuesInitialiseLNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value):
    """Initialises the values of parameter set of a field variable component to a logical constant value for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to initialise the field variable component for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to initialise the field variable component for for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to initialise the field variable component for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to initialise the field variable component for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param componentNumber: The component number of the field variable to initialise the field variable component for.
    :type componentNumber: int
    :param value: The value to initialise the parameter set for.
    :type value: bool
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ComponentValuesInitialiseLNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value])


def Field_ComponentValuesInitialiseSPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value):
    """Initialises the values of parameter set of a field variable component to a single precision constant value for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to initialise the field variable component for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to initialise the field variable component for for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to initialise the field variable component for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to initialise the field variable component for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param componentNumber: The component number of the field variable to initialise the field variable component for.
    :type componentNumber: int
    :param value: The value to initialise the parameter set for.
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ComponentValuesInitialiseSPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value])


def Field_CreateFinishNum(regionUserNumber, fieldUserNumber):
    """Finishes the creation of a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to finish the creation of.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to finish the creation of.
    :type fieldUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_CreateFinishNum, [regionUserNumber, fieldUserNumber])


def Field_CreateStartNum(fieldUserNumber, regionUserNumber):
    """Starts the creation of a field identified by a user number.

    :param fieldUserNumber: The user number of the field to start the creation of.
    :type fieldUserNumber: int
    :param regionUserNumber: The user number of the region containing the field to start the creation of.
    :type regionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_CreateStartNum, [fieldUserNumber, regionUserNumber])


def Field_DOFOrderTypeGetNum(regionUserNumber, fieldUserNumber, variableType):
    """Returns the DOF order type for a field variable for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the DOF Order type for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the DOF Order type for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the DOF Order type for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :returns: DOFOrderType. The field variable DOF Order type. Will be a value from the FieldDOFOrderTypes enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Field_DOFOrderTypeGetNum, [regionUserNumber, fieldUserNumber, variableType])


def Field_DOFOrderTypeSetNum(regionUserNumber, fieldUserNumber, variableType, DOFOrderType):
    """Sets/changes the DOF order type for a field variable for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to set the DOF Order type for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to set the DOF Order type for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to set the DOF Order type for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param DOFOrderType: The field variable DOF Order type to set. Must be a value from the FieldDOFOrderTypes enum.
    :type DOFOrderType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_DOFOrderTypeSetNum, [regionUserNumber, fieldUserNumber, variableType, DOFOrderType])


def Field_DataProjectionSetNum(regionUserNumber, fieldUserNumber, dataProjectionUserNumber):
    """Sets/changes the data projection for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to set the mesh decomposition for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to set the mesh decomposition for.
    :type fieldUserNumber: int
    :param dataProjectionUserNumber: The field data projection user number to set.
    :type dataProjectionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_DataProjectionSetNum, [regionUserNumber, fieldUserNumber, dataProjectionUserNumber])


def Field_DataTypeGetNum(regionUserNumber, fieldUserNumber, variableType):
    """Returns the data type for a field variable for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the data type for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the data type for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the data type for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :returns: dataType. The field variable data type. Will be a value from the FieldDataTypes enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Field_DataTypeGetNum, [regionUserNumber, fieldUserNumber, variableType])


def Field_DataTypeSetNum(regionUserNumber, fieldUserNumber, variableType, dataType):
    """Sets/changes the data type for a field variable for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to set the data type for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to set the data type for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to set the data type for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param dataType: The field variable data type to set. Must be a value from the FieldDataTypes enum.
    :type dataType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_DataTypeSetNum, [regionUserNumber, fieldUserNumber, variableType, dataType])


def Field_DependentTypeGetNum(regionUserNumber, fieldUserNumber):
    """Returns the dependent type for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the dependent type for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the dependent type for.
    :type fieldUserNumber: int
    :returns: dependentType. The field dependent type. Will be a value from the FieldDependentTypes enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Field_DependentTypeGetNum, [regionUserNumber, fieldUserNumber])


def Field_DependentTypeSetNum(regionUserNumber, fieldUserNumber, dependentType):
    """Sets/changes the dependent type for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the dependent type for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the dependent type for.
    :type fieldUserNumber: int
    :param dependentType: The field dependent type to set. Must be a value from the FieldDependentTypes enum.
    :type dependentType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_DependentTypeSetNum, [regionUserNumber, fieldUserNumber, dependentType])


def Field_DestroyNum(regionUserNumber, fieldUserNumber):
    """Destroys a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to destroy.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to destroy.
    :type fieldUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_DestroyNum, [regionUserNumber, fieldUserNumber])


def Field_DimensionGetNum(regionUserNumber, fieldUserNumber, variableType):
    """Returns the dimension for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the dimension for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the dimension for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the dimension for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :returns: dimension. The field dimension. Will be a value from the FieldDimensionTypes enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Field_DimensionGetNum, [regionUserNumber, fieldUserNumber, variableType])


def Field_DimensionSetNum(regionUserNumber, fieldUserNumber, variableType, dimension):
    """Sets/changes the dimension for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to set the dimension for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to set the dimension for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the dimension for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param dimension: The field dimension to set. Must be a value from the FieldDimensionTypes enum.
    :type dimension: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_DimensionSetNum, [regionUserNumber, fieldUserNumber, variableType, dimension])


def Field_GeometricFieldGetNum(regionUserNumber, fieldUserNumber):
    """Returns the geometric field for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the geometric field for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the geometric field for.
    :type fieldUserNumber: int
    :returns: geometricFieldUserNumber. The field geometric field user number.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Field_GeometricFieldGetNum, [regionUserNumber, fieldUserNumber])


def Field_GeometricFieldSetNum(regionUserNumber, fieldUserNumber, geometricFieldUserNumber):
    """Sets/changes the geometric field for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to set the geometric field for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to set the geometric field for.
    :type fieldUserNumber: int
    :param geometricFieldUserNumber: The field geometric field user number to set.
    :type geometricFieldUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_GeometricFieldSetNum, [regionUserNumber, fieldUserNumber, geometricFieldUserNumber])


def Field_GeometricParametersElementLineLengthGetNum(regionUserNumber, geometricFieldUserNumber, elementNumber, elementLineNumber):
    """Gets the line length between nodes of a geometric field for a given element number and element basis line number by a user number.

    :param regionUserNumber: The user number of the region containing the field to obtain the line length from
    :type regionUserNumber: int
    :param geometricFieldUserNumber: The geometric field user number to obtain the line length from
    :type geometricFieldUserNumber: int
    :param elementNumber: The element to get the line length for
    :type elementNumber: int
    :param elementLineNumber: The element basis line to get the length for
    :type elementLineNumber: int
    :returns: lineLength. The line length of the chosen element line number
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_Field_GeometricParametersElementLineLengthGetNum, [regionUserNumber, geometricFieldUserNumber, elementNumber, elementLineNumber])


def Field_GeometricParametersElementVolumeGetNum(regionUserNumber, geometricFieldUserNumber, elementNumber):
    """Gets the volume for a given element number by a user number.

    :param regionUserNumber: The user number of the region containing the field to obtain the volume from
    :type regionUserNumber: int
    :param geometricFieldUserNumber: The geometric field user number to obtain the volume from
    :type geometricFieldUserNumber: int
    :param elementNumber: The element to get the volume for
    :type elementNumber: int
    :returns: elementVolume. The volume of the chosen element number
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_Field_GeometricParametersElementVolumeGetNum, [regionUserNumber, geometricFieldUserNumber, elementNumber])


def Field_LabelGetNum(regionUserNumber, fieldUserNumber):
    """Returns the character string label for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the label for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the label for.
    :type fieldUserNumber: int
    :returns: label. The field label.
    :rtype: string
    """

    return _wrap_routine(_iron_python.cmfe_Field_LabelGetNum, [regionUserNumber, fieldUserNumber])


def Field_LabelSetNum(regionUserNumber, fieldUserNumber, label):
    """Sets/changes the character string label for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to set the label for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to set the label for.
    :type fieldUserNumber: int
    :param label: The field label to set.
    :type label: string
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_LabelSetNum, [regionUserNumber, fieldUserNumber, label])


def Field_MeshDecompositionGetNum(regionUserNumber, fieldUserNumber):
    """Returns the mesh decomposition for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the mesh decomposition for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the mesh decomposition for.
    :type fieldUserNumber: int
    :returns: decompositionUserNumber. The field decomposition user number.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Field_MeshDecompositionGetNum, [regionUserNumber, fieldUserNumber])


def Field_MeshDecompositionSetNum(regionUserNumber, fieldUserNumber, meshUserNumber, decompositionUserNumber):
    """Sets/changes the mesh decomposition for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to set the mesh decomposition for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to set the mesh decomposition for.
    :type fieldUserNumber: int
    :param meshUserNumber: The user number of the mesh to set the mesh decomposition for.
    :type meshUserNumber: int
    :param decompositionUserNumber: The field mesh decomposition user number to set.
    :type decompositionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_MeshDecompositionSetNum, [regionUserNumber, fieldUserNumber, meshUserNumber, decompositionUserNumber])


def Field_NumberOfComponentsGetNum(regionUserNumber, fieldUserNumber, variableType):
    """Returns the number of componenets for a field variable for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the number of components for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the number of components for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the dependent field to get the number of components for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :returns: numberOfComponents. The number of components in the field variable.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Field_NumberOfComponentsGetNum, [regionUserNumber, fieldUserNumber, variableType])


def Field_NumberOfComponentsSetNum(regionUserNumber, fieldUserNumber, variableType, numberOfComponents):
    """Sets/changes the number of componenets for a field variable for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to set the number of components for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to set the number of components for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the dependent field to set the number of components for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param numberOfComponents: The number of components in the field variable to set.
    :type numberOfComponents: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_NumberOfComponentsSetNum, [regionUserNumber, fieldUserNumber, variableType, numberOfComponents])


def Field_NumberOfVariablesGetNum(regionUserNumber, fieldUserNumber):
    """Returns the number of variables for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the number of variables for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the number of variables for.
    :type fieldUserNumber: int
    :returns: numberOfVariables. The number of variables in the field.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Field_NumberOfVariablesGetNum, [regionUserNumber, fieldUserNumber])


def Field_NumberOfVariablesSetNum(regionUserNumber, fieldUserNumber, numberOfVariables):
    """Sets/chnages the number of variables for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to set the number of variables for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to set the number of variables for.
    :type fieldUserNumber: int
    :param numberOfVariables: The number of variables in the field to set.
    :type numberOfVariables: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_NumberOfVariablesSetNum, [regionUserNumber, fieldUserNumber, numberOfVariables])


def Field_ParameterSetAddConstantDPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value):
    """Adds the given double precision value to the given parameter set for the constant of the field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to add the constant to the field parameter set for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to add the constant to the field parameter set for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to add the constant to the field parameter set for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to add the constant to the field parameter set for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param componentNumber: The component number of the field variable to add the constant to the field parameter set for.
    :type componentNumber: int
    :param value: The value to add to the field parameter set.
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddConstantDPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value])


def Field_ParameterSetAddConstantIntgNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value):
    """Adds the given integer value to the given parameter set for the constant of the field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to add the constant to the field parameter set for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to add the constant to the field parameter set for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to add the constant to the field parameter set for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to add the constant to the field parameter set for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param componentNumber: The component number of the field variable to add the constant to the field parameter set for.
    :type componentNumber: int
    :param value: The value to add to the field parameter set.
    :type value: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddConstantIntgNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value])


def Field_ParameterSetAddConstantLNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value):
    """Adds the given logical value to the given parameter set for the constant of the field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to add the constant to the field parameter set for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to add the constant to the field parameter set for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to add the constant to the field parameter set for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to add the constant to the field parameter set for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param componentNumber: The component number of the field variable to add the constant to the field parameter set for.
    :type componentNumber: int
    :param value: The value to add to the field parameter set.
    :type value: bool
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddConstantLNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value])


def Field_ParameterSetAddConstantSPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value):
    """Adds the given single precision value to the given parameter set for the constant of the field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to add the constant to the field parameter set for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to add the constant to the field parameter set for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to add the constant to the field parameter set for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to add the constant to the field parameter set for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param componentNumber: The component number of the field variable to add the constant to the field parameter set for.
    :type componentNumber: int
    :param value: The value to add to the field parameter set.
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddConstantSPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value])


def Field_ParameterSetAddElementDPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber, value):
    """Adds the given double precision value to an element in the given parameter set for field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to add the value to the element in the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to add the value to the element in the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to add the value to the element in the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to add the value to the element. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userElementNumber: The user element number to add the value to.
    :type userElementNumber: int
    :param componentNumber: The component number of the field variable to add the value to the element to in the field parameter set.
    :type componentNumber: int
    :param value: The value to add to the element in the field parameter set.
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddElementDPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber, value])


def Field_ParameterSetAddElementIntgNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber, value):
    """Adds the given integer value to an element in the given parameter set for field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to add the value to the element in the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to add the value to the element in the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to add the value to the element in the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to add the value to the element. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userElementNumber: The user element number to add the value to.
    :type userElementNumber: int
    :param componentNumber: The component number of the field variable to add the value to the element to in the field parameter set.
    :type componentNumber: int
    :param value: The value to add to the element in the field parameter set.
    :type value: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddElementIntgNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber, value])


def Field_ParameterSetAddElementLNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber, value):
    """Adds the given logical value to an element in the given parameter set for field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to add the value to the element in the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to add the value to the element in the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to add the value to the element in the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to add the value to the element. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userElementNumber: The user element number to add the value to.
    :type userElementNumber: int
    :param componentNumber: The component number of the field variable to add the value to the element to in the field parameter set.
    :type componentNumber: int
    :param value: The value to add to the element in the field parameter set.
    :type value: bool
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddElementLNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber, value])


def Field_ParameterSetAddElementSPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber, value):
    """Adds the given single precision value to an element in the given parameter set for field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to add the value to the element in the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to add the value to the element in the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to add the value to the element in the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to add the value to the element. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userElementNumber: The user element number to add the value to.
    :type userElementNumber: int
    :param componentNumber: The component number of the field variable to add the value to the element to in the field parameter set.
    :type componentNumber: int
    :param value: The value to add to the element in the field parameter set.
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddElementSPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber, value])


def Field_ParameterSetAddNodeDPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value):
    """Adds the given double precision value to an node in the given parameter set for field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to add the value to the node in the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to add the value to the node in the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to add the value to the node in the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to add the value to the node. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param versionNumber: The node derivative version number of the node to add the value to.
    :type versionNumber: int
    :param derivativeNumber: The node derivative number of the node to add the value to.
    :type derivativeNumber: int
    :param userNodeNumber: The user node number to add the value to.
    :type userNodeNumber: int
    :param componentNumber: The component number of the field variable to add the value to the node to in the field parameter set.
    :type componentNumber: int
    :param value: The value to add to the node in the field parameter set.
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddNodeDPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value])


def Field_ParameterSetAddNodeIntgNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value):
    """Adds the given integer value to an node in the given parameter set for field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to add the value to the node in the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to add the value to the node in the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to add the value to the node in the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to add the value to the node. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param versionNumber: The node derivative version number of the node to add the value to.
    :type versionNumber: int
    :param derivativeNumber: The node derivative number of the node to add the value to.
    :type derivativeNumber: int
    :param userNodeNumber: The user node number to add the value to.
    :type userNodeNumber: int
    :param componentNumber: The component number of the field variable to add the value to the node to in the field parameter set.
    :type componentNumber: int
    :param value: The value to add to the node in the field parameter set.
    :type value: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddNodeIntgNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value])


def Field_ParameterSetAddNodeLNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value):
    """Adds the given logical value to an node in the given parameter set for field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to add the value to the node in the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to add the value to the node in the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to add the value to the node in the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to add the value to the node. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param versionNumber: The node derivative version number of the node to add the value to.
    :type versionNumber: int
    :param derivativeNumber: The node derivative number of the node to add the value to.
    :type derivativeNumber: int
    :param userNodeNumber: The user node number to add the value to.
    :type userNodeNumber: int
    :param componentNumber: The component number of the field variable to add the value to the node to in the field parameter set.
    :type componentNumber: int
    :param value: The value to add to the node in the field parameter set.
    :type value: bool
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddNodeLNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value])


def Field_ParameterSetAddNodeSPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value):
    """Adds the given single precision value to an node in the given parameter set for field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to add the value to the node in the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to add the value to the node in the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to add the value to the node in the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to add the value to the node. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param versionNumber: The node derivative version number of the node to add the value to.
    :type versionNumber: int
    :param derivativeNumber: The node derivative number of the node to add the value to.
    :type derivativeNumber: int
    :param userNodeNumber: The user node number to add the value to.
    :type userNodeNumber: int
    :param componentNumber: The component number of the field variable to add the value to the node to in the field parameter set.
    :type componentNumber: int
    :param value: The value to add to the node in the field parameter set.
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetAddNodeSPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value])


def Field_ParameterSetCreateNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType):
    """Creates a new parameter set of type set type for a field variable for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to create the parameter set on.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to create the parameter set on.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to create the parameter set on. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to create. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetCreateNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType])


def Field_ParameterSetDataGetDPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType):
    """Returns a pointer to the specified field parameter set local double precision data array for a field identified by an user number. The pointer must be restored with a call to OpenCMISS::Iron::cmfe_Field_ParameterSetDataRestore call. Note: the values can be used for read operations but a field parameter set update or add calls must be used to change any values.

    :param regionUserNumber: The user number of the region containing the field to get the parameter set data for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the parameter set data for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the parameter set data for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the parameter set data to get. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param parametersSize: Size of parameters to allocate.
    :returns: parameters. A pointer to the parameter set data.
    :rtype: Array of floats
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetDataGetDPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType])


def Field_ParameterSetDataGetIntgNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType):
    """Returns a pointer to the specified field parameter set local integer data array for a field identified by an user number. The pointer must be restored with a call to OpenCMISS::Iron::cmfe_Field_ParameterSetDataRestore call. Note: the values can be used for read operations but a field parameter set update or add calls must be used to change any values.

    :param regionUserNumber: The user number of the region containing the field to get the parameter set data for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the parameter set data for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the parameter set data for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the parameter set data to get. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param parametersSize: Size of parameters to allocate.
    :returns: parameters. A pointer to the parameter set data.
    :rtype: Array of ints
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetDataGetIntgNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType])


def Field_ParameterSetDataGetLNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType):
    """Returns a pointer to the specified field parameter set local logical data array for a field identified by an user number. The pointer must be restored with a call to OpenCMISS::Iron::cmfe_Field_ParameterSetDataRestore call. Note: the values can be used for read operations but a field parameter set update or add calls must be used to change any values.

    :param regionUserNumber: The user number of the region containing the field to get the parameter set data for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the parameter set data for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the parameter set data for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the parameter set data to get. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param parametersSize: Size of parameters to allocate.
    :returns: parameters. A pointer to the parameter set data.
    :rtype: Array of bools
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetDataGetLNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType])


def Field_ParameterSetDataGetSPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType):
    """Returns a pointer to the specified field parameter set local single precision data array for a field identified by an user number. The pointer must be restored with a call to OpenCMISS::Iron::cmfe_Field_ParameterSetDataRestore call. Note: the values can be used for read operations but a field parameter set update or add calls must be used to change any values.

    :param regionUserNumber: The user number of the region containing the field to get the parameter set data for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the parameter set data for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the parameter set data for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the parameter set data to get. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param parametersSize: Size of parameters to allocate.
    :returns: parameters. A pointer to the parameter set data.
    :rtype: Array of floats
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetDataGetSPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType])


def Field_ParameterSetDataRestoreDPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, parameters):
    """Restores the specified field variable parameter set local double precision array that was obtained with an OpenCMISS::Iron::cmfe_Field_ParameterSetDataGet call for a field that is specified with an user number.

    :param regionUserNumber: The user number of the region containing the field to restore the parameter set data for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to restore the parameter set data for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to restore the parameter set data for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the parameter set data to restore. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param parameters: A pointer to the parameter set data. On return this pointer is null.
    :type parameters: Array of floats
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetDataRestoreDPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, parameters])


def Field_ParameterSetDataRestoreIntgNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, parameters):
    """Restores the specified field variable parameter set local integer array that was obtained with an OpenCMISS::Iron::cmfe_Field_ParameterSetDataGet call for a field that is specified with an user number.

    :param regionUserNumber: The user number of the region containing the field to restore the parameter set data for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to restore the parameter set data for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to restore the parameter set data for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the parameter set data to restore. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param parameters: A pointer to the parameter set data. On return this pointer is null.
    :type parameters: Array of ints
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetDataRestoreIntgNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, parameters])


def Field_ParameterSetDataRestoreLNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, parameters):
    """Restores the specified field variable parameter set local logical array that was obtained with an OpenCMISS::Iron::cmfe_Field_ParameterSetDataGet call for a field that is specified with an user number.

    :param regionUserNumber: The user number of the region containing the field to restore the parameter set data for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to restore the parameter set data for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to restore the parameter set data for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the parameter set data to restore. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param parameters: A pointer to the parameter set data. On return this pointer is null.
    :type parameters: Array of bools
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetDataRestoreLNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, parameters])


def Field_ParameterSetDataRestoreSPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, parameters):
    """Restores the specified field variable parameter set local single precision array that was obtained with an OpenCMISS::Iron::cmfe_Field_ParameterSetDataGet call for a field that is specified with an user number.

    :param regionUserNumber: The user number of the region containing the field to restore the parameter set data for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to restore the parameter set data for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to restore the parameter set data for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the parameter set data to restore. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param parameters: A pointer to the parameter set data. On return this pointer is null.
    :type parameters: Array of floats
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetDataRestoreSPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, parameters])


def Field_ParameterSetDestroyNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType):
    """Destroys the specified parameter set type for a field variable for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to destroy the parameter set for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to destroy the parameter set for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to destroy the parameter set for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to destroy. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetDestroyNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType])


def Field_ParameterSetGetConstantDPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber):
    """Returns from the given parameter set a double precision value for the specified constant of a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the constant value from the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the constant value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the constant value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to get the constant value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param componentNumber: The component number of the field variable to get the constant value from the field parameter set.
    :type componentNumber: int
    :returns: value. The value from the field parameter set.
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetConstantDPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber])


def Field_ParameterSetGetConstantIntgNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber):
    """Returns from the given parameter set an integer value for the specified constant of a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the constant value from the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the constant value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the constant value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to get the constant value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param componentNumber: The component number of the field variable to get the constant value from the field parameter set.
    :type componentNumber: int
    :returns: value. The value from the field parameter set.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetConstantIntgNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber])


def Field_ParameterSetGetConstantLNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber):
    """Returns from the given parameter set a logical value for the specified constant of a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the constant value from the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the constant value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the constant value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to get the constant value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param componentNumber: The component number of the field variable to get the constant value from the field parameter set.
    :type componentNumber: int
    :returns: value. The value from the field parameter set.
    :rtype: bool
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetConstantLNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber])


def Field_ParameterSetGetConstantSPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber):
    """Returns from the given parameter set a single precision value for the specified constant of a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the constant value from the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the constant value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the constant value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to get the constant value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param componentNumber: The component number of the field variable to get the constant value from the field parameter set.
    :type componentNumber: int
    :returns: value. The value from the field parameter set.
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetConstantSPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber])


def Field_ParameterSetGetDataPointDPNumberI(parentRegionUserNumber, interfaceUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber):
    """Returns from the given parameter set a double precision value for the specified data point of a field variable component for a field identified by a user number.

    :param parentRegionUserNumber: The user number of the parent region for the interface.
    :type parentRegionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containing the field to get the data point value from the field parameter set.
    :type interfaceUserNumber: int
    :param fieldUserNumber: The user number of the field to get the data point value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to get the data point value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userDataPointNumber: The user data point number to get the value for
    :type userDataPointNumber: int
    :param componentNumber: The component number of the field variable to get the data point value from the field parameter set.
    :type componentNumber: int
    :returns: value. The value from the field parameter set.
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetDataPointDPNumberI, [parentRegionUserNumber, interfaceUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber])


def Field_ParameterSetGetDataPointDPNumberR(regionUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber):
    """Returns from the given parameter set a double precision value for the specified data point of a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the data point value from the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the data point value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to get the data point value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userDataPointNumber: The user data point number to get the value for
    :type userDataPointNumber: int
    :param componentNumber: The component number of the field variable to get the data point value from the field parameter set.
    :type componentNumber: int
    :returns: value. The value from the field parameter set.
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetDataPointDPNumberR, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber])


def Field_ParameterSetGetDataPointIntgNumberI(parentRegionUserNumber, interfaceUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber):
    """Returns from the given parameter set a integer value for the specified data point of a field variable component for a field identified by a user number.

    :param parentRegionUserNumber: The user number of the parent region for the interface.
    :type parentRegionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containing the field to get the data point value from the field parameter set.
    :type interfaceUserNumber: int
    :param fieldUserNumber: The user number of the field to get the data point value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to get the data point value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userDataPointNumber: The user data point number to get the value for
    :type userDataPointNumber: int
    :param componentNumber: The component number of the field variable to get the data point value from the field parameter set.
    :type componentNumber: int
    :returns: value. The value from the field parameter set.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetDataPointIntgNumberI, [parentRegionUserNumber, interfaceUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber])


def Field_ParameterSetGetDataPointIntgNumberR(regionUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber):
    """Returns from the given parameter set a integer value for the specified data point of a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the data point value from the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the data point value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to get the data point value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userDataPointNumber: The user data point number to get the value for
    :type userDataPointNumber: int
    :param componentNumber: The component number of the field variable to get the data point value from the field parameter set.
    :type componentNumber: int
    :returns: value. The value from the field parameter set.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetDataPointIntgNumberR, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber])


def Field_ParameterSetGetDataPointLNumberI(parentRegionUserNumber, interfaceUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber):
    """Returns from the given parameter set a logical value for the specified data point of a field variable component for a field identified by a user number.

    :param parentRegionUserNumber: The user number of the parent region for the interface.
    :type parentRegionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containing the field to get the data point value from the field parameter set.
    :type interfaceUserNumber: int
    :param fieldUserNumber: The user number of the field to get the data point value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to get the data point value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userDataPointNumber: The user data point number to get the value for
    :type userDataPointNumber: int
    :param componentNumber: The component number of the field variable to get the data point value from the field parameter set.
    :type componentNumber: int
    :returns: value. The value from the field parameter set.
    :rtype: bool
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetDataPointLNumberI, [parentRegionUserNumber, interfaceUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber])


def Field_ParameterSetGetDataPointLNumberR(regionUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber):
    """Returns from the given parameter set a logical value for the specified data point of a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the data point value from the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the data point value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to get the data point value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userDataPointNumber: The user data point number to get the value for
    :type userDataPointNumber: int
    :param componentNumber: The component number of the field variable to get the data point value from the field parameter set.
    :type componentNumber: int
    :returns: value. The value from the field parameter set.
    :rtype: bool
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetDataPointLNumberR, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber])


def Field_ParameterSetGetDataPointSPNumberI(parentRegionUserNumber, interfaceUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber):
    """Returns from the given parameter set a single precision value for the specified data point of a field variable component for a field identified by a user number.

    :param parentRegionUserNumber: The user number of the parent region for the interface.
    :type parentRegionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containing the field to get the data point value from the field parameter set.
    :type interfaceUserNumber: int
    :param fieldUserNumber: The user number of the field to get the data point value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to get the data point value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userDataPointNumber: The user data point number to get the value for
    :type userDataPointNumber: int
    :param componentNumber: The component number of the field variable to get the data point value from the field parameter set.
    :type componentNumber: int
    :returns: value. The value from the field parameter set.
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetDataPointSPNumberI, [parentRegionUserNumber, interfaceUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber])


def Field_ParameterSetGetDataPointSPNumberR(regionUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber):
    """Returns from the given parameter set a single precision value for the specified data point of a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the data point value from the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the data point value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to get the data point value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userDataPointNumber: The user data point number to get the value for
    :type userDataPointNumber: int
    :param componentNumber: The component number of the field variable to get the data point value from the field parameter set.
    :type componentNumber: int
    :returns: value. The value from the field parameter set.
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetDataPointSPNumberR, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber])


def Field_ParameterSetGetElementDPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber):
    """Returns from the given parameter set a double precision value for the specified element of a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the element value from the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the element value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the element value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to get the element value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userElementNumber: The user element number to get the value from the field parameter set.
    :type userElementNumber: int
    :param componentNumber: The component number of the field variable to get the element value from the field parameter set.
    :type componentNumber: int
    :returns: value. The value from the field parameter set.
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetElementDPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber])


def Field_ParameterSetGetElementIntgNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber):
    """Returns from the given parameter set an integer value for the specified element of a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the element value from the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the element value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the element value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to get the element value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userElementNumber: The user element number to get the value from the field parameter set.
    :type userElementNumber: int
    :param componentNumber: The component number of the field variable to get the element value from the field parameter set.
    :type componentNumber: int
    :returns: value. The value from the field parameter set.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetElementIntgNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber])


def Field_ParameterSetGetElementLNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber):
    """Returns from the given parameter set a logical value for the specified element of a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the element value from the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the element value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the element value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to get the element value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userElementNumber: The user element number to get the value from the field parameter set.
    :type userElementNumber: int
    :param componentNumber: The component number of the field variable to get the element value from the field parameter set.
    :type componentNumber: int
    :returns: value. The value from the field parameter set.
    :rtype: bool
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetElementLNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber])


def Field_ParameterSetGetElementSPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber):
    """Returns from the given parameter set a single precision value for the specified element of a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the element value from the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the element value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the element value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to get the element value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userElementNumber: The user element number to get the value from the field parameter set.
    :type userElementNumber: int
    :param componentNumber: The component number of the field variable to get the element value from the field parameter set.
    :type componentNumber: int
    :returns: value. The value from the field parameter set.
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetElementSPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber])


def Field_ParameterSetGetGaussPointCoord(meshEmbedding, componentNumber, coordsSize):
    """:param meshEmbedding: The embedding
    :type meshEmbedding: MeshEmbedding
    :param componentNumber:
    :type componentNumber: int
    :param coordsSize: Size of coords to allocate.
    :returns: (No description, Xi coordinates of embedded nodes wrt Child element)
    :rtype: tuple. (int, Array of floats)
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetGaussPointCoord, [meshEmbedding, componentNumber, coordsSize])


def Field_ParameterSetGetNodeDPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber):
    """Returns from the given parameter set a double precision value for the specified node and derivative of a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the nodal value from the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the nodal value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the nodal value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to get the nodal value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param versionNumber: The derivative version number to get the value from the field parameter set.
    :type versionNumber: int
    :param derivativeNumber: The derivative number to get the value from the field parameter set.
    :type derivativeNumber: int
    :param userNodeNumber: The user node number to get the value from the field parameter set.
    :type userNodeNumber: int
    :param componentNumber: The component number of the field variable to get the nodal value from the field parameter set.
    :type componentNumber: int
    :returns: value. The value from the field parameter set.
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetNodeDPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber])


def Field_ParameterSetGetNodeIntgNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber):
    """Returns from the given parameter set an integer value for the specified node and derivative of a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the nodal value from the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the nodal value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the nodal value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to get the nodal value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param versionNumber: The derivative version number to get the value from the field parameter set.
    :type versionNumber: int
    :param derivativeNumber: The derivative number to get the value from the field parameter set.
    :type derivativeNumber: int
    :param userNodeNumber: The user node number to get the value from the field parameter set.
    :type userNodeNumber: int
    :param componentNumber: The component number of the field variable to get the nodal value from the field parameter set.
    :type componentNumber: int
    :returns: value. The value from the field parameter set.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetNodeIntgNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber])


def Field_ParameterSetGetNodeLNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber):
    """Returns from the given parameter set a logical value for the specified node and derivative of a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the nodal value from the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the nodal value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the nodal value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to get the nodal value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param versionNumber: The derivative version number to get the value from the field parameter set.
    :type versionNumber: int
    :param derivativeNumber: The derivative number to get the value from the field parameter set.
    :type derivativeNumber: int
    :param userNodeNumber: The user node number to get the value from the field parameter set.
    :type userNodeNumber: int
    :param componentNumber: The component number of the field variable to get the nodal value from the field parameter set.
    :type componentNumber: int
    :returns: value. The value from the field parameter set.
    :rtype: bool
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetNodeLNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber])


def Field_ParameterSetGetNodeSPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber):
    """Returns from the given parameter set a single precision value for the specified node and derivative of a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the nodal value from the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the nodal value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the nodal value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to get the nodal value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param versionNumber: The derivative version number to get the value from the field parameter set.
    :type versionNumber: int
    :param derivativeNumber: The derivative number to get the value from the field parameter set.
    :type derivativeNumber: int
    :param userNodeNumber: The user node number to get the value from the field parameter set.
    :type userNodeNumber: int
    :param componentNumber: The component number of the field variable to get the nodal value from the field parameter set.
    :type componentNumber: int
    :returns: value. The value from the field parameter set.
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetGetNodeSPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber])


def Field_ParameterSetInterpolateMultipleGaussDPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, derivativeNumber, userElementNumber, quadratureScheme, GaussPoints, valuesSizes):
    """Interpolates the given parameter set at a specified set of Gauss points for the specified element and derviative and returns double precision values for a or a field identified by a user number. If no Gauss points are specified then all Gauss points are interpolated.

    :param regionUserNumber: The user number of the region containing the field whose parameter set is to be interpolated.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field whose parameter set is to be interpolated.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to interpolate. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to interpolate. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param derivativeNumber: The derivative number of the field to interpolate.
    :type derivativeNumber: int
    :param userElementNumber: The user element number of the field to interpolate.
    :type userElementNumber: int
    :param quadratureScheme: The quadrature scheme to interpolate the field for.
    :type quadratureScheme: int
    :param GaussPoints: The Gauss points to interpolate the field at.
    :type GaussPoints: Array of ints
    :param valuesSizes: Tuple of dimensions of values to allocate, with length 2.
    :returns: values. The interpolated values.
    :rtype: 2d array of floats
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetInterpolateMultipleGaussDPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, derivativeNumber, userElementNumber, quadratureScheme, GaussPoints, valuesSizes])


def Field_ParameterSetInterpolateMultipleXiDPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, derivativeNumber, userElementNumber, xi, valuesSizes):
    """Interpolates the given parameter set at a specified set of xi locations for the specified element and derviative and returns double precision values for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field whose parameter set is to be interpolated.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field whose parameter set is to be interpolated.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to interpolate. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to interpolate. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param derivativeNumber: The derivative number of the field to interpolate.
    :type derivativeNumber: int
    :param userElementNumber: The user element number of the field to interpolate.
    :type userElementNumber: int
    :param xi: The sets of element xi to interpolate the field at.
    :type xi: 2d array of floats
    :param valuesSizes: Tuple of dimensions of values to allocate, with length 2.
    :returns: values. The interpolated values.
    :rtype: 2d array of floats
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetInterpolateMultipleXiDPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, derivativeNumber, userElementNumber, xi, valuesSizes])


def Field_ParameterSetInterpolateSingleGaussDPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, derivativeNumber, userElementNumber, quadratureScheme, GaussPoint, valuesSize):
    """Interpolates the given parameter set at a specified Gauss point for the specified element and derviative and returns double precision values for a or a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field whose parameter set is to be interpolated.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field whose parameter set is to be interpolated.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to interpolate. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to interpolate. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param derivativeNumber: The derivative number of the field to interpolate.
    :type derivativeNumber: int
    :param userElementNumber: The user element number of the field to interpolate.
    :type userElementNumber: int
    :param quadratureScheme: The quadrature scheme to interpolate the field for.
    :type quadratureScheme: int
    :param GaussPoint: The Gauss point to interpolate the field at.
    :type GaussPoint: int
    :param valuesSize: Size of values to allocate.
    :returns: values. The interpolated values.
    :rtype: Array of floats
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetInterpolateSingleGaussDPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, derivativeNumber, userElementNumber, quadratureScheme, GaussPoint, valuesSize])


def Field_ParameterSetInterpolateSingleXiDPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, derivativeNumber, userElementNumber, xi, valuesSize):
    """Interpolates the given parameter set at a specified xi location for the specified element and derviative and returns double precision values for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field whose parameter set is to be interpolated.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field whose parameter set is to be interpolated.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to interpolate. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to interpolate. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param derivativeNumber: The derivative number of the field to interpolate.
    :type derivativeNumber: int
    :param userElementNumber: The user element number of the field to interpolate.
    :type userElementNumber: int
    :param xi: The element xi to interpolate the field at.
    :type xi: Array of floats
    :param valuesSize: Size of values to allocate.
    :returns: values. The interpolated values.
    :rtype: Array of floats
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetInterpolateSingleXiDPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, derivativeNumber, userElementNumber, xi, valuesSize])


def Field_ParameterSetNodeNumberOfScaleFactorDofsGetNum(regionUserNumber, fieldUserNumber, variableType, meshComponentNumber):
    """Gets the number of scale factor dofs, identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the number of scalefactors for
    :type regionUserNumber: int
    :param fieldUserNumber: The field to get the number of scale factor dofs for
    :type fieldUserNumber: int
    :param variableType: The field variable type to get the number of scale factor dofs for
    :type variableType: int
    :param meshComponentNumber: The mesh component number of the field to get the number of scale factor dofs for
    :type meshComponentNumber: int
    :returns: numberOfScaleFactorsDofs. The number of scale factor dofs
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetNodeNumberOfScaleFactorDofsGetNum, [regionUserNumber, fieldUserNumber, variableType, meshComponentNumber])


def Field_ParameterSetNodeScaleFactorGetNum(regionUserNumber, fieldUserNumber, variableType, versionNumber, derivativeNumber, nodeUserNumber, componentNumber):
    """Gets the scale factor for a particular node identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the scalefactor for
    :type regionUserNumber: int
    :param fieldUserNumber: The field to get scale factor for
    :type fieldUserNumber: int
    :param variableType: The field variable type to get the scale factor for
    :type variableType: int
    :param versionNumber: The user number of the node derivative version to get the scale factor for
    :type versionNumber: int
    :param derivativeNumber: The user number of the node derivative to get the scale factor for
    :type derivativeNumber: int
    :param nodeUserNumber: The user number of the node to get the scale factor for
    :type nodeUserNumber: int
    :param componentNumber: The component number of the field to get the scale factor for
    :type componentNumber: int
    :returns: scaleFactor. The scale factor of the specified node
    :rtype: float
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetNodeScaleFactorGetNum, [regionUserNumber, fieldUserNumber, variableType, versionNumber, derivativeNumber, nodeUserNumber, componentNumber])


def Field_ParameterSetNodeScaleFactorSetNum(regionUserNumber, fieldUserNumber, variableType, versionNumber, derivativeNumber, nodeUserNumber, componentNumber, scaleFactor):
    """Sets the scale factor for a particular node identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to set the scalefactor for
    :type regionUserNumber: int
    :param fieldUserNumber: The field to set scale factor for
    :type fieldUserNumber: int
    :param variableType: The field variable type to set the scale factor for
    :type variableType: int
    :param versionNumber: The user number of the node derivative version to set the scale factor for
    :type versionNumber: int
    :param derivativeNumber: The user number of the node derivative to set the scale factor for
    :type derivativeNumber: int
    :param nodeUserNumber: The user number of the node to set the scale factor for
    :type nodeUserNumber: int
    :param componentNumber: The component number of the field to set the scale factor for
    :type componentNumber: int
    :param scaleFactor: The scale factor of the specified node
    :type scaleFactor: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetNodeScaleFactorSetNum, [regionUserNumber, fieldUserNumber, variableType, versionNumber, derivativeNumber, nodeUserNumber, componentNumber, scaleFactor])


def Field_ParameterSetNodeScaleFactorsGetNum(regionUserNumber, fieldUserNumber, variableType, meshComponentNumber, scaleFactorsSize):
    """Gets the scale factors for all nodes identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the scalefactor for
    :type regionUserNumber: int
    :param fieldUserNumber: The field to get scale factor for
    :type fieldUserNumber: int
    :param variableType: The field variable type to get the scale factor for
    :type variableType: int
    :param meshComponentNumber: The mesh omponent number of the field to set the scale factor for
    :type meshComponentNumber: int
    :param scaleFactorsSize: Size of scaleFactors to allocate.
    :returns: scaleFactors. The scale factors
    :rtype: Array of floats
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetNodeScaleFactorsGetNum, [regionUserNumber, fieldUserNumber, variableType, meshComponentNumber, scaleFactorsSize])


def Field_ParameterSetNodeScaleFactorsSetNum(regionUserNumber, fieldUserNumber, variableType, meshComponentNumber, scaleFactors):
    """Sets the scale factors for all nodes identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to set the scalefactor for
    :type regionUserNumber: int
    :param fieldUserNumber: The field to set scale factor for
    :type fieldUserNumber: int
    :param variableType: The field variable type to set the scale factor for
    :type variableType: int
    :param meshComponentNumber: The mesh omponent number of the field to set the scale factor for
    :type meshComponentNumber: int
    :param scaleFactors: The scale factors
    :type scaleFactors: Array of floats
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetNodeScaleFactorsSetNum, [regionUserNumber, fieldUserNumber, variableType, meshComponentNumber, scaleFactors])


def Field_ParameterSetUpdateConstantDPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value):
    """Updates the given parameter set with the given double precision value for the constant of the field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to update the constant value for the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to update the constant value for the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the constant value for the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the constant value for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param componentNumber: The component number of the field variable to update the constant value for the field parameter set.
    :type componentNumber: int
    :param value: The value to update the field parameter set to.
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateConstantDPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value])


def Field_ParameterSetUpdateConstantIntgNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value):
    """Updates the given parameter set with the given integer value for the constant of the field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to update the constant value for the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to update the constant value for the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the constant value for the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the constant value for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param componentNumber: The component number of the field variable to update the constant value for the field parameter set.
    :type componentNumber: int
    :param value: The value to update the field parameter set to.
    :type value: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateConstantIntgNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value])


def Field_ParameterSetUpdateConstantLNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value):
    """Updates the given parameter set with the given logical value for the constant of the field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to update the constant value for the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to update the constant value for the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the constant value for the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the constant value for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param componentNumber: The component number of the field variable to update the constant value for the field parameter set.
    :type componentNumber: int
    :param value: The value to update the field parameter set to.
    :type value: bool
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateConstantLNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value])


def Field_ParameterSetUpdateConstantSPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value):
    """Updates the given parameter set with the given single precision value for the constant of the field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to update the constant value for the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to update the constant value for the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the constant value for the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the constant value for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param componentNumber: The component number of the field variable to update the constant value for the field parameter set.
    :type componentNumber: int
    :param value: The value to update the field parameter set to.
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateConstantSPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, componentNumber, value])


def Field_ParameterSetUpdateDataPointDPNumberI(parentRegionUserNumber, interfaceUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber, value):
    """Update the given parameter set a double precision value for the specified data point of a field variable component for a field identified by a user number.

    :param parentRegionUserNumber: The user number of the parent region for the interface.
    :type parentRegionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containing the field to update the data point value from the field parameter set.
    :type interfaceUserNumber: int
    :param fieldUserNumber: The user number of the field to update the data point value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the data point value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userDataPointNumber: The user data point number to update the value for
    :type userDataPointNumber: int
    :param componentNumber: The component number of the field variable to update the data point value from the field parameter set.
    :type componentNumber: int
    :param value: The value for the field parameter set to update
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateDataPointDPNumberI, [parentRegionUserNumber, interfaceUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber, value])


def Field_ParameterSetUpdateDataPointDPNumberR(regionUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber, value):
    """Update the given parameter set a double precision value for the specified data point of a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to update the data point value from the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to update the data point value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the data point value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userDataPointNumber: The user data point number to update the value for
    :type userDataPointNumber: int
    :param componentNumber: The component number of the field variable to update the data point value from the field parameter set.
    :type componentNumber: int
    :param value: The value for the field parameter set to update
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateDataPointDPNumberR, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber, value])


def Field_ParameterSetUpdateDataPointIntgNumberI(parentRegionUserNumber, interfaceUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber, value):
    """Update the given parameter set a integer value for the specified data point of a field variable component for a field identified by a user number.

    :param parentRegionUserNumber: The user number of the parent region for the interface.
    :type parentRegionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containing the field to update the data point value from the field parameter set.
    :type interfaceUserNumber: int
    :param fieldUserNumber: The user number of the field to update the data point value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the data point value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userDataPointNumber: The user data point number to update the value for
    :type userDataPointNumber: int
    :param componentNumber: The component number of the field variable to update the data point value from the field parameter set.
    :type componentNumber: int
    :param value: The value for the field parameter set to update
    :type value: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateDataPointIntgNumberI, [parentRegionUserNumber, interfaceUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber, value])


def Field_ParameterSetUpdateDataPointIntgNumberR(regionUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber, value):
    """Update the given parameter set a integer value for the specified data point of a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to update the data point value from the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to update the data point value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the data point value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userDataPointNumber: The user data point number to update the value for
    :type userDataPointNumber: int
    :param componentNumber: The component number of the field variable to update the data point value from the field parameter set.
    :type componentNumber: int
    :param value: The value for the field parameter set to update
    :type value: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateDataPointIntgNumberR, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber, value])


def Field_ParameterSetUpdateDataPointLNumberI(parentRegionUserNumber, interfaceUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber, value):
    """Update the given parameter set a logical value for the specified data point of a field variable component for a field identified by a user number.

    :param parentRegionUserNumber: The user number of the parent region for the interface.
    :type parentRegionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containing the field to update the data point value from the field parameter set.
    :type interfaceUserNumber: int
    :param fieldUserNumber: The user number of the field to update the data point value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the data point value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userDataPointNumber: The user data point number to update the value for
    :type userDataPointNumber: int
    :param componentNumber: The component number of the field variable to update the data point value from the field parameter set.
    :type componentNumber: int
    :param value: The value for the field parameter set to update
    :type value: bool
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateDataPointLNumberI, [parentRegionUserNumber, interfaceUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber, value])


def Field_ParameterSetUpdateDataPointLNumberR(regionUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber, value):
    """Update the given parameter set a logical value for the specified data point of a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to update the data point value from the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to update the data point value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the data point value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userDataPointNumber: The user data point number to update the value for
    :type userDataPointNumber: int
    :param componentNumber: The component number of the field variable to update the data point value from the field parameter set.
    :type componentNumber: int
    :param value: The value for the field parameter set to update
    :type value: bool
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateDataPointLNumberR, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber, value])


def Field_ParameterSetUpdateDataPointSPNumberI(parentRegionUserNumber, interfaceUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber, value):
    """Update the given parameter set a single precision value for the specified data point of a field variable component for a field identified by a user number.

    :param parentRegionUserNumber: The user number of the parent region for the interface.
    :type parentRegionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containing the field to update the data point value from the field parameter set.
    :type interfaceUserNumber: int
    :param fieldUserNumber: The user number of the field to update the data point value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the data point value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userDataPointNumber: The user data point number to update the value for
    :type userDataPointNumber: int
    :param componentNumber: The component number of the field variable to update the data point value from the field parameter set.
    :type componentNumber: int
    :param value: The value for the field parameter set to update
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateDataPointSPNumberI, [parentRegionUserNumber, interfaceUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber, value])


def Field_ParameterSetUpdateDataPointSPNumberR(regionUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber, value):
    """Update the given parameter set a single precision value for the specified data point of a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to update the data point value from the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to update the data point value from the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the data point value from the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the data point value from. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userDataPointNumber: The user data point number to update the value for
    :type userDataPointNumber: int
    :param componentNumber: The component number of the field variable to update the data point value from the field parameter set.
    :type componentNumber: int
    :param value: The value for the field parameter set to update
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateDataPointSPNumberR, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, userDataPointNumber, componentNumber, value])


def Field_ParameterSetUpdateElementDPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber, value):
    """Updates the given parameter set with the given double precision value for the element of the field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to update the element value for the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to update the element value for the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the element value for the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the element value for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userElementNumber: The user element number of the field variable component to update for the field parameter set.
    :type userElementNumber: int
    :param componentNumber: The component number of the field variable to update the element value for the field parameter set.
    :type componentNumber: int
    :param value: The value to update the field parameter set to.
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateElementDPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber, value])


def Field_ParameterSetUpdateElementIntgNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber, value):
    """Updates the given parameter set with the given integer value for the element of the field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to update the element value for the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to update the element value for the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the element value for the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the element value for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userElementNumber: The user element number of the field variable component to update for the field parameter set.
    :type userElementNumber: int
    :param componentNumber: The component number of the field variable to update the element value for the field parameter set.
    :type componentNumber: int
    :param value: The value to update the field parameter set to.
    :type value: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateElementIntgNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber, value])


def Field_ParameterSetUpdateElementLNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber, value):
    """Updates the given parameter set with the given logical value for the element of the field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to update the element value for the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to update the element value for the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the element value for the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the element value for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userElementNumber: The user element number of the field variable component to update for the field parameter set.
    :type userElementNumber: int
    :param componentNumber: The component number of the field variable to update the element value for the field parameter set.
    :type componentNumber: int
    :param value: The value to update the field parameter set to.
    :type value: bool
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateElementLNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber, value])


def Field_ParameterSetUpdateElementSPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber, value):
    """Updates the given parameter set with the given single precision value for the element of the field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to update the element value for the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to update the element value for the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the element value for the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the element value for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param userElementNumber: The user element number of the field variable component to update for the field parameter set.
    :type userElementNumber: int
    :param componentNumber: The component number of the field variable to update the element value for the field parameter set.
    :type componentNumber: int
    :param value: The value to update the field parameter set to.
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateElementSPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, userElementNumber, componentNumber, value])


def Field_ParameterSetUpdateFinishNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType):
    """Finishes the parameter set update for a field variable for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to finish the parameter set update for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to finish the parameter set update for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to finish the parameter set update for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type to finish the update for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateFinishNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType])


def Field_ParameterSetUpdateGaussPointDPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, gaussPointNumber, userElementNumber, componentNumber, value):
    """Updates the given parameter set with the given double precision value for the element Gauss point of the field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to update the Gauss point value for the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to update the Gauss point value for the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the Gauss point value for the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the Gauss point value for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param gaussPointNumber: The user element number of the field variable component to update for the field parameter set.
    :type gaussPointNumber: int
    :param userElementNumber: The user element number of the field variable component to update for the field parameter set.
    :type userElementNumber: int
    :param componentNumber: The component number of the field variable to update the Gauss point value for the field parameter set.
    :type componentNumber: int
    :param value: The value for the field parameter set to update.
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateGaussPointDPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, gaussPointNumber, userElementNumber, componentNumber, value])


def Field_ParameterSetUpdateGaussPointIntgNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, gaussPointNumber, userElementNumber, componentNumber, value):
    """Updates the given parameter set with the given integer value for the element Gauss point of the field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to update the Gauss point value for the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to update the Gauss point value for the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the Gauss point value for the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the Gauss point value for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param gaussPointNumber: The user element number of the field variable component to update for the field parameter set.
    :type gaussPointNumber: int
    :param userElementNumber: The user element number of the field variable component to update for the field parameter set.
    :type userElementNumber: int
    :param componentNumber: The component number of the field variable to update the Gauss point value for the field parameter set.
    :type componentNumber: int
    :param value: The value for the field parameter set to update.
    :type value: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateGaussPointIntgNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, gaussPointNumber, userElementNumber, componentNumber, value])


def Field_ParameterSetUpdateGaussPointLNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, gaussPointNumber, userElementNumber, componentNumber, value):
    """Updates the given parameter set with the given logical value for the element Gauss point of the field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to update the Gauss point value for the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to update the Gauss point value for the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the Gauss point value for the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the Gauss point value for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param gaussPointNumber: The user element number of the field variable component to update for the field parameter set.
    :type gaussPointNumber: int
    :param userElementNumber: The user element number of the field variable component to update for the field parameter set.
    :type userElementNumber: int
    :param componentNumber: The component number of the field variable to update the Gauss point value for the field parameter set.
    :type componentNumber: int
    :param value: The value for the field parameter set to update.
    :type value: bool
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateGaussPointLNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, gaussPointNumber, userElementNumber, componentNumber, value])


def Field_ParameterSetUpdateGaussPointSPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, gaussPointNumber, userElementNumber, componentNumber, value):
    """Updates the given parameter set with the given single precision value for the element Gauss point of the field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to update the Gauss point value for the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to update the Gauss point value for the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the Gauss point value for the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the Gauss point value for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param gaussPointNumber: The user element number of the field variable component to update for the field parameter set.
    :type gaussPointNumber: int
    :param userElementNumber: The user element number of the field variable component to update for the field parameter set.
    :type userElementNumber: int
    :param componentNumber: The component number of the field variable to update the Gauss point value for the field parameter set.
    :type componentNumber: int
    :param value: The value for the field parameter set to update.
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateGaussPointSPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, gaussPointNumber, userElementNumber, componentNumber, value])


def Field_ParameterSetUpdateNodeDPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value):
    """Updates the given parameter set with the given double precision value for the node and derivative of the field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to update the nodal value for the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to update the nodal value for the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the nodal value for the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the nodal value for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param versionNumber: The derivative version number of the field variable component to update for the field parameter set.
    :type versionNumber: int
    :param derivativeNumber: The derivative number of the field variable component to update for the field parameter set.
    :type derivativeNumber: int
    :param userNodeNumber: The user node number of the field variable component to update for the field parameter set.
    :type userNodeNumber: int
    :param componentNumber: The component number of the field variable to update the nodal value for the field parameter set.
    :type componentNumber: int
    :param value: The value to update the field parameter set to.
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateNodeDPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value])


def Field_ParameterSetUpdateNodeIntgNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value):
    """Updates the given parameter set with the given integer value for the node and derivative of the field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to update the nodal value for the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to update the nodal value for the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the nodal value for the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the nodal value for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param versionNumber: The derivative version number of the field variable component to update for the field parameter set.
    :type versionNumber: int
    :param derivativeNumber: The derivative number of the field variable component to update for the field parameter set.
    :type derivativeNumber: int
    :param userNodeNumber: The user node number of the field variable component to update for the field parameter set.
    :type userNodeNumber: int
    :param componentNumber: The component number of the field variable to update the nodal value for the field parameter set.
    :type componentNumber: int
    :param value: The value to update the field parameter set to.
    :type value: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateNodeIntgNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value])


def Field_ParameterSetUpdateNodeLNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value):
    """Updates the given parameter set with the given logical value for the node and derivative of the field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to update the nodal value for the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to update the nodal value for the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the nodal value for the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the nodal value for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param versionNumber: The derivative version number of the field variable component to update for the field parameter set.
    :type versionNumber: int
    :param derivativeNumber: The derivative number of the field variable component to update for the field parameter set.
    :type derivativeNumber: int
    :param userNodeNumber: The user node number of the field variable component to update for the field parameter set.
    :type userNodeNumber: int
    :param componentNumber: The component number of the field variable to update the nodal value for the field parameter set.
    :type componentNumber: int
    :param value: The value to update the field parameter set to.
    :type value: bool
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateNodeLNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value])


def Field_ParameterSetUpdateNodeSPNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value):
    """Updates the given parameter set with the given single precision value for the node and derivative of the field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to update the nodal value for the field parameter set.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to update the nodal value for the field parameter set.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to update the nodal value for the field parameter set. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type of the field to update the nodal value for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :param versionNumber: The derivative version number of the field variable component to update for the field parameter set.
    :type versionNumber: int
    :param derivativeNumber: The derivative number of the field variable component to update for the field parameter set.
    :type derivativeNumber: int
    :param userNodeNumber: The user node number of the field variable component to update for the field parameter set.
    :type userNodeNumber: int
    :param componentNumber: The component number of the field variable to update the nodal value for the field parameter set.
    :type componentNumber: int
    :param value: The value to update the field parameter set to.
    :type value: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateNodeSPNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType, versionNumber, derivativeNumber, userNodeNumber, componentNumber, value])


def Field_ParameterSetUpdateStartNum(regionUserNumber, fieldUserNumber, variableType, fieldSetType):
    """Starts the parameter set update for a field variable for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to start the parameter set update for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to start the parameter set update for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to start the parameter set update for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param fieldSetType: The parameter set type to start the update for. Must be a value from the FieldParameterSetTypes enum.
    :type fieldSetType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParameterSetUpdateStartNum, [regionUserNumber, fieldUserNumber, variableType, fieldSetType])


def Field_ParametersToFieldParametersComponentCopyNum(fromRegionUserNumber, fromFieldUserNumber, fromVariableType, fromParameterSetType, fromComponentNumber, toRegionUserNumber, toFieldUserNumber, toVariableType, toParameterSetType, toComponentNumber):
    """Copy the parameters from the parameter set of a component of a field variable to the paramters of a parameter set of
    a component of another field variable, where both fields are identified by user numbers.

    :param fromRegionUserNumber: The user number of the region containing the field to copy from
    :type fromRegionUserNumber: int
    :param fromFieldUserNumber: The field to copy from
    :type fromFieldUserNumber: int
    :param fromVariableType: The field variable type to copy from
    :type fromVariableType: int
    :param fromParameterSetType: The field parameter set type to copy from
    :type fromParameterSetType: int
    :param fromComponentNumber: The field variable component number to copy from
    :type fromComponentNumber: int
    :param toRegionUserNumber: The user number of the region containing the field to copy to
    :type toRegionUserNumber: int
    :param toFieldUserNumber: The field to copy to
    :type toFieldUserNumber: int
    :param toVariableType: The field variable type to copy to
    :type toVariableType: int
    :param toParameterSetType: The parameter set type to copy to
    :type toParameterSetType: int
    :param toComponentNumber: The field variable component to copy to
    :type toComponentNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ParametersToFieldParametersComponentCopyNum, [fromRegionUserNumber, fromFieldUserNumber, fromVariableType, fromParameterSetType, fromComponentNumber, toRegionUserNumber, toFieldUserNumber, toVariableType, toParameterSetType, toComponentNumber])


def Field_PositionNormalTangentCalculateNodeNum(regionUserNumber, fieldUserNumber, variableType, componentNumber, localNodeNumber, positionSize, normalSize, tangentsSizes):
    """Returns the interpolation type for a field variable component for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the interpolation type for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the interpolation type for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the interpolation type for. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param componentNumber: The component number of the field variable to get the interpolation type for.
    :type componentNumber: int
    :param localNodeNumber: The local node number of the field variable to get the data type for.
    :type localNodeNumber: int
    :param positionSize: Size of position to allocate.
    :param normalSize: Size of normal to allocate.
    :param tangentsSizes: Tuple of dimensions of tangents to allocate, with length 2.
    :returns: (Actual useful outputs, Actual useful outputs, Actual useful outputs)
    :rtype: tuple. (Array of floats, Array of floats, 2d array of floats)
    """

    return _wrap_routine(_iron_python.cmfe_Field_PositionNormalTangentCalculateNodeNum, [regionUserNumber, fieldUserNumber, variableType, componentNumber, localNodeNumber, positionSize, normalSize, tangentsSizes])


def Field_ScalingTypeGetNum(regionUserNumber, fieldUserNumber):
    """Returns the scaling type for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the scaling type for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the scaling type for.
    :type fieldUserNumber: int
    :returns: scalingType. The field scaling type. Will be a value from the FieldScalingTypes enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Field_ScalingTypeGetNum, [regionUserNumber, fieldUserNumber])


def Field_ScalingTypeSetNum(regionUserNumber, fieldUserNumber, scalingType):
    """Sets/changes the scaling type for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to set the scaling type for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to set the scaling type for.
    :type fieldUserNumber: int
    :param scalingType: The field scaling type to set. Must be a value from the FieldScalingTypes enum.
    :type scalingType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_ScalingTypeSetNum, [regionUserNumber, fieldUserNumber, scalingType])


def Field_TypeGetNum(regionUserNumber, fieldUserNumber):
    """Returns the field type for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the field type for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the field type for.
    :type fieldUserNumber: int
    :returns: fieldType. The field type. Will be a value from the FieldTypes enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Field_TypeGetNum, [regionUserNumber, fieldUserNumber])


def Field_TypeSetNum(regionUserNumber, fieldUserNumber, fieldType):
    """Sets/changes the field type for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to set the field type for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to set the field type for.
    :type fieldUserNumber: int
    :param fieldType: The field type to set. Must be a value from the FieldTypes enum.
    :type fieldType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_TypeSetNum, [regionUserNumber, fieldUserNumber, fieldType])


def Field_VariableLabelGetNum(regionUserNumber, fieldUserNumber, variableType):
    """Returns the character string label for a field variable for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the label for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the label for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to get the field variable label. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :returns: label. The field variable label.
    :rtype: string
    """

    return _wrap_routine(_iron_python.cmfe_Field_VariableLabelGetNum, [regionUserNumber, fieldUserNumber, variableType])


def Field_VariableLabelSetNum(regionUserNumber, fieldUserNumber, variableType, label):
    """Sets/changes the character string label for a field variable for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to set the label for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to set the label for.
    :type fieldUserNumber: int
    :param variableType: The variable type of the field to set the field variable label. Must be a value from the FieldVariableTypes enum.
    :type variableType: int
    :param label: The field variable label to set.
    :type label: string
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_VariableLabelSetNum, [regionUserNumber, fieldUserNumber, variableType, label])


def Field_VariableTypesGetNum(regionUserNumber, fieldUserNumber, variableTypesSize):
    """Returns the field variable types for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to get the field variable types for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to get the field variable types for.
    :type fieldUserNumber: int
    :param variableTypesSize: Size of variableTypes to allocate.
    :returns: variableTypes. variableTypes(variable_idx). On return, the field variable types for the variable_idx'th field variable. Will be a value from the FieldVariableTypes enum.
    :rtype: Array of ints
    """

    return _wrap_routine(_iron_python.cmfe_Field_VariableTypesGetNum, [regionUserNumber, fieldUserNumber, variableTypesSize])


def Field_VariableTypesSetNum(regionUserNumber, fieldUserNumber, variableTypes):
    """Sets/changes the field variable types for a field identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to set the field variable types for.
    :type regionUserNumber: int
    :param fieldUserNumber: The user number of the field to set the field variable types for.
    :type fieldUserNumber: int
    :param variableTypes: variableTypes(variable_idx). The field variable types for the variable_idx'th field variable to set. Must be a value from the FieldVariableTypes enum.
    :type variableTypes: Array of ints
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Field_VariableTypesSetNum, [regionUserNumber, fieldUserNumber, variableTypes])


def Finalise():
    """Finalises CMISS.

    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Finalise, [])


def GeneratedMesh_BaseVectorsSetNum(regionUserNumber, generatedMeshUserNumber, baseVectors):
    """Sets/changes the base vectors for a generated mesh on a region identified by a user number.

    :param regionUserNumber: The user number of the region containing the generated mesh to set the base vectors for.
    :type regionUserNumber: int
    :param generatedMeshUserNumber: The user number of the generated mesh to set the base vectors for.
    :type generatedMeshUserNumber: int
    :param baseVectors: baseVectors(coordinate_idx,xi_idx). The base vectors to set.
    :type baseVectors: 2d array of floats
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_GeneratedMesh_BaseVectorsSetNum, [regionUserNumber, generatedMeshUserNumber, baseVectors])


def GeneratedMesh_BasisGetNum(regionUserNumber, generatedMeshUserNumber, basisUserNumbers):
    """Returns the basis for a generated mesh on a region identified by a user number.

    :param regionUserNumber: The user number of the region containing the generated mesh to get the basis for.
    :type regionUserNumber: int
    :param generatedMeshUserNumber: The user number of the generated mesh to get the basis for.
    :type generatedMeshUserNumber: int
    :param basisUserNumbers: On return, the user numbers of the bases.
    :type basisUserNumbers: Array of ints
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_GeneratedMesh_BasisGetNum, [regionUserNumber, generatedMeshUserNumber, basisUserNumbers])


def GeneratedMesh_BasisSetNum(regionUserNumber, generatedMeshUserNumber, basisUserNumbers):
    """Sets/changes the basis for a generated mesh on a region identified by a user number.

    :param regionUserNumber: The user number of the region containing the generated mesh to set the basis for.
    :type regionUserNumber: int
    :param generatedMeshUserNumber: The user number of the generated mesh to set the basis for.
    :type generatedMeshUserNumber: int
    :param basisUserNumbers: The user numbers of the bases to set.
    :type basisUserNumbers: Array of ints
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_GeneratedMesh_BasisSetNum, [regionUserNumber, generatedMeshUserNumber, basisUserNumbers])


def GeneratedMesh_CreateFinishNum(regionUserNumber, generatedMeshUserNumber, meshUserNumber):
    """Finishes the creation of a generated mesh on a region identified by a user number.

    :param regionUserNumber: The user number of the region containing the generated mesh to finish the creation of.
    :type regionUserNumber: int
    :param generatedMeshUserNumber: The user number of the generated mesh to finish the creation of.
    :type generatedMeshUserNumber: int
    :param meshUserNumber: The user number of the mesh to generate.
    :type meshUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_GeneratedMesh_CreateFinishNum, [regionUserNumber, generatedMeshUserNumber, meshUserNumber])


def GeneratedMesh_CreateStartNum(generatedMeshUserNumber, regionUserNumber):
    """Starts the creation of a generated mesh on a region identified by a user number.

    :param generatedMeshUserNumber: The user number of the generated mesh to create.
    :type generatedMeshUserNumber: int
    :param regionUserNumber: The user number of the region to create the generated mesh in.
    :type regionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_GeneratedMesh_CreateStartNum, [generatedMeshUserNumber, regionUserNumber])


def GeneratedMesh_DestroyNum(regionUserNumber, generatedMeshUserNumber):
    """Destroys a generated mesh on a region identified by a user number.

    :param regionUserNumber: The user number of the region containing the generated mesh to destroy.
    :type regionUserNumber: int
    :param generatedMeshUserNumber: The user number of the generated mesh to destroy.
    :type generatedMeshUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_GeneratedMesh_DestroyNum, [regionUserNumber, generatedMeshUserNumber])


def GeneratedMesh_ExtentGetNum(regionUserNumber, generatedMeshUserNumber, extentSize):
    """Returns the extent for a generated mesh on a region identified by a user number.

    :param regionUserNumber: The user number of the region containing the generated mesh to get the extent for.
    :type regionUserNumber: int
    :param generatedMeshUserNumber: The user number of the generated mesh to get the extent for.
    :type generatedMeshUserNumber: int
    :param extentSize: Size of extent to allocate.
    :returns: extent. extent(i). On return, the extent for the i'th dimension of the generated mesh.
    :rtype: Array of floats
    """

    return _wrap_routine(_iron_python.cmfe_GeneratedMesh_ExtentGetNum, [regionUserNumber, generatedMeshUserNumber, extentSize])


def GeneratedMesh_ExtentSetNum(regionUserNumber, generatedMeshUserNumber, extent):
    """Sets/changes the extent for a generated mesh on a region identified by a user number.

    :param regionUserNumber: The user number of the region containing the generated mesh to set the extent for.
    :type regionUserNumber: int
    :param generatedMeshUserNumber: The user number of the generated mesh to set the extent for.
    :type generatedMeshUserNumber: int
    :param extent: extent(i). The extent for the i'th dimension of the generated mesh to set.
    :type extent: Array of floats
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_GeneratedMesh_ExtentSetNum, [regionUserNumber, generatedMeshUserNumber, extent])


def GeneratedMesh_GeometricParametersCalculateNum(regionUserNumber, generatedMeshUserNumber, fieldUserNumber):
    """Calculates and sets the geometric field parameters for a generated mesh identified by a user number.

    :param regionUserNumber: The user number of the region containing the field to calculate the geometric parameters for.
    :type regionUserNumber: int
    :param generatedMeshUserNumber: The user number of the generated mesh to calculate the geometric parameters for.
    :type generatedMeshUserNumber: int
    :param fieldUserNumber: The user number of the field to calculate the geometric parameters for.
    :type fieldUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_GeneratedMesh_GeometricParametersCalculateNum, [regionUserNumber, generatedMeshUserNumber, fieldUserNumber])


def GeneratedMesh_NumberOfElementsGetNum(regionUserNumber, generatedMeshUserNumber, numberOfElementsSize):
    """Returns the number of elements for a generated mesh on a region identified by a user number.

    :param regionUserNumber: The user number of the region containing the generated mesh to get the number of elements for.
    :type regionUserNumber: int
    :param generatedMeshUserNumber: The user number of the generated mesh to get the number of elements for.
    :type generatedMeshUserNumber: int
    :param numberOfElementsSize: Size of numberOfElements to allocate.
    :returns: numberOfElements. numberOfElements(i). On return, the number of elements in the i'th dimension of the generated mesh.
    :rtype: Array of ints
    """

    return _wrap_routine(_iron_python.cmfe_GeneratedMesh_NumberOfElementsGetNum, [regionUserNumber, generatedMeshUserNumber, numberOfElementsSize])


def GeneratedMesh_NumberOfElementsSetNum(regionUserNumber, generatedMeshUserNumber, numberOfElements):
    """Sets/changes the number of elements for a generated mesh on a region identified by a user number.

    :param regionUserNumber: The user number of the region containing the generated mesh to set the number of elements for.
    :type regionUserNumber: int
    :param generatedMeshUserNumber: The user number of the generated mesh to set the number of elements for.
    :type generatedMeshUserNumber: int
    :param numberOfElements: numberOfElements(i). The number of elements in the i'th dimension of the generated mesh to set.
    :type numberOfElements: Array of ints
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_GeneratedMesh_NumberOfElementsSetNum, [regionUserNumber, generatedMeshUserNumber, numberOfElements])


def GeneratedMesh_OriginGetNum(regionUserNumber, generatedMeshUserNumber, originSize):
    """Returns the origin of a generated mesh on a region identified by a user number.

    :param regionUserNumber: The user number of the region containing the generated mesh to get the origin for.
    :type regionUserNumber: int
    :param generatedMeshUserNumber: The user number of the generated mesh to get the origin for.
    :type generatedMeshUserNumber: int
    :param originSize: Size of origin to allocate.
    :returns: origin. origin(i). On return, the origin of the i'th dimension of the generated mesh.
    :rtype: Array of floats
    """

    return _wrap_routine(_iron_python.cmfe_GeneratedMesh_OriginGetNum, [regionUserNumber, generatedMeshUserNumber, originSize])


def GeneratedMesh_OriginSetNum(regionUserNumber, generatedMeshUserNumber, origin):
    """Sets/changes the origin of a generated mesh on a region identified by a user number.

    :param regionUserNumber: The user number of the region containing the generated mesh to set the origin for.
    :type regionUserNumber: int
    :param generatedMeshUserNumber: The user number of the generated mesh to set the origin for.
    :type generatedMeshUserNumber: int
    :param origin: origin(i). The origin of the i'th dimension of the generated mesh to set.
    :type origin: Array of floats
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_GeneratedMesh_OriginSetNum, [regionUserNumber, generatedMeshUserNumber, origin])


def GeneratedMesh_TypeGetNum(regionUserNumber, generatedMeshUserNumber):
    """Returns the type of a generated mesh on a region identified by a user number.

    :param regionUserNumber: The user number of the region containing the generated mesh to get the type for.
    :type regionUserNumber: int
    :param generatedMeshUserNumber: The user number of the generated mesh to get the type for.
    :type generatedMeshUserNumber: int
    :returns: generatedMeshType. The type of the generated mesh. Will be a value from the GeneratedMeshTypes enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_GeneratedMesh_TypeGetNum, [regionUserNumber, generatedMeshUserNumber])


def GeneratedMesh_TypeSetNum(regionUserNumber, generatedMeshUserNumber, generatedMeshType):
    """Sets/changes the type of a generated mesh on a region identified by a user number.

    :param regionUserNumber: The user number of the region containing the generated mesh to set the type for.
    :type regionUserNumber: int
    :param generatedMeshUserNumber: The user number of the generated mesh to set the type for.
    :type generatedMeshUserNumber: int
    :param generatedMeshType: The type of the generated mesh to set. Must be a value from the GeneratedMeshTypes enum.
    :type generatedMeshType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_GeneratedMesh_TypeSetNum, [regionUserNumber, generatedMeshUserNumber, generatedMeshType])


def InitialiseNum():
    """Initialises CMISS returning a user number to the world coordinate system and region.

    :returns: (The world coordinate system user number, The world region user number)
    :rtype: tuple. (int, int)
    """

    return _wrap_routine(_iron_python.cmfe_InitialiseNum, [])


def Initialise(worldCoordinateSystem, worldRegion):
    """Initialises CMISS returning a pointer to the world coordinate system and region.

    :param worldCoordinateSystem: On return, the world coordinate system.
    :type worldCoordinateSystem: CoordinateSystem
    :param worldRegion: On return, the world region.
    :type worldRegion: Region
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Initialise, [worldCoordinateSystem, worldRegion])


def InterfaceCondition_CreateFinishNum(regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber):
    """Finishes the creation of an interface condition identified by an user number.

    :param regionUserNumber: The user number of the region containing the interface to finish the interface condition for.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containg the interface condition to finish creating for.
    :type interfaceUserNumber: int
    :param interfaceConditionUserNumber: The user number of the interface condition to finish creating.
    :type interfaceConditionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceCondition_CreateFinishNum, [regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber])


def InterfaceCondition_CreateStartNum(interfaceConditionUserNumber, regionUserNumber, interfaceUserNumber, geometricFieldUserNumber):
    """Starts the creation of an interface condition identified by a user number.

    :param interfaceConditionUserNumber: The user number of the interface condition to start the creation of.
    :type interfaceConditionUserNumber: int
    :param regionUserNumber: The user number of the region containing the interface to start the creation of the interface condition for.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containing the interface condition to start the creation of.
    :type interfaceUserNumber: int
    :param geometricFieldUserNumber: The user number of the geometric field on the interface for the interface condition.
    :type geometricFieldUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceCondition_CreateStartNum, [interfaceConditionUserNumber, regionUserNumber, interfaceUserNumber, geometricFieldUserNumber])


def InterfaceCondition_DependentVariableAddNum(interfaceRegionUserNumber, interfaceUserNumber, interfaceConditionUserNumber, meshIndex, equationsSetRegionUserNumber, equationsSetUserNumber, variableType):
    """Adds a dependent variable to an interface condition identified by a user number.

    :param interfaceRegionUserNumber: The user number of the region containing the interface containing the interface condition to add the dependent variable for.
    :type interfaceRegionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containing the interface condition to add the dependent variable for.
    :type interfaceUserNumber: int
    :param interfaceConditionUserNumber: The user number of the interface condition to add the dependent variable for.
    :type interfaceConditionUserNumber: int
    :param meshIndex: The mesh index of the interface condition interface for which the dependent variable is added.
    :type meshIndex: int
    :param equationsSetRegionUserNumber: The user number of the region containing the equations set containing the dependent field varible to add.
    :type equationsSetRegionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set containing the dependent field to add the variable for.
    :type equationsSetUserNumber: int
    :param variableType: The variable type of the dependent variable to add.
    :type variableType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceCondition_DependentVariableAddNum, [interfaceRegionUserNumber, interfaceUserNumber, interfaceConditionUserNumber, meshIndex, equationsSetRegionUserNumber, equationsSetUserNumber, variableType])


def InterfaceCondition_DestroyNum(regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber):
    """Destroys an interface condition identified by a user number.

    :param regionUserNumber: The user number of the region containing the interface containing the interface condition to destroy.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containing the interface condition to destroy.
    :type interfaceUserNumber: int
    :param interfaceConditionUserNumber: The user number of the interface condition to destroy.
    :type interfaceConditionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceCondition_DestroyNum, [regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber])


def InterfaceCondition_EquationsCreateFinishNum(regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber):
    """Finishes the creation of equations for an interface condition identified by an user number.

    :param regionUserNumber: The user number of the region containing the interface to finish the interface equations for.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containg the interface condition to finish the interface equations for.
    :type interfaceUserNumber: int
    :param interfaceConditionUserNumber: The user number of the interface condition to finish creating the interface equations for.
    :type interfaceConditionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceCondition_EquationsCreateFinishNum, [regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber])


def InterfaceCondition_EquationsCreateStartNum(regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber):
    """Starts the creation of interface equations for an interface condition identified by a user number.

    :param regionUserNumber: The user number of the region containing the interface and interface condition to start the creation of the interface equations for.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containing the interface condition to start the creation of the interface equations for.
    :type interfaceUserNumber: int
    :param interfaceConditionUserNumber: The user number of the interface condition to start the creation of the interface equations for.
    :type interfaceConditionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceCondition_EquationsCreateStartNum, [regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber])


def InterfaceCondition_EquationsDestroyNum(regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber):
    """Destroys interface equations for an interface condition identified by a user number.

    :param regionUserNumber: The user number of the region containing the interface and interface condition to destroy the interface equations for.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containing the interface condition to destroy the interface equations for.
    :type interfaceUserNumber: int
    :param interfaceConditionUserNumber: The user number of the interface condition to destroy the interface equations for.
    :type interfaceConditionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceCondition_EquationsDestroyNum, [regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber])


def InterfaceCondition_IntegrationTypeGetNum(regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber):
    """Returns the integration type for an interface condition identified by a user number.

    :param regionUserNumber: The user number of the region containing the interface containing the interface condition to get the method for.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containing the interface condition to get the method for.
    :type interfaceUserNumber: int
    :param interfaceConditionUserNumber: The user number of the interface condition to get the method for.
    :type interfaceConditionUserNumber: int
    :returns: interfaceConditionIntegrationType. The interface condition integration type. Will be a value from the InterfaceConditionIntegrationTypes enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceCondition_IntegrationTypeGetNum, [regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber])


def InterfaceCondition_IntegrationTypeSetNum(regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber, interfaceConditionIntegrationType):
    """Sets/changes the integration type for an interface condition identified by a user number.

    :param regionUserNumber: The user number of the region containing the interface containing the interface condition to set the method for.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containing the interface condition to set the method for.
    :type interfaceUserNumber: int
    :param interfaceConditionUserNumber: The user number of the interface condition to set the method for.
    :type interfaceConditionUserNumber: int
    :param interfaceConditionIntegrationType: On return, the interface condition integration type. Must be a value from the InterfaceConditionIntegrationTypes enum.
    :type interfaceConditionIntegrationType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceCondition_IntegrationTypeSetNum, [regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber, interfaceConditionIntegrationType])


def InterfaceCondition_LagrangeFieldCreateFinishNum(regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber):
    """Finishes the creation of a Lagrange Multiplier Field for an interface condition identified by an user number.

    :param regionUserNumber: The user number of the region containing the interface and interface condition to finish the Lagrange multiplier field for.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containg the interface condition to finish the Lagrange multiplier field for.
    :type interfaceUserNumber: int
    :param interfaceConditionUserNumber: The user number of the interface condition to finish creating the Lagrange multiplier field for.
    :type interfaceConditionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceCondition_LagrangeFieldCreateFinishNum, [regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber])


def InterfaceCondition_LagrangeFieldCreateStartNum(regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber, lagrangeFieldUserNumber):
    """Starts the creation of a Lagrange multiplier field for an interface condition identified by a user number.

    :param regionUserNumber: The user number of the region containing the interface and interface condition to start the creation of the Lagrange multiplier field for.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containing the interface condition to start the creation of the Lagrange multiplier field for.
    :type interfaceUserNumber: int
    :param interfaceConditionUserNumber: The user number of the interface condition to start the creation of the Lagrange multiplier field for.
    :type interfaceConditionUserNumber: int
    :param lagrangeFieldUserNumber: The user number of the Lagrange field.
    :type lagrangeFieldUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceCondition_LagrangeFieldCreateStartNum, [regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber, lagrangeFieldUserNumber])


def InterfaceCondition_MethodGetNum(regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber):
    """Returns the method for an interface condition identified by a user number.

    :param regionUserNumber: The user number of the region containing the interface containing the interface condition to get the method for.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containing the interface condition to get the method for.
    :type interfaceUserNumber: int
    :param interfaceConditionUserNumber: The user number of the interface condition to get the method for.
    :type interfaceConditionUserNumber: int
    :returns: interfaceConditionMethod. The interface condition method. Will be a value from the InterfaceConditionMethods enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceCondition_MethodGetNum, [regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber])


def InterfaceCondition_MethodSetNum(regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber, interfaceConditionMethod):
    """Sets/changes the method for an interface condition identified by a user number.

    :param regionUserNumber: The user number of the region containing the interface containing the interface condition to set the method for.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containing the interface condition to set the method for.
    :type interfaceUserNumber: int
    :param interfaceConditionUserNumber: The user number of the interface condition to set the method for.
    :type interfaceConditionUserNumber: int
    :param interfaceConditionMethod: The interface condition method to set. Must be a value from the InterfaceConditionMethods enum.
    :type interfaceConditionMethod: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceCondition_MethodSetNum, [regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber, interfaceConditionMethod])


def InterfaceCondition_OperatorGetNum(regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber):
    """Returns the operator for an interface condition identified by a user number.

    :param regionUserNumber: The user number of the region containing the interface containing the interface condition to get the operator for.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containing the interface condition to get the operator for.
    :type interfaceUserNumber: int
    :param interfaceConditionUserNumber: The user number of the interface condition to get the operator for.
    :type interfaceConditionUserNumber: int
    :returns: interfaceConditionOperator. The interface condition operator. Will be a value from the InterfaceConditionOperators enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceCondition_OperatorGetNum, [regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber])


def InterfaceCondition_OperatorSetNum(regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber, interfaceConditionOperator):
    """Sets/changes the operator for an interface condition identified by a user number.

    :param regionUserNumber: The user number of the region containing the interface containing the interface condition to set the operator for.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containing the interface condition to set the operator for.
    :type interfaceUserNumber: int
    :param interfaceConditionUserNumber: The user number of the interface condition to set the operator for.
    :type interfaceConditionUserNumber: int
    :param interfaceConditionOperator: The interface condition operator to set. Must be a value from the InterfaceConditionOperators enum.
    :type interfaceConditionOperator: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceCondition_OperatorSetNum, [regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber, interfaceConditionOperator])


def InterfaceCondition_PenaltyFieldCreateFinishNum(RegionUserNumber, InterfaceUserNumber, InterfaceConditionUserNumber):
    """Finishes the creation of a penalty Field for an interface condition identified by an user number.

    :param RegionUserNumber: The user number of the region containing the interface and interface condition to finish the penalty field for.
    :type RegionUserNumber: int
    :param InterfaceUserNumber: The user number of the interface containg the interface condition to finish the penalty  field for.
    :type InterfaceUserNumber: int
    :param InterfaceConditionUserNumber: The user number of the interface condition to finish creating the penalty field for.
    :type InterfaceConditionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceCondition_PenaltyFieldCreateFinishNum, [RegionUserNumber, InterfaceUserNumber, InterfaceConditionUserNumber])


def InterfaceCondition_PenaltyFieldCreateStartNum(RegionUserNumber, InterfaceUserNumber, InterfaceConditionUserNumber, PenaltyFieldUserNumber):
    """Starts the creation of a penalty field for an interface condition identified by a user number.

    :param RegionUserNumber: The user number of the region containing the interface and interface condition to start the creation of the penalty field for.
    :type RegionUserNumber: int
    :param InterfaceUserNumber: The user number of the interface containing the interface condition to start the creation of the penalty field for.
    :type InterfaceUserNumber: int
    :param InterfaceConditionUserNumber: The user number of the interface condition to start the creation of the penalty field for.
    :type InterfaceConditionUserNumber: int
    :param PenaltyFieldUserNumber: The user number of the penalty field.
    :type PenaltyFieldUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceCondition_PenaltyFieldCreateStartNum, [RegionUserNumber, InterfaceUserNumber, InterfaceConditionUserNumber, PenaltyFieldUserNumber])


def InterfaceEquations_OutputTypeGetNum(regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber):
    """Returns the output type for an interface equations identified by a user number.

    :param regionUserNumber: The user number of the region containing the interface, interface condition and interface equations to get the output type for.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface, interface condition and interface equations to get the ouput type for.
    :type interfaceUserNumber: int
    :param interfaceConditionUserNumber: The user number of the interface condition and interface equation to get the output type for.
    :type interfaceConditionUserNumber: int
    :returns: outputType. The interface equations output type. Will be a value from the EquationsOutputType enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceEquations_OutputTypeGetNum, [regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber])


def InterfaceEquations_OutputTypeSetNum(regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber, outputType):
    """Sets/changes the output type for an interface equations identified by a user number.

    :param regionUserNumber: The user number of the region containing the interface, interface condition and interface equations to set the output type for.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface, interface condition and interface equations to set the output type for.
    :type interfaceUserNumber: int
    :param interfaceConditionUserNumber: The user number of the interface condition and interface equations to set the output type for.
    :type interfaceConditionUserNumber: int
    :param outputType: The interface equations output type to set. Must be a value from the EquationsOutputTypes enum.
    :type outputType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceEquations_OutputTypeSetNum, [regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber, outputType])


def InterfaceEquations_SparsityGetNum(regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber):
    """Returns the sparsity type for an interface equations identified by a user number.

    :param regionUserNumber: The user number of the region containing the interface, interface condition and interface equations to get the sparsity type for.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface, interface condition and interface equations to get the sparsity type for.
    :type interfaceUserNumber: int
    :param interfaceConditionUserNumber: The user number of the interface condition and interface equation to get the sparsity type for.
    :type interfaceConditionUserNumber: int
    :returns: sparsityType. The interface equations sparsity type. Will be a value from the EquationsSparsityType enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceEquations_SparsityGetNum, [regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber])


def InterfaceEquations_SparsitySetNum(regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber, sparsityType):
    """Sets/changes the sparsity type for an interface equations identified by a user number.

    :param regionUserNumber: The user number of the region containing the interface, interface condition and interface equations to set the sparsity type for.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface, interface condition and interface equations to set the sparsity type for.
    :type interfaceUserNumber: int
    :param interfaceConditionUserNumber: The user number of the interface condition and interface equations to set the sparsity type for.
    :type interfaceConditionUserNumber: int
    :param sparsityType: The interface equations sparsity type to set. Must be a value from the EquationsSparsityTypes enum.
    :type sparsityType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceEquations_SparsitySetNum, [regionUserNumber, interfaceUserNumber, interfaceConditionUserNumber, sparsityType])


def InterfaceMatrices_TimeDependenceTypeGet(interfaceCondition, interfaceMatrixIndex, hasTranspose, timeDependenceTypesSize):
    """Get the time dependence type of interface matrices

    :param interfaceCondition: The interface condition to add.
    :type interfaceCondition: InterfaceCondition
    :param interfaceMatrixIndex:
    :type interfaceMatrixIndex: int
    :param hasTranspose:
    :type hasTranspose: bool
    :param timeDependenceTypesSize: Size of timeDependenceTypes to allocate.
    :returns: timeDependenceTypes. Time dependence types for the given interface matrix and it's transpose (if any). \see INTERFACE_MATRICES_ROUTINES_InterfaceMatricesTimeDependenceTypes,INTERFACE_MATRICES_ROUTINES
    :rtype: Array of ints
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceMatrices_TimeDependenceTypeGet, [interfaceCondition, interfaceMatrixIndex, hasTranspose, timeDependenceTypesSize])


def InterfaceMatrices_TimeDependenceTypeSet(interfaceCondition, interfaceMatrixIndex, hasTranspose, timeDependenceTypes):
    """Set the time dependence type of interface matrices

    :param interfaceCondition: The interface condition to add.
    :type interfaceCondition: InterfaceCondition
    :param interfaceMatrixIndex:
    :type interfaceMatrixIndex: int
    :param hasTranspose:
    :type hasTranspose: bool
    :param timeDependenceTypes: Time dependence types for the given interface matrix and it's transpose (if any). \see INTERFACE_MATRICES_ROUTINES_InterfaceMatricesTimeDependenceTypes,INTERFACE_MATRICES_ROUTINES
    :type timeDependenceTypes: Array of ints
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceMatrices_TimeDependenceTypeSet, [interfaceCondition, interfaceMatrixIndex, hasTranspose, timeDependenceTypes])


def InterfaceMeshConnectivity_BasisSetNum(regionUserNumber, interfaceUserNumber, interfaceBasisNumber):
    """:param regionUserNumber: The user number of the region containing the interface and interface condition to destroy the meshes connectivity for.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containing the interface condition to destroy the meshes connectivity for.
    :type interfaceUserNumber: int
    :param interfaceBasisNumber: The user number of the basis to denote the interface mesh connectivity basis
    :type interfaceBasisNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceMeshConnectivity_BasisSetNum, [regionUserNumber, interfaceUserNumber, interfaceBasisNumber])


def InterfaceMeshConnectivity_CreateFinishNum(regionUserNumber, interfaceUserNumber):
    """Finishes the creation of an interface coupled mesh connectivity identified by a user number.

    :param regionUserNumber: The user number of the region containing the interface to finish the interface meshes connectivity for.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface to finish creating the meshes connectivity.
    :type interfaceUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceMeshConnectivity_CreateFinishNum, [regionUserNumber, interfaceUserNumber])


def InterfaceMeshConnectivity_CreateStartNum(regionUserNumber, interfaceUserNumber, meshNumber):
    """Starts the creation of an interface meshes connectivity identified by a user number.

    :param regionUserNumber: The user number of the region containing the interface to start the creation of the meshes connectivity.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface to start the creation of the meshes connectivity for.
    :type interfaceUserNumber: int
    :param meshNumber: The user number of the interface mesh
    :type meshNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceMeshConnectivity_CreateStartNum, [regionUserNumber, interfaceUserNumber, meshNumber])


def InterfaceMeshConnectivity_DestroyNum(regionUserNumber, interfaceUserNumber):
    """Destroys an interface meshes connectivity identified by a user number.

    :param regionUserNumber: The user number of the region containing the interface and interface condition to destroy the meshes connectivity for.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containing the interface condition to destroy the meshes connectivity for.
    :type interfaceUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceMeshConnectivity_DestroyNum, [regionUserNumber, interfaceUserNumber])


def InterfaceMeshConnectivity_ElementNumberSetNum(regionUserNumber, interfaceUserNumber, interfaceElementNumber, coupledMeshIndexNumber, coupledMeshElementNumber):
    """Sets the connectivity between an element in a coupled mesh to an element in the interface mesh

    :param regionUserNumber: The user number of the region containing the interface meshe connectivity.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface.
    :type interfaceUserNumber: int
    :param interfaceElementNumber: The interface mesh element number to which the specified coupled mesh element would be connected
    :type interfaceElementNumber: int
    :param coupledMeshIndexNumber: The index of the coupled mesh at the interface to set the element connectivity for
    :type coupledMeshIndexNumber: int
    :param coupledMeshElementNumber: The coupled mesh element to be connected to the interface
    :type coupledMeshElementNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceMeshConnectivity_ElementNumberSetNum, [regionUserNumber, interfaceUserNumber, interfaceElementNumber, coupledMeshIndexNumber, coupledMeshElementNumber])


def InterfaceMeshConnectivity_ElementXiSetNum(regionUserNumber, interfaceUserNumber, interfaceElementNumber, coupledMeshIndexNumber, coupledMeshElementNumber, interfaceMeshLocalNodeNumber, interfaceMeshComponentNodeNumber, xi):
    """Sets the mapping from an xi position of a coupled mesh element to a node of an interface mesh element

    :param regionUserNumber: The user number of the region containing the interface to start the creation of the meshes connectivity.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface to start the creation of the meshes connectivity for.
    :type interfaceUserNumber: int
    :param interfaceElementNumber: The interface mesh element number to which the specified coupled mesh element would be connected
    :type interfaceElementNumber: int
    :param coupledMeshIndexNumber: The index of the coupled mesh at the interface to set the element connectivity for
    :type coupledMeshIndexNumber: int
    :param coupledMeshElementNumber: The coupled mesh element to define the element xi connectivity from
    :type coupledMeshElementNumber: int
    :param interfaceMeshLocalNodeNumber: The interface mesh node to assign the coupled mesh element xi to
    :type interfaceMeshLocalNodeNumber: int
    :param interfaceMeshComponentNodeNumber: The interface mesh node's component to assign the coupled mesh element xi to
    :type interfaceMeshComponentNodeNumber: int
    :param xi: The xi value for the xi_idx'th xi direction in the coupled mesh element.
    :type xi: Array of floats
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceMeshConnectivity_ElementXiSetNum, [regionUserNumber, interfaceUserNumber, interfaceElementNumber, coupledMeshIndexNumber, coupledMeshElementNumber, interfaceMeshLocalNodeNumber, interfaceMeshComponentNodeNumber, xi])


def InterfaceMeshConnectivity_NodeNumberSetNum(regionUserNumber, interfaceUserNumber, interfaceElementNumber, coupledMeshIndexNumber, coupledMeshElementNumber):
    """Sets the connectivity between an element in a coupled mesh to an element in the interface mesh

    :param regionUserNumber: The user number of the region containing the interface meshe connectivity.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface.
    :type interfaceUserNumber: int
    :param interfaceElementNumber: The interface mesh element number to which the specified coupled mesh element would be connected
    :type interfaceElementNumber: int
    :param coupledMeshIndexNumber: The index of the coupled mesh at the interface to set the element connectivity for
    :type coupledMeshIndexNumber: int
    :param coupledMeshElementNumber: The coupled mesh element to be connected to the interface
    :type coupledMeshElementNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfaceMeshConnectivity_NodeNumberSetNum, [regionUserNumber, interfaceUserNumber, interfaceElementNumber, coupledMeshIndexNumber, coupledMeshElementNumber])


def InterfacePointsConnectivity_CreateFinishNum(regionUserNumber, interfaceUserNumber):
    """Finishes the creation of an interface coupled mesh points connectivity identified by a user number.

    :param regionUserNumber: The user number of the region containing the interface to finish the interface points connectivity for.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface to finish creating the points connectivity.
    :type interfaceUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfacePointsConnectivity_CreateFinishNum, [regionUserNumber, interfaceUserNumber])


def InterfacePointsConnectivity_CreateStartNum(regionUserNumber, interfaceUserNumber, MeshNumber):
    """Starts the creation of an interface points connectivity identified by a user number.

    :param regionUserNumber: The user number of the region containing the interface to start the creation of the meshes connectivity.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface to start the creation of the meshes connectivity for.
    :type interfaceUserNumber: int
    :param MeshNumber: The user number of the interface mesh
    :type MeshNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfacePointsConnectivity_CreateStartNum, [regionUserNumber, interfaceUserNumber, MeshNumber])


def InterfacePointsConnectivity_DestroyNum(regionUserNumber, interfaceUserNumber):
    """Destroys an interface points connectivity identified by a user number.

    :param regionUserNumber: The user number of the region containing the interface to destroy the points connectivity for.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface to destroy the points connectivity for.
    :type interfaceUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfacePointsConnectivity_DestroyNum, [regionUserNumber, interfaceUserNumber])


def InterfacePointsConnectivity_ElementNumberGetNum(regionUserNumber, interfaceUserNumber, interfaceDataPointIndexNumber, coupledMeshIndexNumber, meshComponentNumber):
    """Gets coupled mesh element number that the data point in the interface is connected to

    :param regionUserNumber: The user number of the region containing the interface
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface
    :type interfaceUserNumber: int
    :param interfaceDataPointIndexNumber: The index of the interface data point, i.e.user defined global number
    :type interfaceDataPointIndexNumber: int
    :param coupledMeshIndexNumber: The index number of the coupled mesh
    :type coupledMeshIndexNumber: int
    :param meshComponentNumber: The mesh component number of the interface mesh that points connectivity is associated to
    :type meshComponentNumber: int
    :returns: coupledMeshElementNumber. The element number where the data point is connected to.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_InterfacePointsConnectivity_ElementNumberGetNum, [regionUserNumber, interfaceUserNumber, interfaceDataPointIndexNumber, coupledMeshIndexNumber, meshComponentNumber])


def InterfacePointsConnectivity_ElementNumberSetNum(regionUserNumber, interfaceUserNumber, interfaceDataPointIndexNumber, coupledMeshIndexNumber, coupledMeshElementNumber, meshComponentNumber):
    """Sets coupled mesh element number that the data point in the interface is connected to

    :param regionUserNumber: The user number of the region containing the interface
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface
    :type interfaceUserNumber: int
    :param interfaceDataPointIndexNumber: The index of the interface data point, i.e.user defined global number
    :type interfaceDataPointIndexNumber: int
    :param coupledMeshIndexNumber: The index number of the coupled mesh
    :type coupledMeshIndexNumber: int
    :param coupledMeshElementNumber: The element number where the data point is projected to.
    :type coupledMeshElementNumber: int
    :param meshComponentNumber: The mesh component number to set the points connectivity element number for
    :type meshComponentNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfacePointsConnectivity_ElementNumberSetNum, [regionUserNumber, interfaceUserNumber, interfaceDataPointIndexNumber, coupledMeshIndexNumber, coupledMeshElementNumber, meshComponentNumber])


def InterfacePointsConnectivity_PointXiGetNum(regionUserNumber, interfaceUserNumber, interfaceDataPointIndexNumber, coupledMeshIndexNumber, xiSize):
    """Gets the xi coordinate mapping between the data points in interface and xi coordinates in a coupled region mesh

    :param regionUserNumber: The user number of the region containing the interface
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface
    :type interfaceUserNumber: int
    :param interfaceDataPointIndexNumber: The index of the interface data point, i.e.user defined global number
    :type interfaceDataPointIndexNumber: int
    :param coupledMeshIndexNumber: The index number of the coupled mesh
    :type coupledMeshIndexNumber: int
    :param xiSize: Size of xi to allocate.
    :returns: xi. xi(xiIdx). The full xi location in the coupled mesh that the data point is connected to
    :rtype: Array of floats
    """

    return _wrap_routine(_iron_python.cmfe_InterfacePointsConnectivity_PointXiGetNum, [regionUserNumber, interfaceUserNumber, interfaceDataPointIndexNumber, coupledMeshIndexNumber, xiSize])


def InterfacePointsConnectivity_PointXiSetNum(regionUserNumber, interfaceUserNumber, interfaceDataPointIndexNumber, coupledMeshIndexNumber, xi):
    """Sets the xi coordinate mapping between the data points in interface and xi coordinates in a coupled region mesh

    :param regionUserNumber: The user number of the region containing the interface
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface
    :type interfaceUserNumber: int
    :param interfaceDataPointIndexNumber: The index of the interface data point, i.e.user defined global number
    :type interfaceDataPointIndexNumber: int
    :param coupledMeshIndexNumber: The index number of the coupled mesh
    :type coupledMeshIndexNumber: int
    :param xi: xi(xiIdx). The full xi location in the coupled mesh that the data point is connected to
    :type xi: Array of floats
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfacePointsConnectivity_PointXiSetNum, [regionUserNumber, interfaceUserNumber, interfaceDataPointIndexNumber, coupledMeshIndexNumber, xi])


def InterfacePointsConnectivity_UpdateFromProjectionINum(regionUserNumber, interfaceUserNumber, dataPointsRegionUserNumber, dataPointsInterfaceUserNumber, dataProjectionUserNumber, coupledMeshIndex):
    """Update points connectivity with projection results, data projection identified by interface user number

    :param regionUserNumber: The user number of the region containing the interface
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface
    :type interfaceUserNumber: int
    :param dataPointsRegionUserNumber: The parent region number of the interface for the data points which the data projection is associated with
    :type dataPointsRegionUserNumber: int
    :param dataPointsInterfaceUserNumber: The interface number of the data points which the data projection is associated with
    :type dataPointsInterfaceUserNumber: int
    :param dataProjectionUserNumber: The data projection user number of the data projection to update points connectivity with
    :type dataProjectionUserNumber: int
    :param coupledMeshIndex: The index number of the coupled mesh
    :type coupledMeshIndex: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfacePointsConnectivity_UpdateFromProjectionINum, [regionUserNumber, interfaceUserNumber, dataPointsRegionUserNumber, dataPointsInterfaceUserNumber, dataProjectionUserNumber, coupledMeshIndex])


def InterfacePointsConnectivity_UpdateFromProjectionRNum(regionUserNumber, interfaceUserNumber, dataPointsRegionUserNumber, dataProjectionUserNumber, coupledMeshIndex):
    """Update points connectivity with projection results, data projection identified by region user number

    :param regionUserNumber: The user number of the region containing the interface
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface
    :type interfaceUserNumber: int
    :param dataPointsRegionUserNumber: The region number of the data points which the data projection is associated with
    :type dataPointsRegionUserNumber: int
    :param dataProjectionUserNumber: The data projection user number of the data projection to update points connectivity with
    :type dataProjectionUserNumber: int
    :param coupledMeshIndex: The index number of the coupled mesh
    :type coupledMeshIndex: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_InterfacePointsConnectivity_UpdateFromProjectionRNum, [regionUserNumber, interfaceUserNumber, dataPointsRegionUserNumber, dataProjectionUserNumber, coupledMeshIndex])


def Interface_CoordinateSystemGetNum(parentRegionUserNumber, interfaceUserNumber):
    """Returns the coordinate system for an interface identified by an user number.

    :param parentRegionUserNumber: The user number of the region to get the coordinate system for.
    :type parentRegionUserNumber: int
    :param interfaceUserNumber: The user number of the interface to get the coordinate system for.
    :type interfaceUserNumber: int
    :returns: coordinateSystemUserNumber. The coordinate system user number.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Interface_CoordinateSystemGetNum, [parentRegionUserNumber, interfaceUserNumber])


def Interface_CoordinateSystemSetNum(parentRegionUserNumber, interfaceUserNumber, coordinateSystemUserNumber):
    """Sets/changes the coordinate system for an interface identified by an user number.

    :param parentRegionUserNumber: The user number of the parent region where interface was created.
    :type parentRegionUserNumber: int
    :param interfaceUserNumber: The user number of the interface to set the coordinate system for.
    :type interfaceUserNumber: int
    :param coordinateSystemUserNumber: The user number of the coordinate system to set.
    :type coordinateSystemUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Interface_CoordinateSystemSetNum, [parentRegionUserNumber, interfaceUserNumber, coordinateSystemUserNumber])


def Interface_CreateFinishNum(regionUserNumber, interfaceUserNumber):
    """Finishes the creation of an interface identified by a user number.

    :param regionUserNumber: The user number of the region containing the interface to finish the interface for.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface to finish creating.
    :type interfaceUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Interface_CreateFinishNum, [regionUserNumber, interfaceUserNumber])


def Interface_CreateStartNum(interfaceUserNumber, regionUserNumber):
    """Starts the creation of an interface identified by a user number.

    :param interfaceUserNumber: The user number of the interface to start the creation of.
    :type interfaceUserNumber: int
    :param regionUserNumber: The user number of the region containing the interface to start the creation of.
    :type regionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Interface_CreateStartNum, [interfaceUserNumber, regionUserNumber])


def Interface_DestroyNum(regionUserNumber, interfaceUserNumber):
    """Destroys an interface identified by a user number.

    :param regionUserNumber: The user number of the region containing the interface to destroy.
    :type regionUserNumber: int
    :param interfaceUserNumber: The user number of the interface to destroy.
    :type interfaceUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Interface_DestroyNum, [regionUserNumber, interfaceUserNumber])


def Interface_LabelGetNum(parentRegionUserNumber, interfaceUserNumber):
    """Returns the character string label for an interface identified by an user number.

    :param parentRegionUserNumber: The user number of the parent region containing the interface to get the label for.
    :type parentRegionUserNumber: int
    :param interfaceUserNumber: The user number of the interface to get the label for.
    :type interfaceUserNumber: int
    :returns: label. The region label.
    :rtype: string
    """

    return _wrap_routine(_iron_python.cmfe_Interface_LabelGetNum, [parentRegionUserNumber, interfaceUserNumber])


def Interface_LabelSetNum(parentRegionUserNumber, interfaceUserNumber, label):
    """Sets/changes the character string label for an interface identified by an user number.

    :param parentRegionUserNumber: The user number of the parent region containing the interface to set the label for.
    :type parentRegionUserNumber: int
    :param interfaceUserNumber: The user number of the interface to set the label for.
    :type interfaceUserNumber: int
    :param label: The interface label to set.
    :type label: string
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Interface_LabelSetNum, [parentRegionUserNumber, interfaceUserNumber, label])


def Interface_MeshAddNum(interfaceRegionUserNumber, interfaceUserNumber, meshRegionUserNumber, meshUserNumber):
    """Adds a mesh to be coupled in an interface identified by a user number.

    :param interfaceRegionUserNumber: The user number of the parent region containing the interface to add a coupled mesh to.
    :type interfaceRegionUserNumber: int
    :param interfaceUserNumber: The user number of the interface to add a coupled mesh to.
    :type interfaceUserNumber: int
    :param meshRegionUserNumber: The user number of the region containing the mesh to add to the interface.
    :type meshRegionUserNumber: int
    :param meshUserNumber: The user number of the mesh to add to the interface.
    :type meshUserNumber: int
    :returns: meshIndex. The mesh index of the mesh in the list of coupled meshes in the interface.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Interface_MeshAddNum, [interfaceRegionUserNumber, interfaceUserNumber, meshRegionUserNumber, meshUserNumber])


def MeshElements_AdjacentElementGetNum(regionUserNumber, meshUserNumber, meshComponentNumber, globalElementNumber, adjacentElementXi):
    """Returns the adjacent element number of a mesh identified by a user number

    :param regionUserNumber: The user number of the region containing the mesh from which to get the adjacent element from.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh from which to get the adjacent element from.
    :type meshUserNumber: int
    :param meshComponentNumber: The mesh component number from which to get adjacent element number from.
    :type meshComponentNumber: int
    :param globalElementNumber: The global element number to get the adjacent element number for. !\todo this should be a user number
    :type globalElementNumber: int
    :param adjacentElementXi: The xi coordinate direction to get the adjacent element for. Note that -xiCoordinateDirection gives the adjacent element before the element in the xiCoordinateDirection'th direction and +xiCoordinateDirection gives the adjacent element after the element in the xiCoordinateDirection'th direction. The xiCoordinateDirection=0 index will give the information on the current element.
    :type adjacentElementXi: int
    :returns: adjacentElement. The adjacent element number in the specified xi coordinate direction. Return 0 if the specified element has no adjacent elements in the specified xi coordinate direction.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_MeshElements_AdjacentElementGetNum, [regionUserNumber, meshUserNumber, meshComponentNumber, globalElementNumber, adjacentElementXi])


def MeshElements_BasisGetNum(regionUserNumber, meshUserNumber, meshComponentNumber, globalElementNumber):
    """Returns the basis for an element in a mesh identified by an user number. \todo should the global element number be a user number?

    :param regionUserNumber: The user number of the region containing the mesh to get the basis for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to get the basis for.
    :type meshUserNumber: int
    :param meshComponentNumber: The mesh component number to get the basis for.
    :type meshComponentNumber: int
    :param globalElementNumber: The global element number to get the basis for.
    :type globalElementNumber: int
    :returns: basisUserNumber. The user number of the basis for the element.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_MeshElements_BasisGetNum, [regionUserNumber, meshUserNumber, meshComponentNumber, globalElementNumber])


def MeshElements_BasisSetNum(regionUserNumber, meshUserNumber, meshComponentNumber, globalElementNumber, basisUserNumber):
    """Sets/changes the basis for an element in a mesh identified by an user number. \todo should the global element number be a user number?

    :param regionUserNumber: The user number of the region containing the mesh to set the basis for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to set the basis for.
    :type meshUserNumber: int
    :param meshComponentNumber: The mesh component number to set the basis for.
    :type meshComponentNumber: int
    :param globalElementNumber: The global element number to set the basis for.
    :type globalElementNumber: int
    :param basisUserNumber: The user number of the basis for the element to set.
    :type basisUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_MeshElements_BasisSetNum, [regionUserNumber, meshUserNumber, meshComponentNumber, globalElementNumber, basisUserNumber])


def MeshElements_CreateFinishNum(regionUserNumber, meshUserNumber, meshComponentNumber):
    """Finishes creating elements for a mesh component of a mesh identified by a user number.

    :param regionUserNumber: The user number of the region containing the mesh to finish creating the elements for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to finish creating the elements for.
    :type meshUserNumber: int
    :param meshComponentNumber: The mesh component number of the mesh to finish creating the elements for.
    :type meshComponentNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_MeshElements_CreateFinishNum, [regionUserNumber, meshUserNumber, meshComponentNumber])


def MeshElements_CreateStartNum(regionUserNumber, meshUserNumber, meshComponentNumber, basisUserNumber):
    """Starts creating elements for a mesh component of a mesh identified by a user number.

    :param regionUserNumber: The user number of the region containing the mesh to start creating the elements for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to start creating the elements for.
    :type meshUserNumber: int
    :param meshComponentNumber: The mesh component number of the mesh to start creating the elements for.
    :type meshComponentNumber: int
    :param basisUserNumber: The user number of the default basis to use for the elements.
    :type basisUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_MeshElements_CreateStartNum, [regionUserNumber, meshUserNumber, meshComponentNumber, basisUserNumber])


def MeshElements_LocalElementNodeVersionSetNum(regionUserNumber, meshUserNumber, globalElementNumber, versionNumber, derivativeNumber, localElementNodeNumber, meshComponentNumber):
    """Sets/changes the element nodes for an element in a mesh identified by an user number. \todo should the global element number be a user number?

    :param regionUserNumber: The user number of the region containing the mesh to set the element nodes for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to set the element nodes for.
    :type meshUserNumber: int
    :param globalElementNumber: The global element number to set the element nodes for.
    :type globalElementNumber: int
    :param versionNumber: The version number of the specified element node to set.
    :type versionNumber: int
    :param derivativeNumber: The derivative number of the specified element node to set.
    :type derivativeNumber: int
    :param localElementNodeNumber: The local element node to set a version for.
    :type localElementNodeNumber: int
    :param meshComponentNumber: The mesh component number to set the element nodes for.
    :type meshComponentNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_MeshElements_LocalElementNodeVersionSetNum, [regionUserNumber, meshUserNumber, globalElementNumber, versionNumber, derivativeNumber, localElementNodeNumber, meshComponentNumber])


def MeshElements_NodesGetNum(regionUserNumber, meshUserNumber, meshComponentNumber, globalElementNumber, elementUserNodesSize):
    """Returns the element nodes for an element in a mesh identified by an user number. \todo should the global element number be a user number?

    :param regionUserNumber: The user number of the region containing the mesh to get the element nodes for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to get the element nodes for.
    :type meshUserNumber: int
    :param meshComponentNumber: The mesh component number to get the element nodes for.
    :type meshComponentNumber: int
    :param globalElementNumber: The global element number to get the element nodes for.
    :type globalElementNumber: int
    :param elementUserNodesSize: Size of elementUserNodes to allocate.
    :returns: elementUserNodes. elementUserNodes(i). On return, the user node number number of the i'th element node.
    :rtype: Array of ints
    """

    return _wrap_routine(_iron_python.cmfe_MeshElements_NodesGetNum, [regionUserNumber, meshUserNumber, meshComponentNumber, globalElementNumber, elementUserNodesSize])


def MeshElements_NodesSetNum(regionUserNumber, meshUserNumber, meshComponentNumber, globalElementNumber, elementUserNodes):
    """Sets/changes the element nodes for an element in a mesh identified by an user number. \todo should the global element number be a user number?

    :param regionUserNumber: The user number of the region containing the mesh to set the element nodes for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to set the element nodes for.
    :type meshUserNumber: int
    :param meshComponentNumber: The mesh component number to set the element nodes for.
    :type meshComponentNumber: int
    :param globalElementNumber: The global element number to set the element nodes for.
    :type globalElementNumber: int
    :param elementUserNodes: elementUserNodes(i). The user node number number of the i'th element node to set.
    :type elementUserNodes: Array of ints
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_MeshElements_NodesSetNum, [regionUserNumber, meshUserNumber, meshComponentNumber, globalElementNumber, elementUserNodes])


def MeshElements_UserNodeVersionSetNum(regionUserNumber, meshUserNumber, globalElementNumber, versionNumber, derivativeNumber, userNodeNumber, meshComponentNumber):
    """Sets/changes the element nodes for an element in a mesh identified by an user number. \todo should the global element number be a user number?

    :param regionUserNumber: The user number of the region containing the mesh to set the element nodes for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to set the element nodes for.
    :type meshUserNumber: int
    :param globalElementNumber: The global element number to set the element nodes for.
    :type globalElementNumber: int
    :param versionNumber: The version number of the specified element node to set.
    :type versionNumber: int
    :param derivativeNumber: The derivative number of the specified element node to set.
    :type derivativeNumber: int
    :param userNodeNumber: The user node number to set a version for.
    :type userNodeNumber: int
    :param meshComponentNumber: The mesh component number to set the element nodes for.
    :type meshComponentNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_MeshElements_UserNodeVersionSetNum, [regionUserNumber, meshUserNumber, globalElementNumber, versionNumber, derivativeNumber, userNodeNumber, meshComponentNumber])


def MeshElements_UserNumberGetNum(regionUserNumber, meshUserNumber, meshComponentNumber, elementGlobalNumber):
    """Returns the user number for an element in a mesh identified by an user number.

    :param regionUserNumber: The user number of the region containing the mesh to get the element user number for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to get the element user number for.
    :type meshUserNumber: int
    :param meshComponentNumber: The mesh component number to get the element user number for.
    :type meshComponentNumber: int
    :param elementGlobalNumber: The global element number to get the element user number for.
    :type elementGlobalNumber: int
    :returns: elementUserNumber. The element user number.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_MeshElements_UserNumberGetNum, [regionUserNumber, meshUserNumber, meshComponentNumber, elementGlobalNumber])


def MeshElements_UserNumberSetNum(regionUserNumber, meshUserNumber, meshComponentNumber, elementGlobalNumber, elementUserNumber):
    """Sets/changes the user number for an element in a mesh identified by an user number.

    :param regionUserNumber: The user number of the region containing the mesh to set the element user number for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to set the element user number for.
    :type meshUserNumber: int
    :param meshComponentNumber: The mesh component number to set the element user number for.
    :type meshComponentNumber: int
    :param elementGlobalNumber: The global element number to set the element user number for.
    :type elementGlobalNumber: int
    :param elementUserNumber: The element user number to set.
    :type elementUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_MeshElements_UserNumberSetNum, [regionUserNumber, meshUserNumber, meshComponentNumber, elementGlobalNumber, elementUserNumber])


def MeshElements_UserNumbersAllSetNum(regionUserNumber, meshUserNumber, meshComponentNumber, elementUserNumbers):
    """Sets/changes the user numbers for all elements in a mesh identified by an user number.

    :param regionUserNumber: The user number of the region containing the mesh to set the element user numbers for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to set the element user numbers for.
    :type meshUserNumber: int
    :param meshComponentNumber: The mesh component number to set the element user numbers for.
    :type meshComponentNumber: int
    :param elementUserNumbers: The element user numbers to set.
    :type elementUserNumbers: Array of ints
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_MeshElements_UserNumbersAllSetNum, [regionUserNumber, meshUserNumber, meshComponentNumber, elementUserNumbers])


def MeshEmbedding_CreateNum(regionOneUserNumber, regionTwoUserNumber, meshEmbedding, parentMeshUserNumber, childMeshUserNumber):
    """Creates a mesh embedding

    :param regionOneUserNumber: The user number of the region containing the mesh.
    :type regionOneUserNumber: int
    :param regionTwoUserNumber: The user number of the region containing the mesh.
    :type regionTwoUserNumber: int
    :param meshEmbedding: The embedding
    :type meshEmbedding: MeshEmbedding
    :param parentMeshUserNumber: The user number of the mesh.
    :type parentMeshUserNumber: int
    :param childMeshUserNumber: The user number of the mesh.
    :type childMeshUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_MeshEmbedding_CreateNum, [regionOneUserNumber, regionTwoUserNumber, meshEmbedding, parentMeshUserNumber, childMeshUserNumber])


def MeshNodes_DerivativesGetNum(regionUserNumber, meshUserNumber, meshComponentNumber, userNodeNumber, derivativesSize):
    """Returns the derivatives at a node in a mesh identified by an user number.

    :param regionUserNumber: The user number of the region containing the mesh to get the derivatives for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to get the derivatives for.
    :type meshUserNumber: int
    :param meshComponentNumber: The mesh component number to get the derivatives for.
    :type meshComponentNumber: int
    :param userNodeNumber: The user node number to get the derivatives for.
    :type userNodeNumber: int
    :param derivativesSize: Size of derivatives to allocate.
    :returns: derivatives. The derivatives in the mesh for the user node number.
    :rtype: Array of ints
    """

    return _wrap_routine(_iron_python.cmfe_MeshNodes_DerivativesGetNum, [regionUserNumber, meshUserNumber, meshComponentNumber, userNodeNumber, derivativesSize])


def MeshNodes_NumberOfDerivativesGetNum(regionUserNumber, meshUserNumber, meshComponentNumber, userNodeNumber):
    """Returns the number of derivatives at a node in a mesh identified by an user number.

    :param regionUserNumber: The user number of the region containing the mesh to get the number of dervatives for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to get the number of derivatives for.
    :type meshUserNumber: int
    :param meshComponentNumber: The mesh component number to get the number of derivatives for.
    :type meshComponentNumber: int
    :param userNodeNumber: The user node number to get the number of derivatives for.
    :type userNodeNumber: int
    :returns: numberOfDerivatives. The number of derivatives in the mesh for the user node number.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_MeshNodes_NumberOfDerivativesGetNum, [regionUserNumber, meshUserNumber, meshComponentNumber, userNodeNumber])


def MeshNodes_NumberOfNodesGetNum(regionUserNumber, meshUserNumber, meshComponentNumber):
    """Returns the number of nodes at a node in a mesh identified by an user number.

    :param regionUserNumber: The user number of the region containing the mesh to get the number of dervatives for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to get the number of nodes for.
    :type meshUserNumber: int
    :param meshComponentNumber: The mesh component number to get the number of nodes for.
    :type meshComponentNumber: int
    :returns: numberOfNodes. The number of nodes in the mesh.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_MeshNodes_NumberOfNodesGetNum, [regionUserNumber, meshUserNumber, meshComponentNumber])


def MeshNodes_NumberOfVersionsGetNum(regionUserNumber, meshUserNumber, meshComponentNumber, derivativeNumber, userNodeNumber):
    """Returns the number of version at a derivative for a node in a mesh identified by an user number.

    :param regionUserNumber: The user number of the region containing the mesh to get the number of versions.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to get the number of versions for.
    :type meshUserNumber: int
    :param meshComponentNumber: The mesh component number to get the number of versions for.
    :type meshComponentNumber: int
    :param derivativeNumber: The derivative number of the node to get the number of versions for.
    :type derivativeNumber: int
    :param userNodeNumber: The user node number to get the number of versions for.
    :type userNodeNumber: int
    :returns: numberOfVersions. The number of versions in the mesh for the derivative index of the user node number.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_MeshNodes_NumberOfVersionsGetNum, [regionUserNumber, meshUserNumber, meshComponentNumber, derivativeNumber, userNodeNumber])


def Mesh_CreateFinishNum(regionUserNumber, meshUserNumber):
    """Finishes the creation of a mesh for a mesh identified by a user number.

    :param regionUserNumber: The user number of the region containing the mesh to finish the creation of.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to finish the creation of.
    :type meshUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Mesh_CreateFinishNum, [regionUserNumber, meshUserNumber])


def Mesh_CreateStartNum(meshUserNumber, regionUserNumber, numberOfDimensions):
    """Starts the creation of a mesh for a mesh identified by a user number.

    :param meshUserNumber: The user number of the mesh to start the creation of.
    :type meshUserNumber: int
    :param regionUserNumber: The user number of the region containing the mesh to start the creation of.
    :type regionUserNumber: int
    :param numberOfDimensions: The number of dimensions for the mesh.
    :type numberOfDimensions: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Mesh_CreateStartNum, [meshUserNumber, regionUserNumber, numberOfDimensions])


def Mesh_DestroyNum(regionUserNumber, meshUserNumber):
    """Destroys a mesh identified by a user number.

    :param regionUserNumber: The user number of the region containing the mesh to destroy.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to destroy.
    :type meshUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Mesh_DestroyNum, [regionUserNumber, meshUserNumber])


def Mesh_ElementExistsNum(regionUserNumber, meshUserNumber, meshComponentNumber, elementUserNumber):
    """Checks if the given element exists on the given mesh component.

    :param regionUserNumber: The user number of the region containing the mesh to check the element for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to check the element for.
    :type meshUserNumber: int
    :param meshComponentNumber: The mesh component number to check the element for.
    :type meshComponentNumber: int
    :param elementUserNumber: The user number of the element to check.
    :type elementUserNumber: int
    :returns: elementExists. True if the element exists, false otherwise.
    :rtype: bool
    """

    return _wrap_routine(_iron_python.cmfe_Mesh_ElementExistsNum, [regionUserNumber, meshUserNumber, meshComponentNumber, elementUserNumber])


def Mesh_ElementsGetNum(regionUserNumber, meshUserNumber, meshComponentNumber, meshElements):
    """Returns the mesh elements for a mesh component on a mesh identified by an user number.

    :param regionUserNumber: The user number of the region containing the mesh to get the elements for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to get the elements for.
    :type meshUserNumber: int
    :param meshComponentNumber: The mesh component number to get the elements for.
    :type meshComponentNumber: int
    :param meshElements: The mesh elements.
    :type meshElements: MeshElements
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Mesh_ElementsGetNum, [regionUserNumber, meshUserNumber, meshComponentNumber, meshElements])


def Mesh_NodeExistsNum(regionUserNumber, meshUserNumber, meshComponentNumber, nodeUserNumber):
    """Checks if the given node exists on the given mesh component.

    :param regionUserNumber: The user number of the region containing the mesh to check the node for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh tocheck the node for.
    :type meshUserNumber: int
    :param meshComponentNumber: The mesh component number to check the node for.
    :type meshComponentNumber: int
    :param nodeUserNumber: The user number of the node to check.
    :type nodeUserNumber: int
    :returns: nodeExists. True if the node exists, false otherwise.
    :rtype: bool
    """

    return _wrap_routine(_iron_python.cmfe_Mesh_NodeExistsNum, [regionUserNumber, meshUserNumber, meshComponentNumber, nodeUserNumber])


def Mesh_NodesGetNum(regionUserNumber, meshUserNumber, meshComponentNumber, meshNodes):
    """Returns the mesh nodes for a mesh component on a mesh identified by an user number.

    :param regionUserNumber: The user number of the region containing the mesh to get the nodes for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to get the nodes for.
    :type meshUserNumber: int
    :param meshComponentNumber: The mesh component number to get the nodes for.
    :type meshComponentNumber: int
    :param meshNodes: On return, the mesh nodes.
    :type meshNodes: MeshNodes
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Mesh_NodesGetNum, [regionUserNumber, meshUserNumber, meshComponentNumber, meshNodes])


def Mesh_NumberOfComponentsGetNum(regionUserNumber, meshUserNumber):
    """Returns the number of components in a mesh identified by a user number.

    :param regionUserNumber: The user number of the region containing the mesh to get the number of components for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to get the number of components for.
    :type meshUserNumber: int
    :returns: numberOfComponents. The number of components in the mesh.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Mesh_NumberOfComponentsGetNum, [regionUserNumber, meshUserNumber])


def Mesh_NumberOfComponentsSetNum(regionUserNumber, meshUserNumber, numberOfComponents):
    """Sets/changes the number of components in a mesh identified by a user number.

    :param regionUserNumber: The user number of the region containing the mesh to set the number of components for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to set the number of components for.
    :type meshUserNumber: int
    :param numberOfComponents: The number of components in the mesh to set.
    :type numberOfComponents: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Mesh_NumberOfComponentsSetNum, [regionUserNumber, meshUserNumber, numberOfComponents])


def Mesh_NumberOfElementsGetNum(regionUserNumber, meshUserNumber):
    """Returns the number of elements in a mesh identified by a user number.

    :param regionUserNumber: The user number of the region containing the mesh to get the number of elements for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to get the number of elements for.
    :type meshUserNumber: int
    :returns: numberOfElements. The number of elements in the mesh.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Mesh_NumberOfElementsGetNum, [regionUserNumber, meshUserNumber])


def Mesh_NumberOfElementsSetNum(regionUserNumber, meshUserNumber, numberOfElements):
    """Sets/changes the number of elements in a mesh identified by a user number.

    :param regionUserNumber: The user number of the region containing the mesh to set the number of elements for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to set the number of elements for.
    :type meshUserNumber: int
    :param numberOfElements: The number of elements in the mesh to set.
    :type numberOfElements: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Mesh_NumberOfElementsSetNum, [regionUserNumber, meshUserNumber, numberOfElements])


def Mesh_SurroundingElementsCalculateSetNum(regionUserNumber, meshUserNumber, surroundingElementsCalculateFlag):
    """Sets/changes the surrounding elements calculate flag.

    :param regionUserNumber: The user number of the region containing the mesh to set the surrounding elements calculate flag for.
    :type regionUserNumber: int
    :param meshUserNumber: The user number of the mesh to set the surrounding elements calculate flag for.
    :type meshUserNumber: int
    :param surroundingElementsCalculateFlag: Boolean flag to determine whether to calculate surrounding elements.
    :type surroundingElementsCalculateFlag: bool
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Mesh_SurroundingElementsCalculateSetNum, [regionUserNumber, meshUserNumber, surroundingElementsCalculateFlag])


def Mesh_TopologyDataPointsCalculateProjectionInterfaceNum(parentRegionUserNumber, interfaceUserNumber, MeshUserNumber, DataProjection):
    """Calculate mesh data points topology in an interface identified by a user number based on projection

    :param parentRegionUserNumber: The user number of the region.
    :type parentRegionUserNumber: int
    :param interfaceUserNumber: The user number of the region.
    :type interfaceUserNumber: int
    :param MeshUserNumber:
    :type MeshUserNumber: int
    :param DataProjection: The data projection
    :type DataProjection: DataProjection
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Mesh_TopologyDataPointsCalculateProjectionInterfaceNum, [parentRegionUserNumber, interfaceUserNumber, MeshUserNumber, DataProjection])


def Mesh_TopologyDataPointsCalculateProjectionRegionNum(regionUserNumber, MeshUserNumber, DataProjection):
    """Calculate mesh data points topology in a region identified by a user number based on projection

    :param regionUserNumber: The user number of the region.
    :type regionUserNumber: int
    :param MeshUserNumber:
    :type MeshUserNumber: int
    :param DataProjection: The data projection
    :type DataProjection: DataProjection
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Mesh_TopologyDataPointsCalculateProjectionRegionNum, [regionUserNumber, MeshUserNumber, DataProjection])


def Nodes_CreateFinishNum(regionUserNumber):
    """Finishes the process of creating nodes in a region for nodes identified by user number.

    :param regionUserNumber: The user number of the region containing the nodes to finish the creation of.
    :type regionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Nodes_CreateFinishNum, [regionUserNumber])


def Nodes_CreateStartNum(regionUserNumber, numberOfNodes):
    """Starts the process of creating nodes in a region for nodes identified by user number.

    :param regionUserNumber: The user number of the region containing the nodes to start the creation of.
    :type regionUserNumber: int
    :param numberOfNodes: The number of nodes to create.
    :type numberOfNodes: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Nodes_CreateStartNum, [regionUserNumber, numberOfNodes])


def Nodes_DestroyNum(regionUserNumber):
    """Destroys the nodes in a region for nodes identified by user number.

    :param regionUserNumber: The user number of the region containing the nodes to destroy.
    :type regionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Nodes_DestroyNum, [regionUserNumber])


def Nodes_LabelGetNum(regionUserNumber, nodeGlobalNumber):
    """Returns the character label for a node in a set of nodes identified by user number. \todo should this be user number??

    :param regionUserNumber: The user number of the region containing the nodes to get the label for.
    :type regionUserNumber: int
    :param nodeGlobalNumber: The global number of the nodes to get the label for.
    :type nodeGlobalNumber: int
    :returns: label. The label for the node.
    :rtype: string
    """

    return _wrap_routine(_iron_python.cmfe_Nodes_LabelGetNum, [regionUserNumber, nodeGlobalNumber])


def Nodes_LabelSetNum(regionUserNumber, nodeGlobalNumber, label):
    """Sets/changes the character label for a node in a set of nodes identified by user number. \todo should this be user number??

    :param regionUserNumber: The user number of the region containing the nodes to set the label for.
    :type regionUserNumber: int
    :param nodeGlobalNumber: The global number of the nodes to set the label for.
    :type nodeGlobalNumber: int
    :param label: The label for the node to set.
    :type label: string
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Nodes_LabelSetNum, [regionUserNumber, nodeGlobalNumber, label])


def Nodes_NumberOfNodesGetNum(regionUserNumber):
    """Returns the number of nodes

    :param regionUserNumber: The user number of the region containing the nodes to get node count for.
    :type regionUserNumber: int
    :returns: numberOfNodes. The number of nodes
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Nodes_NumberOfNodesGetNum, [regionUserNumber])


def Nodes_UserNumberGetNum(regionUserNumber, nodeGlobalNumber):
    """Returns the user number for a node in a set of nodes identified by user number.

    :param regionUserNumber: The user number of the region containing the nodes to get the node user number for.
    :type regionUserNumber: int
    :param nodeGlobalNumber: The global number of the nodes to get the node user number for.
    :type nodeGlobalNumber: int
    :returns: nodeUserNumber. The user number for the node.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Nodes_UserNumberGetNum, [regionUserNumber, nodeGlobalNumber])


def Nodes_UserNumberSetNum(regionUserNumber, nodeGlobalNumber, nodeUserNumber):
    """Sets/changes the user number for a node in a set of nodes identified by user number.

    :param regionUserNumber: The user number of the region containing the nodes to set the node user number for.
    :type regionUserNumber: int
    :param nodeGlobalNumber: The global number of the nodes to set the node user number for.
    :type nodeGlobalNumber: int
    :param nodeUserNumber: The user number for the node to set.
    :type nodeUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Nodes_UserNumberSetNum, [regionUserNumber, nodeGlobalNumber, nodeUserNumber])


def Nodes_UserNumbersAllSetNum(regionUserNumber, nodeUserNumbers):
    """Sets/changes the user numbers for a set of nodes identified by user number.

    :param regionUserNumber: The user number of the region containing the nodes to set the node user numbers for.
    :type regionUserNumber: int
    :param nodeUserNumbers: The user numbers for the nodes to set.
    :type nodeUserNumbers: Array of ints
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Nodes_UserNumbersAllSetNum, [regionUserNumber, nodeUserNumbers])


def OutputSetOff():
    """Sets output off

    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_OutputSetOff, [])


def OutputSetOn(echoFilename):
    """Sets output on

    :param echoFilename: The filename of the file to echo output to
    :type echoFilename: string
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_OutputSetOn, [echoFilename])


def Problem_CellMLEquationsCreateFinishNum(problemUserNumber):
    """Finishes the process of creating CellML equations for a problem identified by user number.

    :param problemUserNumber: The user number of the problem to finish the creation of CellML equations for.
    :type problemUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Problem_CellMLEquationsCreateFinishNum, [problemUserNumber])


def Problem_CellMLEquationsCreateStartNum(problemUserNumber):
    """Starts the process of creating CellML equations for a problem identified by user number.

    :param problemUserNumber: The user number of the problem to start the creation of CellML equations for.
    :type problemUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Problem_CellMLEquationsCreateStartNum, [problemUserNumber])


def Problem_CellMLEquationsGetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, CellMLEquations):
    """Returns the CellML equations from a problem identified by an user number.

    :param problemUserNumber: The user number of the problem to get the CellML equations for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the CellML equations for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the CellML equations for.
    :type solverIndex: int
    :param CellMLEquations: On return, the specified CellML equations.
    :type CellMLEquations: CellMLEquations
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Problem_CellMLEquationsGetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, CellMLEquations])


def Problem_ControlLoopCreateFinishNum(problemUserNumber):
    """Finishes the process of creating a control loop for a problem identified by user number.

    :param problemUserNumber: The user number of the problem to finish creating the control loop for.
    :type problemUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Problem_ControlLoopCreateFinishNum, [problemUserNumber])


def Problem_ControlLoopCreateStartNum(problemUserNumber):
    """Starts the process of creating a control loop for a problem identified by user number.

    :param problemUserNumber: The user number of the problem to start creating the control loop for.
    :type problemUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Problem_ControlLoopCreateStartNum, [problemUserNumber])


def Problem_ControlLoopDestroyNum(problemUserNumber):
    """Destroys the control loops for a problem identified by user number.

    :param problemUserNumber: The user number of the problem to destroy the control loops for.
    :type problemUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Problem_ControlLoopDestroyNum, [problemUserNumber])


def Problem_ControlLoopGetNum(problemUserNumber, controlLoopIdentifiers, controlLoop):
    """Returns a control loop from a problem identified by an user number.

    :param problemUserNumber: The user number of the problem to get the control loop for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the control loop for.
    :type controlLoopIdentifiers: Array of ints
    :param controlLoop: On return, the specified problem control loop.
    :type controlLoop: ControlLoop
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Problem_ControlLoopGetNum, [problemUserNumber, controlLoopIdentifiers, controlLoop])


def Problem_CreateFinishNum(problemUserNumber):
    """Finishes the process of a problem identified by user number.

    :param problemUserNumber: The user number of the problem to finish the creation of.
    :type problemUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Problem_CreateFinishNum, [problemUserNumber])


def Problem_CreateStartNum(problemUserNumber, problemSpecification):
    """Starts the process of a problem identified by user number.

    :param problemUserNumber: The user number of the problem to start the creation of.
    :type problemUserNumber: int
    :param problemSpecification: The problem specification array, containt the problem class, type etc
    :type problemSpecification: Array of ints
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Problem_CreateStartNum, [problemUserNumber, problemSpecification])


def Problem_DestroyNum(problemUserNumber):
    """Destroys a problem identified by an user number.

    :param problemUserNumber: The user number of the problem to destroy.
    :type problemUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Problem_DestroyNum, [problemUserNumber])


def Problem_SolveNum(problemUserNumber):
    """Solves a problem identified by an user number.

    :param problemUserNumber: The user number of the problem to solve.
    :type problemUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Problem_SolveNum, [problemUserNumber])


def Problem_SolverEquationsCreateFinishNum(problemUserNumber):
    """Finishes the process of creating solver equations for a problem identified by user number.

    :param problemUserNumber: The user number of the problem to finish the creation of solver equations for.
    :type problemUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Problem_SolverEquationsCreateFinishNum, [problemUserNumber])


def Problem_SolverEquationsCreateStartNum(problemUserNumber):
    """Starts the process of creating solver equations for a problem identified by user number.

    :param problemUserNumber: The user number of the problem to start the creation of solver equations for.
    :type problemUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Problem_SolverEquationsCreateStartNum, [problemUserNumber])


def Problem_SolverEquationsDestroyNum(problemUserNumber):
    """Destroys the solver equations for a problem identified by an user number.

    :param problemUserNumber: The user number of the problem to destroy solver equations for.
    :type problemUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Problem_SolverEquationsDestroyNum, [problemUserNumber])


def Problem_SolverEquationsGetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, solverEquations):
    """Returns the solver equations from a problem identified by an user number.

    :param problemUserNumber: The user number of the problem to get the solver equations for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the solver equations for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the solver equations for.
    :type solverIndex: int
    :param solverEquations: On return, the specified solver equations.
    :type solverEquations: SolverEquations
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Problem_SolverEquationsGetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, solverEquations])


def Problem_SolverGetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, solver):
    """Returns a solver from a problem identified by an user number.

    :param problemUserNumber: The user number of the problem to get the solver for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the solver for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the solver for.
    :type solverIndex: int
    :param solver: On return, the specified solver.
    :type solver: Solver
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Problem_SolverGetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, solver])


def Problem_SolversCreateFinishNum(problemUserNumber):
    """Finishes the process of creating solvers for a problem identified by user number.

    :param problemUserNumber: The user number of the problem to finish the creation of solvers for.
    :type problemUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Problem_SolversCreateFinishNum, [problemUserNumber])


def Problem_SolversCreateStartNum(problemUserNumber):
    """Starts the process of creating solvers for a problem identified by user number.

    :param problemUserNumber: The user number of the problem to start the creation of solvers for.
    :type problemUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Problem_SolversCreateStartNum, [problemUserNumber])


def Problem_SolversDestroyNum(problemUserNumber):
    """Destroys the solvers for a problem identified by an user number.

    :param problemUserNumber: The user number of the problem to destroy the solvers for.
    :type problemUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Problem_SolversDestroyNum, [problemUserNumber])


def Problem_SpecificationGetNum(problemUserNumber, problemSpecification):
    """Returns the specification array for a problem identified by a user number.

    :param problemUserNumber: The user number of the problem to get the specification for.
    :type problemUserNumber: int
    :param problemSpecification: On return, the problem specification array. Must be allocated and large enough to contain the specification on entry.
    :type problemSpecification: Array of ints
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Problem_SpecificationGetNum, [problemUserNumber, problemSpecification])


def Problem_SpecificationSizeGetNum(problemUserNumber):
    """Returns the size of the specification array for a problem identified by a user number.

    :param problemUserNumber: The user number of the problem to get the size of the specification for.
    :type problemUserNumber: int
    :returns: specificationSize. The size of the problem specification array.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Problem_SpecificationSizeGetNum, [problemUserNumber])


def RandomSeedsGet(randomSeedsSize):
    """Returns the random seeds for OpenCMISS

    :param randomSeedsSize: Size of randomSeeds to allocate.
    :returns: randomSeeds. The random seeds.
    :rtype: Array of ints
    """

    return _wrap_routine(_iron_python.cmfe_RandomSeedsGet, [randomSeedsSize])


def RandomSeedsSet(randomSeeds):
    """Sets the random seeds for OpenCMISS

    :param randomSeeds: The random seeds to set.
    :type randomSeeds: Array of ints
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_RandomSeedsSet, [randomSeeds])


def RandomSeedsSizeGet():
    """Returns the size of the random seeds array for OpenCMISS

    :returns: randomSeedsSize. The size of the random seeds array.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_RandomSeedsSizeGet, [])


def Region_CoordinateSystemGetNum(regionUserNumber):
    """Returns the coordinate system for a region identified by an user number.

    :param regionUserNumber: The user number of the region to get the coordinate system for.
    :type regionUserNumber: int
    :returns: coordinateSystemUserNumber. The coordinate system user number.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Region_CoordinateSystemGetNum, [regionUserNumber])


def Region_CoordinateSystemSetNum(regionUserNumber, coordinateSystemUserNumber):
    """Sets/changes the coordinate system for a region identified by an user number.

    :param regionUserNumber: The user number of the region to set the coordinate system for.
    :type regionUserNumber: int
    :param coordinateSystemUserNumber: The user number of the coordinate system to set.
    :type coordinateSystemUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Region_CoordinateSystemSetNum, [regionUserNumber, coordinateSystemUserNumber])


def Region_CreateFinishNum(regionUserNumber):
    """Finishes the process of creating a region identified by user number.

    :param regionUserNumber: The user number of the region to finish the creation of.
    :type regionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Region_CreateFinishNum, [regionUserNumber])


def Region_CreateStartNum(regionUserNumber, parentRegionUserNumber):
    """Starts the process creating a region identified by user number.

    :param regionUserNumber: The user number of the region to start the creation of.
    :type regionUserNumber: int
    :param parentRegionUserNumber: The user number of the parent region to start the creation of the region in.
    :type parentRegionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Region_CreateStartNum, [regionUserNumber, parentRegionUserNumber])


def Region_DestroyNum(regionUserNumber):
    """Destroys a region identified by an user number.

    :param regionUserNumber: The user number of the region to destroy.
    :type regionUserNumber: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Region_DestroyNum, [regionUserNumber])


def Region_LabelGetNum(regionUserNumber):
    """Returns the character string label for a region identified by an user number.

    :param regionUserNumber: The user number of the region to get the label for.
    :type regionUserNumber: int
    :returns: label. The region label.
    :rtype: string
    """

    return _wrap_routine(_iron_python.cmfe_Region_LabelGetNum, [regionUserNumber])


def Region_LabelSetNum(regionUserNumber, label):
    """Sets/changes the character string label for a region identified by an user number.

    :param regionUserNumber: The user number of the region to set the label for.
    :type regionUserNumber: int
    :param label: The region label to set.
    :type label: string
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Region_LabelSetNum, [regionUserNumber, label])


def SolverEquations_BoundaryConditionsAnalyticNum(problemUserNumber, controlLoopIdentifiers, solverIndex):
    """Set boundary conditions for solver equations according to the analytic equations for solver equations identified by user numbers.

    :param problemUserNumber: The user number of the problem containing the solver equations to calculate the boundary conditions for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to calculate the solver equations boundary conditions for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to calculate the solver equations boundary conditions for.
    :type solverIndex: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_SolverEquations_BoundaryConditionsAnalyticNum, [problemUserNumber, controlLoopIdentifiers, solverIndex])


def SolverEquations_BoundaryConditionsCreateFinishNum(problemUserNumber, controlLoopIdentifiers, solverIndex):
    """Finish the creation of the boundary conditions for the solver equations identified by the user numbers

    :param problemUserNumber: The user number of the problem containing the solver equations to finish the boundary conditions for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the solver equations boundary conditions for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the solver equations boundary conditions for.
    :type solverIndex: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_SolverEquations_BoundaryConditionsCreateFinishNum, [problemUserNumber, controlLoopIdentifiers, solverIndex])


def SolverEquations_BoundaryConditionsCreateStartNum(problemUserNumber, controlLoopIdentifiers, solverIndex):
    """Start the creation of boundary conditions for solver equations identified by user numbers

    :param problemUserNumber: The user number of the problem containing the solver equations to start the boundary conditions for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the solver equations boundary conditions for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the solver equations boundary conditions for.
    :type solverIndex: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_SolverEquations_BoundaryConditionsCreateStartNum, [problemUserNumber, controlLoopIdentifiers, solverIndex])


def SolverEquations_BoundaryConditionsGetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, boundaryConditions):
    """Get the boundary conditions for solver equations identified by user numbers

    :param problemUserNumber: The user number of the problem containing the solver equations to start the boundary conditions for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the solver equations boundary conditions for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the solver equations boundary conditions for.
    :type solverIndex: int
    :param boundaryConditions: On return, The boundary conditions for the specified solver equations.
    :type boundaryConditions: BoundaryConditions
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_SolverEquations_BoundaryConditionsGetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, boundaryConditions])


def SolverEquations_EquationsSetAddNum(problemUserNumber, controlLoopIdentifiers, solverIndex, regionUserNumber, equationsSetUserNumber):
    """Adds equations sets to solver equations identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to add the equations set for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to add the equations set for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to add the equations set for.
    :type solverIndex: int
    :param regionUserNumber: The user number of the region with the equations set to add.
    :type regionUserNumber: int
    :param equationsSetUserNumber: The user number of the equations set to add.
    :type equationsSetUserNumber: int
    :returns: equationsSetIndex. The index of the added equations set in the solver equations.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_SolverEquations_EquationsSetAddNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, regionUserNumber, equationsSetUserNumber])


def SolverEquations_InterfaceConditionAddNum(problemUserNumber, controlLoopIdentifiers, solverIndex, interfaceRegionUserNumber, interfaceUserNumber, interfaceConditionUserNumber):
    """Adds an interface condition to solver equations identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to add the interface condition for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to add the interface condition for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to add the interface condition for.
    :type solverIndex: int
    :param interfaceRegionUserNumber: The user number of the region containing the interface and interface condition to add.
    :type interfaceRegionUserNumber: int
    :param interfaceUserNumber: The user number of the interface containting the interface condition to add.
    :type interfaceUserNumber: int
    :param interfaceConditionUserNumber: The user number of the interface conditions to add.
    :type interfaceConditionUserNumber: int
    :returns: interfaceConditionIndex. The index of the added interface condition in the solver equations.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_SolverEquations_InterfaceConditionAddNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, interfaceRegionUserNumber, interfaceUserNumber, interfaceConditionUserNumber])


def SolverEquations_SparsityTypeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, sparsityType):
    """Sets/changes the sparsity type for solver equations identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to set the sparsity type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the sparsity type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the sparsity type for.
    :type solverIndex: int
    :param sparsityType: The sparsity type to set. Must be a value from the SolverEquationsSparsityTypes enum.
    :type sparsityType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_SolverEquations_SparsityTypeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, sparsityType])


def Solver_CellMLEquationsGetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, CellMLEquations):
    """Returns the CellML equations for a solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to get the CellML equations for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the CellML equations for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the CellML equations for.
    :type solverIndex: int
    :param CellMLEquations: On return, the CelllML equations for the solver.
    :type CellMLEquations: CellMLEquations
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_CellMLEquationsGetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, CellMLEquations])


def Solver_DAEEulerSolverTypeGetNum(problemUserNumber, controlLoopIdentifiers, solverIndex):
    """Returns the solve type for an Euler differential-algebraic equation solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to get the DAE Euler solver type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the DAE Euler solver type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the DAE Euler solver type for
    :type solverIndex: int
    :returns: DAEEulerSolverType. The DAE Euler solver type. Will be a value from the EulerDAESolverTypes enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Solver_DAEEulerSolverTypeGetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex])


def Solver_DAEEulerSolverTypeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, DAEEulerSolverType):
    """Sets/changes the solve type for an Euler differential-algebraic equation solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to set the DAE Euler solver type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the DAE Euler solver type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the DAE Euler solver type for
    :type solverIndex: int
    :param DAEEulerSolverType: The DAE Euler solver type to set. Must be a value from the EulerDAESolverTypes enum.
    :type DAEEulerSolverType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_DAEEulerSolverTypeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, DAEEulerSolverType])


def Solver_DAESolverTypeGetNum(problemUserNumber, controlLoopIdentifiers, solverIndex):
    """Returns the solve type for an differential-algebraic equation solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to get the DAE solver type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the DAE solver type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the DAE solver type for
    :type solverIndex: int
    :returns: DAESolverType. The DAE solver type. Will be a value from the DAESolverTypes enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Solver_DAESolverTypeGetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex])


def Solver_DAESolverTypeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, DAESolverType):
    """Sets/changes the solve type for an differential-algebraic equation solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to set the DAE solver type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the DAE solver type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the DAE solver type for
    :type solverIndex: int
    :param DAESolverType: The DAE solver type to set. Must be a value from the DAESolverTypes enum.
    :type DAESolverType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_DAESolverTypeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, DAESolverType])


def Solver_DAETimeStepSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, timeStep):
    """Sets/changes the (initial) time step for an differential-algebraic equation solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to set the DAE times for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the DAE times for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the DAE times for.
    :type solverIndex: int
    :param timeStep: The (initial) time step for the differential-algebraic solver.
    :type timeStep: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_DAETimeStepSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, timeStep])


def Solver_DAETimesSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, startTime, endTime):
    """Sets/changes the times for an differential-algebraic equation solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to set the DAE times for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the DAE times for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the DAE times for.
    :type solverIndex: int
    :param startTime: The start time for the differential-algebraic solver.
    :type startTime: float
    :param endTime: The end time for the differential-algebraic solver.
    :type endTime: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_DAETimesSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, startTime, endTime])


def Solver_DynamicDegreeGetNum(problemUserNumber, controlLoopIdentifiers, solverIndex):
    """Returns the degree of the polynomial used to interpolate time for a dynamic solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to get the dynamic degree for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the dynamic degree for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the dynamic degree for
    :type solverIndex: int
    :returns: degree. The dynamic degree. Will be a value from the DynamicDegreeTypes enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Solver_DynamicDegreeGetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex])


def Solver_DynamicDegreeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, degree):
    """Sets/changes the degree of the polynomial used to interpolate time for a dynamic solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to set the dynamic degree for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the dynamic degree for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the dynamic degree for
    :type solverIndex: int
    :param degree: The dynamic degree to set. Must be a value from the DynamicDegreeTypes enum.
    :type degree: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_DynamicDegreeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, degree])


def Solver_DynamicLinearSolverGetNum(problemUserNumber, controlLoopIdentifiers, solverIndex):
    """Returns the linear solver associated with a linear dynamic solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to get the dynamic linear solver for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the dynamic linear solver for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the dynamic linear solver for.
    :type solverIndex: int
    :returns: linearSolverIndex. The dynamic linear solver index.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Solver_DynamicLinearSolverGetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex])


def Solver_DynamicLinearityTypeGetNum(problemUserNumber, controlLoopIdentifiers, solverIndex):
    """Returns the linearity type for a dynamic solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to get the dynamic linearity type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the dynamic linearity type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the dynamic linearity type for.
    :type solverIndex: int
    :returns: linearityType. The dynamic linearity type. Will be a value from the DynamicLinearityTypes enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Solver_DynamicLinearityTypeGetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex])


def Solver_DynamicNonlinearSolverGetNum(problemUserNumber, controlLoopIdentifiers, solverIndex):
    """Returns the nonlinear solver associated with a nonlinear dynamic solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to get the dynamic nonlinear solver for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the dynamic nonlinear solver for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the dynamic nonlinear solver for.
    :type solverIndex: int
    :returns: nonlinearSolverIndex. The dynamic nonlinear solver index.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Solver_DynamicNonlinearSolverGetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex])


def Solver_DynamicSchemeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, scheme):
    """Sets/changes the scheme for a dynamic solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to set the scheme for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the scheme for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the scheme for.
    :type solverIndex: int
    :param scheme: The dynamic scheme to set. Must be a value from the DynamicSchemeTypes enum.
    :type scheme: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_DynamicSchemeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, scheme])


def Solver_DynamicThetaSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, thetas):
    """Sets/changes the theta for a dynamic solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to set the theta for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the theta for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the theta for.
    :type solverIndex: int
    :param thetas: thetas(i). The i'th dynamic theta to set.
    :type thetas: Array of floats
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_DynamicThetaSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, thetas])


def Solver_DynamicTimesSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, currentTime, timeIncrement):
    """Sets/changes the times for a dynamic solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to set the times for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the times for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the times for.
    :type solverIndex: int
    :param currentTime: The current time to set.
    :type currentTime: float
    :param timeIncrement: The time increment to set.
    :type timeIncrement: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_DynamicTimesSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, currentTime, timeIncrement])


def Solver_GeometricTransformationArbitraryPathSetNum(problemUserNumber, controlLoopIdentifier, solverIndex, arbitraryPath):
    """Sets the arbitrary path logical for a geometric transformation identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to set the arbitrary path for.
    :type problemUserNumber: int
    :param controlLoopIdentifier: The control loop identifier with the solver to set the arbitrary path for.
    :type controlLoopIdentifier: int
    :param solverIndex: The solver index for the geometric transformation solver.
    :type solverIndex: int
    :param arbitraryPath: .TRUE. if the the transformation has an arbitrary path, .FALSE. if the path is uni-directional
    :type arbitraryPath: bool
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_GeometricTransformationArbitraryPathSetNum, [problemUserNumber, controlLoopIdentifier, solverIndex, arbitraryPath])


def Solver_GeometricTransformationClearNum(problemUserNumber, controlLoopIdentifier, solverIndex):
    """Clear transformation a geometric transformation identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to clear.
    :type problemUserNumber: int
    :param controlLoopIdentifier: The control loop identifier with the solver to clear.
    :type controlLoopIdentifier: int
    :param solverIndex: The solver index for the geometric transformation solver.
    :type solverIndex: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_GeometricTransformationClearNum, [problemUserNumber, controlLoopIdentifier, solverIndex])


def Solver_GeometricTransformationFieldSetNum(problemUserNumber, controlLoopIdentifier, solverIndex, regionUserNumber, fieldUserNumber, variableType):
    """Sets the field for a geometric transformation identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to set the field for.
    :type problemUserNumber: int
    :param controlLoopIdentifier: The control loop identifier with the solver to set the field for.
    :type controlLoopIdentifier: int
    :param solverIndex: The solver index for the geometric transformation solver.
    :type solverIndex: int
    :param regionUserNumber: The region user number for the field
    :type regionUserNumber: int
    :param fieldUserNumber: The field user number
    :type fieldUserNumber: int
    :param variableType: The field variable type to set the transformation for
    :type variableType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_GeometricTransformationFieldSetNum, [problemUserNumber, controlLoopIdentifier, solverIndex, regionUserNumber, fieldUserNumber, variableType])


def Solver_GeometricTransformationMatrixSetNum(problemUserNumber, controlLoopIdentifier, solverIndex, matrix, loadIncrementIdx):
    """Sets the full transformation matrix at a specific increment for a geometric transformation identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to set the matrix for.
    :type problemUserNumber: int
    :param controlLoopIdentifier: The control loop identifier with the solver to set the matrix for.
    :type controlLoopIdentifier: int
    :param solverIndex: The solver index to set the matrix for.
    :type solverIndex: int
    :param matrix: The full transformation matrix to set
    :type matrix: 2d array of floats
    :param loadIncrementIdx: The load increment index to set the matrix for.
    :type loadIncrementIdx: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_GeometricTransformationMatrixSetNum, [problemUserNumber, controlLoopIdentifier, solverIndex, matrix, loadIncrementIdx])


def Solver_GeometricTransformationNoLoadIncrementsSetNum(problemUserNumber, controlLoopIdentifier, solverIndex, numberOfIncrements):
    """Sets the arbitrary path logical for a geometric transformation identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to set the field for.
    :type problemUserNumber: int
    :param controlLoopIdentifier: The control loop identifier with the solver to set the field for.
    :type controlLoopIdentifier: int
    :param solverIndex: The solver index for the geometric transformation solver.
    :type solverIndex: int
    :param numberOfIncrements: The number of load increments to apply the transformation
    :type numberOfIncrements: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_GeometricTransformationNoLoadIncrementsSetNum, [problemUserNumber, controlLoopIdentifier, solverIndex, numberOfIncrements])


def Solver_GeometricTransformationRotationSetNum(problemUserNumber, controlLoopIdentifier, solverIndex, pivotPoint, axis, angle, loadIncrementIdx):
    """Sets the rotation at a specific increment for a geometric transformation identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to set the rotation for.
    :type problemUserNumber: int
    :param controlLoopIdentifier: The control loop identifier with the solver to set the rotation for.
    :type controlLoopIdentifier: int
    :param solverIndex: The solver index to set the rotation for.
    :type solverIndex: int
    :param pivotPoint: The pivot point to rotate about
    :type pivotPoint: Array of floats
    :param axis: The axis to  to rotate around
    :type axis: Array of floats
    :param angle: The angle to rotate
    :type angle: float
    :param loadIncrementIdx: The load increment index to set the rotation for.
    :type loadIncrementIdx: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_GeometricTransformationRotationSetNum, [problemUserNumber, controlLoopIdentifier, solverIndex, pivotPoint, axis, angle, loadIncrementIdx])


def Solver_GeometricTransformationScalingsSetNum(problemUserNumber, controlLoopIdentifier, solverIndex, scalings):
    """Sets the scalings for a geometric transformation identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to set the scalings for.
    :type problemUserNumber: int
    :param controlLoopIdentifier: The control loop identifier with the solver to set the scalings for.
    :type controlLoopIdentifier: int
    :param solverIndex: The solver index to set the scalings for.
    :type solverIndex: int
    :param scalings: The scalings to set
    :type scalings: Array of floats
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_GeometricTransformationScalingsSetNum, [problemUserNumber, controlLoopIdentifier, solverIndex, scalings])


def Solver_GeometricTransformationTranslationSetNum(problemUserNumber, controlLoopIdentifier, solverIndex, translation, loadIncrementIdx):
    """Sets the translation at a specific increment for a geometric transformation identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to set the translation for.
    :type problemUserNumber: int
    :param controlLoopIdentifier: The control loop identifier with the solver to set the translation for.
    :type controlLoopIdentifier: int
    :param solverIndex: The solver index to set the translation for.
    :type solverIndex: int
    :param translation: The translation components to set
    :type translation: Array of floats
    :param loadIncrementIdx: The load increment index to set the translation for.
    :type loadIncrementIdx: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_GeometricTransformationTranslationSetNum, [problemUserNumber, controlLoopIdentifier, solverIndex, translation, loadIncrementIdx])


def Solver_LabelGetNum(problemUserNumber, controlLoopIdentifiers, solverIndex):
    """Returns the character string label for a solver identified by an user number.

    :param problemUserNumber: The user number of the problem to set the label for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: The control loop identifiers.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the label for.
    :type solverIndex: int
    :returns: label. The solver label.
    :rtype: string
    """

    return _wrap_routine(_iron_python.cmfe_Solver_LabelGetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex])


def Solver_LabelSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, label):
    """Sets/changes the character string label for a solver identified by an user number.

    :param problemUserNumber: The user number of the problem to set the label for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: The solver identifiers.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the label for.
    :type solverIndex: int
    :param label: The region label to set.
    :type label: string
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_LabelSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, label])


def Solver_LibraryTypeGetNum(problemUserNumber, controlLoopIdentifiers, solverIndex):
    """Returns the library type for a solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to get the library type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the library type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the library type for.
    :type solverIndex: int
    :returns: libraryType. The library type for the solver. Will be a value from the SolverLibraries enum.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Solver_LibraryTypeGetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex])


def Solver_LibraryTypeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, libraryType):
    """Sets/changes the library type for a solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to set the library type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the library type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the library type for.
    :type solverIndex: int
    :param libraryType: The library type for the solver to set. Must be a value from the SolverLibraries enum.
    :type libraryType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_LibraryTypeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, libraryType])


def Solver_LinearDirectTypeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, directSolverType):
    """Sets/changes the type of direct linear solver for a solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the direct linear solver to set the direct type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the direct type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the direct type for.
    :type solverIndex: int
    :param directSolverType: The type of the direct linear solver to set. Must be a value from the DirectLinearSolverTypes enum.
    :type directSolverType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_LinearDirectTypeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, directSolverType])


def Solver_LinearIterativeAbsoluteToleranceSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, absoluteTolerance):
    """Sets/changes the maximum absolute tolerance for an iterative linear solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the iterative linear solver to set the absolute tolerance for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the absolute tolerance for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the absolute tolerance for.
    :type solverIndex: int
    :param absoluteTolerance: The absolute tolerance for the iterative linear solver to set.
    :type absoluteTolerance: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_LinearIterativeAbsoluteToleranceSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, absoluteTolerance])


def Solver_LinearIterativeDivergenceToleranceSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, divergenceTolerance):
    """Sets/changes the maximum divergence tolerance for an iterative linear solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the iterative linear solver to set the divergence tolerance for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the divergence tolerance for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the divergence tolerance for.
    :type solverIndex: int
    :param divergenceTolerance: The divergence tolerance for the iterative linear solver to set.
    :type divergenceTolerance: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_LinearIterativeDivergenceToleranceSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, divergenceTolerance])


def Solver_LinearIterativeGMRESRestartSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, GMRESRestart):
    """Sets/changes the GMRES restart value for a GMRES iterative linear solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the GMRES iterative linear solver to set the restart value for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the restart value for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the restart value for.
    :type solverIndex: int
    :param GMRESRestart: The GMRES restart value to set.
    :type GMRESRestart: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_LinearIterativeGMRESRestartSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, GMRESRestart])


def Solver_LinearIterativeMaximumIterationsSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, maximumIterations):
    """Sets/changes the maximum number of iterations for an iterative linear solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the iterative linear solver to set the maximum iterations for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the maximum iterations for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the maximum iterations for.
    :type solverIndex: int
    :param maximumIterations: The maximum iterations to set.
    :type maximumIterations: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_LinearIterativeMaximumIterationsSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, maximumIterations])


def Solver_LinearIterativePreconditionerTypeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, preconditionerType):
    """Sets/changes the preconditioner type for an iterative linear solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the iterative linear solver to set the preconditioner type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the preconditioner type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the preconditioner type for.
    :type solverIndex: int
    :param preconditionerType: The preconditioner type to set. Must be a value from the IterativePreconditionerTypes enum.
    :type preconditionerType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_LinearIterativePreconditionerTypeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, preconditionerType])


def Solver_LinearIterativeRelativeToleranceSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, relativeTolerance):
    """Sets/changes the maximum relative tolerance for an iterative linear solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the iterative linear solver to set the relative tolerance for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the relative tolerance for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the relative tolerance for.
    :type solverIndex: int
    :param relativeTolerance: The relative tolerance for the iterative linear solver to set.
    :type relativeTolerance: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_LinearIterativeRelativeToleranceSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, relativeTolerance])


def Solver_LinearIterativeTypeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, iterativeSolverType):
    """Sets/changes the type for an iterative linear solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the iterative linear solver to set the type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the type for.
    :type solverIndex: int
    :param iterativeSolverType: The iterative solver type to set. Must be a value from the IterativeLinearSolverTypes enum.
    :type iterativeSolverType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_LinearIterativeTypeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, iterativeSolverType])


def Solver_LinearTypeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, linearSolverType):
    """Sets/changes the type for a linear solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the linear solver to set the type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the type for.
    :type solverIndex: int
    :param linearSolverType: The linear solver type to set. Must be a value from the LinearSolverTypes enum.
    :type linearSolverType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_LinearTypeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, linearSolverType])


def Solver_NewtonAbsoluteToleranceSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, absoluteTolerance):
    """Sets/changes the absolute tolerance for a Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Newton solver to set the absolute tolerance for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the absolute tolerance for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the absolute tolerance for.
    :type solverIndex: int
    :param absoluteTolerance: The absolute tolerance for the Newton solver to set.
    :type absoluteTolerance: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_NewtonAbsoluteToleranceSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, absoluteTolerance])


def Solver_NewtonCellMLSolverGetNum(problemUserNumber, controlLoopIdentifiers, solverIndex):
    """Returns the CellML solver associated with a Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to get the Newton CellML solver for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the Newton CellML solver for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the Newton CellML solver for.
    :type solverIndex: int
    :returns: CellMLSolverIndex. The Newton CellML solver index.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Solver_NewtonCellMLSolverGetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex])


def Solver_NewtonConvergenceTestTypeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, convergenceTestType):
    """Sets/changes the convergence test type for a Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Newton solver to set the convergence test type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the convergence test type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the convergence test type for.
    :type solverIndex: int
    :param convergenceTestType: The convergence test type for the Newton solver to set.
    :type convergenceTestType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_NewtonConvergenceTestTypeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, convergenceTestType])


def Solver_NewtonJacobianCalculationTypeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, jacobianCalculationType):
    """Sets/changes the Jacobian calculation type for a Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Newton solver to set the Jacobian calculation type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the Jacobian calculation type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the Jacobian calculation type for.
    :type solverIndex: int
    :param jacobianCalculationType: The Jacobian calculation type for the Newton solver to set. Must be a value from the JacobianCalculationTypes enum.
    :type jacobianCalculationType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_NewtonJacobianCalculationTypeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, jacobianCalculationType])


def Solver_NewtonLineSearchAlphaSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, alpha):
    """Sets/changes the line search alpha for a Newton line search solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Newton line search solver to set the alpha for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the alpha for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the alpha for.
    :type solverIndex: int
    :param alpha: The alpha for the Newton line search solver to set.
    :type alpha: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_NewtonLineSearchAlphaSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, alpha])


def Solver_NewtonLineSearchMaxStepSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, maxStep):
    """Sets/changes the line search maximum step for a Newton line search solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Newton line search solver to set the maximum step for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the maximum step for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the maximum step for.
    :type solverIndex: int
    :param maxStep: The maximum step for the Newton line search solver to set.
    :type maxStep: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_NewtonLineSearchMaxStepSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, maxStep])


def Solver_NewtonLineSearchMonitorOutputSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, monitorLinesearchFlag):
    """Enables/disables output monitoring for a nonlinear Newton line search solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Newton solver to set the linesearch monitoring for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the linesearch monitoring for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the absolute tolerance for.
    :type solverIndex: int
    :param monitorLinesearchFlag: Flag to determine whether to enable/disable linsearch monitor output.
    :type monitorLinesearchFlag: bool
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_NewtonLineSearchMonitorOutputSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, monitorLinesearchFlag])


def Solver_NewtonLineSearchStepTolSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, stepTol):
    """Sets/changes the line search step tolerance for a Newton line search solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Newton line search solver to set the step tolerance for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the step tolerance for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the step tolerance for.
    :type solverIndex: int
    :param stepTol: The step tolerance for the Newton line search solver to set.
    :type stepTol: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_NewtonLineSearchStepTolSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, stepTol])


def Solver_NewtonLineSearchTypeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, lineSearchType):
    """Sets/changes the type of line search for a Newton line search solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Newton line search solver to set the line search type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the line search type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the line search type for.
    :type solverIndex: int
    :param lineSearchType: The type of line search for the Newton line search solver to set. Must be a value from the NewtonLineSearchTypes enum.
    :type lineSearchType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_NewtonLineSearchTypeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, lineSearchType])


def Solver_NewtonLinearSolverGetNum(problemUserNumber, controlLoopIdentifiers, solverIndex):
    """Returns the linear solver associated with a Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to get the Newton linear solver for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the Newton linear solver for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the Newton linear solver for.
    :type solverIndex: int
    :returns: linearSolverIndex. The Newton linear solver index.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Solver_NewtonLinearSolverGetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex])


def Solver_NewtonMaximumFunctionEvaluationsSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, maximumFunctionEvaluations):
    """Sets/changes the maximum number of function evaluations for a Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Newton solver to set the maximum function evaluations for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the maximum function evaluations for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the maximum function evaluations for.
    :type solverIndex: int
    :param maximumFunctionEvaluations: The maximum number of function evaluations for the Newton solver to set.
    :type maximumFunctionEvaluations: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_NewtonMaximumFunctionEvaluationsSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, maximumFunctionEvaluations])


def Solver_NewtonMaximumIterationsSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, maximumIterations):
    """Sets/changes the maximum number of iterations for a Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Newton solver to set the maximum iterations for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the maximum iterations for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the maximum iterations for.
    :type solverIndex: int
    :param maximumIterations: The maximum number of iterations for the Newton solver to set.
    :type maximumIterations: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_NewtonMaximumIterationsSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, maximumIterations])


def Solver_NewtonRelativeToleranceSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, relativeTolerance):
    """Sets/changes the relative tolerance for a Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Newton solver to set the relative tolerance for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the relative tolerance for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the relative tolerance for.
    :type solverIndex: int
    :param relativeTolerance: The relative tolerance for the Newton solver to set.
    :type relativeTolerance: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_NewtonRelativeToleranceSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, relativeTolerance])


def Solver_NewtonSolutionToleranceSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, solutionTolerance):
    """Sets/changes the solution tolerance for a Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Newton solver to set the solution tolerance for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the solution tolerance for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the solution tolerance for.
    :type solverIndex: int
    :param solutionTolerance: The absolulte tolerance for the Newton solver to set.
    :type solutionTolerance: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_NewtonSolutionToleranceSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, solutionTolerance])


def Solver_NewtonTrustRegionDelta0SetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, delta0):
    """Sets/changes the delta0 for a Newton trust region solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Newton trust region solver to set the delta0 for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the delta0 for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the delta0 for.
    :type solverIndex: int
    :param delta0: The delta0 for the Newton trust region solver to set.
    :type delta0: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_NewtonTrustRegionDelta0SetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, delta0])


def Solver_NewtonTrustRegionToleranceSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, tolerance):
    """Sets/changes the tolerance for a Newton trust region solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Newton trust region solver to set the tolerance for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the tolerance for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the tolerance for.
    :type solverIndex: int
    :param tolerance: The tolerance for the Newton trust region solver to set.
    :type tolerance: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_NewtonTrustRegionToleranceSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, tolerance])


def Solver_NewtonTypeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, newtonSolveType):
    """Sets/changes the type of a Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Newton solver to set the type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the type for.
    :type solverIndex: int
    :param newtonSolveType: The type of the Newton solver to set. Must be a value from the NewtonSolverTypes enum.
    :type newtonSolveType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_NewtonTypeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, newtonSolveType])


def Solver_NonlinearTypeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, nonlinearSolveType):
    """Sets/changes the type of a nonlinear solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the nonlinear solver to set the type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the type for.
    :type solverIndex: int
    :param nonlinearSolveType: The type of the nonlinear solver to set. Must be a value from the NonlinearSolverTypes enum.
    :type nonlinearSolveType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_NonlinearTypeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, nonlinearSolveType])


def Solver_OutputTypeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, outputType):
    """Sets/changes the type of output for a solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to set the output type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the output type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the output type for.
    :type solverIndex: int
    :param outputType: The type of solver output to set. Must be a value from the SolverOutputTypes enum.
    :type outputType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_OutputTypeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, outputType])


def Solver_QuasiNewtonAbsoluteToleranceSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, absoluteTolerance):
    """Sets/changes the absolute tolerance for a Quasi-Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Quasi-Newton solver to set the absolute tolerance for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the absolute tolerance for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the absolute tolerance for.
    :type solverIndex: int
    :param absoluteTolerance: The absolute tolerance for the Quasi-Newton solver to set.
    :type absoluteTolerance: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonAbsoluteToleranceSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, absoluteTolerance])


def Solver_QuasiNewtonCellMLSolverGetNum(problemUserNumber, controlLoopIdentifiers, solverIndex):
    """Returns the CellML solver associated with a Quasi-Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to get the Quasi-Newton CellML solver for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the Quasi-Newton CellML solver for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the Quasi-Newton CellML solver for.
    :type solverIndex: int
    :returns: CellMLSolverIndex. The Quasi-Newton CellML solver index.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonCellMLSolverGetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex])


def Solver_QuasiNewtonConvergenceTestTypeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, convergenceTestType):
    """Sets/changes the convergence test type for a Quasi-Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Quasi-Newton solver to set the convergence test type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the convergence test type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the convergence test type for.
    :type solverIndex: int
    :param convergenceTestType: The convergence test type for the Quasi-Newton solver to set.
    :type convergenceTestType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonConvergenceTestTypeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, convergenceTestType])


def Solver_QuasiNewtonJacobianCalculationTypeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, jacobianCalculationType):
    """Sets/changes the Jacobian calculation type for a Quasi-Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Quasi-Newton solver to set the Jacobian calculation type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the Jacobian calculation type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the Jacobian calculation type for.
    :type solverIndex: int
    :param jacobianCalculationType: The Jacobian calculation type for the Quasi-Newton solver to set. Must be a value from the JacobianCalculationTypes enum.
    :type jacobianCalculationType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonJacobianCalculationTypeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, jacobianCalculationType])


def Solver_QuasiNewtonLineSearchMaxStepSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, maxStep):
    """Sets/changes the line search maximum step for a Quasi-Newton line search solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Quasi-Newton line search solver to set the maximum step for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the maximum step for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the maximum step for.
    :type solverIndex: int
    :param maxStep: The maximum step for the Quasi-Newton line search solver to set.
    :type maxStep: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonLineSearchMaxStepSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, maxStep])


def Solver_QuasiNewtonLineSearchMonitorOutputSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, monitorLinesearchFlag):
    """Enables/disables output monitoring for a nonlinear Quasi-Newton line search solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Quasi-Newton solver to set the linesearch monitoring for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the linesearch monitoring for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the absolute tolerance for.
    :type solverIndex: int
    :param monitorLinesearchFlag: Flag to determine whether to enable/disable linsearch monitor output.
    :type monitorLinesearchFlag: bool
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonLineSearchMonitorOutputSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, monitorLinesearchFlag])


def Solver_QuasiNewtonLineSearchStepTolSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, stepTol):
    """Sets/changes the line search step tolerance for a Quasi-Newton line search solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Quasi-Newton line search solver to set the step tolerance for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the step tolerance for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the step tolerance for.
    :type solverIndex: int
    :param stepTol: The step tolerance for the Quasi-Newton line search solver to set.
    :type stepTol: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonLineSearchStepTolSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, stepTol])


def Solver_QuasiNewtonLineSearchTypeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, lineSearchType):
    """Sets/changes the type of line search for a Quasi-Newton line search solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Quasi-Newton line search solver to set the line search type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the line search type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the line search type for.
    :type solverIndex: int
    :param lineSearchType: The type of line search for the Quasi-Newton line search solver to set. Must be a value from the QuasiNewtonLineSearchTypes enum.
    :type lineSearchType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonLineSearchTypeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, lineSearchType])


def Solver_QuasiNewtonLinearSolverGetNum(problemUserNumber, controlLoopIdentifiers, solverIndex):
    """Returns the linear solver associated with a Quasi-Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to get the Quasi-Newton linear solver for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the Quasi-Newton linear solver for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the Quasi-Newton linear solver for.
    :type solverIndex: int
    :returns: linearSolverIndex. The Quasi-Newton linear solver index.
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonLinearSolverGetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex])


def Solver_QuasiNewtonMaximumFunctionEvaluationsSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, maximumFunctionEvaluations):
    """Sets/changes the maximum number of function evaluations for a Quasi-Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Quasi-Newton solver to set the maximum function evaluations for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the maximum function evaluations for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the maximum function evaluations for.
    :type solverIndex: int
    :param maximumFunctionEvaluations: The maximum number of function evaluations for the Quasi-Newton solver to set.
    :type maximumFunctionEvaluations: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonMaximumFunctionEvaluationsSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, maximumFunctionEvaluations])


def Solver_QuasiNewtonMaximumIterationsSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, maximumIterations):
    """Sets/changes the maximum number of iterations for a Quasi-Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Quasi-Newton solver to set the maximum iterations for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the maximum iterations for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the maximum iterations for.
    :type solverIndex: int
    :param maximumIterations: The maximum number of iterations for the Quasi-Newton solver to set.
    :type maximumIterations: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonMaximumIterationsSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, maximumIterations])


def Solver_QuasiNewtonRelativeToleranceSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, relativeTolerance):
    """Sets/changes the relative tolerance for a Quasi-Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Quasi-Newton solver to set the relative tolerance for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the relative tolerance for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the relative tolerance for.
    :type solverIndex: int
    :param relativeTolerance: The relative tolerance for the Quasi-Newton solver to set.
    :type relativeTolerance: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonRelativeToleranceSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, relativeTolerance])


def Solver_QuasiNewtonRestartSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, quasiNewtonRestart):
    """Sets/changes the restart of a Quasi-Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Quasi-Newton solver to set the for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the for.
    :type solverIndex: int
    :param quasiNewtonRestart: The restart of the Quasi-Newton solver to set.
    :type quasiNewtonRestart: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonRestartSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, quasiNewtonRestart])


def Solver_QuasiNewtonRestartTypeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, quasiNewtonRestartType):
    """Sets/changes the restart type of a Quasi-Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Quasi-Newton solver to set the type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the type for.
    :type solverIndex: int
    :param quasiNewtonRestartType: The restart type of the Quasi-Newton solver to set. Must be a value from the QuasiNewtonRestartTypes enum.
    :type quasiNewtonRestartType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonRestartTypeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, quasiNewtonRestartType])


def Solver_QuasiNewtonScaleTypeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, quasiNewtonScaleType):
    """Sets/changes the scale type of a Quasi-Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Quasi-Newton solver to set the type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the type for.
    :type solverIndex: int
    :param quasiNewtonScaleType: The scale type of the Quasi-Newton solver to set. Must be a value from the QuasiNewtonScaleTypes enum.
    :type quasiNewtonScaleType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonScaleTypeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, quasiNewtonScaleType])


def Solver_QuasiNewtonSolutionToleranceSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, solutionTolerance):
    """Sets/changes the solution tolerance for a Quasi-Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Quasi-Newton solver to set the solution tolerance for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the solution tolerance for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the solution tolerance for.
    :type solverIndex: int
    :param solutionTolerance: The absolulte tolerance for the Quasi-Newton solver to set.
    :type solutionTolerance: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonSolutionToleranceSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, solutionTolerance])


def Solver_QuasiNewtonSolveTypeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, quasiNewtonSolveType):
    """Sets/changes the type of a Quasi-Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Quasi-Newton solver to set the type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the type for.
    :type solverIndex: int
    :param quasiNewtonSolveType: The type of the Quasi-Newton solver to set. Must be a value from the QuasiNewtonSolverTypes enum.
    :type quasiNewtonSolveType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonSolveTypeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, quasiNewtonSolveType])


def Solver_QuasiNewtonTrustRegionDelta0SetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, delta0):
    """Sets/changes the delta0 for a Quasi-Newton trust region solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Quasi-Newton trust region solver to set the delta0 for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the delta0 for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the delta0 for.
    :type solverIndex: int
    :param delta0: The delta0 for the Quasi-Newton trust region solver to set.
    :type delta0: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonTrustRegionDelta0SetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, delta0])


def Solver_QuasiNewtonTrustRegionToleranceSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, tolerance):
    """Sets/changes the tolerance for a Quasi-Newton trust region solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Quasi-Newton trust region solver to set the tolerance for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the tolerance for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the tolerance for.
    :type solverIndex: int
    :param tolerance: The tolerance for the Quasi-Newton trust region solver to set.
    :type tolerance: float
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonTrustRegionToleranceSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, tolerance])


def Solver_QuasiNewtonTypeSetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, quasiNewtonType):
    """Sets/changes the type of a Quasi-Newton solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the Quasi-Newton solver to set the type for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to set the type for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to set the type for.
    :type solverIndex: int
    :param quasiNewtonType: The Quasi-Newton type to set. Must be a value from the QuasiNewtonTypes enum.
    :type quasiNewtonType: int
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_QuasiNewtonTypeSetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, quasiNewtonType])


def Solver_SolverEquationsGetNum(problemUserNumber, controlLoopIdentifiers, solverIndex, solverEquations):
    """Returns the solver equations for a solver identified by an user number.

    :param problemUserNumber: The user number of the problem number with the solver to get the solver equations for.
    :type problemUserNumber: int
    :param controlLoopIdentifiers: controlLoopIdentifiers(i). The i'th control loop identifier to get the solver equations for.
    :type controlLoopIdentifiers: Array of ints
    :param solverIndex: The solver index to get the solver equations for.
    :type solverIndex: int
    :param solverEquations: On return, the solver equations for the solver.
    :type solverEquations: SolverEquations
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_Solver_SolverEquationsGetNum, [problemUserNumber, controlLoopIdentifiers, solverIndex, solverEquations])


def TimingSetOff():
    """Sets timing off

    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_TimingSetOff, [])


def TimingSetOn(timingType, timingSummaryFlag, timingFilename, routineList):
    """Sets timing on

    :param timingType: The type of timing to set on. Must be a value from the TimingTypes enum.
    :type timingType: int
    :param timingSummaryFlag: .TRUE. if the timing information will be output with subsequent OpenCMISS::Iron::cmfe_TimingSummaryOutput calls, .FALSE. if the timing information will be output every time the routine exits.
    :type timingSummaryFlag: bool
    :param timingFilename: If present the name of the file to output timing information to. If omitted the timing output is sent to the screen.
    :type timingFilename: string
    :param routineList: The list of routines to set timing on in.
    :type routineList: Array of strings
    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_TimingSetOn, [timingType, timingSummaryFlag, timingFilename, routineList])


def TimingSummaryOutput():
    """Outputs the timing summary.

    :rtype: None
    """

    return _wrap_routine(_iron_python.cmfe_TimingSummaryOutput, [])


def UserNumberGetBasis(basis):
    """Get the user number of the given basis.

    :param basis: The basis to get the user number for
    :type basis: Basis
    :returns: userNumber. The basis's user number
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_UserNumberGetBasis, [basis])


def UserNumberGetMesh(mesh):
    """Get the user number of the given mesh.

    :param mesh: The mesh to get the user number for
    :type mesh: Mesh
    :returns: userNumber. The mesh's user number
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_UserNumberGetMesh, [mesh])


def UserNumberGetRegion(region):
    """Get the user number of the given region.

    :param region: The region to get the user number for
    :type region: Region
    :returns: userNumber. The region's user number
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_UserNumberGetRegion, [region])


def WorkingRealPrecisionGet():
    """Returns the working precision

    :returns: workingRealPrecision. The working real precision
    :rtype: int
    """

    return _wrap_routine(_iron_python.cmfe_WorkingRealPrecisionGet, [])


class DiagnosticTypes(Enum):
    """Diganostic constants.
    """

    ALL = 1  # Type for setting diagnostic output in all routines
    IN = 2  # Type for setting diagnostic output in one routine
    FROM = 3  # Type for setting diagnostic output in one routine downwards


class TimingTypes(Enum):
    """Timing constants.
    """

    ALL = 1  # Type for setting timing output in all routines
    IN = 2  # Type for setting timing output in one routine
    FROM = 3  # Type for setting timing output from one routine downwards


class BasisTypes(Enum):
    """Basis definition type parameters.
    """

    LAGRANGE_HERMITE_TP = 1  # Lagrange-Hermite tensor product basis type
    SIMPLEX = 2  # Simplex basis type
    SERENDIPITY = 3  # Serendipity basis type
    AUXILLIARY = 4  # Auxillary basis type
    B_SPLINE_TP = 5  # B-spline basis type
    FOURIER_LAGRANGE_HERMITE_TP = 6  # Fourier-Lagrange tensor product basis type
    EXTENDED_LAGRANGE_TP = 7  # Extendend Lagrange tensor product basis type


class BasisInterpolationSpecifications(Enum):
    """Interpolation specification parameters
    """

    LINEAR_LAGRANGE = 1  # Linear Lagrange interpolation specification
    QUADRATIC_LAGRANGE = 2  # Quadratic Lagrange interpolation specification
    CUBIC_LAGRANGE = 3  # Cubic Lagrange interpolation specification
    CUBIC_HERMITE = 4  # Cubic Hermite interpolation specification
    QUADRATIC1_HERMITE = 5  # Quadratic Hermite (no derivative at xi=0) interpolation specification
    QUADRATIC2_HERMITE = 6  # Quadratic Hermite (no derivative at xi=1) interpolation specification
    LINEAR_SIMPLEX = 7  # Linear Simplex interpolation specification
    QUADRATIC_SIMPLEX = 8  # Quadratic Simplex interpolation specification
    CUBIC_SIMPLEX = 9  # Cubic Simplex interpolation specification


class BasisQuadratureSchemes(Enum):
    """Quadrature scheme parameters
    """

    DEFAULT = 1  # Identifier for the default quadrature scheme
    LOW = 2  # Identifier for a low order quadrature scheme
    MID = 3  # Identifier for a mid order quadrature scheme
    HIGH = 4  # Identifier for a high order quadrature scheme


class BasisQuadratureTypes(Enum):
    """Basis quadrature type parameters.
    """

    GAUSS_LEGENDRE = 1  # Gauss-Legendre quadrature
    GAUSS_LAGUERRE = 2  # Gauss-Laguerre quadrature
    GUASS_HERMITE = 3  # Gauss-Hermite quadrature
    ADAPTIVE_GAUSS_LEGENDRE = 4  # Adaptive Gauss-Legendre quadrature
    GAUSS_SIMPLEX = 5  # Gauss-Legendre for Simplex elements quadrature


class BasisXiCollapse(Enum):
    """Basis Xi collapse parameters.
    """

    XI_COLLAPSED = 1  # The Xi direction is collapsed
    COLLAPSED_AT_XI0 = 2  # The Xi direction at the xi=0 end of this Xi direction is collapsed
    COLLAPSED_AT_XI1 = 3  # The Xi direction at the xi=1 end of this Xi direction is collapsed
    NOT_COLLAPSED = 4  # The Xi direction is not collapsed


class BoundaryConditionsTypes(Enum):
    """Specific boundary condition types, which might only be applicable to certain equation sets.
    """

    FREE = 0  # The dof is free.
    FIXED = 1  # The dof is fixed as a boundary condition.
    FIXED_WALL = 4
    FIXED_INLET = 2
    FIXED_OUTLET = 3
    MOVED_WALL = 5
    MOVED_WALL_INCREMENTED = 17
    FREE_WALL = 6
    NEUMANN_POINT = 8  # Specify the normal derivative at a node, which is then integrated to find the nodal load term
    NEUMANN_POINT_INCREMENTED = 22  # Specify the normal derivative at a node, which is then integrated to find the nodal load term. The value is incremented inside a load incremented control loop.
    NEUMANN_INTEGRATED = 9  # Set the integrated right hand side load value directly
    DIRICHLET = 10
    CAUCHY = 11
    ROBIN = 12
    FIXED_INCREMENTED = 13
    PRESSURE = 14
    PRESSURE_INCREMENTED = 15
    CORRECTION_MASS_INCREASE = 18
    IMPERMEABLE_WALL = 19
    NEUMANN_INTEGRATED_ONLY = 20  # A Neumann integrated boundary condition, and no point values will be integrated over a face or line that includes this dof
    FIXED_FITTED = 23
    FIXED_NONREFLECTING = 24
    FIXED_CELLML = 25


class BoundaryConditionSparsityTypes(Enum):
    """Storage type for matrices used by boundary conditions.
    """

    SPARSE = 1
    FULL = 2


class ErrorHandlingModes(Enum):
    """CMISS error handling mode parameters
    """

    RETURN_ERROR_CODE = 0  # Just return the error code
    OUTPUT_ERROR = 1  # Output the error traceback and return the error code
    TRAP_ERROR = 2  # Trap the error by outputing the error traceback and stopping the program


class CellMLFieldTypes(Enum):
    """CellML field type parameters.
    """

    MODELS = 1  # CellML models field type
    STATE = 2  # CellML state field type
    INTERMEDIATE = 3  # CellML intermediate field type
    PARAMETERS = 4  # CellML parameters field type


class DataTypeConstants(Enum):
    """Data type constants for base data types
    """

    INTEGER = 1  # Integer data type
    SHORT_INTEGER = 2  # Short integer data type
    LONG_INTEGER = 3  # Long integer data type
    SINGLE_REAL = 4  # Single precision real data type
    DOUBLE_REAL = 5  # Double precision real data type
    QUADRAUPLE_REAL = 6  # Quadruple precision real data type
    CHARACTER = 7  # Character data type
    LOGICAL = 8  # Logical data type
    SINGLE_COMPLEX = 9  # Single precision complex data type
    DOUBLE_COMPLEX = 10  # Double precision complex data type
    QUADRUPLE_COMPLEX = 11  # Quadruple precision complex data type


class GlobalDerivativeConstants(Enum):
    """Global derivative constant identifiers
    """

    NO_GLOBAL_DERIV = 1  # No global derivative i.e., u
    GLOBAL_DERIV_S1 = 2  # First global derivative in the s1 direction i.e., du/ds1
    GLOBAL_DERIV_S2 = 3  # First global derivative in the s2 direction i.e., du/ds2
    GLOBAL_DERIV_S1_S2 = 4  # Global Cross derivative in the s1 and s2 direction i.e., d^2u/ds1ds2
    GLOBAL_DERIV_S3 = 5  # First global derivative in the s3 direction i.e., du/ds3
    GLOBAL_DERIV_S1_S3 = 6  # Global Cross derivative in the s1 and s3 direction i.e., d^2u/ds1ds3
    GLOBAL_DERIV_S2_S3 = 7  # Global Cross derivative in the s2 and s3 direction i.e., d^2u/ds2ds3
    GLOBAL_DERIV_S1_S2_S3 = 8  # Cross derivative in the s1, s2 and s3 direction i.e., d^3u/ds1ds2ds3


class ControlLoopIdentifiers(Enum):
    """The control loop identification parameters.
    """

    NODE = 0  # The identifier for a each "leaf" node in a control loop


class ControlLoopOutputTypes(Enum):
    """The control loop output types.
    """

    NONE = 0  # No output from the control loop
    PROGRESS = 1  # Progress output from the control loop
    TIMING = 2  # Timing output from the control loop


class CoordinateSystemTypes(Enum):
    """Coordinate system type parameters.
    """

    RECTANGULAR_CARTESIAN = 1  # Rectangular Cartesian coordinate system type
    CYLINDRICAL_POLAR = 2  # Cylindrical polar coordinate system type
    SPHERICAL_POLAR = 3  # Spherical polar coordinate system type
    PROLATE_SPHEROIDAL = 4  # Prolate spheroidal coordinate system type
    OBLATE_SPHEROIDAL = 5  # Oblate spheroidal coordinate system type


class CoordinateRadialInterpolations(Enum):
    """The type of radial interpolation for polar coordinate systems
    """

    NO_RADIAL = 0  # No radial interpolation
    RADIAL = 1  # r radial interpolation
    RADIAL_SQUARED = 2  # r^2 radial interpolation
    RADIAL_CUBED = 3  # r^3 radial interpolation


class DataProjectionProjectionTypes(Enum):
    """Data Projection types
    """

    BOUNDARY_LINES = 1  # The boundary line projection type for data projection, only projects to boundary lines of the mesh
    BOUNDARY_FACES = 2  # The boundary face projection type for data projection, only projects to boundary faces of the mesh
    ALL_ELEMENTS = 3  # The element projection type for data projection, projects to all elements in mesh


class EquationsOutputTypes(Enum):
    """Equations output types
    """

    NONE = 0  # No output from the equations
    TIMING = 1  # Timing information output
    MATRIX = 2  # All below and equation matrices output
    ELEMENT_MATRIX = 3  # All below and element matrices output
    NODAL_MATRIX = 4  # All below and nodal matrices output


class EquationsSparsityTypes(Enum):
    """Equations sparsity types
    """

    SPARSE = 1  # Use sparse matrices for the equations
    FULL = 2  # Use fully populated matrices for the equations


class EquationsLumpingTypes(Enum):
    """Equations lumping types
    """

    UNLUMPED = 1  # The equations matrices are not lumped
    LUMPED = 2  # The equations matrices are "mass" lumped


class EquationsLinearityTypes(Enum):
    """The equations linearity types
    """

    LINEAR = 1  # The equations are linear
    NONLINEAR = 2  # The equations are non-linear OPENCMISS_EquationsLinearityTypes,OPENCMISS
    NONLINEAR_BCS = 3  # The equations have non-linear boundary conditions OPENCMISS_EquationsLinearityTypes,OPENCMISS


class EquationsJacobianCalculated(Enum):
    """Equations Jacobian matrices calculation types
    """

    FINITE_DIFFERENCE = 1  # Evaluate Jacobian matrix using finite differences
    ANALYTIC = 2  # Evaluate Jacobian matrix using analytic expressions


class EquationsSetClasses(Enum):
    """Equations set classes.
    """

    NONE = 0  # No equations set class
    ELASTICITY = 1  # Elasticity equations set class
    FLUID_MECHANICS = 2  # Fluid Mechanics equations set class
    ELECTROMAGNETICS = 3  # Electromagnetics equations set class
    CLASSICAL_FIELD = 4  # Classical Field equations set class
    BIOELECTRICS = 5  # Bioelectrics equations set class
    MODAL = 6  # Modal equations set class
    FITTING = 7  # Fitting equations set class
    OPTIMISATION = 8  # Optimisation equations set class
    MULTI_PHYSICS = 9  # Multi Physics equations set class


class EquationsSetTypes(Enum):
    """Equations set Types.
    """

    NONE = 0  # No equations set type
    LINEAR_ELASTICITY = 1  # Linear elasticity equations set type
    FINITE_ELASTICITY = 2  # Finite elasticity equations set type
    STOKES_EQUATION = 1  # Stokes equation equations set type
    NAVIER_STOKES_EQUATION = 2  # Navier-Stokes equations set type
    DARCY_EQUATION = 3  # Darcy equation equations set type
    DARCY_PRESSURE_EQUATION = 4  # Darcy pressure equation equations set type
    POISEUILLE_EQUATION = 5  # Poiseuille equation equations set type
    BURGERS_EQUATION = 6  # Burgers equation equations set type
    CHARACTERISTIC_EQUATION = 7  # Characteristic equation equations set type
    ELECTROSTATIC = 1  # Electrostatic equations set type
    MAGNETOSTATIC = 2  # Magnetostatic equations set type
    MAXWELLS_EQUATIONS = 3  # Maxwells equation equations set type
    LAPLACE_EQUATION = 1  # Laplace equation equations set type
    POISSON_EQUATION = 2  # Poisson equation equations set type
    HELMHOLTZ_EQUATION = 3  # Helmholtz equation equations set type
    WAVE_EQUATION = 4  # Wave equation equations set type
    DIFFUSION_EQUATION = 6  # Diffusion equation equations set type
    ADVECTION_EQUATION = 11  # Advection-Diffusion equation equations set type
    ADVECTION_DIFFUSION_EQUATION = 7  # Advection-Diffusion equation equations set type
    REACTION_DIFFUSION_EQUATION = 8  # Reaction-Diffusion equation equations set type
    BIHARMONIC_EQUATION = 9  # Biharmonic equation equations set type
    MONODOMAIN_EQUATION = 1  # Monodomain equation equations set type
    BIDOMAIN_EQUATION = 2  # Bidomain equation equations set type
    LINEAR_ELASTIC_MODAL = 1  # Linear elasticity modal equations set type
    DATA_FITTING_EQUATION = 10  # Galerkin projection equations set type
    FINITE_ELASTICITY_DARCY = 1  # Finite Elasticity Darcy equations set type
    FINITE_ELASTICITY_STOKES = 2  # Finite Elasticity Stokes equations set type
    FINITE_ELASTICITY_NAVIER_STOKES = 3  # Finite Elasticity Navier Stokes equations set type
    DIFFUSION_DIFFUSION = 4  # Diffusion Diffusion equations set type
    DIFFUSION_ADVECTION_DIFFUSION = 5  # Diffusion Advection Diffusion equations set type
    MONODOMAIN_STRANG_SPLITTING_EQUATION = 3  # Monodomain equation equations Strang Splitting set type


class EquationsSetSubtypes(Enum):
    """Equations set subtypes.
    """

    NONE = 0  # No equations set subtype
    THREE_DIMENSIONAL = 4  # Three dimensional linear elasticity equations set subtype
    TWO_DIMENSIONAL_PLANE_STRESS = 2  # Plane stress linear elasticity equations set subtype
    TWO_DIMENSIONAL_PLANE_STRAIN = 3  # Plane strain linear elasticity equations set subtype
    ONE_DIMENSIONAL = 1  # One dimensional linear elasticity equations set subtype
    PLATE = 5  # Plate linear elasticity equations set subtype
    SHELL = 6  # Shell linear elasticity equations set subtype
    MOONEY_RIVLIN = 1  # Mooney-Rivlin constitutive law for finite elasticity equations set subtype
    INCOMPRESSIBLE_MOONEY_RIVLIN = 21  # Incompressible Mooney-Rivlin constitutive law for finite elasticity equations set subtype
    NEARLY_INCOMPRESSIBLE_MOONEY_RIVLIN = 22  # Nearly Incompressible Mooney-Rivlin constitutive law for finite elasticity equations set subtype
    MOONEY_RIVLIN_ACTIVECONTRACTION = 24  # Mooney-Rivlin constitutive law with steady-state active contraction for finite elasticity equations set subtype
    STVENANT_KIRCHOFF_ACTIVECONTRACTION = 25  # St Venant Kirchoff constitutive law with steady-state active contraction for finite elasticity equations set subtype
    ACTIVECONTRACTION = 6  # Active contraction/costa-based law with quasistatic time loop for finite elasticity equations set subtype
    ISOTROPIC_EXPONENTIAL = 2  # Isotropic exponential constitutive law for finite elasticity equations set subtype
    TRANSVERSE_ISOTROPIC_EXPONENTIAL = 3  # Transverse isotropic exponential constitutive law for finite elasticity equations set subtype
    TRANSVERSE_ISOTROPIC_ACTIVE = 27  # Transverse isotropic, active-contraction constitutive law for finite elasticity equations set subtype
    TRANS_ISOTROPIC_ACTIVE_TRANSITION = 28  # Transverse isotropic, active-contraction material-transition constitutive law for finite elasticity equations set subtype
    ORTHOTROPIC_MATERIAL_COSTA = 4  # Orthotropic Costa constitutive law for finite elasticity equations set subtype
    COMPRESSIBLE_FINITE_ELASTICITY = 5  # Compressible version for finite elasticity equations set subtype
    COMPRESSIBLE_ACTIVECONTRACTION = 26  # Compressible version for finite elasticity equations set with active contraction subtype
    TRANSVERSE_ISOTROPIC_GUCCIONE = 15  # Transverse isotropic Guccione constitutive law for finite elasticity equations set subtype
    ACTIVE_STRAIN = 34  # Isotropic active strain constitutive law based on multiplicative decomposition of the deformation gradient subtype
    MULTISCALE_ACTIVE_STRAIN = 35  # Isotropic active strain constitutive law based on multiplicative decomposition of the deformation gradient and the cellular model of Razumova et al. (2000) subtype
    REFERENCE_STATE_MOONEY_RIVLIN = 36  # Determine the reference configuration using Mooney-Rivlin constitutive law for finite elasticity equations set subtype
    GUCCIONE_ACTIVECONTRACTION = 32  # Transverse isotropic Guccione constitutive law with active contraction subtype
    INCOMPRESS_FINITE_ELASTICITY_DARCY = 8  # Incompressible version for finite elasticity coupled with Darcy equations set subtype
    ELASTICITY_DARCY_INRIA_MODEL = 10  # INRIA Model for finite elasticity coupled with Darcy equations set subtype
    ELASTICITY_MULTI_COMP_DARCY_INRIA = 12  # Multi Compartment Darcy INRIA Model coupled with finite elasticity equations set subtype
    INCOMPRESS_ELASTICITY_DRIVEN_DARCY = 11  # Incompressible finite elasticity with Darcy flow driven by solid hydrostatic pressure
    INCOMPRESSIBLE_ELASTICITY_DRIVEN_MR = 13  # Incompressible finite elasticity with Darcy flow driven by solid hydrostatic pressure, formulated in terms of modified invariants
    INCOMPRESS_ELAST_MULTI_COMP_DARCY = 14
    MEMBRANE = 7  # Compressible version for finite elasticity equations set subtype
    ORTHOTROPIC_HOLZAPFEL_OGDEN = 9  # Orthotropic Holzapfel-Ogden constitutive law for finite elasticity equations set subtype
    HOLZAPFEL_OGDEN_ACTIVECONTRACTION = 31  # Orthotropic Holzapfel-Ogden constitutive law with active contraction for finite elasticity equations set subtype
    ELASTICITY_FLUID_PRES_STATIC_INRIA = 16  # Static finite elasticity coupled with fluid pressure set subtype
    ELASTICITY_FLUID_PRES_HOLMES_MOW = 18  # Holmes and Mow's poroelastic constitutive relation subtype
    ELASTI_FLUID_PRES_HOLMES_MOW_ACTIVE = 19  # Holmes and Mow's poroelastic constitutive relation subtype with active contraction
    TRANSVERSE_ISOTROPIC_POLYNOMIAL = 20  # Transverse isotropic constitutive law for finite elasticity equations set subtype
    ANISOTROPIC_POLYNOMIAL = 29  # Anisotropic polynomial constitutive law for finite elasticity equations set subtype
    ANISOTROPIC_POLYNOMIAL_ACTIVE = 30  # Anisotropic polynomial active constitutive law for finite elasticity equations set subtype
    TRANSVERSE_ISOTROPIC_HUMPHREY_YIN = 23  # Humphrey and Yin transversely isotropic constitutive relation subtype
    STATIC_STOKES = 1  # Static Stokes equations set subtype
    LAPLACE_STOKES = 2  # Laplace type Stokes equations set subtype
    TRANSIENT_STOKES = 3  # Transient Stokes equations set subtype
    ALE_STOKES = 5  # ALE Stokes equations set subtype
    PGM_STOKES = 6  # PGM Stokes equations set subtype
    OPTIMISED_STOKES = 4  # Optimised Stokes equations set subtype
    STATIC_NAVIER_STOKES = 1  # Static Navier-Stokes equations set subtype
    LAPLACE_NAVIER_STOKES = 2  # Laplace type Navier-Stokes equations set subtype
    TRANSIENT_NAVIER_STOKES = 3  # Transient Navier-Stokes equations set subtype
    TRANSIENT_RBS_NAVIER_STOKES = 9  # Transient residual-based stabilisation Navier-Stokes equations set subtype
    STATIC_RBS_NAVIER_STOKES = 13  # Transient residual-based stabilisation Navier-Stokes equations set subtype
    MULTISCALE3D_NAVIER_STOKES = 11  # Transient stabilised 3D Navier-Stokes equations set with coupled multiscale boundaries subtype
    CONSTITUTIVE_MU_NAVIER_STOKES = 18  # Transient stabilised 3D Navier-Stokes equations set with coupled constitutive model for non-Newtonian viscosity
    TRANSIENT1D_NAVIER_STOKES = 8  # TRANSIENT1D Navier-Stokes equations set subtype
    TRANSIENT1D_ADV_NAVIER_STOKES = 14  # TRANSIENT1D Navier-Stokes equations set subtype with coupled Advection
    CHARACTERISTIC = 1  # Static Characteristics equations set subtype
    COUPLED1D0D_NAVIER_STOKES = 12  # Coupled 1D-0D Navier-Stokes equations set subtype
    COUPLED1D0D_ADV_NAVIER_STOKES = 15  # Coupled 1D-0D Navier-Stokes equations set subtype with coupled Advection
    STREE1D0D = 16  # Coupled 1D-0D Navier-Stokes equations set subtype with coupled Advection
    STREE1D0D_ADV = 17  # Coupled 1D-0D Navier-Stokes equations set subtype with coupled Advection
    ALE_NAVIER_STOKES = 5  # ALE Navier-Stokes equations set subtype
    PGM_NAVIER_STOKES = 6  # PGM Navier-Stokes equations set subtype
    OPTIMISED_NAVIER_STOKES = 4  # Optimised Navier-Stokes equations set subtype
    STANDARD_DARCY = 1  # Standard Darcy equations set subtype
    QUASISTATIC_DARCY = 2  # Quasistatic Darcy equations set subtype
    ALE_DARCY = 3  # ALE Darcy equations set subtype
    TRANSIENT_DARCY = 4  # Transient Darcy equations set subtype
    TRANSIENT_ALE_DARCY = 5  # Transient ALE Darcy equations set subtype
    MULTI_COMPARTMENT_DARCY = 6  # Multi Compartment Darcy equations set subtype
    BURGERS = 1  # Burgers equations set subtype
    GENERALISED_BURGERS = 2  # Generalised Burgers equations set subtype
    STATIC_BURGERS = 3  # Static Burgers equations set subtype
    INVISCID_BURGERS = 4  # Inviscid Burgers equations set subtype
    STANDARD_LAPLACE = 1  # Standard Laplace equations set subtype
    GENERALISED_LAPLACE = 2  # Generalised Laplace equations set subtype
    MOVING_MESH_LAPLACE = 3  # Moving mesh Laplace equations set subtype
    STATIC_POISEUILLE = 1  # Static Poiseuille equations set subtype
    DYNAMIC_POISEUILLE = 2  # Dynamic Poiseuille equations set subtype
    LINEAR_PRESSURE_POISSON = 5  # Vector source Poisson equations set subtype
    NONLINEAR_PRESSURE_POISSON = 6  # Vector source Poisson equations set subtype
    ALE_PRESSURE_POISSON = 7  # Vector source Poisson equations set subtype
    FITTED_PRESSURE_POISSON = 8  # Vector source Poisson equations set subtype
    CONSTANT_SOURCE_POISSON = 1  # Constant source Poisson equations set subtype
    EXTRACELLULAR_BIDOMAIN_POISSON = 9  # Poisson equations set subtype, that is the extracellular bidomain equation
    LINEAR_SOURCE_POISSON = 2  # Linear source Poisson equations set subtype
    QUADRATIC_SOURCE_POISSON = 3  # Quadratic source Poisson equations set subtype
    EXPONENTIAL_SOURCE_POISSON = 4  # Exponential source Poisson equations set subtype
    STANDARD_HELMHOLTZ = 2  # No source Helmholtz equations set subtype
    GENERALISED_HELMHOLTZ = 3  # No source Helmholtz equations set subtype
    NO_SOURCE_DIFFUSION = 1  # No source diffusion equations set subtype
    CONSTANT_SOURCE_DIFFUSION = 2  # Constant source diffusion equations set subtype
    LINEAR_SOURCE_DIFFUSION = 3  # Linear source diffusion equations set subtype
    QUADRATIC_SOURCE_DIFFUSION = 4  # Quadratic source diffusion equations set subtype
    EXPONENTIAL_SOURCE_DIFFUSION = 5  # Exponential source diffusion equations set subtype
    NO_SOURCE_ALE_DIFFUSION = 6  # No source diffusion equations set subtype
    CONSTANT_SOURCE_ALE_DIFFUSION = 7  # Constant source diffusion equations set subtype
    LINEAR_SOURCE_ALE_DIFFUSION = 8  # Linear source diffusion equations set subtype
    QUADRATIC_SOURCE_ALE_DIFFUSION = 9  # Quadratic source diffusion equations set subtype
    EXPONENTIAL_SOURCE_ALE_DIFFUSION = 10  # Exponential source diffusion equations set subtype
    MULTI_COMP_TRANSPORT_DIFFUSION = 11  # Multi-compartment transport diffusion equations set subtype
    ADVECTION = 1  # advection equations set subtype
    NO_SOURCE_ADVECTION_DIFFUSION = 1  # No source advection diffusion equations set subtype
    CONSTANT_SOURCE_ADVECTION_DIFFUSION = 2  # Constant source advection diffusion equations set subtype
    LINEAR_SOURCE_ADVECTION_DIFFUSION = 3  # Linear source advection diffusion equations set subtype
    QUADRATIC_SOURCE_ADVEC_DIFF = 4  # Quadratic source advection diffusion equations set subtype
    EXPONENTIAL_SOURCE_ADVEC_DIFF = 5  # Exponential source advection diffusion equations set subtype
    CONSTITUTIVE_LAW_IN_CELLML_EVALUATE = 17  # In CellML evaluated incompressible material law for finite elasticity equations set subtype
    CONSTIT_AND_GROWTH_LAW_IN_CELLML = 33  # CellML evaluated growth and constituative material law for finite elasticity equations set subtype
    NO_SOURCE_ALE_ADVECTION_DIFFUSION = 21  # No source advection diffusion equations set subtype
    CONSTANT_SOURCE_ALE_ADVEC_DIFF = 22  # Constant source advection diffusion equations set subtype
    LINEAR_SOURCE_ALE_ADVEC_DIFF = 23  # Linear source advection diffusion equations set subtype
    QUADRATIC_SOURCE_ALE_ADVEC_DIFF = 24  # Quadratic source advection diffusion equations set subtype
    EXP_SOURCE_ALE_ADVECTION_DIFFUSION = 25  # Exponential source advection diffusion equations set subtype
    NO_SOURCE_STATIC_ADVEC_DIFF = 6  # No source advection diffusion equations set subtype
    CONSTANT_SOURCE_STATIC_ADVEC_DIFF = 7  # Constant source advection diffusion equations set subtype
    LINEAR_SOURCE_STATIC_ADVEC_DIFF = 8  # Linear source advection diffusion equations set subtype
    NO_SOURCE_ADVECTION_DIFF_SUPG = 9  # No source advection diffusion equations set subtype
    CONSTANT_SOURCE_ADVECTION_DIFF_SUPG = 10  # Constant source advection diffusion equations set subtype
    LINEAR_SOURCE_ADVECTION_DIFF_SUPG = 11  # Linear source advection diffusion equations set subtype
    QUAD_SOURCE_ADVECTION_DIFF_SUPG = 12  # Quadratic source advection diffusion equations set subtype
    EXP_SOURCE_ADVECTION_DIFF_SUPG = 13  # Exponential source advection diffusion equations set subtype
    NO_SOURCE_ALE_ADVECTION_DIFF_SUPG = 29  # No source advection diffusion equations set subtype
    CONSTANT_SOURCE_ALE_ADVEC_DIFF_SUPG = 30  # Constant source advection diffusion equations set subtype
    LINEAR_SOURCE_ALE_ADVEC_DIFF_SUPG = 31  # Linear source advection diffusion equations set subtype
    QUAD_SOURCE_ALE_ADVECTION_DIFF_SUPG = 32  # Quadratic source advection diffusion equations set subtype
    EXP_SOURCE_ALE_ADVECTION_DIFF_SUPG = 33  # Exponential source advection diffusion equations set subtype
    NO_SOURCE_STATIC_ADVEC_DIFF_SUPG = 14  # No source advection diffusion equations set subtype
    CONST_SOURCE_STATIC_ADVEC_DIFF_SUPG = 15  # Constant source advection diffusion equations set subtype
    LIN_SOURCE_STATIC_ADVEC_DIFF_SUPG = 16  # Linear source advection diffusion equations set subtype
    COUPLED_SOURCE_DIFFUSION_ADVEC_DIFF = 17  # Coupled source diffusion & advection-diffusion equations set subtype
    MULTI_COMP_TRANSPORT_ADVEC_DIFF = 18  # Multi-component transport advection-diffusion equations set
    MULT_COMP_TRANSPORT_ADVEC_DIFF_SUPG = 19  # Multi-component transport advection-diffusion equations set using SUPG scheme
    CELLML_REAC_SPLIT_REAC_DIFF = 2
    CELLML_REAC_NO_SPLIT_REAC_DIFF = 3
    CONSTANT_REAC_DIFF = 1
    MONODOMAIN_BUENOOROVIO = 1  # First monodomain equations set subtype
    MONODOMAIN_TENTUSSCHER06 = 2  # First monodomain equations set subtype
    FIRST_BIDOMAIN = 1  # First bidomain equations set subtype
    SECOND_BIDOMAIN = 2  # Second bidomain equations set subtype
    STANDARD_DATA_FITTING = 1  # Standard Galerkin Projection equations set subtype
    GENERALISED_DATA_FITTING = 2  # Generalised Galerkin Projection equations set subtype
    MAT_PROPERTIES_DATA_FITTING = 3  # Material Properties Galerkin Projection equations set subtype
    MAT_PROP_INRIA_MODEL_DATA_FITTING = 4  # Material Properties INRIA Model Galerkin Projection equations set subtype
    VECTOR_DATA_FITTING = 5  # Standard Galerkin Projection equations set subtype
    DIVFREE_VECTOR_DATA_FITTING = 6  # Standard Galerkin Projection equations set subtype
    DATA_POINT_VECTOR_STATIC_FITTING = 9  # Standard static Galerkin Projection using data points subtype
    DATA_PT_VECTOR_QUASISTATIC_FITTING = 10  # Standard quasistatic Galerkin Projection using data points subtype
    VECTOR_DATA_PRE_FITTING = 7  # Standard Galerkin Projection equations set subtype
    DIVFREE_VECTOR_DATA_PRE_FITTING = 8  # Standard Galerkin Projection equations set subtype
    COUPLED_SOURCE_DIFFUSION_DIFFUSION = 111  # Coupled source diffusion-diffusion equations set subtype
    STANDARD_MONODOMAIN_ELASTICITY = 141  # Standard Monodomain Elasticity equations set subtype
    OneD3D_MONODOMAIN_ELASTICITY = 142  # Coupled 1D Monodomain 3D Elasticity equations set subtype
    MONODOMAIN_ELASTICITY_W_TITIN = 143  # Coupled 1D Monodomain 3D Elasticity equations set subtype with titin
    MONODOMAIN_ELASTICITY_VELOCITY = 144  # Coupled 1D Monodomain 3D Elasticity equations set subtype with force-velocity relation
    OneD3D_MONODOMAIN_ACTIVE_STRAIN = 145  # Coupled 1D Monodomain 3D Elasticity equations set subtype
    FINITE_ELASTICITY_NAVIER_STOKES_ALE = 151  # Finite Elasticity Navier Stokes ALE equations set subtype


class EquationsSetSolutionMethods(Enum):
    """The solution method parameters
    """

    FEM = 1  # Finite Element Method solution method
    BEM = 2  # Boundary Element Method solution method
    FD = 3  # Finite Difference solution method
    FV = 4  # Finite Volume solution method
    GFEM = 5  # Grid-based Finite Element Method solution method
    GFD = 6  # Grid-based Finite Difference solution method
    GFV = 7  # Grid-based Finite Volume solution method


class EquationsSetDerivedTypes(Enum):
    """EquationsSet derived type parameters
    """

    STRAIN = 1  # Strain tensor field output
    STRESS = 2  # Stress tensor field output


class EquationsSetTensorEvaluateTypes(Enum):
    """Type of tensor to evaluate from an EquationsSet
    """

    DEFORMATION_GRADIENT = 1  # Deformation gradient tensor
    R_CAUCHY_GREEN_DEFORMATION = 2  # Right Cauchy-Green deformation field
    GREEN_LAGRANGE_STRAIN = 3  # Green-Lagrange strain tensor
    CAUCHY_STRESS = 4  # Cauchy-stress tensor
    SECOND_PK_STRESS = 5  # Second Piola Kirchhoff-stress tensor


class EquationsSetDynamicMatrixTypes(Enum):
    """Type of matrix in a dynamic equations set
    """

    STIFFNESS = 1  # A stiffness matrix (multiplies displacement values)
    DAMPING = 2  # A damping matrix (multiplies velocity values)
    MASS = 3  # A mass matrix (multiplies acceleration values)


class EquationsSetLaplaceAnalyticFunctionTypes(Enum):
    """The analytic function types for a Laplace equation
    """

    TWO_DIM_1 = 1  # u=x**2+2*x*y-y**2
    TWO_DIM_2 = 2  # u=cos(x)cosh(y)
    THREE_DIM_1 = 3  # u=x**2-2*y**2+z**2
    THREE_DIM_2 = 4  # u=cos(x)*cosh(y)*z


class EquationsSetHelmholtzAnalyticFunctionTypes(Enum):
    """The analytic function types for a Helmholtz equation
    """

    TWO_DIM_1 = 1  # u=cos(sqrt(2)*k*x)*sin(sqrt(2)*k*y)


class PoiseuilleAnalyticFunctionTypes(Enum):
    """The analytic function types for a Poiseuille equation.
    """

    TWO_DIM_1 = 1  # u=ln(4/(x+y+1^2))


class PoissonAnalyticFunctionTypes(Enum):
    """The analytic function types for a Poisson equation.
    """

    POISSON_EQUATION_TWO_DIM_1 = 1  # u=ln(4/(x+y+1^2))
    POISSON_EQUATION_TWO_DIM_2 = 2  # u=tbd
    POISSON_EQUATION_TWO_DIM_3 = 3  # u=tbd
    POISSON_EQUATION_THREE_DIM_1 = 4  # u=ln(6/(x+y+z+1^2))
    POISSON_EQUATION_THREE_DIM_2 = 5  # u=tbd
    POISSON_EQUATION_THREE_DIM_3 = 6  # u=tbd
    PRESSURE_POISSON_THREE_DIM_1 = 18  # u=tbd
    PRESSURE_POISSON_THREE_DIM_2 = 19  # u=tbd


class DiffusionAnalyticFunctionTypes(Enum):
    """The analytic function types for a diffusion equation.
    """

    DIFFUSION_EQUATION_ONE_DIM_1 = 1
    DIFFUSION_EQUATION_TWO_DIM_1 = 2  # u=exp(-kt)*sin(sqrt(k)*(x*cos(phi)+y*sin(phi)))
    DIFFUSION_EQUATION_THREE_DIM_1 = 3
    LINEAR_SOURCE_DIFFUSION_THREE_DIM_1 = 3
    QUADRATIC_SOURCE_DIFFUSION_ONE_DIM_1 = 1
    EXPONENTIAL_SOURCE_DIFFUSION_ONE_DIM_1 = 1
    MULTI_COMP_DIFFUSION_TWO_COMP_TWO_DIM = 4  # Prescribed solution, using a source term to correct for error - 2D with 2 compartments
    MULTI_COMP_DIFFUSION_TWO_COMP_THREE_DIM = 5  # Prescribed solution, using a source term to correct for error - 3D with 2 compartments
    MULTI_COMP_DIFFUSION_THREE_COMP_THREE_DIM = 6  # Prescribed solution, using a source term to correct for error - 3D with 3 compartments
    MULTI_COMP_DIFFUSION_FOUR_COMP_THREE_DIM = 7  # Prescribed solution, using a source term to correct for error - 3D with 3 compartments


class StokesAnalyticFunctionTypes(Enum):
    """The analytic function types for a Stokes equation.
    """

    TWO_DIM_1 = 1  # u=tbd
    TWO_DIM_2 = 2  # u=tbd
    TWO_DIM_3 = 3  # u=tbd
    TWO_DIM_4 = 4  # u=tbd
    TWO_DIM_5 = 5  # u=tbd
    THREE_DIM_1 = 6  # u=tbd
    THREE_DIM_2 = 7  # u=tbd
    THREE_DIM_3 = 8  # u=tbd
    THREE_DIM_4 = 9  # u=tbd
    THREE_DIM_5 = 10  # u=tbd


class NavierStokesAnalyticFunctionTypes(Enum):
    """The analytic function types for a Navier-Stokes equation.
    """

    TWO_DIM_POISEUILLE = 12  # fully developed 2D channel flow (parabolic)
    TWO_DIM_TAYLOR_GREEN = 13  # 2D dynamic nonlinear Taylor-Green vortex decay
    FLOWRATE_AORTA = 14  # A fourier decomposed flow waveform for boundary conditions
    SINUSOID = 15  # A sinusoidal flow waveform
    SPLINT_FROM_FILE = 17  # Spline integration of dependent values specified in a file
    TWO_DIM_1 = 1  # u=tbd
    TWO_DIM_2 = 2  # u=tbd
    TWO_DIM_3 = 3  # u=tbd
    TWO_DIM_4 = 4  # u=tbd
    TWO_DIM_5 = 5  # u=tbd
    THREE_DIM_1 = 6  # u=tbd
    THREE_DIM_2 = 7  # u=tbd
    THREE_DIM_3 = 8  # u=tbd
    THREE_DIM_4 = 9  # u=tbd
    THREE_DIM_5 = 10  # u=tbd


class DarcyAnalyticFunctionTypes(Enum):
    """The analytic function types for a Darcy equation.
    """

    DARCY_EQUATION_TWO_DIM_1 = 1  # u=tbd
    DARCY_EQUATION_TWO_DIM_2 = 2  # u=tbd
    DARCY_EQUATION_TWO_DIM_3 = 3  # u=tbd
    DARCY_EQUATION_THREE_DIM_1 = 4  # u=tbd
    DARCY_EQUATION_THREE_DIM_2 = 5  # u=tbd
    DARCY_EQUATION_THREE_DIM_3 = 6  # u=tbd
    INCOMP_ELAST_DARCY_ANALYTIC_DARCY = 7  # this is a solution where the finite elasticity solve is skipped to allow easy analytic testing of the mass increase & velocity solve step of incompressible poromechanical model


class BurgersAnalyticFunctionTypes(Enum):
    """The analytic function types for a Burgers equation.
    """

    BURGERS_EQUATION_ONE_DIM_1 = 1
    GENERALISED_BURGERS_EQUATION_ONE_DIM_1 = 1
    GENERALISED_BURGERS_EQUATION_ONE_DIM_2 = 2
    STATIC_BURGERS_EQUATION_ONE_DIM_1 = 1


class EquationsSetLinearElasticityAnalyticFunctionTypes(Enum):
    """The analytic function types for a LinearElasticity equation
    """

    ONE_DIM_1 = 1  # u=tbd
    TWO_DIM_1 = 2  # u=tbd
    TWO_DIM_2 = 3  # u=tbd
    THREE_DIM_1 = 4  # u=tbd
    THREE_DIM_2 = 5  # u=tbd


class EquationsSetFiniteElasticityAnalyticFunctionTypes(Enum):
    """The analytic function types for a FiniteElasticity equation
    """

    CYLINDER = 1  # u=tbd


class AnalyticParamIndices(Enum):
    """Indices for EQUATIONS_SET_ANALYTIC_TYPE%ANALYTIC_USER_PARAMS
    """

    PIN = 1  # Inner pressure parameter index
    POUT = 2  # Outer pressure parameter index
    LAMBDA = 3  # Lambda parameter index
    TSI = 4  # Tsi parameter index
    RIN = 5  # Inner radius parameter index
    ROUT = 6  # Outer radius parameter index
    C1 = 7  # c1 parameter index
    C2 = 8  # c2 parameter index


class FieldDependentTypes(Enum):
    """Depedent field parameter types.
    """

    INDEPENDENT = 1  # Independent field type
    DEPENDENT = 2  # Dependent field type


class FieldDimensionTypes(Enum):
    """Field dimension parameter types.
    """

    SCALAR = 1  # Scalar field
    VECTOR = 2  # Vector field
    TENSOR = 3  # Tensor field


class FieldTypes(Enum):
    """Field type parameters.
    """

    GEOMETRIC = 1  # Geometric field
    FIBRE = 2  # Fibre field
    GENERAL = 3  # General field
    MATERIAL = 4  # Material field
    GEOMETRIC_GENERAL = 5  # Geometric general field


class FieldInterpolationTypes(Enum):
    """Field interpolation parameters.
    """

    CONSTANT = 1  # Constant interpolation. One parameter for the field
    ELEMENT_BASED = 2  # Element based interpolation. Parameters are different in each element
    NODE_BASED = 3  # Node based interpolation. Parameters are nodal based and a basis function is used
    GRID_POINT_BASED = 4  # Grid point based interpolation. Parameters are different at each grid point
    GAUSS_POINT_BASED = 5  # Gauss point based interpolation. Parameters are different at each Gauss point
    DATA_POINT_BASED = 6  # Data point based interpolation. Parameters are different at each data point


class FieldVariableTypes(Enum):
    """Field variable type parameters.
    """

    NUMBER_OF_VARIABLE_SUBTYPES = 4  # The number of subtypes of a variable - i.e., u, du/dn, du/dt, d^2u/dt^2
    U = 1  # Standard variable type i.e., u
    DELUDELN = 2  # Normal derivative variable type i.e., du/dn
    DELUDELT = 3  # First time derivative variable type i.e., du/dt
    DEL2UDELT2 = 4  # Second time derivative variable type i.e., d^2u/dt^2
    V = 5  # Second standard variable type i.e., v
    DELVDELN = 6  # Second normal derivative variable type i.e., dv/dn
    DELVDELT = 7  # Second first time derivative variable type i.e., dv/dt
    DEL2VDELT2 = 8  # Second second time derivative variable type i.e., d^2v/dt^2
    U1 = 9  # Standard variable type i.e., u
    DELU1DELN = 10  # Normal derivative variable type i.e., du/dn
    DELU1DELT = 11  # First time derivative variable type i.e., du/dt
    DEL2U1DELT2 = 12  # Second time derivative variable type i.e., d^2u/dt^2
    U2 = 13  # Standard variable type i.e., u
    DELU2DELN = 14  # Normal derivative variable type i.e., du/dn
    DELU2DELT = 15  # First time derivative variable type i.e., du/dt
    DEL2U2DELT2 = 16  # Second time derivative variable type i.e., d^2u/dt^2
    U3 = 17  # Standard variable type i.e., u
    DELU3DELN = 18  # Normal derivative variable type i.e., du/dn
    DELU3DELT = 19  # First time derivative variable type i.e., du/dt
    DEL2U3DELT2 = 20  # Second time derivative variable type i.e., d^2u/dt^2
    U4 = 21  # Standard variable type i.e., u
    DELU4DELN = 22  # Normal derivative variable type i.e., du/dn
    DELU4DELT = 23  # First time derivative variable type i.e., du/dt
    DEL2U4DELT2 = 24  # Second time derivative variable type i.e., d^2u/dt^2
    U5 = 25  # Standard variable type i.e., u
    DELU5DELN = 26  # Normal derivative variable type i.e., du/dn
    DELU5DELT = 27  # First time derivative variable type i.e., du/dt
    DEL2U5DELT2 = 28  # Second time derivative variable type i.e., d^2u/dt^2
    U6 = 29  # Standard variable type i.e., u
    DELU6DELN = 30  # Normal derivative variable type i.e., du/dn
    DELU6DELT = 31  # First time derivative variable type i.e., du/dt
    DEL2U6DELT2 = 32  # Second time derivative variable type i.e., d^2u/dt^2
    U7 = 33  # Standard variable type i.e., u
    DELU7DELN = 34  # Normal derivative variable type i.e., du/dn
    DELU7DELT = 35  # First time derivative variable type i.e., du/dt
    DEL2U7DELT2 = 36  # Second time derivative variable type i.e., d^2u/dt^2
    U8 = 37  # Standard variable type i.e., u
    DELU8DELN = 38  # Normal derivative variable type i.e., du/dn
    DELU8DELT = 39  # First time derivative variable type i.e., du/dt
    DEL2U8DELT2 = 40  # Second time derivative variable type i.e., d^2u/dt^2
    U9 = 41  # Standard variable type i.e., u
    DELU9DELN = 42  # Normal derivative variable type i.e., du/dn
    DELU9DELT = 43  # First time derivative variable type i.e., du/dt
    DEL2U9DELT2 = 44  # Second time derivative variable type i.e., d^2u/dt^2
    U10 = 45  # Standard variable type i.e., u
    DELU10DELN = 46  # Normal derivative variable type i.e., du/dn
    DELU10DELT = 47  # First time derivative variable type i.e., du/dt
    DEL2U10DELT2 = 48  # Second time derivative variable type i.e., d^2u/dt^2


class FieldDataTypes(Enum):
    """Field data types
    """

    INTG = 1  # Integer field data type
    SP = 2  # Single precision real field data type
    DP = 3  # Double precision real field data type
    L = 4  # Logical field data type


class FieldDOFOrderTypes(Enum):
    """Field DOF order types
    """

    SEPARATED = 1  # Field variable component dofs are not contiguous
    CONTIGUOUS = 2  # Field variable component dofs are contiguous


class FieldParameterSetTypes(Enum):
    """Field parameter set type parameters
    """

    VALUES = 1  # The parameter set corresponding to the field values (at time T+DT for dynamic problems)
    BOUNDARY_CONDITIONS = 2  # The parameter set corresponding to the field boundary condition values
    INITIAL_VALUES = 3  # The parameter set corresponding to the field initial values
    INCREMENTAL_VALUES = 4  # The parameter set corresponding to the field incremental values
    ANALYTIC_VALUES = 5  # The parameter set corresponding to the analytic field values
    PREVIOUS_VALUES = 6  # The parameter set corresponding to the previous field values (at time T)
    MEAN_PREDICTED_DISPLACEMENT = 7  # The parameter set corresponding to the mean predicited avalues (at time T+DT)
    VELOCITY_VALUES = 8  # The parameter set corresponding to the velocity values (at time T+DT)
    INITIAL_VELOCITY = 9  # The parameter set corresponding to the initial velocity values for dynamic problems. This is also the previous velocity values
    PREVIOUS_VELOCITY = 9  # The parameter set corresponding to the previous velocity values (at time T). This is also the initial velocity values for dynamic problems
    MEAN_PREDICTED_VELOCITY = 10  # The parameter set corresponding to the mean predicited velocity values (at time T+DT)
    ACCELERATION_VALUES = 11  # The parameter set corresponding to the acceleration values (at time T+DT)
    INITIAL_ACCELERATION = 12  # The parameter set corresponding to the initial acceleration values for dynamic problems. This is also the previous accelearation values
    PREVIOUS_ACCELERATION = 12  # The parameter set corresponding to the previous acceleration values (at time T).This is also the initial acceleration values for dynamic problems
    MEAN_PREDICTED_ACCELERATION = 13  # The parameter set corresponding to the mean predicited acceleration values (at time T+DT)
    PRESSURE_VALUES = 29  # The parameter set corresponding to the surface pressure values
    PREVIOUS_PRESSURE = 30  # The parameter set corresponding to the previous surface pressure values (at time T)
    IMPERMEABLE_FLAG_VALUES = 34  # The parameter set corresponding to the impermeable flag values
    INTEGRATED_NEUMANN = 35  # Stores integrated Neumann values calculated from Neumann point values
    MESH_DISPLACEMENT = 19  # The parameter set corresponding to the mesh displacement values for ALE
    MESH_VELOCITY = 20  # The parameter set corresponding to the mesh velocity values for ALE


class FieldScalingTypes(Enum):
    """Field scaling type parameters
    """

    NONE = 0  # The field is not scaled
    UNIT = 1  # The field has unit scaling
    ARC_LENGTH = 2  # The field has arc length scaling
    ARITHMETIC_MEAN = 3  # The field has arithmetic mean of the arc length scaling
    GEOMETRIC_MEAN = 4  # The field has geometric mean of the arc length scaling
    HARMONIC_MEAN = 5  # The field has geometric mean of the arc length scaling


class GeneratedMeshTypes(Enum):
    """Generated mesh types.
    """

    REGULAR = 1  # A regular generated mesh
    POLAR = 2  # A polar generated mesh
    FRACTAL_TREE = 3  # A fractal tree generated mesh
    CYLINDER = 4  # A cylinder generated mesh
    ELLIPSOID = 5  # An ellipsoid generated mesh


class GeneratedMeshSurfaceTypes(Enum):
    """Generated mesh surface types.
    """

    CYLINDER_INNER = 1  # Cylinder inner surface constant
    CYLINDER_OUTER = 2  # Cylinder outer surface
    CYLINDER_TOP = 3  # Cylinder top surface constant
    CYLINDER_BOTTOM = 4  # Cylinder bottom surface constant
    ELLIPSOID_INNER = 5  # Ellipsoid inner surface constant
    ELLIPSOID_OUTER = 6  # Ellipsoid outer surface constant
    ELLIPSOID_TOP = 7  # Ellipsoid top surface constant
    REGULAR_LEFT = 8  # Regular left surface constant
    REGULAR_RIGHT = 9  # Regular right surface constant
    REGULAR_TOP = 10  # Regular top surface constant
    REGULAR_BOTTOM = 11  # Regular bottom surface constant
    REGULAR_FRONT = 12  # Regular front surface constant
    REGULAR_BACK = 13  # Regular back surface constant


class InterfaceConditionMethods(Enum):
    """Interface condition methods.
    """

    LAGRANGE_MULTIPLIERS = 1  # Lagrange multipliers interface condition method
    AUGMENTED_LAGRANGE = 2  # Augmented Lagrange multiplers interface condition method
    PENALTY = 3  # Penalty interface condition method
    POINT_TO_POINT = 4  # Point to point interface condition method


class InterfaceConditionOperators(Enum):
    """Interface condition operator types.
    """

    FIELD_CONTINUITY = 1  # Continuous field operator, i.e., lambda.(u1_gauss-u2_gauss)
    FIELD_NORMAL_CONTINUITY = 2  # Continuous field normal operator, i.e., lambda(u_1.n_1-u_2.n_2)
    FLS_CONTACT = 3  # Frictionless contact operator, i.e., lambda.(x_1.n-x_2.n)
    FLS_CONTACT_REPROJECT = 4  # Frictionless contact operator, reproject at each newton iteration and has geometric linearisation terms i.e., lambda.(x_1.n-x_2.n)
    SOLID_FLUID = 5  # Solid fluid operator, i.e., lambda.(v_f-du_s/dt)
    SOLID_FLUID_NORMAL = 6  # Solid fluid normal operator, i.e., lambda(v_f.n_f-du_s/dt.n_s)


class InterfaceConditionIntegrationTypes(Enum):
    """Interface condition integration types.
    """

    GAUSS = 1  # Gauss points integration type, i.e. Loop over element Gauss points and sum up their contribution
    DATA_POINTS = 2  # Data points integration type i.e. Loop over data points and  sum up their contribution


class DecompositionTypes(Enum):
    """The Decomposition types parameters
    """

    ALL = 1  # The decomposition contains all elements
    CALCULATED = 2  # The element decomposition is calculated by graph partitioning
    USER_DEFINED = 3  # The user will set the element decomposition


class MatrixStorageTypes(Enum):
    """Type of matrix storage.
    """

    BLOCK = 0  # Distributed matrix block storage type
    DIAGONAL = 1  # Distributed matrix diagonal storage type
    COLUMN_MAJOR = 2  # Distributed matrix column major storage type
    ROW_MAJOR = 3  # Distributed matrix row major storage type
    COMPRESSED_ROW = 4  # Distributed matrix compressed row storage type
    COMPRESSED_COLUMN = 5  # Distributed matrix compressed column storage type
    ROW_COLUMN = 6  # Distributed matrix row-column storage type


class MatrixVectorDataTypes(Enum):
    """Type of data stored in matrices and vectors.
    """

    INTG = 1
    SP = 4  # Single precision real distributed matrix-vector data type
    DP = 5  # Double precision real distributed matrix-vector data type
    L = 8  # Logical distributed matrix-vector data type


class ProblemClasses(Enum):
    """Problem classes.
    """

    NONE = 0  # No problem class
    ELASTICITY = 1  # Elasticity problem class
    FLUID_MECHANICS = 2  # Fluid mechanics problem class
    ELECTROMAGNETICS = 3  # Electromagnetics problem class
    CLASSICAL_FIELD = 4  # Classical field problem class
    BIOELECTRICS = 5  # Bioelectrics problem class
    MODAL = 6  # Modal problem class
    FITTING = 7  # Fitting problem class
    OPTIMISATION = 8  # Optimisation problem class
    MULTI_PHYSICS = 9  # Multi physics problem class


class ProblemTypes(Enum):
    """Problem Types.
    """

    NONE = 0  # No problem type
    LINEAR_ELASTICITY = 1  # Linear elasticity problem type
    FINITE_ELASTICITY = 2  # Finite elasticity problem type
    LINEAR_ELASTICITY_CONTACT = 3  # Linear elasticity problem subject to contact contstraint type
    FINITE_ELASTICITY_CONTACT = 4  # Finite elasticity problem subject to contact constraint type
    STOKES_EQUATION = 1  # Stokes equation problem type
    NAVIER_STOKES_EQUATION = 2  # Navier-Stokes problem type
    DARCY_EQUATION = 3  # Darcy equation problem type
    POISEUILLE_EQUATION = 5  # Poiseuille equation problem type
    BURGERS_EQUATION = 6  # Burgers equation problem type
    ELECTROSTATIC = 1  # Electrostatic problem type
    MAGNETOSTATIC = 2  # Magnetostatic problem type
    MAXWELLS_EQUATIONS = 3  # Maxwell's equations problem type
    LAPLACE_EQUATION = 1  # Laplace problem type
    POISSON_EQUATION = 2  # Poisson problem type
    HELMHOLTZ_EQUATION = 3  # Helmholtz problem type
    WAVE_EQUATION = 4  # Wave equation problem type
    DIFFUSION_EQUATION = 6  # Diffusion equation problem type
    ADVECTION_DIFFUSION_EQUATION = 7  # Advection-Diffusion equation problem type
    REACTION_DIFFUSION_EQUATION = 8  # Reaction-Diffusion equation problem type
    BIHARMONIC_EQUATION = 9  # Bi-harmonic equation problem type
    MONODOMAIN_EQUATION = 1  # Monodomain equation problem type
    BIDOMAIN_EQUATION = 2  # Bidomain equation problem type
    LINEAR_ELASTIC_MODAL = 1  # Linear elastic modal problem type
    DATA_FITTING = 10  # Galerkin projection problem type
    FINITE_ELASTICITY_DARCY = 1  # Finite Elasticity Darcy problem type
    FINITE_ELASTICITY_STOKES = 2  # Finite Elasticity Stokes problem type
    FINITE_ELASTICITY_NAVIER_STOKES = 3  # Finite Elasticity NavierStokes problem type
    DIFFUSION_DIFFUSION = 4  # Diffusion Diffusion problem type
    DIFFUSION_ADVECTION_DIFFUSION = 5  # Diffusion Advection Diffusion problem type
    MULTI_COMPARTMENT_TRANSPORT = 6  # Multi-compartment transport problem type
    FINITE_ELASTICITY_FLUID_PRESSURE = 7  # Finite elasticity fluid pressure problem type
    BIOELECTRIC_FINITE_ELASTICITY = 8  # Monodomain finite elasticity problem type
    MONODOMAIN_STRANG_SPLITTING_EQUATION = 3  # Monodomain equation problem type


class ProblemSubtypes(Enum):
    """Problem Subtypes.
    """

    NONE = 0  # No problem subtype
    STATIC_STOKES = 1  # Static Stokes problem subtype
    LAPLACE_STOKES = 2  # Laplace type Stokes problem subtype
    TRANSIENT_STOKES = 3  # Transient Stokes problem subtype
    ALE_STOKES = 5  # ALE Stokes problem subtype
    PGM_STOKES = 6  # PGM Stokes problem subtype
    OPTIMISED_STOKES = 4  # Optimised Stokes problem subtype
    STATIC_NAVIER_STOKES = 1  # Static Navier-Stokes problem subtype
    LAPLACE_NAVIER_STOKES = 2  # Laplace type Navier-Stokes problem subtype
    TRANSIENT_NAVIER_STOKES = 3  # Transient Navier-Stokes problem subtype
    TRANSIENT_RBS_NAVIER_STOKES = 9  # Transient stabilised Navier-Stokes problem subtype
    MULTISCALE_NAVIER_STOKES = 10  # Transient stabilised Navier-Stokes problem with multiscale boundary coupling subtype
    TRANSIENT1D_NAVIER_STOKES = 8  # TRANSIENT1D Navier-Stokes problem subtype
    COUPLED1D0D_NAVIER_STOKES = 11  # Coupled 1D-DAE Navier-Stokes problem subtype
    TRANSIENT1D_ADV_NAVIER_STOKES = 13  # TRANSIENT1D Navier-Stokes problem subtype with Advection
    COUPLED1D0D_ADV_NAVIER_STOKES = 14  # Coupled 1D-DAE Navier-Stokes problem subtype with Advection
    STREE1D0D = 14  # Coupled 1D-DAE Navier-Stokes problem subtype with Advection
    STREE1D0D_ADV = 14  # Coupled 1D-DAE Navier-Stokes problem subtype with Advection
    ALE_NAVIER_STOKES = 5  # ALE Navier-Stokes problem subtype
    PGM_NAVIER_STOKES = 6  # PGM Navier-Stokes problem subtype
    OPTIMISED_NAVIER_STOKES = 4  # Optimised Navier-Stokes problem subtype
    STANDARD_DARCY = 1  # Standard Darcy problem subtype
    QUASISTATIC_DARCY = 2  # Quasistatic Darcy problem subtype
    ALE_DARCY = 3  # ALE Darcy problem subtype
    TRANSIENT_DARCY = 4  # Transient Darcy problem subtype
    PGM_DARCY = 5  # PGM Darcy problem subtype
    PGM_TRANSIENT_DARCY = 6  # PGM Transient Darcy problem subtype
    STANDARD_LAPLACE = 1  # Standard Laplace problem subtype
    GENERALISED_LAPLACE = 2  # Generalised Laplace problem subtype
    STATIC_POISEUILLE = 1  # Static Poiseuille problem subtype
    DYNAMIC_POISEUILLE = 2  # Static Poiseuille problem subtype
    EXTRACELLULAR_BIDOMAIN_POISSON = 7  # Linear source Poisson problem subtype
    LINEAR_SOURCE_POISSON = 1  # Linear source Poisson problem subtype
    LINEAR_PRESSURE_POISSON = 3  # Vector source Poisson problem subtype
    NONLINEAR_PRESSURE_POISSON = 4  # Vector source Poisson problem subtype
    ALE_PRESSURE_POISSON = 5  # Vector source Poisson problem subtype
    FITTED_PRESSURE_POISSON = 6  # Vector source Poisson problem subtype
    NONLINEAR_SOURCE_POISSON = 2  # Nonlinear source Poisson problem subtype
    STANDARD_HELMHOLTZ = 2  # No source Helmholtz problem subtype
    GENERALISED_HELMHOLTZ = 3  # No source Helmholtz problem subtype
    NO_SOURCE_DIFFUSION = 1  # No source Diffusion problem subtype
    LINEAR_SOURCE_DIFFUSION = 2  # Linear source Diffusion problem subtype
    NONLINEAR_SOURCE_DIFFUSION = 3  # Nonlinear source Diffusion problem subtype
    NO_SOURCE_ALE_DIFFUSION = 4  # No source Diffusion problem subtype
    LINEAR_SOURCE_ALE_DIFFUSION = 5  # Linear source Diffusion problem subtype
    NONLINEAR_SOURCE_ALE_DIFFUSION = 6  # Nonlinear source Diffusion problem subtype
    NO_SOURCE_ADVECTION_DIFFUSION = 1  # No source advection-Diffusion problem subtype
    LINEAR_SOURCE_ADVECTION_DIFFUSION = 2  # Linear source advection-Diffusion problem subtype
    NONLINEAR_SOURCE_ADVECTION_DIFFUSION = 3  # Nonlinear source advection-Diffusion problem subtype
    NO_SOURCE_ALE_ADVECTION_DIFFUSION = 4  # No source advection-Diffusion problem subtype
    LINEAR_SOURCE_ALE_ADVECTION_DIFFUSION = 5  # Linear source advection-Diffusion problem subtype
    NONLINEAR_SOURCE_ALE_ADVECTION_DIFFUSION = 6  # Nonlinear source advection-Diffusion problem subtype
    NO_SOURCE_STATIC_ADVEC_DIFF = 7  # No source advection-Diffusion problem subtype
    LINEAR_SOURCE_STATIC_ADVEC_DIFF = 8  # Linear source advection-Diffusion problem subtype
    NONLINEAR_SOURCE_STATIC_ADVEC_DIFF = 9  # Nonlinear source advection-Diffusion problem subtype
    STATIC_BURGERS = 1  # static Burgers problem subtype
    DYNAMIC_BURGERS = 2  # dynamic Burgers problem subtype
    CELLML_REAC_INTEG_REAC_DIFF_STRANG_SPLIT = 1
    CELLML_REAC_EVAL_REAC_DIFF_NO_SPLIT = 2
    CONSTANT_REAC_DIFF_NO_SPLIT = 3
    STANDARD_DATA_FITTING = 1  # Standard Galerkin projection problem subtype
    VECTOR_DATA_FITTING = 4  # Standard Galerkin projection problem subtype
    DIV_FREE_VECTOR_DATA_FITTING = 5  # Standard Galerkin projection problem subtype
    DATA_POINT_VECTOR_STATIC_FITTING = 8  # Standard static Galerkin projection problem using data points subtype
    DATA_PT_VECTOR_QUASISTATIC_FITTING = 9  # Standard quasistatic Galerkin projection problem using data points subtype
    VECTOR_DATA_PRE_FITTING = 6  # Standard Galerkin projection problem subtype
    DIV_FREE_VECTOR_DATA_PRE_FITTING = 7  # Standard Galerkin projection problem subtype
    GENERALISED_DATA_FITTING = 2  # Generalised Galerkin projection problem subtype
    MAT_PROPERTIES_DATA_FITTING = 3  # Material Properties Galerkin projection problem subtype
    STANDARD_ELASTICITY_DARCY = 101  # Standard Elasticity Darcy problem subtype
    PGM_ELASTICITY_DARCY = 102  # PGM Elasticity Darcy problem subtype
    QUASISTATIC_ELASTICITY_TRANSIENT_DARCY = 103  # Quasistatic Elasticity Transient Darcy problem subtype
    QUASISTATIC_ELAST_TRANS_DARCY_MAT_SOLVE = 104  # Quasistatic Elasticity Transient Darcy Material Solve problem subtype
    COUPLED_SOURCE_DIFFUSION_DIFFUSION = 111  # Coupled source diffusion-diffusion problem subtype
    COUPLED_SOURCE_DIFFUSION_ADVEC_DIFFUSION = 121  # Coupled source diffusion & advection-diffusion problem subtype
    STANDARD_MULTI_COMPARTMENT_TRANSPORT = 131  # Standard multi-compartment transport problem subtype
    STANDARD_ELASTICITY_FLUID_PRESSURE = 133  # Standard elasticity fluid pressure problem subtype
    GUDUNOV_MONODOMAIN_SIMPLE_ELASTICITY = 141  # Transient monodomain simple elasticity problem subtype
    GUDUNOV_MONODOMAIN_1D3D_ELASTICITY = 142  # Transient monodomain simple elasticity problem subtype
    MONODOMAIN_ELASTICITY_W_TITIN = 143  # Transient monodomain simple elasticity problem subtype with titin
    MONODOMAIN_ELASTICITY_VELOCITY = 144  # Transient monodomain simple elasticity problem subtype with force-velocity relation
    MONODOMAIN_1D3D_ACTIVE_STRAIN = 145  # Transient monodomain active strain elasticity problem subtype
    FINITE_ELASTICITY_NAVIER_STOKES_ALE = 151  # Coupled Finite Elasticity Navier Stokes moving mesh subtype
    QUASISTATIC_FINITE_ELASTICITY = 1  # Quasistatic finite elasticity subtype
    FINITE_ELASTICITY_CELLML = 2  # Quasistatic finite elasticity subtype
    MULTISCALE_FINITE_ELASTICITY = 3  # Multiscale finite elasticity subtype
    FINITE_ELASTICITY_WITH_GROWTH_CELLML = 4  # Quasistatic finite elasticity subtype
    MONODOMAIN_GUDUNOV_SPLIT = 1  # Monodomain Gudunov split problem subtype
    MONODOMAIN_STRANG_SPLIT = 2  # Monodomain Gudunov split problem subtype
    BIDOMAIN_GUDUNOV_SPLIT = 1  # Bidomain Gudunov split problem subtype
    BIDOMAIN_STRANG_SPLIT = 2  # Bidomain Gudunov split problem subtype
    MONODOMAIN_BUENOOROVIO = 1  # Generalised Laplace problem subtype
    MONODOMAIN_TENTUSSCHER06 = 2  # Generalised Laplace problem subtype
    LE_CONTACT_TRANSFORM_REPROJECT = 1  # linear elasticity problem subject to contact constraint, transform field at load increments and reproject at Newton iterations
    LE_CONTACT_TRANSFORM = 2  # linear elasticity problem subject to contact constraint, transform field at load increments
    LE_CONTACT_REPROJECT = 3  # linear elasticity problem subject to contact constraint, reproject at Newton iterations
    FE_CONTACT_TRANSFORM_REPROJECT = 4  # linear elasticity problem subject to contact constraint, transform field at load increments and reproject at Newton iterations
    FE_CONTACT_TRANSFORM = 5  # finear elasticity problem subject to contact constraint, transform field at load increments
    FE_CONTACT_REPROJECT = 6  # finear elasticity problem subject to contact constraint, reproject at Newton iterations


class ProblemControlLoopTypes(Enum):
    """Problem control loop type parameters
    """

    SIMPLE = 1  # Simple, one iteration control loop
    FIXED_LOOP = 2  # Fixed iteration control loop
    TIME_LOOP = 3  # Time control loop
    WHILE_LOOP = 4  # While control loop
    LOAD_INCREMENT_LOOP = 5  # Load increment control loop


class SolverTypes(Enum):
    """The types of solver
    """

    LINEAR = 1  # A linear solver
    NONLINEAR = 2  # A nonlinear solver
    DYNAMIC = 3  # A dynamic solver
    DAE = 4  # A differential-algebraic equation solver
    EIGENPROBLEM = 5  # A eigenproblem solver
    OPTIMISER = 6  # An optimiser solver


class SolverLibraries(Enum):
    """The types of solver libraries.
    """

    CMISS = 1  # CMISS (internal) solver library
    PETSC = 2  # PETSc solver library
    MUMPS = 3  # MUMPS solver library
    SUPERLU = 4  # SuperLU solver library
    SPOOLES = 5  # SPOOLES solver library
    UMFPACK = 6  # UMFPACK solver library
    LUSOL = 7  # LUSOL solver library
    ESSL = 8  # ESSL solver library
    LAPACK = 9  # LAPACK solver library
    TAO = 10  # TAO solver library
    HYPRE = 11  # Hypre solver library
    PASTIX = 12  # PaStiX solver library


class LinearSolverTypes(Enum):
    """The types of linear solvers.
    """

    DIRECT = 1  # Direct linear solver type
    ITERATIVE = 2  # Iterative linear solver type


class DirectLinearSolverTypes(Enum):
    """The types of direct linear solvers. \todo Move libraries to a more appropriate place.
    """

    LU = 1  # LU direct linear solver
    CHOLESKY = 2  # Cholesky direct linear solver
    SVD = 3  # SVD direct linear solver


class IterativeLinearSolverTypes(Enum):
    """The types of iterative linear solvers.
    """

    RICHARDSON = 1  # Richardson iterative solver type
    CHEBYSHEV = 2  # Chebychev iterative solver type
    CONJUGATE_GRADIENT = 3  # Conjugate gradient iterative solver type
    BICONJUGATE_GRADIENT = 4  # Bi-conjugate gradient iterative solver type
    GMRES = 5  # Generalised minimum residual iterative solver type
    BiCGSTAB = 6  # Stabalised bi-conjugate gradient iterative solver type
    CONJGRAD_SQUARED = 7  # Conjugate gradient squared iterative solver type


class IterativePreconditionerTypes(Enum):
    """The types of iterative preconditioners.
    """

    NONE = 0  # No preconditioner type
    JACOBI = 1  # Jacobi preconditioner type
    BLOCK_JACOBI = 2  # Iterative block Jacobi preconditioner type
    SOR = 3  # Successive over relaxation preconditioner type
    INCOMPLETE_CHOLESKY = 4  # Incomplete Cholesky preconditioner type
    INCOMPLETE_LU = 5  # Incomplete LU preconditioner type
    ADDITIVE_SCHWARZ = 6  # Additive Schwrz preconditioner type


class NonlinearSolverTypes(Enum):
    """The types of nonlinear solvers.
    """

    NEWTON = 1  # Newton nonlinear solver type
    BFGS_INVERSE = 2  # BFGS inverse nonlinear solver type
    SQP = 3  # Sequential Quadratic Program nonlinear solver type
    QUASI_NEWTON = 4  # Quasi-Newton nonlinear solver type


class QuasiNewtonSolverTypes(Enum):
    """The types of nonlinear Quasi-Newton solvers
    """

    LINESEARCH = 1  # Quasi-Newton line search nonlinear solver type
    TRUSTREGION = 2  # Quasi-Newton trust region nonlinear solver type


class QuasiNewtonTypes(Enum):
    """The nonlinear Quasi-Newton types
    """

    LBFGS = 1  # LBFGS Quasi-Newton type
    GOODBROYDEN = 2  # "Good" Broyden Quasi-Newton type
    BADBROYDEN = 3  # "Bad" Broyden Quasi-Newton type


class QuasiNewtonLineSearchTypes(Enum):
    """The types of line search techniques for Quasi-Newton line search nonlinear solvers
    """

    BASIC = 1  # Simple damping line search
    L2 = 2  # Secant line search over the L2 norm of the function
    CP = 3  # Critical point secant line search


class QuasiNewtonRestartTypes(Enum):
    """The nonlinear Quasi-Newton restart types
    """

    NONE = 1  # Never restart
    POWELL = 2  # Restart based upon descent criteria
    PERIODIC = 3  # Restart after a fixed number of iterations


class QuasiNewtonScaleTypes(Enum):
    """The nonlinear Quasi-Newton scale types
    """

    NONE = 1  # Don't scale the problem
    SHANNO = 2  # Use Shanno scaling
    LINESEARCH = 3  # Scale based upon line search lambda
    JACOBIAN = 4  # Scale by inverting a previously computed Jacobian


class NewtonSolverTypes(Enum):
    """The types of nonlinear Newton solvers.
    """

    LINESEARCH = 1  # Newton line search nonlinear solver type
    TRUSTREGION = 2  # Newton trust region nonlinear solver type


class NewtonLineSearchTypes(Enum):
    """The types line search techniques for Newton line search nonlinear solvers.
    """

    LINEAR = 2  # Linear line search for Newton line search nonlinear solves
    QUADRATIC = 3  # Quadratic search for Newton line search nonlinear solves
    CUBIC = 4  # Cubic search for Newton line search nonlinear solves


class JacobianCalculationTypes(Enum):
    """The Jacobian calculation types for a nonlinear solver.
    """

    NOT = 1  # The Jacobian values will not be calculated for the nonlinear equations set
    EQUATIONS = 2  # The Jacobian values will be calculated  analytically for the nonlinear equations set
    FD = 3  # The Jacobian values will be calcualted using finite differences for the nonlinear equations set


class NewtonConvergenceTypes(Enum):
    """The convergence test types for a nonlinear newton solver.
    """

    PETSC_DEFAULT = 1  # Newton solver Petsc default convergence test type
    ENERGY_NORM = 2  # Newton solver energy norm convergence test type
    DIFFERENTIATED_RATIO = 3  # Newton solver Sum of differentiated ratios of unconstrained to constrained residuals convergence test type


class DynamicOrderTypes(Enum):
    """The order types for a dynamic solver.
    """

    FIRST = 1  # Dynamic solver has first order terms
    SECOND = 2  # Dynamic solver has second order terms


class DynamicLinearityTypes(Enum):
    """The time linearity types for a dynamic solver.
    """

    LINEAR = 1  # Dynamic solver has linear terms
    NONLINEAR = 2  # Dynamic solver has nonlinear terms


class DynamicDegreeTypes(Enum):
    """The time interpolation polynomial degree types for a dynamic solver.
    """

    FIRST = 1  # Dynamic solver uses a first degree polynomial for time interpolation
    SECOND = 2  # Dynamic solver uses a second degree polynomial for time interpolation
    THIRD = 3  # Dynamic solver uses a third degree polynomial for time interpolation


class DynamicSchemeTypes(Enum):
    """The types of dynamic solver scheme.
    """

    EULER = 1  # Euler (explicit) dynamic solver
    BACKWARD_EULER = 2  # Backward Euler (implicit) dynamic solver
    CRANK_NICOLSON = 3  # Crank-Nicolson dynamic solver
    GALERKIN = 4  # Galerkin dynamic solver
    ZLAMAL = 5  # Zlamal dynamic solver
    SECOND_DEGREE_GEAR = 6  # 2nd degree Gear dynamic solver
    SECOND_DEGREE_LINIGER1 = 7  # 1st 2nd degree Liniger dynamic solver
    SECOND_DEGREE_LINIGER2 = 8  # 2nd 2nd degree Liniger dynamic solver
    NEWMARK1 = 9  # 1st Newmark dynamic solver
    NEWMARK2 = 10  # 2nd Newmark dynamic solver
    NEWMARK3 = 11  # 3rd Newmark dynamic solver
    THIRD_DEGREE_GEAR = 12  # 3rd degree Gear dynamic solver
    THIRD_DEGREE_LINIGER1 = 13  # 1st 3rd degree Liniger dynamic solver
    THIRD_DEGREE_LINIGER2 = 14  # 2nd 3rd degree Liniger dynamic solver
    HOUBOLT = 15  # Houbolt dynamic solver
    WILSON = 16  # Wilson dynamic solver
    BOSSAK_NEWMARK1 = 17  # 1st Bossak-Newmark dynamic solver
    BOSSAK_NEWMARK2 = 18  # 2nd Bossak-Newmark dynamic solver
    HILBERT_HUGHES_TAYLOR1 = 19  # 1st Hilbert-Hughes-Taylor dynamic solver
    HILBERT_HUGHES_TAYLOR2 = 20  # 1st Hilbert-Hughes-Taylor dynamic solver
    USER_DEFINED = 21  # User specified degree and theta dynamic solver


class DAETypes(Enum):
    """The type of differential-algebraic equation.
    """

    DIFFERENTIAL_ONLY = 0  # Differential equations only
    INDEX_1 = 1  # Index 1 differential-algebraic equation
    INDEX_2 = 2  # Index 2 differential-algebraic equation
    INDEX_3 = 3  # Index 3 differential-algebraic equation


class DAESolverTypes(Enum):
    """The differential-algebraic equation solver types for a differential-algebraic equation solver.
    """

    EULER = 1  # Euler differential-algebraic equation solver
    CRANK_NICOLSON = 2  # Crank-Nicolson differential-algebraic equation solver
    RUNGE_KUTTA = 3  # Runge-Kutta differential-algebraic equation solver
    ADAMS_MOULTON = 4  # Adams-Moulton differential-algebraic equation solver
    BDF = 5  # General BDF differential-algebraic equation solver
    RUSH_LARSON = 6  # Rush-Larson differential-algebraic equation solver
    EXTERNAL = 7  # External (e.g., CellML generated) differential-algebraic equation solver


class EulerDAESolverTypes(Enum):
    """The Euler solver types for a differential-algebriac equation solver.
    """

    FORWARD = 1  # Forward Euler differential equation solver
    BACKWARD = 2  # Backward Euler differential equation solver
    IMPROVED = 3  # Improved Euler differential equation solver


class SolutionInitialiseTypes(Enum):
    """The types of solution initialisation.
    """

    ZERO = 0  # Initialise the solution by zeroing it before a solve
    CURRENT_FIELD = 1  # Initialise the solution by copying in the current dependent field values
    NO_CHANGE = 2  # Do not change the solution before a solve


class SolverOutputTypes(Enum):
    """The types of output.
    """

    NONE = 0  # No output from the solver routines
    PROGRESS = 1  # Progress output from solver routines
    TIMING = 2  # Timing output from the solver routines plus below
    SOLVER = 3  # Solver specific output from the solver routines plus below
    MATRIX = 4  # Solver matrices output from the solver routines plus below


class SolverEquationsSparsityTypes(Enum):
    """The types of sparse solver equations matrices.
    """

    SPARSE = 1  # Use sparse solver matrices
    FULL = 2  # Use fully populated solver matrices


# Redirection for field routines that have separate methods
# for different data types


def Field_ParameterSetDataGet(self, *args):
    variableType, fieldSetType = args
    routines = {
        FieldDataTypes.INTG: self.ParameterSetDataGetIntg,
        FieldDataTypes.SP: self.ParameterSetDataGetSP,
        FieldDataTypes.DP: self.ParameterSetDataGetDP,
        FieldDataTypes.L: self.ParameterSetDataGetL,
    }
    data_type = self.DataTypeGet(variableType)
    return routines[data_type](*args)


def Field_ParameterSetDataRestore(self, *args):
    variableType, fieldSetType, parameters = args
    routines = {
        FieldDataTypes.INTG: self.ParameterSetDataRestoreIntg,
        FieldDataTypes.SP: self.ParameterSetDataRestoreSP,
        FieldDataTypes.DP: self.ParameterSetDataRestoreDP,
        FieldDataTypes.L: self.ParameterSetDataRestoreL,
    }
    data_type = self.DataTypeGet(variableType)
    return routines[data_type](*args)


def Field_ComponentValuesInitialise(self, *args):
    variableType = args[0]
    routines = {
        FieldDataTypes.INTG: self.ComponentValuesInitialiseIntg,
        FieldDataTypes.SP: self.ComponentValuesInitialiseSP,
        FieldDataTypes.DP: self.ComponentValuesInitialiseDP,
        FieldDataTypes.L: self.ComponentValuesInitialiseL,
    }
    data_type = self.DataTypeGet(variableType)
    return routines[data_type](*args)


def Field_ParameterSetGetConstant(self, *args):
    variableType = args[0]
    routines = {
        FieldDataTypes.INTG: self.ParameterSetGetConstantIntg,
        FieldDataTypes.SP: self.ParameterSetGetConstantSP,
        FieldDataTypes.DP: self.ParameterSetGetConstantDP,
        FieldDataTypes.L: self.ParameterSetGetConstantL,
    }
    data_type = self.DataTypeGet(variableType)
    return routines[data_type](*args)


def Field_ParameterSetGetElement(self, *args):
    variableType = args[0]
    routines = {
        FieldDataTypes.INTG: self.ParameterSetGetElementIntg,
        FieldDataTypes.SP: self.ParameterSetGetElementSP,
        FieldDataTypes.DP: self.ParameterSetGetElementDP,
        FieldDataTypes.L: self.ParameterSetGetElementL,
    }
    data_type = self.DataTypeGet(variableType)
    return routines[data_type](*args)


def Field_ParameterSetGetGaussPoint(self, *args):
    variableType = args[0]
    routines = {
        FieldDataTypes.DP: self.ParameterSetGetGaussPointDP,
    }
    data_type = self.DataTypeGet(variableType)
    return routines[data_type](*args)


def Field_ParameterSetGetNode(self, *args):
    variableType = args[0]
    routines = {
        FieldDataTypes.INTG: self.ParameterSetGetNodeIntg,
        FieldDataTypes.SP: self.ParameterSetGetNodeSP,
        FieldDataTypes.DP: self.ParameterSetGetNodeDP,
        FieldDataTypes.L: self.ParameterSetGetNodeL,
    }
    data_type = self.DataTypeGet(variableType)
    return routines[data_type](*args)


def Field_ParameterSetUpdateConstant(self, *args):
    variableType = args[0]
    routines = {
        FieldDataTypes.INTG: self.ParameterSetUpdateConstantIntg,
        FieldDataTypes.SP: self.ParameterSetUpdateConstantSP,
        FieldDataTypes.DP: self.ParameterSetUpdateConstantDP,
        FieldDataTypes.L: self.ParameterSetUpdateConstantL,
    }
    data_type = self.DataTypeGet(variableType)
    return routines[data_type](*args)


def Field_ParameterSetUpdateElement(self, *args):
    variableType = args[0]
    routines = {
        FieldDataTypes.INTG: self.ParameterSetUpdateElementIntg,
        FieldDataTypes.SP: self.ParameterSetUpdateElementSP,
        FieldDataTypes.DP: self.ParameterSetUpdateElementDP,
        FieldDataTypes.L: self.ParameterSetUpdateElementL,
    }
    data_type = self.DataTypeGet(variableType)
    return routines[data_type](*args)


def Field_ParameterSetUpdateGaussPoint(self, *args):
    variableType = args[0]
    routines = {
        FieldDataTypes.INTG: self.ParameterSetUpdateGaussPointIntg,
        FieldDataTypes.SP: self.ParameterSetUpdateGaussPointSP,
        FieldDataTypes.DP: self.ParameterSetUpdateGaussPointDP,
        FieldDataTypes.L: self.ParameterSetUpdateGaussPointL,
    }
    data_type = self.DataTypeGet(variableType)
    return routines[data_type](*args)


def Field_ParameterSetUpdateNode(self, *args):
    variableType = args[0]
    routines = {
        FieldDataTypes.INTG: self.ParameterSetUpdateNodeIntg,
        FieldDataTypes.SP: self.ParameterSetUpdateNodeSP,
        FieldDataTypes.DP: self.ParameterSetUpdateNodeDP,
        FieldDataTypes.L: self.ParameterSetUpdateNodeL,
    }
    data_type = self.DataTypeGet(variableType)
    return routines[data_type](*args)


def Field_ParameterSetAddConstant(self, *args):
    variableType = args[0]
    routines = {
        FieldDataTypes.INTG: self.ParameterSetAddConstantIntg,
        FieldDataTypes.SP: self.ParameterSetAddConstantSP,
        FieldDataTypes.DP: self.ParameterSetAddConstantDP,
        FieldDataTypes.L: self.ParameterSetAddConstantL,
    }
    data_type = self.DataTypeGet(variableType)
    return routines[data_type](*args)


def Field_ParameterSetAddElement(self, *args):
    variableType = args[0]
    routines = {
        FieldDataTypes.INTG: self.ParameterSetAddElementIntg,
        FieldDataTypes.SP: self.ParameterSetAddElementSP,
        FieldDataTypes.DP: self.ParameterSetAddElementDP,
        FieldDataTypes.L: self.ParameterSetAddElementL,
    }
    data_type = self.DataTypeGet(variableType)
    return routines[data_type](*args)


def Field_ParameterSetAddNode(self, *args):
    variableType = args[0]
    routines = {
        FieldDataTypes.INTG: self.ParameterSetAddNodeIntg,
        FieldDataTypes.SP: self.ParameterSetAddNodeSP,
        FieldDataTypes.DP: self.ParameterSetAddNodeDP,
        FieldDataTypes.L: self.ParameterSetAddNodeL,
    }
    data_type = self.DataTypeGet(variableType)
    return routines[data_type](*args)


def Field_ParameterSetInterpolateGauss(self, *args):
    variableType = args[0]
    routines = {
        FieldDataTypes.DP: self.ParameterSetInterpolateGaussDP,
    }
    data_type = self.DataTypeGet(variableType)
    return routines[data_type](*args)


Field.ParameterSetDataGet = Field_ParameterSetDataGet
Field.ParameterSetDataRestore = Field_ParameterSetDataRestore
Field.ComponentValuesInitialise = Field_ComponentValuesInitialise

Field.ParameterSetGetConstant = Field_ParameterSetGetConstant
Field.ParameterSetGetElement = Field_ParameterSetGetElement
Field.ParameterSetGetGaussPoint = Field_ParameterSetGetGaussPoint
Field.ParameterSetGetNode = Field_ParameterSetGetNode

Field.ParameterSetUpdateConstant = Field_ParameterSetUpdateConstant
Field.ParameterSetUpdateElement = Field_ParameterSetUpdateElement
Field.ParameterSetUpdateGaussPoint = Field_ParameterSetUpdateGaussPoint
Field.ParameterSetUpdateNode = Field_ParameterSetUpdateNode

Field.ParameterSetAddConstant = Field_ParameterSetAddConstant
Field.meterSetAddElement = Field_ParameterSetAddElement
Field.ParameterSetAddNode = Field_ParameterSetAddNode

Field.ParameterSetInterpolateGauss = Field_ParameterSetInterpolateGauss


def DistributedMatrix_DataGet(self, *args):
    routines = {
        MatrixVectorDataTypes.INTG: self.DataGetIntg,
        MatrixVectorDataTypes.SP: self.DataGetSP,
        MatrixVectorDataTypes.DP: self.DataGetDP,
        MatrixVectorDataTypes.L: self.DataGetL,
    }
    data_type = self.DataTypeGet()
    return routines[data_type](*args)


def DistributedMatrix_DataRestore(self, *args):
    routines = {
        MatrixVectorDataTypes.INTG: self.DataRestoreIntg,
        MatrixVectorDataTypes.SP: self.DataRestoreSP,
        MatrixVectorDataTypes.DP: self.DataRestoreDP,
        MatrixVectorDataTypes.L: self.DataRestoreL,
    }
    data_type = self.DataTypeGet()
    return routines[data_type](*args)


def DistributedVector_DataGet(self, *args):
    routines = {
        MatrixVectorDataTypes.INTG: self.DataGetIntg,
        MatrixVectorDataTypes.SP: self.DataGetSP,
        MatrixVectorDataTypes.DP: self.DataGetDP,
        MatrixVectorDataTypes.L: self.DataGetL,
    }
    data_type = self.DataTypeGet()
    return routines[data_type](*args)


def DistributedVector_DataRestore(self, *args):
    routines = {
        MatrixVectorDataTypes.INTG: self.DataRestoreIntg,
        MatrixVectorDataTypes.SP: self.DataRestoreSP,
        MatrixVectorDataTypes.DP: self.DataRestoreDP,
        MatrixVectorDataTypes.L: self.DataRestoreL,
    }
    data_type = self.DataTypeGet()
    return routines[data_type](*args)


DistributedMatrix.DataGet = DistributedMatrix_DataGet
DistributedMatrix.DataRestore = DistributedMatrix_DataRestore
DistributedVector.DataGet = DistributedVector_DataGet
DistributedVector.DataRestore = DistributedVector_DataRestore


def DistributedMatrix_ToSciPy(self):
    """Return a SciPy matrix representation of this matrix

    This works with sparse and full matrices and uses a view
    of the matrix data so there is no copying.
    Once finished with the matrix you should call the
    SciPyRestore method.
    """

    # Import scipy here as we don't want to require it unless
    # people are actually going to use it
    import numpy
    from scipy import sparse

    storageType = self.StorageTypeGet()
    dimensions = self.DimensionsGet()
    data = self.DataGet()

    if storageType == MatrixStorageTypes.BLOCK:
        # Not sparse, so just reshape the data
        matrix = data.reshape(dimensions, order='F')
    elif storageType == MatrixStorageTypes.DIAGONAL:
        offsets = numpy.array([0])
        matrix = sparse.dia_matrix((data, offsets), shape=dimensions)
    elif storageType == MatrixStorageTypes.COMPRESSED_ROW:
        # OpenCMISS has two types of distributed matrices, ones used internally
        # and ones used by PETSc. The PETSc ones use zero based arrays but the
        # internal ones use one based arrays. So for these to work with SciPy
        # we need to subtract one from the row and column index arrays.
        # This requires allocating a new array but it will take much less space
        # than the data array so this souldn't be an issue.
        # As the first row index is always zero, we can check if it is one instead
        rowIndices, columnIndices = self.StorageLocationsGet()
        if rowIndices[0] == 1:
            rowIndices = rowIndices - 1
            columnIndices = columnIndices - 1
        else:
            # Still copy these so that we're not hanging on do
            # data allocated within OpenCMISS, it's not that expensive
            rowIndices = rowIndices.copy()
            columnIndices = columnIndices.copy()
        matrix = sparse.csr_matrix(
                (data, columnIndices, rowIndices), shape=dimensions)
    elif storageType == MatrixStorageTypes.COMPRESSED_COLUMN:
        rowIndices, columnIndices = self.StorageLocationsGet()
        # As the first column index is always zero, we can check if it is one instead
        if columnIndices[0] == 1:
            rowIndices = rowIndices - 1
            columnIndices = columnIndices - 1
        else:
            rowIndices = rowIndices.copy()
            columnIndices = columnIndices.copy()
        matrix = sparse.csc_matrix(
                (data, rowIndices, columnIndices), shape=dimensions)
    else:
        self.DataRestore(data)
        raise ValueError("The storage type for this matrix is not "
            "supported by SciPy")
    return matrix


def DistributedMatrix_SciPyRestore(self, matrix):
    """Restores the data pointers used when creating a SciPy matrix

    Trying to use the SciPy matrix after this will not work
    """

    import numpy

    dimensions = self.DimensionsGet()
    if isinstance(matrix, numpy.ndarray):
        # For full matrices
        # This doesn't actually copy data if the
        # order='F' is used:
        matrix = numpy.reshape(matrix, -1, order='F')
        self.DataRestore(matrix)
    else:
        # For sparse matrices
        self.DataRestore(matrix.data)


DistributedMatrix.ToSciPy = DistributedMatrix_ToSciPy
DistributedMatrix.SciPyRestore = DistributedMatrix_SciPyRestore
WorldCoordinateSystem = CoordinateSystem()
WorldRegion = Region()
Initialise(WorldCoordinateSystem, WorldRegion)
# Don't output errors, we'll include trace in exception
ErrorHandlingModeSet(ErrorHandlingModes.RETURN_ERROR_CODE)

# Ignore SIGPIPE generated when closing the help pager when it isn't fully
# buffered, otherwise it gets caught by OpenCMISS and crashes the interpreter
signal.signal(signal.SIGPIPE, signal.SIG_IGN)