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)
