def build_from_mesh(self, m, **args):
dim = m.dim()
if (dim == 2):
self.sl = getfem.Slice(('none', ), m, self.nrefine)
elif (dim == 3):
self.sl = getfem.Slice(('boundary', ), m, self.nrefine)
else:
raise Exception('%d-D Meshes are not supported' % (dim, ))
self.build_from_slice(self.sl, **args)
print "U0.shape: ", U0.shape
Nt = gf.Spmat('copy', N)
Nt.transpose()
KK = Nt * K * N
FF = Nt * F # FF = Nt*(F-K*U0)
# solve ...
P = gf.Precond('ildlt', KK)
UU = gf.linsolve_cg(KK, FF, P)
print "UU.shape:", UU.shape
U = N * UU + U0
print "U.shape:", U.shape
# post-processing
sl = gf.Slice(('boundary', ), mfu, degree)
# compute the Von Mises Stress
DU = gf.compute_gradient(mfu, U, mfe)
VM = np.zeros((DU.shape[2], ), 'd')
Sigma = DU
for i in range(DU.shape[2]):
d = np.array(DU[:, :, i])
E = (d + d.T) * 0.5
Sigma[:, :, i] = E
VM[i] = np.sum(E**2) - (1. / 3.) * np.sum(np.diagonal(E))**2
print 'Von Mises range: ', VM.min(), VM.max()
# export results to VTK (you can use http://mayavi.sourceforge.net/ to view these results )
])
])
m0.add_convex(gf.GeoTrans('GT_PRISM_INCOMPLETE_P2'),
[[1, .5, 0, .5, 0, 0, 1, 0, 0, 1, .5, 0, .5, 0, 0],
[0, 1, 2, 0, 1, 0, 0, 2, 0, 0, 1, 2, 0, 1, 0],
[2, 2, 2, 2, 2, 2, 3.5, 3.5, 3.5, 4, 4, 4, 4, 4, 4]])
m1 = gf.Mesh('cartesian', [0, 1, 2, 3], [0, 1, 2], [-3, -2])
mf0 = gf.MeshFem(m0)
mf0.set_classical_fem(1)
mf1 = gf.MeshFem(m1)
mf1.set_classical_fem(1)
sl = gf.Slice(('boundary', ), m0, 6)
U = np.random.standard_normal(mf0.nbdof())
# VTK:
m0.export_to_vtk('check_export0.vtk', 'quality')
m1.export_to_vtk('check_export1.vtk', 'quality')
mf0.export_to_vtk('check_export2.vtk', 'ascii')
mf1.export_to_vtk('check_export3.vtk', 'ascii')
# DX:
try:
m0.export_to_dx('check_export0.dx')
except RuntimeError as detail:
print(detail)
m1.export_to_dx('check_export0.dx', 'ascii', 'edges')
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
#
############################################################################
import getfem
from numpy import *
mfu = getfem.MeshFem('load', 'tank_3D.mfu')
m = mfu.linked_mesh()
mfp = getfem.MeshFem('load', 'tank_3D.mfp', m)
U = fromfile('tank_3D.U', 'd')
P = fromfile('tank_3D.P', 'd')
sl = getfem.Slice(
('boundary', ('intersection', ('planar', +1, [0, 0, 0], [0, 1, 0]),
('planar', +1, [0, 0, 0], [1, 0, 0]))), m, 3)
print "importing tvtk.."
import getfem_tvtk
print "import done"
fig = getfem_tvtk.Figure(gui='tvtk')
fig.show(sl, data=(mfp, P), vdata=(mfu, U), edges=False)
fig.show(sl, data=(mfp, P), edges=False)
old = fig.scalar_range()
sl = getfem.Slice(
file_name = "check_meshfem_ascii.vtu"
mfu.export_to_vtu(file_name, "ascii", U1, "U1")
unstructured_grid = pv.read(file_name)
expected = U1
actual = unstructured_grid.point_arrays["U1"]
np.testing.assert_equal(expected, actual, "export of U1 is not correct.")
file_name = "check_meshfem_binary.vtu"
mfu.export_to_vtu(file_name, U1, "U1")
unstructured_grid = pv.read(file_name)
expected = U1
actual = unstructured_grid.point_arrays["U1"]
np.testing.assert_equal(expected, actual, "export of U1 is not correct.")
sl = gf.Slice(("boundary", ), mesh, 1)
U2 = np.array([3.0, 2.0, 1.0, 0.0])
file_name = "check_slice_ascii.vtk"
sl.export_to_vtk(file_name, "ascii", U2, "U2")
unstructured_grid = pv.read(file_name)
expected = U2
actual = unstructured_grid.point_arrays["U2"]
np.testing.assert_equal(expected, actual, "export of U2 is not correct.")
file_name = "check_slice_binary.vtk"
sl.export_to_vtk(file_name, U2, "U2")
unstructured_grid = pv.read(file_name)
expected = U2
actual = unstructured_grid.point_arrays["U2"]
np.testing.assert_equal(expected, actual, "export of U2 is not correct.")
print("Iteration %d done" % step)
if (test_tangent_matrix):
md.test_tangent_matrix(1E-8, 10, 0.0001)
U = md.variable('u')
VM0 = md.compute_Von_Mises_or_Tresca('u', lawname, 'params', mfdu)
# Direct interpolation of the Von Mises stress
# VM = md.interpolation('(sqrt(3/2)/Det(Id(meshdim)+Grad_u))*Norm((Id(meshdim)+Grad_u)*Saint_Venant_Kirchhoff_PK2(Grad_u,params)*(Id(meshdim)+Grad_u'') - Id(meshdim)*Trace((Id(meshdim)+Grad_u)*Saint_Venant_Kirchhoff_PK2(Grad_u,params)*(Id(meshdim)+Grad_u''))/meshdim)', mfdu);
VM = md.compute_finite_strain_elasticity_Von_Mises(lawname, 'u', 'params', mfdu)
print(npla.norm(VM-VM0))
sl=gf.Slice(('boundary',), mfu, 4)
sl.export_to_vtk('demo_nonlinear_elasticity_iter_%d.vtk' % step, 'ascii',
mfdu, VM, 'Von Mises Stress', mfu, U, 'Displacement')
print('You can vizualize the loading steps by launching for instance')
print('mayavi2 -d demo_nonlinear_elasticity_iter_1.vtk -f WarpVector -m Surface')
k = 1
# time loop
while (s.hasNextEvent()):
s.computeOneStep()
name = 'bounce' + str(k) + '.vtk'
dataPlot[k, 0] = s.nextTime()
dataPlot[k, 1] = block.q()[2]
dataPlot[k, 2] = block.velocity()[2]
# Post proc for paraview
md.to_variables(block.q())
VM = md.compute_isotropic_linearized_Von_Mises_or_Tresca(
'u', 'lambda', 'mu', mff)
#U = fem_model.variable('u')
sl = gf.Slice(('boundary', ), sico.mfu, 1)
sl.export_to_vtk(name, sico.mfu, block.q(), 'Displacement', mff, VM,
'Von Mises Stress')
#print s.nextTime()
k += 1
s.nextStep()
#subplot(211)
#title('position')
#plot(dataPlot[:,0], dataPlot[:,1])
#grid()
#subplot(212)
#title('velocity')
#plot(dataPlot[:,0], dataPlot[:,2])
#grid()
if f_coeff > 1e-10:
md.set_variable('wR', md.variable('uR'))
md.set_variable('wB', md.variable('uB'))
starttime = time.clock()
md.solve('noisy', 'max_iter', 40, 'max_res', 1e-8, #)[0]
'lsearch', 'simplest', 'alpha max ratio', 1.5, 'alpha min', 0.2, 'alpha mult', 0.6)[0]
print('solution time for iteration %i is %f sec' % (nit, time.clock()-starttime))
U_R = md.variable('uR')
VM_R = md.compute_Von_Mises_or_Tresca('uR', lawname, 'params_ring1', mfvm_R)
mfvm_R.export_to_vtk('lsc_R_%i.vtk' % nit, mfvm_R, VM_R,
'Von Mises Stresses', mfu_R, U_R, 'Displacements')
lambda_R = md.variable('lambda_ring')
mf_lambda_R = md.mesh_fem_of_variable('lambda_ring')
sl = gf.Slice(('boundary',), mf_lambda_R, CONTACT_BOUNDARY_R)
sl.export_to_vtk('lsc_R_boundary_%i.vtk' % nit,
mfu_R, U_R, 'BDisplacements',
mf_lambda_R, lambda_R, 'BMultiplier')
U_B = md.variable('uB')
VM_B = md.compute_Von_Mises_or_Tresca('uB', lawname, 'params_block', mfvm_B)
mfvm_B.export_to_vtk('lsc_B_%i.vtk' % nit, mfvm_B, VM_B,
'Von Mises Stresses', mfu_B, U_B, 'Displacements')
sl = gf.Slice(('boundary',), mfu_B, CONTACT_BOUNDARY_B)
sl.export_to_vtk('lsc_B_boundary_%i.vtk' % nit,
mfu_B, U_B, 'BDisplacements')
md.add_fem_variable('theta', mfth)
md.add_initialized_data('E', E)
md.add_initialized_data('nu', Nu)
md.add_initialized_data('epsilon', thickness)
md.add_initialized_data('kappa', 5. / 6.)
md.add_Mindlin_Reissner_plate_brick(mim, mim, 'u3', 'theta', 'E', 'nu',
'epsilon', 'kappa', 2)
md.add_initialized_data('VolumicData', f)
md.add_source_term_brick(mim, 'u3', 'VolumicData')
md.add_Dirichlet_condition_with_multipliers(mim, 'u3', mfu3, CLAMPED_BOUNDARY)
md.add_Dirichlet_condition_with_multipliers(mim, 'theta', mfth,
CLAMPED_BOUNDARY)
md.add_Dirichlet_condition_with_multipliers(mim, 'u3', mfu3,
SIMPLE_SUPPORT_BOUNDARY)
print('running solve...')
md.solve()
print('solve done!')
u3 = md.variable('u3')
sl = gf.Slice(('none', ), mfu3, 4)
sl.export_to_vtk('plate.vtk', mfu3, u3, 'Displacement')
sl.export_to_pos('plate.pos', mfu3, u3, 'Displacement')
print('You can view the solution with (for example):')
print('mayavi2 -d plate.vtk -f WarpScalar -m Surface')
print('or')
print('gmsh plate.pos')
cm = mls.cut_mesh()
ctip = mls.crack_tip_convexes()
mf = gf.MeshFem(m)
mf.set_classical_fem(1)
mfls = gf.MeshFem('levelset',mls,mf)
gf.memstats()
nbd = mfls.nbdof()
if True:
sl = gf.Slice(('none',), mls, 2);
U = rand(1,nbd);
sl.export_to_pos('slU.pos',mfls,U,'U')
mfls.export_to_pos('U.pos',U,'U')
cm.export_to_pos('cm.pos')
m.export_to_pos('m.pos')
else:
sl = gf.Slice(('none',), mls, 1);
for i in range(nbd):
U = np.zeros(nbd)
U[i] = 1
sl.export_to_pos('slU'+str(i)+'.pos',mfls,U,'U'+str(i))
mfls.export_to_pos('U'+str(i)+'.pos',U,'U'+str(i))
cm.export_to_pos('cm.pos')
m.export_to_pos('m.pos')
print("SOLVING LOAD STEP %i" % nit)
md.solve("noisy", "max_iter", max_iter, "max_res",
max_res) # , "lsearch", "simplest")
U1 = md.variable("u1")
if nonlinear_elasticity:
VM1 = md.compute_Von_Mises_or_Tresca("u1", lawname, "params1", mfvm1)
else:
VM1 = md.compute_isotropic_linearized_Von_Mises_or_Tresca(
"u1", "clambda1", "cmu1", mfvm1)
mfvm1.export_to_vtk("lsc_1_%i.vtk" % nit, mfvm1, VM1,
"Von Mises Stresses 1", mfu1, U1, "Displacements 1")
lambda1 = md.variable("lambda1")
mf_lambda1 = md.mesh_fem_of_variable("lambda1")
sl = gf.Slice(("boundary", ), mf_lambda1, CONTACT_BOUNDARY1)
sl.export_to_vtk("lsc_1_boundary_%i.vtk" % nit, mfu1, U1,
"BDisplacements 1", mf_lambda1, lambda1, "BMultiplier 1")
if test_case not in [0, 3]:
U2 = md.variable("u2")
if nonlinear_elasticity:
VM2 = md.compute_Von_Mises_or_Tresca("u2", lawname, "params2",
mfvm2)
else:
VM2 = md.compute_isotropic_linearized_Von_Mises_or_Tresca(
"u2", "clambda2", "cmu2", mfvm2)
mfvm2.export_to_vtk("lsc_2_%i.vtk" % nit, mfvm2, VM2,
"Von Mises Stresses 2", mfu2, U2,
"Displacements 2")
