def test_new_integrateX_via_circle_geom(quad_dominated, order, domain):
mesh = MakeUniform2DGrid(quads = quad_dominated, N=1, P1=(0,0), P2=(1,1))
r=0.6
levelset = sqrt(x*x+y*y)-r
referencevals = { POS : 1-pi*r*r/4, NEG : pi*r*r/4, IF : r*pi/2}
n_ref = 8
errors = []
for i in range(n_ref):
V = H1(mesh,order=1)
lset_approx = GridFunction(V)
InterpolateToP1(levelset,lset_approx)
f = CoefficientFunction(1)
integral = Integrate(levelset_domain = { "levelset" : lset_approx, "domain_type" : domain},
cf=f, mesh=mesh, order = order)
print("Result of Integration Reflevel ",i,", Key ",domain," : ", integral)
errors.append(abs(integral - referencevals[domain]))
if i < n_ref - 1:
mesh.Refine()
eoc = [log(errors[i+1]/errors[i])/log(0.5) for i in range(n_ref-1)]
print("L2-errors:", errors)
print("experimental order of convergence (L2):", eoc)
mean_eoc_array = eoc[1:]
mean_eoc = sum(mean_eoc_array)/len(mean_eoc_array)
assert mean_eoc > 1.75
def test_new_integrateX_via_orth_cutted_quad2D(order, domain, quad_dominated, dim):
mesh = MakeUniform2DGrid(quads = quad_dominated, N=1, P1=(0,0), P2=(1,1))
levelset = 1 - 3*dim
referencevals = {NEG: 2./3, POS: 1./3, IF: 1. }
lset_approx = GridFunction(H1(mesh,order=1))
InterpolateToP1(levelset,lset_approx)
f = CoefficientFunction(1)
integral = Integrate(levelset_domain = { "levelset" : lset_approx, "domain_type" : domain},
cf=f, mesh=mesh, order = order)
error = abs(integral - referencevals[domain])
assert error < 5e-15*(order+1)*(order+1)
def test_new_integrateX_via_orth_cutted_quad2D_epsiloned(order, domain, quad_dominated, dim, eps):
mesh = MakeUniform2DGrid(quads = quad_dominated, N=1, P1=(0,0), P2=(1,1))
if dim == x:
levelset = 1 - 2*x + eps*(y-0.5)
elif dim == y:
levelset = 1 - 2*y + eps*(x-0.5)
referencevals = {NEG: 1./2, POS: 1./2, IF: sqrt(1.+eps*eps/4) }
lset_approx = GridFunction(H1(mesh,order=1))
InterpolateToP1(levelset,lset_approx)
f = CoefficientFunction(1)
integral = Integrate(levelset_domain = { "levelset" : lset_approx, "domain_type" : domain},
cf=f, mesh=mesh, order = order)
error = abs(integral - referencevals[domain])
print(error)
assert error < 5e-15*(order+1)*(order+1)
def test_spacetime_integrateX_via_straight_cutted_quad2Dplus1D(
domain, quad_dominated):
mesh = MakeUniform2DGrid(quads=quad_dominated, N=1, P1=(0, 0), P2=(1, 1))
tref = ReferenceTimeVariable()
levelset = lambda t: 1 - 2 * x - 2 * t
referencevals = {POS: 1. / 8, NEG: 1 - 1 / 8, IF: 1.0 / 2}
h1fes = H1(mesh, order=1)
lset_approx_h1 = GridFunction(h1fes)
tfe = ScalarTimeFE(1)
fes = SpaceTimeFESpace(h1fes, tfe)
lset_approx = GridFunction(fes)
InterpolateToP1(levelset(0), lset_approx_h1)
lset_approx.vec[0:h1fes.ndof] = lset_approx_h1.vec
InterpolateToP1(levelset(1), lset_approx_h1)
lset_approx.vec[h1fes.ndof:2 * h1fes.ndof] = lset_approx_h1.vec
print(lset_approx.vec)
f = CoefficientFunction(1)
integral = Integrate(levelset_domain={
"levelset": lset_approx,
"domain_type": domain
},
cf=f,
mesh=mesh,
order=0,
time_order=0)
print("Integral: ", integral)
error = abs(integral - referencevals[domain])
assert error < 5e-15
def test_spacetime_integrate_no_cut(quad_dominated, integrands):
mesh = MakeUniform2DGrid(quads=quad_dominated, N=1, P1=(0, 0), P2=(1, 1))
f, ref_value, space_order, time_order = integrands
h1fes = H1(mesh, order=1)
tfe = ScalarTimeFE(1)
fes = SpaceTimeFESpace(h1fes, tfe)
lset_approx = GridFunction(fes)
lset_approx.vec[:] = -1
integral = Integrate(levelset_domain={
"levelset": lset_approx,
"domain_type": NEG
},
cf=f,
mesh=mesh,
order=space_order,
time_order=time_order)
print("Integral: ", integral)
error = abs(integral - ref_value)
assert error < 5e-15
def test_shifteval():
mesh = MakeUniform2DGrid(quads=False, N=8, P1=(0, 0), P2=(1, 1))
# H1-conforming finite element space
fes = H1(mesh, order=3, dirichlet=[1, 2, 3, 4])
fes_dfm = H1(mesh, order=3, dim=2)
gfu_new = GridFunction(fes)
gfu_old = GridFunction(fes)
dfm_back = GridFunction(fes_dfm)
#dfm_back.vec[37:] = 0.1
dfm_back.Set(CoefficientFunction((0.2 * sin(5 * y), 0.2 * cos(5 * x))))
for i in range(2 * mesh.nv):
dfm_back.vec[i] = 0.0
dfm_forth = GridFunction(fes_dfm)
mesh.SetDeformation(dfm_back)
exact = sin(10 * y)
gfu_old.Set(exact)
l2error_old = sqrt(
Integrate((gfu_old - exact) * (gfu_old - exact), mesh, order=10))
mesh.UnsetDeformation()
Draw(gfu_old, mesh, "gfu_old")
Draw(dfm_back, mesh, "dfmback")
gfu_new.Set(shifted_eval(gfu_old, dfm_back, dfm_forth))
Draw(gfu_new, mesh, "gfu_new")
error_old = l2error_old
error_new = sqrt(
Integrate((gfu_new - exact) * (gfu_new - exact), mesh, order=10))
print("L2-error(old):", error_old)
print("L2-error(new):", error_new)
assert error_old < 1e-3
assert error_new < 1e-3
def test_intcurved(quad_dominated, order):
levelset = sqrt(x * x + y * y) - 0.5
referencevals = {POS: 4.0 - 0.25 * pi, NEG: 0.25 * pi, IF: pi}
mesh = MakeUniform2DGrid(quads=quad_dominated, N=4, P1=(-1, -1), P2=(1, 1))
lsetmeshadap = LevelSetMeshAdaptation(mesh,
order=order,
threshold=0.2,
discontinuous_qn=True)
lsetp1 = lsetmeshadap.lset_p1
errors_uncurved = dict()
errors_curved = dict()
eoc_uncurved = dict()
eoc_curved = dict()
for key in [NEG, POS, IF]:
errors_curved[key] = []
errors_uncurved[key] = []
eoc_curved[key] = []
eoc_uncurved[key] = []
refinements = 5
if order == 1:
refinements += 2
for reflevel in range(refinements):
if (reflevel > 0):
mesh.Refine()
f = CoefficientFunction(1.0)
for key in [NEG, POS, IF]:
# Applying the mesh deformation
deformation = lsetmeshadap.CalcDeformation(levelset)
integrals_uncurved = Integrate(levelset_domain={
"levelset": lsetp1,
"domain_type": key
},
cf=f,
mesh=mesh,
order=order)
mesh.SetDeformation(deformation)
integrals_curved = Integrate(levelset_domain={
"levelset": lsetp1,
"domain_type": key
},
cf=f,
mesh=mesh,
order=order)
# Unapply the mesh deformation (for refinement)
mesh.UnsetDeformation()
errors_curved[key].append(
abs(integrals_curved - referencevals[key]))
errors_uncurved[key].append(
abs(integrals_uncurved - referencevals[key]))
# refine cut elements:
if not quad_dominated:
RefineAtLevelSet(gf=lsetmeshadap.lset_p1)
for key in [NEG, POS, IF]:
eoc_curved[key] = [
log(a / b) / log(2)
for (a, b) in zip(errors_curved[key][0:-1], errors_curved[key][1:])
]
eoc_uncurved[key] = [
log(a / b) / log(2) for (
a,
b) in zip(errors_uncurved[key][0:-1], errors_uncurved[key][1:])
]
# print("errors (uncurved): \n{}\n".format(errors_uncurved))
# print(" eoc (uncurved): \n{}\n".format( eoc_uncurved))
print("errors ( curved): \n{}\n".format(errors_curved))
print(" eoc ( curved): \n{}\n".format(eoc_curved))
print("avg.eoc(curved, IF): \n{}\n".format(
sum(eoc_curved[IF][2:]) / len(eoc_curved[IF][2:])))
print("avg.eoc(curved,NEG): \n{}\n".format(
sum(eoc_curved[NEG][2:]) / len(eoc_curved[NEG][2:])))
print("avg.eoc(curved,POS): \n{}\n".format(
sum(eoc_curved[POS][2:]) / len(eoc_curved[POS][2:])))
if (order > 1):
assert errors_curved[IF][-1] < 1e-5
assert errors_curved[NEG][-1] < 1e-5
assert errors_curved[POS][-1] < 1e-5
else:
assert errors_curved[IF][-1] < 1e-4
assert errors_curved[NEG][-1] < 1e-4
assert errors_curved[POS][-1] < 1e-4
s = 0
if order == 1:
s += 2
assert sum(eoc_curved[IF][s:]) / len(eoc_curved[IF][s:]) > order + 0.75
assert sum(eoc_curved[NEG][s:]) / len(eoc_curved[NEG][s:]) > order + 0.75
assert sum(eoc_curved[POS][s:]) / len(eoc_curved[POS][s:]) > order + 0.75