def _assemble_and_solve_adj_eq(self, dFdu_adj_form, dJdu, compute_bdy):
dJdu_copy = dJdu.copy()
bcs = self._homogenize_bcs()
solver = self.block_helper.adjoint_solver
if solver is None:
if self.assemble_system:
rhs_bcs_form = backend.inner(backend.Function(self.function_space),
dFdu_adj_form.arguments()[0]) * backend.dx
A, _ = backend.assemble_system(dFdu_adj_form, rhs_bcs_form, bcs)
else:
A = compat.assemble_adjoint_value(dFdu_adj_form)
[bc.apply(A) for bc in bcs]
solver = backend.LUSolver(A, self.method)
self.block_helper.adjoint_solver = solver
solver.parameters.update(self.lu_solver_parameters)
[bc.apply(dJdu) for bc in bcs]
adj_sol = backend.Function(self.function_space)
solver.solve(adj_sol.vector(), dJdu)
adj_sol_bdy = None
if compute_bdy:
adj_sol_bdy = compat.function_from_vector(self.function_space, dJdu_copy - compat.assemble_adjoint_value(
backend.action(dFdu_adj_form, adj_sol)))
return adj_sol, adj_sol_bdy
def _ad_convert_type(self, value, options=None):
options = {} if options is None else options
riesz_representation = options.get("riesz_representation", "l2")
if riesz_representation == "l2":
return create_overloaded_object(
compat.function_from_vector(self.function_space(),
value,
cls=backend.Function))
elif riesz_representation == "L2":
ret = compat.create_function(self.function_space())
u = backend.TrialFunction(self.function_space())
v = backend.TestFunction(self.function_space())
M = backend.assemble(backend.inner(u, v) * backend.dx)
compat.linalg_solve(M, ret.vector(), value)
return ret
elif riesz_representation == "H1":
ret = compat.create_function(self.function_space())
u = backend.TrialFunction(self.function_space())
v = backend.TestFunction(self.function_space())
M = backend.assemble(
backend.inner(u, v) * backend.dx +
backend.inner(backend.grad(u), backend.grad(v)) * backend.dx)
compat.linalg_solve(M, ret.vector(), value)
return ret
elif callable(riesz_representation):
return riesz_representation(value)
else:
raise NotImplementedError("Unknown Riesz representation %s" %
riesz_representation)
def _assemble_and_solve_adj_eq(self, dFdu_adj_form, dJdu, compute_bdy):
dJdu_copy = dJdu.copy()
bcs = self._homogenize_bcs()
solver = self.block_helper.adjoint_solver
if solver is None:
solver = backend.KrylovSolver(self.method, self.preconditioner)
if self.assemble_system:
rhs_bcs_form = backend.inner(
backend.Function(self.function_space),
dFdu_adj_form.arguments()[0]) * backend.dx
A, _ = backend.assemble_system(dFdu_adj_form, rhs_bcs_form,
bcs)
if self.pc_operator is not None:
P = self._replace_form(self.pc_operator)
P, _ = backend.assemble_system(P, rhs_bcs_form, bcs)
solver.set_operators(A, P)
else:
solver.set_operator(A)
else:
A = compat.assemble_adjoint_value(dFdu_adj_form)
[bc.apply(A) for bc in bcs]
if self.pc_operator is not None:
P = self._replace_form(self.pc_operator)
P = compat.assemble_adjoint_value(P)
[bc.apply(P) for bc in bcs]
solver.set_operators(A, P)
else:
solver.set_operator(A)
self.block_helper.adjoint_solver = solver
solver.parameters.update(self.krylov_solver_parameters)
[bc.apply(dJdu) for bc in bcs]
adj_sol = backend.Function(self.function_space)
solver.solve(adj_sol.vector(), dJdu)
adj_sol_bdy = None
if compute_bdy:
adj_sol_bdy = compat.function_from_vector(
self.function_space, dJdu_copy - compat.assemble_adjoint_value(
backend.action(dFdu_adj_form, adj_sol)))
return adj_sol, adj_sol_bdy