Stores the Jacobian matrix for a code section. More...

#include <preaccumulationHelper.hpp>

Public Types
using	Gradient = typename Type::Gradient
	See LhsExpressionInterface.

using	Identifier = typename Type::Identifier
	See LhsExpressionInterface.

using	Position = typename Tape::Position
	See PositionalEvaluationTapeInterface.

using	Real = typename Type::Real
	See LhsExpressionInterface.

using	Tape = typename Type::Tape
	See LhsExpressionInterface.

using	Type = T_Type
	See PreaccumulationHelper.

Public Member Functions
template<typename... Inputs>
void	addInput (Inputs const &... inputs)
	Add multiple additional inputs. Inputs need to be of type `Type`. Called after start().

template<typename... Outputs>
void	addOutput (Outputs &... outputs)
	Add multiple additional outputs. Outputs need to be of type `Type`. Called before finish().

template<typename... Outputs>
void	finish (bool const storeAdjoints, Outputs &... outputs)

template<typename... Outputs>
void	finishLocalAdjoints (Outputs &... outputs)

template<typename... Outputs>
void	finishLocalAdjointVector (Outputs &... outputs)

template<typename... Outputs>
void	finishLocalAdjointVectorOffset (Outputs &... outputs)

template<typename... Outputs>
void	finishLocalAdjointVectorPreprocessTape (Outputs &... outputs)

template<typename... Outputs>
void	finishLocalMappedAdjoints (Outputs &... outputs)

	PreaccumulationHelper ()
	Constructor.

template<typename... Inputs>
void	start (Inputs const &... inputs)
	Starts a preaccumulation region. Resets the internal state. See `addInputs()` for inputs.

Public Attributes
std::vector< Identifier >	inputData

std::vector< Gradient >	localAdjoints

std::vector< Identifier >	outputData

std::vector< Type * >	outputValues

Protected Member Functions
template<typename Func, typename... Outputs>
void	finishInternal (Func &coreRoutine, Outputs &... outputs)
	Internal implementation of workflow for preaccumulation with local adjoints.

Protected Attributes
JacobianCountNonZerosRow< Real >	jacobian
	Jacobian for the preaccumulation.

Position	startPos
	Starting position for the region.

std::vector< Gradient >	storedAdjoints
	If adjoints of inputs should be stored, before the preaccumulation.

Detailed Description

template<typename T_Type, typename = void>
struct codi::PreaccumulationHelper< T_Type, typename >

Stores the Jacobian matrix for a code section.

The preaccumulation of a code section corresponds to the process of replacing the recorded tape entries with the Jacobian matrix of that section. If the code part is defined by the function , then the Jacobian $\frac{df}{dx}$ is computed by the Preaccumulation helper and stored on the tape.

The preaccumulation of a code part is beneficial if it is complicated to compute but has only a few inputs and outputs. If the computation requires 200 statements with a total of 600 arguments, the storage for this would be 7400 byte on a Jacobian tape. If the function has only two input arguments and two output arguments, the storage for the Jacobian matrix of this function would require 50 byte.

The procedure for the preaccumulation of a code section is as follows.

  Real A[4] = {u * 1.0, 0.5,
               0.0, u * -1.0};
  Real start[2] = {u * 10.0, u * 20.0};
  Real end[2];
 
  codi::PreaccumulationHelper<Real> ph;             // Step 1: Create the helper structure
  if(performPreAcc) {
    ph.start(start[0], start[1]);                   // Step 2: Start the preaccumulation region and specify inputs
    for(size_t i = 0; i < 4; ++i) {
      ph.addInput(A[i]);                            // Step 3: Add additional inputs (optional)
    }
  }
 
  ode(start, end, 1000, A, 1.0 / 1000.0, 2);        // Step 4: Evaluate the function/region for the accumulation in a normal way
 
  if(performPreAcc) {
    ph.addOutput(end[1]);                           // Step 5: Add additional outputs (optional)
    ph.finish(false, end[0]);                       // Step 6: Finish the preaccumulation region and specify outputs
  }
 
  Real w = sqrt(end[0] * end[0] + end[1] * end[1]);

The preaccumulation helper can be used multiple times, the start routine resets the state such that multiple evaluations are possible. This improves the performance of the helper since stack allocations are only performed once.

Template Parameters

T_Type The CoDiPack type on which the evaluations take place.

Member Function Documentation

◆ finish()

template<typename T_Type, typename = void>

template<typename... Outputs>

void codi::PreaccumulationHelper< T_Type, typename >::finish	(	bool const	storeAdjoints,
		Outputs &...	outputs )

inline

Finish the preaccumulation region and perform the preaccumulation. See addOutput() for outputs. Not compatible with simultaneous thread-local preaccumulations with shared inputs. In this case, see finishLocalMappedAdjoints, finishLocalAdjointVectorPreprocessTape, finishLocalAdjoints, finishLocalAdjointVector, and finishLocalAdjointVectorOffset.

◆ finishLocalAdjoints()

template<typename T_Type, typename = void>

template<typename... Outputs>

void codi::PreaccumulationHelper< T_Type, typename >::finishLocalAdjoints ( Outputs &... outputs )

inline

Finish the preaccumulation region and perform the preaccumulation. Uses local adjoints instead of adjoints from the tape. Behaves either like finishLocalMappedAdjoints or like finishLocalAdjointVectorPreprocessTape, depending on which is more efficient given the numbers of inputs and outputs. See addOutput() for outputs.

◆ finishLocalAdjointVector()

template<typename T_Type, typename = void>

template<typename... Outputs>

void codi::PreaccumulationHelper< T_Type, typename >::finishLocalAdjointVector ( Outputs &... outputs )

inline

Finish the preaccumulation region and perform the preaccumulation. Maintains a local adjoint vector that is as large as the global one. See addOutput() for outputs.

◆ finishLocalAdjointVectorOffset()

template<typename T_Type, typename = void>

template<typename... Outputs>

void codi::PreaccumulationHelper< T_Type, typename >::finishLocalAdjointVectorOffset ( Outputs &... outputs )

inline

Finish the preaccumulation region and perform the preaccumulation. Precomputes the identifier range used in the recording and creates a local adjoint vector, into which we address with an offset. Depends on tape editing features to preprocess identifiers. If tape editing is not supported, we fall back to the behaviour of finishLocalAdjointVector(). See addOutput() for outputs.

◆ finishLocalAdjointVectorPreprocessTape()

template<typename T_Type, typename = void>

template<typename... Outputs>

void codi::PreaccumulationHelper< T_Type, typename >::finishLocalAdjointVectorPreprocessTape ( Outputs &... outputs )

inline

Finish the preaccumulation region and perform the preaccumulation. Create a local adjoint vector instead of using adjoints from the tape. Edits the tape, remapping the identifiers to a contiguous range. More efficient than finishLocalMappedAdjoints if both the numbers of inputs and outputs are > 1. Behaves like finishLocalMappedAdjoints if the underlying tape does not support editing.

◆ finishLocalMappedAdjoints()

template<typename T_Type, typename = void>

template<typename... Outputs>

void codi::PreaccumulationHelper< T_Type, typename >::finishLocalMappedAdjoints ( Outputs &... outputs )

inline

Finish the preaccumulation region and perform the preaccumulation. Creates a local map of adjoints instead of using adjoints from the tape. See addOutput() for outputs.

Member Data Documentation

◆ inputData

template<typename T_Type, typename = void>

std::vector<Identifier> codi::PreaccumulationHelper< T_Type, typename >::inputData

List of input identifiers. Can be added manually after start() was called.

◆ localAdjoints

template<typename T_Type, typename = void>

std::vector<Gradient> codi::PreaccumulationHelper< T_Type, typename >::localAdjoints

Vector of local adjoint variables. Persists across preaccumulations to reduce the number of allocations, can be freed anytime if needed.

◆ outputData

template<typename T_Type, typename = void>

std::vector<Identifier> codi::PreaccumulationHelper< T_Type, typename >::outputData

List of output identifiers. Can be added manually before finish() is called. Has to be in sync with outputValues.

◆ outputValues

template<typename T_Type, typename = void>

std::vector<Type*> codi::PreaccumulationHelper< T_Type, typename >::outputValues

List of output value pointers. Can be added manually before finish() is called. Has to be in sync with outputData.

The documentation for this struct was generated from the following file:

include/codi/tools/helpers/preaccumulationHelper.hpp

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Member Function Documentation

◆ finish()

◆ finishLocalAdjoints()

◆ finishLocalAdjointVector()

◆ finishLocalAdjointVectorOffset()

◆ finishLocalAdjointVectorPreprocessTape()

◆ finishLocalMappedAdjoints()

Member Data Documentation

◆ inputData

◆ localAdjoints

◆ outputData

◆ outputValues