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:

virtual void	initialSetup ()

virtual void	setInnerSolve (SolveObject &solve)

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

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

bool	isKokkosObject () const

MooseApp &	getMooseApp () const

const std::string &	type () const

const std::string &	name () const

std::string	typeAndName () const

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

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () 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 &name) const

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

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

void	paramWarning (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

std::string	messagePrefix (const bool hit_prefix=true) const

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

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

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

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

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

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

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

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

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

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

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

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

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) 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 ()

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
static const std::string	type_param

static const std::string	name_param

static const std::string	unique_name_param

static const std::string	app_param

static const std::string	moose_base_param

static const std::string	kokkos_object_param

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

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

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

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

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.

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

NonlinearSystemBase &	_nl_forward
	The nonlinear system representing the forward model.

NonlinearSystemBase &	_nl_adjoint
	The nonlinear system representing the adjoint model.

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

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

MooseApp &	_pg_moose_app

const std::string	_prefix

const Parallel::Communicator &	_communicator

Private Member Functions
const PostprocessorName &	getPostprocessorNameInternal (const std::string &param_name, const unsigned int index, const bool allow_default_value=true) const

bool	isDefaultPostprocessorValueByName (const PostprocessorName &name) const

PostprocessorValue	getDefaultPostprocessorValueByName (const PostprocessorName &name) const

void	checkParam (const std::string &param_name, const unsigned int index=std::numeric_limits< unsigned int >::max()) const

bool	postprocessorsAdded () const

const PostprocessorValue &	getPostprocessorValueInternal (const std::string &param_name, unsigned int index, std::size_t t_index) const

const PostprocessorValue &	getPostprocessorValueInternal (const std::string &param_name, unsigned int index, std::size_t t_index) const

const PostprocessorValue &	getPostprocessorValueByNameInternal (const PostprocessorName &name, std::size_t t_index) const

const PostprocessorValue &	getPostprocessorValueByNameInternal (const PostprocessorName &name, std::size_t t_index) const

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)

static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)

Private Attributes
const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

const MooseObject &	_ppi_moose_object

const InputParameters &	_ppi_params

const FEProblemBase &	_ppi_feproblem

std::map< PostprocessorName, std::unique_ptr< PostprocessorValue > >	_default_values

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 38 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 163 of file AdjointSolve.C.

{
  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()),
                                          libMesh::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.");
  }
}

Referenced by solve().

◆ 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 149 of file AdjointSolve.C.

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

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

◆ checkIntegrity()

void AdjointSolve::checkIntegrity ( )

protected

Checks whether the forward and adjoint systems are consistent.

Definition at line 204 of file AdjointSolve.C.

{
  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 (!libMesh::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.");
}

Referenced by solve().

◆ 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 78 of file AdjointSolve.C.

{
  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 = cast_ref<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 = *cast_ref<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");
 
  // Hanging-node (and other DofMap) constraints are not applied by the raw transpose solve above,
  // which leaves constrained dofs at zero, so back-substitute them here. The vector being
  // constrained belongs to the adjoint system, not the forward system that owns the matrix.
  _nl_adjoint.system().get_dof_map().enforce_constraints_exactly(_nl_adjoint.system(), &solution);
 
  _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;
}

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

◆ validParams()

InputParameters AdjointSolve::validParams ( )

static

Definition at line 26 of file AdjointSolve.C.

{
  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;
}

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

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(), solve(), and AdjointTransientSolve::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

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Private 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