Source code for Muscat.FE.WeakForms.PythonNumericalWeakFrom


[docs]
class PyWeakForm(object):
    def __init__(self):
        super().__init__()
        self.form = []


[docs]
    def AddTerm(self, monom):
        self.form.append(monom)



[docs]
    def GetNumberOfTerms(self):
        return len(self.form)



[docs]
    def GetMonom(self, i):
        return self.form[i]



[docs]
    def GetRightPart(self, unknownvars):
        res = PyWeakForm()
        for p in self:
            for uv in unknownvars:
                if p.hasVariable(uv):
                    break
            else:
                res.AddTerm(p)
        return res



[docs]
    def GetLeftPart(self, unknownvars):
        res = PyWeakForm()
        for p in self:
            tocopy = False
            for uv in unknownvars:
                if p.hasVariable(uv):
                    tocopy = True
                    break
            if tocopy:
                res.AddTerm(p)
        return res



[docs]
    def GetMaxDerivativeDimensionality(self):
        """return the number of coordinate needed on the mesh
        to correctly compute the derivatives"""

        res = 0
        for p in self:
            tocopy = False
            for m in p:
                if m.derDegree > 0 and m.normal == 0:
                    res = max(res, m.derCoordIndex_ + 1)
        return res


    def __str__(self):
        res = ""
        for i in range(self.GetNumberOfTerms()):
            res += str(self.GetMonom(i)) + "\n"
        return res

    def __iter__(self):
        return iter(self.form)




[docs]
class PyWeakMonom(object):
    def __init__(self):
        super().__init__()
        self.prefactor = 1
        self.prod = []


[docs]
    def AddProd(self, term):
        self.prod.append(term)



[docs]
    def GetNumberOfProds(self):
        return len(self.prod)



[docs]
    def GetProd(self, n):
        return self.prod[n]



[docs]
    def hasVariable(self, var):
        for m in self:
            if m.fieldName == str(var):
                return True
        return False


    def __str__(self):
        res = str(self.prefactor)
        for i in range(self.GetNumberOfProds()):
            res += "*"
            res += str(self.GetProd(i))
        return res

    def __iter__(self):
        return iter(self.prod)


[docs]
    def copy(self):
        import copy

        return copy.deepcopy(self)





[docs]
class PyWeakTerm(object):
    EnumError = -1
    EnumNormal = 0
    EnumConstant = 1
    EnumUnknownField = 2
    EnumTestField = 3
    EnumExtraField = 4
    EnumExtraIPField = 5

    def __init__(self):
        super().__init__()
        self.fieldName = ""
        self.derCoordName = ""
        self.derDegree = -1
        self.constant = False
        self.normal = False

        # internal data repr for integration
        self.internalType = PyWeakTerm.EnumError
        self.spaceIndex_ = None
        self.numberingIndex_ = None
        self.valuesIndex_ = None
        self.modeIndex_ = None
        self.derCoordIndex_ = None

    def __str__(self):
        res = ""
        if self.derDegree > 0 and self.normal == 0:
            #            #res += "d" + self.fieldName + "/"  + "d"  + str(self.derCoordName)
            res += (
                "Derivative("
                + str(self.fieldName)
                + ", "
                + str(self.derCoordName)
                + ","
                + str(self.derDegree)
                + ")"
            )
        else:
            res += self.fieldName
        return res


[docs]
    def copy(self):
        import copy

        return copy.deepcopy(self)





[docs]
def CheckIntegrity(GUI: bool = False):
    return "ok"



if __name__ == "__main__":
    print(CheckIntegrity(GUI=True))  # pragma: no cover