The solve object is responsible for solving the adjoint version of a forward model. More...

#include <AdjointSolve.h>

Inheritance diagram for AdjointSolve:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	AdjointSolve (Executioner &ex)

virtual bool	solve () override
	Solve the adjoint system with the following procedure: More...

virtual void	initialSetup ()

virtual void	setInnerSolve (SolveObject &solve)

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

std::shared_ptr< const MooseObject >	getSharedPtr () const

MooseApp &	getMooseApp () const

const std::string &	type () const

virtual const std::string &	name () const

std::string	typeAndName () const

std::string	errorPrefix (const std::string &error_type) const

void	callMooseError (std::string msg, const bool with_prefix) const

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

const InputParameters &	parameters () const

MooseObjectName	uniqueName () const

const T &	getParam (const std::string &name) const

std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const

const T *	queryParam (const std::string &name) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const

bool	isParamValid (const std::string &name) const

bool	isParamSetByUser (const std::string &nm) const

void	paramError (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramInfo (const std::string &param, Args... args) const

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const

void	mooseError (Args &&... args) const

void	mooseErrorNonPrefixed (Args &&... args) const

void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseInfo (Args &&... args) const

std::string	getDataFileName (const std::string &param) const

std::string	getDataFileNameByName (const std::string &relative_path) const

std::string	getDataFilePath (const std::string &relative_path) const

PerfGraph &	perfGraph ()

bool	isDefaultPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

bool	hasPostprocessor (const std::string &param_name, const unsigned int index=0) const

bool	hasPostprocessorByName (const PostprocessorName &name) const

std::size_t	coupledPostprocessors (const std::string &param_name) const

const PostprocessorName &	getPostprocessorName (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const

virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const

virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

Public Attributes
const ConsoleStream	_console

Protected Member Functions
void	checkIntegrity ()
	Checks whether the forward and adjoint systems are consistent. More...

virtual void	assembleAdjointSystem (SparseMatrix< Number > &matrix, const NumericVector< Number > &solution, NumericVector< Number > &rhs)
	Assembles adjoint system. More...

void	applyNodalBCs (SparseMatrix< Number > &matrix, const NumericVector< Number > &solution, NumericVector< Number > &rhs)
	Helper function for applying nodal BCs to the adjoint matrix and RHS. More...

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const

std::string	timedSectionName (const std::string &section_name) const

virtual void	addPostprocessorDependencyHelper (const PostprocessorName &) const

Protected Attributes
const unsigned int	_forward_sys_num
	The number of the nonlinear system representing the forward model. More...

const unsigned int	_adjoint_sys_num
	The number of the nonlinear system representing the adjoint model. More...

NonlinearSystemBase &	_nl_forward
	The nonlinear system representing the forward model. More...

NonlinearSystemBase &	_nl_adjoint
	The nonlinear system representing the adjoint model. More...

Executioner &	_executioner

FEProblemBase &	_problem

DisplacedProblem *	_displaced_problem

MooseMesh &	_mesh

MooseMesh *	_displaced_mesh

SystemBase &	_solver_sys

AuxiliarySystem &	_aux

SolveObject *	_inner_solve

const bool &	_enabled

MooseApp &	_app

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

MooseApp &	_pg_moose_app

const std::string	_prefix

const Parallel::Communicator &	_communicator

Detailed Description

The solve object is responsible for solving the adjoint version of a forward model.

It does this by solving a linear system with a transposed matrix and a source. The matrix is evaluated from the forward model's Jacobian, using the converged solution. The source is computed by evaluating the residual of a secondary nonlinear-system representing the adjoint system, in which the adjoint solution is 0.

Definition at line 31 of file AdjointSolve.h.

Constructor & Destructor Documentation

◆ AdjointSolve()

AdjointSolve::AdjointSolve ( Executioner & ex )

Definition at line 39 of file AdjointSolve.C.

   : SolveObject(ex),
     _forward_sys_num(
         _problem.nlSysNum(getParam<std::vector<SolverSystemName>>("forward_system")[0])),
     _adjoint_sys_num(_problem.nlSysNum(getParam<NonlinearSystemName>("adjoint_system"))),
     _nl_forward(_problem.getNonlinearSystemBase(_forward_sys_num)),
     _nl_adjoint(_problem.getNonlinearSystemBase(_adjoint_sys_num))
 {
   // Disallow vectors of systems
   if (getParam<std::vector<SolverSystemName>>("forward_system").size() != 1)
     paramError("forward_system",
                "Multiple nonlinear forward systems is not supported at the moment");
 
   // These should never be hit, but just in case
   if (!dynamic_cast<NonlinearSystem *>(&_nl_forward))
     paramError("forward_system", "Forward system does not appear to be a 'NonlinearSystem'.");
   if (!dynamic_cast<NonlinearSystem *>(&_nl_adjoint))
     paramError("adjoint_system", "Adjoint system does not appear to be a 'NonlinearSystem'.");
   // Adjoint system should never perform its own automatic scaling. Scaling factors from the forward
   // system are applied.
   _nl_adjoint.automaticScaling(false);
 
   // We need to force the forward system to have a scaling vector. This is
   // in case a user provides scaling for an individual variables but doesn't have any
   // AD objects.
   _nl_forward.addScalingVector();
 
   // Set the solver options for the adjoint system
   mooseAssert(_problem.numSolverSystems() > 1,
               "We should have forward and adjoint systems as evidenced by our initialization list");
   const auto prefix = _nl_adjoint.prefix();
   Moose::PetscSupport::storePetscOptions(_problem, prefix, ex);
   Moose::PetscSupport::setConvergedReasonFlags(_problem, prefix);
   // Set solver parameter prefix
   auto & solver_params = _problem.solverParams(_nl_adjoint.number());
   solver_params._prefix = prefix;
   solver_params._solver_sys_num = _nl_adjoint.number();
 }

Member Function Documentation

◆ applyNodalBCs()

void AdjointSolve::applyNodalBCs	(	SparseMatrix< Number > &	matrix,
		const NumericVector< Number > &	solution,
		NumericVector< Number > &	rhs
	)

protected

Helper function for applying nodal BCs to the adjoint matrix and RHS.

Say there is a BC setting the d-th DoF to a dirichlet condition on the forward problem. This basically sets the d-th column of the matrix to zero, the d-th entry of the matrix diagonal to one, and the d-th entry of the RHS to the solution passed in.

Parameters

matrix	The matrix whose columns are set to 0
solution	The solution to replace the entries of the RHS
rhs	The RHS to to replace with the solution

Definition at line 159 of file AdjointSolve.C.

Referenced by solve().

 {
   std::vector<dof_id_type> nbc_dofs;
   auto & nbc_warehouse = _nl_forward.getNodalBCWarehouse();
   if (nbc_warehouse.hasActiveObjects())
   {
     for (const auto & bnode : *_mesh.getBoundaryNodeRange())
     {
       BoundaryID boundary_id = bnode->_bnd_id;
       Node * node = bnode->_node;
 
       if (!nbc_warehouse.hasActiveBoundaryObjects(boundary_id) ||
           node->processor_id() != processor_id())
         continue;
 
       for (const auto & bc : nbc_warehouse.getActiveBoundaryObjects(boundary_id))
         if (bc->shouldApply())
           for (unsigned int c = 0; c < bc->variable().count(); ++c)
             nbc_dofs.push_back(node->dof_number(_forward_sys_num, bc->variable().number() + c, 0));
     }
 
     // Petsc has a nice interface for zeroing rows and columns, so we'll use it
     auto petsc_matrix = dynamic_cast<PetscMatrix<Number> *>(&matrix);
     auto petsc_solution = dynamic_cast<const PetscVector<Number> *>(&solution);
     auto petsc_rhs = dynamic_cast<PetscVector<Number> *>(&rhs);
     if (petsc_matrix && petsc_solution && petsc_rhs)
       LibmeshPetscCall(MatZeroRowsColumns(petsc_matrix->mat(),
                                           cast_int<PetscInt>(nbc_dofs.size()),
                                           numeric_petsc_cast(nbc_dofs.data()),
                                           1.0,
                                           petsc_solution->vec(),
                                           petsc_rhs->vec()));
     else
       mooseError("Using PETSc matrices and vectors is required for applying homogenized boundary "
                  "conditions.");
   }
 }

◆ assembleAdjointSystem()

void AdjointSolve::assembleAdjointSystem	(	SparseMatrix< Number > &	matrix,
		const NumericVector< Number > &	solution,
		NumericVector< Number > &	rhs
	)

protectedvirtual

Assembles adjoint system.

Parameters

matrix	Un-transposed matrix (will be transposed later in solver)
solution	Adjoint solution (basically the initial guess for the solver)
rhs	The adjoint source (i.e. -residual)

Reimplemented in AdjointTransientSolve.

Definition at line 145 of file AdjointSolve.C.

Referenced by AdjointTransientSolve::assembleAdjointSystem(), and solve().

 {
 
   _problem.computeJacobian(*_nl_forward.currentSolution(), matrix, _forward_sys_num);
 
   _problem.setCurrentNonlinearSystem(_adjoint_sys_num);
   _problem.computeResidualTag(*_nl_adjoint.currentSolution(), rhs, _nl_adjoint.nonTimeVectorTag());
 
   rhs.scale(-1.0);
 }

◆ checkIntegrity()

void AdjointSolve::checkIntegrity ( )

protected

Checks whether the forward and adjoint systems are consistent.

Definition at line 200 of file AdjointSolve.C.

Referenced by solve().

 {
   const auto adj_vars = _nl_adjoint.getVariables(0);
   for (const auto & adj_var : adj_vars)
     // If the user supplies any scaling factors for individual variables the
     // adjoint system won't be consistent.
     if (!absolute_fuzzy_equals(adj_var->scalingFactor(), 1.0))
       mooseError(
           "User cannot supply scaling factors for adjoint variables.   Adjoint system is scaled "
           "automatically by the forward system.");
 
   // This is to prevent automatic scaling of the adjoint system. Scaling is
   // taken from the forward system
   if (_nl_adjoint.hasVector("scaling_factors"))
     _nl_adjoint.removeVector("scaling_factors");
 
   // Main thing is that the number of dofs in each system is the same
   if (_nl_forward.system().n_dofs() != _nl_adjoint.system().n_dofs())
     mooseError(
         "The forward and adjoint systems do not seem to be the same size. This could be due to (1) "
         "the number of variables added to each system is not the same, (2) variables do not have "
         "consistent family/order, (3) variables do not have the same block restriction.");
 }

◆ solve()

bool AdjointSolve::solve ( )

overridevirtual

Solve the adjoint system with the following procedure:

Call the _inner_solve
Execute user-objects, auxkernels, and multiapps on ADJOINT_TIMESTEP_BEGIN
Assemble the adjoint system: 3a. Evaluate forward system Jacobian 3b. Evaluate adjoint system residual
Solve adjoint system by calling libMesh::linearSolver::adjoint_solve
Execute user-objects, auxkernels, and multiapps on ADJOINT_TIMESTEP_END

Returns: true Inner solve, multiapps, and adjoint solve all converged; false Inner solve, multiapps, or adjoint solve did not converge

Implements SolveObject.

Reimplemented in AdjointTransientSolve.

Definition at line 79 of file AdjointSolve.C.

Referenced by SteadyAndAdjoint::execute(), and AdjointTransientSolve::solve().

 {
   TIME_SECTION("execute", 1, "Executing adjoint problem", false);
 
   mooseAssert(!_inner_solve,
               "I don't see any code path in which this class winds up with an inner solve");
 
   // enforce PETSc options are passed to the adjoint solve as well, as set in the user file
   auto & petsc_options = _problem.getPetscOptions();
   auto & pars = _problem.solverParams(_nl_adjoint.number());
   Moose::PetscSupport::petscSetOptions(petsc_options, pars);
 
   _problem.execute(OptimizationAppTypes::EXEC_ADJOINT_TIMESTEP_BEGIN);
 
   if (!_problem.execMultiApps(OptimizationAppTypes::EXEC_ADJOINT_TIMESTEP_BEGIN))
   {
     _console << "MultiApps failed to converge on ADJOINT_TIMESTEP_BEGIN!" << std::endl;
     return false;
   }
   // Output results between the forward and adjoint solve.
   _problem.outputStep(OptimizationAppTypes::EXEC_ADJOINT_TIMESTEP_BEGIN);
 
   checkIntegrity();
 
   // Convenient references
   // Adjoint matrix, solution, and right-hand-side
   auto & matrix = static_cast<ImplicitSystem &>(_nl_forward.system()).get_system_matrix();
   auto & solution = _nl_adjoint.solution();
   auto & rhs = _nl_adjoint.getResidualNonTimeVector();
   // Linear solver parameters
   auto & es = _problem.es();
   const auto tol = es.parameters.get<Real>("linear solver tolerance");
   const auto maxits = es.parameters.get<unsigned int>("linear solver maximum iterations");
   // Linear solver for adjoint system
   auto & solver = *static_cast<ImplicitSystem &>(_nl_adjoint.system()).get_linear_solver();
 
   // Assemble adjoint system by evaluating the forward Jacobian, computing the adjoint
   // residual/source, and homogenizing nodal BCs
   assembleAdjointSystem(matrix, solution, rhs);
   applyNodalBCs(matrix, solution, rhs);
 
   // Solve the adjoint system
   solver.adjoint_solve(matrix, solution, rhs, tol, maxits);
 
   // For scaling of the forward problem we need to apply correction factor
   solution *= _nl_forward.getVector("scaling_factors");
 
   _nl_adjoint.update();
   if (solver.get_converged_reason() < 0)
   {
     _console << "Adjoint solve failed to converge with reason: "
              << Utility::enum_to_string(solver.get_converged_reason()) << std::endl;
     return false;
   }
 
   _problem.execute(OptimizationAppTypes::EXEC_ADJOINT_TIMESTEP_END);
   if (!_problem.execMultiApps(OptimizationAppTypes::EXEC_ADJOINT_TIMESTEP_END))
   {
     _console << "MultiApps failed to converge on ADJOINT_TIMESTEP_END!" << std::endl;
     return false;
   }
 
   return true;
 }

◆ validParams()

InputParameters AdjointSolve::validParams ( )

static

Definition at line 27 of file AdjointSolve.C.

Referenced by SteadyAndAdjoint::validParams(), and AdjointTransientSolve::validParams().

 {
   InputParameters params = emptyInputParameters();
   params.addRequiredParam<std::vector<SolverSystemName>>(
       "forward_system",
       "Name of the nonlinear system representing the forward problem. Multiple and linear solver "
       "systems are not currently supported.");
   params.addRequiredParam<NonlinearSystemName>(
       "adjoint_system", "Name of the system representing the adjoint problem.");
   return params;
 }

Member Data Documentation

◆ _adjoint_sys_num

const unsigned int AdjointSolve::_adjoint_sys_num

protected

The number of the nonlinear system representing the adjoint model.

Definition at line 88 of file AdjointSolve.h.

Referenced by assembleAdjointSystem().

◆ _forward_sys_num

const unsigned int AdjointSolve::_forward_sys_num

protected

The number of the nonlinear system representing the forward model.

Definition at line 86 of file AdjointSolve.h.

Referenced by applyNodalBCs(), assembleAdjointSystem(), and AdjointTransientSolve::evaluateTimeResidual().

◆ _nl_adjoint

NonlinearSystemBase& AdjointSolve::_nl_adjoint

protected

The nonlinear system representing the adjoint model.

Definition at line 92 of file AdjointSolve.h.

Referenced by AdjointSolve(), assembleAdjointSystem(), checkIntegrity(), AdjointTransientSolve::evaluateTimeResidual(), AdjointTransientSolve::insertForwardSolution(), AdjointTransientSolve::setForwardSolution(), AdjointTransientSolve::solve(), and solve().

◆ _nl_forward

NonlinearSystemBase& AdjointSolve::_nl_forward

protected

The nonlinear system representing the forward model.

Definition at line 90 of file AdjointSolve.h.

Referenced by AdjointSolve(), applyNodalBCs(), assembleAdjointSystem(), checkIntegrity(), AdjointTransientSolve::evaluateTimeResidual(), AdjointTransientSolve::insertForwardSolution(), AdjointTransientSolve::setForwardSolution(), and solve().

The documentation for this class was generated from the following files:

optimization/include/executioners/AdjointSolve.h
optimization/src/executioners/AdjointSolve.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ AdjointSolve()

Member Function Documentation

◆ applyNodalBCs()

◆ assembleAdjointSystem()

◆ checkIntegrity()

◆ solve()

◆ validParams()

Member Data Documentation

◆ _adjoint_sys_num

◆ _forward_sys_num

◆ _nl_adjoint

◆ _nl_forward