def extrapolate_setup(extype, mesh_file, d, w, phi, dx_f, d_, **semimp_namespace): alpha = 1. / det(Identity(len(d_["n"])) + grad(d_["n"])) F_extrapolate = alpha*inner(grad(d), grad(phi))*dx_f \ - inner(Constant((0, 0)), phi)*dx_f return dict(F_extrapolate=F_extrapolate)
def updateG(self, dt): """ Update the G tensor of a tissue. Args: dt (:obj:`float`): Timestep """ self.tissue.G.project( (self.initial * dt + Identity(3)) * self.tissue.G)
def compute(self, get): u = get("Velocity") p = get("Pressure") mu = get("DynamicViscosity") if isinstance(mu, (float, int)): mu = Constant(mu) expr = mu * (grad(u) + grad(u).T) - p * Identity(len(u)) return self.expr2function(expr, self._function)
def projectAGG(self, a=Constant(0.0), g=Constant(0.0), gamma=Constant([0, 0, 1])): """ Calculate and project growth function from given :math:`a`, :math:`g` and :math:`\gamma` values """ self.a.project(a) self.g.project(g) self.gamma.project(gamma / sqrt(inner(gamma, gamma))) g0 = g * (1 - a) g1 = g * (1 + 2 * a) self.project(Identity(3) * g0 + (g1 - g0) * outer(gamma, gamma))
def __init__(self, u): '''Deformation measures.''' self.d = d = len(u) self.I = I = Identity(d) self.F = F = variable(I + grad(u)) self.C = C = F.T * F self.E = 0.5 * (C - I) self.J = det(F) self.I1 = tr(C) self.I2 = 0.5 * (tr(C)**2 - tr(C * C)) self.I3 = det(C)
def set_model(self): measures = [self.dx, self.ds, self.dS] # import pdb; pdb.set_trace() if self.parameters['material']['p'] == 'zero': from plate_lib import ActuationOverNematicFoundation actuation = ActuationOverNematicFoundation(self.z, self.mesh, self.parameters, measures) elif self.parameters['material']['p'] == 'neg': from plate_lib import ActuationOverNematicFoundationPneg actuation = ActuationOverNematicFoundationPneg( self.z, self.mesh, self.parameters, measures) else: raise NotImplementedError x = Expression(['x[0]', 'x[1]', '0.'], degree=0) self.load = Expression('s', s=1., degree=0) e1 = Constant([1, 0, 0]) e3 = Constant([0, 0, 1]) # self.n = Expression('sin(theta)*_e1 + cos(theta)*_e3', # _e1 = e1, _e3 = e3, theta = 0., degree = 0) self.n = Expression(['sin(theta)', 0, 'cos(theta)'], theta=0, degree=0) # import pdb; pdb.set_trace() # print('Nematic: {}'.format(self.parameters["material"]["nematic"])) if self.parameters["material"]["nematic"] == 'e1': n = e1 elif self.parameters["material"]["nematic"] == 'e3': n = e3 elif self.parameters["material"]["nematic"] == 'tilt': n = (e1 - e3) / np.sqrt(2) else: raise NotImplementedError Qn = outer(self.n, self.n) - 1. / 3. * Identity(3) actuation.Q0n = self.load * Qn self.Q0 = actuation.Q0n actuation.define_variational_equation() self.F = actuation.F self.J = actuation.jacobian self.energy_mem = actuation.energy_mem self.energy_ben = actuation.energy_ben self.energy_nem = actuation.energy_nem self.work = actuation.work
def les_setup(u_, mesh, Wale, bcs, CG1Function, nut_krylov_solver, **NS_namespace): """Set up for solving Wale LES model """ DG = FunctionSpace(mesh, "DG", 0) CG1 = FunctionSpace(mesh, "CG", 1) # Compute cell size and put in delta delta = Function(DG) delta.vector().zero() delta.vector().axpy(1.0, assemble(TestFunction(DG)*dx)) # Set up Wale form Gij = grad(u_) Sij = sym(Gij) Skk = tr(Sij) dim = mesh.geometry().dim() Sd = sym(Gij*Gij) - 1./3.*Identity(mesh.geometry().dim())*Skk*Skk nut_form = Wale['Cw']**2 * pow(delta, 2./dim) * pow(inner(Sd, Sd), 1.5) / (Max(pow(inner(Sij, Sij), 2.5) + pow(inner(Sd, Sd), 1.25), 1e-6)) ff = FacetFunction("size_t", mesh, 0) bcs_nut = derived_bcs(CG1, bcs['u0'], u_) nut_ = CG1Function(nut_form, mesh, method=nut_krylov_solver, bcs=bcs_nut, name='nut', bounded=True) return dict(Sij=Sij, Sd=Sd, Skk=Skk, nut_=nut_, delta=delta, bcs_nut=bcs_nut)
def __init__(self, mesh0=UnitCubeMesh(8, 8, 8), params={}): parameters['form_compiler']['representation'] = 'uflacs' parameters['form_compiler']['optimize'] = True parameters['form_compiler']['quadrature_degree'] = 4 self.mesh0 = Mesh(mesh0) self.mesh = Mesh(mesh0) if not 'C1' in params: params['C1'] = 100 self.params = params self.b = Constant((0.0, 0.0, 0.0)) self.h = Constant((0.0, 0.0, 0.0)) self.C0 = FunctionSpace(self.mesh0, "Lagrange", 2) self.V0 = VectorFunctionSpace(self.mesh0, "Lagrange", 1) self.W0 = TensorFunctionSpace(self.mesh0, "Lagrange", 1) self.C = FunctionSpace(self.mesh, "Lagrange", 2) self.V = VectorFunctionSpace(self.mesh, "Lagrange", 1) self.W = TensorFunctionSpace(self.mesh, "Lagrange", 1) self.G = project(Identity(3), self.W0) self.ut = Function(self.V0) self.du = TestFunction(self.V0) self.w = TrialFunction(self.V0) self.n0 = FacetNormal(self.mesh0) self.v = Function(self.V) self.t = 0.0
def initialize_with_field(self, u): super().initialize_with_field(u) I = Identity(len(u)) eps = sym(grad(u)) for m in self.material_parameters: E = m.get('E', None) nu = m.get('nu', None) mu = m.get('mu', None) lm = m.get('lm', None) if mu is None: if E is None or nu is None: raise RuntimeError( 'Material model requires parameter "mu"; ' 'otherwise, require parameters "E" and "nu".') mu = E / (2 * (1 + nu)) if lm is None: if E is None or nu is None: raise RuntimeError( 'Material model requires parameter "lm"; ' 'otherwise, require parameters "E" and "nu".') lm = E * nu / ((1 + nu) * (1 - 2 * nu)) sig = 2 * mu * eps + lm * tr(eps) * I psi = 0.5 * inner(sig, eps) self.psi.append(psi) self.pk1.append(sig) self.pk2.append(sig)
def sigma(u): return lambda_ * div(u) * Identity(d) + 2 * mu * epsilon(u)
def initialization(mesh, subdomains, boundaries): TM = TensorFunctionSpace(mesh, 'DG', 0) PM = FunctionSpace(mesh, 'DG', 0) UCG = VectorElement("CG", mesh.ufl_cell(), 2) BDM = FiniteElement("BDM", mesh.ufl_cell(), 1) PDG = FiniteElement("DG", mesh.ufl_cell(), 0) UCG_F = FunctionSpace(mesh, UCG) BDM_F = FunctionSpace(mesh, BDM) PDG_F = FunctionSpace(mesh, PDG) W = BlockFunctionSpace([BDM_F, PDG_F], restrict=[None, None]) U = BlockFunctionSpace([UCG_F]) I = Identity(mesh.topology().dim()) C_cg = FiniteElement("CG", mesh.ufl_cell(), 1) C_dg = FiniteElement("DG", mesh.ufl_cell(), 0) mini = C_cg + C_dg C = FunctionSpace(mesh, mini) C = BlockFunctionSpace([C]) #TODO solution0_h = BlockFunction(W) solution0_m = BlockFunction(U) solution0_c = BlockFunction(C) solution1_h = BlockFunction(W) solution1_m = BlockFunction(U) solution1_c = BlockFunction(C) solution2_h = BlockFunction(W) solution2_m = BlockFunction(U) solution2_c = BlockFunction(C) solution_h = BlockFunction(W) solution_m = BlockFunction(U) solution_c = BlockFunction(C) ## mechanics # 0 properties alpha1 = 0.74 K1 = 8.4 * 1000.e6 nu1 = 0.18 alpha2 = 0.74 K2 = 8.4 * 1000.e6 nu2 = 0.18 alpha_values = [alpha1, alpha2] K_values = [K1, K2] nu_values = [nu1, nu2] alpha_0 = Function(PM) K_0 = Function(PM) nu_0 = Function(PM) alpha_0 = init_scalar_parameter(alpha_0, alpha_values[0], 500, subdomains) K_0 = init_scalar_parameter(K_0, K_values[0], 500, subdomains) nu_0 = init_scalar_parameter(nu_0, nu_values[0], 500, subdomains) alpha_0 = init_scalar_parameter(alpha_0, alpha_values[1], 501, subdomains) K_0 = init_scalar_parameter(K_0, K_values[1], 501, subdomains) nu_0 = init_scalar_parameter(nu_0, nu_values[1], 501, subdomains) K_mult_min = 1.0 K_mult_max = 1.0 mu_l_0, lmbda_l_0, Ks_0, K_0 = \ bulk_modulus_update(mesh,solution0_c[0],K_mult_min,K_mult_max,K_0,nu_0,alpha_0,K_0) # n-1 properties alpha1 = 0.74 K1 = 8.4 * 1000.e6 nu1 = 0.18 alpha2 = 0.74 K2 = 8.4 * 1000.e6 nu2 = 0.18 alpha_values = [alpha1, alpha2] K_values = [K1, K2] nu_values = [nu1, nu2] alpha_1 = Function(PM) K_1 = Function(PM) nu_1 = Function(PM) alpha_1 = init_scalar_parameter(alpha_1, alpha_values[0], 500, subdomains) K_1 = init_scalar_parameter(K_1, K_values[0], 500, subdomains) nu_1 = init_scalar_parameter(nu_1, nu_values[0], 500, subdomains) alpha_1 = init_scalar_parameter(alpha_1, alpha_values[1], 501, subdomains) K_1 = init_scalar_parameter(K_1, K_values[1], 501, subdomains) nu_1 = init_scalar_parameter(nu_1, nu_values[1], 501, subdomains) K_mult_min = 1.0 K_mult_max = 1.0 mu_l_1, lmbda_l_1, Ks_1, K_1 = \ bulk_modulus_update(mesh,solution0_c[0],K_mult_min,K_mult_max,K_1,nu_1,alpha_1,K_0) # n properties alpha1 = 0.74 K2 = 8.4 * 1000.e6 nu1 = 0.18 alpha2 = 0.74 K2 = 8.4 * 1000.e6 nu2 = 0.18 alpha_values = [alpha1, alpha2] K_values = [K1, K2] nu_values = [nu1, nu2] alpha = Function(PM) K = Function(PM) nu = Function(PM) alpha = init_scalar_parameter(alpha, alpha_values[0], 500, subdomains) K = init_scalar_parameter(K, K_values[0], 500, subdomains) nu = init_scalar_parameter(nu, nu_values[0], 500, subdomains) alpha = init_scalar_parameter(alpha, alpha_values[1], 501, subdomains) K = init_scalar_parameter(K, K_values[1], 501, subdomains) nu = init_scalar_parameter(nu, nu_values[1], 501, subdomains) K_mult_min = 1.0 K_mult_max = 1.0 mu_l, lmbda_l, Ks, K = \ bulk_modulus_update(mesh,solution0_c[0],K_mult_min,K_mult_max,K,nu,alpha,K_0) ## flow # 0 properties cf1 = 1e-10 phi1 = 0.2 rho1 = 1000.0 mu1 = 1. kx = 8.802589710965712e-10 ky = 8.802589710965712e-11 k1 = np.array([kx, 0., 0., ky]) cf2 = 1e-10 phi2 = 0.2 rho2 = 1000.0 mu2 = 1. kx = 8.802589710965712e-10 ky = 8.802589710965712e-11 k2 = np.array([kx, 0., 0., ky]) cf_values = [cf1, cf2] phi_values = [phi1, phi2] rho_values = [rho1, rho2] mu_values = [mu1, mu2] k_values = [k1, k2] cf_0 = Function(PM) phi_0 = Function(PM) rho_0 = Function(PM) mu_0 = Function(PM) k_0 = Function(TM) cf_0 = init_scalar_parameter(cf_0, cf_values[0], 500, subdomains) phi_0 = init_scalar_parameter(phi_0, phi_values[0], 500, subdomains) rho_0 = init_scalar_parameter(rho_0, rho_values[0], 500, subdomains) mu_0 = init_scalar_parameter(mu_0, mu_values[0], 500, subdomains) k_0 = init_tensor_parameter(k_0, k_values[0], 500, subdomains, mesh.topology().dim()) cf_0 = init_scalar_parameter(cf_0, cf_values[1], 501, subdomains) phi_0 = init_scalar_parameter(phi_0, phi_values[1], 501, subdomains) rho_0 = init_scalar_parameter(rho_0, rho_values[1], 501, subdomains) mu_0 = init_scalar_parameter(mu_0, mu_values[1], 501, subdomains) k_0 = init_tensor_parameter(k_0, k_values[1], 501, subdomains, mesh.topology().dim()) #filename = "perm4.csv" #k_0 = init_from_file_parameter(k_0,0.,0.,filename) # n-1 properties cf1 = 1e-10 phi1 = 0.2 rho1 = 1000.0 mu1 = 1. kx = 8.802589710965712e-10 ky = 8.802589710965712e-11 k1 = np.array([kx, 0., 0., ky]) cf2 = 1e-10 phi2 = 0.2 rho2 = 1000.0 mu2 = 1. kx = 8.802589710965712e-10 ky = 8.802589710965712e-11 k2 = np.array([kx, 0., 0., ky]) cf_values = [cf1, cf2] phi_values = [phi1, phi2] rho_values = [rho1, rho2] mu_values = [mu1, mu2] k_values = [k1, k2] cf_1 = Function(PM) phi_1 = Function(PM) rho_1 = Function(PM) mu_1 = Function(PM) k_1 = Function(TM) cf_1 = init_scalar_parameter(cf_1, cf_values[0], 500, subdomains) phi_1 = init_scalar_parameter(phi_1, phi_values[0], 500, subdomains) rho_1 = init_scalar_parameter(rho_1, rho_values[0], 500, subdomains) mu_1 = init_scalar_parameter(mu_1, mu_values[0], 500, subdomains) k_1 = init_tensor_parameter(k_1, k_values[0], 500, subdomains, mesh.topology().dim()) cf_1 = init_scalar_parameter(cf_1, cf_values[1], 501, subdomains) phi_1 = init_scalar_parameter(phi_1, phi_values[1], 501, subdomains) rho_1 = init_scalar_parameter(rho_1, rho_values[1], 501, subdomains) mu_1 = init_scalar_parameter(mu_1, mu_values[1], 501, subdomains) k_1 = init_tensor_parameter(k_1, k_values[1], 501, subdomains, mesh.topology().dim()) #filename = "perm4.csv" #k_1 = init_from_file_parameter(k_1,0.,0.,filename) # n properties cf1 = 1e-10 phi1 = 0.2 rho1 = 1000.0 mu1 = 1. kx = 8.802589710965712e-10 ky = 8.802589710965712e-11 k1 = np.array([kx, 0., 0., ky]) cf2 = 1e-10 phi2 = 0.2 rho2 = 1000.0 mu2 = 1. kx = 8.802589710965712e-10 ky = 8.802589710965712e-11 k2 = np.array([kx, 0., 0., ky]) cf_values = [cf1, cf2] phi_values = [phi1, phi2] rho_values = [rho1, rho2] mu_values = [mu1, mu2] k_values = [k1, k2] cf = Function(PM) phi = Function(PM) rho = Function(PM) mu = Function(PM) k = Function(TM) cf = init_scalar_parameter(cf, cf_values[0], 500, subdomains) phi = init_scalar_parameter(phi, phi_values[0], 500, subdomains) rho = init_scalar_parameter(rho, rho_values[0], 500, subdomains) mu = init_scalar_parameter(mu, mu_values[0], 500, subdomains) k = init_tensor_parameter(k, k_values[0], 500, subdomains, mesh.topology().dim()) cf = init_scalar_parameter(cf, cf_values[1], 501, subdomains) phi = init_scalar_parameter(phi, phi_values[1], 501, subdomains) rho = init_scalar_parameter(rho, rho_values[1], 501, subdomains) mu = init_scalar_parameter(mu, mu_values[1], 501, subdomains) k = init_tensor_parameter(k, k_values[1], 501, subdomains, mesh.topology().dim()) #filename = "perm4.csv" #k = init_from_file_parameter(k,0.,0.,filename) ### transport # 0 dx1 = 1e-12 dy1 = 1e-12 d1 = np.array([dx1, 0., 0., dy1]) dx2 = 1e-12 dy2 = 1e-12 d2 = np.array([dx2, 0., 0., dy2]) d_values = [d1, d2] d_0 = Function(TM) d_0 = init_tensor_parameter(d_0, d_values[0], 500, subdomains, mesh.topology().dim()) d_0 = init_tensor_parameter(d_0, d_values[1], 501, subdomains, mesh.topology().dim()) # n-1 dx1 = 1e-12 dy1 = 1e-12 d1 = np.array([dx1, 0., 0., dy1]) dx2 = 1e-12 dy2 = 1e-12 d2 = np.array([dx2, 0., 0., dy2]) d_values = [d1, d2] d_1 = Function(TM) d_1 = init_tensor_parameter(d_1, d_values[0], 500, subdomains, mesh.topology().dim()) d_1 = init_tensor_parameter(d_1, d_values[1], 501, subdomains, mesh.topology().dim()) # n dx1 = 1e-12 dy1 = 1e-12 d1 = np.array([dx1, 0., 0., dy1]) dx2 = 1e-12 dy2 = 1e-12 d2 = np.array([dx2, 0., 0., dy2]) d_values = [d1, d2] d = Function(TM) d = init_tensor_parameter(d, d_values[0], 500, subdomains, mesh.topology().dim()) d = init_tensor_parameter(d, d_values[1], 501, subdomains, mesh.topology().dim()) ####initialization # initial u_0 = Constant((0.0, 0.0)) u_0_project = project(u_0, U[0]) assign(solution0_m.sub(0), u_0_project) p_0 = Constant(1.e6) p_0_project = project(p_0, W[1]) assign(solution0_h.sub(1), p_0_project) # v_0 = Constant((0.0, 0.0)) # v_0_project = project(v_0, W[0]) # assign(solution0_h.sub(0), v_0_project) c0 = c_sat_cal(1.e6, 20.) c0_project = project(c0, C[0]) assign(solution0_c.sub(0), c0_project) # n - 1 u_0 = Constant((0.0, 0.0)) u_0_project = project(u_0, U[0]) assign(solution1_m.sub(0), u_0_project) p_0 = Constant(1.e6) p_0_project = project(p_0, W[1]) assign(solution1_h.sub(1), p_0_project) # v_0 = Constant((0.0, 0.0)) # v_0_project = project(v_0, W[0]) # assign(solution1_h.sub(0), v_0_project) c0 = c_sat_cal(1.e6, 20.) c0_project = project(c0, C[0]) assign(solution1_c.sub(0), c0_project) # n - 2 u_0 = Constant((0.0, 0.0)) u_0_project = project(u_0, U[0]) assign(solution2_m.sub(0), u_0_project) p_0 = Constant(1.e6) p_0_project = project(p_0, W[1]) assign(solution2_h.sub(1), p_0_project) # v_0 = Constant((0.0, 0.0)) # v_0_project = project(v_0, W[0]) # assign(solution2_h.sub(0), v_0_project) c0 = c_sat_cal(1.e6, 20.) c0_project = project(c0, C[0]) assign(solution2_c.sub(0), c0_project) # n u_0 = Constant((0.0, 0.0)) u_0_project = project(u_0, U[0]) assign(solution_m.sub(0), u_0_project) p_0 = Constant(1.e6) p_0_project = project(p_0, W[1]) assign(solution_h.sub(1), p_0_project) # v_0 = Constant((0.0, 0.0)) # v_0_project = project(v_0, W[0]) # assign(solution_h.sub(0), v_0_project) c0 = c_sat_cal(1.e6, 20.) c0_project = project(c0, C[0]) assign(solution_c.sub(0), c0_project) ###iterative parameters phi_it = Function(PM) assign(phi_it, phi_0) print('c_sat', c_sat_cal(1.0e8, 20.)) c_sat = c_sat_cal(1.0e8, 20.) c_sat = project(c_sat, PM) c_inject = Constant(0.0) c_inject = project(c_inject, PM) mu_c1_1 = 1.e-4 mu_c2_1 = 5.e-0 mu_c1_2 = 1.e-4 mu_c2_2 = 5.e-0 mu_c1_values = [mu_c1_1, mu_c1_2] mu_c2_values = [mu_c2_1, mu_c2_2] mu_c1 = Function(PM) mu_c2 = Function(PM) mu_c1 = init_scalar_parameter(mu_c1, mu_c1_values[0], 500, subdomains) mu_c2 = init_scalar_parameter(mu_c2, mu_c2_values[0], 500, subdomains) mu_c1 = init_scalar_parameter(mu_c1, mu_c1_values[1], 501, subdomains) mu_c2 = init_scalar_parameter(mu_c2, mu_c2_values[1], 501, subdomains) coeff_for_perm_1 = 22.2 coeff_for_perm_2 = 22.2 coeff_for_perm_values = [coeff_for_perm_1, coeff_for_perm_2] coeff_for_perm = Function(PM) coeff_for_perm = init_scalar_parameter(coeff_for_perm, coeff_for_perm_values[0], 500, subdomains) coeff_for_perm = init_scalar_parameter(coeff_for_perm, coeff_for_perm_values[1], 501, subdomains) solutionIt_h = BlockFunction(W) return solution0_m, solution0_h, solution0_c \ ,solution1_m, solution1_h, solution1_c \ ,solution2_m, solution2_h, solution2_c \ ,solution_m, solution_h, solution_c \ ,alpha_0, K_0, mu_l_0, lmbda_l_0, Ks_0 \ ,alpha_1, K_1, mu_l_1, lmbda_l_1, Ks_1 \ ,alpha, K, mu_l, lmbda_l, Ks \ ,cf_0, phi_0, rho_0, mu_0, k_0 \ ,cf_1, phi_1, rho_1, mu_1, k_1 \ ,cf, phi, rho, mu, k \ ,d_0, d_1, d, I \ ,phi_it, solutionIt_h, mu_c1, mu_c2 \ ,nu_0, nu_1, nu, coeff_for_perm \ ,c_sat, c_inject
def STVK(U, alfa_mu, alfa_lam): return alfa_lam * tr(eps(U)) * Identity( len(U)) + 2.0 * alfa_mu * eps(U)
def Extrapolate_setup(d, phi, dx_f, d_, **semimp_namespace): alfa = 1. / det(Identity(len(d_["n"])) + grad(d_["n"])) F_extrapolate = alfa*inner(grad(d), grad(phi))*dx_f - inner(Constant((0, 0)), phi)*dx_f return dict(F_extrapolate=F_extrapolate)
def S(U, lamda_s, mu_s): I = Identity(len(U)) return 2 * mu_s * E(U) + lamda_s * tr(E(U)) * I
def sigma_f(p, u, mu_f): return -p * Identity(len(u)) + mu_f * (grad(u) + grad(u).T)
def sigma(u, p, mu): # Define stress tensor return 2*mu*epsilon(u) - p*Identity(len(u))
def SecondOrderIdentity(F): """Return identity with same dimension as input """ dim = get_dimesion(F) return Identity(dim)
def sigma(v): return 2.0 * mu * sym(grad(v)) + lmbda * tr(sym( grad(v))) * Identity(2)
def sigma_f_p(p, u): return -p * Identity(len(u))
def S(self): C1 = self.params['C1'] return C1 * (self.A() - Identity(3))
def F(self): return Identity(3) + grad(self.u + self.ut)
def m_linear(integrator_type, mesh, subdomains, boundaries, t_start, dt, T, solution0, \ alpha_0, K_0, mu_l_0, lmbda_l_0, Ks_0, \ alpha_1, K_1, mu_l_1, lmbda_l_1, Ks_1, \ alpha, K, mu_l, lmbda_l, Ks, \ cf_0, phi_0, rho_0, mu_0, k_0,\ cf_1, phi_1, rho_1, mu_1, k_1,\ cf, phi, rho, mu, k, \ pressure_freeze): # Create mesh and define function space parameters["ghost_mode"] = "shared_facet" # required by dS dx = Measure('dx', domain=mesh, subdomain_data=subdomains) ds = Measure('ds', domain=mesh, subdomain_data=boundaries) dS = Measure('dS', domain=mesh, subdomain_data=boundaries) C = VectorFunctionSpace(mesh, "CG", 2) C = BlockFunctionSpace([C]) TM = TensorFunctionSpace(mesh, 'DG', 0) PM = FunctionSpace(mesh, 'DG', 0) n = FacetNormal(mesh) vc = CellVolume(mesh) fc = FacetArea(mesh) h = vc/fc h_avg = (vc('+') + vc('-'))/(2*avg(fc)) monitor_dt = dt f_stress_x = Constant(-1.e3) f_stress_y = Constant(-20.0e6) f = Constant((0.0, 0.0)) #sink/source for displacement I = Identity(mesh.topology().dim()) # Define variational problem psiu, = BlockTestFunction(C) block_u = BlockTrialFunction(C) u, = block_split(block_u) w = BlockFunction(C) theta = -1.0 a_time = inner(-alpha*pressure_freeze*I,sym(grad(psiu)))*dx #quasi static a = inner(2*mu_l*strain(u)+lmbda_l*div(u)*I, sym(grad(psiu)))*dx rhs_a = inner(f,psiu)*dx \ + dot(f_stress_y*n,psiu)*ds(2) r_u = [a] #DirichletBC bcd1 = DirichletBC(C.sub(0).sub(0), 0.0, boundaries, 1) # No normal displacement for solid on left side bcd3 = DirichletBC(C.sub(0).sub(0), 0.0, boundaries, 3) # No normal displacement for solid on right side bcd4 = DirichletBC(C.sub(0).sub(1), 0.0, boundaries, 4) # No normal displacement for solid on bottom side bcs = BlockDirichletBC([bcd1,bcd3,bcd4]) AA = block_assemble([r_u]) FF = block_assemble([rhs_a - a_time]) bcs.apply(AA) bcs.apply(FF) block_solve(AA, w.block_vector(), FF, "mumps") export_solution = w return export_solution, T
def test_steady_stokes(k): # Polynomial order and mesh resolution nx_list = [4, 8, 16] nu = Constant(1) if comm.Get_rank() == 0: print('{:=^72}'.format('Computing for polynomial order ' + str(k))) # Error listst error_u, error_p, error_div = [], [], [] for nx in nx_list: if comm.Get_rank() == 0: print('# Resolution ' + str(nx)) mesh = UnitSquareMesh(nx, nx) # Get forcing from exact solutions u_exact, p_exact = exact_solution(mesh) f = div(p_exact * Identity(2) - 2 * nu * sym(grad(u_exact))) # Define FunctionSpaces and functions V = VectorElement("DG", mesh.ufl_cell(), k) Q = FiniteElement("DG", mesh.ufl_cell(), k - 1) Vbar = VectorElement("DGT", mesh.ufl_cell(), k) Qbar = FiniteElement("DGT", mesh.ufl_cell(), k) mixedL = FunctionSpace(mesh, MixedElement([V, Q])) mixedG = FunctionSpace(mesh, MixedElement([Vbar, Qbar])) Uh = Function(mixedL) Uhbar = Function(mixedG) # Set forms alpha = Constant(6 * k * k) forms_stokes = FormsStokes(mesh, mixedL, mixedG, alpha).forms_steady(nu, f) # No-slip boundary conditions, set pressure in one of the corners bc0 = DirichletBC(mixedG.sub(0), Constant((0, 0)), Gamma) bc1 = DirichletBC(mixedG.sub(1), Constant(0), Corner, "pointwise") bcs = [bc0, bc1] # Initialize static condensation class ssc = StokesStaticCondensation(mesh, forms_stokes['A_S'], forms_stokes['G_S'], forms_stokes['B_S'], forms_stokes['Q_S'], forms_stokes['S_S'], bcs) # Assemble global system and incorporates bcs ssc.assemble_global_system(True) # Solve using mumps ssc.solve_problem(Uhbar, Uh, "mumps", "default") # Compute velocity/pressure/local div error uh, ph = Uh.split() e_u = np.sqrt(np.abs(assemble(dot(uh - u_exact, uh - u_exact) * dx))) e_p = np.sqrt(np.abs(assemble((ph - p_exact) * (ph - p_exact) * dx))) e_d = np.sqrt(np.abs(assemble(div(uh) * div(uh) * dx))) if comm.rank == 0: error_u.append(e_u) error_p.append(e_p) error_div.append(e_d) print('Error in velocity ' + str(error_u[-1])) print('Error in pressure ' + str(error_p[-1])) print('Local mass error ' + str(error_div[-1])) if comm.rank == 0: iterator_list = [1. / float(nx) for nx in nx_list] conv_u = compute_convergence(iterator_list, error_u) conv_p = compute_convergence(iterator_list, error_p) assert any(conv > k + 0.75 for conv in conv_u) assert any(conv > (k - 1) + 0.75 for conv in conv_p)
def transport_linear(integrator_type, mesh, subdomains, boundaries, t_start, dt, T, solution0, \ alpha_0, K_0, mu_l_0, lmbda_l_0, Ks_0, \ alpha_1, K_1, mu_l_1, lmbda_l_1, Ks_1, \ alpha, K, mu_l, lmbda_l, Ks, \ cf_0, phi_0, rho_0, mu_0, k_0,\ cf_1, phi_1, rho_1, mu_1, k_1,\ cf, phi, rho, mu, k, \ d_0, d_1, d_t, vel_c, p_con, A_0, Temp, c_extrapolate): # Create mesh and define function space parameters["ghost_mode"] = "shared_facet" # required by dS dx = Measure('dx', domain=mesh, subdomain_data=subdomains) ds = Measure('ds', domain=mesh, subdomain_data=boundaries) dS = Measure('dS', domain=mesh, subdomain_data=boundaries) C_cg = FiniteElement("CG", mesh.ufl_cell(), 1) C_dg = FiniteElement("DG", mesh.ufl_cell(), 0) mini = C_cg + C_dg C = FunctionSpace(mesh, mini) C = BlockFunctionSpace([C]) TM = TensorFunctionSpace(mesh, 'DG', 0) PM = FunctionSpace(mesh, 'DG', 0) n = FacetNormal(mesh) vc = CellVolume(mesh) fc = FacetArea(mesh) h = vc / fc h_avg = (vc('+') + vc('-')) / (2 * avg(fc)) penalty1 = Constant(1.0) tau = Function(PM) tau = tau_cal(tau, phi, -0.5) tuning_para = 0.25 vel_norm = (dot(vel_c, n) + abs(dot(vel_c, n))) / 2.0 cell_size = CellDiameter(mesh) vnorm = sqrt(dot(vel_c, vel_c)) I = Identity(mesh.topology().dim()) d_eff = Function(TM) d_eff = diff_coeff_cal_rev(d_eff, d_0, tau, phi) + tuning_para * cell_size * vnorm * I monitor_dt = dt # Define variational problem dc, = BlockTrialFunction(C) dc_dot, = BlockTrialFunction(C) psic, = BlockTestFunction(C) block_c = BlockFunction(C) c, = block_split(block_c) block_c_dot = BlockFunction(C) c_dot, = block_split(block_c_dot) theta = -1.0 a_time = phi * rho * inner(c_dot, psic) * dx a_dif = dot(rho*d_eff*grad(c),grad(psic))*dx \ - dot(avg_w(rho*d_eff*grad(c),weight_e(rho*d_eff,n)), jump(psic, n))*dS \ + theta*dot(avg_w(rho*d_eff*grad(psic),weight_e(rho*d_eff,n)), jump(c, n))*dS \ + penalty1/h_avg*k_e(rho*d_eff,n)*dot(jump(c, n), jump(psic, n))*dS a_adv = -dot(rho*vel_c*c,grad(psic))*dx \ + dot(jump(psic), rho('+')*vel_norm('+')*c('+') - rho('-')*vel_norm('-')*c('-') )*dS \ + dot(psic, rho*vel_norm*c)*ds(3) R_c = R_c_cal(c_extrapolate, p_con, Temp) c_D1 = Constant(0.5) rhs_c = R_c * A_s_cal(phi, phi_0, A_0) * psic * dx - dot( rho * phi * vel_c, n) * c_D1 * psic * ds(1) r_u = [a_dif + a_adv] j_u = block_derivative(r_u, [c], [dc]) r_u_dot = [a_time] j_u_dot = block_derivative(r_u_dot, [c_dot], [dc_dot]) r = [r_u_dot[0] + r_u[0] - rhs_c] # this part is not applied. exact_solution_expression1 = Expression("1.0", t=0, element=C[0].ufl_element()) def bc(t): p5 = DirichletBC(C.sub(0), exact_solution_expression1, boundaries, 1, method="geometric") return BlockDirichletBC([p5]) # Define problem wrapper class ProblemWrapper(object): def set_time(self, t): pass # Residual and jacobian functions def residual_eval(self, t, solution, solution_dot): return r def jacobian_eval(self, t, solution, solution_dot, solution_dot_coefficient): return [[ Constant(solution_dot_coefficient) * j_u_dot[0, 0] + j_u[0, 0] ]] # Define boundary condition def bc_eval(self, t): pass # Define initial condition def ic_eval(self): return solution0 # Define custom monitor to plot the solution def monitor(self, t, solution, solution_dot): pass problem_wrapper = ProblemWrapper() (solution, solution_dot) = (block_c, block_c_dot) solver = TimeStepping(problem_wrapper, solution, solution_dot) solver.set_parameters({ "initial_time": t_start, "time_step_size": dt, "monitor": { "time_step_size": monitor_dt, }, "final_time": T, "exact_final_time": "stepover", "integrator_type": integrator_type, "problem_type": "linear", "linear_solver": "mumps", "report": True }) export_solution = solver.solve() return export_solution, T
def test_unsteady_stokes(): nx, ny = 15, 15 k = 1 nu = Constant(1.0e-0) dt = Constant(2.5e-2) num_steps = 20 theta0 = 1.0 # Initial theta value theta1 = 0.5 # Theta after 1 step theta = Constant(theta0) mesh = UnitSquareMesh(nx, ny) # The 'unsteady version' of the benchmark in the 2012 paper by Labeur&Wells u_exact = Expression( ( "sin(t) * x[0]*x[0]*(1.0 - x[0])*(1.0 - x[0])*(2.0*x[1] \ -6.0*x[1]*x[1] + 4.0*x[1]*x[1]*x[1])", "-sin(t)* x[1]*x[1]*(1.0 - x[1])*(1.0 - x[1])*(2.0*x[0] \ - 6.0*x[0]*x[0] + 4.0*x[0]*x[0]*x[0])", ), t=0, degree=7, domain=mesh, ) p_exact = Expression("sin(t) * x[0]*(1.0 - x[0])", t=0, degree=7, domain=mesh) du_exact = Expression( ( "cos(t) * x[0]*x[0]*(1.0 - x[0])*(1.0 - x[0])*(2.0*x[1] \ - 6.0*x[1]*x[1] + 4.0*x[1]*x[1]*x[1])", "-cos(t)* x[1]*x[1]*(1.0 - x[1])*(1.0 - x[1])*(2.0*x[0] \ -6.0*x[0]*x[0] + 4.0*x[0]*x[0]*x[0])", ), t=0, degree=7, domain=mesh, ) ux_exact = Expression( ( "x[0]*x[0]*(1.0 - x[0])*(1.0 - x[0])*(2.0*x[1] \ - 6.0*x[1]*x[1] + 4.0*x[1]*x[1]*x[1])", "-x[1]*x[1]*(1.0 - x[1])*(1.0 - x[1])*(2.0*x[0] \ - 6.0*x[0]*x[0] + 4.0*x[0]*x[0]*x[0])", ), degree=7, domain=mesh, ) px_exact = Expression("x[0]*(1.0 - x[0])", degree=7, domain=mesh) sin_ext = Expression("sin(t)", t=0, degree=7, domain=mesh) f = du_exact + sin_ext * div(px_exact * Identity(2) - 2 * sym(grad(ux_exact))) Vhigh = VectorFunctionSpace(mesh, "DG", 7) Phigh = FunctionSpace(mesh, "DG", 7) # New syntax: V = VectorElement("DG", mesh.ufl_cell(), k) Q = FiniteElement("DG", mesh.ufl_cell(), k - 1) Vbar = VectorElement("DGT", mesh.ufl_cell(), k) Qbar = FiniteElement("DGT", mesh.ufl_cell(), k) mixedL = FunctionSpace(mesh, MixedElement([V, Q])) mixedG = FunctionSpace(mesh, MixedElement([Vbar, Qbar])) V2 = FunctionSpace(mesh, V) Uh = Function(mixedL) Uhbar = Function(mixedG) U0 = Function(mixedL) Uhbar0 = Function(mixedG) u0, p0 = split(U0) ubar0, pbar0 = split(Uhbar0) ustar = Function(V2) # Then the boundary conditions bc0 = DirichletBC(mixedG.sub(0), Constant((0, 0)), Gamma) bc1 = DirichletBC(mixedG.sub(1), Constant(0), Corner, "pointwise") bcs = [bc0, bc1] alpha = Constant(6 * k * k) forms_stokes = FormsStokes(mesh, mixedL, mixedG, alpha).forms_unsteady(ustar, dt, nu, f) ssc = StokesStaticCondensation( mesh, forms_stokes["A_S"], forms_stokes["G_S"], forms_stokes["G_ST"], forms_stokes["B_S"], forms_stokes["Q_S"], forms_stokes["S_S"], ) t = 0.0 step = 0 for step in range(num_steps): step += 1 t += float(dt) if comm.Get_rank() == 0: print("Step " + str(step) + " Time " + str(t)) # Set time level in exact solution u_exact.t = t p_exact.t = t du_exact.t = t - (1 - float(theta)) * float(dt) sin_ext.t = t - (1 - float(theta)) * float(dt) ssc.assemble_global_lhs() ssc.assemble_global_rhs() for bc in bcs: ssc.apply_boundary(bc) ssc.solve_problem(Uhbar, Uh, "none", "default") assign(U0, Uh) assign(ustar, U0.sub(0)) assign(Uhbar0, Uhbar) if step == 1: theta.assign(theta1) udiv_e = sqrt(assemble(div(Uh.sub(0)) * div(Uh.sub(0)) * dx)) u_ex_h = interpolate(u_exact, Vhigh) p_ex_h = interpolate(p_exact, Phigh) u_error = sqrt(assemble(dot(Uh.sub(0) - u_ex_h, Uh.sub(0) - u_ex_h) * dx)) p_error = sqrt(assemble(dot(Uh.sub(1) - p_ex_h, Uh.sub(1) - p_ex_h) * dx)) assert udiv_e < 1e-12 assert u_error < 1.5e-4 assert p_error < 1e-2
def __ufl_forms(self, nu, f): (w, q, wbar, qbar) = self.__test_functions() (u, p, ubar, pbar) = self.__trial_functions() # Infer geometric dimension zero_vec = np.zeros(self.gdim) ds = self.ds n = self.n he = self.he alpha = self.alpha h_d = self.h_d beta_stab = self.beta_stab facet_integral = self.facet_integral pI = p * Identity( self.mixedL.sub(1).ufl_cell().topological_dimension()) pbI = pbar * \ Identity(self.mixedL.sub(1).ufl_cell().topological_dimension()) # Upper left block # Contribution comes from local momentum balance AB = inner(2*nu*sym(grad(u)), grad(w))*dx \ + facet_integral(dot(-2*nu*sym(grad(u))*n + (2*nu*alpha/he)*u, w)) \ + facet_integral(dot(-2*nu*u, sym(grad(w))*n)) \ - inner(pI, grad(w))*dx # Contribution comes from local mass balance BtF = -dot(q, div(u))*dx - \ facet_integral(beta_stab*he/(nu+1)*dot(p, q)) A_S = AB + BtF # Upper right block # Contribution from local momentum CD = facet_integral(-alpha/he*2*nu*inner(ubar, w)) \ + facet_integral(2*nu*inner(ubar, sym(grad(w))*n)) \ + facet_integral(dot(pbI*n, w)) H = facet_integral(beta_stab * he / (nu + 1) * dot(pbar, q)) G_S = CD + H # Transpose block CDT = facet_integral(- alpha/he*2*nu*inner(wbar, u)) \ + facet_integral(2*nu*inner(wbar, sym(grad(u))*n)) \ + facet_integral(qbar * dot(u, n)) HT = facet_integral(beta_stab * he / (nu + 1) * dot(p, qbar)) G_ST = CDT + HT # Lower right block, penalty on ds(98) approximates free-slip KL = facet_integral(alpha/he * 2 * nu*dot(ubar, wbar)) \ - facet_integral(dot(pbar*n, wbar)) \ + Constant(1E12)/he * inner(outer(ubar, wbar), outer(n, n)) * ds(98) LtP = - facet_integral(dot(ubar, n)*qbar) \ - facet_integral(beta_stab*he/(nu+1) * pbar * qbar) B_S = KL + LtP # Righthandside Q_S = dot(f, w) * dx S_S = facet_integral(dot(Constant(zero_vec), wbar)) S_S += dot(h_d[0], wbar) * ds(99) + dot(h_d[1], wbar) * ds( 100) #Neumann BC return { 'A_S': A_S, 'G_S': G_S, 'G_ST': G_ST, 'B_S': B_S, 'Q_S': Q_S, 'S_S': S_S }
def E(U): return 0.5 * (F_(U).T * F_(U) - Identity(len(U)))
def sigma_f(p, u, d, mu_f): return -p*Identity(len(u)) +\ mu_f*(grad(u)*inv(F_(d)) + inv(F_(d)).T*grad(u).T)
def F_(U): return Identity(len(U)) + grad(U)
def sigma_f_new(u, p, d, mu_f): return -p * Identity( len(u)) + mu_f * (grad(u) * inv(F_(d)) + inv(F_(d)).T * grad(u).T)