def restrict_coeff(self, coeff, engine, vec=False, matrix=False, idx=None):
if len(self._sel_index) == 1 and self._sel_index[0] == -1:
return coeff
arr = self.get_restriction_array(engine, idx)
ret = []
flag = False
if not isinstance(coeff, tuple):
flag = True
coeff = [coeff]
for c in coeff:
if (isinstance(c, mfem.Coefficient)
or isinstance(c, mfem.VectorCoefficient)
or isinstance(c, mfem.MatrixCoefficient)):
if vec:
ret.append(mfem.VectorRestrictedCoefficient(c, arr))
elif matrix:
ret.append(mfem.MatrixRestrictedCoefficient(c, arr))
else:
ret.append(mfem.RestrictedCoefficient(c, arr))
else:
ret.append(c)
if not flag:
return tuple(ret)
else:
return ret[0]
def restrict_coeff(self, coeff, fes, vec = False, matrix=False):
if self._sel == 'all':
return coeff
arr = self.get_restriction_array(fes)
if arr is None:
# this could happen when local mesh does not have Bdr/Domain attribute
return coeff
if vec:
return mfem.VectorRestrictedCoefficient(coeff, arr)
elif matrix:
return mfem.MatrixRestrictedCoefficient(coeff, arr)
else:
return mfem.RestrictedCoefficient(coeff, arr)
def do_integration(expr, solvars, phys, mesh, kind, attrs,
order, num):
from petram.helper.variables import (Variable,
var_g,
NativeCoefficientGenBase,
CoefficientVariable)
from petram.phys.coefficient import SCoeff
st = parser.expr(expr)
code= st.compile('<string>')
names = code.co_names
g = {}
#print solvars.keys()
for key in phys._global_ns.keys():
g[key] = phys._global_ns[key]
for key in solvars.keys():
g[key] = solvars[key]
l = var_g.copy()
ind_vars = ','.join(phys.get_independent_variables())
if kind == 'Domain':
size = max(max(mesh.attributes.ToList()), max(attrs))
else:
size = max(max(mesh.bdr_attributes.ToList()), max(attrs))
arr = [0]*(size)
for k in attrs:
arr[k-1] = 1
flag = mfem.intArray(arr)
s = SCoeff(expr, ind_vars, l, g, return_complex=False)
## note L2 does not work for boundary....:D
if kind == 'Domain':
fec = mfem.L2_FECollection(order, mesh.Dimension())
else:
fec = mfem.H1_FECollection(order, mesh.Dimension())
fes = mfem.FiniteElementSpace(mesh, fec)
one = mfem.ConstantCoefficient(1)
gf = mfem.GridFunction(fes)
gf.Assign(0.0)
if kind == 'Domain':
gf.ProjectCoefficient(mfem.RestrictedCoefficient(s, flag))
else:
gf.ProjectBdrCoefficient(mfem.RestrictedCoefficient(s, flag), flag)
b = mfem.LinearForm(fes)
one = mfem.ConstantCoefficient(1)
if kind == 'Domain':
itg = mfem.DomainLFIntegrator(one)
b.AddDomainIntegrator(itg)
else:
itg = mfem.BoundaryLFIntegrator(one)
b.AddBoundaryIntegrator(itg)
b.Assemble()
from petram.engine import SerialEngine
en = SerialEngine()
ans = mfem.InnerProduct(en.x2X(gf), en.b2B(b))
if not np.isfinite(ans):
print("not finite", ans, arr)
print(size, mesh.bdr_attributes.ToList())
from mfem.common.chypre import LF2PyVec, PyVec2PyMat, Array2PyVec, IdentityPyMat
#print(list(gf.GetDataArray()))
print(len(gf.GetDataArray()), np.sum(gf.GetDataArray()))
print(np.sum(list(b.GetDataArray())))
return ans