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) md.set_variable('v', V0) # Mass and stiffness matrices M = gf.asm_generic(mim, 2, 'u*Test_u', -1, md) if (lump_mass_matrix == 1): assert (u_degree == 1), "Sorry, basic lump only for affine elements" for j in range(0, Ndof): for i in range(1, u_degree + 1): if (j + i < Ndof): M[j, j] += M[j, j + i] M[j, j + i] = 0. if (j - i >= 0): M[j, j] += M[j, j - i] M[j, j - i] = 0. K = gf.asm_generic(mim, 2, 'Grad_u*Grad_Test_u', -1, md) # Dirichlet condition on the top for i in range(0, u_degree + 1): K[Ndof - 1, Ndof - 1 - i] = 0.
md.solve('max_res', 1E-9, 'max_iter', 100, 'noisy', 'lsearch', 'simplest', 'alpha min', 0.8) U = md.variable('u'); mfer = gf.MeshFem(m,1) mfer.set_fem(gf.Fem('FEM_PK(3,{d})'.format(d=0)),listTetra) mfer.set_fem(gf.Fem('FEM_QK(3,{d})'.format(d=0)),listHexa) mfer.set_fem(gf.Fem('FEM_PYRAMID_LAGRANGE({d})'.format(d=0)),listPyramid) mfer.set_fem(gf.Fem('FEM_PK_PRISM(3,{d})'.format(d=0)),listPrism) divsigma = '(lambda_para+ mu_para)*(Hess_u(1,1,:) + Hess_u(2,2,:) + Hess_u(3,3,:) ) + mu_para*(Hess_u:Id( qdim(u) ))' # 1a) interior residual bulkresidual = 'sqr(element_size)*Norm_sqr({divsigma})*Test_psi'.format(divsigma=divsigma) ETA1tmp = gf.asm_generic(mim,1,bulkresidual,-1 ,md ,'psi',True,mfer,np.zeros(mfer.nbdof())) ETA1 = ETA1tmp [ ETA1tmp.size - mfer.nbdof() : ETA1tmp.size ] # 1b) jump at inner faces sig_u = "(lambda_para*Trace(Grad_u)*Id(qdim(u)) + mu_para*(Grad_u + Grad_u'))" grad_u_neighbor = "Interpolate(Grad_u,neighbor_element)" sig_u_neighbor = "(lambda_para*Trace({Grad_u})*Id(qdim(u)) + mu_para*(({Grad_u}) + ({Grad_u})'))".format(Grad_u=grad_u_neighbor) stress_jump_inner = "((({sig_u}) - ({sig_u_neighbor}))*Normal )".format(sig_u=sig_u,sig_u_neighbor=sig_u_neighbor) edgeresidual = "0.5*(element_size*Norm_sqr({stress_jump_inner})*2*0.5*(Test_psi + Interpolate(Test_psi,neighbor_element)))".format(stress_jump_inner=stress_jump_inner) ETA2tmp = gf.asm_generic(mim,1,edgeresidual,INNER_FACES ,md ,'psi',True,mfer,np.zeros(mfer.nbdof()))
IKSI = md.interval_of_variable('ksi') output = (mfu, md.variable('u'), 'Displacements', mfp, md.variable('p'), 'Pressure', mfksi, md.variable('ksi'), 'dksi', mf_dirichlet_mult, -md.variable(dirichlet_multname), "Reaction stresses", mfout, VM, 'Von Mises Stress', mfu, RHS[IU[0]:IU[0] + IU[1]], 'residual u', mfp, RHS[IP[0]:IP[0] + IP[1]], 'residual p', mfksi, RHS[IKSI[0]:IKSI[0] + IKSI[1]], 'residual ksi') md.finite_strain_elastoplasticity_next_iter\ (mim, "Simo_Miehe", "displacement_and_plastic_multiplier_and_pressure", "u", "ksi", "p", "gamma0", "invCp0", _K_, _mu_, "hardening_law") GAMMA = gf.asm_generic(mim, 1, "gamma*Test_t", -1, "gamma", False, mimd1, md.variable("gamma0"), "t", True, mfout, np.zeros(mfout.nbdof())) GAMMA = np.transpose(gf.linsolve_mumps(mass_mat, GAMMA)) output += (mfout, GAMMA, "plastic strain") mf1.export_to_vtk( '%s/finite_strain_plasticity_%i.vtk' % (resultspath, step), 'ascii', *output) DIRMULT = -md.variable(dirichlet_multname) DIRMULT = np.reshape(DIRMULT, [1, DIRMULT.size]) if symmetric and not rigid_grip: dfR = gf.asm_boundary_source(R_BOUNDARY, mim, mf1, mf_dirichlet_mult, DIRMULT) f.write(('step=%i fR=(%f,0) sR=(%f,0)\n') % (step, dfR.sum(), dfR.sum() / H))
if pseudodynamic: if MM < 1e-4: MM = 0. pseudodynamic = False elif nit <= 6: MM /= 2. else: TMP = md.interpolation("max(psi0_max,psi0)", mimd1, -1) md.set_variable("psi0_max", TMP) break out = (mfu, md.variable("u"), "Displacements", mfphi, md.variable("phi"), "phi") for i, j in [[1, 1], [2, 2], [1, 2]]: sigma = gf.asm_generic(mim, 1, "{sigma}({i},{j})*Test_t".format(sigma=_sigma_, i=i, j=j), -1, md, "t", True, mfout, np.zeros(mfout.nbdof()))\ [md.nbdof():] sigma = np.transpose(gf.linsolve_mumps(mass_mat, sigma)) out += (mfout, sigma, "Cauchy Stress {i}{j}".format(i=i, j=j)) mfout.export_to_vtk("%s/demo_phase_field_%i.vtk" % (resultspath, step), *out) DIRMULT = -md.variable(dirmultname) DIRMULT = np.reshape(DIRMULT, [1, DIRMULT.size]) dfT = gf.asm_boundary_source(T_BOUNDARY, mim, mfu, md.mesh_fem_of_variable(dirmultname), DIRMULT) f.write(("step=%i eps=%e fR=(%e,%e)\n") % (step, eps, dfT[0::N].sum(), dfT[1::N].sum())) f.flush()
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") mmat_v = gf.asm_mass_matrix(mim, mfv) #mmat_v = gf.asm_generic(mim, 2, "Test2_v.Test_v", -1, "v", 1, mfv, np.zeros(mfv.nbdof())) IV = md.interval_of_variable("v") t = 0 step = 0 while t < T+1e-8: print("Solving step at t=%f" % t) md.set_variable\ ("p_in", mfp_.eval(p_in_str.format(t), globals(), locals()).flatten("F")) md.set_variable("v0", md.variable("v")) md.solve("noisy", "lsolver", "mumps", "max_res", 1e-8) vv = (gf.asm_generic(mim, 1, "(v-dt*Grad_p).Test_v", -1, md))[IV[0]:IV[0]+IV[1]] md.set_variable("v", gf.linsolve_mumps(mmat_v, vv)) mfv.export_to_vtk("results_%i.vtk" % step, mfv, md.variable("v"), "Velocity", mfp, md.variable("p"), "Pressure") t += dt step += 1
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_generic_assembly_brick\ (mim, "1/dt*(v-v0).Test_v + (Grad_v0*v0).Test_v + nu*Grad_v:Grad_Test_v - f.Test_v") md.add_nonlinear_generic_assembly_brick\ (mim, "Grad_p.Grad_Test_p + 1/dt*Trace(Grad_v)*Test_p") mmat_v = gf.asm_mass_matrix(mim, mfv) #mmat_v = gf.asm_generic(mim, 2, "Test2_v.Test_v", -1, "v", 1, mfv, np.zeros(mfv.nbdof())) IV = md.interval_of_variable("v") IV = range(IV[0], IV[0] + IV[1]) t = 0 step = 0 while t < T + 1e-8: print("Solving step at t=%f" % t) md.set_variable\ ("p_in", mfp_.eval(p_in_str.format(t), globals(), locals()).flatten("F")) md.set_variable("v0", md.variable("v")) md.solve("noisy", "lsolver", "mumps", "max_res", 1e-8) vv = gf.asm_generic(mim, 1, "(v-dt*Grad_p).Test_v", -1, md)[IV] md.set_variable("v", gf.linsolve_mumps(mmat_v, vv)) mfv.export_to_vtk("results_%i.vtk" % step, mfv, md.variable("v"), "Velocity", mfp, md.variable("p"), "Pressure") t += dt step += 1
elast_law = 'SaintVenant Kirchhoff' md.add_initialized_data('elast_params', [Lambda, Mu]) md.add_nonlinear_elasticity_brick(mim_1, 'u_1', elast_law, 'elast_params') md.add_nonlinear_elasticity_brick(mim_2, 'u_2', elast_law, 'elast_params') md.add_nonlinear_elasticity_brick(mim_p1, 'u_p1', elast_law, 'elast_params') md.add_nonlinear_elasticity_brick(mim_p2, 'u_p2', elast_law, 'elast_params') md.add_nonlinear_elasticity_brick(mim_p3, 'u_p3', elast_law, 'elast_params') # Dirichlet BC's F = md.interpolation('[0,0]', mfu_2, RG_DIRICHLET_2) md.add_initialized_fem_data('dirichlet_2', mfu_2, F) md.add_Dirichlet_condition_with_multipliers(mim_2, 'u_2', mfu_2, RG_DIRICHLET_2, 'dirichlet_2') # Load area_1_in = gf.asm_generic(mim_1, 0, "1", RG_NEUMANN_1) m1 = torsion / area_1_in _expr_load_ = "{m}/Norm_sqr(X+u_1)*[-X(2)-u_1(2);X(1)+u_1(1)].Test_u_1".format( m=m1) md.add_nonlinear_generic_assembly_brick(mim_1, _expr_load_, RG_NEUMANN_1) # Add inertia, used temporarily for getting an initial solution md.add_initialized_data('penalty_param', 1e0) #ibin_1 = md.add_mass_brick(mim_1, 'u_1', 'penalty_param') ##ibin_2 = md.add_mass_brick(mim_2, 'u_2', 'penalty_param') #ibin_p1 = md.add_mass_brick(mim_p1, 'u_p1', 'penalty_param') #ibin_p2 = md.add_mass_brick(mim_p2, 'u_p2', 'penalty_param') #ibin_p3 = md.add_mass_brick(mim_p3, 'u_p3', 'penalty_param') ibin_1 = md.add_linear_generic_assembly_brick(mim_1, 'penalty_param*u_1.Test_u_1')
print("Dirichlet mult dofs: %i" % md.mesh_fem_of_variable("dirmult").nbdof()) shutil.copyfile(os.path.abspath(sys.argv[0]),resultspath+"/"+sys.argv[0]) starttime_overall = time.process_time() with open("%s/tension_3D.dat" % resultspath, "w") as f1: for step in range(steps_t+1): md.set_variable("disp", disp*step/float(steps_t)) print('STEP %i: Solving with disp = %g' % (step, md.variable("disp"))) starttime = time.process_time() md.solve('noisy', 'max_iter', 25, 'max_res', 1e-10, 'lsearch', 'simplest', 'alpha max ratio', 100, 'alpha min', 0.2, 'alpha mult', 0.6, 'alpha threshold res', 1e9) print('STEP %i COMPLETED IN %f SEC' % (step, time.process_time()-starttime)) F = gf.asm_generic(mim, 0, "dirmult", XP_RG, md) print("Displacement %g, total force %g" % (md.variable("disp"), F)) A = gf.asm_generic(mim, 0, "Norm(J*Inv(F')*[1;0;0])", XP_RG, md) V = gf.asm_generic(mim, 0, "1", -1, md) sigma11 = gf.asm_generic(mim, 0, "sigma(1,1)", -1, md)/V gamma = gf.asm_generic(mim, 0, "gamma", -1, md)/V f1.write("%.10g %.10g %.10g %.10g %10g %10g\n" % (md.variable("disp"), F, A, F/A, sigma11, gamma)) f1.flush() output = (mfout1, md.local_projection(mim, "sqrt(1.5)*Norm(sigmaD)", mfout1), "Von Mises Stress", mfout1, md.local_projection(mim, "J", mfout1), "J", mfout1, md.local_projection(mim, "sigma(1,1)", mfout1), "Cauchy stress 11", mfout1, md.local_projection(mim, "sigma(2,2)", mfout1), "Cauchy stress 22", mfout1, md.local_projection(mim, "sigma(1,2)", mfout1), "Cauchy stress 12",