def test_newton_solver():
mesh, _, boundaries, dx, ds, _ = cashocs.regular_mesh(5)
V = FunctionSpace(mesh, 'CG', 1)
u = Function(V)
u_fen = Function(V)
v = TestFunction(V)
F = inner(grad(u), grad(v)) * dx + Constant(1e2) * pow(
u, 3) * v * dx - Constant(1) * v * dx
bcs = cashocs.create_bcs_list(V, Constant(0), boundaries, [1, 2, 3, 4])
solve(F == 0, u, bcs)
u_fen.vector()[:] = u.vector()[:]
u.vector()[:] = 0.0
cashocs.damped_newton_solve(F,
u,
bcs,
rtol=1e-9,
atol=1e-10,
max_iter=50,
convergence_type='combined',
norm_type='l2',
damped=False,
verbose=True)
assert np.allclose(u.vector()[:], u_fen.vector()[:])
def test_create_bcs():
trial = fenics.TrialFunction(V)
test = fenics.TestFunction(V)
a = fenics.inner(fenics.grad(trial), fenics.grad(test)) * dx
L = fenics.Constant(1) * test * dx
bc_val = np.random.rand()
bc1 = fenics.DirichletBC(V, fenics.Constant(bc_val), boundaries, 1)
bc2 = fenics.DirichletBC(V, fenics.Constant(bc_val), boundaries, 2)
bc3 = fenics.DirichletBC(V, fenics.Constant(bc_val), boundaries, 3)
bc4 = fenics.DirichletBC(V, fenics.Constant(bc_val), boundaries, 4)
bcs_ex = [bc1, bc2, bc3, bc4]
bcs = cashocs.create_bcs_list(V, fenics.Constant(bc_val), boundaries,
[1, 2, 3, 4])
u_ex = fenics.Function(V)
u = fenics.Function(V)
fenics.solve(a == L, u_ex, bcs_ex)
fenics.solve(a == L, u, bcs)
assert np.allclose(u_ex.vector()[:], u.vector()[:])
assert abs(u(0, 0) - bc_val) < 1e-14
p = Function(W)
u = Function(V)
# Set up a discontinuous Galerkin method (SIPG) (needed for the adjoint system,
# reduces to the classical Galerkin method for CG elements)
n = FacetNormal(mesh)
h = CellDiameter(mesh)
h_avg = (h('+') + h('-')) / 2
flux = 1 / 2 * (inner(grad(u)('+') + grad(u)('-'), n('+')))
alpha = 1e3
gamma = 1e3
e = dot(grad(p), grad(y))*dx \
- dot(avg(grad(p)), jump(y, n))*dS \
- dot(jump(p, n), avg(grad(y)))*dS \
+ Constant(alpha)/h_avg*dot(jump(p, n), jump(y, n))*dS \
- dot(grad(p), y*n)*ds \
- dot(p*n, grad(y))*ds \
+ (Constant(gamma)/h)*p*y*ds - u*p*dx
bcs = cashocs.create_bcs_list(V, Constant(0), boundaries, [1, 2, 3, 4])
lambd = 1e-6
y_d = Expression('sin(2*pi*x[0])*sin(2*pi*x[1])', degree=1)
J = Constant(0.5) * (y - y_d) * (y - y_d) * dx + Constant(
0.5 * lambd) * u * u * dx
optimization_problem = cashocs.OptimalControlProblem(e, bcs, J, y, u, p,
config)
optimization_problem.solve()
elem_2 = FiniteElement('CG', mesh.ufl_cell(), 1)
V = FunctionSpace(mesh, MixedElement([elem_1, elem_2]))
U = FunctionSpace(mesh, 'CG', 1)
state = Function(V)
adjoint = Function(V)
y, z = split(state)
p, q = split(adjoint)
u = Function(U)
v = Function(U)
controls = [u, v]
e_y = inner(grad(y), grad(p)) * dx + z * p * dx - u * p * dx
bcs_y = cashocs.create_bcs_list(V.sub(0), Constant(0), boundaries,
[1, 2, 3, 4])
e_z = inner(grad(z), grad(q)) * dx + y * q * dx - v * q * dx
bcs_z = cashocs.create_bcs_list(V.sub(1), Constant(0), boundaries,
[1, 2, 3, 4])
e = e_y + e_z
bcs = bcs_y + bcs_z
y_d = Expression('sin(2*pi*x[0])*sin(2*pi*x[1])', degree=1)
z_d = Expression('sin(4*pi*x[0])*sin(4*pi*x[1])', degree=1)
alpha = 1e-6
beta = 1e-6
J = Constant(0.5)*(y - y_d)*(y - y_d)*dx + Constant(0.5)*(z - z_d)*(z - z_d)*dx \
+ Constant(0.5*alpha)*u*u*dx + Constant(0.5*beta)*v*v*dx
mesh, subdomains, boundaries, dx, ds, dS = cashocs.import_mesh('./mesh/mesh.xdmf')
v_elem = VectorElement('CG', mesh.ufl_cell(), 2)
p_elem = FiniteElement('CG', mesh.ufl_cell(), 1)
V = FunctionSpace(mesh, MixedElement([v_elem, p_elem]))
up = Function(V)
u, p = split(up)
vq = Function(V)
v, q = split(vq)
e = inner(grad(u), grad(v))*dx - p*div(v)*dx - q*div(u)*dx
u_in = Expression(('-1.0/4.0*(x[1] - 2.0)*(x[1] + 2.0)', '0.0'), degree=2)
bc_in = DirichletBC(V.sub(0), u_in, boundaries, 1)
bc_no_slip = cashocs.create_bcs_list(V.sub(0), Constant((0,0)), boundaries, [2,4])
bcs = [bc_in] + bc_no_slip
J = inner(grad(u), grad(u))*dx
sop = cashocs.ShapeOptimizationProblem(e, bcs, J, up, vq, boundaries, config)
sop.solve()
### Post Processing
import matplotlib.pyplot as plt
plt.figure(figsize=(15,3))
ax_mesh = plt.subplot(1, 3, 1)
y = Function(V)
z = Function(V)
p = Function(V)
q = Function(V)
states = [y, z]
adjoints = [p, q]
u = Function(V)
v = Function(V)
controls = [u, v]
e1 = inner(grad(y), grad(p)) * dx + z * p * dx - u * p * dx
e2 = inner(grad(z), grad(q)) * dx + y * q * dx - v * q * dx
e = [e1, e2]
bcs1 = cashocs.create_bcs_list(V, Constant(0), boundaries, [1, 2, 3, 4])
bcs2 = cashocs.create_bcs_list(V, Constant(0), boundaries, [1, 2, 3, 4])
bcs = [bcs1, bcs2]
y_d = Expression('sin(2*pi*x[0])*sin(2*pi*x[1])', degree=1)
z_d = Expression('sin(4*pi*x[0])*sin(4*pi*x[1])', degree=1)
alpha = 1e-4
beta = 1e-4
J = Constant(0.5)*(y - y_d)*(y - y_d)*dx + Constant(0.5)*(z - z_d)*(z - z_d)*dx \
+ Constant(0.5*alpha)*u*u*dx + Constant(0.5*beta)*v*v*dx
ocp = cashocs.OptimalControlProblem(e, bcs, J, states, controls, adjoints,
config)
elem = FiniteElement('CG', mesh.ufl_cell(), 1)
Mixed = FunctionSpace(mesh, MixedElement([elem, elem]))
J = Constant(0.5) * (y - y_d) * (y - y_d) * dx + Constant(
0.5 * alpha) * u * u * ds
scalar_product = TrialFunction(V) * TestFunction(V) * ds
ocp = cashocs.OptimalControlProblem(e,
bcs,
J,
y,
u,
p,
config,
riesz_scalar_products=scalar_product)
ocp.solve()
bcs = cashocs.create_bcs_list(V, 1, boundaries, [1, 2, 3, 4])
bdry_idx = Function(V)
[bc.apply(bdry_idx.vector()) for bc in bcs]
mask = np.where(bdry_idx.vector()[:] == 1)[0]
y_bdry = Function(V)
u_bdry = Function(V)
y_bdry.vector()[mask] = y.vector()[mask]
u_bdry.vector()[mask] = u.vector()[mask]
error_inf = np.max(np.abs(y_bdry.vector()[:] - u_bdry.vector()[:])) / np.max(
np.abs(u_bdry.vector()[:])) * 100
error_l2 = np.sqrt(assemble(
(y - u) * (y - u) * ds)) / np.sqrt(assemble(u * u * ds)) * 100
print('Error regarding the (weak) imposition of the boundary values')
up = Function(V)
u, p = split(up)
vq = Function(V)
v, q = split(vq)
c = Function(U)
e = inner(grad(u), grad(v)) * dx - p * div(v) * dx - q * div(u) * dx - inner(
c, v) * dx
def pressure_point(x, on_boundary):
return near(x[0], 0) and near(x[1], 0)
no_slip_bcs = cashocs.create_bcs_list(V.sub(0), Constant((0, 0)), boundaries,
[1, 2, 3])
lid_velocity = Expression(('4*x[0]*(1-x[0])', '0.0'), degree=2)
bc_lid = DirichletBC(V.sub(0), lid_velocity, boundaries, 4)
bc_pressure = DirichletBC(V.sub(1),
Constant(0),
pressure_point,
method='pointwise')
bcs = no_slip_bcs + [bc_lid, bc_pressure]
alpha = 1e-5
u_d = Expression(('sqrt(pow(x[0], 2) + pow(x[1], 2))*cos(2*pi*x[1])',
'-sqrt(pow(x[0], 2) + pow(x[1], 2))*sin(2*pi*x[0])'),
degree=2)
J = Constant(0.5) * inner(u - u_d, u - u_d) * dx + Constant(
0.5 * alpha) * inner(c, c) * dx