Class which provides a Proper Orthogonal Decomposition (POD)-based mapping between full-order and reduced-order spaces. More...

#include <PODMapping.h>

Inheritance diagram for PODMapping:

[legend]

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	PODMapping (const InputParameters &parameters)

virtual void	buildMapping (const VariableName &vname) override
	Abstract function for building mapping for a given variable. More...

void	map (const VariableName &vname, const DenseVector< Real > &full_order_vector, std::vector< Real > &reduced_order_vector) const override
	Method used for mapping full-order solutions for a given variable onto a latent space. More...

void	map (const VariableName &vname, const unsigned int global_sample_i, std::vector< Real > &reduced_order_vector) const override
	Method used for mapping full-order solutions for a given variable onto a latent space. More...

void	inverse_map (const VariableName &vname, const std::vector< Real > &reduced_order_vector, DenseVector< Real > &full_order_vector) const override
	Method used for mapping reduced-order solutions for a given variable onto the full-order space. More...

const std::vector< DenseVector< Real > > &	leftBasis (const VariableName &vname)
	Return all of the left basis functions for a given variable. More...

const std::vector< DenseVector< Real > > &	rightBasis (const VariableName &vname)
	Return all of the right basis functions for a given variable. More...

const std::vector< Real > &	singularValues (const VariableName &vname)
	Return all of the singular values for a given variable. More...

const DenseVector< Real > &	leftBasisFunction (const VariableName &vname, const unsigned int base_i)
	Get the `base_i`-th left basis function for a given variable. More...

const DenseVector< Real > &	rightBasisFunction (const VariableName &vname, const unsigned int base_i)
	Get the `base_i`-th right basis function for a given variable. More...

virtual const std::vector< VariableName > &	getVariableNames ()
	Get the available variable names in this mapping. More...

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

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

const std::string &	modelMetaDataName () const
	Accessor for the name of the model meta data. More...

const FileName &	getModelDataFileName () const
	Get the associated filename. More...

bool	hasModelData () const
	Check if we need to load model data (if the filename parameter is used) More...

UserObjectName	getUserObjectName (const std::string &param_name) const

const T &	getUserObject (const std::string &param_name, bool is_dependency=true) const

const T &	getUserObjectByName (const UserObjectName &object_name, bool is_dependency=true) const

const UserObject &	getUserObjectBase (const std::string &param_name, bool is_dependency=true) const

const UserObject &	getUserObjectBaseByName (const UserObjectName &object_name, bool is_dependency=true) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const


template<typename T , typename... Args>
T &	declareModelData (const std::string &data_name, Args &&... args)
	Declare model data for loading from file as well as restart. More...


template<typename T , typename... Args>
const T &	getModelData (const std::string &data_name, Args &&... args) const
	Retrieve model data from the interface. More...

Static Public Member Functions
static InputParameters	validParams ()

Public Attributes
const ConsoleStream	_console

Protected Member Functions
void	checkIfReadyToUse (const VariableName &libmesh_dbg_var(vname)) const
	Check if we have a mapping for the variable and if it is ready to be used. More...

virtual void	addUserObjectDependencyHelper (const UserObject &) const

Protected Attributes
const std::vector< dof_id_type >	_num_modes
	The number of modes which need to be computed. More...

const std::vector< Real > &	_energy_threshold
	The energy thresholds for truncation of the number of modes, defined by the user. More...

std::map< VariableName, std::vector< DenseVector< Real > > > &	_left_basis_functions
	Restartable container holding the basis functions for each variable. More...

std::map< VariableName, std::vector< DenseVector< Real > > > &	_right_basis_functions
	Restartable container holding the basis functions for each variable. More...

std::map< VariableName, std::vector< Real > > &	_singular_values
	Restartable container holding the singular values. More...

const std::string &	_extra_slepc_options
	Variable holding additional petsc options for the singular value solve. More...

const std::vector< VariableName > &	_variable_names
	Storage for the names of the variables this mapping can handle. More...

std::map< VariableName, bool > &	_mapping_ready_to_use
	Bool to decide if we already have the mapping built or not to make sure it is not computed multiple times unless the user requests it. More...

const bool &	_enabled

MooseApp &	_app

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

const Parallel::Communicator &	_communicator

Private Attributes
const ParallelSolutionStorage *const	_parallel_storage
	Link to the parallel storage which holds the solution fields that are used for the SVD. More...

const StochasticTools::POD	_pod
	The POD object which can be used to compute the basis functions/vectors. More...

Detailed Description

Class which provides a Proper Orthogonal Decomposition (POD)-based mapping between full-order and reduced-order spaces.

Definition at line 23 of file PODMapping.h.

Constructor & Destructor Documentation

◆ PODMapping()

PODMapping::PODMapping ( const InputParameters & parameters )

Definition at line 45 of file PODMapping.C.

   : VariableMappingBase(parameters),
     UserObjectInterface(this),
     _num_modes(isParamValid("num_modes_to_compute")
                    ? getParam<std::vector<dof_id_type>>("num_modes_to_compute")
                    : std::vector<dof_id_type>(_variable_names.size(), 1)),
     _energy_threshold(getParam<std::vector<Real>>("energy_threshold")),
     _left_basis_functions(declareModelData<std::map<VariableName, std::vector<DenseVector<Real>>>>(
         "left_basis_functions")),
     _right_basis_functions(declareModelData<std::map<VariableName, std::vector<DenseVector<Real>>>>(
         "right_basis_functions")),
     _singular_values(
         declareModelData<std::map<VariableName, std::vector<Real>>>("singular_values")),
     _extra_slepc_options(getParam<std::string>("extra_slepc_options")),
     _parallel_storage(isParamValid("solution_storage")
                           ? &getUserObject<ParallelSolutionStorage>("solution_storage")
                           : nullptr),
     _pod(StochasticTools::POD(_parallel_storage, _extra_slepc_options, _communicator))
 {
   if (!isParamValid("filename"))
   {
     if (_num_modes.size() != _variable_names.size())
       paramError("num_modes", "The number of modes should be defined for each variable!");
 
     for (const auto & mode : _num_modes)
       if (!mode)
         paramError("num_modes", "The number of modes should always be a positive integer!");
 
     if (_energy_threshold.size())
     {
       if (_energy_threshold.size() != _variable_names.size())
         paramError("energy_threshold",
                    "The energy thresholds should be defined for each variable!");
 
       for (const auto & threshold : _energy_threshold)
         if (threshold < 0 || threshold >= 1)
           paramError("energy_threshold",
                      "The energy thresholds should always be in the [0,1) range!");
     }
 
 #if PETSC_VERSION_LESS_THAN(3, 14, 0)
     mooseError("PODMapping is not supported with PETSc version below 3.14!");
 #else
     for (const auto & vname : _variable_names)
     {
       _singular_values.emplace(vname, std::vector<Real>());
       _left_basis_functions.emplace(vname, std::vector<DenseVector<Real>>());
       _right_basis_functions.emplace(vname, std::vector<DenseVector<Real>>());
       _mapping_ready_to_use.emplace(vname, false);
     }
 #endif
   }
 }

Member Function Documentation

◆ buildMapping()

void PODMapping::buildMapping ( const VariableName & vname )

overridevirtual

Abstract function for building mapping for a given variable.

Parameters

vname The name of the variable

Implements VariableMappingBase.

Definition at line 100 of file PODMapping.C.

Referenced by SingularTripletReporter::execute().

 {
 #if !PETSC_VERSION_LESS_THAN(3, 14, 0)
   if (!_parallel_storage)
     paramError(
         "solution_storage",
         "The parallel storage reporter is not supplied! We cannot build a mapping without data!");
 
   if (_mapping_ready_to_use.find(vname) != _mapping_ready_to_use.end() &&
       !_mapping_ready_to_use[vname])
   {
     auto it = std::find(_variable_names.begin(), _variable_names.end(), vname);
     mooseAssert(it != _variable_names.end(), "Variable " + vname + " is not in PODMapping!");
     unsigned int var_i = std::distance(_variable_names.begin(), it);
     // Clear storage containers for the basis functions and singular values.
     _left_basis_functions[vname].clear();
     _right_basis_functions[vname].clear();
     _singular_values[vname].clear();
     // Find the number of modes that we would want to compute
     std::size_t num_modes_compute = (std::size_t)_num_modes[var_i];
     // Find the first element that satisfies the threshold
     const Real threshold = (_energy_threshold.empty() ? 0.0 : _energy_threshold[var_i]) +
                            std::numeric_limits<Real>::epsilon();
     // Use POD class to compute for a variable
     _pod.computePOD(vname,
                     _left_basis_functions[vname],
                     _right_basis_functions[vname],
                     _singular_values[vname],
                     num_modes_compute,
                     threshold);
     _mapping_ready_to_use[vname] = true;
   }
 
 #endif
 }

◆ checkIfReadyToUse()

void VariableMappingBase::checkIfReadyToUse ( const VariableName & libmesh_dbg_varvname ) const

protectedinherited

Check if we have a mapping for the variable and if it is ready to be used.

Definition at line 37 of file VariableMappingBase.C.

Referenced by inverse_map(), leftBasis(), leftBasisFunction(), map(), rightBasis(), rightBasisFunction(), and singularValues().

 {
   mooseAssert(_mapping_ready_to_use.find(vname) != _mapping_ready_to_use.end() &&
                   _mapping_ready_to_use[vname],
               "The mapping for variable " + vname + "is not ready to use!");
 }

◆ declareModelData()

template<typename T , typename... Args>

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

inherited

Declare model data for loading from file as well as restart.

Definition at line 78 of file RestartableModelInterface.h.

 {
   return _model_restartable.declareRestartableData<T>(data_name, std::forward<Args>(args)...);
 }

◆ getModelData()

template<typename T , typename... Args>

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

inherited

Retrieve model data from the interface.

Definition at line 85 of file RestartableModelInterface.h.

 {
   return _model_restartable.getRestartableData<T>(data_name, std::forward<Args>(args)...);
 }

◆ getModelDataFileName()

const FileName & RestartableModelInterface::getModelDataFileName ( ) const

inherited

Get the associated filename.

Definition at line 33 of file RestartableModelInterface.C.

 {
   return _model_object.getParam<FileName>("filename");
 }

◆ getVariableNames()

virtual const std::vector<VariableName>& VariableMappingBase::getVariableNames ( )

inlinevirtualinherited

Get the available variable names in this mapping.

Definition at line 71 of file VariableMappingBase.h.

Referenced by SingularTripletReporter::initialSetup(), and InverseMapping::initialSetup().

71 { return _variable_names; }

VariableMappingBase::_variable_names

const std::vector< VariableName > & _variable_names

Storage for the names of the variables this mapping can handle.

Definition: VariableMappingBase.h:78

◆ hasModelData()

bool RestartableModelInterface::hasModelData ( ) const

inherited

Check if we need to load model data (if the filename parameter is used)

Definition at line 39 of file RestartableModelInterface.C.

 {
   return _model_object.isParamValid("filename");
 }

◆ inverse_map()

void PODMapping::inverse_map	(	const VariableName &	vname,
		const std::vector< Real > &	reduced_order_vector,
		DenseVector< Real > &	full_order_vector
	)		const

overridevirtual

Method used for mapping reduced-order solutions for a given variable onto the full-order space.

Parameters

vname	The name of the variable
reduced_order_vector	The coordinates in the latent space
full_order_vector	Storage for the reconstructed solution for the given variable

Implements VariableMappingBase.

Definition at line 181 of file PODMapping.C.

 {
   mooseAssert(std::find(_variable_names.begin(), _variable_names.end(), vname) !=
                   _variable_names.end(),
               "Variable " + vname + " is not in PODMapping!");
 
   checkIfReadyToUse(vname);
 
   if (reduced_order_vector.size() != _left_basis_functions[vname].size())
     mooseError("The number of supplied reduced-order coefficients (",
                reduced_order_vector.size(),
                ") is not the same as the number of basis functions (",
                _left_basis_functions[vname].size(),
                ") for variable ",
                vname,
                "!");
   // This zeros the DenseVector too
   full_order_vector.resize(_left_basis_functions[vname][0].size());
 
   for (auto base_i : index_range(reduced_order_vector))
     for (unsigned int dof_i = 0; dof_i < _left_basis_functions[vname][base_i].size(); ++dof_i)
       full_order_vector(dof_i) +=
           reduced_order_vector[base_i] * _left_basis_functions[vname][base_i](dof_i);
 }

◆ leftBasis()

const std::vector< DenseVector< Real > > & PODMapping::leftBasis ( const VariableName & vname )

Return all of the left basis functions for a given variable.

Parameters

vname The name of the variable.

Definition at line 241 of file PODMapping.C.

Referenced by SingularTripletReporter::execute().

 {
   checkIfReadyToUse(vname);
   if (_left_basis_functions.find(vname) == _left_basis_functions.end())
     mooseError("We are trying to access container for variable '",
                vname,
                "' but we don't have it in the POD mapping!");
   return _left_basis_functions[vname];
 }

◆ leftBasisFunction()

const DenseVector< Real > & PODMapping::leftBasisFunction	(	const VariableName &	vname,
		const unsigned int	base_i
	)

Get the base_i-th left basis function for a given variable.

Parameters

vname	The name of the variable
base_i	The index of the basis function

Definition at line 209 of file PODMapping.C.

 {
   mooseAssert(std::find(_variable_names.begin(), _variable_names.end(), vname) !=
                   _variable_names.end(),
               "Variable " + vname + " is not in PODMapping!");
 
   checkIfReadyToUse(vname);
 
   mooseAssert(base_i < _left_basis_functions[vname].size(),
               "The POD for " + vname + " only has " +
                   std::to_string(_left_basis_functions[vname].size()) + " left modes!");
 
   return _left_basis_functions[vname][base_i];
 }

◆ map() [1/2]

void PODMapping::map	(	const VariableName &	vname,
		const DenseVector< Real > &	full_order_vector,
		std::vector< Real > &	reduced_order_vector
	)		const

overridevirtual

Method used for mapping full-order solutions for a given variable onto a latent space.

Parameters

vname	The name of the variable
full_order_vector	Serialized vector of the solution field for the given variable
reduced_order_vector	Storage space for the coordinates in the latent space

Implements VariableMappingBase.

Definition at line 163 of file PODMapping.C.

 {
   checkIfReadyToUse(vname);
 
   mooseAssert(_left_basis_functions.find(vname) != _left_basis_functions.end(),
               "The bases for the requested variable are not available!");
 
   const auto & bases = _left_basis_functions[vname];
 
   reduced_order_vector.clear();
   reduced_order_vector.resize(bases.size());
   for (auto base_i : index_range(bases))
     reduced_order_vector[base_i] = bases[base_i].dot(full_order_vector);
 }

◆ map() [2/2]

void PODMapping::map	(	const VariableName &	vname,
		const unsigned int	global_sample_i,
		std::vector< Real > &	reduced_order_vector
	)		const

overridevirtual

Method used for mapping full-order solutions for a given variable onto a latent space.

Parameters

vname	The name of the variable
global_sample_i	The global index of the sample whose solution should be mapped into the latent space
reduced_order_vector	Storage space for the coordinates in the latent space

Implements VariableMappingBase.

Definition at line 141 of file PODMapping.C.

 {
   mooseAssert(_parallel_storage, "We need the parallel solution storage for this operation.");
   mooseAssert(_left_basis_functions.find(vname) != _left_basis_functions.end(),
               "The bases for the requested variable are not available!");
   checkIfReadyToUse(vname);
 
   // This takes the 0th snapshot because we only support steady-state simulations
   // at the moment.
   const auto & snapshot = _parallel_storage->getGlobalSample(global_sample_i, vname)[0];
 
   const auto & bases = _left_basis_functions[vname];
 
   reduced_order_vector.clear();
   reduced_order_vector.resize(bases.size());
   for (auto base_i : index_range(bases))
     reduced_order_vector[base_i] = bases[base_i].dot(snapshot);
 }

◆ modelMetaDataName()

const std::string& RestartableModelInterface::modelMetaDataName ( ) const

inlineinherited

Accessor for the name of the model meta data.

Definition at line 47 of file RestartableModelInterface.h.

Referenced by SurrogateTrainerOutput::output(), and MappingOutput::output().

47 { return _model_meta_data_name; }

RestartableModelInterface::_model_meta_data_name

const std::string _model_meta_data_name

The model meta data name.

Definition: RestartableModelInterface.h:61

◆ rightBasis()

const std::vector< DenseVector< Real > > & PODMapping::rightBasis ( const VariableName & vname )

Return all of the right basis functions for a given variable.

Parameters

vname The name of the variable.

Definition at line 252 of file PODMapping.C.

Referenced by SingularTripletReporter::execute().

 {
   checkIfReadyToUse(vname);
   if (_right_basis_functions.find(vname) == _right_basis_functions.end())
     mooseError("We are trying to access container for variable '",
                vname,
                "' but we don't have it in the POD mapping!");
   return _right_basis_functions[vname];
 }

◆ rightBasisFunction()

const DenseVector< Real > & PODMapping::rightBasisFunction	(	const VariableName &	vname,
		const unsigned int	base_i
	)

Get the base_i-th right basis function for a given variable.

Parameters

vname	The name of the variable
base_i	The index of the basis function

Definition at line 225 of file PODMapping.C.

 {
   mooseAssert(std::find(_variable_names.begin(), _variable_names.end(), vname) !=
                   _variable_names.end(),
               "Variable " + vname + " is not in PODMapping!");
 
   checkIfReadyToUse(vname);
 
   mooseAssert(base_i < _right_basis_functions[vname].size(),
               "The POD for " + vname + " only has " +
                   std::to_string(_right_basis_functions[vname].size()) + " right modes!");
 
   return _right_basis_functions[vname][base_i];
 }

◆ singularValues()

const std::vector< Real > & PODMapping::singularValues ( const VariableName & vname )

Return all of the singular values for a given variable.

Parameters

vname The name of the variable.

Definition at line 263 of file PODMapping.C.

Referenced by SingularTripletReporter::execute().

 {
   checkIfReadyToUse(vname);
   if (_singular_values.find(vname) == _singular_values.end())
     mooseError("We are trying to access container for variable '",
                vname,
                "' but we don't have it in the POD mapping!");
   return _singular_values[vname];
 }

◆ validParams()

InputParameters PODMapping::validParams ( )

static

Definition at line 18 of file PODMapping.C.

 {
   InputParameters params = VariableMappingBase::validParams();
   params.addClassDescription("Class which provides a Proper Orthogonal Decomposition-based mapping "
                              "between full-order and reduced-order spaces.");
   params.addParam<UserObjectName>(
       "solution_storage", "The name of the storage reporter where the snapshots are located.");
   params.addParam<std::vector<dof_id_type>>(
       "num_modes_to_compute",
       "The number of modes that this object should compute. "
       "Modes with 0 eigenvalues are filtered out, so the real number of modes "
       "might be lower than this. This is also used for setting the "
       "subspace sizes for distributed singular value solves. By default, the subspace used for the "
       "SVD is twice as big as the number of requested vectors. For more information see the SLEPc "
       "manual. If not specified, only one mode is computed per variable.");
   params.addParam<std::vector<Real>>(
       "energy_threshold",
       std::vector<Real>(),
       "The energy threshold for the automatic truncation of the number of modes. In general, the "
       "lower this number is the more information is retained about the system by keeping more POD "
       "modes.");
   params.addParam<std::string>("extra_slepc_options",
                                "",
                                "Additional options for the singular/eigenvalue solvers in SLEPc.");
   return params;
 }

Member Data Documentation

◆ _energy_threshold

const std::vector<Real>& PODMapping::_energy_threshold

protected

The energy thresholds for truncation of the number of modes, defined by the user.

Definition at line 104 of file PODMapping.h.

Referenced by buildMapping(), and PODMapping().

◆ _extra_slepc_options

const std::string& PODMapping::_extra_slepc_options

protected

Variable holding additional petsc options for the singular value solve.

Definition at line 116 of file PODMapping.h.

◆ _left_basis_functions

std::map<VariableName, std::vector<DenseVector<Real> > >& PODMapping::_left_basis_functions

protected

Restartable container holding the basis functions for each variable.

Definition at line 107 of file PODMapping.h.

Referenced by buildMapping(), inverse_map(), leftBasis(), leftBasisFunction(), map(), and PODMapping().

◆ _mapping_ready_to_use

std::map<VariableName, bool>& VariableMappingBase::_mapping_ready_to_use

protectedinherited

Bool to decide if we already have the mapping built or not to make sure it is not computed multiple times unless the user requests it.

Definition at line 82 of file VariableMappingBase.h.

Referenced by buildMapping(), VariableMappingBase::checkIfReadyToUse(), and PODMapping().

◆ _num_modes

const std::vector<dof_id_type> PODMapping::_num_modes

protected

The number of modes which need to be computed.

Definition at line 101 of file PODMapping.h.

Referenced by buildMapping(), and PODMapping().

◆ _parallel_storage

const ParallelSolutionStorage* const PODMapping::_parallel_storage

private

Link to the parallel storage which holds the solution fields that are used for the SVD.

Definition at line 120 of file PODMapping.h.

Referenced by buildMapping(), and map().

◆ _pod

const StochasticTools::POD PODMapping::_pod

private

The POD object which can be used to compute the basis functions/vectors.

Definition at line 123 of file PODMapping.h.

Referenced by buildMapping().

◆ _right_basis_functions

std::map<VariableName, std::vector<DenseVector<Real> > >& PODMapping::_right_basis_functions

protected

Restartable container holding the basis functions for each variable.

Definition at line 110 of file PODMapping.h.

Referenced by buildMapping(), PODMapping(), rightBasis(), and rightBasisFunction().

◆ _singular_values

std::map<VariableName, std::vector<Real> >& PODMapping::_singular_values

protected

Restartable container holding the singular values.

Definition at line 113 of file PODMapping.h.

Referenced by buildMapping(), PODMapping(), and singularValues().

◆ _variable_names

const std::vector<VariableName>& VariableMappingBase::_variable_names

protectedinherited

Storage for the names of the variables this mapping can handle.

Definition at line 78 of file VariableMappingBase.h.

Referenced by buildMapping(), VariableMappingBase::getVariableNames(), inverse_map(), leftBasisFunction(), PODMapping(), and rightBasisFunction().

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

stochastic_tools/include/variablemappings/PODMapping.h
stochastic_tools/src/variablemappings/PODMapping.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PODMapping()

Member Function Documentation

◆ buildMapping()

◆ checkIfReadyToUse()

◆ declareModelData()

◆ getModelData()

◆ getModelDataFileName()

◆ getVariableNames()

◆ hasModelData()

◆ inverse_map()

◆ leftBasis()

◆ leftBasisFunction()

◆ map() [1/2]

◆ map() [2/2]

◆ modelMetaDataName()

◆ rightBasis()

◆ rightBasisFunction()

◆ singularValues()

◆ validParams()

Member Data Documentation

◆ _energy_threshold

◆ _extra_slepc_options

◆ _left_basis_functions

◆ _mapping_ready_to_use

◆ _num_modes

◆ _parallel_storage

◆ _pod

◆ _right_basis_functions

◆ _singular_values

◆ _variable_names