#include <OptimizationFunctionInnerProductHelper.h>

Inheritance diagram for OptimizationFunctionInnerProductHelper:

Public Member Functions
	OptimizationFunctionInnerProductHelper (const InputParameters &parameters)

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
void	setCurrentTime (Real time, Real dt)
	This function sets up member variables for the inner product accumulation at certain time. More...

void	update (const Point &q_point, Real q_inner_product)
	Accumulates integration for inner product by multiplying the given value by the function's parameterGradient. More...

void	add (const OptimizationFunctionInnerProductHelper &other)
	Accumulates inner product integration in _curr_time_ip vector from another object. More...

void	getVector (std::vector< Real > &result)
	Gathers _curr_time_ip from other processors and performs time integration. More...

Private Attributes
FEProblemBase &	_ip_problem
	FEProblem used for getting system quantities. More...

const OptimizationFunction *const	_function
	Function used in optimization. More...

const Real &	_reverse_time_end
	The final time when we want to reverse the time index in function evaluation. More...

Real	_simulation_time
	Time the simulation is at. More...

Real	_actual_time
	Time the actual problem is at, defined by _reverse_time_end. More...

std::vector< std::pair< Real, std::vector< Real > > >	_time_ip
	Vector holding data for each time. More...

std::vector< Real > *	_curr_time_ip = nullptr
	Vector for current time. More...

Detailed Description

Definition at line 24 of file OptimizationFunctionInnerProductHelper.h.

Constructor & Destructor Documentation

◆ OptimizationFunctionInnerProductHelper()

OptimizationFunctionInnerProductHelper::OptimizationFunctionInnerProductHelper ( const InputParameters & parameters )

Definition at line 32 of file OptimizationFunctionInnerProductHelper.C.

   : _ip_problem(*parameters.getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")),
     _function(dynamic_cast<const OptimizationFunction *>(&_ip_problem.getFunction(
         parameters.get<FunctionName>("function"), parameters.get<THREAD_ID>("_tid")))),
     _reverse_time_end(parameters.get<Real>("reverse_time_end")),
     _simulation_time(_ip_problem.getMooseApp().getStartTime())
 {
   if (!_function)
     mooseError("Function requested by ",
                parameters.get<std::string>("_type"),
                " must be an OptimizationFunction.");
 }

Member Function Documentation

◆ add()

void OptimizationFunctionInnerProductHelper::add ( const OptimizationFunctionInnerProductHelper & other )

protected

Accumulates inner product integration in _curr_time_ip vector from another object.

This is used for thread joining.

Definition at line 79 of file OptimizationFunctionInnerProductHelper.C.

Referenced by ElementOptimizationFunctionInnerProduct::threadJoin(), and SideOptimizationFunctionInnerProduct::threadJoin().

 {
   _curr_time_ip->resize(std::max(_curr_time_ip->size(), other._curr_time_ip->size()), 0.0);
   for (const auto & i : index_range(*other._curr_time_ip))
     (*_curr_time_ip)[i] += (*other._curr_time_ip)[i];
 }

◆ getVector()

void OptimizationFunctionInnerProductHelper::getVector ( std::vector< Real > & result )

protected

Gathers _curr_time_ip from other processors and performs time integration.

Parameters

result Return vector of inner products

Definition at line 87 of file OptimizationFunctionInnerProductHelper.C.

Referenced by ElementOptimizationFunctionInnerProduct::finalize(), and SideOptimizationFunctionInnerProduct::finalize().

 {
   std::size_t nvar = _curr_time_ip->size();
   _ip_problem.comm().max(nvar);
   _curr_time_ip->resize(nvar, 0.0);
   _ip_problem.comm().sum(*_curr_time_ip);
 
   if (!_ip_problem.isTransient())
     result = (*_curr_time_ip);
   else
   {
     // Make sure everything is the same size
     for (const auto & it : _time_ip)
       nvar = std::max(nvar, it.second.size());
     for (auto & it : _time_ip)
       it.second.resize(nvar);
     result.assign(nvar, 0.0);
 
     // Integrate in time
     std::sort(_time_ip.begin(),
               _time_ip.end(),
               [](const std::pair<Real, std::vector<Real>> & a,
                  const std::pair<Real, std::vector<Real>> & b) { return a.first < b.first; });
     // We are integrating over the entire history here. Technically this can be done in an
     // accumulative manner by storing the integration over previous time steps. However, this
     // is a relatively cheap operation and considering all cases where time steps may be
     // repeated would be difficult.
     for (const auto & ti : _time_ip)
       for (const auto & i : make_range(nvar))
         result[i] += ti.second[i];
   }
 }

◆ setCurrentTime()

void OptimizationFunctionInnerProductHelper::setCurrentTime	(	Real	time,
		Real	dt
	)

protected

This function sets up member variables for the inner product accumulation at certain time.

The time step size is needed in order to calculate the actual simulation time (for adjoint calculations)

Parameters

time	Current simulation time, the actual time is computed via _reverse_time_end
dt	The current time step size

Definition at line 47 of file OptimizationFunctionInnerProductHelper.C.

Referenced by ElementOptimizationFunctionInnerProduct::initialize(), and SideOptimizationFunctionInnerProduct::initialize().

 {
   // We are saving the integral for each time step.
   // So create or grab the vector if the time has changed or this is our first time here.
   _curr_time_ip = nullptr;
   for (auto & pr : _time_ip)
     if (MooseUtils::relativeFuzzyEqual(time, pr.first))
       _curr_time_ip = &pr.second;
   if (!_curr_time_ip)
   {
     _time_ip.emplace_back(time, std::vector<Real>());
     _curr_time_ip = &_time_ip.back().second;
   }
   _curr_time_ip->clear();
 
   _actual_time =
       MooseUtils::absoluteFuzzyEqual(_reverse_time_end, 0.0) ? time : _reverse_time_end - time + dt;
 }

◆ update()

void OptimizationFunctionInnerProductHelper::update	(	const Point &	q_point,
		Real	q_inner_product
	)

protected

Accumulates integration for inner product by multiplying the given value by the function's parameterGradient.

Parameters

q_point	The quadrature point location
q_inner_product	The inner product value for the current quadrature point, which is multiplied by the function parameter gradient.

Definition at line 67 of file OptimizationFunctionInnerProductHelper.C.

Referenced by ElementOptimizationFunctionInnerProduct::execute(), and SideOptimizationFunctionInnerProduct::execute().

 {
   if (!_curr_time_ip)
     mooseError("Internal error, 'setCurrentTime' needs to be called before calling 'update'.");
 
   const std::vector<Real> pg = _function->parameterGradient(_actual_time, q_point);
   _curr_time_ip->resize(std::max(pg.size(), _curr_time_ip->size()), 0.0);
   for (const auto & i : index_range(pg))
     (*_curr_time_ip)[i] += q_inner_product * pg[i];
 }

◆ validParams()

InputParameters OptimizationFunctionInnerProductHelper::validParams ( )

static

Definition at line 21 of file OptimizationFunctionInnerProductHelper.C.

Referenced by ElementOptimizationFunctionInnerProduct::validParams(), and SideOptimizationFunctionInnerProduct::validParams().

 {
   InputParameters params = emptyInputParameters();
   params.addRequiredParam<FunctionName>("function", "Optimization function.");
   params.addParam<Real>(
       "reverse_time_end",
       0.0,
       "End time used for reversing the time integration when evaluating function derivative.");
   return params;
 }