def test_scaling_control():
u.vector()[:] = 1e-2
J1 = Constant(0.5) * (y - y_d) * (y - y_d) * dx
J2 = Constant(0.5) * u * u * dx
J_list = [J1, J2]
desired_weights = np.random.rand(2).tolist()
summ = sum(desired_weights)
test_ocp = cashocs.OptimalControlProblem(F,
bcs,
J_list,
y,
u,
p,
config,
desired_weights=desired_weights)
val = test_ocp.reduced_cost_functional.evaluate()
assert abs(val - summ) < 1e-14
assert cashocs.verification.control_gradient_test(ocp) > 1.9
assert cashocs.verification.control_gradient_test(ocp) > 1.9
assert cashocs.verification.control_gradient_test(ocp) > 1.9
def test_custom_supply_control():
adjoint_form = inner(grad(p), grad(
TestFunction(V))) * dx - (y - y_d) * TestFunction(V) * dx
dJ = Constant(alpha) * u * TestFunction(V) * dx + TestFunction(V) * p * dx
user_ocp = cashocs.OptimalControlProblem(F, bcs, J, y, u, p, config)
user_ocp.supply_custom_forms(dJ, adjoint_form, bcs)
assert cashocs.verification.control_gradient_test(user_ocp) > 1.9
assert cashocs.verification.control_gradient_test(user_ocp) > 1.9
assert cashocs.verification.control_gradient_test(user_ocp) > 1.9
def test_config_error():
with pytest.raises(ConfigError):
config.set('AlgoCG', 'cg_method', 'nonexistent')
config.set('OptimizationRoutine', 'algorithm', 'cg')
config.set('OptimizationRoutine', 'maximum_iterations', '2')
u.vector()[:] = np.random.rand(V.dim())
ocp_conf = cashocs.OptimalControlProblem(F, bcs, J, y, u, p, config)
ocp_conf.solve(max_iter=10)
with pytest.raises(CashocsException):
ocp_conf._erase_pde_memory()
ocp_conf.solve(max_iter=10)
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()
u = Function(V)
F = inner(grad(y), grad(p)) * dx - u * p * dx
bcs = cashocs.create_bcs_list(V, Constant(0), boundaries, [1, 2, 3, 4])
y_d = Expression('sin(2*pi*x[0])*sin(2*pi*x[1])', degree=1, domain=mesh)
alpha = 1e-6
J = Constant(0.5) * (y - y_d) * (y - y_d) * dx + Constant(
0.5 * alpha) * u * u * dx
ksp_options = [['ksp_type', 'cg'], ['pc_type', 'hypre'],
['pc_hypre_type', 'boomeramg'], ['ksp_rtol', 0.0],
['ksp_atol', 0.0], ['ksp_max_it', 1],
['ksp_monitor_true_residual']]
ocp = cashocs.OptimalControlProblem(F, bcs, J, y, u, p, config)
ocp_ksp = cashocs.OptimalControlProblem(F,
bcs,
J,
y,
u,
p,
config,
ksp_options=ksp_options)
def test_not_converged_error():
with pytest.raises(NotConvergedError):
u.vector()[:] = 0.0
ocp._erase_pde_memory()
ocp.solve('gd', 1e-10, 0.0, 1)
mesh, subdomains, boundaries, dx, ds, dS = cashocs.regular_mesh(25)
V = FunctionSpace(mesh, 'CG', 1)
y = Function(V)
p = Function(V)
u = Function(V)
e = inner(grad(y), grad(p))*dx - u*p*dx
bcs = cashocs.create_bcs_list(V, Constant(0), boundaries, [1, 2, 3, 4])
y_d = Expression('sin(2*pi*x[0])*sin(2*pi*x[1])', degree=1)
alpha = 1e-6
J = Constant(0.5)*(y - y_d)*(y - y_d)*dx + Constant(0.5*alpha)*u*u*dx
ocp = cashocs.OptimalControlProblem(e, bcs, J, y, u, p, config)
dJ = Constant(alpha)*u*TestFunction(V)*dx + p*TestFunction(V)*dx
adjoint_form = inner(grad(p), grad(TestFunction(V)))*dx - (y - y_d)*TestFunction(V)*dx
adjoint_bcs = bcs
ocp.supply_custom_forms(dJ, adjoint_form, adjoint_bcs)
ocp.solve()
### Post Processing
import matplotlib.pyplot as plt
def test_control_constraints_handling():
cg1_elem = FiniteElement('CG', mesh.ufl_cell(), 1)
vcg1_elem = VectorElement('CG', mesh.ufl_cell(), 1)
vcg2_elem = VectorElement('CG', mesh.ufl_cell(), 2)
real_elem = FiniteElement('R', mesh.ufl_cell(), 0)
dg0_elem = FiniteElement('DG', mesh.ufl_cell(), 0)
vdg0_elem = VectorElement('DG', mesh.ufl_cell(), 0)
dg1_elem = FiniteElement('DG', mesh.ufl_cell(), 1)
rt_elem = FiniteElement('RT', mesh.ufl_cell(), 1)
mixed_elem = MixedElement([cg1_elem, dg0_elem, vdg0_elem])
pass_elem = MixedElement(
[cg1_elem, real_elem, dg0_elem, vcg1_elem, mixed_elem])
fail_elem1 = MixedElement(
[mixed_elem, cg1_elem, vdg0_elem, real_elem, rt_elem])
fail_elem2 = MixedElement(
[dg1_elem, mixed_elem, cg1_elem, vdg0_elem, real_elem])
fail_elem3 = MixedElement(
[mixed_elem, cg1_elem, vcg2_elem, vdg0_elem, real_elem])
pass_space = FunctionSpace(mesh, pass_elem)
pass_control = Function(pass_space)
fail_space1 = FunctionSpace(mesh, fail_elem1)
fail_space2 = FunctionSpace(mesh, fail_elem2)
fail_space3 = FunctionSpace(mesh, fail_elem3)
fail_control1 = Function(fail_space1)
fail_control2 = Function(fail_space2)
fail_control3 = Function(fail_space3)
ocp_cc_pass = cashocs.OptimalControlProblem(F,
bcs,
J,
y,
pass_control,
p,
config,
control_constraints=cc)
with pytest.raises(InputError):
ocp_cc_fail1 = cashocs.OptimalControlProblem(F,
bcs,
J,
y,
fail_control1,
p,
config,
control_constraints=cc)
with pytest.raises(InputError):
ocp_cc_fail2 = cashocs.OptimalControlProblem(F,
bcs,
J,
y,
fail_control2,
p,
config,
control_constraints=cc)
with pytest.raises(InputError):
ocp_cc_fail3 = cashocs.OptimalControlProblem(F,
bcs,
J,
y,
fail_control3,
p,
config,
control_constraints=cc)
mesh, subdomains, boundaries, dx, ds, dS = cashocs.regular_mesh(10)
V = FunctionSpace(mesh, 'CG', 1)
y = Function(V)
p = Function(V)
u = Function(V)
F = inner(grad(y), grad(p)) * dx - u * p * dx
bcs = cashocs.create_bcs_list(V, Constant(0), boundaries, [1, 2, 3, 4])
y_d = Expression('sin(2*pi*x[0])*sin(2*pi*x[1])', degree=1, domain=mesh)
alpha = 1e-6
J = Constant(0.5) * (y - y_d) * (y - y_d) * dx + Constant(
0.5 * alpha) * u * u * dx
ocp = cashocs.OptimalControlProblem(F, bcs, J, y, u, p, config)
cc = [0, 100]
ocp_cc = cashocs.OptimalControlProblem(F,
bcs,
J,
y,
u,
p,
config,
control_constraints=cc)
def test_control_constraints_handling():
cg1_elem = FiniteElement('CG', mesh.ufl_cell(), 1)
e = inner(grad(y), grad(p)) * dx + y * p * dx - u * p * ds
bcs = None
y_d = Expression('sin(2*pi*x[0])*sin(2*pi*x[1])', degree=1)
alpha = 1e-6
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()
### Post Processing
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 5))
plt.subplot(1, 3, 1)
fig = plot(u)
plt.colorbar(fig, fraction=0.046, pad=0.04)
plt.title('Control variable u')
else:
y_prev = states[k - 1]
p = adjoints[k]
u = controls[k]
state_eq = Constant(1/dt)*(y - y_prev)*p*dx + inner(grad(y), grad(p))*dx - u*p*dx
e.append(state_eq)
y_d.append(interpolate(y_d_expr, V))
J_list.append(Constant(0.5*dt) * (y - y_d[k]) * (y - y_d[k]) * dx + Constant(0.5 * dt * alpha) * u * u * dx)
J = cashocs.utils.summation(J_list)
ocp = cashocs.OptimalControlProblem(e, bcs_list, J, states, controls, adjoints, config)
ocp.solve()
### Post processing
u_file = File('./visualization/u.pvd')
y_file = File('./visualization/y.pvd')
temp_u = Function(V)
temp_y = Function(V)
for k in range(len(t_array)):
t = t_array[k]
temp_u.vector()[:] = controls[k].vector()[:]
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
optimization_problem = cashocs.OptimalControlProblem(e, bcs, J, state,
controls, adjoint, config)
optimization_problem.solve()
### Post Processing
y, z = state.split(True)
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 10))
plt.subplot(2, 3, 1)
fig = plot(u)
plt.colorbar(fig, fraction=0.046, pad=0.04)
plt.title('Control variable u')
plt.subplot(2, 3, 2)
fig = plot(y)
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]))
state_m = Function(Mixed)
y_m, z_m = split(state_m)
adjoint_m = Function(Mixed)
p_m, q_m = split(adjoint_m)
F = inner(grad(y_m), grad(p_m)) * dx + z_m * p_m * dx - u * p_m * dx + inner(
grad(z_m), grad(q_m)) * dx + y_m * q_m * dx - v * q_m * dx
bcs_m1 = cashocs.create_bcs_list(Mixed.sub(0), Constant(0), boundaries,
[1, 2, 3, 4])
bcs_m2 = cashocs.create_bcs_list(Mixed.sub(1), Constant(0), boundaries,
[1, 2, 3, 4])
['pc_type', 'icc'],
['pc_factor_levels', 0],
['ksp_rtol', 1e-6],
['ksp_atol', 1e-15],
]
y_d = Expression('sin(2*pi*x[0])*sin(2*pi*x[1])', degree=1)
alpha = 1e-6
J = Constant(0.5) * (y - y_d) * (y - y_d) * dx + Constant(
0.5 * alpha) * u * u * dx
ocp = cashocs.OptimalControlProblem(e,
bcs,
J,
y,
u,
p,
config,
ksp_options=ksp_options,
adjoint_ksp_options=adjoint_ksp_options)
ocp.solve()
### Post Processing
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 5))
plt.subplot(1, 3, 1)
fig = plot(u)
plt.colorbar(fig, fraction=0.046, pad=0.04)
config = cashocs.load_config('config.ini')
mesh, subdomains, boundaries, dx, ds, dS = cashocs.regular_mesh(25)
V = FunctionSpace(mesh, 'CG', 1)
y = Function(V)
p = Function(V)
u = Function(V)
e = inner(grad(y), grad(p)) * dx - u * p * dx
bcs = cashocs.create_bcs_list(V, Constant(0), boundaries, [1, 2, 3, 4])
y_d = Expression('sin(2*pi*x[0]*x[1])', degree=1)
alpha = 1e-3
J_init = Constant(0.5) * (y - y_d) * (y - y_d) * dx + Constant(
0.5 * alpha) * u * u * dx
ocp_init = cashocs.OptimalControlProblem(e, bcs, J_init, y, u, p, config)
ocp_init.solve()
y_bar = 1e-1
gammas = [pow(10, i) for i in np.arange(1, 9, 3)]
for gamma in gammas:
J = Constant(0.5) * (y - y_d) * (y - y_d) * dx + Constant(
0.5 * alpha) * u * u * dx + Constant(1 / (2 * gamma)) * pow(
Max(0,
Constant(gamma) * (y - y_bar)), 2) * dx
ocp_gamma = cashocs.OptimalControlProblem(e, bcs, J, y, u, p, config)
ocp_gamma.solve()
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
ocp = cashocs.OptimalControlProblem(e, bcs, J, up, c, vq, config)
ocp.solve()
### Post Processing
u, p = up.split(True)
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 5))
plt.subplot(1, 3, 1)
fig = plot(c)
plt.colorbar(fig, fraction=0.046, pad=0.04)
plt.title('Control variable c')
plt.subplot(1, 3, 2)
fig = plot(u)
