def computeVelocityField(mesh): Xh = dl.VectorFunctionSpace(mesh,'Lagrange', 2) Wh = dl.FunctionSpace(mesh, 'Lagrange', 1) mixed_element = dl.MixedElement([Xh.ufl_element(), Wh.ufl_element()]) XW = dl.FunctionSpace(mesh, mixed_element) Re = 1e2 g = dl.Expression(('0.0','(x[0] < 1e-14) - (x[0] > 1 - 1e-14)'), element=Xh.ufl_element()) bc1 = dl.DirichletBC(XW.sub(0), g, v_boundary) bc2 = dl.DirichletBC(XW.sub(1), dl.Constant(0), q_boundary, 'pointwise') bcs = [bc1, bc2] vq = dl.Function(XW) (v,q) = ufl.split(vq) (v_test, q_test) = dl.TestFunctions (XW) def strain(v): return ufl.sym(ufl.grad(v)) F = ( (2./Re)*ufl.inner(strain(v),strain(v_test))+ ufl.inner (ufl.nabla_grad(v)*v, v_test) - (q * ufl.div(v_test)) + ( ufl.div(v) * q_test) ) * ufl.dx dl.solve(F == 0, vq, bcs, solver_parameters={"newton_solver": {"relative_tolerance":1e-4, "maximum_iterations":100, "linear_solver":"default"}}) return v
def computeVelocityField(self): """ The steady-state Navier-Stokes equation for velocity v: -1/Re laplace v + nabla q + v dot nabla v = 0 in Omega nabla dot v = 0 in Omega v = g on partial Omega """ Xh = dl.VectorFunctionSpace(self.mesh, 'Lagrange', self.eldeg) Wh = dl.FunctionSpace(self.mesh, 'Lagrange', 1) mixed_element = dl.MixedElement([Xh.ufl_element(), Wh.ufl_element()]) XW = dl.FunctionSpace(self.mesh, mixed_element) Re = dl.Constant(self.Re) def v_boundary(x, on_boundary): return on_boundary def q_boundary(x, on_boundary): return x[0] < dl.DOLFIN_EPS and x[1] < dl.DOLFIN_EPS g = dl.Expression(('0.0', '(x[0] < 1e-14) - (x[0] > 1 - 1e-14)'), element=Xh.ufl_element()) bc1 = dl.DirichletBC(XW.sub(0), g, v_boundary) bc2 = dl.DirichletBC(XW.sub(1), dl.Constant(0), q_boundary, 'pointwise') bcs = [bc1, bc2] vq = dl.Function(XW) (v, q) = ufl.split(vq) (v_test, q_test) = dl.TestFunctions(XW) def strain(v): return ufl.sym(ufl.grad(v)) F = ((2. / Re) * ufl.inner(strain(v), strain(v_test)) + ufl.inner(ufl.nabla_grad(v) * v, v_test) - (q * ufl.div(v_test)) + (ufl.div(v) * q_test)) * ufl.dx dl.solve(F == 0, vq, bcs, solver_parameters={ "newton_solver": { "relative_tolerance": 1e-4, "maximum_iterations": 100, "linear_solver": "default" } }) return v
def epsilon(u): return 0.5*(nabla_grad(u) + nabla_grad(u).T)
C2 = as_vector([0., c[2]]) # C1 = Constant((0.5, 0.)) # C1 = as_matrix([c[0],], [c[2],]) # print('C1:\n', C1) # print(type(C1)) # Define variational problem u = TrialFunction(V) v = TestFunction(V) # f = Expression("10*exp(-(pow(x[0] - 0.5, 2) + pow(x[1] - 0.5, 2)) / 0.02)", degree=2) c000 = Constant(0.5) c111 = Constant(2.) g = Constant(0.) a = inner(C*nabla_grad(u), nabla_grad(v))*dx # a = inner(grad(u), grad(v))*dx # L1 = inner(C1, grad(v))*dx # L1 = 0.5*grad(v)[0]*dx L1 = c000*nabla_grad(v)[0]*dx L2 = c111*nabla_grad(v)[1]*dx # L1 = dot(C1, v)*dx # print('v', type(v)) # print('grad_v', type(nabla_grad(v))) # Compute solution u1 = Function(V) solve(a == L1, u1, bc1)
# plt.figure() # p = plot(u_n) # plt.colorbar(p) # plt.show() T = 80.0 # final time num_step = 200 dt = T / num_step k = 1. / dt tol = 1e-6 R.vector()[:] = R1(u_n) V2Fct_x.vector()[:] = v2_x(u_n) V2Fct_y.vector()[:] = v2_y(u_n) F = dot((u - u_n) * k, v) * dx + nu * dot(grad(u), grad(v)) * dx + dot(nabla_grad(v1()) * u, nabla_grad(v)) * dx - \ dot(R * u, v) * dx - dot(V2Fct_x * u, v.dx(0)) * dx - dot(V2Fct_y * u, v.dx(1)) * dx u = Function(Vhat) a = lhs(F) L = rhs(F) t = 0 ## uncomment to save the solution onto pvd files. Can be used to plot dynamically in paraview # vtkfile = File('framework2/solution.pvd') # vtkfile << (u_n, t) for n in range(num_step): R.vector()[:] = R1(u_n) V2Fct_x.vector()[:] = v2_x(u_n) V2Fct_y.vector()[:] = v2_y(u_n)
def strain(v): return ufl.sym(ufl.nabla_grad(v))
def eps(self, u): return sym(nabla_grad(u))
def epsilon(u_): return sym(nabla_grad(u_))
p = TrialFunction(Q) q = TestFunction(Q) u_n = Function(V) u_1 = Function(V) p_n = Function(Q) p_1 = Function(Q) U = 0.5 * (u_n + u) n = FacetNormal(mesh) f = Constant((0, 0)) k = Constant(dt) mu = Constant(mu) rho = Constant(rho) F1 = rho * dot((u - u_n) / k, v) * dx + rho * dot(dot(u_n, nabla_grad(u_n)), v) * dx + \ inner(sigma(U, p_n), epsilon(v)) * dx + dot(p_n * n, v) * ds - dot(mu * nabla_grad(U) * n, v) \ * ds - dot(f, v) * dx a1 = lhs(F1) L1 = rhs(F1) a2 = dot(nabla_grad(p), nabla_grad(q)) * dx L2 = dot(nabla_grad(p_n), nabla_grad(q)) * dx - (1 / k) * div(u_1) * q * dx a3 = dot(u, v) * dx L3 = dot(u_1, v) * dx - k * dot(nabla_grad(p_1 - p_n), v) * dx A1 = assemble(a1) A2 = assemble(a2) A3 = assemble(a3)
C = as_matrix(((c[0], c[1]), (c[2], c[3]))) # Define variational problem u = TrialFunction(V) v = TestFunction(V) A_y = Expression( '10 + 9*sin( 2 * pi * x[0] * x[1] * (1-x[0]) * (1-x[1]) )', degree=1, pi=np.pi) # A_y = Expression('10 + sin(2*pi*x[0]* eps *x[1] * eps *(1-x[0]* eps)*(1-x[1]* eps))', eps=eps, degree=1) e1 = as_vector([1., 0.]) e2 = as_vector([0., 1.]) a = inner(A_y*nabla_grad(u), nabla_grad(v))*dx # L1 = - A_y*nabla_grad(u)[0]*dx # other expression L1 = -inner(A_y*e1, nabla_grad(u))*dx L2 = -inner(A_y*e2, nabla_grad(u))*dx # Compute solution u1 = Function(V) solve(a == L1, u1, bc1) # A1, f1 = assemble_system(a, L1, bc1) # print('A1:\n', A1.array()) # print('f1:\n', f1.get_local()) # w1 = np.array(u1.vector()) # print('w1:\n', w1)
def symgrad(v): return ufl.sym(ufl.nabla_grad(v))
# p = plot(u_n) # plt.colorbar(p) # plt.show() T = 80.0 # final time num_step = 200 dt = T / num_step k = 1. / dt tol = 1e-6 R.vector()[:] = R1(u_n) V2Fct_x.vector()[:] = v2_x(u_n) V2Fct_y.vector()[:] = v2_y(u_n) F = dot((u - u_n) * k, v) * dx + nu * dot(grad(u), grad(v)) * dx + dot( nabla_grad(v1()) * u, nabla_grad(v)) * dx - dot(R * u, v) * dx - dot( V2Fct_x * u, v.dx(0)) * dx - dot(V2Fct_y * u, v.dx(1)) * dx #F = dot((u-u_n)*k,v)*dx + nu * dot(grad(u), grad(v)) * dx + dot(nabla_grad(v1())*u, nabla_grad(v)) * dx - \ # dot( R*u, v) * dx - dot(V2Fct*u, nabla_grad(v)) * dx # - dot( v2(u), grad(v)) * dx # - dot( R(u), v) * dx # - dot( v2(u), grad(v)) * dx # - dot( Adv(u), grad(v)) * dx # dot(nabla_grad(zlogFct)*u, nabla_grad(v)) * dx u = Function(Vhat) a = lhs(F) L = rhs(F) t = 0 ## uncomment to save the solution onto pvd files. Can be used to plot dynamically in paraview
C = as_matrix(((c[0], c[1]), (c[2], c[3]))) # Define variational problem u = TrialFunction(V) v = TestFunction(V) A_y = Expression( '10 + 9*sin( 2 * pi * x[0] * x[1] * (1-x[0]) * (1-x[1]) )', degree=1, pi=np.pi) # A_y = Expression('10 + sin(2*pi*x[0]* eps *x[1] * eps *(1-x[0]* eps)*(1-x[1]* eps))', eps=eps, degree=1) e1 = as_vector([1., 0.]) e2 = as_vector([0., 1.]) a = inner(A_y*nabla_grad(u), nabla_grad(v))*dx L1 = - A_y*nabla_grad(u)[0]*dx # other expression # L1 = -inner(A_y*e1, nabla_grad(u))*dx L2 = -inner(A_y*e2, nabla_grad(u))*dx # Compute solution u1 = Function(V) solve(a == L1, u1, bc1) # A1, f1 = assemble_system(a, L1, bc1) # print('A1:\n', A1.array()) # print('f1:\n', f1.get_local()) # w1 = np.array(u1.vector()) # print('w1:\n', w1)