Mcont = gf.asm_mass_matrix(mimls, mf_cont)
#D = np.abs(np.diag(np.diag(Mcont.full())))
#ind = np.argwhere(D > ((1/NY)**N)*1e-7)
D = np.abs(Mcont.diag().T[0])
ind = np.argwhere(D > ((1 / NY)**N) * 1e-7)
mf = gf.MeshFem('partial', mf_basic, ind)
#% Solving the direct problem
print('solving the direct problem')
md.solve('max_res', 1e-7)
U = md.variable("u")
nbd = mf_ls.nbdof()
#% Computation of indicators (computation of K could be avoided)
K = gf.asm('linear elasticity', mim, mf, mf_ls, λ * np.ones((1, nbd)),
μ * np.ones((1, nbd)))
print(f'Elastic energy at iteration {niter}: {np.dot(U,(K*U))}')
S = gf.asm('volumic', 'V()+=comp()', mim)
if (N == 2):
print(f'Remaining surface of material: {S}')
else:
print(f'Remaining volume of material: {S}')
DU = gf.compute(mf, U, 'gradient', mf_g)
EPSU = DU + DU[[1, 0], :]
#% Computation of the shape derivative
if (N == 2):
GF1 = (DU[0][0] + DU[1][1])**2 * λ + 2 * μ * np.sum(
np.sum(EPSU, axis=0), axis=0)
else:
gf.Integ("IM_STRUCTURED_COMPOSITE(IM_GAUSS_PARALLELEPIPED(2,6),9)"),
gf.Integ("IM_GAUSS_PARALLELEPIPED(2,4)"))
else:
mim = gf.MeshIm(
"levelset", mls, "all",
gf.Integ("IM_STRUCTURED_COMPOSITE(IM_TRIANGLE(6),3)"),
gf.Integ("IM_STRUCTURED_COMPOSITE(IM_GAUSS_PARALLELEPIPED(2,6),9)"),
gf.Integ("IM_STRUCTURED_COMPOSITE(IM_TRIANGLE(6),5)"))
mim_bound = [
gf.MeshIm("levelset", mls, boundary,
gf.Integ("IM_STRUCTURED_COMPOSITE(IM_TRIANGLE(6),3)"))
for boundary in ["boundary(a)", "boundary(b)"]
]
surf_crack = gf.asm("generic", mim_bound[0], 0, "1", -1)\
+gf.asm("generic", mim_bound[1], 0, "1", -1)
print("surf_crack = %g" % surf_crack)
# Model definition:
md = gf.Model("real")
md.add_fem_variable("u", mf_u)
md.add_fem_variable("theta", mf_theta)
md.add_variable("P", 1)
md.add_variable("T", 1)
md.set_variable("T", 273 + room_temp)
# Data
md.add_initialized_data("surf_crack", surf_crack)
md.add_initialized_data("mu0", E0 / (2 * (1 + nu)))
md.add_initialized_data("la0", E0 * nu / ((1 - 2 * nu) * (1 + nu)))
md.add_initialized_data("ka0", E0 / (3 * (1 - 2 * nu)))
print('mayavi2 -d mesh%d.vtk -f ExtractEdges -m Surface \n' % refiter)
# Assembly of the linear system and solve.
md.solve()
# Main unknown
U = md.variable('u')
# Residual a posteriori estimator
grad_jump = '( (Grad_u-Interpolate(Grad_u,neighbor_element)).Normal )'
bulkresidual = 'sqr(element_size*Trace(Hess_u))*Test_psi'
edgeresidual = '0.25*element_size*sqr(%s)*(Test_psi + Interpolate(Test_psi,neighbor_element))' % grad_jump
ETA1tmp = gf.asm('generic', mim, 1, bulkresidual, -1, md, 'psi', 1, mfP0,
np.zeros(mfP0.nbdof()))
ETA1 = ETA1tmp[ETA1tmp.size - mfP0.nbdof():ETA1tmp.size]
ETA2tmp = gf.asm('generic', mim, 1, edgeresidual, INNER_FACES, md, 'psi',
1, mfP0, np.zeros(mfP0.nbdof()))
ETA2 = ETA2tmp[ETA2tmp.size - mfP0.nbdof():ETA2tmp.size]
ETA = np.sqrt(ETA1 + ETA2)
# Export data
mfu.export_to_pos('laplacian%d.pos' % refiter, U, 'Computed solution')
print('You can view the solution with (for example):')
print('gmsh laplacian%d.pos' % refiter)
mfP0.export_to_pos('eta1_%d.pos' % refiter, ETA1, 'Bulk residual')
print('You can view eta1 with (for example):')
print('gmsh eta1_%d.pos' % refiter)
# Two Dirichlet brick in order to test the multiplier
# selection in the intersection.
if (Dirichlet_with_multipliers):
md.add_Dirichlet_condition_with_multipliers(mim, 'u', mfu,
DIRICHLET_BOUNDARY_NUM2, 'Ue')
else:
md.add_Dirichlet_condition_with_penalization(mim, 'u',
dirichlet_coefficient,
DIRICHLET_BOUNDARY_NUM2, 'Ue')
# Assembly of the linear system and solve.
md.solve()
# Error computation
U = md.variable('u')
L2error = gf.asm('generic', mim, 0, 'sqr(u-Ue)', -1, md)
H1error = gf.asm('generic', mim, 0, 'Norm_sqr(Grad_u-Grad_Ue)', -1, md)
H1error = np.sqrt(L2error + H1error)
L2error = np.sqrt(L2error)
print('Error in L2 norm (without reconstruction): %g' % L2error)
print('Error in H1 norm (without reconstruction): %g' % H1error)
if (using_HHO):
L2error = gf.asm('generic', mim, 0, 'sqr(HHO_Val_u-Ue)', -1, md)
H1error = gf.asm('generic', mim, 0, 'Norm_sqr(HHO_Grad_u-Grad_Ue)', -1, md)
H1error = np.sqrt(L2error + H1error)
L2error = np.sqrt(L2error)
print('Error in L2 norm (with reconstruction): %g' % L2error)
print('Error in H1 norm (with reconstruction): %g' % H1error)
# Export data
# mfur.export_to_pos('laplacian_e.pos', Ue, 'Exact solution')
np.arange(0, 1 + 1. / NX, 1. / NX)) # Structured 2D mesh
mfu2 = gf.MeshFem(m2, 1)
mfu2.set_fem(gf.Fem('FEM_PK(2,1)'))
mim2 = gf.MeshIm(m2, gf.Integ('IM_TRIANGLE(4)'))
U2 = mfu2.eval('x+y')
md = gf.Model('real')
md.add_fem_variable('u1', mfu1)
md.set_variable('u1', U1)
md.add_fem_variable('u2', mfu2)
md.set_variable('u2', U2)
md.add_standard_secondary_domain('secdom', mim2)
result = gf.asm('generic', mim1, 0, "u1*Secondary_Domain(u2)", -1, md,
"Secondary_domain", "secdom")
if (abs(result - 0.5) > 1e-8):
print("Bad value")
exit(1)
result = gf.asm('generic', mim1, 0, "u1*(Secondary_Domain(Grad_u2)(1))", -1,
md, "Secondary_domain", "secdom")
if (abs(result - 0.5) > 1e-8):
print("Bad value")
exit(1)
result = gf.asm('generic', mim1, 0,
"u1*(Secondary_Domain(X)(1)+Secondary_Domain(X)(2))", -1, md,
"Secondary_domain", "secdom")
if (abs(result - 0.5) > 1e-8):
print("Bad value")
mim_bound = gf.MeshIm('levelset', mls, 'boundary(a+b)',
gf.Integ('IM_TRIANGLE(6)')) #, gf.Integ('IM_QUAD(5)'))
mim = gf.MeshIm('levelset', mls, 'all(a+b)', gf.Integ('IM_TRIANGLE(6)'))
mim.set_integ(4)
mfu0 = gf.MeshFem(m, 2)
mfu0.set_fem(gf.Fem('FEM_QK(2,3)'))
mfdu = gf.MeshFem(m, 1)
mfdu.set_fem(gf.Fem('FEM_QK_DISCONTINUOUS(2,2)'))
mf_mult = gf.MeshFem(m, 2)
mf_mult.set_fem(gf.Fem('FEM_QK(2,1)'))
A = gf.asm('volumic', 'V()+=comp()', mim_bound)
#mls.cut_mesh().export_to_pos('mls.pos','cut mesh')
#mf_ls.export_to_pos('mf_ls.pos',ULS,'ULS')
dof_out = mfu0.dof_from_im(mim)
cv_out = mim.convex_index()
cv_in = setdiff1d(m.cvid(), cv_out)
# mfu = gf.MeshFem('partial', mfu0, dof_out, cv_in)
md = gf.Model('real')
md.add_fem_variable('u', mfu0)
md.add_initialized_data('lambda', [1])
md.add_initialized_data('mu', [1])
md.add_isotropic_linearized_elasticity_brick(mim, 'u', 'lambda', 'mu')
# Main unknown
U = md.variable('u')
L2error = gf.compute(mfu, U - Ue, 'L2 norm', mim)
H1error = gf.compute(mfu, U - Ue, 'H1 norm', mim)
print('Error in L2 norm : ', L2error)
print('Error in H1 norm : ', H1error)
# Export data
mfu.export_to_pos('laplacian.pos', Ue, 'Exact solution', U,
'Computed solution')
print('You can view the solution with (for example):')
print('gmsh laplacian.pos')
if (verify_neighbour_computation):
A = gf.asm('generic', mim, 1, 'u*Test_u*(Normal.Normal)', TEST_FACES, md)
B = gf.asm(
'generic', mim, 1,
'-Interpolate(u,neighbour_elt)*Interpolate(Test_u,neighbour_elt)*(Interpolate(Normal,neighbour_elt).Normal)',
TEST_FACES, md)
err_v = np.linalg.norm(A - B)
A = gf.asm('generic', mim, 1, '(Grad_u.Normal)*(Grad_Test_u.Normal)',
TEST_FACES, md)
B = gf.asm(
'generic', mim, 1,
'(Interpolate(Grad_u,neighbour_elt).Normal)*(Interpolate(Grad_Test_u,neighbour_elt).Normal)',
TEST_FACES, md)
err_v = err_v + np.linalg.norm(A - B)
if (err_v > 1E-13):
print('Test on neighbour element computation: error to big: ', err_v)
exit(1)
Bexact = mdmag.interpolation(Bexact_exp, intonme)
intonme.export_to_vtk('field_exact3d.vtk', 'ascii', Bexact)
print('exact B norm l2', gf.compute_L2_norm(intonme, Bexact, mim))
#Interpolate and export exact fields END
######################################################################################################################
WITH_B_CROSS_N = True
# Main potential unknown
mdmag.add_fem_variable('b', mfb)
# lagrange augmentation unknown for potential
mdmag.add_fem_variable('p', mfdiv_mult)
tm = time.time()
# building (curl b, curl \tau) term
CURL_B = gf.asm('generic', mim, 2, curl_testb_curl_b_exp, -1, 'b', 1, mfb, 0)
tm = time.time() - tm
print("CURL.CURL elapsed time", tm)
# (curl b, curl \tau) adding to the model
magi = mdmag.add_explicit_matrix('b', 'b', CURL_B)
#####################################################################################################
# Interior penalty terms
if (DS_GA):
J_CROSSTAU_DOT_M_CURLB = gf.asm(
'generic', mim, 2, '({K}).{L}'.format(K=cross_jump_test_b,
L=mean_curl_b), INNER_FACES, 'b',
1, mfb, 0)
#J_CROSSB_DOT_M_CURLTAU=gf.asm('generic', mim, 2, '({K}).{L}'.format(K=cross_jump_b, L=mean_curl_test_b), INNER_FACES, 'b', 1, mfb, 0)
CROSS_CROSS_IP_EXP = "({alpha})*({L}).({M})".format(alpha=ALPHAF,
for col in range(1000):
ls.set_values(ULS)
mls.adapt()
mim_bound = gf.MeshIm('levelset',mls,'boundary', gf.Integ('IM_TRIANGLE(6)'))
mim = gf.MeshIm('levelset',mls,'outside', gf.Integ('IM_TRIANGLE(6)'))
mim.set_integ(4)
mf_mult = gf.MeshFem(m)
mf_mult.set_fem(gf.Fem('FEM_QK(2,1)'))
M = gf.asm_mass_matrix(mim, mf_basic)
D = np.abs(M.diag().T[0])
ind = np.argwhere(D>1e-8)
mf = gf.MeshFem('partial', mf_basic, ind)
S = gf.asm('volumic','V()+=comp()',mim)
print('remaining surface :',S)
# % Problem definition (Laplace(u) + u = f)
md = gf.Model('real')
md.add_fem_variable('u', mf)
md.add_Laplacian_brick(mim, 'u')
md.add_fem_data('VolumicData', mf_basic)
md.add_source_term_brick(mim, 'u', 'VolumicData')
md.add_initialized_data('rho', [1.0])
md.add_mass_brick(mim, 'u', 'rho')
md.add_multiplier('mult_dir', mf_mult, 'u')
# % To be completely robust, a stabilization should be used on the Dirichlet
# % boundary to ensure the inf-sup condition (Nitsche or Barbosa-Hughes)
md.add_Dirichlet_condition_with_multipliers(mim_bound, 'u', 'mult_dir', -1)
V = mfv.eval('[x*y, x*y, x*y]')
W = mfw.eval('[x*y, x*y]')
md = gf.Model('real')
md.add_fem_variable('u', mfu)
md.set_variable('u', U)
md.add_fem_variable('v', mfv)
md.set_variable('v', V)
md.add_fem_variable('w', mfw)
md.set_variable('w', W)
# Simple test on the integral of u
result = gf.asm('generic', mim, 0, "u", -1, md)
if (abs(result-1) > 1e-8) : print("Bad value"); exit(1)
# Single contraction and comparison with Trace
result1 = gf.asm('generic', mim, 0,
"Def P(a):=a*(a'); Contract(P(Grad_v), 1, 2)", -1, md)
result2 = gf.asm('generic', mim, 0,
"Def P(a):=a*(a'); Trace(P(Grad_v))", -1, md)
if (abs(result1-result2) > 1e-8) : print("Bad value"); exit(1)
# Constant order 3 tensor contraction test
result1 = gf.asm('generic', mim, 0,
"Contract([[[1,1],[2,2]],[[1,1],[2,2]]], 1, 2)", -1, md)
result2 = np.array([3., 3.]);
if (np.linalg.norm(result1-result2) > 1e-8) : print("Bad value"); exit(1)