def __init__(self, point_coords, element_nodes, spring_constant=1.):
self.pts = array(point_coords, copy=1)
self.elnodes = array(element_nodes, copy=1)
self.npts = len(self.pts)
self.nels = len(self.elnodes)
self.mesh = gf.Mesh('empty', 2)
for i in range(self.npts):
self.mesh.add_point(self.pts[i, :])
for i in range(self.nels):
self.mesh.add_convex(gf.GeoTrans('GT_PK(1,1)'),
transpose(self.pts[self.elnodes[i, :]]))
self.fem = gf.MeshFem(self.mesh)
self.ptdm = zeros(
(self.npts, 2), dtype=int
) # point-to-dof-map i.e. rhs=self.model.rhs() then rhs[ptdm[p,i]] applies to point p and coordinate axis i
self.fem.set_qdim(2)
self.fem.set_classical_fem(1)
# classic means Lagrange polynomial
self.mim = gf.MeshIm(self.mesh, gf.Integ('IM_GAUSS1D(2)'))
self.model = gf.Model('real') # 2D model variable U is of real value
self.EA = spring_constant # stiffness k = E*A
self.model.add_initialized_data(
'lambda', self.EA) # define Lame coefficients lambda and mu
self.model.add_initialized_data('mu', 0)
# define Lame coefficients lambda and mu
self.model.add_fem_variable('U', self.fem)
self.model.add_isotropic_linearized_elasticity_brick(
self.mim, 'U', 'lambda', 'mu')
self.nreg = 0 # how many regions are defined on the mesh
self.fixreg = 0 # how many regions have been created for the purpose of fixing nodes
self.loadreg = 0 # how many regions have been created for the purpose of loading nodes
self.s_pts = zeros((self.npts, 2)) # shifted points
self.lengths = zeros(self.nels) # element lengths
self.s_lengths = zeros(
self.nels) # element lengths in deformed geometry
self.elong = zeros(self.nels) # element elongation factor
self.p_elong = zeros(self.nels) # element percentage of elongation
self.delta_l = zeros(self.nels) # element length differences
self.thescore = 0
import getfem as gf
import numpy as np
# creation of a simple cartesian mesh
m = gf.Mesh('cartesian', np.arange(0,1.1,0.1), np.arange(0,1.1,0.1))
# create a MeshFem of for a field of dimension 1 (i.e. a scalar field)
mf = gf.MeshFem(m, 1)
# assign the Q2 fem to all convexes of the MeshFem
mf.set_fem(gf.Fem('FEM_QK(2,2)'))
# view the expression of its basis functions on the reference convex
print gf.Fem('FEM_QK(2,2)').poly_str()
# an exact integration will be used
mim = gf.MeshIm(m, gf.Integ('IM_EXACT_PARALLELEPIPED(2)'))
# detect the border of the mesh
border = m.outer_faces()
# mark it as boundary #42
m.set_region(42, border)
# empty real model
md = gf.Model('real')
# declare that "u" is an unknown of the system
# on the finite element method `mf`
md.add_fem_variable('u', mf)
# add generic elliptic brick on "u"
md.add_Laplacian_brick(mim, 'u');
# create a Mesh object (importing)
m = gf.Mesh('import', 'gid', file_msh)
m.set('optimize structure')
# create a MeshFem object
mfu = gf.MeshFem(m, 3) # displacement
mfd = gf.MeshFem(m, 1) # data
mfe = gf.MeshFem(m, 1) # for plot von-mises
# assign the FEM
mfu.set_fem(gf.Fem('FEM_PK(3,%d)' % (degree, )))
mfd.set_fem(gf.Fem('FEM_PK(3,0)'))
mfe.set_fem(gf.Fem('FEM_PK_DISCONTINUOUS(3,%d,0.01)' % (degree, )))
# build a MeshIm object
mim = gf.MeshIm(m, gf.Integ('IM_TETRAHEDRON(5)'))
print 'nbcvs=%d, nbpts=%d, qdim=%d, fem = %s, nbdof=%d' % \
(m.nbcvs(), m.nbpts(), mfu.qdim(), mfu.fem()[0].char(), mfu.nbdof())
# detect some boundary of the mesh
P = m.pts()
ctop = (abs(P[1, :] - 13) < 1e-6)
cbot = (abs(P[1, :] + 10) < 1e-6)
pidtop = np.compress(ctop, range(0, m.nbpts()))
pidbot = np.compress(cbot, range(0, m.nbpts()))
ftop = m.faces_from_pid(pidtop)
fbot = m.faces_from_pid(pidbot)
# create boundary region
NEUMANN_BOUNDARY = 1
DIRICHLET_BOUNDARY = 2
mesh.set_region(LEFT_BOUND, fb1)
mesh.set_region(BOTTOM_BOUND, fb2)
mesh.set_region(AUX_BOUND1, fb3)
mesh.set_region(AUX_BOUND2, fb4)
mesh.region_subtract(LEFT_BOUND, AUX_BOUND2)
mesh.region_subtract(BOTTOM_BOUND, AUX_BOUND1)
# Create a MeshFem for u and rhs fields of dimension 1 (i.e. a scalar field)
mfu = gf.MeshFem(mesh, 1)
mfP0 = gf.MeshFem(mesh, 1)
# Assign the discontinuous P2 fem to all convexes of the both MeshFem
mfu.set_fem(gf.Fem('FEM_PK(2,2)'))
mfP0.set_fem(gf.Fem('FEM_PK(2,0)'))
# Integration method used
mim = gf.MeshIm(mesh, gf.Integ('IM_TRIANGLE(4)'))
# Inner edges for the computation of the normal derivative jump
in_faces = mesh.inner_faces()
INNER_FACES = 18
mesh.set_region(INNER_FACES, in_faces)
# Model
md = gf.Model('real')
# Main unknown
md.add_fem_variable('u', mfu)
# Laplacian term on u
md.add_Laplacian_brick(mim, 'u')
with_graphics = True
try:
import getfem_tvtk
except:
print "\n** Could NOT import getfem_tvtk -- graphical output disabled **\n"
import time
time.sleep(2)
with_graphics = False
L = 100
H = 20
m = gf.Mesh('triangles grid', np.arange(0, L + 0.01, 4),
np.arange(0, H + 0.01, 2))
mim = gf.MeshIm(m, gf.Integ('IM_TRIANGLE(6)'))
mfu = gf.MeshFem(m, 2)
mfsigma = gf.MeshFem(m, 4)
mfd = gf.MeshFem(m)
mf0 = gf.MeshFem(m)
mfdu = gf.MeshFem(m)
mfu.set_fem(gf.Fem('FEM_PK(2,1)'))
mfsigma.set_fem(gf.Fem('FEM_PK_DISCONTINUOUS(2,1)'))
mfd.set_fem(gf.Fem('FEM_PK(2,1)'))
mf0.set_fem(gf.Fem('FEM_PK(2,0)'))
mfdu.set_fem(gf.Fem('FEM_PK_DISCONTINUOUS(2,1)'))
Lambda = 121150
Mu = 80769
von_mises_threshold = 4000
d = 1.000e+00
x = 1.000e+00
y = 1.000e+00
z = 1.000e+00
m = gf.Mesh('cartesian Q1', np.arange(0., x + d, d), np.arange(0., y + d, d),
np.arange(0., z + d, d))
m.set('optimize_structure')
print "create a MeshFem object"
mfu = gf.MeshFem(m, 3) # displacement
print "assign the FEM"
mfu.set_fem(gf.Fem('FEM_QK(3,1)'))
print "build a MeshIm object"
mim = gf.MeshIm(m, gf.Integ('IM_HEXAHEDRON(5)'))
print "detect some boundary of the mesh"
P = m.pts()
ctop = (abs(P[0, :] - 0.) < 1e-6)
cbot = (abs(P[1, :] - 0.) < 1e-6)
pidtop = np.compress(ctop, range(0, m.nbpts()))
pidbot = np.compress(cbot, range(0, m.nbpts()))
ftop = m.faces_from_pid(pidtop)
fbot = m.faces_from_pid(pidbot)
print "create boundary region"
NEUMANN_BOUNDARY = 1
DIRICHLET_BOUNDARY = 2
m.set_region(NEUMANN_BOUNDARY, ftop)
m.set_region(DIRICHLET_BOUNDARY, fbot)
gf.MeshFem("product", mf_part_unity,
gf.MeshFem("global function", m, ls, ck, 1))
for ls in [ls1, ls2]
]
mf_sing[0].set_enriched_dofs(np.union1d(ctip_dofs[0], ctip_dofs[1]))
mf_sing[1].set_enriched_dofs(np.union1d(ctip_dofs[2], ctip_dofs[3]))
mf_u = gf.MeshFem("sum", mf_sing[0], mf_sing[1], mfls)
mf_u.set_qdim(2)
mf_theta = gf.MeshFem("sum", mf_sing[0], mf_sing[1], mfls)
# MeshIm definition (MeshImLevelSet):
if (quad):
mim = gf.MeshIm(
"levelset", mls, "all",
gf.Integ("IM_STRUCTURED_COMPOSITE(IM_TRIANGLE(6),5)"),
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)"]
]
m.region_subtract(WALL_RG, INOUT_RG)
#MeshFem
mfv_ = gf.MeshFem(m, 2)
mfv_.set_classical_fem(2)
kept_dofs = np.setdiff1d(np.arange(mfv_.nb_basic_dof()),
mfv_.basic_dof_on_region(WALL_RG))
mfv = gf.MeshFem("partial", mfv_, kept_dofs)
mfp_ = gf.MeshFem(m, 1)
mfp_.set_classical_fem(1)
kept_dofs = np.setdiff1d(np.arange(mfp_.nb_basic_dof()),
mfp_.basic_dof_on_region(OUT_RG))
mfp = gf.MeshFem("partial", mfp_, kept_dofs)
mim = gf.MeshIm(m, 5) # 9 gauss points per quad
md = gf.Model("real")
md.add_fem_variable("v", mfv)
md.add_fem_data("v0", mfv)
md.add_fem_variable("p", mfp)
md.add_fem_data("p_in", mfp_)
md.add_initialized_data("f", [0,0])
md.add_initialized_data("dt", [dt])
md.add_initialized_data("nu", [nu])
md.add_Dirichlet_condition_with_multipliers(mim, "p", mfp, IN_RG, "p_in")
md.add_nonlinear_term\
(mim, "1/dt*(v-v0).Test_v + (Grad_v0*v0).Test_v + nu*Grad_v:Grad_Test_v - f.Test_v")
md.add_nonlinear_term\
(mim, "Grad_p.Grad_Test_p + 1/dt*Trace(Grad_v)*Test_p")
P = m.pts()
is_in_circle = (P[0, :] - xc)**2 + (P[1, :] - yc)**2 <= radius**2
areap = np.zeros(idx.size - 1)
for cv in range(idx.size - 1):
if all(is_in_circle[pid[idx[cv]:idx[cv + 1]]]):
areap[cv] = 1
mfu = gf.MeshFem(m, 2)
mfd = gf.MeshFem(m, 1)
mfm = gf.MeshFem(m, 2)
mfdu = gf.MeshFem(m)
mim = gf.MeshIm(m, 5)
mfu.set_fem(gf.Fem('FEM_QK(2,2)'))
mfd.set_fem(gf.Fem('FEM_QK(2,1)'))
mfm.set_fem(gf.Fem('FEM_QK(2,2)'))
mfdu.set_fem(gf.Fem('FEM_QK_DISCONTINUOUS(2,2)'))
mfu.set_dof_partition(areap)
b_in = m.outer_faces(np.nonzero(areap == 1))
b_out = m.outer_faces(np.nonzero(areap == 0))
b_border = m.outer_faces()
b_out = np.array(
tuple(
set(tuple(r) for r in b_out.transpose()) -
set(tuple(r) for r in b_border.transpose()))).transpose()
NX = 80 # Number of element per direction
if (quadrangles):
m = gf.Mesh('cartesian', np.arange(0., 1. + 1. / NX, 1. / NX),
np.arange(0., 1. + 1. / NX, 1. / NX))
else:
m = gf.Mesh(
'import', 'structured',
'GT="GT_PK(2,1)";SIZES=[1,1];NOISED=0;NSUBDIV=[%d,%d];' % (NX, NX))
## Create a mesh_fem for a 2D vector field
mftheta = gf.MeshFem(m, 2)
mfu = gf.MeshFem(m, 1)
mftheta.set_classical_fem(K)
mfu.set_classical_fem(K)
mim = gf.MeshIm(m, 6)
mim_reduced = gf.MeshIm(m, 1)
## Detect the border of the mesh and assign it the boundary number 1
border = m.outer_faces()
m.set_region(1, border)
## Build the model
md = gf.Model('real')
md.add_fem_variable('u', mfu)
md.add_fem_variable('theta', mftheta)
md.add_initialized_data('E', Emodulus)
md.add_initialized_data('nu', nu)
md.add_initialized_data('epsilon', epsilon)
md.add_initialized_data('kappa', kappa)
n = [-np.sin(theta), np.cos(theta)]
R = 0.19 #rand() * 0.09 + 0.02
ULS2 = np.minimum(ULS2, ((x - xc) * n[0] + (y - yc) * n[1]))
#ULS2s = np.minimum(ULS2s, ((x - xc)**2 + (y - yc)**2) - R**2)
ULS2s = np.minimum(ULS2s, (abs(y - yc) + abs(x - xc) - R))
ls2.set_values(ULS2, ULS2s) # '-y-x+.2') # '(y-.2)^2 - 0.04')
mls = gf.MeshLevelSet(m)
mls.add(ls)
mls.add(ls2)
mls.adapt()
mls.cut_mesh().export_to_pos('ver.pos')
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')
err_L2 = 400
err_H1 = 400
exit(1)
else:
# Load the final step
filename = resultspath + ('/mf_%d.mf' % (NT))
m = gf.Mesh('load', filename)
mf_u = gf.MeshFem('load', filename, m)
filename = resultspath + ('/U_%d.dat' % (NT))
U = np.loadtxt(filename)
# Load the reference solution
m_ref = gf.Mesh('load', refname_mf)
mf_u_ref = gf.MeshFem('load', refname_mf, m_ref)
U_ref = np.loadtxt(refname_U)
mim_ref = gf.MeshIm(m_ref, 6)
# Estimate of the difference in L2 and H1 norms
Ui = gf.compute_interpolate_on(mf_u, U, mf_u_ref)
norm_L2 = gf.compute_L2_norm(mf_u_ref, U_ref, mim_ref)
err_L2 = gf.compute_L2_dist(mf_u_ref, Ui, mim_ref,
mf_u_ref, U_ref)
norm_H1 = gf.compute_H1_semi_norm(mf_u_ref, U_ref, mim_ref)
norm_H1 = np.sqrt(pow(norm_L2, 2) + pow(norm_H1, 2))
err_H1 = gf.compute_H1_semi_dist(mf_u_ref, Ui, mim_ref,
mf_u_ref, U_ref)
print 'Error in L2 norm: %g' % err_L2
print 'Error in H1 semi-norm: %g' % err_H1
errors1[option, i, 0] = err_L2 / norm_L2
errors1[option, i,
np.square(DOFpts[1, :] + 0.375) <= 0.1**2)[0]
mf_sing_u2 = gf.MeshFem('global function', m, ls2,
[ck0, ck1, ck2, ck3], 1)
mf_xfem_sing2 = gf.MeshFem('product', mf_part_unity, mf_sing_u2)
mf_xfem_sing2.set_enriched_dofs(np.union1d(Idofs_up, Idofs_down))
if variant == 2:
mf_u = gf.MeshFem('sum', mf_xfem_sing, mfls_u)
else:
mf_u = gf.MeshFem('sum', mf_xfem_sing, mf_xfem_sing2, mfls_u)
mf_u.set_qdim(2)
# MeshIm definition (MeshImLevelSet):
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)'))
# Exact solution for a single crack:
mf_ue = gf.MeshFem('global function', m, ls, [ck0, ck1, ck2, ck3])
A = 2 + 2 * Mu / (Lambda + 2 * Mu)
B = -2 * (Lambda + Mu) / (Lambda + 2 * Mu)
Ue = np.zeros([2, 4])
Ue[0, 0] = 0
Ue[1, 0] = A - B # sin(theta/2)
Ue[0, 1] = A + B
Ue[1, 1] = 0 # cos(theta/2)
Ue[0, 2] = -B
Ue[1, 2] = 0 # sin(theta/2)*sin(theta)
Ue[0, 3] = 0
if test_case >= 2:
mesh1.set_region(CONTACT_BOUNDARY1, border)
else:
normals = mesh1.normal_of_faces(border)
contact_boundary = border[:, np.nonzero(normals[N - 1] < -0.01)[0]]
mesh1.set_region(CONTACT_BOUNDARY1, contact_boundary)
P = mesh1.pts() # get list of mesh points coordinates
ctop = (P[N - 1, :] > 39.999) # find those on top of the object
pidtop = np.compress(ctop, list(range(0, mesh1.nbpts())))
ftop = mesh1.faces_from_pid(pidtop)
mesh1.set_region(DIRICHLET_BOUNDARY1, ftop)
# dol1 = pre_mflambda1.basic_dof_on_region(CONTACT_BOUNDARY1)
# mflambda1 = gf.MeshFem("partial", pre_mflambda1, dol1)
mim1 = gf.MeshIm(mesh1, 4)
mim1_contact = gf.MeshIm(mesh1, 4)
if test_case not in [0, 3]:
mfu2 = gf.MeshFem(mesh2, N)
mfu2.set_classical_fem(2)
pre_mflambda2 = gf.MeshFem(mesh2, N)
pre_mflambda2.set_classical_fem(1)
mfvm2 = gf.MeshFem(mesh2)
mfvm2.set_classical_discontinuous_fem(1)
CONTACT_BOUNDARY2 = 2
border = mesh2.outer_faces()
if test_case != 1:
if (export_mesh):
mesh.export_to_vtk('mesh.vtk');
print ('\nYou can view the mesh for instance with');
print ('mayavi2 -d mesh.vtk -f ExtractEdges -m Surface \n');
#
# Definition of finite elements methods and integration method
#
mfu = gf.MeshFem(mesh, 2) # Finite element for the elastic displacement
mfu.set_classical_fem(elements_degree)
mft = gf.MeshFem(mesh, 1) # Finite element for temperature and electrical field
mft.set_classical_fem(elements_degree)
mfvm = gf.MeshFem(mesh, 1) # Finite element for Von Mises stress interpolation
mfvm.set_classical_discontinuous_fem(elements_degree)
mim = gf.MeshIm(mesh, pow(elements_degree,2)) # Integration method
#
# Model definition
#
md=gf.Model('real');
md.add_fem_variable('u', mfu) # Displacement of the structure
md.add_fem_variable('theta', mft) # Temperature
md.add_fem_variable('V', mft) # Electric potential
# Membrane elastic deformation
md.add_initialized_data('cmu', [cmu])
md.add_initialized_data('clambdastar', [clambdastar])
md.add_isotropic_linearized_elasticity_brick(mim, 'u', 'clambdastar', 'cmu')
#mesh_B.set_pts(pts_B)
#mesh_R.export_to_vtk('/tmp/mesh_R.vtk')
#mesh_B.export_to_vtk('/tmp/mesh_B.vtk')
# Ring
mfu_R = gf.MeshFem(mesh_R, N)
mfu_R.set_classical_fem(fem_disp_order_R)
pre_mflambda_R = gf.MeshFem(mesh_R, N)
pre_mflambda_R.set_classical_fem(fem_mult_order_R)
mfvm_R = gf.MeshFem(mesh_R)
mfvm_R.set_classical_discontinuous_fem(fem_disp_order_R-1)
mim_R = gf.MeshIm(mesh_R, integration_degree_R)
mim_R_contact = gf.MeshIm(mesh_R, integration_contact_degree_R)
# Block
mfu_B = gf.MeshFem(mesh_B, N)
mfu_B.set_classical_fem(fem_disp_order_B)
pre_mflambda_B = gf.MeshFem(mesh_B, N)
pre_mflambda_B.set_classical_fem(fem_mult_order_B)
mfvm_B = gf.MeshFem(mesh_B)
mfvm_B.set_classical_discontinuous_fem(fem_disp_order_B-1)
mim_B = gf.MeshIm(mesh_B, integration_degree_B)
mim_B_contact = gf.MeshIm(mesh_B, integration_contact_degree_B)
# lawname = 'Ciarlet Geymonat'
# params = [1.,1.,0.25]
lawname = 'SaintVenant Kirchhoff'
params = [1.,1.]
if (incompressible):
lawname = 'Incompressible Mooney Rivlin'
params = [1.,1.]
N1 = 2; N2 = 4; h = 20.; DX = 1./N1; DY = (1.*h)/N2;
m = gf.Mesh('cartesian', np.arange(-0.5, 0.5+DX,DX), np.arange(0., h+DY,DY),
np.arange(-1.5, 1.5+3*DX,3*DX))
mfu = gf.MeshFem(m, 3) # mesh-fem supporting a 3D-vector field
mfdu = gf.MeshFem(m,1)
# The mesh_im stores the integration methods for each tetrahedron
mim = gf.MeshIm(m, gf.Integ('IM_GAUSS_PARALLELEPIPED(3,4)'))
# We choose a P2 fem for the main unknown
mfu.set_fem(gf.Fem('FEM_QK(3,2)'))
if (dirichlet_version == 1):
mfd = mfu;
else:
mfd = gf.MeshFem(m,1)
mfd.set_fem(gf.Fem('FEM_QK(3,1)'))
# The P2 fem is not derivable across elements, hence we use a discontinuous
# fem for the derivative of U.
mfdu.set_fem(gf.Fem('FEM_QK_DISCONTINUOUS(3,2)'));
# Display some information about the mesh
print('nbcvs=%d, nbpts=%d, nbdof=%d' % (m.nbcvs(), m.nbpts(), mfu.nbdof()))
def import_fem2(sico):
""" Build a mesh object using getfem.
We use getfem++ to build the finite element model and
to fill in the operators required by siconos:
- the mass matrix (Mass)
- the stiffness matrix (Stiff)
- the matrix that links global coordinates and local coord. at contact points (H)
"""
############################
# The geometry and the mesh
############################
dimX = 10.01
dimY = 10.01
dimZ = 10.01
stepX = 1.0
stepY = 1.0
stepZ = 1.0
x = np.arange(0, dimX, stepX)
y = np.arange(0, dimY, stepY)
z = np.arange(0, dimZ, stepZ)
m = gf.Mesh('regular simplices', x, y, z)
m.set('optimize_structure')
# Export the mesh to vtk
m.export_to_vtk("BlockMesh.vtk")
# Create MeshFem objects
# (i.e. assign elements onto the mesh for each variable)
mfu = gf.MeshFem(m, 3) # displacement
mfd = gf.MeshFem(m, 1) # data
mff = gf.MeshFem(m, 1) # for plot von-mises
# assign the FEM
mfu.set_fem(gf.Fem('FEM_PK(3,1)'))
mfd.set_fem(gf.Fem('FEM_PK(3,0)'))
mff.set_fem(gf.Fem('FEM_PK_DISCONTINUOUS(3,1,0.01)'))
# mfu.export_to_vtk("BlockMeshDispl.vtk")
# Set the integration method
mim = gf.MeshIm(m, gf.Integ('IM_TETRAHEDRON(5)'))
# Summary
print(' ==================================== \n Mesh details: ')
print(' Problem dimension:', mfu.qdim(), '\n Number of elements: ',
m.nbcvs(), '\n Number of nodes: ', m.nbpts())
print(' Number of dof: ', mfu.nbdof(), '\n Element type: ',
mfu.fem()[0].char())
print(' ====================================')
###########################
# Set the parameters
# for the constitutive law
###########################
E = 1e3 # Young modulus
Nu = 0.3 # Poisson coef.
# Lame coeff.
Lambda = E * Nu / ((1 + Nu) * (1 - 2 * Nu))
Mu = E / (2 * (1 + Nu))
# Density
Rho = 7800
############################
# Boundaries detection
############################
allPoints = m.pts()
# Bottom points and faces
cbot = (abs(allPoints[2, :]) < 1e-6)
pidbot = np.compress(cbot, list(range(0, m.nbpts())))
fbot = m.faces_from_pid(pidbot)
BOTTOM = 1
m.set_region(BOTTOM, fbot)
# Top points and faces
ctop = (abs(allPoints[2, :]) > dimZ - stepZ)
pidtop = np.compress(ctop, list(range(0, m.nbpts())))
ftop = m.faces_from_pid(pidtop)
TOP = 2
m.set_region(TOP, ftop)
# Top-Left points and faces
cleft = (abs(allPoints[1, :]) < 1e-6)
clefttop = cleft * ctop
pidlefttop = np.compress(clefttop, list(range(0, m.nbpts())))
flefttop = m.faces_from_pid(pidlefttop)
pidleft = np.compress(cleft, list(range(0, m.nbpts())))
fleft = m.faces_from_pid(pidleft)
LEFTTOP = 3
m.set_region(LEFTTOP, flefttop)
LEFT = 4
m.set_region(LEFT, fleft)
############################
# Assembly
############################
nbd = mfd.nbdof()
# Stiffness matrix
sico.Stiff = gf.asm_linear_elasticity(mim, mfu, mfd,
np.repeat([Lambda], nbd),
np.repeat([Mu], nbd))
# Mass matrix
sico.Mass = Rho * gf.asm_mass_matrix(mim, mfu)
# Right-hand side
Ftop = gf.asm_boundary_source(TOP, mim, mfu, mfd,
np.repeat([[0], [0], [-1]], nbd, 1))
Fleft = gf.asm_boundary_source(LEFT, mim, mfu, mfd,
np.repeat([[0], [10], [0]], nbd, 1))
sico.RHS = Ftop + Fleft
sico.nbdof = mfu.nbdof()
sico.q0 = mfu.basic_dof_from_cvid()
sico.bot = pidbot
# H-Matrix
fillH(pidbot, sico, mfu.nbdof())
return m
generally GetFEM are working. It focuses on testing some operations
of the high generic assembly language.
$Id$
"""
import numpy as np
import getfem as gf
import os
NX = 4
m1 = gf.Mesh('cartesian', np.arange(0, 1 + 1. / NX,
1. / NX)) # Structured 1D mesh
mfu1 = gf.MeshFem(m1, 1)
mfu1.set_fem(gf.Fem('FEM_PK(1,1)'))
mim1 = gf.MeshIm(m1, gf.Integ('IM_GAUSS1D(4)'))
U1 = mfu1.eval('x')
m2 = gf.Mesh('triangles grid', np.arange(0, 1 + 1. / NX, 1. / NX),
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)
def import_fem(sico):
""" Build a mesh object using getfem.
We use getfem++ to build the finite element model and
to fill in the operators required by siconos:
- the mass matrix (Mass)
- the stiffness matrix (Stiff)
- the matrix that links global coordinates and local coord. at contact points (H)
"""
############################
# The geometry and the mesh
############################
dimX = 10.01
dimY = 10.01
dimZ = 3.01
stepX = 1.0
stepY = 1.0
stepZ = 1.0
x = np.arange(0, dimX, stepX)
y = np.arange(0, dimY, stepY)
z = np.arange(0, dimZ, stepZ)
m = gf.Mesh('regular simplices', x, y, z)
m.set('optimize_structure')
# Export the mesh to vtk
m.export_to_vtk("BlockMesh.vtk")
# Create MeshFem objects
# (i.e. assign elements onto the mesh for each variable)
mfu = gf.MeshFem(m, 3) # displacement
mfd = gf.MeshFem(m, 1) # data
mff = gf.MeshFem(m, 1) # for plot von-mises
# assign the FEM
mfu.set_fem(gf.Fem('FEM_PK(3,1)'))
mfd.set_fem(gf.Fem('FEM_PK(3,0)'))
mff.set_fem(gf.Fem('FEM_PK_DISCONTINUOUS(3,1,0.01)'))
# mfu.export_to_vtk("BlockMeshDispl.vtk")
# Set the integration method
mim = gf.MeshIm(m, gf.Integ('IM_TETRAHEDRON(5)'))
# Summary
print(' ==================================== \n Mesh details: ')
print(' Problem dimension:', mfu.qdim(), '\n Number of elements: ',
m.nbcvs(), '\n Number of nodes: ', m.nbpts())
print(' Number of dof: ', mfu.nbdof(), '\n Element type: ',
mfu.fem()[0].char())
print(' ====================================')
###########################
# Set the parameters
# for the constitutive law
###########################
E = 1e3 # Young modulus
Nu = 0.3 # Poisson coef.
# Lame coeff.
Lambda = E * Nu / ((1 + Nu) * (1 - 2 * Nu))
Mu = E / (2 * (1 + Nu))
# Density
Rho = 1.0 #7.800
Gravity = -9.81
############################
# Boundaries detection
############################
allPoints = m.pts()
# Bottom points and faces
cbot = (abs(allPoints[2, :]) < 1e-6)
pidbot = np.compress(cbot, list(range(0, m.nbpts())))
fbot = m.faces_from_pid(pidbot)
BOTTOM = 1
m.set_region(BOTTOM, fbot)
# Top points and faces
ctop = (abs(allPoints[2, :]) > dimZ - stepZ)
pidtop = np.compress(ctop, list(range(0, m.nbpts())))
ftop = m.faces_from_pid(pidtop)
TOP = 2
m.set_region(TOP, ftop)
# Top-Left points and faces
cleft = (abs(allPoints[1, :]) < 1e-6)
clefttop = cleft * ctop
pidlefttop = np.compress(clefttop, list(range(0, m.nbpts())))
flefttop = m.faces_from_pid(pidlefttop)
pidleft = np.compress(cleft, list(range(0, m.nbpts())))
fleft = m.faces_from_pid(pidleft)
LEFTTOP = 3
m.set_region(LEFTTOP, flefttop)
LEFT = 4
m.set_region(LEFT, fleft)
# Create a model
md = gf.Model('real')
md.add_fem_variable('u', mfu)
md.add_initialized_data('lambda', Lambda)
md.add_initialized_data('mu', Mu)
md.add_initialized_data('source_term', [0, 0, -100])
md.add_initialized_data('push', [0, 100, 0])
md.add_initialized_data('rho', Rho)
md.add_initialized_data('gravity', Gravity)
# Weight = np.zeros(mfu.nbdof())
## Weight = []
md.add_initialized_data('weight', [0, 0, Rho * Gravity])
md.add_isotropic_linearized_elasticity_brick(mim, 'u', 'lambda', 'mu')
#md.add_source_term_brick(mim,'u','source_term',TOP)
#md.add_source_term_brick(mim,'u','push',LEFT)
md.add_source_term_brick(mim, 'u', 'weight')
#md.add_Dirichlet_condition_with_multipliers(mim,'u',mfu,BOTTOM)
md.assembly()
sico.Stiff = md.tangent_matrix()
sico.RHS = md.rhs()
sico.q0 = md.variable('u')
md2 = gf.Model('real')
md2.add_fem_variable('u', mfu)
md2.add_initialized_data('rho', Rho)
md2.add_mass_brick(mim, 'u', 'rho')
md2.assembly()
sico.Mass = md2.tangent_matrix()
sico.nbdof = mfu.nbdof()
sico.mfu = mfu
sico.mesh = m
sico.pos = np.zeros(sico.nbdof)
sico.pos[0:sico.nbdof:3] = m.pts()[0, :]
sico.pos[1:sico.nbdof:3] = m.pts()[1, :]
sico.pos[2:sico.nbdof:3] = m.pts()[2, :]
sico.K0 = np.dot(sico.Stiff.full(), sico.pos)
sico.bot = pidbot
# running solve...
#md.solve()
# post-processing
#VM=md.compute_isotropic_linearized_Von_Mises_or_Tresca('u','lambda','mu',mff)
# extracted solution
#U = md.variable('u')
# export U and VM in a pos file
#sl = gf.Slice(('boundary',),mfu,1)
#sl.export_to_vtk('toto.vtk', mfu, U, 'Displacement', mff, VM, 'Von Mises Stress')
# H-Matrix
fillH(pidbot, sico, mfu.nbdof())
return md
mesh.export_to_vtk("%s/mesh.vtk" % resultspath)
# FEM
mfu = gf.MeshFem(mesh, N)
mfu.set_classical_fem(disp_fem_order)
mfdir = mfu
mfphi = gf.MeshFem(mesh, 1)
mfphi.set_classical_fem(phi_fem_order)
mfout = gf.MeshFem(mesh)
mfout.set_classical_discontinuous_fem(2)
# Integration method
mim = gf.MeshIm(mesh, integration_degree)
mimd1 = gf.MeshImData(mim, -1)
# Model
md = gf.Model("real")
md.add_fem_variable("u", mfu) # displacements
md.add_fem_variable("phi", mfphi) # phase field
md.add_fem_data("u_stored", mfu)
md.add_fem_data("phi_stored", mfphi)
md.add_im_data("psi0_max", mimd1)
md.add_initialized_data("kappa", E / (3. * (1. - 2. * nu)))
md.add_initialized_data("mu", E / (2 * (1 + nu)))
mfus = []
mfds = []
mims = []
for elements_degree, mesh in zip(elements_degrees, meshs):
mfu = gf.MeshFem(mesh, 3)
mfu.set_classical_fem(elements_degree)
mfus.append(mfu)
mfd = gf.MeshFem(mesh, 1)
mfd.set_classical_fem(elements_degree)
mfds.append(mfd)
mim = gf.MeshIm(mesh, elements_degree * 2)
mims.append(mim)
###############################################################################
# We get the mass and stiffness matrices using asm function.
#
mass_matrixs = []
linear_elasticitys = []
for i, (mfu, mfd, mim) in enumerate(zip(mfus, mfds, mims)):
mass_matrix = gf.asm_mass_matrix(mim, mfu, mfu)
mass_matrix.scale(rho)
mass_matrixs.append(mass_matrix)
print('Geometric transformation: ', gt[0])
print('num Tetra: ', len(listTetra))
print('num Hexa: ', len(listHexa))
print('num Hexa: ', len(listHexa))
print('num Hexa: ', len(listHexa))
mfu = gf.MeshFem(m, 3)
mfu.set_fem(gf.Fem('FEM_QK(3,{d})'.format(d=degree)),listHexa)
mfu.set_fem(gf.Fem('FEM_PYRAMID_LAGRANGE({d})'.format(d=degree)),listPyramid)
mfu.set_fem(gf.Fem('FEM_PK_PRISM(3,{d})'.format(d=degree)),listPrism)
mfu.set_fem(gf.Fem('FEM_PK(3,{d})'.format(d=degree)),listTetra)
mim = gf.MeshIm(m, 3)
# Model
md = gf.Model('real')
md.add_fem_variable('u',mfu)
md.add_initialized_data('mu_para', Mu)
md.add_initialized_data('lambda_para', Lambda)
md.add_linear_generic_assembly_brick(mim,"lambda_para*Div_u*Div_Test_u + 2*mu_para*Sym(Grad_u):Grad_Test_u")
md.add_initialized_data('Fdata',[0.0,-1.0, 0.0])
md.add_source_term_brick(mim, 'u', 'Fdata', NEUMANN_BOUNDARY)
md.add_initialized_data('DirichletData', [0, 0, 0])
md.add_Dirichlet_condition_with_simplification('u', DIRICHLET_BOUNDARY,'DirichletData')
md.solve('max_res', 1E-9, 'max_iter', 100, 'noisy', 'lsearch', 'simplest', 'alpha min', 0.8)
U = md.variable('u');
# Definition of finite elements methods and integration method
#
mfu1 = gf.MeshFem(mesh1, 2)
mfu1.set_classical_fem(elements_degree)
mflambda = gf.MeshFem(mesh1, 2)
mflambda.set_classical_fem(elements_degree - 1)
mflambda_C = gf.MeshFem(mesh1, 1)
mflambda_C.set_classical_fem(elements_degree - 1)
mfu2 = gf.MeshFem(mesh2, 2)
mfu2.set_classical_fem(elements_degree)
mfvm1 = gf.MeshFem(mesh1, 1)
mfvm1.set_classical_discontinuous_fem(elements_degree)
mfvm2 = gf.MeshFem(mesh2, 1)
mfvm2.set_classical_discontinuous_fem(elements_degree)
mim1 = gf.MeshIm(mesh1, 4)
mim1c = gf.MeshIm(mesh1, gf.Integ('IM_STRUCTURED_COMPOSITE(IM_TRIANGLE(4),2)'))
mim2 = gf.MeshIm(mesh2, 4)
#
# Model definition
#
md = gf.Model('real')
md.add_fem_variable('u1', mfu1) # Displacement of the structure 1
md.add_fem_variable('u2', mfu2) # Displacement of the structure 2
md.add_initialized_data('cmu', [cmu])
md.add_initialized_data('clambdastar', [clambdastar])
md.add_isotropic_linearized_elasticity_brick(mim1, 'u1', 'clambdastar', 'cmu')
md.add_isotropic_linearized_elasticity_brick(mim2, 'u2', 'clambdastar', 'cmu')
kept_dofs = np.setdiff1d(np.arange(mfN.nb_basic_dof()),
np.union1d(xdofsL, ydofsB))
mfu = gf.MeshFem('partial', mfN, kept_dofs)
else:
mfu = mfN
mfp = gf.MeshFem(mesh, 1)
mfp.set_classical_fem(press_fem_order)
mfksi = gf.MeshFem(mesh, 1)
mfksi.set_classical_fem(mult_fem_order)
mfout = gf.MeshFem(mesh)
mfout.set_classical_discontinuous_fem(disp_fem_order)
mim = gf.MeshIm(mesh, integration_degree)
mimd1 = gf.MeshImData(mim, -1, [1])
mimd4 = gf.MeshImData(mim, -1, [4])
mimpress = gf.MeshIm(mesh, integration_degree_press)
# Model
md = gf.Model('real')
md.add_fem_variable('u', mfu) # displacements
md.add_fem_variable('p', mfp) # pressure
md.add_fem_variable("ksi", mfksi) # plastic multiplier for the current step
md.add_im_data("gamma0",
mimd1) # accumulated plastic strain at previous time step
md.add_im_data('invCp0',
mfmult_1 = gf.MeshFem(m_1, N)
#mfmult_2 = gf.MeshFem(m_2, N)
mfmult_p1 = gf.MeshFem(m_p1, N)
mfmult_p2 = gf.MeshFem(m_p2, N)
mfmult_p3 = gf.MeshFem(m_p3, N)
mfmult_1.set_classical_discontinuous_fem(mult_fem_order)
#mfmult_2.set_classical_discontinuous_fem(mult_fem_order)
mfmult_p1.set_classical_discontinuous_fem(mult_fem_order)
mfmult_p2.set_classical_discontinuous_fem(mult_fem_order)
mfmult_p3.set_classical_discontinuous_fem(mult_fem_order)
#mfmult_p1.set_classical_fem(mult_fem_order)
#mfmult_p2.set_classical_fem(mult_fem_order)
#mfmult_p3.set_classical_fem(mult_fem_order)
# Integration methods
mim_1 = gf.MeshIm(m_1, integration_degree)
mim_2 = gf.MeshIm(m_2, integration_degree)
mim_p1 = gf.MeshIm(m_p1, integration_degree)
mim_p2 = gf.MeshIm(m_p2, integration_degree)
mim_p3 = gf.MeshIm(m_p3, integration_degree)
mim_contact_1 = gf.MeshIm(m_1, integration_contact_degree)
mim_contact_2 = gf.MeshIm(m_2, integration_contact_degree)
mim_contact_p1 = gf.MeshIm(m_p1, integration_contact_degree)
mim_contact_p2 = gf.MeshIm(m_p2, integration_contact_degree)
mim_contact_p3 = gf.MeshIm(m_p3, integration_contact_degree)
# Model definition
md = gf.Model('real')
md.add_fem_variable('u_1', mfu_1)
md.add_fem_variable('u_2', mfu_2)
md.add_fem_variable('u_p1', mfu_p1)
pidright = np.compress((abs(pts[0, :] - 1.0) < 1e-7), list(range(0,
m.nbpts())))
fidright = m.faces_from_pid(pidright)
normals = m.normal_of_faces(fidright)
fidright = fidright[:, abs(normals[0, :] - 1.0) < 1e-3]
GAMMAN = 3
m.set_region(GAMMAN, fidright)
#% Definition of the finite element methods
ls = gf.LevelSet(m, ls_degree)
mls = gf.MeshLevelSet(m)
mls.add(ls)
mf_ls = ls.mf()
if N == 2:
mimls = gf.MeshIm(m, gf.Integ('IM_TRIANGLE(4)'))
else:
mimls = gf.MeshIm(m, gf.Integ('IM_TETRAHEDRON(5)'))
mf_basic = gf.MeshFem(m, N)
mf_basic.set_fem(gf.Fem(f'FEM_PK({N},{k})'))
mf_g = gf.MeshFem(m, 1)
mf_g.set_fem(gf.Fem(f'FEM_PK_DISCONTINUOUS({N},{k-1})'))
mf_cont = gf.MeshFem(m, 1)
mf_cont.set_fem(gf.Fem(f'FEM_PK({N},{ls_degree})'))
print(f'There is {mf_basic.nbdof()} elasticity dofs')
Mcont = gf.asm_mass_matrix(mimls, mf_cont)
mfu.set_fem(
gf.Fem('FEM_HHO(FEM_SIMPLEX_IPK(%d,2),FEM_SIMPLEX_CIPK(%d,2))' %
(N, N - 1)))
mfur.set_fem(gf.Fem('FEM_PK(%d,3)' % N))
else:
mfu.set_fem(gf.Fem('FEM_PK(%d,2)' % N))
mfur.set_fem(gf.Fem('FEM_PK(%d,2)' % N))
mfgu.set_fem(gf.Fem('FEM_PK(%d,2)' % N))
mfrhs.set_fem(gf.Fem('FEM_PK(%d,2)' % N))
print('nbdof : %d' % mfu.nbdof())
# Integration method used
if (N == 2):
mim = gf.MeshIm(m, gf.Integ('IM_TRIANGLE(4)'))
else:
mim = gf.MeshIm(m, gf.Integ('IM_TETRAHEDRON(5)'))
# Boundary selection
flst = m.outer_faces()
fnor = m.normal_of_faces(flst)
tleft = abs(fnor[1, :] + 1) < 1e-14
ttop = abs(fnor[0, :] - 1) < 1e-14
fleft = np.compress(tleft, flst, axis=1)
ftop = np.compress(ttop, flst, axis=1)
fneum = np.compress(np.logical_not(ttop + tleft), flst, axis=1)
# Mark it as boundary
DIRICHLET_BOUNDARY_NUM1 = 1
DIRICHLET_BOUNDARY_NUM2 = 2
normals = m.normal_of_faces(border)
contact_boundary = border[:, np.nonzero(normals[0] < -0.01)[0]]
m.set_region(GAMMAC, contact_boundary)
contact_boundary = border[:, np.nonzero(normals[0] > 0.01)[0]]
m.set_region(GAMMAD, contact_boundary)
# Finite element methods
mfu = gf.MeshFem(m)
mfu.set_classical_fem(
u_degree) # Assumed to be a Lagrange FEM in the following
mfd = gf.MeshFem(m, 1)
mfd.set_classical_fem(u_degree)
# Integration method
mim = gf.MeshIm(m, 4)
# GetFEM model
md = gf.Model('real')
md.add_fem_variable('u', mfu)
md.add_fem_data('v', mfu)
md.add_initialized_data('t_N', theta_N)
md.add_initialized_data('g_N', gamma0_N / h)
# Initial conditions
U0 = mfu.eval('0.5-0.5*x') # Initial displacement
Um1 = np.copy(U0) # U_{-1} for Paoli-Schatzman scheme
Ndof = U0.size
V0 = np.zeros(Ndof) # Initial velocity
s0 = 0. # Initial stress
md.set_variable('u', U0)
# coding: utf-8
import getfem as gf
import numpy as np
m = gf.Mesh('cartesian', np.arange(0.0, 10.0, 1.0))
print m
mfu = gf.MeshFem(m,1)
mfu.set_fem(gf.Fem('FEM_PK(1,1)'))
mim = gf.MeshIm(m, gf.Integ('IM_GAUSS1D(1)'))
mfd = gf.MeshFem(m, 1)
mfd.set_fem(gf.Fem('FEM_PK(1,1)'))
nbd = mfd.nbdof()
Lambda = 1.0; Mu = 1.0
K = gf.asm_linear_elasticity(mim, mfu, mfd, np.repeat([Lambda], nbd), np.repeat([Mu], nbd))
K.full()
print 'Lambda = ', Lambda
print 'Mu = ', Mu
print K.full()
print '2*Mu+Lambda = ', 2*Mu+Lambda
