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

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _pgridfunc
else:
    import _pgridfunc

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

_swig_new_instance_method = _pgridfunc.SWIG_PyInstanceMethod_New
_swig_new_static_method = _pgridfunc.SWIG_PyStaticMethod_New

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


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


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


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


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


import weakref

MFEM_VERSION = _pgridfunc.MFEM_VERSION

MFEM_VERSION_STRING = _pgridfunc.MFEM_VERSION_STRING

MFEM_VERSION_TYPE = _pgridfunc.MFEM_VERSION_TYPE

MFEM_VERSION_TYPE_RELEASE = _pgridfunc.MFEM_VERSION_TYPE_RELEASE

MFEM_VERSION_TYPE_DEVELOPMENT = _pgridfunc.MFEM_VERSION_TYPE_DEVELOPMENT

MFEM_VERSION_MAJOR = _pgridfunc.MFEM_VERSION_MAJOR

MFEM_VERSION_MINOR = _pgridfunc.MFEM_VERSION_MINOR

MFEM_VERSION_PATCH = _pgridfunc.MFEM_VERSION_PATCH

MFEM_HYPRE_VERSION = _pgridfunc.MFEM_HYPRE_VERSION

import mfem._par.pfespace
import mfem._par.operators
import mfem._par.mem_manager
import mfem._par.vector
import mfem._par.array
import mfem._par.fespace
import mfem._par.coefficient
import mfem._par.globals
import mfem._par.matrix
import mfem._par.intrules
import mfem._par.sparsemat
import mfem._par.densemat
import mfem._par.eltrans
import mfem._par.fe
import mfem._par.geom
import mfem._par.mesh
import mfem._par.sort_pairs
import mfem._par.ncmesh
import mfem._par.vtk
import mfem._par.element
import mfem._par.table
import mfem._par.hash
import mfem._par.vertex
import mfem._par.gridfunc
import mfem._par.bilininteg
import mfem._par.fe_coll
import mfem._par.lininteg
import mfem._par.linearform
import mfem._par.handle
import mfem._par.hypre
import mfem._par.restriction
import mfem._par.pmesh
import mfem._par.pncmesh
import mfem._par.communication
import mfem._par.sets

def GlobalLpNorm(p, loc_norm, comm):
    r"""GlobalLpNorm(double const p, double loc_norm, MPI_Comm comm) -> double"""
    return _pgridfunc.GlobalLpNorm(p, loc_norm, comm)
GlobalLpNorm = _pgridfunc.GlobalLpNorm
class ParGridFunction(mfem._par.gridfunc.GridFunction):
    r"""Proxy of C++ mfem::ParGridFunction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def ParFESpace(self):
        r"""ParFESpace(ParGridFunction self) -> ParFiniteElementSpace"""
        return _pgridfunc.ParGridFunction_ParFESpace(self)
    ParFESpace = _swig_new_instance_method(_pgridfunc.ParGridFunction_ParFESpace)

    def Update(self):
        r"""Update(ParGridFunction self)"""
        return _pgridfunc.ParGridFunction_Update(self)
    Update = _swig_new_instance_method(_pgridfunc.ParGridFunction_Update)

    def SetSpace(self, *args):
        r"""
        SetSpace(ParGridFunction self, FiniteElementSpace f)
        SetSpace(ParGridFunction self, ParFiniteElementSpace f)
        """
        return _pgridfunc.ParGridFunction_SetSpace(self, *args)
    SetSpace = _swig_new_instance_method(_pgridfunc.ParGridFunction_SetSpace)

    def MakeRef(self, *args):
        r"""
        MakeRef(ParGridFunction self, Vector base, int offset, int size)
        MakeRef(ParGridFunction self, Vector base, int offset)
        MakeRef(ParGridFunction self, FiniteElementSpace f, double * v)
        MakeRef(ParGridFunction self, ParFiniteElementSpace f, double * v)
        MakeRef(ParGridFunction self, FiniteElementSpace f, Vector v, int v_offset)
        MakeRef(ParGridFunction self, ParFiniteElementSpace f, Vector v, int v_offset)
        """
        return _pgridfunc.ParGridFunction_MakeRef(self, *args)
    MakeRef = _swig_new_instance_method(_pgridfunc.ParGridFunction_MakeRef)

    def Distribute(self, *args):
        r"""
        Distribute(ParGridFunction self, Vector tv)
        Distribute(ParGridFunction self, Vector tv)
        """
        return _pgridfunc.ParGridFunction_Distribute(self, *args)
    Distribute = _swig_new_instance_method(_pgridfunc.ParGridFunction_Distribute)

    def AddDistribute(self, *args):
        r"""
        AddDistribute(ParGridFunction self, double a, Vector tv)
        AddDistribute(ParGridFunction self, double a, Vector tv)
        """
        return _pgridfunc.ParGridFunction_AddDistribute(self, *args)
    AddDistribute = _swig_new_instance_method(_pgridfunc.ParGridFunction_AddDistribute)

    def SetFromTrueDofs(self, tv):
        r"""SetFromTrueDofs(ParGridFunction self, Vector tv)"""
        return _pgridfunc.ParGridFunction_SetFromTrueDofs(self, tv)
    SetFromTrueDofs = _swig_new_instance_method(_pgridfunc.ParGridFunction_SetFromTrueDofs)

    def Assign(self, *args):
        r"""
        Assign(ParGridFunction self, ParGridFunction rhs) -> ParGridFunction
        Assign(ParGridFunction self, double value) -> ParGridFunction
        Assign(ParGridFunction self, Vector v) -> ParGridFunction
        Assign(ParGridFunction self, HypreParVector tv) -> ParGridFunction
        """
        return _pgridfunc.ParGridFunction_Assign(self, *args)
    Assign = _swig_new_instance_method(_pgridfunc.ParGridFunction_Assign)

    def GetTrueDofs(self, *args):
        r"""
        GetTrueDofs(ParGridFunction self, Vector tv)
        GetTrueDofs(ParGridFunction self) -> HypreParVector
        """
        return _pgridfunc.ParGridFunction_GetTrueDofs(self, *args)
    GetTrueDofs = _swig_new_instance_method(_pgridfunc.ParGridFunction_GetTrueDofs)

    def ParallelAverage(self, *args):
        r"""
        ParallelAverage(ParGridFunction self, Vector tv)
        ParallelAverage(ParGridFunction self, HypreParVector tv)
        ParallelAverage(ParGridFunction self) -> HypreParVector
        """
        return _pgridfunc.ParGridFunction_ParallelAverage(self, *args)
    ParallelAverage = _swig_new_instance_method(_pgridfunc.ParGridFunction_ParallelAverage)

    def ParallelProject(self, *args):
        r"""
        ParallelProject(ParGridFunction self, Vector tv)
        ParallelProject(ParGridFunction self, HypreParVector tv)
        ParallelProject(ParGridFunction self) -> HypreParVector
        """
        return _pgridfunc.ParGridFunction_ParallelProject(self, *args)
    ParallelProject = _swig_new_instance_method(_pgridfunc.ParGridFunction_ParallelProject)

    def ParallelAssemble(self, *args):
        r"""
        ParallelAssemble(ParGridFunction self, Vector tv)
        ParallelAssemble(ParGridFunction self, HypreParVector tv)
        ParallelAssemble(ParGridFunction self) -> HypreParVector
        """
        return _pgridfunc.ParGridFunction_ParallelAssemble(self, *args)
    ParallelAssemble = _swig_new_instance_method(_pgridfunc.ParGridFunction_ParallelAssemble)

    def ExchangeFaceNbrData(self):
        r"""ExchangeFaceNbrData(ParGridFunction self)"""
        return _pgridfunc.ParGridFunction_ExchangeFaceNbrData(self)
    ExchangeFaceNbrData = _swig_new_instance_method(_pgridfunc.ParGridFunction_ExchangeFaceNbrData)

    def FaceNbrData(self, *args):
        r"""
        FaceNbrData(ParGridFunction self) -> Vector
        FaceNbrData(ParGridFunction self) -> Vector
        """
        return _pgridfunc.ParGridFunction_FaceNbrData(self, *args)
    FaceNbrData = _swig_new_instance_method(_pgridfunc.ParGridFunction_FaceNbrData)

    def GetValue(self, *args):
        r"""
        GetValue(ParGridFunction self, int i, IntegrationPoint ip, int vdim=1) -> double
        GetValue(ParGridFunction self, ElementTransformation T) -> double
        GetValue(ParGridFunction self, ElementTransformation T, IntegrationPoint ip, int comp=0, Vector tr=None) -> double
        """
        return _pgridfunc.ParGridFunction_GetValue(self, *args)
    GetValue = _swig_new_instance_method(_pgridfunc.ParGridFunction_GetValue)

    def GetVectorValue(self, *args):
        r"""
        GetVectorValue(ParGridFunction self, int i, IntegrationPoint ip, Vector val)
        GetVectorValue(ParGridFunction self, ElementTransformation T, IntegrationPoint ip, Vector val, Vector tr=None)
        """
        return _pgridfunc.ParGridFunction_GetVectorValue(self, *args)
    GetVectorValue = _swig_new_instance_method(_pgridfunc.ParGridFunction_GetVectorValue)

    def ProjectCoefficient(self, *args):
        r"""
        ProjectCoefficient(ParGridFunction self, Coefficient coeff)
        ProjectCoefficient(ParGridFunction self, Coefficient coeff, intArray dofs, int vd=0)
        ProjectCoefficient(ParGridFunction self, VectorCoefficient vcoeff)
        ProjectCoefficient(ParGridFunction self, VectorCoefficient vcoeff, intArray dofs)
        ProjectCoefficient(ParGridFunction self, mfem::Coefficient *[] coeff)
        ProjectCoefficient(ParGridFunction self, Coefficient coeff)
        """
        return _pgridfunc.ParGridFunction_ProjectCoefficient(self, *args)
    ProjectCoefficient = _swig_new_instance_method(_pgridfunc.ParGridFunction_ProjectCoefficient)

    def ProjectDiscCoefficient(self, *args):
        r"""
        ProjectDiscCoefficient(ParGridFunction self, VectorCoefficient coeff, intArray dof_attr)
        ProjectDiscCoefficient(ParGridFunction self, VectorCoefficient coeff)
        ProjectDiscCoefficient(ParGridFunction self, Coefficient coeff, mfem::GridFunction::AvgType type)
        ProjectDiscCoefficient(ParGridFunction self, VectorCoefficient coeff, mfem::GridFunction::AvgType type)
        ProjectDiscCoefficient(ParGridFunction self, VectorCoefficient coeff)
        ProjectDiscCoefficient(ParGridFunction self, Coefficient coeff, mfem::GridFunction::AvgType type)
        ProjectDiscCoefficient(ParGridFunction self, VectorCoefficient vcoeff, mfem::GridFunction::AvgType type)
        """
        return _pgridfunc.ParGridFunction_ProjectDiscCoefficient(self, *args)
    ProjectDiscCoefficient = _swig_new_instance_method(_pgridfunc.ParGridFunction_ProjectDiscCoefficient)

    def ProjectBdrCoefficient(self, *args):
        r"""
        ProjectBdrCoefficient(ParGridFunction self, Coefficient coeff, intArray attr)
        ProjectBdrCoefficient(ParGridFunction self, VectorCoefficient vcoeff, intArray attr)
        ProjectBdrCoefficient(ParGridFunction self, mfem::Coefficient *[] coeff, intArray attr)
        ProjectBdrCoefficient(ParGridFunction self, VectorCoefficient vcoeff, intArray attr)
        ProjectBdrCoefficient(ParGridFunction self, mfem::Coefficient *[] coeff, intArray attr)
        """
        return _pgridfunc.ParGridFunction_ProjectBdrCoefficient(self, *args)
    ProjectBdrCoefficient = _swig_new_instance_method(_pgridfunc.ParGridFunction_ProjectBdrCoefficient)

    def ProjectBdrCoefficientTangent(self, vcoeff, bdr_attr):
        r"""ProjectBdrCoefficientTangent(ParGridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"""
        return _pgridfunc.ParGridFunction_ProjectBdrCoefficientTangent(self, vcoeff, bdr_attr)
    ProjectBdrCoefficientTangent = _swig_new_instance_method(_pgridfunc.ParGridFunction_ProjectBdrCoefficientTangent)

    def ComputeL1Error(self, *args):
        r"""
        ComputeL1Error(ParGridFunction self, mfem::Coefficient *[] exsol, mfem::IntegrationRule const *[] irs=0) -> double
        ComputeL1Error(ParGridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double
        ComputeL1Error(ParGridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double
        """
        return _pgridfunc.ParGridFunction_ComputeL1Error(self, *args)
    ComputeL1Error = _swig_new_instance_method(_pgridfunc.ParGridFunction_ComputeL1Error)

    def ComputeL2Error(self, *args):
        r"""
        ComputeL2Error(ParGridFunction self, mfem::Coefficient *[] exsol, mfem::IntegrationRule const *[] irs=0) -> double
        ComputeL2Error(ParGridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double
        ComputeL2Error(ParGridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0, intArray elems=None) -> double
        """
        return _pgridfunc.ParGridFunction_ComputeL2Error(self, *args)
    ComputeL2Error = _swig_new_instance_method(_pgridfunc.ParGridFunction_ComputeL2Error)

    def ComputeGradError(self, exgrad, irs=0):
        r"""ComputeGradError(ParGridFunction self, VectorCoefficient exgrad, mfem::IntegrationRule const *[] irs=0) -> double"""
        return _pgridfunc.ParGridFunction_ComputeGradError(self, exgrad, irs)
    ComputeGradError = _swig_new_instance_method(_pgridfunc.ParGridFunction_ComputeGradError)

    def ComputeCurlError(self, excurl, irs=0):
        r"""ComputeCurlError(ParGridFunction self, VectorCoefficient excurl, mfem::IntegrationRule const *[] irs=0) -> double"""
        return _pgridfunc.ParGridFunction_ComputeCurlError(self, excurl, irs)
    ComputeCurlError = _swig_new_instance_method(_pgridfunc.ParGridFunction_ComputeCurlError)

    def ComputeDivError(self, exdiv, irs=0):
        r"""ComputeDivError(ParGridFunction self, Coefficient exdiv, mfem::IntegrationRule const *[] irs=0) -> double"""
        return _pgridfunc.ParGridFunction_ComputeDivError(self, exdiv, irs)
    ComputeDivError = _swig_new_instance_method(_pgridfunc.ParGridFunction_ComputeDivError)

    def ComputeDGFaceJumpError(self, exsol, ell_coeff, Nu, irs=0):
        r"""ComputeDGFaceJumpError(ParGridFunction self, Coefficient exsol, Coefficient ell_coeff, double Nu, mfem::IntegrationRule const *[] irs=0) -> double"""
        return _pgridfunc.ParGridFunction_ComputeDGFaceJumpError(self, exsol, ell_coeff, Nu, irs)
    ComputeDGFaceJumpError = _swig_new_instance_method(_pgridfunc.ParGridFunction_ComputeDGFaceJumpError)

    def ComputeH1Error(self, *args):
        r"""
        ComputeH1Error(ParGridFunction self, Coefficient exsol, VectorCoefficient exgrad, Coefficient ell_coef, double Nu, int norm_type) -> double
        ComputeH1Error(ParGridFunction self, Coefficient exsol, VectorCoefficient exgrad, mfem::IntegrationRule const *[] irs=0) -> double
        """
        return _pgridfunc.ParGridFunction_ComputeH1Error(self, *args)
    ComputeH1Error = _swig_new_instance_method(_pgridfunc.ParGridFunction_ComputeH1Error)

    def ComputeHDivError(self, exsol, exdiv, irs=0):
        r"""ComputeHDivError(ParGridFunction self, VectorCoefficient exsol, Coefficient exdiv, mfem::IntegrationRule const *[] irs=0) -> double"""
        return _pgridfunc.ParGridFunction_ComputeHDivError(self, exsol, exdiv, irs)
    ComputeHDivError = _swig_new_instance_method(_pgridfunc.ParGridFunction_ComputeHDivError)

    def ComputeHCurlError(self, exsol, excurl, irs=0):
        r"""ComputeHCurlError(ParGridFunction self, VectorCoefficient exsol, VectorCoefficient excurl, mfem::IntegrationRule const *[] irs=0) -> double"""
        return _pgridfunc.ParGridFunction_ComputeHCurlError(self, exsol, excurl, irs)
    ComputeHCurlError = _swig_new_instance_method(_pgridfunc.ParGridFunction_ComputeHCurlError)

    def ComputeMaxError(self, *args):
        r"""
        ComputeMaxError(ParGridFunction self, mfem::Coefficient *[] exsol, mfem::IntegrationRule const *[] irs=0) -> double
        ComputeMaxError(ParGridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double
        ComputeMaxError(ParGridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double
        """
        return _pgridfunc.ParGridFunction_ComputeMaxError(self, *args)
    ComputeMaxError = _swig_new_instance_method(_pgridfunc.ParGridFunction_ComputeMaxError)

    def ComputeLpError(self, *args):
        r"""
        ComputeLpError(ParGridFunction self, double const p, Coefficient exsol, Coefficient weight=None, mfem::IntegrationRule const *[] irs=0) -> double
        ComputeLpError(ParGridFunction self, double const p, VectorCoefficient exsol, Coefficient weight=None, VectorCoefficient v_weight=None, mfem::IntegrationRule const *[] irs=0) -> double
        """
        return _pgridfunc.ParGridFunction_ComputeLpError(self, *args)
    ComputeLpError = _swig_new_instance_method(_pgridfunc.ParGridFunction_ComputeLpError)

    def ComputeFlux(self, blfi, flux, wcoef=True, subdomain=-1):
        r"""ComputeFlux(ParGridFunction self, BilinearFormIntegrator blfi, GridFunction flux, bool wcoef=True, int subdomain=-1)"""
        return _pgridfunc.ParGridFunction_ComputeFlux(self, blfi, flux, wcoef, subdomain)
    ComputeFlux = _swig_new_instance_method(_pgridfunc.ParGridFunction_ComputeFlux)
    __swig_destroy__ = _pgridfunc.delete_ParGridFunction

    def __init__(self, *args):
        r"""
        __init__(ParGridFunction self) -> ParGridFunction
        __init__(ParGridFunction self, ParGridFunction orig) -> ParGridFunction
        __init__(ParGridFunction self, ParFiniteElementSpace pf) -> ParGridFunction
        __init__(ParGridFunction self, ParFiniteElementSpace pf, double * data) -> ParGridFunction
        __init__(ParGridFunction self, ParFiniteElementSpace pf, GridFunction gf) -> ParGridFunction
        __init__(ParGridFunction self, ParFiniteElementSpace pf, HypreParVector tv) -> ParGridFunction
        __init__(ParGridFunction self, ParMesh pmesh, GridFunction gf, int const * partitioning=None) -> ParGridFunction
        __init__(ParGridFunction self, ParMesh pmesh, std::istream & input) -> ParGridFunction
        __init__(ParGridFunction self, ParFiniteElementSpace fes, Vector v, int offset) -> ParGridFunction
        """

        from mfem._par.pmesh import ParMesh
        from mfem._par.pfespace import ParFiniteElementSpace
        from mfem._par.gridfunc import GridFunction
        if (len(args) == 2 and isinstance(args[1], str) and
             isinstance(args[0], ParMesh)):
            g0 = GridFunction(args[0], args[1])
            fec = g0.OwnFEC()
            fes = g0.FESpace()
            pfes = ParFiniteElementSpace(args[0], fec, fes.GetVDim(),
                                              fes.GetOrdering())
            x = ParGridFunction(pfes, g0)
            x.thisown = 0
            pfes.thisown = 0
            g0.thisown = 0
            self.this = x.this
            return 


        _pgridfunc.ParGridFunction_swiginit(self, _pgridfunc.new_ParGridFunction(*args))

    def Save(self, *args):
        r"""
        Save(ParGridFunction self, std::ostream & out)
        Save(ParGridFunction self, char const * file, int precision=8)
        """
        return _pgridfunc.ParGridFunction_Save(self, *args)
    Save = _swig_new_instance_method(_pgridfunc.ParGridFunction_Save)

    def SaveAsOne(self, *args):
        r"""
        SaveAsOne(ParGridFunction self, std::ostream & out=out)
        SaveAsOne(ParGridFunction self, char const * file, int precision=8)
        """
        return _pgridfunc.ParGridFunction_SaveAsOne(self, *args)
    SaveAsOne = _swig_new_instance_method(_pgridfunc.ParGridFunction_SaveAsOne)

# Register ParGridFunction in _pgridfunc:
_pgridfunc.ParGridFunction_swigregister(ParGridFunction)


def L2ZZErrorEstimator(flux_integrator, x, smooth_flux_fes, flux_fes, errors, norm_p=2, solver_tol=1e-12, solver_max_it=200):
    r"""L2ZZErrorEstimator(BilinearFormIntegrator flux_integrator, ParGridFunction x, ParFiniteElementSpace smooth_flux_fes, ParFiniteElementSpace flux_fes, Vector errors, int norm_p=2, double solver_tol=1e-12, int solver_max_it=200) -> double"""
    return _pgridfunc.L2ZZErrorEstimator(flux_integrator, x, smooth_flux_fes, flux_fes, errors, norm_p, solver_tol, solver_max_it)
L2ZZErrorEstimator = _pgridfunc.L2ZZErrorEstimator


