#include <AdjointTransientSolve.h>

Inheritance diagram for AdjointTransientSolve:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	AdjointTransientSolve (Executioner &ex)

virtual bool	solve () override
	Overriding parent class so the time-derivative residual is stored for the next time step. More...

void	insertForwardSolution (int tstep)
	This function should be called after every converged forward time step. More...

void	setForwardSolution (int tstep)
	Takes the previously saved forward solutions residing in the adjoint system and copies them to the available solution states in the forward systems. 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
virtual void	assembleAdjointSystem (SparseMatrix< Number > &matrix, const NumericVector< Number > &solution, NumericVector< Number > &rhs) override
	Overriding parent class so the previous time-derivative residual is added to the right-hand-side of the linear solve. More...

void	evaluateTimeResidual (const NumericVector< Number > &solution, NumericVector< Number > &residual)
	This evaluates the time part of the adjoint residual. More...

void	checkIntegrity ()
	Checks whether the forward and adjoint systems are consistent. 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

T &	declareRestartableData (const std::string &data_name, Args &&... args)

ManagedValue< T >	declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)

const T &	getRestartableData (const std::string &data_name) const

T &	declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)

T &	declareRecoverableData (const std::string &data_name, Args &&... args)

T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)

T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)

std::string	restartableName (const std::string &data_name) const

Static Protected Member Functions
static std::string	getForwardSolutionName (int tstep)
	Prescribed name of the forward solution at a specified time step. More...

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

MooseApp &	_restartable_app

const std::string	_restartable_system_name

const THREAD_ID	_restartable_tid

const bool	_restartable_read_only

Private Attributes
NumericVector< Number > &	_old_time_residual
	The residual contribution from previous adjoint solutions. More...

std::vector< std::string > &	_forward_solutions
	Name of the forward solution at each time step residing in the adjoint system. More...

Detailed Description

Transient adjoint solve object.

See also: TransientAndAdjoint for example usage. General algorithm:

Set forward initial conditions
Save the forward initial solution using insertForwardSolution(0)
for t_step = 1,...,num_step
Solve forward time step
Save forward solution using insertForwardSolution(t_step)
Set _old_time_residual = 0

for t_step = num_step,...,1
Set forward solution using setForwardSolution(t_step)
Solve adjoint time step: A* u* = b* + _old_time_residual
Evaluate time residual: _old_time_residual = A_t* u*

where A* is the transpose of the linearized forward operator at the specified timestep, u* is the adjoint solution, and A_t* is the transpose of the linearized forward time operator.

Definition at line 32 of file AdjointTransientSolve.h.

Constructor & Destructor Documentation

◆ AdjointTransientSolve()

AdjointTransientSolve::AdjointTransientSolve ( Executioner & ex )

Definition at line 28 of file AdjointTransientSolve.C.

   : AdjointSolve(ex),
     Restartable(this, "Executioners"),
     _old_time_residual(_nl_adjoint.getResidualTimeVector()),
     _forward_solutions(declareRecoverableData<std::vector<std::string>>("forward_solutions"))
 {
 }

Member Function Documentation

◆ applyNodalBCs()

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

protectedinherited

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 AdjointSolve::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 AdjointTransientSolve::assembleAdjointSystem	(	SparseMatrix< Number > &	matrix,
		const NumericVector< Number > &	solution,
		NumericVector< Number > &	rhs
	)

overrideprotectedvirtual

Overriding parent class so the previous time-derivative residual is added to the right-hand-side of the linear solve.

Reimplemented from AdjointSolve.

Definition at line 96 of file AdjointTransientSolve.C.

 {
   // Assemble the steady-state version of the adjoint problem
   AdjointSolve::assembleAdjointSystem(matrix, solution, rhs);
   // Add the contribution from old solutions
   rhs += _old_time_residual;
 }

◆ checkIntegrity()

void AdjointSolve::checkIntegrity ( )

protectedinherited

Checks whether the forward and adjoint systems are consistent.

Definition at line 200 of file AdjointSolve.C.

Referenced by AdjointSolve::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.");
 }

◆ evaluateTimeResidual()

void AdjointTransientSolve::evaluateTimeResidual	(	const NumericVector< Number > &	solution,
		NumericVector< Number > &	residual
	)

protected

This evaluates the time part of the adjoint residual.

This is used to accumulate the source contribution from previous adjoint time steps for the next adjoint time step. It works by evaluating the Jacobian of the time-derivative term on the forward system and multiplying the transpose by the current adjoint solution.

Parameters

solution	Current adjoint solution
residual	Vector to save the result into

Definition at line 107 of file AdjointTransientSolve.C.

Referenced by solve().

 {
   // This tag should exist, but the matrix might not necessarily be added
   auto time_matrix_tag = _problem.getMatrixTagID("TIME");
   // Use the adjoint system matrix to hold the time Jacobian
   auto & time_matrix = static_cast<ImplicitSystem &>(_nl_adjoint.system()).get_system_matrix();
 
   // Make sure we tell the problem which system we are evaluating
   _problem.setCurrentNonlinearSystem(_forward_sys_num);
   // Accumulate the time part of the Jacobian into the adjoint matrix
   _problem.computeJacobianTag(*_nl_forward.currentSolution(), time_matrix, time_matrix_tag);
 
   // Perform multiplication of the adjoint solution on the transpose of the time Jacobian
   residual.zero();
   residual.add_vector_transpose(solution, time_matrix);
 }

◆ getForwardSolutionName()

static std::string AdjointTransientSolve::getForwardSolutionName ( int tstep )

inlinestaticprotected

Prescribed name of the forward solution at a specified time step.

Parameters

tstep The forward time step

Returns: std::string The name of the vector representing the forward solution on the adjoint system

Definition at line 89 of file AdjointTransientSolve.h.

Referenced by insertForwardSolution().

   {
     return "forward_solution" + std::to_string(tstep);
   }

◆ insertForwardSolution()

void AdjointTransientSolve::insertForwardSolution ( int tstep )

This function should be called after every converged forward time step.

It adds a new vector (if necessary) to the adjoint system representing the forward solution at the given time step.

Parameters

tstep Time step of the forward solution in which to store in _forward_solutions

Definition at line 49 of file AdjointTransientSolve.C.

Referenced by TransientAndAdjoint::postStep(), and TransientAndAdjoint::preExecute().

 {
   // Time step should not be negative
   if (tstep < 0)
     mooseError("Negative time step occurred.");
   auto t_step = cast_int<std::size_t>(tstep); // Avoid compiler warnings
   // Should not be inserting a time greater the last one inserted
   if (t_step > _forward_solutions.size())
     mooseError("Trying to insert a solution at a time-step greater than one past the  previously "
                "inserted time step. Previous time step = ",
                (int)_forward_solutions.size() - 1,
                ", inserted time step = ",
                t_step,
                ".");
 
   // Add vector name to member variable if this time has not occurred
   if (t_step == _forward_solutions.size())
     _forward_solutions.push_back(getForwardSolutionName(tstep));
 
   // Get/add vector from/to adjoint system
   auto & solution = _nl_adjoint.addVector(_forward_solutions[t_step], false, PARALLEL);
 
   // Set the vector to the inserted solution
   solution = _nl_forward.solution();
 }

◆ setForwardSolution()

void AdjointTransientSolve::setForwardSolution ( int tstep )

Takes the previously saved forward solutions residing in the adjoint system and copies them to the available solution states in the forward systems.

This should be called at each adjoint time step.

Parameters

tstep The forward time step index being evaluated during the adjoint solve.

Definition at line 76 of file AdjointTransientSolve.C.

Referenced by TransientAndAdjoint::postExecute().

 {
   // Make sure the time step was saved
   if (tstep < 0 || tstep >= cast_int<int>(_forward_solutions.size()))
     mooseError("Could not find forward solution at time step ", tstep, ".");
   auto t_step = cast_int<std::size_t>(tstep); // Avoid compiler warnings
 
   // Copy the solutions to states that exist in the system
   unsigned int state = 0;
   while (_nl_forward.hasSolutionState(state))
   {
     const auto & name = t_step > state ? _forward_solutions[t_step - state] : _forward_solutions[0];
     _nl_forward.solutionState(state) = _nl_adjoint.getVector(name);
     state++;
   }
 
   _nl_forward.update();
 }

◆ solve()

bool AdjointTransientSolve::solve ( )

overridevirtual

Overriding parent class so the time-derivative residual is stored for the next time step.

Reimplemented from AdjointSolve.

Definition at line 37 of file AdjointTransientSolve.C.

Referenced by TransientAndAdjoint::postExecute().

 {
   bool converged = AdjointSolve::solve();
 
   // Gather the contribution of this timestep to add to the next solve's source
   if (converged)
     evaluateTimeResidual(_nl_adjoint.solution(), _old_time_residual);
 
   return converged;
 }

◆ validParams()

InputParameters AdjointTransientSolve::validParams ( )

static

Definition at line 22 of file AdjointTransientSolve.C.

Referenced by TransientAndAdjoint::validParams().

 {
   InputParameters params = AdjointSolve::validParams();
   return params;
 }

Member Data Documentation

◆ _adjoint_sys_num

const unsigned int AdjointSolve::_adjoint_sys_num

protectedinherited

The number of the nonlinear system representing the adjoint model.

Definition at line 88 of file AdjointSolve.h.

Referenced by AdjointSolve::assembleAdjointSystem().

◆ _forward_solutions

std::vector<std::string>& AdjointTransientSolve::_forward_solutions

private

Name of the forward solution at each time step residing in the adjoint system.

Definition at line 98 of file AdjointTransientSolve.h.

Referenced by insertForwardSolution(), and setForwardSolution().

◆ _forward_sys_num

const unsigned int AdjointSolve::_forward_sys_num

protectedinherited

The number of the nonlinear system representing the forward model.

Definition at line 86 of file AdjointSolve.h.

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

◆ _nl_adjoint

NonlinearSystemBase& AdjointSolve::_nl_adjoint

protectedinherited

The nonlinear system representing the adjoint model.

Definition at line 92 of file AdjointSolve.h.

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

◆ _nl_forward

NonlinearSystemBase& AdjointSolve::_nl_forward

protectedinherited

The nonlinear system representing the forward model.

Definition at line 90 of file AdjointSolve.h.

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

◆ _old_time_residual

NumericVector<Number>& AdjointTransientSolve::_old_time_residual

private

The residual contribution from previous adjoint solutions.

Definition at line 96 of file AdjointTransientSolve.h.

Referenced by assembleAdjointSystem(), and solve().

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

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

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ AdjointTransientSolve()

Member Function Documentation

◆ applyNodalBCs()

◆ assembleAdjointSystem()

◆ checkIntegrity()

◆ evaluateTimeResidual()

◆ getForwardSolutionName()

◆ insertForwardSolution()

◆ setForwardSolution()

◆ solve()

◆ validParams()

Member Data Documentation

◆ _adjoint_sys_num

◆ _forward_solutions

◆ _forward_sys_num

◆ _nl_adjoint

◆ _nl_forward

◆ _old_time_residual