libMesh::RBEIMEvaluation Class Reference

This class enables evaluation of an Empirical Interpolation Method (EIM) approximation. More...

#include <rb_eim_evaluation.h>

Inheritance diagram for libMesh::RBEIMEvaluation:

Public Types
enum	EimErrorIndicatorNormalization { RESIDUAL_TERMS, MAX_RHS }
	Here we store an enum that defines the type of EIM error indicator normalization that we use in get_eim_error_indicator(). More...
typedef std::map< dof_id_type, std::vector< std::vector< Number > > >	QpDataMap
	Type of the data structure used to map from (elem id) -> [n_vars][n_qp] data. More...
typedef std::map< std::pair< dof_id_type, unsigned int >, std::vector< std::vector< Number > > >	SideQpDataMap
	Type of the data structure used to map from (elem id, side index) -> [n_vars][n_qp] data. More...
typedef std::map< dof_id_type, std::vector< Number > >	NodeDataMap
	Type of the data structure used to map from (node id) -> [n_vars] data. More...

Public Member Functions
	RBEIMEvaluation (const Parallel::Communicator &comm)
	Constructor. More...
	RBEIMEvaluation (RBEIMEvaluation &&)=default
	Special functions. More...
	RBEIMEvaluation (const RBEIMEvaluation &)=delete
RBEIMEvaluation &	operator= (const RBEIMEvaluation &)=delete
RBEIMEvaluation &	operator= (RBEIMEvaluation &&)=default
virtual	~RBEIMEvaluation ()
virtual void	clear () override
	Clear this object. More...
void	resize_data_structures (const unsigned int Nmax)
	Resize the data structures for storing data associated with this object. More...
void	set_parametrized_function (std::unique_ptr< RBParametrizedFunction > pf)
	Set the parametrized function that we will approximate using the Empirical Interpolation Method. More...
RBParametrizedFunction &	get_parametrized_function ()
	Get a reference to the parametrized function. More...
const RBParametrizedFunction &	get_parametrized_function () const
	Get a const reference to the parametrized function. More...
DenseVector< Number >	rb_eim_solve (DenseVector< Number > &EIM_rhs)
	Calculate the EIM approximation for the given right-hand side vector EIM_rhs. More...
void	rb_eim_solves (const std::vector< RBParameters > &mus, unsigned int N)
	Perform rb_eim_solves at each mu in mus and store the results in _rb_eim_solutions. More...
void	initialize_interpolation_points_spatial_indices ()
	Initialize _interpolation_points_spatial_indices. More...
void	initialize_param_fn_spatial_indices ()
	The Online counterpart of initialize_interpolation_points_spatial_indices(). More...
unsigned int	get_n_basis_functions () const
	Return the current number of EIM basis functions. More...
unsigned int	get_n_interpolation_points () const
	Return the number of interpolation points. More...
void	set_n_basis_functions (unsigned int n_bfs)
	Set the number of basis functions. More...
void	decrement_vector (QpDataMap &v, const DenseVector< Number > &coeffs)
	Subtract coeffs[i]*basis_function[i] from v. More...
void	side_decrement_vector (SideQpDataMap &v, const DenseVector< Number > &coeffs)
	Same as decrement_vector() except for Side data. More...
void	node_decrement_vector (NodeDataMap &v, const DenseVector< Number > &coeffs)
	Same as decrement_vector() except for node data. More...
void	initialize_eim_theta_objects ()
	Build a vector of RBTheta objects that accesses the components of the RB_solution member variable of this RBEvaluation. More...
std::vector< std::unique_ptr< RBTheta > > &	get_eim_theta_objects ()
virtual std::unique_ptr< RBTheta >	build_eim_theta (unsigned int index)
	Build a theta object corresponding to EIM index index. More...
void	get_eim_basis_function_values_at_qps (unsigned int basis_function_index, dof_id_type elem_id, unsigned int var, std::vector< Number > &values) const
	Fill up values with the basis function values for basis function basis_function_index and variable var, at all quadrature points on element elem_id. More...
void	get_eim_basis_function_side_values_at_qps (unsigned int basis_function_index, dof_id_type elem_id, unsigned int side_index, unsigned int var, std::vector< Number > &values) const
	Same as get_eim_basis_function_values_at_qps() except for side data. More...
Number	get_eim_basis_function_node_local_value (unsigned int basis_function_index, dof_id_type node_id, unsigned int var) const
	Same as get_eim_basis_function_values_at_qps() except for node data. More...
Number	get_eim_basis_function_value (unsigned int basis_function_index, dof_id_type elem_id, unsigned int comp, unsigned int qp) const
	Same as above, except that we just return the value at the qp^th quadrature point. More...
Number	get_eim_basis_function_side_value (unsigned int basis_function_index, dof_id_type elem_id, unsigned int side_index, unsigned int comp, unsigned int qp) const
	Same as get_eim_basis_function_value() except for side data. More...
Number	get_eim_basis_function_node_value (unsigned int basis_function_index, dof_id_type node_id, unsigned int var) const
	Same as get_eim_basis_function_value() except for node data. More...
const QpDataMap &	get_basis_function (unsigned int i) const
	Get a reference to the i^th basis function. More...
const SideQpDataMap &	get_side_basis_function (unsigned int i) const
	Get a reference to the i^th side basis function. More...
const NodeDataMap &	get_node_basis_function (unsigned int i) const
	Get a reference to the i^th node basis function. More...
void	set_rb_eim_solutions (const std::vector< DenseVector< Number >> &rb_eim_solutions)
	Set _rb_eim_solutions. More...
const std::vector< DenseVector< Number > > &	get_rb_eim_solutions () const
	Return the EIM solution coefficients from the most recent call to rb_eim_solves(). More...
std::vector< Number >	get_rb_eim_solutions_entries (unsigned int index) const
	Return entry index for each solution in _rb_eim_solutions. More...
const std::vector< DenseVector< Number > > &	get_eim_solutions_for_training_set () const
	Return a const reference to the EIM solutions for the parameters in the training set. More...
std::vector< DenseVector< Number > > &	get_eim_solutions_for_training_set ()
	Return a writeable reference to the EIM solutions for the parameters in the training set. More...
const std::vector< Real > &	get_rb_eim_error_indicators () const
	Return the EIM error indicator values from the most recent call to rb_eim_solves(). More...
void	add_interpolation_points_xyz (Point p)
	Set the data associated with EIM interpolation points. More...
void	add_interpolation_points_comp (unsigned int comp)
void	add_interpolation_points_subdomain_id (subdomain_id_type sbd_id)
void	add_interpolation_points_boundary_id (boundary_id_type b_id)
void	add_interpolation_points_xyz_perturbations (const std::vector< Point > &perturbs)
void	add_interpolation_points_elem_id (dof_id_type elem_id)
void	add_interpolation_points_side_index (unsigned int side_index)
void	add_interpolation_points_node_id (dof_id_type node_id)
void	add_interpolation_points_qp (unsigned int qp)
void	add_interpolation_points_elem_type (ElemType elem_type)
void	add_interpolation_points_phi_i_qp (const std::vector< Real > &phi_i_qp)
void	add_interpolation_points_JxW_all_qp (const std::vector< Real > &JxW_all_qp)
void	add_interpolation_points_phi_i_all_qp (const std::vector< std::vector< Real >> &phi_i_all_qp)
void	add_interpolation_points_spatial_indices (const std::vector< unsigned int > &spatial_indices)
Point	get_interpolation_points_xyz (unsigned int index) const
	Get the data associated with EIM interpolation points. More...
unsigned int	get_interpolation_points_comp (unsigned int index) const
subdomain_id_type	get_interpolation_points_subdomain_id (unsigned int index) const
boundary_id_type	get_interpolation_points_boundary_id (unsigned int index) const
const std::vector< Point > &	get_interpolation_points_xyz_perturbations (unsigned int index) const
dof_id_type	get_interpolation_points_elem_id (unsigned int index) const
unsigned int	get_interpolation_points_side_index (unsigned int index) const
dof_id_type	get_interpolation_points_node_id (unsigned int index) const
unsigned int	get_interpolation_points_qp (unsigned int index) const
ElemType	get_interpolation_points_elem_type (unsigned int index) const
const std::vector< Real > &	get_interpolation_points_phi_i_qp (unsigned int index) const
const std::vector< Real > &	get_interpolation_points_JxW_all_qp (unsigned int index) const
const std::vector< std::vector< Real > > &	get_interpolation_points_phi_i_all_qp (unsigned int index) const
const std::vector< unsigned int > &	get_interpolation_points_spatial_indices (unsigned int index) const
unsigned int	get_n_interpolation_points_spatial_indices () const
	_interpolation_points_spatial_indices is optional data, so we need to be able to check how many _interpolation_points_spatial_indices values have actually been set since it may not match the number of interpolation points. More...
void	set_interpolation_matrix_entry (unsigned int i, unsigned int j, Number value)
	Set entry of the EIM interpolation matrix. More...
const DenseMatrix< Number > &	get_interpolation_matrix () const
	Get the EIM interpolation matrix. More...
void	add_basis_function (const QpDataMap &bf)
	Add bf to our EIM basis. More...
void	add_interpolation_data (Point p, unsigned int comp, dof_id_type elem_id, subdomain_id_type subdomain_id, unsigned int qp, const std::vector< Point > &perturbs, const std::vector< Real > &phi_i_qp, ElemType elem_type, const std::vector< Real > &JxW_all_qp, const std::vector< std::vector< Real >> &phi_i_all_qp)
	Add interpolation data associated with a new basis function. More...
void	add_side_basis_function (const SideQpDataMap &side_bf)
	Add side_bf to our EIM basis. More...
void	add_side_interpolation_data (Point p, unsigned int comp, dof_id_type elem_id, unsigned int side_index, subdomain_id_type subdomain_id, boundary_id_type boundary_id, unsigned int qp, const std::vector< Point > &perturbs, const std::vector< Real > &phi_i_qp)
	Add interpolation data associated with a new basis function. More...
void	add_node_basis_function (const NodeDataMap &node_bf)
	Add node_bf to our EIM basis. More...
void	add_node_interpolation_data (Point p, unsigned int comp, dof_id_type node_id, boundary_id_type boundary_id)
	Add interpolation data associated with a new basis function. More...
void	set_preserve_rb_eim_solutions (bool preserve_rb_eim_solutions)
	Set _preserve_rb_eim_solutions. More...
bool	get_preserve_rb_eim_solutions () const
	Get _preserve_rb_eim_solutions. More...
void	write_out_basis_functions (const std::string &directory_name="offline_data", bool write_binary_basis_functions=true)
	Write out all the basis functions to file. More...
void	read_in_basis_functions (const System &sys, const std::string &directory_name="offline_data", bool read_binary_basis_functions=true)
	Read in all the basis functions from file. More...
virtual void	project_qp_data_map_onto_system (System &sys, const QpDataMap &bf_data, const EIMVarGroupPlottingInfo &eim_vargroup)
	Project the specified variable of bf_data into the solution vector of System. More...
const std::vector< EIMVarGroupPlottingInfo > &	get_eim_vars_to_project_and_write () const
	Get _eim_vars_to_project_and_write. More...
void	write_out_projected_basis_functions (EquationSystems &es, const std::string &directory_name="offline_data")
	Project all basis functions using project_qp_data_map_onto_system() and then write out the resulting vectors. More...
const std::set< unsigned int > &	scale_components_in_enrichment () const
	Get _scale_components_in_enrichment. More...
virtual bool	use_eim_error_indicator () const
	Virtual function to indicate if we use the EIM error indicator in this case. More...
void	set_eim_error_indicator_active (bool is_active)
	Activate/decative the error indicator in EIM solves. More...
const DenseVector< Number > &	get_error_indicator_interpolation_row () const
	Get/set _extra_points_interpolation_matrix. More...
void	set_error_indicator_interpolation_row (const DenseVector< Number > &error_indicator_row)
std::pair< Real, Real >	get_eim_error_indicator (Number error_indicator_rhs, const DenseVector< Number > &eim_solution, const DenseVector< Number > &eim_rhs)
	Evaluates the EIM error indicator based on error_indicator_rhs, eim_solution, and _error_indicator_interpolation_row. More...
const VectorizedEvalInput &	get_vec_eval_input () const
	Get the VectorizedEvalInput data. More...
void	initialize_parameters (const RBParameters &mu_min_in, const RBParameters &mu_max_in, const std::map< std::string, std::vector< Real >> &discrete_parameter_values)
	Initialize the parameter ranges and set current_parameters. More...
void	initialize_parameters (const RBParametrized &rb_parametrized)
	Initialize the parameter ranges and set current_parameters. More...
unsigned int	get_n_params () const
	Get the number of parameters. More...
unsigned int	get_n_continuous_params () const
	Get the number of continuous parameters. More...
unsigned int	get_n_discrete_params () const
	Get the number of discrete parameters. More...
std::set< std::string >	get_parameter_names () const
	Get a set that stores the parameter names. More...
const RBParameters &	get_parameters () const
	Get the current parameters. More...
bool	set_parameters (const RBParameters &params)
	Set the current parameters to params The parameters are checked for validity; an error is thrown if the number of parameters or samples is different than expected. More...
const RBParameters &	get_parameters_min () const
	Get an RBParameters object that specifies the minimum allowable value for each parameter. More...
const RBParameters &	get_parameters_max () const
	Get an RBParameters object that specifies the maximum allowable value for each parameter. More...
Real	get_parameter_min (const std::string &param_name) const
	Get minimum allowable value of parameter param_name. More...
Real	get_parameter_max (const std::string &param_name) const
	Get maximum allowable value of parameter param_name. More...
void	print_parameters () const
	Print the current parameters. More...
void	write_parameter_data_to_files (const std::string &continuous_param_file_name, const std::string &discrete_param_file_name, const bool write_binary_data)
	Write out the parameter ranges to files. More...
void	read_parameter_data_from_files (const std::string &continuous_param_file_name, const std::string &discrete_param_file_name, const bool read_binary_data)
	Read in the parameter ranges from files. More...
bool	is_discrete_parameter (const std::string &mu_name) const
	Is parameter mu_name discrete? More...
const std::map< std::string, std::vector< Real > > &	get_discrete_parameter_values () const
	Get a const reference to the discrete parameter values. More...
void	print_discrete_parameter_values () const
	Print out all the discrete parameter values. More...
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

Static Public Member Functions
static void	get_parametrized_function_values_at_qps (const QpDataMap &pf, dof_id_type elem_id, unsigned int comp, std::vector< Number > &values)
	Fill up values by evaluating the parametrized function pf for all quadrature points on element elem_id and component comp. More...
static void	get_parametrized_function_side_values_at_qps (const SideQpDataMap &pf, dof_id_type elem_id, unsigned int side_index, unsigned int comp, std::vector< Number > &values)
	Same as get_parametrized_function_values_at_qps() except for side data. More...
static Number	get_parametrized_function_node_local_value (const NodeDataMap &pf, dof_id_type node_id, unsigned int comp)
	Same as get_parametrized_function_values_at_qps() except for node data. More...
static Number	get_parametrized_function_value (const Parallel::Communicator &comm, const QpDataMap &pf, dof_id_type elem_id, unsigned int comp, unsigned int qp)
	Same as above, except that we just return the value at the qp^th quadrature point. More...
static Number	get_parametrized_function_side_value (const Parallel::Communicator &comm, const SideQpDataMap &pf, dof_id_type elem_id, unsigned int side_index, unsigned int comp, unsigned int qp)
	Same as get_parametrized_function_value() except for side data. More...
static Number	get_parametrized_function_node_value (const Parallel::Communicator &comm, const NodeDataMap &pf, dof_id_type node_id, unsigned int comp)
	Same as get_parametrized_function_value() except for node data. More...
static Real	get_closest_value (Real value, const std::vector< Real > &list_of_values)
static std::string	get_info ()
	Gets a string containing the reference information. More...
static void	print_info (std::ostream &out_stream=libMesh::out)
	Prints the reference information, by default to libMesh::out. More...
static unsigned int	n_objects ()
	Prints the number of outstanding (created, but not yet destroyed) objects. More...
static void	enable_print_counter_info ()
	Methods to enable/disable the reference counter output from print_info() More...
static void	disable_print_counter_info ()

Public Attributes
EimErrorIndicatorNormalization	eim_error_indicator_normalization
bool	verbose_mode
	Public boolean to toggle verbose mode. More...

Protected Types
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts
	Data structure to log the information. More...

Protected Member Functions
void	increment_constructor_count (const std::string &name) noexcept
	Increments the construction counter. More...
void	increment_destructor_count (const std::string &name) noexcept
	Increments the destruction counter. More...

Protected Attributes
std::vector< EIMVarGroupPlottingInfo >	_eim_vars_to_project_and_write
	This vector specifies which EIM variables will be projected and written out in write_out_projected_basis_functions(). More...
std::set< unsigned int >	_scale_components_in_enrichment
	This set that specifies which EIM variables will be scaled during EIM enrichment so that their maximum value matches the maximum value across all variables. More...
const Parallel::Communicator &	_communicator

Static Protected Attributes
static Counts	_counts
	Actually holds the data. More...
static Threads::atomic< unsigned int >	_n_objects
	The number of objects. More...
static Threads::spin_mutex	_mutex
	Mutual exclusion object to enable thread-safe reference counting. More...
static bool	_enable_print_counter = true
	Flag to control whether reference count information is printed when print_info is called. More...

Private Member Functions
void	write_out_interior_basis_functions (const std::string &directory_name, bool write_binary_basis_functions)
	Method that writes out element interior EIM basis functions. More...
void	write_out_side_basis_functions (const std::string &directory_name, bool write_binary_basis_functions)
	Method that writes out element side EIM basis functions. More...
void	write_out_node_basis_functions (const std::string &directory_name, bool write_binary_basis_functions)
	Method that writes out element node EIM basis functions. More...
void	read_in_interior_basis_functions (const System &sys, const std::string &directory_name, bool read_binary_basis_functions)
	Method that reads in element interior EIM basis functions. More...
void	read_in_side_basis_functions (const System &sys, const std::string &directory_name, bool read_binary_basis_functions)
	Method that reads in element side EIM basis functions. More...
void	read_in_node_basis_functions (const System &sys, const std::string &directory_name, bool read_binary_basis_functions)
	Method that reads in element node EIM basis functions. More...
void	print_local_eim_basis_functions () const
	Print the contents of _local_eim_basis_functions to libMesh::out. More...
void	gather_bfs ()
	Helper function that gathers the contents of _local_eim_basis_functions to processor 0 in preparation for printing to file. More...
void	side_gather_bfs ()
	Same as gather_bfs() except for side data. More...
void	node_gather_bfs ()
	Same as gather_bfs() except for node data. More...
void	distribute_bfs (const System &sys)
	Helper function that distributes the entries of _local_eim_basis_functions to their respective processors after they are read in on processor 0. More...
void	side_distribute_bfs (const System &sys)
	Same as distribute_bfs() except for side data. More...
void	node_distribute_bfs (const System &sys)
	Same as distribute_bfs() except for node data. More...

Private Attributes
std::vector< DenseVector< Number > >	_rb_eim_solutions
	The EIM solution coefficients from the most recent call to rb_eim_solves(). More...
std::vector< Real >	_rb_eim_error_indicators
	If we're using the EIM error indicator, then we store the error indicator values corresponding to _rb_eim_solutions here. More...
std::vector< DenseVector< Number > >	_eim_solutions_for_training_set
	Storage for EIM solutions from the training set. More...
std::vector< RBParameters >	_rb_eim_solves_mus
	The parameters and the number of basis functions that were used in the most recent call to rb_eim_solves(). More...
unsigned int	_rb_eim_solves_N
DenseMatrix< Number >	_interpolation_matrix
	Dense matrix that stores the lower triangular interpolation matrix that can be used. More...
VectorizedEvalInput	_vec_eval_input
	We store the EIM interpolation point data in this object. More...
std::vector< unsigned int >	_interpolation_points_comp
	In the case of a "vector-valued" EIM, this vector determines which component of the parameterized function we sample at each EIM point. More...
std::vector< std::vector< unsigned int > >	_interpolation_points_spatial_indices
	Here we store the spatial indices that were initialized by initialize_spatial_indices_at_interp_pts(). More...
std::unique_ptr< RBParametrizedFunction >	_parametrized_function
	Store the parametrized function that will be approximated by this EIM system. More...
std::vector< std::unique_ptr< RBTheta > >	_rb_eim_theta_objects
	The vector of RBTheta objects that are created to point to this RBEIMEvaluation. More...
std::vector< QpDataMap >	_local_eim_basis_functions
	The EIM basis functions. More...
std::vector< SideQpDataMap >	_local_side_eim_basis_functions
	The EIM basis functions on element sides. More...
std::vector< NodeDataMap >	_local_node_eim_basis_functions
	The EIM basis functions on element nodes (e.g. More...
bool	_preserve_rb_eim_solutions
	Boolean to indicate if we skip updating _rb_eim_solutions in rb_eim_solves(). More...
bool	_is_eim_error_indicator_active
	Indicate if the EIM error indicator is active in RB EIM solves. More...
DenseVector< Number >	_error_indicator_interpolation_row
	Here we store an extra row of the interpolation matrix which is used to compute the EIM error indicator. More...

Detailed Description

This class enables evaluation of an Empirical Interpolation Method (EIM) approximation.

RBEvaluation plays an analogous role in the context of the regular reduced basis method.

Definition at line 90 of file rb_eim_evaluation.h.

Member Typedef Documentation

Counts

typedef std::map<std::string, std::pair<unsigned int, unsigned int> > libMesh::ReferenceCounter::Counts

protectedinherited

Data structure to log the information.

The log is identified by the class name.

Definition at line 119 of file reference_counter.h.

NodeDataMap

typedef std::map<dof_id_type, std::vector<Number> > libMesh::RBEIMEvaluation::NodeDataMap

Type of the data structure used to map from (node id) -> [n_vars] data.

Definition at line 125 of file rb_eim_evaluation.h.

QpDataMap

typedef std::map<dof_id_type, std::vector<std::vector<Number> > > libMesh::RBEIMEvaluation::QpDataMap

Type of the data structure used to map from (elem id) -> [n_vars][n_qp] data.

Definition at line 115 of file rb_eim_evaluation.h.

SideQpDataMap

typedef std::map<std::pair<dof_id_type,unsigned int>, std::vector<std::vector<Number> > > libMesh::RBEIMEvaluation::SideQpDataMap

Type of the data structure used to map from (elem id, side index) -> [n_vars][n_qp] data.

Definition at line 120 of file rb_eim_evaluation.h.

Member Enumeration Documentation

EimErrorIndicatorNormalization

enum libMesh::RBEIMEvaluation::EimErrorIndicatorNormalization

Here we store an enum that defines the type of EIM error indicator normalization that we use in get_eim_error_indicator().

The enum is public so that it can be set in user code.

RESIDUAL_TERMS: Use the terms in the EIM residual to determine the error indicator normalization (default).

MAX_RHS: Use the maximum value in the EIM RHS vector to determine the error indicator normalization.

Enumerator
RESIDUAL_TERMS
MAX_RHS

Definition at line 634 of file rb_eim_evaluation.h.

{ RESIDUAL_TERMS, MAX_RHS };

Constructor & Destructor Documentation

RBEIMEvaluation() [1/3]

RBEIMEvaluation::RBEIMEvaluation

(

const Parallel::Communicator &

comm

)

Constructor.

Definition at line 48 of file rb_eim_evaluation.C.

:
ParallelObject(comm),
eim_error_indicator_normalization(RBEIMEvaluation::RESIDUAL_TERMS),
_rb_eim_solves_N(0),
_preserve_rb_eim_solutions(false),
_is_eim_error_indicator_active(false)
{
}

RBEIMEvaluation() [2/3]

libMesh::RBEIMEvaluation::RBEIMEvaluation ( RBEIMEvaluation &&  )

default

Special functions.

• This class contains unique_ptrs, so it can't be default copy constructed/assigned.
• The destructor is defaulted out of line.

RBEIMEvaluation() [3/3]

libMesh::RBEIMEvaluation::RBEIMEvaluation ( const RBEIMEvaluation &  )

delete

~RBEIMEvaluation()

RBEIMEvaluation::~RBEIMEvaluation ( )

virtualdefault

Member Function Documentation

add_basis_function()

void RBEIMEvaluation::add_basis_function

(

const QpDataMap &

bf

)

Add bf to our EIM basis.

Definition at line 893 of file rb_eim_evaluation.C.

References _local_eim_basis_functions.

Referenced by libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors().

{
  _local_eim_basis_functions.emplace_back(bf);
}

add_interpolation_data()

void RBEIMEvaluation::add_interpolation_data	(	Point	p,
		unsigned int	comp,
		dof_id_type	elem_id,
		subdomain_id_type	subdomain_id,
		unsigned int	qp,
		const std::vector< Point > &	perturbs,
		const std::vector< Real > &	phi_i_qp,
		ElemType	elem_type,
		const std::vector< Real > &	JxW_all_qp,
		const std::vector< std::vector< Real >> &	phi_i_all_qp
	)

Add interpolation data associated with a new basis function.

Definition at line 899 of file rb_eim_evaluation.C.

References _interpolation_points_comp, _vec_eval_input, libMesh::VectorizedEvalInput::all_xyz, libMesh::VectorizedEvalInput::all_xyz_perturb, libMesh::VectorizedEvalInput::elem_ids, libMesh::VectorizedEvalInput::elem_types, libMesh::VectorizedEvalInput::JxW_all_qp, libMesh::VectorizedEvalInput::phi_i_all_qp, libMesh::VectorizedEvalInput::phi_i_qp, libMesh::VectorizedEvalInput::qps, and libMesh::VectorizedEvalInput::sbd_ids.

Referenced by libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors().

{
  _vec_eval_input.all_xyz.emplace_back(p);
  _interpolation_points_comp.emplace_back(comp);
  _vec_eval_input.elem_ids.emplace_back(elem_id);
  _vec_eval_input.sbd_ids.emplace_back(subdomain_id);
  _vec_eval_input.qps.emplace_back(qp);
  _vec_eval_input.all_xyz_perturb.emplace_back(perturbs);
  _vec_eval_input.phi_i_qp.emplace_back(phi_i_qp);
  _vec_eval_input.elem_types.emplace_back(elem_type);
  _vec_eval_input.JxW_all_qp.emplace_back(JxW_all_qp);
  _vec_eval_input.phi_i_all_qp.emplace_back(phi_i_all_qp);
}

add_interpolation_points_boundary_id()

void RBEIMEvaluation::add_interpolation_points_boundary_id

(

boundary_id_type

b_id

)

Definition at line 712 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::boundary_ids.

Referenced by libMesh::RBDataDeserialization::load_rb_eim_evaluation_data().

{
  _vec_eval_input.boundary_ids.emplace_back(b_id);
}

add_interpolation_points_comp()

void RBEIMEvaluation::add_interpolation_points_comp

(

unsigned int

comp

)

Definition at line 702 of file rb_eim_evaluation.C.

References _interpolation_points_comp.

Referenced by libMesh::RBDataDeserialization::load_rb_eim_evaluation_data().

{
  _interpolation_points_comp.emplace_back(comp);
}

add_interpolation_points_elem_id()

void RBEIMEvaluation::add_interpolation_points_elem_id

(

dof_id_type

elem_id

)

Definition at line 722 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::elem_ids.

Referenced by libMesh::RBDataDeserialization::load_rb_eim_evaluation_data().

{
  _vec_eval_input.elem_ids.emplace_back(elem_id);
}

add_interpolation_points_elem_type()

void RBEIMEvaluation::add_interpolation_points_elem_type

(

ElemType

elem_type

)

Definition at line 742 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::elem_types.

Referenced by libMesh::RBDataDeserialization::load_rb_eim_evaluation_data().

{
  _vec_eval_input.elem_types.emplace_back(elem_type);
}

add_interpolation_points_JxW_all_qp()

void RBEIMEvaluation::add_interpolation_points_JxW_all_qp

(

const std::vector< Real > &

JxW_all_qp

)

Definition at line 747 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::JxW_all_qp.

Referenced by libMesh::RBDataDeserialization::load_rb_eim_evaluation_data().

{
  _vec_eval_input.JxW_all_qp.emplace_back(JxW_all_qp);
}

add_interpolation_points_node_id()

void RBEIMEvaluation::add_interpolation_points_node_id

(

dof_id_type

node_id

)

Definition at line 732 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::node_ids.

Referenced by libMesh::RBDataDeserialization::load_rb_eim_evaluation_data().

{
  _vec_eval_input.node_ids.emplace_back(node_id);
}

add_interpolation_points_phi_i_all_qp()

void RBEIMEvaluation::add_interpolation_points_phi_i_all_qp

(

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

phi_i_all_qp

)

Definition at line 752 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::phi_i_all_qp.

Referenced by libMesh::RBDataDeserialization::load_rb_eim_evaluation_data().

{
  _vec_eval_input.phi_i_all_qp.emplace_back(phi_i_all_qp);
}

add_interpolation_points_phi_i_qp()

void RBEIMEvaluation::add_interpolation_points_phi_i_qp

(

const std::vector< Real > &

phi_i_qp

)

Definition at line 757 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::phi_i_qp.

Referenced by libMesh::RBDataDeserialization::load_rb_eim_evaluation_data().

{
  _vec_eval_input.phi_i_qp.emplace_back(phi_i_qp);
}

add_interpolation_points_qp()

void RBEIMEvaluation::add_interpolation_points_qp

(

unsigned int

qp

)

Definition at line 737 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::qps.

Referenced by libMesh::RBDataDeserialization::load_rb_eim_evaluation_data().

{
  _vec_eval_input.qps.emplace_back(qp);
}

add_interpolation_points_side_index()

void RBEIMEvaluation::add_interpolation_points_side_index

(

unsigned int

side_index

)

Definition at line 727 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::side_indices.

Referenced by libMesh::RBDataDeserialization::load_rb_eim_evaluation_data().

{
  _vec_eval_input.side_indices.emplace_back(side_index);
}

add_interpolation_points_spatial_indices()

void RBEIMEvaluation::add_interpolation_points_spatial_indices

(

const std::vector< unsigned int > &

spatial_indices

)

Definition at line 762 of file rb_eim_evaluation.C.

References _interpolation_points_spatial_indices.

Referenced by libMesh::RBDataDeserialization::load_rb_eim_evaluation_data().

{
  _interpolation_points_spatial_indices.emplace_back(spatial_indices);
}

add_interpolation_points_subdomain_id()

void RBEIMEvaluation::add_interpolation_points_subdomain_id

(

subdomain_id_type

sbd_id

)

Definition at line 707 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::sbd_ids.

Referenced by libMesh::RBDataDeserialization::load_rb_eim_evaluation_data().

{
  _vec_eval_input.sbd_ids.emplace_back(sbd_id);
}

add_interpolation_points_xyz()

void RBEIMEvaluation::add_interpolation_points_xyz

(

Point

p

)

Set the data associated with EIM interpolation points.

Definition at line 697 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::all_xyz.

Referenced by libMesh::RBDataDeserialization::load_rb_eim_evaluation_data().

{
  _vec_eval_input.all_xyz.emplace_back(p);
}

add_interpolation_points_xyz_perturbations()

void RBEIMEvaluation::add_interpolation_points_xyz_perturbations

(

const std::vector< Point > &

perturbs

)

Definition at line 717 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::all_xyz_perturb.

Referenced by libMesh::RBDataDeserialization::load_rb_eim_evaluation_data().

{
  _vec_eval_input.all_xyz_perturb.emplace_back(perturbs);
}

add_node_basis_function()

void RBEIMEvaluation::add_node_basis_function

(

const NodeDataMap &

node_bf

)

Add node_bf to our EIM basis.

Definition at line 957 of file rb_eim_evaluation.C.

References _local_node_eim_basis_functions.

Referenced by libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes().

{
  _local_node_eim_basis_functions.emplace_back(node_bf);
}

add_node_interpolation_data()

void RBEIMEvaluation::add_node_interpolation_data	(	Point	p,
		unsigned int	comp,
		dof_id_type	node_id,
		boundary_id_type	boundary_id
	)

Add interpolation data associated with a new basis function.

Definition at line 963 of file rb_eim_evaluation.C.

References _interpolation_points_comp, _vec_eval_input, libMesh::VectorizedEvalInput::all_xyz, libMesh::VectorizedEvalInput::all_xyz_perturb, libMesh::VectorizedEvalInput::boundary_ids, libMesh::VectorizedEvalInput::elem_ids, libMesh::VectorizedEvalInput::elem_types, libMesh::INVALID_ELEM, libMesh::VectorizedEvalInput::JxW_all_qp, libMesh::VectorizedEvalInput::node_ids, libMesh::VectorizedEvalInput::phi_i_all_qp, libMesh::VectorizedEvalInput::phi_i_qp, libMesh::VectorizedEvalInput::qps, libMesh::VectorizedEvalInput::sbd_ids, and libMesh::VectorizedEvalInput::side_indices.

Referenced by libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes().

{
  _vec_eval_input.all_xyz.emplace_back(p);
  _interpolation_points_comp.emplace_back(comp);
  _vec_eval_input.node_ids.emplace_back(node_id);
  _vec_eval_input.boundary_ids.emplace_back(boundary_id);

  // Add dummy values for the other properties, which are unused in the
  // node case.
  _vec_eval_input.elem_ids.emplace_back(0);
  _vec_eval_input.side_indices.emplace_back(0);
  _vec_eval_input.sbd_ids.emplace_back(0);
  _vec_eval_input.qps.emplace_back(0);
  _vec_eval_input.all_xyz_perturb.emplace_back();
  _vec_eval_input.phi_i_qp.emplace_back();
  _vec_eval_input.elem_types.emplace_back(INVALID_ELEM);
  _vec_eval_input.JxW_all_qp.emplace_back();
  _vec_eval_input.phi_i_all_qp.emplace_back();
}

add_side_basis_function()

void RBEIMEvaluation::add_side_basis_function

(

const SideQpDataMap &

side_bf

)

Add side_bf to our EIM basis.

Definition at line 923 of file rb_eim_evaluation.C.

References _local_side_eim_basis_functions.

Referenced by libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides().

{
  _local_side_eim_basis_functions.emplace_back(side_bf);
}

add_side_interpolation_data()

void RBEIMEvaluation::add_side_interpolation_data	(	Point	p,
		unsigned int	comp,
		dof_id_type	elem_id,
		unsigned int	side_index,
		subdomain_id_type	subdomain_id,
		boundary_id_type	boundary_id,
		unsigned int	qp,
		const std::vector< Point > &	perturbs,
		const std::vector< Real > &	phi_i_qp
	)

Add interpolation data associated with a new basis function.

Definition at line 929 of file rb_eim_evaluation.C.

References _interpolation_points_comp, _vec_eval_input, libMesh::VectorizedEvalInput::all_xyz, libMesh::VectorizedEvalInput::all_xyz_perturb, libMesh::VectorizedEvalInput::boundary_ids, libMesh::VectorizedEvalInput::elem_ids, libMesh::VectorizedEvalInput::elem_types, libMesh::INVALID_ELEM, libMesh::VectorizedEvalInput::JxW_all_qp, libMesh::VectorizedEvalInput::phi_i_all_qp, libMesh::VectorizedEvalInput::phi_i_qp, libMesh::VectorizedEvalInput::qps, libMesh::VectorizedEvalInput::sbd_ids, and libMesh::VectorizedEvalInput::side_indices.

Referenced by libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides().

{
  _vec_eval_input.all_xyz.emplace_back(p);
  _interpolation_points_comp.emplace_back(comp);
  _vec_eval_input.elem_ids.emplace_back(elem_id);
  _vec_eval_input.side_indices.emplace_back(side_index);
  _vec_eval_input.sbd_ids.emplace_back(subdomain_id);
  _vec_eval_input.boundary_ids.emplace_back(boundary_id);
  _vec_eval_input.qps.emplace_back(qp);
  _vec_eval_input.all_xyz_perturb.emplace_back(perturbs);
  _vec_eval_input.phi_i_qp.emplace_back(phi_i_qp);

  // Add dummy values for the other properties, which are unused in the
  // node case.
  _vec_eval_input.elem_types.emplace_back(INVALID_ELEM);
  _vec_eval_input.JxW_all_qp.emplace_back();
  _vec_eval_input.phi_i_all_qp.emplace_back();
}

build_eim_theta()

std::unique_ptr< RBTheta > RBEIMEvaluation::build_eim_theta ( unsigned int  index )

virtual

Build a theta object corresponding to EIM index index.

The default implementation builds an RBEIMTheta object, possibly override in subclasses if we need more specialized behavior.

Definition at line 418 of file rb_eim_evaluation.C.

Referenced by initialize_eim_theta_objects().

{
  return std::make_unique<RBEIMTheta>(*this, index);
}

clear()

void RBEIMEvaluation::clear ( )

overridevirtual

Clear this object.

Reimplemented from libMesh::RBParametrized.

Definition at line 60 of file rb_eim_evaluation.C.

References _interpolation_matrix, _interpolation_points_comp, _interpolation_points_spatial_indices, _rb_eim_theta_objects, _vec_eval_input, libMesh::VectorizedEvalInput::clear(), and libMesh::DenseMatrix< T >::resize().

Referenced by distribute_bfs(), node_distribute_bfs(), and side_distribute_bfs().

{
  _vec_eval_input.clear();

  _interpolation_points_comp.clear();
  _interpolation_points_spatial_indices.clear();


  _interpolation_matrix.resize(0,0);

  // Delete any RBTheta objects that were created
  _rb_eim_theta_objects.clear();
}

comm()

const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const

inlineinherited

Returns

A reference to the Parallel::Communicator object used by this mesh.

Definition at line 97 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_tao_equality_constraints(), libMesh::__libmesh_tao_equality_constraints_jacobian(), libMesh::__libmesh_tao_gradient(), libMesh::__libmesh_tao_hessian(), libMesh::__libmesh_tao_inequality_constraints(), libMesh::__libmesh_tao_inequality_constraints_jacobian(), libMesh::__libmesh_tao_objective(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult_add(), libMesh::MeshRefinement::_refine_elements(), libMesh::MeshRefinement::_smooth_flags(), libMesh::DofMap::add_constraints_to_send_list(), add_cube_convex_hull_to_mesh(), libMesh::PetscDMWrapper::add_dofs_helper(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::EigenSystem::add_matrices(), libMesh::System::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::System::add_variable(), libMesh::System::add_variables(), libMesh::System::add_vector(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::assemble_affine_expansion(), libMesh::FEMSystem::assemble_qoi(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::MeshCommunication::assign_global_indices(), libMesh::Partitioner::assign_partitioning(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::PetscDMWrapper::build_section(), libMesh::PetscDMWrapper::build_sf(), libMesh::MeshBase::cache_elem_data(), libMesh::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::RBConstruction::compute_output_dual_innerprods(), libMesh::RBConstruction::compute_residual_dual_norm_slow(), libMesh::RBSCMConstruction::compute_SCM_bounds_on_training_set(), libMesh::DofMap::computed_sparsity_already(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::ContinuationSystem::ContinuationSystem(), libMesh::MeshBase::copy_constraint_rows(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshTools::create_bounding_box(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshTools::create_nodal_bounding_box(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::MeshTools::create_subdomain_bounding_box(), libMesh::PetscMatrix< libMesh::Number >::create_submatrix_nosort(), libMesh::MeshCommunication::delete_remote_elements(), distribute_bfs(), libMesh::DofMap::distribute_dofs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::DTKSolutionTransfer::DTKSolutionTransfer(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::EpetraVector< T >::EpetraVector(), AssembleOptimization::equality_constraints(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_error_tolerance(), libMesh::MeshRefinement::flag_elements_by_mean_stddev(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), gather_bfs(), libMesh::DofMap::gather_constraints(), libMesh::MeshfreeInterpolation::gather_remote_data(), libMesh::CondensedEigenSystem::get_eigenpair(), get_eim_basis_function_node_value(), get_eim_basis_function_side_value(), get_eim_basis_function_value(), libMesh::MeshBase::get_info(), libMesh::System::get_info(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::RBEIMConstruction::get_max_abs_value(), libMesh::RBEIMConstruction::get_node_max_abs_value(), get_parametrized_function_node_value(), get_parametrized_function_side_value(), get_parametrized_function_value(), libMesh::RBEIMConstruction::get_random_point(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::LocationMap< T >::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::RBEIMConstruction::initialize_parametrized_functions_in_training_set(), libMesh::RBEIMConstruction::inner_product(), integrate_function(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_equal_connectivity(), libMesh::MeshTools::libmesh_assert_equal_points(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::libmesh_petsc_linesearch_shellfunc(), libMesh::libmesh_petsc_preconditioner_apply(), libMesh::libmesh_petsc_recalculate_monitor(), libMesh::libmesh_petsc_snes_fd_residual(), libMesh::libmesh_petsc_snes_jacobian(), libMesh::libmesh_petsc_snes_mffd_interface(), libMesh::libmesh_petsc_snes_mffd_residual(), libMesh::libmesh_petsc_snes_postcheck(), libMesh::libmesh_petsc_snes_precheck(), libMesh::libmesh_petsc_snes_residual(), libMesh::libmesh_petsc_snes_residual_helper(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), libMesh::LinearImplicitSystem::LinearImplicitSystem(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_new_nodes_parallel_consistent(), libMesh::MeshCommunication::make_node_bcids_parallel_consistent(), libMesh::MeshCommunication::make_node_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_unique_ids_parallel_consistent(), libMesh::MeshCommunication::make_nodes_parallel_consistent(), libMesh::MeshCommunication::make_p_levels_parallel_consistent(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::FEMSystem::mesh_position_set(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), LinearElasticityWithContact::move_mesh(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::DofMap::n_constrained_dofs(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), MixedOrderTest::n_neighbor_links(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::SparsityPattern::Build::n_nonzeros(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), node_distribute_bfs(), node_gather_bfs(), libMesh::RBEIMConstruction::node_inner_product(), libMesh::MeshBase::operator==(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::ReplicatedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::MeshTools::paranoid_n_levels(), libMesh::Partitioner::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::petsc_auto_fieldsplit(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Partitioner::processor_pairs_to_interface_nodes(), libMesh::InterMeshProjection::project_system_vectors(), FEMParameters::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO::read_header(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), read_in_interior_basis_functions(), read_in_node_basis_functions(), read_in_side_basis_functions(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::System::read_legacy_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), LinearElasticityWithContact::residual_and_jacobian(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), scale_mesh_and_plot(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::send_and_insert_dof_values(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::Partitioner::set_interface_node_processor_ids_BFS(), libMesh::Partitioner::set_interface_node_processor_ids_linear(), libMesh::Partitioner::set_interface_node_processor_ids_petscpartitioner(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::PetscDiffSolver::setup_petsc_data(), side_distribute_bfs(), side_gather_bfs(), libMesh::RBEIMConstruction::side_inner_product(), libMesh::Partitioner::single_partition(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::split_mesh(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), libMesh::MeshRefinement::test_level_one(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), libMesh::MeshRefinement::test_unflagged(), DofMapTest::testBadElemFECombo(), SystemsTest::testBlockRestrictedVarNDofs(), BoundaryInfoTest::testBoundaryOnChildrenErrors(), ConstraintOperatorTest::testCoreform(), MeshInputTest::testExodusIGASidesets(), MeshTriangulationTest::testFoundCenters(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), PointLocatorTest::testPlanar(), MeshTriangulationTest::testPoly2TriRefinementBase(), SystemsTest::testProjectCubeWithMeshFunction(), BoundaryInfoTest::testRenumber(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshTriangulationTest::testTriangulatorInterp(), MeshTriangulationTest::testTriangulatorMeshedHoles(), MeshTriangulationTest::testTriangulatorRoundHole(), libMesh::MeshTools::total_weight(), libMesh::RBConstruction::train_reduced_basis_with_POD(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::Poly2TriTriangulator::triangulate(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_assembly(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::VTKIO::write_nodal_data(), write_out_interior_basis_functions(), write_out_node_basis_functions(), write_out_side_basis_functions(), libMesh::RBEvaluation::write_out_vectors(), libMesh::TransientRBConstruction::write_riesz_representors_to_files(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::RBDataSerialization::RBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::TransientRBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::RBEIMEvaluationSerialization::write_to_file(), and libMesh::RBDataSerialization::RBSCMEvaluationSerialization::write_to_file().

  { return _communicator; }

decrement_vector()

void RBEIMEvaluation::decrement_vector	(	QpDataMap &	v,
		const DenseVector< Number > &	coeffs
	)

Subtract coeffs[i]*basis_function[i] from v.

Definition at line 329 of file rb_eim_evaluation.C.

References _local_eim_basis_functions, get_n_basis_functions(), libMesh::index_range(), and libMesh::DenseVector< T >::size().

Referenced by libMesh::RBEIMConstruction::compute_max_eim_error(), and libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors().

{
  LOG_SCOPE("decrement_vector()", "RBEIMEvaluation");

  libmesh_error_msg_if(get_n_basis_functions() != coeffs.size(),
                       "Error: Number of coefficients should match number of basis functions");

  for (auto & [elem_id, v_comp_and_qp] : v)
    {
      for (const auto & comp : index_range(v_comp_and_qp))
        for (unsigned int qp : index_range(v_comp_and_qp[comp]))
          for (unsigned int i : index_range(_local_eim_basis_functions))
            {
              // Check that entry (elem_id,comp,qp) exists in _local_eim_basis_functions so that
              // we get a clear error message if there is any missing data
              const auto & basis_comp_and_qp = libmesh_map_find(_local_eim_basis_functions[i], elem_id);

              libmesh_error_msg_if(comp >= basis_comp_and_qp.size(), "Error: Invalid comp");
              libmesh_error_msg_if(qp >= basis_comp_and_qp[comp].size(), "Error: Invalid qp");

              v_comp_and_qp[comp][qp] -= coeffs(i) * basis_comp_and_qp[comp][qp];
            }
    }
}

disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

{
  _enable_print_counter = false;
  return;
}

distribute_bfs()

void RBEIMEvaluation::distribute_bfs ( const System &  sys )

private

Helper function that distributes the entries of _local_eim_basis_functions to their respective processors after they are read in on processor 0.

Definition at line 2103 of file rb_eim_evaluation.C.

References _local_eim_basis_functions, TIMPI::Communicator::broadcast(), clear(), libMesh::ParallelObject::comm(), TIMPI::Communicator::gather(), libMesh::System::get_mesh(), libMesh::index_range(), libMesh::make_range(), mesh, n_vars, TIMPI::Communicator::rank(), TIMPI::Communicator::scatter(), and TIMPI::Communicator::size().

Referenced by read_in_interior_basis_functions().

{
  // So we can avoid calling these many times below
  auto n_procs = sys.comm().size();
  auto rank = sys.comm().rank();

  // In serial there's nothing to distribute
  if (n_procs == 1)
    return;

  // Broadcast the number of basis functions from proc 0. After
  // distributing, all procs should have the same number of basis
  // functions.
  auto n_bf = _local_eim_basis_functions.size();
  sys.comm().broadcast(n_bf);

  // Allocate enough space to store n_bf basis functions on non-zero ranks
  if (rank != 0)
    _local_eim_basis_functions.resize(n_bf);

  // Broadcast the number of variables from proc 0. After
  // distributing, all procs should have the same number of variables.
  auto n_vars = _local_eim_basis_functions[0].begin()->second.size();
  sys.comm().broadcast(n_vars);

  // Construct lists of elem ids owned by different processors
  const MeshBase & mesh = sys.get_mesh();

  std::vector<dof_id_type> gathered_local_elem_ids;
  gathered_local_elem_ids.reserve(mesh.n_elem());
  for (const auto & elem : mesh.active_local_element_ptr_range())
    gathered_local_elem_ids.push_back(elem->id());

  // I _think_ the local elem ids are likely to already be sorted in
  // ascending order, since that is how they are stored on the Mesh,
  // but we can always just guarantee this to be on the safe side as
  // well.
  std::sort(gathered_local_elem_ids.begin(), gathered_local_elem_ids.end());

  // Gather the number of local elems from all procs to proc 0
  auto n_local_elems = gathered_local_elem_ids.size();
  std::vector<std::size_t> gathered_n_local_elems = {n_local_elems};
  sys.comm().gather(/*root_id=*/0, gathered_n_local_elems);

  // Gather the elem ids owned by each processor onto processor 0.
  sys.comm().gather(/*root_id=*/0, gathered_local_elem_ids);

  // Construct vectors of "start" and "one-past-the-end" indices into
  // the gathered_local_elem_ids vector for each proc. Only valid on
  // processor 0.
  std::vector<std::size_t> start_elem_ids_index, end_elem_ids_index;

  if (rank == 0)
    {
      start_elem_ids_index.resize(n_procs);
      start_elem_ids_index[0] = 0;
      for (processor_id_type p=1; p<n_procs; ++p)
        start_elem_ids_index[p] = start_elem_ids_index[p-1] + gathered_n_local_elems[p-1];

      end_elem_ids_index.resize(n_procs);
      end_elem_ids_index[n_procs - 1] = gathered_local_elem_ids.size();
      for (processor_id_type p=0; p<n_procs - 1; ++p)
        end_elem_ids_index[p] = start_elem_ids_index[p+1];
    }

  // On processor 0, using basis function 0 and variable 0, prepare a
  // vector with the number of qps per Elem.  Then scatter this vector
  // out to the processors that require it. The order of this vector
  // matches the gathered_local_elem_ids ordering. The counts will be
  // gathered_n_local_elems, since there will be one qp count per Elem.
  std::vector<unsigned int> n_qp_per_elem_data;

  // On rank 0, the "counts" vector holds the number of floating point values that
  // are to be scattered to each proc. It is only required on proc 0.
  std::vector<int> counts;

  if (rank == 0)
    {
      n_qp_per_elem_data.reserve(gathered_local_elem_ids.size());
      counts.resize(n_procs);

      auto & bf_map = _local_eim_basis_functions[0];

      for (processor_id_type p=0; p<n_procs; ++p)
        {
          for (auto e : make_range(start_elem_ids_index[p], end_elem_ids_index[p]))
            {
              auto elem_id = gathered_local_elem_ids[e];

              // Get reference to array[n_vars][n_qp] for current Elem.
              // Throws an error if the required elem_id is not found.
              const auto & array = libmesh_map_find(bf_map, elem_id);

              auto n_qps = array[0].size();

              // We use var==0 to set the number of qps for all vars
              n_qp_per_elem_data.push_back(n_qps);

              // Accumulate the count for this proc
              counts[p] += n_qps;
            } // end for (e)
        } // end for proc_id
    } // if (rank == 0)

  // Now scatter the n_qp_per_elem_data to all procs (must call the
  // scatter on all procs, it is a collective).
  {
    std::vector<unsigned int> recv;
    std::vector<int> tmp(gathered_n_local_elems.begin(), gathered_n_local_elems.end());
    sys.comm().scatter(n_qp_per_elem_data, tmp, recv, /*root_id=*/0);

    // Now swap n_qp_per_elem_data and recv. All processors now have a
    // vector of length n_local_elems containing the number of
    // quadarature points per Elem.
    n_qp_per_elem_data.swap(recv);
  }

  // For each basis function and each variable, build a vector
  // of qp data in the Elem ordering given by the
  // gathered_local_elem_ids, then call
  //
  // sys.comm().scatter(data, counts, recv, /*root_id=*/0);
  std::vector<std::vector<Number>> qp_data(n_vars);
  if (rank == 0)
    {
      // The total amount of qp data is given by summing the entries
      // of the "counts" vector.
      auto n_qp_data =
        std::accumulate(counts.begin(), counts.end(), 0u);

      // On processor 0, reserve enough space to hold all the qp
      // data for a single basis function for each var.
      for (auto var : index_range(qp_data))
        qp_data[var].reserve(n_qp_data);
    }

  // The recv_qp_data vector will be used on the receiving end of all
  // the scatters below.
  std::vector<Number> recv_qp_data;

  // Loop from 0..n_bf on _all_ procs, since the scatters inside this
  // loop are collective.
  for (auto bf : make_range(n_bf))
    {
      // Prepare data for scattering (only on proc 0)
      if (rank == 0)
        {
          // Reference to the data map for the current basis function.
          auto & bf_map = _local_eim_basis_functions[bf];

          // Clear any data from previous bf
          for (auto var : index_range(qp_data))
            qp_data[var].clear();

          for (processor_id_type p=0; p<n_procs; ++p)
            {
              for (auto e : make_range(start_elem_ids_index[p], end_elem_ids_index[p]))
                {
                  auto elem_id = gathered_local_elem_ids[e];

                  // Get reference to array[n_vars][n_qp] for current Elem.
                  // Throws an error if the required elem_id is not found.
                  const auto & array = libmesh_map_find(bf_map, elem_id);

                  for (auto var : index_range(array))
                    {
                      // Insert all qp values for this var
                      qp_data[var].insert(/*insert at*/qp_data[var].end(),
                                          /*data start*/array[var].begin(),
                                          /*data end*/array[var].end());
                    } // end for (var)
                } // end for (e)
            } // end for proc_id
        } // end if rank==0

      // Perform the scatters (all procs)
      for (auto var : make_range(n_vars))
        {
          // Do the scatter for the current var
          sys.comm().scatter(qp_data[var], counts, recv_qp_data, /*root_id=*/0);

          if (rank != 0)
            {
              // Store the scattered data we received in _local_eim_basis_functions[bf]
              auto & bf_map = _local_eim_basis_functions[bf];
              auto cursor = recv_qp_data.begin();

              for (auto i : index_range(gathered_local_elem_ids))
                {
                  auto elem_id = gathered_local_elem_ids[i];
                  auto n_qp_this_elem = n_qp_per_elem_data[i];
                  auto & array = bf_map[elem_id];

                  // Create space to store the data if it doesn't already exist.
                  if (array.empty())
                    array.resize(n_vars);

                  array[var].assign(cursor, cursor + n_qp_this_elem);
                  std::advance(cursor, n_qp_this_elem);
                }
            } // if (rank != 0)
        } // end for (var)
    } // end for (bf)

  // Now that the scattering is done, delete non-local Elem
  // information from processor 0's _local_eim_basis_functions data
  // structure.
  if (rank == 0)
    {
      for (processor_id_type p=1; p<n_procs; ++p)
        {
          for (auto e : make_range(start_elem_ids_index[p], end_elem_ids_index[p]))
            {
              auto elem_id = gathered_local_elem_ids[e];

              // Delete this Elem's information from every basis function.
              for (auto & bf_map : _local_eim_basis_functions)
                bf_map.erase(elem_id);
            } // end for (e)
        } // end for proc_id
    } // if (rank == 0)
}

enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

Methods to enable/disable the reference counter output from print_info()

Definition at line 94 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

{
  _enable_print_counter = true;
  return;
}

gather_bfs()

void RBEIMEvaluation::gather_bfs ( )

private

Helper function that gathers the contents of _local_eim_basis_functions to processor 0 in preparation for printing to file.

Definition at line 1684 of file rb_eim_evaluation.C.

References _local_eim_basis_functions, libMesh::ParallelObject::comm(), TIMPI::Communicator::gather(), libMesh::index_range(), TIMPI::Communicator::max(), libMesh::ParallelObject::n_processors(), n_vars, libMesh::ParallelObject::processor_id(), and TIMPI::Communicator::verify().

Referenced by write_out_interior_basis_functions().

{
  // We need to gather _local_eim_basis_functions data from other
  // procs for printing.
  //
  // Ideally, this could be accomplished by simply calling:
  // this->comm().gather(/*root_id=*/0, _local_eim_basis_functions);
  //
  // but the data structure seems to be too complicated for this to
  // work automatically. (I get some error about the function called
  // being "private within this context".) Therefore, we have to
  // gather the information manually.

  // So we can avoid calling this many times below
  auto n_procs = this->n_processors();

  // In serial there's nothing to gather
  if (n_procs == 1)
    return;

  // Current assumption is that the number of basis functions stored on
  // each processor is the same, the only thing that differs is the number
  // of elements, so make sure that is the case now.
  auto n_bf = _local_eim_basis_functions.size();
  this->comm().verify(n_bf);

  // This function should never be called if there are no basis
  // functions, so if it was, something went wrong.
  libmesh_error_msg_if(!n_bf, "RBEIMEvaluation::gather_bfs() should not be called with 0 basis functions.");

  // The number of variables should be the same on all processors
  // and we can get this from _local_eim_basis_functions. However,
  // it may be that some processors have no local elements, so on
  // those processors we cannot look up the size from
  // _local_eim_basis_functions. As a result we use comm().max(n_vars)
  // to make sure all processors agree on the final value.
  std::size_t n_vars =
    _local_eim_basis_functions[0].empty() ? 0 : _local_eim_basis_functions[0].begin()->second.size();
  this->comm().max(n_vars);

  // Gather list of Elem ids stored on each processor to proc 0.  We
  // use basis function 0 as an example and assume all the basis
  // functions are distributed similarly.
  std::vector<dof_id_type> elem_ids;
  elem_ids.reserve(_local_eim_basis_functions[0].size());
  for (const auto & pr : _local_eim_basis_functions[0])
    elem_ids.push_back(pr.first);
  this->comm().gather(/*root_id=*/0, elem_ids);

  // Store the number of qps per Elem on this processor. Again, use
  // basis function 0 (and variable 0) to get this information, then
  // apply it to all basis functions.
  std::vector<unsigned int> n_qp_per_elem;
  n_qp_per_elem.reserve(_local_eim_basis_functions[0].size());
  for (const auto & pr : _local_eim_basis_functions[0])
    {
      // array[n_vars][n_qp] per Elem. We get the number of QPs
      // for variable 0, assuming they are all the same.
      const auto & array = pr.second;
      n_qp_per_elem.push_back(array[0].size());
    }

  // Before gathering, compute the total amount of local qp data for
  // each var, which is the sum of the entries in the "n_qp_per_elem" array.
  // This will be used to reserve space in a vector below.
  auto n_local_qp_data =
    std::accumulate(n_qp_per_elem.begin(),
                    n_qp_per_elem.end(),
                    0u);

  // Gather the number of qps per Elem for each processor onto processor 0.
  this->comm().gather(/*root_id=*/0, n_qp_per_elem);

  // Sanity check: On processor 0, this checks that we have gathered the same number
  // of elem ids and qp counts.
  libmesh_error_msg_if(elem_ids.size() != n_qp_per_elem.size(),
                       "Must gather same number of Elem ids as qps per Elem.");

  // Reserve space to store contiguous vectors of qp data for each var
  std::vector<std::vector<Number>> gathered_qp_data(n_vars);
  for (auto var : index_range(gathered_qp_data))
    gathered_qp_data[var].reserve(n_local_qp_data);

  // Now we construct a vector for each basis function, for each
  // variable, which is ordered according to:
  // [ [qp vals for Elem 0], [qp vals for Elem 1], ... [qp vals for Elem N] ]
  // and gather it to processor 0.
  for (auto bf : index_range(_local_eim_basis_functions))
    {
      // Clear any data from previous bf
      for (auto var : index_range(gathered_qp_data))
        gathered_qp_data[var].clear();

      for (const auto & pr : _local_eim_basis_functions[bf])
        {
          // array[n_vars][n_qp] per Elem
          const auto & array = pr.second;
          for (auto var : index_range(array))
            {
              // Insert all qp values for this var
              gathered_qp_data[var].insert(/*insert at*/gathered_qp_data[var].end(),
                                           /*data start*/array[var].begin(),
                                           /*data end*/array[var].end());
            }
        }

      // Reference to the data map for the current basis function.
      auto & bf_map = _local_eim_basis_functions[bf];

      for (auto var : index_range(gathered_qp_data))
        {
          // For each var, gather gathered_qp_data[var] onto processor
          // 0. There apparently is not a gather overload for
          // vector-of-vectors...
          this->comm().gather(/*root_id=*/0, gathered_qp_data[var]);

          // On processor 0, iterate over the gathered_qp_data[var]
          // vector we just gathered, filling in the "small" vectors
          // for each Elem. Note: here we ignore the fact that we
          // already have the data on processor 0 and just overwrite
          // it, this makes the indexing logic a bit simpler.
          if (this->processor_id() == 0)
            {
              auto cursor = gathered_qp_data[var].begin();
              for (auto i : index_range(elem_ids))
                {
                  auto elem_id = elem_ids[i];
                  auto n_qp_this_elem = n_qp_per_elem[i];

                  // Get reference to the [n_vars][n_qp] array for
                  // this Elem. We assign() into the vector of
                  // quadrature point values, which allocates space if
                  // it doesn't already exist.
                  auto & array = bf_map[elem_id];

                  // Possibly allocate space if this is data for a new
                  // element we haven't seen before.
                  if (array.empty())
                    array.resize(n_vars);

                  array[var].assign(cursor, cursor + n_qp_this_elem);
                  std::advance(cursor, n_qp_this_elem);
                }
            }
        }
    } // end loop over basis functions
}

get_basis_function()

const RBEIMEvaluation::QpDataMap & RBEIMEvaluation::get_basis_function

(

unsigned int

i

)

const

Get a reference to the i^th basis function.

Definition at line 639 of file rb_eim_evaluation.C.

References _local_eim_basis_functions.

Referenced by libMesh::RBEIMConstruction::update_eim_matrices(), and write_out_projected_basis_functions().

{
  return _local_eim_basis_functions[i];
}

get_closest_value()

Real libMesh::RBParametrized::get_closest_value ( Real  value, const std::vector< Real > &  list_of_values  )

staticinherited

Returns

The closest entry to value from list_of_values.

Definition at line 443 of file rb_parametrized.C.

References std::abs(), distance(), libMesh::Real, and value.

Referenced by libMesh::RBParametrized::is_value_in_list().

{
  libmesh_error_msg_if(list_of_values.empty(), "Error: list_of_values is empty.");

  Real min_distance = std::numeric_limits<Real>::max();
  Real closest_val = 0.;
  for (const auto & current_value : list_of_values)
    {
      Real distance = std::abs(value - current_value);
      if (distance < min_distance)
        {
          min_distance = distance;
          closest_val = current_value;
        }
    }

  return closest_val;
}

get_discrete_parameter_values()

const std::map< std::string, std::vector< Real > > & libMesh::RBParametrized::get_discrete_parameter_values ( ) const

inherited

Get a const reference to the discrete parameter values.

Definition at line 370 of file rb_parametrized.C.

References libMesh::RBParametrized::_discrete_parameter_values, and libMesh::RBParametrized::parameters_initialized.

Referenced by libMesh::RBDataSerialization::add_parameter_ranges_to_builder(), libMesh::RBParametrized::check_if_valid_params(), libMesh::RBParametrized::get_n_discrete_params(), libMesh::RBParametrized::initialize_parameters(), libMesh::RBParametrized::print_discrete_parameter_values(), and libMesh::RBParametrized::write_discrete_parameter_values_to_file().

{
  libmesh_error_msg_if(!parameters_initialized, "Error: parameters not initialized in RBParametrized::get_discrete_parameter_values");

  return _discrete_parameter_values;
}

get_eim_basis_function_node_local_value()

Number RBEIMEvaluation::get_eim_basis_function_node_local_value	(	unsigned int	basis_function_index,
		dof_id_type	node_id,
		unsigned int	var
	)		const

Same as get_eim_basis_function_values_at_qps() except for node data.

Note that this does not do any parallel communication, it just looks up the value from _local_node_eim_basis_functions.

Definition at line 577 of file rb_eim_evaluation.C.

References _local_node_eim_basis_functions, and get_parametrized_function_node_local_value().

Referenced by libMesh::RBEIMAssembly::evaluate_node_basis_function().

{
  libmesh_error_msg_if(basis_function_index >= _local_node_eim_basis_functions.size(),
                       "Invalid basis function index: " << basis_function_index);

  return get_parametrized_function_node_local_value(
    _local_node_eim_basis_functions[basis_function_index],
    node_id,
    comp);
}

get_eim_basis_function_node_value()

Number RBEIMEvaluation::get_eim_basis_function_node_value	(	unsigned int	basis_function_index,
		dof_id_type	node_id,
		unsigned int	var
	)		const

Same as get_eim_basis_function_value() except for node data.

Note that unlike get_eim_basis_function_node_local_value(), this does do parallel communication so that it can be called on any processor regardless of whether node_id is local or not.

Definition at line 590 of file rb_eim_evaluation.C.

References _local_node_eim_basis_functions, libMesh::ParallelObject::comm(), and get_parametrized_function_node_value().

Referenced by libMesh::RBEIMConstruction::update_eim_matrices().

{
  libmesh_error_msg_if(basis_function_index >= _local_node_eim_basis_functions.size(),
                       "Invalid basis function index: " << basis_function_index);

  return get_parametrized_function_node_value(
    comm(),
    _local_node_eim_basis_functions[basis_function_index],
    node_id,
    comp);
}

get_eim_basis_function_side_value()

Number RBEIMEvaluation::get_eim_basis_function_side_value	(	unsigned int	basis_function_index,
		dof_id_type	elem_id,
		unsigned int	side_index,
		unsigned int	comp,
		unsigned int	qp
	)		const

Same as get_eim_basis_function_value() except for side data.

Definition at line 620 of file rb_eim_evaluation.C.

References _local_side_eim_basis_functions, libMesh::ParallelObject::comm(), and get_parametrized_function_side_value().

Referenced by libMesh::RBEIMConstruction::update_eim_matrices().

{
  libmesh_error_msg_if(basis_function_index >= _local_side_eim_basis_functions.size(),
                       "Invalid side basis function index: " << basis_function_index);

  return get_parametrized_function_side_value(
    comm(),
    _local_side_eim_basis_functions[basis_function_index],
    elem_id,
    side_index,
    comp,
    qp);
}

get_eim_basis_function_side_values_at_qps()

void RBEIMEvaluation::get_eim_basis_function_side_values_at_qps	(	unsigned int	basis_function_index,
		dof_id_type	elem_id,
		unsigned int	side_index,
		unsigned int	var,
		std::vector< Number > &	values
	)		const

Same as get_eim_basis_function_values_at_qps() except for side data.

Definition at line 560 of file rb_eim_evaluation.C.

References _local_side_eim_basis_functions, and get_parametrized_function_side_values_at_qps().

Referenced by libMesh::RBEIMAssembly::evaluate_side_basis_function().

{
  libmesh_error_msg_if(basis_function_index >= _local_side_eim_basis_functions.size(),
                       "Invalid basis function index: " << basis_function_index);

  get_parametrized_function_side_values_at_qps(
    _local_side_eim_basis_functions[basis_function_index],
    elem_id,
    side_index,
    comp,
    values);
}

get_eim_basis_function_value()

Number RBEIMEvaluation::get_eim_basis_function_value	(	unsigned int	basis_function_index,
		dof_id_type	elem_id,
		unsigned int	comp,
		unsigned int	qp
	)		const

Same as above, except that we just return the value at the qp^th quadrature point.

Definition at line 604 of file rb_eim_evaluation.C.

References _local_eim_basis_functions, libMesh::ParallelObject::comm(), and get_parametrized_function_value().

Referenced by libMesh::RBEIMConstruction::update_eim_matrices().

{
  libmesh_error_msg_if(basis_function_index >= _local_eim_basis_functions.size(),
                       "Invalid basis function index: " << basis_function_index);

  return get_parametrized_function_value(
    comm(),
    _local_eim_basis_functions[basis_function_index],
    elem_id,
    comp,
    qp);
}

get_eim_basis_function_values_at_qps()

void RBEIMEvaluation::get_eim_basis_function_values_at_qps	(	unsigned int	basis_function_index,
		dof_id_type	elem_id,
		unsigned int	var,
		std::vector< Number > &	values
	)		const

Fill up values with the basis function values for basis function basis_function_index and variable var, at all quadrature points on element elem_id.

Each processor stores data for only the elements local to that processor, so if elem_id is not on this processor then values will be empty.

Definition at line 545 of file rb_eim_evaluation.C.

References _local_eim_basis_functions, and get_parametrized_function_values_at_qps().

Referenced by libMesh::RBEIMAssembly::evaluate_basis_function().

{
  libmesh_error_msg_if(basis_function_index >= _local_eim_basis_functions.size(),
                       "Invalid basis function index: " << basis_function_index);

  get_parametrized_function_values_at_qps(
    _local_eim_basis_functions[basis_function_index],
    elem_id,
    comp,
    values);
}

get_eim_error_indicator()

std::pair< Real, Real > RBEIMEvaluation::get_eim_error_indicator	(	Number	error_indicator_rhs,
		const DenseVector< Number > &	eim_solution,
		const DenseVector< Number > &	eim_rhs
	)

Evaluates the EIM error indicator based on error_indicator_rhs, eim_solution, and _error_indicator_interpolation_row.

We also pass in eim_rhs since this is used to normalize the error indicator.

We return a pair that specifies the relative error indicator, and the normalization that was used to compute the relative error indicator. We can then recover the absolute error indicator via rel. indicator x normalization.

Definition at line 2988 of file rb_eim_evaluation.C.

References _error_indicator_interpolation_row, std::abs(), libMesh::DenseVector< T >::dot(), eim_error_indicator_normalization, libMesh::DenseVector< T >::get_principal_subvector(), libMesh::DenseVector< T >::linfty_norm(), MAX_RHS, std::real(), libMesh::Real, RESIDUAL_TERMS, and libMesh::DenseVector< T >::size().

Referenced by rb_eim_solves().

{
  DenseVector<Number> coeffs;
  _error_indicator_interpolation_row.get_principal_subvector(eim_solution.size(), coeffs);

  Number EIM_val_at_error_indicator_pt = coeffs.dot(eim_solution);
  Real error_indicator_val =
    std::real(error_indicator_rhs - EIM_val_at_error_indicator_pt);

  Real normalization = 0.;
  if (eim_error_indicator_normalization == RESIDUAL_TERMS)
  {
    // This normalization is based on the terms from the "EIM residual" calculation
    // used in the calculation of error_indicator_val.
    normalization =
      std::abs(error_indicator_rhs) + std::abs(EIM_val_at_error_indicator_pt);
  }
  else if (eim_error_indicator_normalization == MAX_RHS)
  {
    // Normalize the error indicator based on the max-norm of the EIM RHS vector.
    // This approach handles the case where different EIM variables have different
    // magnitudes well, i.e. if error_indicator_val is based on a
    // "small magnitude" variable, then by normalizing based on the entire
    // RHS vector (which will typically include values from multiple different
    // EIM variables) we will effectively scale down the error indicator
    // corresponding to small variables, which is typically what we want.
    normalization = std::max(eim_rhs.linfty_norm(), std::abs(error_indicator_rhs));
  }
  else
  {
    libmesh_error_msg("unsupported eim_error_indicator_normalization");
  }

  // We avoid NaNs by setting normalization to 1 in the case that it is exactly 0.
  if (normalization == 0.)
    normalization = 1.;

  // Return the relative error indicator, and the normalization that we used. By returning
  // the normalization, we can subsequently recover the absolute error indicator if
  // desired.
  return std::make_pair(std::abs(error_indicator_val) / normalization, normalization);
}

get_eim_solutions_for_training_set() [1/2]

const std::vector< DenseVector< Number > > & RBEIMEvaluation::get_eim_solutions_for_training_set

(

)

const

Return a const reference to the EIM solutions for the parameters in the training set.

Definition at line 682 of file rb_eim_evaluation.C.

References _eim_solutions_for_training_set.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder(), libMesh::RBDataDeserialization::load_rb_eim_evaluation_data(), and libMesh::RBEIMConstruction::store_eim_solutions_for_training_set().

{
  return _eim_solutions_for_training_set;
}

get_eim_solutions_for_training_set() [2/2]

std::vector< DenseVector< Number > > & RBEIMEvaluation::get_eim_solutions_for_training_set

(

)

Return a writeable reference to the EIM solutions for the parameters in the training set.

Definition at line 687 of file rb_eim_evaluation.C.

References _eim_solutions_for_training_set.

{
  return _eim_solutions_for_training_set;
}

get_eim_theta_objects()

std::vector< std::unique_ptr< RBTheta > > & RBEIMEvaluation::get_eim_theta_objects

(

)

Returns

The vector of theta objects that point to this RBEIMEvaluation.

Definition at line 413 of file rb_eim_evaluation.C.

References _rb_eim_theta_objects.

{
  return _rb_eim_theta_objects;
}

get_eim_vars_to_project_and_write()

const std::vector< EIMVarGroupPlottingInfo > & RBEIMEvaluation::get_eim_vars_to_project_and_write

(

)

const

Get _eim_vars_to_project_and_write.

Definition at line 2921 of file rb_eim_evaluation.C.

References _eim_vars_to_project_and_write.

Referenced by write_out_projected_basis_functions().

{
  return _eim_vars_to_project_and_write;
}

get_error_indicator_interpolation_row()

const DenseVector< Number > & RBEIMEvaluation::get_error_indicator_interpolation_row

(

)

const

Get/set _extra_points_interpolation_matrix.

Definition at line 3039 of file rb_eim_evaluation.C.

References _error_indicator_interpolation_row.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder().

{
  return _error_indicator_interpolation_row;
}

get_info()

std::string libMesh::ReferenceCounter::get_info ( )

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

References libMesh::ReferenceCounter::_counts, and libMesh::Quality::name().

Referenced by libMesh::ReferenceCounter::print_info().

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)

  std::ostringstream oss;

  oss << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";

  for (const auto & [name, cd] : _counts)
    oss << "| " << name << " reference count information:\n"
        << "|  Creations:    " << cd.first    << '\n'
        << "|  Destructions: " << cd.second << '\n';

  oss << " ---------------------------------------------------------------------------- \n";

  return oss.str();

#else

  return "";

#endif
}

get_interpolation_matrix()

const DenseMatrix< Number > & RBEIMEvaluation::get_interpolation_matrix

(

)

const

Get the EIM interpolation matrix.

Definition at line 878 of file rb_eim_evaluation.C.

References _interpolation_matrix.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder().

{
  return _interpolation_matrix;
}

get_interpolation_points_boundary_id()

boundary_id_type RBEIMEvaluation::get_interpolation_points_boundary_id

(

unsigned int

index

)

const

Definition at line 788 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::boundary_ids.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder().

{
  libmesh_error_msg_if(index >= _vec_eval_input.boundary_ids.size(), "Error: Invalid index");

  return _vec_eval_input.boundary_ids[index];
}

get_interpolation_points_comp()

unsigned int RBEIMEvaluation::get_interpolation_points_comp

(

unsigned int

index

)

const

Definition at line 774 of file rb_eim_evaluation.C.

References _interpolation_points_comp.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), and libMesh::RBEIMConstruction::update_eim_matrices().

{
  libmesh_error_msg_if(index >= _interpolation_points_comp.size(), "Error: Invalid index");

  return _interpolation_points_comp[index];
}

get_interpolation_points_elem_id()

dof_id_type RBEIMEvaluation::get_interpolation_points_elem_id

(

unsigned int

index

)

const

Definition at line 802 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::elem_ids.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), and libMesh::RBEIMConstruction::update_eim_matrices().

{
  libmesh_error_msg_if(index >= _vec_eval_input.elem_ids.size(), "Error: Invalid index");

  return _vec_eval_input.elem_ids[index];
}

get_interpolation_points_elem_type()

ElemType RBEIMEvaluation::get_interpolation_points_elem_type

(

unsigned int

index

)

const

Definition at line 830 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::elem_types.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder().

{
  libmesh_error_msg_if(index >= _vec_eval_input.elem_types.size(), "Error: Invalid index");

  return _vec_eval_input.elem_types[index];
}

get_interpolation_points_JxW_all_qp()

const std::vector< Real > & RBEIMEvaluation::get_interpolation_points_JxW_all_qp

(

unsigned int

index

)

const

Definition at line 837 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::JxW_all_qp.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder().

{
  libmesh_error_msg_if(index >= _vec_eval_input.JxW_all_qp.size(), "Error: Invalid index");

  return _vec_eval_input.JxW_all_qp[index];
}

get_interpolation_points_node_id()

dof_id_type RBEIMEvaluation::get_interpolation_points_node_id

(

unsigned int

index

)

const

Definition at line 816 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::node_ids.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), and libMesh::RBEIMConstruction::update_eim_matrices().

{
  libmesh_error_msg_if(index >= _vec_eval_input.node_ids.size(), "Error: Invalid index");

  return _vec_eval_input.node_ids[index];
}

get_interpolation_points_phi_i_all_qp()

const std::vector< std::vector< Real > > & RBEIMEvaluation::get_interpolation_points_phi_i_all_qp

(

unsigned int

index

)

const

Definition at line 844 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::phi_i_all_qp.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder().

{
  libmesh_error_msg_if(index >= _vec_eval_input.phi_i_all_qp.size(), "Error: Invalid index");

  return _vec_eval_input.phi_i_all_qp[index];
}

get_interpolation_points_phi_i_qp()

const std::vector< Real > & RBEIMEvaluation::get_interpolation_points_phi_i_qp

(

unsigned int

index

)

const

Definition at line 851 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::phi_i_qp.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder().

{
  libmesh_error_msg_if(index >= _vec_eval_input.phi_i_qp.size(), "Error: Invalid index");

  return _vec_eval_input.phi_i_qp[index];
}

get_interpolation_points_qp()

unsigned int RBEIMEvaluation::get_interpolation_points_qp

(

unsigned int

index

)

const

Definition at line 823 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::qps.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), and libMesh::RBEIMConstruction::update_eim_matrices().

{
  libmesh_error_msg_if(index >= _vec_eval_input.qps.size(), "Error: Invalid index");

  return _vec_eval_input.qps[index];
}

get_interpolation_points_side_index()

unsigned int RBEIMEvaluation::get_interpolation_points_side_index

(

unsigned int

index

)

const

Definition at line 809 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::side_indices.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), and libMesh::RBEIMConstruction::update_eim_matrices().

{
  libmesh_error_msg_if(index >= _vec_eval_input.side_indices.size(), "Error: Invalid index");

  return _vec_eval_input.side_indices[index];
}

get_interpolation_points_spatial_indices()

const std::vector< unsigned int > & RBEIMEvaluation::get_interpolation_points_spatial_indices

(

unsigned int

index

)

const

Definition at line 858 of file rb_eim_evaluation.C.

References _interpolation_points_spatial_indices.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder().

{
  libmesh_error_msg_if(index >= _interpolation_points_spatial_indices.size(), "Error: Invalid index");

  return _interpolation_points_spatial_indices[index];
}

get_interpolation_points_subdomain_id()

subdomain_id_type RBEIMEvaluation::get_interpolation_points_subdomain_id

(

unsigned int

index

)

const

Definition at line 781 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::sbd_ids.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder().

{
  libmesh_error_msg_if(index >= _vec_eval_input.sbd_ids.size(), "Error: Invalid index");

  return _vec_eval_input.sbd_ids[index];
}

get_interpolation_points_xyz()

Point RBEIMEvaluation::get_interpolation_points_xyz

(

unsigned int

index

)

const

Get the data associated with EIM interpolation points.

Definition at line 767 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::all_xyz.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder().

{
  libmesh_error_msg_if(index >= _vec_eval_input.all_xyz.size(), "Error: Invalid index");

  return _vec_eval_input.all_xyz[index];
}

get_interpolation_points_xyz_perturbations()

const std::vector< Point > & RBEIMEvaluation::get_interpolation_points_xyz_perturbations

(

unsigned int

index

)

const

Definition at line 795 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::all_xyz_perturb.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder().

{
  libmesh_error_msg_if(index >= _vec_eval_input.all_xyz_perturb.size(), "Error: Invalid index");

  return _vec_eval_input.all_xyz_perturb[index];
}

get_n_basis_functions()

unsigned int RBEIMEvaluation::get_n_basis_functions

(

)

const

Return the current number of EIM basis functions.

Definition at line 304 of file rb_eim_evaluation.C.

References _local_eim_basis_functions, _local_node_eim_basis_functions, _local_side_eim_basis_functions, and get_parametrized_function().

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder(), libMesh::RBEIMConstruction::compute_max_eim_error(), decrement_vector(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::RBEIMTheta::evaluate_vec(), initialize_eim_theta_objects(), node_decrement_vector(), rb_eim_solve(), rb_eim_solves(), read_in_basis_functions(), set_eim_error_indicator_active(), side_decrement_vector(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), libMesh::RBEIMConstruction::train_eim_approximation_with_greedy(), libMesh::RBEIMConstruction::train_eim_approximation_with_POD(), libMesh::RBEIMConstruction::update_eim_matrices(), and write_out_projected_basis_functions().

{
  if (get_parametrized_function().on_mesh_sides())
    return _local_side_eim_basis_functions.size();
  else if (get_parametrized_function().on_mesh_nodes())
    return _local_node_eim_basis_functions.size();
  else
    return _local_eim_basis_functions.size();
}

get_n_continuous_params()

unsigned int libMesh::RBParametrized::get_n_continuous_params ( ) const

inherited

Get the number of continuous parameters.

Definition at line 112 of file rb_parametrized.C.

References libMesh::RBParametrized::get_n_discrete_params(), libMesh::RBParametrized::get_n_params(), libMesh::libmesh_assert(), and libMesh::RBParametrized::parameters_initialized.

Referenced by libMesh::RBDataSerialization::add_parameter_ranges_to_builder(), and libMesh::RBParametrized::write_parameter_ranges_to_file().

{
  libmesh_error_msg_if(!parameters_initialized, "Error: parameters not initialized in RBParametrized::get_n_continuous_params");

  libmesh_assert(get_n_params() >= get_n_discrete_params());

  return static_cast<unsigned int>(get_n_params() - get_n_discrete_params());
}

get_n_discrete_params()

unsigned int libMesh::RBParametrized::get_n_discrete_params ( ) const

inherited

Get the number of discrete parameters.

Definition at line 121 of file rb_parametrized.C.

References libMesh::RBParametrized::get_discrete_parameter_values(), and libMesh::RBParametrized::parameters_initialized.

Referenced by libMesh::RBDataSerialization::add_parameter_ranges_to_builder(), libMesh::RBParametrized::get_n_continuous_params(), and libMesh::RBParametrized::write_discrete_parameter_values_to_file().

{
  libmesh_error_msg_if(!parameters_initialized, "Error: parameters not initialized in RBParametrized::get_n_discrete_params");

  return cast_int<unsigned int>
    (get_discrete_parameter_values().size());
}

get_n_interpolation_points()

unsigned int RBEIMEvaluation::get_n_interpolation_points

(

)

const

Return the number of interpolation points.

If we're not using the EIM error indicator, then this matches get_n_basis_functions(), but if we are using the EIM error indicator then we should have one extra interpolation point.

Definition at line 314 of file rb_eim_evaluation.C.

References _vec_eval_input, and libMesh::VectorizedEvalInput::all_xyz.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder(), and set_eim_error_indicator_active().

{
  return _vec_eval_input.all_xyz.size();
}

get_n_interpolation_points_spatial_indices()

unsigned int RBEIMEvaluation::get_n_interpolation_points_spatial_indices

(

)

const

_interpolation_points_spatial_indices is optional data, so we need to be able to check how many _interpolation_points_spatial_indices values have actually been set since it may not match the number of interpolation points.

Definition at line 865 of file rb_eim_evaluation.C.

References _interpolation_points_spatial_indices.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder().

{
  return _interpolation_points_spatial_indices.size();
}

get_n_params()

unsigned int libMesh::RBParametrized::get_n_params ( ) const

inherited

Get the number of parameters.

Definition at line 103 of file rb_parametrized.C.

References libMesh::RBParameters::n_parameters(), libMesh::RBParametrized::parameters_initialized, libMesh::RBParametrized::parameters_max, and libMesh::RBParametrized::parameters_min.

Referenced by libMesh::RBParametrized::check_if_valid_params(), libMesh::RBEIMConstruction::compute_max_eim_error(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::RBParametrized::get_n_continuous_params(), libMesh::RBSCMConstruction::print_info(), libMesh::RBEIMConstruction::print_info(), libMesh::RBConstruction::print_info(), set_eim_error_indicator_active(), and libMesh::RBConstruction::train_reduced_basis_with_POD().

{
  libmesh_error_msg_if(!parameters_initialized, "Error: parameters not initialized in RBParametrized::get_n_params");

  libmesh_assert_equal_to ( parameters_min.n_parameters(), parameters_max.n_parameters() );

  return parameters_min.n_parameters();
}

get_node_basis_function()

const RBEIMEvaluation::NodeDataMap & RBEIMEvaluation::get_node_basis_function

(

unsigned int

i

)

const

Get a reference to the i^th node basis function.

Definition at line 651 of file rb_eim_evaluation.C.

References _local_node_eim_basis_functions.

Referenced by libMesh::RBEIMConstruction::update_eim_matrices().

{
  return _local_node_eim_basis_functions[i];
}

get_parameter_max()

Real libMesh::RBParametrized::get_parameter_max ( const std::string &  param_name ) const

inherited

Get maximum allowable value of parameter param_name.

Definition at line 183 of file rb_parametrized.C.

References libMesh::RBParameters::get_value(), libMesh::RBParametrized::parameters_initialized, and libMesh::RBParametrized::parameters_max.

Referenced by libMesh::RBParametrized::check_if_valid_params(), libMesh::RBSCMConstruction::print_info(), libMesh::RBEIMConstruction::print_info(), and libMesh::RBConstruction::print_info().

{
  libmesh_error_msg_if(!parameters_initialized, "Error: parameters not initialized in RBParametrized::get_parameter_max");

  return parameters_max.get_value(param_name);
}

get_parameter_min()

Real libMesh::RBParametrized::get_parameter_min ( const std::string &  param_name ) const

inherited

Get minimum allowable value of parameter param_name.

Definition at line 176 of file rb_parametrized.C.

References libMesh::RBParameters::get_value(), libMesh::RBParametrized::parameters_initialized, and libMesh::RBParametrized::parameters_min.

Referenced by libMesh::RBParametrized::check_if_valid_params(), libMesh::RBSCMConstruction::print_info(), libMesh::RBEIMConstruction::print_info(), and libMesh::RBConstruction::print_info().

{
  libmesh_error_msg_if(!parameters_initialized, "Error: parameters not initialized in RBParametrized::get_parameter_min");

  return parameters_min.get_value(param_name);
}

get_parameter_names()

std::set< std::string > libMesh::RBParametrized::get_parameter_names ( ) const

inherited

Get a set that stores the parameter names.

Definition at line 129 of file rb_parametrized.C.

References libMesh::RBParametrized::parameters_initialized, and libMesh::RBParametrized::parameters_min.

{
  libmesh_deprecated();
  libmesh_error_msg_if(!parameters_initialized, "Error: parameters not initialized in RBParametrized::get_parameter_names");

  std::set<std::string> parameter_names;
  for (const auto & pr : parameters_min)
    parameter_names.insert(pr.first);

  return parameter_names;
}

get_parameters()

const RBParameters & libMesh::RBParametrized::get_parameters ( ) const

inherited

Get the current parameters.

Definition at line 155 of file rb_parametrized.C.

References libMesh::RBParametrized::parameters, and libMesh::RBParametrized::parameters_initialized.

Referenced by libMesh::TransientRBConstruction::add_scaled_mass_matrix(), libMesh::TransientRBEvaluation::cache_online_residual_terms(), libMesh::RBEvaluation::compute_residual_dual_norm(), libMesh::RBSCMConstruction::compute_SCM_bounds_on_training_set(), libMesh::RBSCMConstruction::enrich_C_J(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::RBEvaluation::eval_output_dual_norm(), libMesh::RBSCMConstruction::evaluate_stability_constant(), libMesh::RBConstruction::get_RB_error_bound(), libMesh::RBSCMEvaluation::get_SCM_LB(), libMesh::RBSCMEvaluation::get_SCM_UB(), SimpleRBEvaluation::get_stability_lower_bound(), libMesh::RBConstruction::greedy_termination_test(), libMesh::RBEIMConstruction::initialize_parametrized_functions_in_training_set(), libMesh::RBSCMEvaluation::legacy_read_offline_data_from_files(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::RBConstruction::preevaluate_thetas(), libMesh::RBSCMConstruction::print_info(), libMesh::RBEIMConstruction::print_info(), libMesh::RBConstruction::print_info(), libMesh::RBParametrized::print_parameters(), libMesh::RBSCMConstruction::process_parameters_file(), libMesh::TransientRBEvaluation::rb_solve(), libMesh::RBEvaluation::rb_solve(), libMesh::RBSCMEvaluation::save_current_parameters(), libMesh::RBEIMConstruction::train_eim_approximation_with_greedy(), libMesh::RBEIMConstruction::train_eim_approximation_with_POD(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_assembly(), libMesh::TransientRBConstruction::truth_solve(), libMesh::RBConstruction::truth_solve(), libMesh::TransientRBEvaluation::uncached_compute_residual_dual_norm(), and libMesh::RBConstruction::update_greedy_param_list().

{
  libmesh_error_msg_if(!parameters_initialized, "Error: parameters not initialized in RBParametrized::get_parameters");

  return parameters;
}

get_parameters_max()

const RBParameters & libMesh::RBParametrized::get_parameters_max ( ) const

inherited

Get an RBParameters object that specifies the maximum allowable value for each parameter.

Definition at line 169 of file rb_parametrized.C.

References libMesh::RBParametrized::parameters_initialized, and libMesh::RBParametrized::parameters_max.

Referenced by libMesh::RBDataSerialization::add_parameter_ranges_to_builder(), libMesh::RBParametrized::initialize_parameters(), libMesh::RBSCMConstruction::process_parameters_file(), libMesh::RBEIMConstruction::set_rb_construction_parameters(), libMesh::RBConstruction::set_rb_construction_parameters(), and libMesh::RBParametrized::write_parameter_ranges_to_file().

{
  libmesh_error_msg_if(!parameters_initialized, "Error: parameters not initialized in RBParametrized::get_parameters_max");

  return parameters_max;
}

get_parameters_min()

const RBParameters & libMesh::RBParametrized::get_parameters_min ( ) const

inherited

Get an RBParameters object that specifies the minimum allowable value for each parameter.

Definition at line 162 of file rb_parametrized.C.

References libMesh::RBParametrized::parameters_initialized, and libMesh::RBParametrized::parameters_min.

Referenced by libMesh::RBDataSerialization::add_parameter_ranges_to_builder(), libMesh::RBParametrized::initialize_parameters(), libMesh::RBSCMConstruction::process_parameters_file(), libMesh::RBEIMConstruction::set_rb_construction_parameters(), libMesh::RBConstruction::set_rb_construction_parameters(), and libMesh::RBParametrized::write_parameter_ranges_to_file().

{
  libmesh_error_msg_if(!parameters_initialized, "Error: parameters not initialized in RBParametrized::get_parameters_min");

  return parameters_min;
}

get_parametrized_function() [1/2]

RBParametrizedFunction & RBEIMEvaluation::get_parametrized_function

(

)

Get a reference to the parametrized function.

Definition at line 91 of file rb_eim_evaluation.C.

References _parametrized_function.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder(), libMesh::RBEIMConstruction::enrich_eim_approximation(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), get_n_basis_functions(), libMesh::RBEIMConstruction::get_random_point_from_training_sample(), initialize_interpolation_points_spatial_indices(), initialize_param_fn_spatial_indices(), libMesh::RBEIMConstruction::initialize_parametrized_functions_in_training_set(), libMesh::RBEIMConstruction::initialize_qp_data(), libMesh::RBDataDeserialization::load_rb_eim_evaluation_data(), node_distribute_bfs(), rb_eim_solves(), read_in_basis_functions(), set_n_basis_functions(), libMesh::RBEIMConstruction::set_rb_construction_parameters(), side_distribute_bfs(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), libMesh::RBEIMConstruction::train_eim_approximation_with_greedy(), libMesh::RBEIMConstruction::train_eim_approximation_with_POD(), libMesh::RBEIMConstruction::update_eim_matrices(), and write_out_basis_functions().

{
  libmesh_error_msg_if(!_parametrized_function, "Parametrized function not initialized yet");

  return *_parametrized_function;
}

get_parametrized_function() [2/2]

const RBParametrizedFunction & RBEIMEvaluation::get_parametrized_function

(

)

const

Get a const reference to the parametrized function.

Definition at line 98 of file rb_eim_evaluation.C.

References _parametrized_function.

{
  libmesh_error_msg_if(!_parametrized_function, "Parametrized function not initialized yet");

  return *_parametrized_function;
}

get_parametrized_function_node_local_value()

Number RBEIMEvaluation::get_parametrized_function_node_local_value ( const NodeDataMap &  pf, dof_id_type  node_id, unsigned int  comp  )

static

Same as get_parametrized_function_values_at_qps() except for node data.

Note that this does not do any parallel communication, so it is only applicable to looking up local values.

Definition at line 466 of file rb_eim_evaluation.C.

Referenced by get_eim_basis_function_node_local_value(), and get_parametrized_function_node_value().

{
  LOG_SCOPE("get_parametrized_function_node_local_value()", "RBEIMConstruction");

  auto it = pf.find(node_id);
  if (it != pf.end())
    {
      const std::vector<Number> & vec = it->second;
      libmesh_error_msg_if (comp >= vec.size(), "Error: Invalid comp index");
      return vec[comp];
    }
  else
    return 0.;
}

get_parametrized_function_node_value()

Number RBEIMEvaluation::get_parametrized_function_node_value ( const Parallel::Communicator &  comm, const NodeDataMap &  pf, dof_id_type  node_id, unsigned int  comp  )

static

Same as get_parametrized_function_value() except for node data.

Unlike get_parametrized_function_node_local_value(), this does parallel communication, and therefore if can be used to look up values regardless of whether or not node_id is local.

Definition at line 531 of file rb_eim_evaluation.C.

References libMesh::ParallelObject::comm(), get_parametrized_function_node_local_value(), TIMPI::Communicator::sum(), and value.

Referenced by libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), get_eim_basis_function_node_value(), and libMesh::RBEIMConstruction::store_eim_solutions_for_training_set().

{
  LOG_SCOPE("get_parametrized_function_node_value()", "RBEIMConstruction");

  Number value = get_parametrized_function_node_local_value(pf, node_id, comp);
  comm.sum(value);

  return value;
}

get_parametrized_function_side_value()

Number RBEIMEvaluation::get_parametrized_function_side_value ( const Parallel::Communicator &  comm, const SideQpDataMap &  pf, dof_id_type  elem_id, unsigned int  side_index, unsigned int  comp, unsigned int  qp  )

static

Same as get_parametrized_function_value() except for side data.

Definition at line 507 of file rb_eim_evaluation.C.

References libMesh::ParallelObject::comm(), get_parametrized_function_side_values_at_qps(), TIMPI::Communicator::sum(), and value.

Referenced by libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), get_eim_basis_function_side_value(), and libMesh::RBEIMConstruction::store_eim_solutions_for_training_set().

{
  std::vector<Number> values;
  get_parametrized_function_side_values_at_qps(pf, elem_id, side_index, comp, values);

  // In parallel, values should only be non-empty on one processor
  Number value = 0.;
  if (!values.empty())
  {
    libmesh_error_msg_if(qp >= values.size(), "Error: Invalid qp index");

    value = values[qp];
  }
  comm.sum(value);

  return value;
}

get_parametrized_function_side_values_at_qps()

void RBEIMEvaluation::get_parametrized_function_side_values_at_qps ( const SideQpDataMap &  pf, dof_id_type  elem_id, unsigned int  side_index, unsigned int  comp, std::vector< Number > &  values  )

static

Same as get_parametrized_function_values_at_qps() except for side data.

Definition at line 444 of file rb_eim_evaluation.C.

Referenced by get_eim_basis_function_side_values_at_qps(), and get_parametrized_function_side_value().

{
  LOG_SCOPE("get_parametrized_function_side_values_at_qps()", "RBEIMConstruction");

  values.clear();

  const auto it = pf.find(std::make_pair(elem_id,side_index));
  if (it != pf.end())
  {
    const auto & comps_and_qps_on_elem = it->second;
    libmesh_error_msg_if(comp >= comps_and_qps_on_elem.size(),
                         "Invalid comp index: " << comp);

    values = comps_and_qps_on_elem[comp];
  }
}

get_parametrized_function_value()

Number RBEIMEvaluation::get_parametrized_function_value ( const Parallel::Communicator &  comm, const QpDataMap &  pf, dof_id_type  elem_id, unsigned int  comp, unsigned int  qp  )

static

Same as above, except that we just return the value at the qp^th quadrature point.

Definition at line 484 of file rb_eim_evaluation.C.

References libMesh::ParallelObject::comm(), get_parametrized_function_values_at_qps(), TIMPI::Communicator::sum(), and value.

Referenced by libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), get_eim_basis_function_value(), and libMesh::RBEIMConstruction::store_eim_solutions_for_training_set().

{
  std::vector<Number> values;
  get_parametrized_function_values_at_qps(pf, elem_id, comp, values);

  // In parallel, values should only be non-empty on one processor
  Number value = 0.;
  if (!values.empty())
  {
    libmesh_error_msg_if(qp >= values.size(), "Error: Invalid qp index");

    value = values[qp];
  }
  comm.sum(value);

  return value;
}

get_parametrized_function_values_at_qps()

void RBEIMEvaluation::get_parametrized_function_values_at_qps ( const QpDataMap &  pf, dof_id_type  elem_id, unsigned int  comp, std::vector< Number > &  values  )

static

Fill up values by evaluating the parametrized function pf for all quadrature points on element elem_id and component comp.

Definition at line 423 of file rb_eim_evaluation.C.

Referenced by get_eim_basis_function_values_at_qps(), and get_parametrized_function_value().

{
  LOG_SCOPE("get_parametrized_function_values_at_qps()", "RBEIMConstruction");

  values.clear();

  const auto it = pf.find(elem_id);
  if (it != pf.end())
  {
    const auto & comps_and_qps_on_elem = it->second;
    libmesh_error_msg_if(comp >= comps_and_qps_on_elem.size(),
                         "Invalid comp index: " << comp);

    values = comps_and_qps_on_elem[comp];
  }
}

get_preserve_rb_eim_solutions()

bool RBEIMEvaluation::get_preserve_rb_eim_solutions

(

)

const

Get _preserve_rb_eim_solutions.

Definition at line 888 of file rb_eim_evaluation.C.

References _preserve_rb_eim_solutions.

{
  return _preserve_rb_eim_solutions;
}

get_rb_eim_error_indicators()

const std::vector< Real > & RBEIMEvaluation::get_rb_eim_error_indicators

(

)

const

Return the EIM error indicator values from the most recent call to rb_eim_solves().

Definition at line 692 of file rb_eim_evaluation.C.

References _rb_eim_error_indicators.

{
  return _rb_eim_error_indicators;
}

get_rb_eim_solutions()

const std::vector< DenseVector< Number > > & RBEIMEvaluation::get_rb_eim_solutions

(

)

const

Return the EIM solution coefficients from the most recent call to rb_eim_solves().

Definition at line 661 of file rb_eim_evaluation.C.

References _rb_eim_solutions.

Referenced by libMesh::RBEIMConstruction::compute_max_eim_error().

{
  return _rb_eim_solutions;
}

get_rb_eim_solutions_entries()

std::vector< Number > RBEIMEvaluation::get_rb_eim_solutions_entries

(

unsigned int

index

)

const

Return entry index for each solution in _rb_eim_solutions.

Definition at line 666 of file rb_eim_evaluation.C.

References _rb_eim_solutions, and libMesh::index_range().

Referenced by libMesh::RBEIMTheta::evaluate_vec().

{
  LOG_SCOPE("get_rb_eim_solutions_entries()", "RBEIMEvaluation");

  std::vector<Number> rb_eim_solutions_entries(_rb_eim_solutions.size());
  for (unsigned int mu_index : index_range(_rb_eim_solutions))
    {
      libmesh_error_msg_if(index >= _rb_eim_solutions[mu_index].size(),
                           "Error: Requested solution index " << index <<
                           ", but only have " << _rb_eim_solutions[mu_index].size() << " entries.");
      rb_eim_solutions_entries[mu_index] = _rb_eim_solutions[mu_index](index);
    }

  return rb_eim_solutions_entries;
}

get_side_basis_function()

const RBEIMEvaluation::SideQpDataMap & RBEIMEvaluation::get_side_basis_function

(

unsigned int

i

)

const

Get a reference to the i^th side basis function.

Definition at line 645 of file rb_eim_evaluation.C.

References _local_side_eim_basis_functions.

Referenced by libMesh::RBEIMConstruction::update_eim_matrices().

{
  return _local_side_eim_basis_functions[i];
}

get_vec_eval_input()

const VectorizedEvalInput & RBEIMEvaluation::get_vec_eval_input

(

)

const

Get the VectorizedEvalInput data.

Definition at line 3034 of file rb_eim_evaluation.C.

References _vec_eval_input.

Referenced by libMesh::RBEIMConstruction::get_random_point().

{
  return _vec_eval_input;
}

increment_constructor_count()

void libMesh::ReferenceCounter::increment_constructor_count ( const std::string &  name )

inlineprotectednoexceptinherited

Increments the construction counter.

Should be called in the constructor of any derived class that will be reference counted.

Definition at line 183 of file reference_counter.h.

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.first++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_constructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

increment_destructor_count()

void libMesh::ReferenceCounter::increment_destructor_count ( const std::string &  name )

inlineprotectednoexceptinherited

Increments the destruction counter.

Should be called in the destructor of any derived class that will be reference counted.

Definition at line 207 of file reference_counter.h.

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::~ReferenceCountedObject().

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.second++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_destructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

initialize_eim_theta_objects()

void RBEIMEvaluation::initialize_eim_theta_objects

(

)

Build a vector of RBTheta objects that accesses the components of the RB_solution member variable of this RBEvaluation.

Store these objects in the member vector rb_theta_objects.

Definition at line 405 of file rb_eim_evaluation.C.

References _rb_eim_theta_objects, build_eim_theta(), get_n_basis_functions(), and libMesh::make_range().

{
  // Initialize the rb_theta objects that access the solution from this rb_eim_evaluation
  _rb_eim_theta_objects.clear();
  for (auto i : make_range(get_n_basis_functions()))
    _rb_eim_theta_objects.emplace_back(build_eim_theta(i));
}

initialize_interpolation_points_spatial_indices()

void RBEIMEvaluation::initialize_interpolation_points_spatial_indices

(

)

Initialize _interpolation_points_spatial_indices.

Once this data is initialized, we can store it in the training data, and read it back in during the Online stage to be used in solves.

Definition at line 290 of file rb_eim_evaluation.C.

References _interpolation_points_spatial_indices, _vec_eval_input, get_parametrized_function(), and libMesh::RBParametrizedFunction::get_spatial_indices().

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder().

{
  _interpolation_points_spatial_indices.clear();

  get_parametrized_function().get_spatial_indices(_interpolation_points_spatial_indices,
                                                  _vec_eval_input);
}

initialize_param_fn_spatial_indices()

void RBEIMEvaluation::initialize_param_fn_spatial_indices

(

)

The Online counterpart of initialize_interpolation_points_spatial_indices().

This is used to initialize the spatial indices data in _parametrized_function so that the _parametrized_function can be used in the Online stage without reconstructing the spatial indices on every element or node in the mesh.

Definition at line 298 of file rb_eim_evaluation.C.

References _interpolation_points_spatial_indices, _vec_eval_input, get_parametrized_function(), and libMesh::RBParametrizedFunction::initialize_spatial_indices().

Referenced by libMesh::RBDataDeserialization::load_rb_eim_evaluation_data().

{
  get_parametrized_function().initialize_spatial_indices(_interpolation_points_spatial_indices,
                                                         _vec_eval_input);
}

initialize_parameters() [1/2]

void libMesh::RBParametrized::initialize_parameters ( const RBParameters &  mu_min_in, const RBParameters &  mu_max_in, const std::map< std::string, std::vector< Real >> &  discrete_parameter_values  )

inherited

Initialize the parameter ranges and set current_parameters.

Parameter ranges are inclusive. The input min/max RBParameters should have exactly 1 sample each. Vector-valued samples are not currently supported for the min/max parameters or for discrete parameters.

Definition at line 53 of file rb_parametrized.C.

References libMesh::RBParametrized::_discrete_parameter_values, libMesh::RBParameters::begin_serialized(), libMesh::RBParameters::end_serialized(), libMesh::RBParameters::n_parameters(), libMesh::RBParameters::n_samples(), libMesh::Quality::name(), libMesh::RBParametrized::parameters_initialized, libMesh::RBParametrized::parameters_max, libMesh::RBParametrized::parameters_min, libMesh::Real, libMesh::RBParametrized::set_parameters(), and libMesh::RBParameters::set_value().

Referenced by libMesh::RBConstruction::enrich_basis_from_rhs_terms(), libMesh::RBParametrized::initialize_parameters(), libMesh::RBDataDeserialization::load_parameter_ranges(), libMesh::RBSCMConstruction::perform_SCM_greedy(), libMesh::RBSCMConstruction::process_parameters_file(), libMesh::RBParametrized::read_parameter_data_from_files(), libMesh::RBEIMConstruction::set_rb_construction_parameters(), libMesh::RBConstruction::set_rb_construction_parameters(), RBParametersTest::testRBParametrized(), libMesh::RBEIMConstruction::train_eim_approximation_with_greedy(), libMesh::RBEIMConstruction::train_eim_approximation_with_POD(), libMesh::RBConstruction::train_reduced_basis_with_greedy(), and libMesh::RBConstruction::train_reduced_basis_with_POD().

{
  // Check that the min/max vectors have the same size.
  libmesh_error_msg_if(mu_min_in.n_parameters() != mu_max_in.n_parameters(),
                       "Error: Invalid mu_min/mu_max in initialize_parameters(), different number of parameters.");
  libmesh_error_msg_if(mu_min_in.n_samples() != 1 ||
                       mu_max_in.n_samples() != 1,
                       "Error: Invalid mu_min/mu_max in initialize_parameters(), only 1 sample supported.");

  // Ensure all the values are valid for min and max.
  auto pr_min = mu_min_in.begin_serialized();
  auto pr_max = mu_max_in.begin_serialized();
  for (; pr_min != mu_min_in.end_serialized(); ++pr_min, ++pr_max)
    libmesh_error_msg_if((*pr_min).second > (*pr_max).second,
                         "Error: Invalid mu_min/mu_max in RBParameters constructor.");

  parameters_min = mu_min_in;
  parameters_max = mu_max_in;

  // Add in min/max values due to the discrete parameters
  for (const auto & [name, vals] : discrete_parameter_values)
    {
      libmesh_error_msg_if(vals.empty(), "Error: List of discrete parameters for " << name << " is empty.");

      Real min_val = *std::min_element(vals.begin(), vals.end());
      Real max_val = *std::max_element(vals.begin(), vals.end());

      libmesh_assert_less_equal(min_val, max_val);

      parameters_min.set_value(name, min_val);
      parameters_max.set_value(name, max_val);
    }

    _discrete_parameter_values = discrete_parameter_values;

  parameters_initialized = true;

  // Initialize the current parameters to parameters_min
  set_parameters(parameters_min);
}

initialize_parameters() [2/2]

void libMesh::RBParametrized::initialize_parameters ( const RBParametrized &  rb_parametrized )

inherited

Initialize the parameter ranges and set current_parameters.

Definition at line 96 of file rb_parametrized.C.

References libMesh::RBParametrized::get_discrete_parameter_values(), libMesh::RBParametrized::get_parameters_max(), libMesh::RBParametrized::get_parameters_min(), and libMesh::RBParametrized::initialize_parameters().

{
  initialize_parameters(rb_parametrized.get_parameters_min(),
                        rb_parametrized.get_parameters_max(),
                        rb_parametrized.get_discrete_parameter_values());
}

is_discrete_parameter()

bool libMesh::RBParametrized::is_discrete_parameter ( const std::string &  mu_name ) const

inherited

Is parameter mu_name discrete?

Definition at line 363 of file rb_parametrized.C.

References libMesh::RBParametrized::_discrete_parameter_values, and libMesh::RBParametrized::parameters_initialized.

Referenced by libMesh::RBDataSerialization::add_parameter_ranges_to_builder(), libMesh::RBEIMConstruction::print_info(), libMesh::RBConstruction::print_info(), and libMesh::RBParametrized::write_parameter_ranges_to_file().

{
  libmesh_error_msg_if(!parameters_initialized, "Error: parameters not initialized in RBParametrized::is_discrete_parameter");

  return (_discrete_parameter_values.find(mu_name) != _discrete_parameter_values.end());
}

n_objects()

static unsigned int libMesh::ReferenceCounter::n_objects ( )

inlinestaticinherited

Prints the number of outstanding (created, but not yet destroyed) objects.

Definition at line 85 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

Referenced by libMesh::LibMeshInit::~LibMeshInit().

  { return _n_objects; }

n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns

The number of processors in the group.

Definition at line 103 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, libMesh::libmesh_assert(), and TIMPI::Communicator::size().

Referenced by libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DofMap::add_constraints_to_send_list(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::System::add_vector(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_scalar_dofs(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), gather_bfs(), libMesh::MeshBase::get_info(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::n_active_elem_on_proc(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), node_gather_bfs(), libMesh::Partitioner::partition(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::prepare_send_list(), libMesh::DofMap::print_dof_constraints(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), libMesh::CheckpointIO::read_nodes(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::System::read_serialized_vector(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::Partitioner::repartition(), OverlappingFunctorTest::run_partitioner_test(), libMesh::DofMap::scatter_constraints(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), WriteVecAndScalar::setupTests(), side_gather_bfs(), DistributedMeshTest::testRemoteElemError(), CheckpointIOTest::testSplitter(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::VTKIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

  {
    processor_id_type returnval =
      cast_int<processor_id_type>(_communicator.size());
    libmesh_assert(returnval); // We never have an empty comm
    return returnval;
  }

node_decrement_vector()

void RBEIMEvaluation::node_decrement_vector	(	NodeDataMap &	v,
		const DenseVector< Number > &	coeffs
	)

Same as decrement_vector() except for node data.

Definition at line 381 of file rb_eim_evaluation.C.

References _local_node_eim_basis_functions, get_n_basis_functions(), libMesh::index_range(), and libMesh::DenseVector< T >::size().

Referenced by libMesh::RBEIMConstruction::compute_max_eim_error(), and libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes().

{
  LOG_SCOPE("node_decrement_vector()", "RBEIMEvaluation");

  libmesh_error_msg_if(get_n_basis_functions() != coeffs.size(),
                       "Error: Number of coefficients should match number of basis functions");

  for (auto & [node_id, v_comps] : v)
    {
      for (const auto & comp : index_range(v_comps))
        for (unsigned int i : index_range(_local_node_eim_basis_functions))
          {
            // Check that entry (node_id,comp) exists in _local_node_eim_basis_functions so that
            // we get a clear error message if there is any missing data
            const auto & basis_comp = libmesh_map_find(_local_node_eim_basis_functions[i], node_id);

            libmesh_error_msg_if(comp >= basis_comp.size(), "Error: Invalid comp");

            v_comps[comp] -= coeffs(i) * basis_comp[comp];
          }
    }
}

node_distribute_bfs()

void RBEIMEvaluation::node_distribute_bfs ( const System &  sys )

private

Same as distribute_bfs() except for node data.

Definition at line 2601 of file rb_eim_evaluation.C.

References _local_node_eim_basis_functions, TIMPI::Communicator::broadcast(), clear(), libMesh::ParallelObject::comm(), TIMPI::Communicator::gather(), libMesh::System::get_mesh(), get_parametrized_function(), libMesh::RBParametrizedFunction::get_parametrized_function_boundary_ids(), libMesh::index_range(), libMesh::make_range(), mesh, n_vars, node_boundary_id, libMesh::DofObject::processor_id(), TIMPI::Communicator::rank(), TIMPI::Communicator::scatter(), and TIMPI::Communicator::size().

Referenced by read_in_node_basis_functions().

{
  // So we can avoid calling these many times below
  auto n_procs = sys.comm().size();
  auto rank = sys.comm().rank();

  // In serial there's nothing to distribute
  if (n_procs == 1)
    return;

  // Broadcast the number of basis functions from proc 0. After
  // distributing, all procs should have the same number of basis
  // functions.
  auto n_bf = _local_node_eim_basis_functions.size();
  sys.comm().broadcast(n_bf);

  // Allocate enough space to store n_bf basis functions on non-zero ranks
  if (rank != 0)
    _local_node_eim_basis_functions.resize(n_bf);

  // Broadcast the number of variables from proc 0. After
  // distributing, all procs should have the same number of variables.
  auto n_vars = _local_node_eim_basis_functions[0].begin()->second.size();
  sys.comm().broadcast(n_vars);

  // Construct lists of elem ids owned by different processors
  const MeshBase & mesh = sys.get_mesh();

  std::vector<dof_id_type> gathered_local_node_ids;
  {
    const std::set<boundary_id_type> & parametrized_function_boundary_ids =
      get_parametrized_function().get_parametrized_function_boundary_ids();

    const auto & binfo = mesh.get_boundary_info();

    // Make a set with all the nodes that have nodesets. Use
    // a set so that we don't have any duplicate entries. We
    // deal with duplicate entries below by getting all boundary
    // IDs on each node.
    std::set<dof_id_type> nodes_with_nodesets;
    for (const auto & t : binfo.build_node_list())
      nodes_with_nodesets.insert(std::get<0>(t));

    // To be filled in by BoundaryInfo calls in loop below
    std::vector<boundary_id_type> node_boundary_ids;

    for(dof_id_type node_id : nodes_with_nodesets)
      {
        const Node * node = mesh.node_ptr(node_id);

        if (node->processor_id() != mesh.comm().rank())
          continue;

        binfo.boundary_ids(node, node_boundary_ids);

        bool has_node_boundary_id = false;
        for(boundary_id_type node_boundary_id : node_boundary_ids)
          if(parametrized_function_boundary_ids.count(node_boundary_id))
            {
              has_node_boundary_id = true;
              break;
            }

        if(has_node_boundary_id)
          {
            gathered_local_node_ids.push_back(node_id);
          }
      }
  }

  // I _think_ the local node ids are likely to already be sorted in
  // ascending order, since that is how they are stored on the Mesh,
  // but we can always just guarantee this to be on the safe side as
  // well.
  std::sort(gathered_local_node_ids.begin(), gathered_local_node_ids.end());

  // Gather the number of local nodes from all procs to proc 0
  auto n_local_nodes = gathered_local_node_ids.size();
  std::vector<std::size_t> gathered_n_local_nodes = {n_local_nodes};
  sys.comm().gather(/*root_id=*/0, gathered_n_local_nodes);

  // Gather the node ids owned by each processor onto processor 0.
  sys.comm().gather(/*root_id=*/0, gathered_local_node_ids);

  // Construct vectors of "start" and "one-past-the-end" indices into
  // the gathered_local_node_ids vector for each proc. Only valid on
  // processor 0.
  std::vector<std::size_t> start_node_ids_index, end_node_ids_index;

  if (rank == 0)
    {
      start_node_ids_index.resize(n_procs);
      start_node_ids_index[0] = 0;
      for (processor_id_type p=1; p<n_procs; ++p)
        start_node_ids_index[p] = start_node_ids_index[p-1] + gathered_n_local_nodes[p-1];

      end_node_ids_index.resize(n_procs);
      end_node_ids_index[n_procs - 1] = gathered_local_node_ids.size();
      for (processor_id_type p=0; p<n_procs - 1; ++p)
        end_node_ids_index[p] = start_node_ids_index[p+1];
    }

  // On processor 0, using basis function 0 and variable 0, prepare a
  // vector with the nodes.  Then scatter this vector
  // out to the processors that require it. The order of this vector
  // matches the gathered_local_node_ids ordering. The counts will be
  // gathered_n_local_nodes.

  // On rank 0, the "counts" vector holds the number of floating point values that
  // are to be scattered to each proc. It is only required on proc 0.
  std::vector<int> counts;

  if (rank == 0)
    {
      counts.resize(n_procs);

      for (processor_id_type p=0; p<n_procs; ++p)
        {
          auto node_ids_range = (end_node_ids_index[p] - start_node_ids_index[p]);

          // Accumulate the count for this proc
          counts[p] += node_ids_range;
        } // end for proc_id
    } // if (rank == 0)

  // The recv_node_data vector will be used on the receiving end of all
  // the scatters below.
  std::vector<Number> recv_node_data;

  // For each basis function and each variable, build a vector
  // data in the Node ordering given by the
  // gathered_local_node_ids, then call
  //
  // sys.comm().scatter(data, counts, recv, /*root_id=*/0);
  std::vector<std::vector<Number>> node_data(n_vars);

  // We also reserve space in node_data, since we will push_back into it below.
  int count_sum = std::accumulate(counts.begin(), counts.end(), 0);
  for (auto var : index_range(node_data))
    node_data[var].reserve(count_sum);

  // Loop from 0..n_bf on _all_ procs, since the scatters inside this
  // loop are collective.
  for (auto bf : make_range(n_bf))
    {
      // Prepare data for scattering (only on proc 0)
      if (rank == 0)
        {
          // Reference to the data map for the current basis function.
          auto & bf_map = _local_node_eim_basis_functions[bf];

          // Clear any data from previous bf (this does not change the capacity
          // that was reserved above).
          for (auto var : index_range(node_data))
              node_data[var].clear();

          for (processor_id_type p=0; p<n_procs; ++p)
            {
              for (auto n : make_range(start_node_ids_index[p], end_node_ids_index[p]))
                {
                  auto node_id = gathered_local_node_ids[n];

                  // Get reference to array[n_vars] for current Node.
                  // Throws an error if the required node_id is not found.
                  const auto & array = libmesh_map_find(bf_map, node_id);

                  for (auto var : index_range(array))
                    node_data[var].push_back(array[var]);
                } // end for (n)
            } // end for proc_id
        } // end if rank==0

      // Perform the scatters (all procs)
      for (auto var : make_range(n_vars))
        {
          // Do the scatter for the current var
          sys.comm().scatter(node_data[var], counts, recv_node_data, /*root_id=*/0);

          if (rank != 0)
            {
              // Store the scattered data we received in _local_eim_basis_functions[bf]
              auto & bf_map = _local_node_eim_basis_functions[bf];
              auto cursor = recv_node_data.begin();

              for (auto i : index_range(gathered_local_node_ids))
                {
                  auto node_id = gathered_local_node_ids[i];
                  auto & array = bf_map[node_id];

                  // Create space to store the data if it doesn't already exist.
                  if (array.empty())
                    array.resize(n_vars);

                  // There is only one value per variable per node, so
                  // we set the value by de-referencing cursor, and
                  // then advance the cursor by 1.
                  array[var] = *cursor;
                  std::advance(cursor, 1);
                }
            } // if (rank != 0)
        } // end for (var)
    } // end for (bf)

  // Now that the scattering is done, delete non-local Elem
  // information from processor 0's _local_eim_basis_functions data
  // structure.
  if (rank == 0)
    {
      for (processor_id_type p=1; p<n_procs; ++p)
        {
          for (auto n : make_range(start_node_ids_index[p], end_node_ids_index[p]))
            {
              auto node_id = gathered_local_node_ids[n];

              // Delete this Node's information from every basis function.
              for (auto & bf_map : _local_node_eim_basis_functions)
                bf_map.erase(node_id);
            } // end for (n)
        } // end for proc_id
    } // if (rank == 0)
}

node_gather_bfs()

void RBEIMEvaluation::node_gather_bfs ( )

private

Same as gather_bfs() except for node data.

Definition at line 1980 of file rb_eim_evaluation.C.

References _local_node_eim_basis_functions, libMesh::ParallelObject::comm(), TIMPI::Communicator::gather(), libMesh::index_range(), TIMPI::Communicator::max(), libMesh::ParallelObject::n_processors(), n_vars, libMesh::ParallelObject::processor_id(), and TIMPI::Communicator::verify().

Referenced by write_out_node_basis_functions().

{
  // We need to gather _local_node_eim_basis_functions data from other
  // procs for printing.
  //
  // Ideally, this could be accomplished by simply calling:
  // this->comm().gather(/*root_id=*/0, _local_node_eim_basis_functions);
  //
  // but the data structure seems to be too complicated for this to
  // work automatically. (I get some error about the function called
  // being "private within this context".) Therefore, we have to
  // gather the information manually.

  // So we can avoid calling this many times below
  auto n_procs = this->n_processors();

  // In serial there's nothing to gather
  if (n_procs == 1)
    return;

  // Current assumption is that the number of basis functions stored on
  // each processor is the same, the only thing that differs is the number
  // of elements, so make sure that is the case now.
  auto n_bf = _local_node_eim_basis_functions.size();
  this->comm().verify(n_bf);

  // This function should never be called if there are no basis
  // functions, so if it was, something went wrong.
  libmesh_error_msg_if(!n_bf, "RBEIMEvaluation::gather_bfs() should not be called with 0 basis functions.");

  // The number of variables should be the same on all processors
  // and we can get this from _local_eim_basis_functions. However,
  // it may be that some processors have no local elements, so on
  // those processors we cannot look up the size from
  // _local_eim_basis_functions. As a result we use comm().max(n_vars)
  // to make sure all processors agree on the final value.
  std::size_t n_vars =
    _local_node_eim_basis_functions[0].empty() ? 0 : _local_node_eim_basis_functions[0].begin()->second.size();
  this->comm().max(n_vars);

  // Gather list of Node ids stored on each processor to proc 0.  We
  // use basis function 0 as an example and assume all the basis
  // functions are distributed similarly.
  unsigned int n_local_nodes = _local_node_eim_basis_functions[0].size();
  std::vector<dof_id_type> node_ids;
  node_ids.reserve(n_local_nodes);
  for (const auto & pr : _local_node_eim_basis_functions[0])
    node_ids.push_back(pr.first);
  this->comm().gather(/*root_id=*/0, node_ids);

  // Now we construct a vector for each basis function, for each
  // variable, which is ordered according to:
  // [ [val for Node 0], [val for Node 1], ... [val for Node N] ]
  // and gather it to processor 0.
  std::vector<std::vector<Number>> gathered_node_data(n_vars);
  for (auto bf : index_range(_local_node_eim_basis_functions))
    {
      // Clear any data from previous bf
      for (auto var : index_range(gathered_node_data))
        {
          gathered_node_data[var].clear();
          gathered_node_data[var].resize(n_local_nodes);
        }

      unsigned int local_node_idx = 0;
      for (const auto & pr : _local_node_eim_basis_functions[bf])
        {
          // array[n_vars] per Node
          const auto & array = pr.second;
          for (auto var : index_range(array))
            {
              gathered_node_data[var][local_node_idx] = array[var];
            }

          local_node_idx++;
        }

      // Reference to the data map for the current basis function.
      auto & bf_map = _local_node_eim_basis_functions[bf];

      for (auto var : index_range(gathered_node_data))
        {
          // For each var, gather gathered_qp_data[var] onto processor
          // 0. There apparently is not a gather overload for
          // vector-of-vectors...
          this->comm().gather(/*root_id=*/0, gathered_node_data[var]);

          // On processor 0, iterate over the gathered_qp_data[var]
          // vector we just gathered, filling in the "small" vectors
          // for each Elem. Note: here we ignore the fact that we
          // already have the data on processor 0 and just overwrite
          // it, this makes the indexing logic a bit simpler.
          if (this->processor_id() == 0)
            {
              auto cursor = gathered_node_data[var].begin();
              for (auto i : index_range(node_ids))
                {
                  auto node_id = node_ids[i];

                  // Get reference to the [n_vars] array for
                  // this Node. We assign() into the vector of
                  // node values, which allocates space if
                  // it doesn't already exist.
                  auto & array = bf_map[node_id];

                  // Possibly allocate space if this is data for a new
                  // node we haven't seen before.
                  if (array.empty())
                    array.resize(n_vars);

                  // There is only one value per variable per node, so
                  // we set the value by de-referencing cursor, and
                  // then advance the cursor by 1.
                  array[var] = *cursor;
                  std::advance(cursor, 1);
                }
            }
        }
    } // end loop over basis functions
}

operator=() [1/2]

RBEIMEvaluation& libMesh::RBEIMEvaluation::operator= ( const RBEIMEvaluation &  )

delete

operator=() [2/2]

RBEIMEvaluation& libMesh::RBEIMEvaluation::operator= ( RBEIMEvaluation &&  )

default

print_discrete_parameter_values()

void libMesh::RBParametrized::print_discrete_parameter_values ( ) const

inherited

Print out all the discrete parameter values.

Definition at line 377 of file rb_parametrized.C.

References libMesh::RBParametrized::get_discrete_parameter_values(), libMesh::Quality::name(), libMesh::out, and value.

Referenced by libMesh::RBSCMConstruction::print_info(), libMesh::RBEIMConstruction::print_info(), and libMesh::RBConstruction::print_info().

{
  for (const auto & [name, values] : get_discrete_parameter_values())
    {
      libMesh::out << "Discrete parameter " << name << ", values: ";

      for (const auto & value : values)
        libMesh::out << value << " ";
      libMesh::out << std::endl;
    }
}

print_info()

void libMesh::ReferenceCounter::print_info ( std::ostream &  out_stream = libMesh::out )

staticinherited

Prints the reference information, by default to libMesh::out.

Definition at line 81 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter, and libMesh::ReferenceCounter::get_info().

Referenced by libMesh::LibMeshInit::~LibMeshInit().

{
  if (_enable_print_counter)
    out_stream << ReferenceCounter::get_info();
}

print_local_eim_basis_functions()

void RBEIMEvaluation::print_local_eim_basis_functions ( ) const

private

Print the contents of _local_eim_basis_functions to libMesh::out.

Helper function mainly useful for debugging.

Definition at line 1633 of file rb_eim_evaluation.C.

References _local_eim_basis_functions, _local_node_eim_basis_functions, _local_side_eim_basis_functions, libMesh::index_range(), and libMesh::out.

{
  for (auto bf : index_range(_local_eim_basis_functions))
    {
      libMesh::out << "Interior basis function " << bf << std::endl;
      for (const auto & [elem_id, array] : _local_eim_basis_functions[bf])
        {
          libMesh::out << "Elem " << elem_id << std::endl;
          for (auto var : index_range(array))
            {
              libMesh::out << "Variable " << var << std::endl;
              for (auto qp : index_range(array[var]))
                libMesh::out << array[var][qp] << " ";
              libMesh::out << std::endl;
            }
        }
    }

  for (auto bf : index_range(_local_side_eim_basis_functions))
    {
      libMesh::out << "Side basis function " << bf << std::endl;
      for (const auto & [pr, array] : _local_side_eim_basis_functions[bf])
        {
          const auto & elem_id = pr.first;
          const auto & side_index = pr.second;
          libMesh::out << "Elem " << elem_id << ", Side " << side_index << std::endl;
          for (auto var : index_range(array))
            {
              libMesh::out << "Variable " << var << std::endl;
              for (auto qp : index_range(array[var]))
                libMesh::out << array[var][qp] << " ";
              libMesh::out << std::endl;
            }
        }
    }

  for (auto bf : index_range(_local_node_eim_basis_functions))
    {
      libMesh::out << "Node basis function " << bf << std::endl;
      for (const auto & [node_id, array] : _local_node_eim_basis_functions[bf])
        {
          libMesh::out << "Node " << node_id << std::endl;
          for (auto var : index_range(array))
            {
              libMesh::out << "Variable " << var << ": " << array[var] << std::endl;
            }
          libMesh::out << std::endl;
        }
    }
}

print_parameters()

void libMesh::RBParametrized::print_parameters ( ) const

inherited

Print the current parameters.

Definition at line 190 of file rb_parametrized.C.

References libMesh::RBParametrized::get_parameters(), libMesh::RBParametrized::parameters_initialized, and libMesh::RBParameters::print().

Referenced by libMesh::RBEIMConstruction::train_eim_approximation_with_greedy(), and libMesh::RBConstruction::train_reduced_basis_with_greedy().

{
  libmesh_error_msg_if(!parameters_initialized, "Error: parameters not initialized in RBParametrized::print_current_parameters");

  get_parameters().print();
}

processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns

The rank of this processor in the group.

Definition at line 114 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, and TIMPI::Communicator::rank().

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::Partitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::ExodusII_IO_Helper::close(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::compute_communication_map_parameters(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_node_communication_maps(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::DistributedMesh::delete_elem(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofMap::distribute_scalar_dofs(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMap::end_dof(), libMesh::DofMap::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::MeshFunction::find_element(), libMesh::MeshFunction::find_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMap::first_dof(), libMesh::DofMap::first_old_dof(), gather_bfs(), libMesh::Nemesis_IO_Helper::get_cmap_params(), libMesh::Nemesis_IO_Helper::get_eb_info_global(), libMesh::Nemesis_IO_Helper::get_elem_cmap(), libMesh::Nemesis_IO_Helper::get_elem_map(), libMesh::MeshBase::get_info(), libMesh::DofMap::get_info(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::DofMap::get_local_constraints(), libMesh::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::LaplaceMeshSmoother::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), HeatSystem::init_data(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::DistributedMesh::insert_elem(), libMesh::DofMap::is_evaluable(), libMesh::SparsityPattern::Build::join(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DofMap::local_variable_indices(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMap::n_local_dofs(), libMesh::System::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), node_gather_bfs(), libMesh::SparsityPattern::Build::operator()(), libMesh::DistributedMesh::own_node(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Nemesis_IO_Helper::put_cmap_params(), libMesh::Nemesis_IO_Helper::put_elem_cmap(), libMesh::Nemesis_IO_Helper::put_elem_map(), libMesh::Nemesis_IO_Helper::put_loadbal_param(), libMesh::Nemesis_IO_Helper::put_node_cmap(), libMesh::Nemesis_IO_Helper::put_node_map(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::ExodusII_IO::read_header(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::System::read_legacy_data(), libMesh::DynaIO::read_mesh(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::System::read_serialized_data(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), side_gather_bfs(), ExodusTest< elem_type >::test_read_gold(), ExodusTest< elem_type >::test_write(), MeshInputTest::testAbaqusRead(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), MeshInputTest::testCopyNodalSolutionImpl(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), MeshInputTest::testDynaFileMappings(), MeshInputTest::testDynaNoSplines(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusFileMappings(), MeshInputTest::testExodusIGASidesets(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), MeshInputTest::testLowOrderEdgeBlocks(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testSingleElementImpl(), WriteVecAndScalar::testSolution(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_element_values_element_major(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elemset_data(), libMesh::ExodusII_IO_Helper::write_elemsets(), libMesh::ExodusII_IO::write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::System::write_header(), libMesh::ExodusII_IO::write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::UCDIO::write_nodal_data(), libMesh::VTKIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_common(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::ExodusII_IO_Helper::write_nodeset_data(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), write_out_interior_basis_functions(), write_out_node_basis_functions(), write_out_side_basis_functions(), write_output_solvedata(), libMesh::System::write_parallel_data(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::System::write_serialized_data(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::System::write_serialized_vector(), libMesh::System::write_serialized_vectors(), libMesh::ExodusII_IO_Helper::write_sideset_data(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), libMesh::ExodusII_IO_Helper::write_timestep(), and libMesh::ExodusII_IO::write_timestep_discontinuous().

  { return cast_int<processor_id_type>(_communicator.rank()); }

project_qp_data_map_onto_system()

void RBEIMEvaluation::project_qp_data_map_onto_system ( System &  sys, const QpDataMap &  bf_data, const EIMVarGroupPlottingInfo &  eim_vargroup  )

virtual

Project the specified variable of bf_data into the solution vector of System.

This method is virtual so that it can be overridden in sub-classes, e.g. to perform a specialized type of projection.

Definition at line 2823 of file rb_eim_evaluation.C.

References libMesh::DenseMatrix< T >::cholesky_solve(), libMesh::System::current_local_solution, dim, libMesh::MeshBase::elem_dimensions(), libMesh::FEMContext::elem_fe_reinit(), libMesh::EIMVarGroupPlottingInfo::first_eim_var_index, libMesh::DiffContext::get_dof_indices(), libMesh::FEMContext::get_element_fe(), libMesh::FEMContext::get_element_qrule(), libMesh::FEAbstract::get_JxW(), libMesh::System::get_mesh(), libMesh::FEGenericBase< OutputType >::get_phi(), libMesh::make_range(), libMesh::QBase::n_points(), libMesh::System::n_vars(), libMesh::FEMContext::pre_fe_reinit(), and libMesh::System::solution.

Referenced by write_out_projected_basis_functions().

{
  LOG_SCOPE("project_basis_function_onto_system()", "RBEIMEvaluation");

  libmesh_error_msg_if(sys.n_vars() == 0, "System must have at least one variable");

  // TODO: Currently only implemented for the case of one variable in a variable group
  unsigned int var = eim_vargroup.first_eim_var_index;

  FEMContext context(sys);
  {
    // Pre-request relevant data for all dimensions
    for (unsigned int dim=1; dim<=3; ++dim)
      if (sys.get_mesh().elem_dimensions().count(dim))
        for (auto init_var : make_range(sys.n_vars()))
        {
          auto fe = context.get_element_fe(init_var, dim);
          fe->get_JxW();
          fe->get_phi();
        }
  }

  FEBase * elem_fe = nullptr;
  context.get_element_fe( 0, elem_fe );
  const std::vector<Real> & JxW = elem_fe->get_JxW();
  const std::vector<std::vector<Real>> & phi = elem_fe->get_phi();

  // Get a reference to the current_local_solution vector, which has
  // GHOSTED DOFs. Make sure it is initially zeroed, since we will now
  // accumulate values into it.
  auto & current_local_soln = *(sys.current_local_solution);
  current_local_soln.zero();

  // The repeat_count vector will store the number of times a
  // projected value has been assigned to a node. We get a reference
  // to it for convenience in the code below.
  std::unique_ptr<NumericVector<Number>> repeat_count_ptr = current_local_soln.zero_clone();
  auto & repeat_count = *repeat_count_ptr;

  for (const auto & elem : sys.get_mesh().active_local_element_ptr_range())
    {
      context.pre_fe_reinit(sys, elem);
      context.elem_fe_reinit();

      const std::vector<dof_id_type> & dof_indices = context.get_dof_indices(/*var=*/0);
      unsigned int n_proj_dofs = dof_indices.size();
      unsigned int n_qpoints = context.get_element_qrule().n_points();

      const std::vector<std::vector<Number>> & var_and_qp_data = libmesh_map_find(qp_data_map, elem->id());
      libmesh_error_msg_if(var >= var_and_qp_data.size(), "Invalid EIM variable number: " << var);
      const std::vector<Number> & qp_data = var_and_qp_data[var];

      // If qp_data doesn't match n_qpoints then we skip this element since this means
      // that the EIM basis function is not applicable on this element. This can happen,
      // for example, if we have 1D and 3D elements in the same mesh and the EIM basis
      // functions have been set up for the 3D elements only. Note that the EIM is
      // necessarily dependent on the element dimension since it is based on the number
      // of quad. points per element. If multiple dimensions need to be supported then
      // one can add a separate EIM for each dimension.
      if (qp_data.size() != n_qpoints)
        continue;

      DenseMatrix<Number> Me(n_proj_dofs, n_proj_dofs);
      DenseVector<Number> Fe(n_proj_dofs);
      for (auto qp : make_range(n_qpoints))
        for (auto i : make_range(n_proj_dofs))
          {
            Fe(i) += JxW[qp] * qp_data[qp] * phi[i][qp];

            for (auto j : make_range(n_proj_dofs))
              Me(i,j) += JxW[qp] * phi[i][qp] * phi[j][qp];
          }

      DenseVector<Number> projected_data;
      Me.cholesky_solve(Fe, projected_data);

      for (auto i : make_range(n_proj_dofs))
        {
          current_local_soln.add(dof_indices[i], projected_data(i));
          repeat_count.add(dof_indices[i], 1.);
        }
    }

  current_local_soln.close();
  repeat_count.close();

  // Average the projected QP values to get nodal values
  current_local_soln /= repeat_count;
  current_local_soln.close();

  // Copy values from the GHOSTED current_local_solution vector into
  // sys.solution, since that is what will ultimately be plotted/used
  // by other parts of the code.
  (*sys.solution) = current_local_soln;
}

rb_eim_solve()

DenseVector< Number > RBEIMEvaluation::rb_eim_solve

(

DenseVector< Number > &

EIM_rhs

)

Calculate the EIM approximation for the given right-hand side vector EIM_rhs.

Store the solution coefficients in the member _eim_solution.

Definition at line 105 of file rb_eim_evaluation.C.

References _interpolation_matrix, get_n_basis_functions(), libMesh::DenseMatrix< T >::get_principal_submatrix(), libMesh::DenseMatrix< T >::lu_solve(), and libMesh::DenseVector< T >::size().

Referenced by libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), and libMesh::RBEIMConstruction::store_eim_solutions_for_training_set().

{
  LOG_SCOPE("rb_eim_solve()", "RBEIMEvaluation");

  libmesh_error_msg_if(EIM_rhs.size() > get_n_basis_functions(),
                       "Error: N cannot be larger than the number of basis functions in rb_solve");

  libmesh_error_msg_if(EIM_rhs.size()==0, "Error: N must be greater than 0 in rb_solve");

  const unsigned int N = EIM_rhs.size();
  DenseVector<Number> rb_eim_solution(N);
  DenseMatrix<Number> interpolation_matrix_N;
  _interpolation_matrix.get_principal_submatrix(N, interpolation_matrix_N);

  interpolation_matrix_N.lu_solve(EIM_rhs, rb_eim_solution);

  return rb_eim_solution;
}

rb_eim_solves()

void RBEIMEvaluation::rb_eim_solves	(	const std::vector< RBParameters > &	mus,
		unsigned int	N
	)

Perform rb_eim_solves at each mu in mus and store the results in _rb_eim_solutions.

Definition at line 124 of file rb_eim_evaluation.C.

References _eim_solutions_for_training_set, _interpolation_matrix, _interpolation_points_comp, _is_eim_error_indicator_active, _preserve_rb_eim_solutions, _rb_eim_error_indicators, _rb_eim_solutions, _rb_eim_solves_mus, _rb_eim_solves_N, _vec_eval_input, get_eim_error_indicator(), get_n_basis_functions(), get_parametrized_function(), libMesh::DenseMatrix< T >::get_principal_submatrix(), libMesh::index_range(), libMesh::libmesh_ignore(), libMesh::DenseMatrix< T >::lu_solve(), libMesh::make_range(), libMesh::RBParametrizedFunction::node_vectorized_evaluate(), libMesh::Real, libMesh::RBParametrizedFunction::side_vectorized_evaluate(), and libMesh::RBParametrizedFunction::vectorized_evaluate().

Referenced by libMesh::RBEIMConstruction::compute_max_eim_error(), and libMesh::RBEIMTheta::evaluate_vec().

{
  if (_preserve_rb_eim_solutions)
    {
      // In this case we preserve _rb_eim_solutions and hence we
      // just return immediately so that we skip updating
      // _rb_eim_solutions below. This is relevant in cases where
      // we set up _rb_eim_solutions elsewhere and we don't want
      // to override it.
      return;
    }

  libmesh_error_msg_if(N > get_n_basis_functions(),
    "Error: N cannot be larger than the number of basis functions in rb_eim_solves");
  libmesh_error_msg_if(N==0, "Error: N must be greater than 0 in rb_eim_solves");

  // If mus and N are the same as before, then we return early
  if ((_rb_eim_solves_mus == mus) && (_rb_eim_solves_N == N))
    return;

  LOG_SCOPE("rb_eim_solves()", "RBEIMEvaluation");

  _rb_eim_solves_mus = mus;
  _rb_eim_solves_N = N;

  if (get_parametrized_function().is_lookup_table)
    {
      _rb_eim_solutions.resize(mus.size());
      for (auto mu_index : index_range(mus))
        {
          Real lookup_table_param =
            mus[mu_index].get_value(get_parametrized_function().lookup_table_param_name);

          // Cast lookup_table_param to an unsigned integer so that we can use
          // it as an index into the EIM rhs values obtained from the lookup table.
          unsigned int lookup_table_index =
            cast_int<unsigned int>(std::round(lookup_table_param));

          DenseVector<Number> values;
          _eim_solutions_for_training_set[lookup_table_index].get_principal_subvector(N, values);
          _rb_eim_solutions[mu_index] = values;
        }

      return;
    }

  // output all comps indexing is as follows:
  //   mu index --> interpolation point index --> component index --> value.
  std::vector<std::vector<std::vector<Number>>> output_all_comps;
  if (get_parametrized_function().on_mesh_sides())
    get_parametrized_function().side_vectorized_evaluate(mus, _vec_eval_input, output_all_comps);
  else if (get_parametrized_function().on_mesh_nodes())
    get_parametrized_function().node_vectorized_evaluate(mus, _vec_eval_input, output_all_comps);
  else
    get_parametrized_function().vectorized_evaluate(mus, _vec_eval_input, output_all_comps);

  // Previously we did one RB-EIM solve per input mu, but now we do
  // one RB-EIM solve per input mu, per sample. In order for this to
  // work, we require that all the input mu objects have the same
  // number of samples.
  auto n_samples_0 = mus[0].n_samples();
  for (const auto & mu : mus)
    libmesh_error_msg_if(mu.n_samples() != n_samples_0, "All RBParameters objects must have same n_samples()");

  // After we verified that all mus have the same number of samples,
  // the total number of RB-EIM solves is simply the number of mus
  // times the number of samples.
  unsigned int num_rb_eim_solves = mus.size() * n_samples_0;

  // A special case is when we are passed a single RBParameters object
  // with no parameters stored on it. In this case, we effectively
  // have Theta(mu) == const, and therefore we still need to do at
  // least one RB-EIM solve. In this case, we require that there is
  // only one entry in "mus" for simplicity.
  if (num_rb_eim_solves == 0 && mus[0].n_parameters() == 0)
    {
      libmesh_error_msg_if(mus.size() != 1, "Must pass in only a single RBParameters object when solving with no parameters.");
      num_rb_eim_solves = 1;
    }

  std::vector<std::vector<Number>> evaluated_values_at_interp_points(num_rb_eim_solves);

  std::vector<Number> evaluated_values_at_err_indicator_point;
  if (_is_eim_error_indicator_active)
    evaluated_values_at_err_indicator_point.resize(num_rb_eim_solves);

  // In this loop, counter goes from 0 to num_rb_eim_solves.  The
  // purpose of this loop is to strip out the "columns" of the
  // output_all_comps array into rows.
  {
    unsigned int counter = 0;
    for (auto mu_index : index_range(mus))
      for (auto sample_index : make_range(mus[mu_index].n_samples()))
      {
        // Ignore compiler warnings about unused loop index
        libmesh_ignore(sample_index);

        evaluated_values_at_interp_points[counter].resize(N);

        for (unsigned int interp_pt_index=0; interp_pt_index<N; interp_pt_index++)
          {
            unsigned int comp = _interpolation_points_comp[interp_pt_index];

            // This line of code previously used "mu_index", now we use
            // "counter" handle the multi-sample RBParameters case.
            evaluated_values_at_interp_points[counter][interp_pt_index] =
              output_all_comps[counter][interp_pt_index][comp];
          }

        if (_is_eim_error_indicator_active)
          {
            unsigned int comp = _interpolation_points_comp[N];

            evaluated_values_at_err_indicator_point[counter] =
              output_all_comps[counter][N][comp];
          }

        counter++;
      }

    // Throw an error if we didn't do the required number of solves for
    // some reason
    libmesh_error_msg_if(counter != num_rb_eim_solves,
                        "We should have done " << num_rb_eim_solves <<
                        " solves, instead we did " << counter);
  }

  DenseMatrix<Number> interpolation_matrix_N;
  _interpolation_matrix.get_principal_submatrix(N, interpolation_matrix_N);

  // The number of RB EIM solutions is equal to the size of the
  // "evaluated_values_at_interp_points" vector which we determined
  // earlier.
  _rb_eim_solutions.resize(num_rb_eim_solves);
  if (_is_eim_error_indicator_active)
    _rb_eim_error_indicators.resize(num_rb_eim_solves);

  {
    unsigned int counter = 0;
    for (auto mu_index : index_range(mus))
      for (auto sample_index : make_range(mus[mu_index].n_samples()))
      {
        // Ignore compiler warnings about unused loop index
        libmesh_ignore(sample_index);

        DenseVector<Number> EIM_rhs = evaluated_values_at_interp_points[counter];
        interpolation_matrix_N.lu_solve(EIM_rhs, _rb_eim_solutions[counter]);

        // If we're using the EIM error indicator, then we compute it via the approach
        // proposed in Proposition 3.3 of "An empirical interpolation method: application
        // to efficient reduced-basis discretization of partial differential equations",
        // Barrault et al.
        if (_is_eim_error_indicator_active)
          {
            Number error_indicator_rhs = evaluated_values_at_err_indicator_point[counter];
            _rb_eim_error_indicators[counter] =
              get_eim_error_indicator(
                error_indicator_rhs, _rb_eim_solutions[counter], EIM_rhs).first;
          }

        counter++;
      }
  }
}

read_in_basis_functions()

void RBEIMEvaluation::read_in_basis_functions	(	const System &	sys,
		const std::string &	directory_name = "offline_data",
		bool	read_binary_basis_functions = true
	)

Read in all the basis functions from file.

Parameters

sys	The Mesh in this System determines the parallel distribution of the basis functions.
directory_name	Specifies which directory to write files to.
read_binary_basis_functions	Indicates whether to expect binary or ASCII data.

Note: this is not a virtual function and is not related to the RBEvaluation function of the same name.

Definition at line 1327 of file rb_eim_evaluation.C.

References get_n_basis_functions(), get_parametrized_function(), read_in_interior_basis_functions(), read_in_node_basis_functions(), and read_in_side_basis_functions().

{
  LOG_SCOPE("read_in_basis_functions()", "RBEIMEvaluation");

  // Return early without reading in anything if there are no basis functions
  if (get_n_basis_functions() == 0)
    return;

  if (get_parametrized_function().on_mesh_sides())
    read_in_side_basis_functions(sys, directory_name, read_binary_basis_functions);
  else if (get_parametrized_function().on_mesh_nodes())
    read_in_node_basis_functions(sys, directory_name, read_binary_basis_functions);
  else
    read_in_interior_basis_functions(sys, directory_name, read_binary_basis_functions);
}

read_in_interior_basis_functions()

void RBEIMEvaluation::read_in_interior_basis_functions ( const System &  sys, const std::string &  directory_name, bool  read_binary_basis_functions  )

private

Method that reads in element interior EIM basis functions.

This may be called by read_in_basis_functions().

Definition at line 1346 of file rb_eim_evaluation.C.

References _local_eim_basis_functions, libMesh::ParallelObject::comm(), libMesh::Xdr::data(), libMesh::DECODE, distribute_bfs(), libMesh::index_range(), libMesh::MeshTools::n_elem(), n_vars, TIMPI::Communicator::rank(), and libMesh::READ.

Referenced by read_in_basis_functions().

{
  LOG_SCOPE("read_in_interior_basis_functions()", "RBEIMEvaluation");

  // Read values on processor 0 only.
  if (sys.comm().rank() == 0)
    {
      // Create filename
      std::ostringstream file_name;
      const std::string basis_function_suffix = (read_binary_basis_functions ? ".xdr" : ".dat");
      file_name << directory_name << "/" << "bf_data" << basis_function_suffix;

      // Create XDR reader object
      Xdr xdr(file_name.str(), read_binary_basis_functions ? DECODE : READ);

      // Read in the number of basis functions. The comment parameter
      // is ignored when reading.
      std::size_t n_bf;
      xdr.data(n_bf);

      // Read in the number of elements
      std::size_t n_elem;
      xdr.data(n_elem);

      // Read in the number of variables.
      std::size_t n_vars;
      xdr.data(n_vars);

      // Read in vector containing the number of QPs per elem. We can
      // create this vector with the required size or let it be read
      // from the file and sized for us.
      std::vector<unsigned int> n_qp_per_elem(n_elem);
      xdr.data(n_qp_per_elem);

      // The total amount of qp data for each var is the sum of the
      // entries in the "n_qp_per_elem" array.
      auto n_qp_data =
        std::accumulate(n_qp_per_elem.begin(),
                        n_qp_per_elem.end(),
                        0u);

      // Allocate space to store all required basis functions,
      // clearing any data that may have been there previously.
      //
      // TODO: Do we need to also write out/read in Elem ids?
      // Or can we assume they will always be contiguously
      // numbered (at least on proc 0)?
      _local_eim_basis_functions.clear();
      _local_eim_basis_functions.resize(n_bf);
      for (auto i : index_range(_local_eim_basis_functions))
        for (std::size_t elem_id=0; elem_id<n_elem; ++elem_id)
          {
            auto & array = _local_eim_basis_functions[i][elem_id];
            array.resize(n_vars);
          }

      // Allocate temporary storage for one var's worth of qp data.
      std::vector<Number> qp_data;

      // Read in data for each basis function
      for (auto i : index_range(_local_eim_basis_functions))
        {
          // Reference to the data map for the current basis function.
          auto & bf_map = _local_eim_basis_functions[i];

          for (std::size_t var=0; var<n_vars; ++var)
            {
              qp_data.clear();
              qp_data.resize(n_qp_data);

              // Read data using data_stream() since that is
              // (currently) how we write it out. The "line_break"
              // parameter of data_stream() is ignored while reading.
              xdr.data_stream(qp_data.data(), qp_data.size());

              // Iterate over the qp_data vector, filling in the
              // "small" vectors for each Elem.
              auto cursor = qp_data.begin();
              for (std::size_t elem_id=0; elem_id<n_elem; ++elem_id)
                {
                  // Get reference to the [n_vars][n_qp] array for
                  // this Elem. We assign() into the vector of
                  // quadrature point values, which allocates space if
                  // it doesn't already exist.
                  auto & array = bf_map[elem_id];
                  array[var].assign(cursor, cursor + n_qp_per_elem[elem_id]);
                  std::advance(cursor, n_qp_per_elem[elem_id]);
                }
            } // end for (var)
        } // end for (i)
    } // end if processor 0

  // Distribute the basis function information to the processors that require it
  this->distribute_bfs(sys);
}

read_in_node_basis_functions()

void RBEIMEvaluation::read_in_node_basis_functions ( const System &  sys, const std::string &  directory_name, bool  read_binary_basis_functions  )

private

Method that reads in element node EIM basis functions.

This may be called by read_in_basis_functions().

Definition at line 1553 of file rb_eim_evaluation.C.

References _local_node_eim_basis_functions, libMesh::ParallelObject::comm(), libMesh::Xdr::data(), libMesh::DECODE, libMesh::index_range(), n_vars, node_distribute_bfs(), TIMPI::Communicator::rank(), and libMesh::READ.

Referenced by read_in_basis_functions().

{
  LOG_SCOPE("read_in_node_basis_functions()", "RBEIMEvaluation");

  // Read values on processor 0 only.
  if (sys.comm().rank() == 0)
    {
      // Create filename
      std::ostringstream file_name;
      const std::string basis_function_suffix = (read_binary_basis_functions ? ".xdr" : ".dat");
      file_name << directory_name << "/" << "bf_data" << basis_function_suffix;

      // Create XDR reader object
      Xdr xdr(file_name.str(), read_binary_basis_functions ? DECODE : READ);

      // Read in the number of basis functions. The comment parameter
      // is ignored when reading.
      std::size_t n_bf;
      xdr.data(n_bf);

      // Read in the number of nodes
      std::size_t n_node;
      xdr.data(n_node);

      // Read in the number of variables.
      std::size_t n_vars;
      xdr.data(n_vars);

      std::vector<unsigned int> node_ids(n_node);
      xdr.data(node_ids);

      // Allocate space to store all required basis functions,
      // clearing any data that may have been there previously.
      //
      // TODO: Do we need to also write out/read in Node ids?
      // Or can we assume they will always be contiguously
      // numbered (at least on proc 0)?
      _local_node_eim_basis_functions.clear();
      _local_node_eim_basis_functions.resize(n_bf);
      for (auto i : index_range(_local_node_eim_basis_functions))
        for (auto node_id : node_ids)
          {
            auto & array = _local_node_eim_basis_functions[i][node_id];
            array.resize(n_vars);
          }

      // Read data into node_value from xdr
      std::vector<Number> node_value;

      // Read in data for each basis function
      for (auto i : index_range(_local_node_eim_basis_functions))
        {
          // Reference to the data map for the current basis function.
          auto & bf_map = _local_node_eim_basis_functions[i];

          for (std::size_t var=0; var<n_vars; ++var)
            {
              node_value.clear();
              node_value.resize(n_node);

              // Read data using data_stream() since that is
              // (currently) how we write it out. The "line_break"
              // parameter of data_stream() is ignored while reading.
              xdr.data_stream(node_value.data(), node_value.size());

              for (unsigned int node_counter=0; node_counter<n_node; node_counter++)
                {
                  auto & array = bf_map[node_ids[node_counter]];
                  array[var] = node_value[node_counter];
                }
            } // end for (var)
        } // end for (i)
    } // end if processor 0

  // Distribute the basis function information to the processors that require it
  this->node_distribute_bfs(sys);
}

read_in_side_basis_functions()

void RBEIMEvaluation::read_in_side_basis_functions ( const System &  sys, const std::string &  directory_name, bool  read_binary_basis_functions  )

private

Method that reads in element side EIM basis functions.

This may be called by read_in_basis_functions().

Definition at line 1445 of file rb_eim_evaluation.C.

References _local_side_eim_basis_functions, libMesh::ParallelObject::comm(), libMesh::Xdr::data(), libMesh::DECODE, libMesh::index_range(), n_vars, TIMPI::Communicator::rank(), libMesh::READ, and side_distribute_bfs().

Referenced by read_in_basis_functions().

{
  LOG_SCOPE("read_in_basis_functions()", "RBEIMEvaluation");

  // Read values on processor 0 only.
  if (sys.comm().rank() == 0)
    {
      // Create filename
      std::ostringstream file_name;
      const std::string basis_function_suffix = (read_binary_basis_functions ? ".xdr" : ".dat");
      file_name << directory_name << "/" << "bf_data" << basis_function_suffix;

      // Create XDR reader object
      Xdr xdr(file_name.str(), read_binary_basis_functions ? DECODE : READ);

      // Read in the number of basis functions. The comment parameter
      // is ignored when reading.
      std::size_t n_bf;
      xdr.data(n_bf);

      // Read in the number of elements
      std::size_t n_elem_side;
      xdr.data(n_elem_side);

      // Read in the number of variables.
      std::size_t n_vars;
      xdr.data(n_vars);

      std::vector<unsigned int> elem_ids(n_elem_side);
      xdr.data(elem_ids);
      std::vector<unsigned int> side_indices(n_elem_side);
      xdr.data(side_indices);

      // Read in vector containing the number of QPs per elem. We can
      // create this vector with the required size or let it be read
      // from the file and sized for us.
      std::vector<unsigned int> n_qp_per_elem_side(n_elem_side);
      xdr.data(n_qp_per_elem_side);

      // The total amount of qp data for each var is the sum of the
      // entries in the "n_qp_per_elem" array.
      auto n_qp_data =
        std::accumulate(n_qp_per_elem_side.begin(),
                        n_qp_per_elem_side.end(),
                        0u);

      // Allocate space to store all required basis functions,
      // clearing any data that may have been there previously.
      _local_side_eim_basis_functions.clear();
      _local_side_eim_basis_functions.resize(n_bf);
      for (auto i : index_range(_local_side_eim_basis_functions))
        for (std::size_t elem_side_idx=0; elem_side_idx<n_elem_side; ++elem_side_idx)
          {
            unsigned int elem_id = elem_ids[elem_side_idx];
            unsigned int side_index = side_indices[elem_side_idx];
            auto elem_side_pair = std::make_pair(elem_id, side_index);

            auto & array = _local_side_eim_basis_functions[i][elem_side_pair];
            array.resize(n_vars);
          }

      // Allocate temporary storage for one var's worth of qp data.
      std::vector<Number> qp_data;

      // Read in data for each basis function
      for (auto i : index_range(_local_side_eim_basis_functions))
        {
          // Reference to the data map for the current basis function.
          auto & bf_map = _local_side_eim_basis_functions[i];

          for (std::size_t var=0; var<n_vars; ++var)
            {
              qp_data.clear();
              qp_data.resize(n_qp_data);

              // Read data using data_stream() since that is
              // (currently) how we write it out. The "line_break"
              // parameter of data_stream() is ignored while reading.
              xdr.data_stream(qp_data.data(), qp_data.size());

              // Iterate over the qp_data vector, filling in the
              // "small" vectors for each Elem.
              auto cursor = qp_data.begin();
              for (std::size_t elem_side_idx=0; elem_side_idx<n_elem_side; ++elem_side_idx)
                {
                  unsigned int elem_id = elem_ids[elem_side_idx];
                  unsigned int side_index = side_indices[elem_side_idx];
                  auto elem_side_pair = std::make_pair(elem_id, side_index);

                  // Get reference to the [n_vars][n_qp] array for
                  // this Elem. We assign() into the vector of
                  // quadrature point values, which allocates space if
                  // it doesn't already exist.
                  auto & array = bf_map[elem_side_pair];
                  array[var].assign(cursor, cursor + n_qp_per_elem_side[elem_side_idx]);
                  std::advance(cursor, n_qp_per_elem_side[elem_side_idx]);
                }
            } // end for (var)
        } // end for (i)
    } // end if processor 0

  // Distribute the basis function information to the processors that require it
  this->side_distribute_bfs(sys);
}

read_parameter_data_from_files()

void libMesh::RBParametrized::read_parameter_data_from_files ( const std::string &  continuous_param_file_name, const std::string &  discrete_param_file_name, const bool  read_binary_data  )

inherited

Read in the parameter ranges from files.

Definition at line 274 of file rb_parametrized.C.

References libMesh::RBParametrized::initialize_parameters(), libMesh::RBParametrized::read_discrete_parameter_values_from_file(), and libMesh::RBParametrized::read_parameter_ranges_from_file().

Referenced by libMesh::RBSCMEvaluation::legacy_read_offline_data_from_files(), and libMesh::RBEvaluation::legacy_read_offline_data_from_files().

{
  RBParameters param_min;
  RBParameters param_max;
  read_parameter_ranges_from_file(continuous_param_file_name,
                                  read_binary_data,
                                  param_min,
                                  param_max);

  std::map<std::string, std::vector<Real>> discrete_parameter_values_in;
  read_discrete_parameter_values_from_file(discrete_param_file_name,
                                           read_binary_data,
                                           discrete_parameter_values_in);

  initialize_parameters(param_min, param_max, discrete_parameter_values_in);
}

resize_data_structures()

void RBEIMEvaluation::resize_data_structures

(

const unsigned int

Nmax

)

Resize the data structures for storing data associated with this object.

Definition at line 74 of file rb_eim_evaluation.C.

References _interpolation_matrix, _interpolation_points_comp, _interpolation_points_spatial_indices, _vec_eval_input, libMesh::VectorizedEvalInput::all_xyz, libMesh::VectorizedEvalInput::clear(), and libMesh::DenseMatrix< T >::resize().

Referenced by libMesh::RBDataDeserialization::load_rb_eim_evaluation_data(), libMesh::RBEIMConstruction::train_eim_approximation_with_greedy(), and libMesh::RBEIMConstruction::train_eim_approximation_with_POD().

{
  // Resize the data structures relevant to the EIM system
  _vec_eval_input.clear();
  _vec_eval_input.all_xyz.clear();

  _interpolation_points_comp.clear();
  _interpolation_points_spatial_indices.clear();

  _interpolation_matrix.resize(Nmax,Nmax);
}

scale_components_in_enrichment()

const std::set< unsigned int > & RBEIMEvaluation::scale_components_in_enrichment

(

)

const

Get _scale_components_in_enrichment.

Definition at line 2965 of file rb_eim_evaluation.C.

References _scale_components_in_enrichment.

Referenced by libMesh::RBEIMConstruction::initialize_parametrized_functions_in_training_set(), and libMesh::RBEIMConstruction::train_eim_approximation_with_POD().

{
  return _scale_components_in_enrichment;
}

set_eim_error_indicator_active()

void RBEIMEvaluation::set_eim_error_indicator_active

(

bool

is_active

)

Activate/decative the error indicator in EIM solves.

We need this option since in some cases (e.g. during EIM training) we do not want to activate the EIM error indicator, whereas in "online solves" we do want to activate it.

Definition at line 2977 of file rb_eim_evaluation.C.

References _is_eim_error_indicator_active, get_n_basis_functions(), get_n_interpolation_points(), libMesh::RBParametrized::get_n_params(), and use_eim_error_indicator().

Referenced by libMesh::RBEIMTheta::evaluate_vec().

{
  // We skip setting _is_eim_error_indicator_active in the case that
  // we have no parameters, since we do not use the EIM error indicator
  // in that case. We also check if the number of interpolation points
  // is larger than the number of EIM basis functions, since that is
  // also always the case when the error indicator is active.
  if ((get_n_params() > 0) && (get_n_interpolation_points() > get_n_basis_functions()))
    _is_eim_error_indicator_active = (is_active && use_eim_error_indicator());
}

set_error_indicator_interpolation_row()

void RBEIMEvaluation::set_error_indicator_interpolation_row

(

const DenseVector< Number > &

error_indicator_row

)

Definition at line 3044 of file rb_eim_evaluation.C.

References _error_indicator_interpolation_row.

Referenced by libMesh::RBDataDeserialization::load_rb_eim_evaluation_data(), and libMesh::RBEIMConstruction::update_eim_matrices().

{
  _error_indicator_interpolation_row = extra_point_row;
}

set_interpolation_matrix_entry()

void RBEIMEvaluation::set_interpolation_matrix_entry	(	unsigned int	i,
		unsigned int	j,
		Number	value
	)

Set entry of the EIM interpolation matrix.

Definition at line 870 of file rb_eim_evaluation.C.

References _interpolation_matrix, libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), and value.

Referenced by libMesh::RBDataDeserialization::load_rb_eim_evaluation_data(), and libMesh::RBEIMConstruction::update_eim_matrices().

{
  libmesh_error_msg_if((i >= _interpolation_matrix.m()) || (j >= _interpolation_matrix.n()),
                       "Error: Invalid matrix indices");

  _interpolation_matrix(i,j) = value;
}

set_n_basis_functions()

void RBEIMEvaluation::set_n_basis_functions

(

unsigned int

n_bfs

)

Set the number of basis functions.

Useful when reading in stored data.

Definition at line 319 of file rb_eim_evaluation.C.

References _local_eim_basis_functions, _local_node_eim_basis_functions, _local_side_eim_basis_functions, and get_parametrized_function().

Referenced by libMesh::RBDataDeserialization::load_rb_eim_evaluation_data().

{
  if (get_parametrized_function().on_mesh_sides())
    _local_side_eim_basis_functions.resize(n_bfs);
  else if (get_parametrized_function().on_mesh_nodes())
    _local_node_eim_basis_functions.resize(n_bfs);
  else
    _local_eim_basis_functions.resize(n_bfs);
}

set_parameters()

bool libMesh::RBParametrized::set_parameters ( const RBParameters &  params )

inherited

Set the current parameters to params The parameters are checked for validity; an error is thrown if the number of parameters or samples is different than expected.

We

Returns

a boolean true if the new parameters are within the min/max range, and false otherwise (but the parameters are set regardless). Enabling the "verbose_mode" flag will also print more details.

Definition at line 141 of file rb_parametrized.C.

References libMesh::RBParametrized::check_if_valid_params(), libMesh::RBParametrized::parameters, and libMesh::RBParametrized::parameters_initialized.

Referenced by libMesh::RBSCMConstruction::compute_SCM_bounds_on_training_set(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::RBConstruction::get_RB_error_bound(), SimpleRBEvaluation::get_stability_lower_bound(), libMesh::RBParametrized::initialize_parameters(), libMesh::RBSCMEvaluation::reload_current_parameters(), libMesh::RBSCMEvaluation::set_current_parameters_from_C_J(), and RBParametersTest::testRBParametrized().

{
  libmesh_error_msg_if(!parameters_initialized, "Error: parameters not initialized in RBParametrized::set_parameters");

  // Terminate if params has the wrong number of parameters or samples.
  // If the parameters are outside the min/max range, return false.
  const bool valid_params = check_if_valid_params(params);

  // Make a copy of params (default assignment operator just does memberwise copy, which is sufficient here)
  this->parameters = params;

  return valid_params;
}

set_parametrized_function()

void RBEIMEvaluation::set_parametrized_function

(

std::unique_ptr< RBParametrizedFunction >

pf

)

Set the parametrized function that we will approximate using the Empirical Interpolation Method.

This object will take ownership of the unique pointer.

Definition at line 86 of file rb_eim_evaluation.C.

References _parametrized_function.

{
  _parametrized_function = std::move(pf);
}

set_preserve_rb_eim_solutions()

void RBEIMEvaluation::set_preserve_rb_eim_solutions

(

bool

preserve_rb_eim_solutions

)

Set _preserve_rb_eim_solutions.

Definition at line 883 of file rb_eim_evaluation.C.

References _preserve_rb_eim_solutions.

{
  _preserve_rb_eim_solutions = preserve_rb_eim_solutions;
}

set_rb_eim_solutions()

void RBEIMEvaluation::set_rb_eim_solutions

(

const std::vector< DenseVector< Number >> &

rb_eim_solutions

)

Set _rb_eim_solutions.

Normally we update _rb_eim_solutions by performing and EIM solve, but in some cases we want to set the EIM solution coefficients elsewhere, so this setter enables us to do that.

Definition at line 656 of file rb_eim_evaluation.C.

References _rb_eim_solutions.

{
  _rb_eim_solutions = rb_eim_solutions;
}

side_decrement_vector()

void RBEIMEvaluation::side_decrement_vector	(	SideQpDataMap &	v,
		const DenseVector< Number > &	coeffs
	)

Same as decrement_vector() except for Side data.

Definition at line 355 of file rb_eim_evaluation.C.

References _local_side_eim_basis_functions, get_n_basis_functions(), libMesh::index_range(), and libMesh::DenseVector< T >::size().

Referenced by libMesh::RBEIMConstruction::compute_max_eim_error(), and libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides().

{
  LOG_SCOPE("side_decrement_vector()", "RBEIMEvaluation");

  libmesh_error_msg_if(get_n_basis_functions() != coeffs.size(),
                       "Error: Number of coefficients should match number of basis functions");

  for (auto & [elem_and_side, v_comp_and_qp] : v)
    {
      for (const auto & comp : index_range(v_comp_and_qp))
        for (unsigned int qp : index_range(v_comp_and_qp[comp]))
          for (unsigned int i : index_range(_local_side_eim_basis_functions))
            {
              // Check that entry (elem_and_side,comp,qp) exists in _local_side_eim_basis_functions so that
              // we get a clear error message if there is any missing data
              const auto & basis_comp_and_qp = libmesh_map_find(_local_side_eim_basis_functions[i], elem_and_side);

              libmesh_error_msg_if(comp >= basis_comp_and_qp.size(), "Error: Invalid comp");
              libmesh_error_msg_if(qp >= basis_comp_and_qp[comp].size(), "Error: Invalid qp");

              v_comp_and_qp[comp][qp] -= coeffs(i) * basis_comp_and_qp[comp][qp];
            }
    }
}

side_distribute_bfs()

void RBEIMEvaluation::side_distribute_bfs ( const System &  sys )

private

Same as distribute_bfs() except for side data.

Definition at line 2326 of file rb_eim_evaluation.C.

References _local_side_eim_basis_functions, TIMPI::Communicator::broadcast(), clear(), libMesh::ParallelObject::comm(), TIMPI::Communicator::gather(), libMesh::System::get_mesh(), get_parametrized_function(), libMesh::RBParametrizedFunction::get_parametrized_function_boundary_ids(), libMesh::index_range(), libMesh::make_range(), mesh, n_vars, TIMPI::Communicator::rank(), TIMPI::Communicator::scatter(), and TIMPI::Communicator::size().

Referenced by read_in_side_basis_functions().

{
  // So we can avoid calling these many times below
  auto n_procs = sys.comm().size();
  auto rank = sys.comm().rank();

  // In serial there's nothing to distribute
  if (n_procs == 1)
    return;

  // Broadcast the number of basis functions from proc 0. After
  // distributing, all procs should have the same number of basis
  // functions.
  auto n_bf = _local_side_eim_basis_functions.size();
  sys.comm().broadcast(n_bf);

  // Allocate enough space to store n_bf basis functions on non-zero ranks
  if (rank != 0)
    _local_side_eim_basis_functions.resize(n_bf);

  // Broadcast the number of variables from proc 0. After
  // distributing, all procs should have the same number of variables.
  auto n_vars = _local_side_eim_basis_functions[0].begin()->second.size();
  sys.comm().broadcast(n_vars);

  const std::set<boundary_id_type> & parametrized_function_boundary_ids =
    get_parametrized_function().get_parametrized_function_boundary_ids();

  // Construct lists of elem ids owned by different processors
  const MeshBase & mesh = sys.get_mesh();

  // BoundaryInfo and related data structures
  const auto & binfo = mesh.get_boundary_info();
  std::vector<boundary_id_type> side_boundary_ids;

  std::vector<dof_id_type> gathered_local_elem_ids;
  std::vector<dof_id_type> gathered_local_side_indices;
  for (const auto & elem : mesh.active_local_element_ptr_range())
    {
      for (unsigned int side = 0; side != elem->n_sides(); ++side)
        {
          // skip non-boundary elements
          if (!elem->neighbor_ptr(side))
            {
              binfo.boundary_ids(elem, side, side_boundary_ids);

              bool has_side_boundary_id = false;
              for (boundary_id_type side_boundary_id : side_boundary_ids)
                if (parametrized_function_boundary_ids.count(side_boundary_id))
                  {
                    has_side_boundary_id = true;
                    break;
                  }

              if (has_side_boundary_id)
                {
                  gathered_local_elem_ids.push_back(elem->id());
                  gathered_local_side_indices.push_back(side);
                }
            }
        }

        // In the case of 2D elements, we also check the shellfaces
        if (elem->dim() == 2)
          for (unsigned int shellface_index=0; shellface_index<2; shellface_index++)
            {
              binfo.shellface_boundary_ids(elem, shellface_index, side_boundary_ids);

              bool has_side_boundary_id = false;
              for (boundary_id_type side_boundary_id : side_boundary_ids)
                if (parametrized_function_boundary_ids.count(side_boundary_id))
                  {
                    has_side_boundary_id = true;
                    break;
                  }

              if (has_side_boundary_id)
                {
                  // We use shellface_index as the side_index since shellface boundary conditions
                  // are stored separately from side boundary conditions in BoundaryInfo.
                  gathered_local_elem_ids.push_back(elem->id());
                  gathered_local_side_indices.push_back(shellface_index);
                }
            }
    }

  // Gather the number of local elems from all procs to proc 0
  auto n_local_elems = gathered_local_elem_ids.size();
  std::vector<std::size_t> gathered_n_local_elems = {n_local_elems};
  sys.comm().gather(/*root_id=*/0, gathered_n_local_elems);

  // Gather the (elem,side) owned by each processor onto processor 0.
  sys.comm().gather(/*root_id=*/0, gathered_local_elem_ids);
  sys.comm().gather(/*root_id=*/0, gathered_local_side_indices);

  // Construct vectors of "start" and "one-past-the-end" indices into
  // the gathered_local_elem_ids vector for each proc. Only valid on
  // processor 0.
  std::vector<std::size_t> start_elem_ids_index, end_elem_ids_index;

  if (rank == 0)
    {
      start_elem_ids_index.resize(n_procs);
      start_elem_ids_index[0] = 0;
      for (processor_id_type p=1; p<n_procs; ++p)
        start_elem_ids_index[p] = start_elem_ids_index[p-1] + gathered_n_local_elems[p-1];

      end_elem_ids_index.resize(n_procs);
      end_elem_ids_index[n_procs - 1] = gathered_local_elem_ids.size();
      for (processor_id_type p=0; p<n_procs - 1; ++p)
        end_elem_ids_index[p] = start_elem_ids_index[p+1];
    }

  // On processor 0, using basis function 0 and variable 0, prepare a
  // vector with the number of qps per Elem.  Then scatter this vector
  // out to the processors that require it. The order of this vector
  // matches the gathered_local_elem_ids ordering. The counts will be
  // gathered_n_local_elems, since there will be one qp count per Elem.
  std::vector<unsigned int> n_qp_per_elem_data;

  // On rank 0, the "counts" vector holds the number of floating point values that
  // are to be scattered to each proc. It is only required on proc 0.
  std::vector<int> counts;

  if (rank == 0)
    {
      n_qp_per_elem_data.reserve(gathered_local_elem_ids.size());
      counts.resize(n_procs);

      auto & bf_map = _local_side_eim_basis_functions[0];

      for (processor_id_type p=0; p<n_procs; ++p)
        {
          for (auto e : make_range(start_elem_ids_index[p], end_elem_ids_index[p]))
            {
              auto elem_id = gathered_local_elem_ids[e];
              auto side_index = gathered_local_side_indices[e];

              // Get reference to array[n_vars][n_qp] for current Elem.
              // Throws an error if the required elem_id is not found.
              const auto & array = libmesh_map_find(bf_map, std::make_pair(elem_id, side_index));

              auto n_qps = array[0].size();

              // We use var==0 to set the number of qps for all vars
              n_qp_per_elem_data.push_back(n_qps);

              // Accumulate the count for this proc
              counts[p] += n_qps;
            } // end for (e)
        } // end for proc_id
    } // if (rank == 0)

  // Now scatter the n_qp_per_elem_data to all procs (must call the
  // scatter on all procs, it is a collective).
  {
    std::vector<unsigned int> recv;
    std::vector<int> tmp(gathered_n_local_elems.begin(), gathered_n_local_elems.end());
    sys.comm().scatter(n_qp_per_elem_data, tmp, recv, /*root_id=*/0);

    // Now swap n_qp_per_elem_data and recv. All processors now have a
    // vector of length n_local_elems containing the number of
    // quadarature points per Elem.
    n_qp_per_elem_data.swap(recv);
  }

  // For each basis function and each variable, build a vector
  // of qp data in the Elem ordering given by the
  // gathered_local_elem_ids, then call
  //
  // sys.comm().scatter(data, counts, recv, /*root_id=*/0);
  std::vector<std::vector<Number>> qp_data(n_vars);
  if (rank == 0)
    {
      // The total amount of qp data is given by summing the entries
      // of the "counts" vector.
      auto n_qp_data =
        std::accumulate(counts.begin(), counts.end(), 0u);

      // On processor 0, reserve enough space to hold all the qp
      // data for a single basis function for each var.
      for (auto var : index_range(qp_data))
        qp_data[var].reserve(n_qp_data);
    }

  // The recv_qp_data vector will be used on the receiving end of all
  // the scatters below.
  std::vector<Number> recv_qp_data;

  // Loop from 0..n_bf on _all_ procs, since the scatters inside this
  // loop are collective.
  for (auto bf : make_range(n_bf))
    {
      // Prepare data for scattering (only on proc 0)
      if (rank == 0)
        {
          // Reference to the data map for the current basis function.
          auto & bf_map = _local_side_eim_basis_functions[bf];

          // Clear any data from previous bf
          for (auto var : index_range(qp_data))
            qp_data[var].clear();

          for (processor_id_type p=0; p<n_procs; ++p)
            {
              for (auto e : make_range(start_elem_ids_index[p], end_elem_ids_index[p]))
                {
                  auto elem_id = gathered_local_elem_ids[e];
                  auto side_index = gathered_local_side_indices[e];

                  // Get reference to array[n_vars][n_qp] for current Elem.
                  // Throws an error if the required (elem,side) is not found.
                  const auto & array = libmesh_map_find(bf_map, std::make_pair(elem_id, side_index));

                  for (auto var : index_range(array))
                    {
                      // Insert all qp values for this var
                      qp_data[var].insert(/*insert at*/qp_data[var].end(),
                                          /*data start*/array[var].begin(),
                                          /*data end*/array[var].end());
                    } // end for (var)
                } // end for (e)
            } // end for proc_id
        } // end if rank==0

      // Perform the scatters (all procs)
      for (auto var : make_range(n_vars))
        {
          // Do the scatter for the current var
          sys.comm().scatter(qp_data[var], counts, recv_qp_data, /*root_id=*/0);

          if (rank != 0)
            {
              // Store the scattered data we received in _local_side_eim_basis_functions[bf]
              auto & bf_map = _local_side_eim_basis_functions[bf];
              auto cursor = recv_qp_data.begin();

              for (auto i : index_range(gathered_local_elem_ids))
                {
                  auto elem_id = gathered_local_elem_ids[i];
                  auto side_index = gathered_local_side_indices[i];
                  auto n_qp_this_elem = n_qp_per_elem_data[i];
                  auto & array = bf_map[std::make_pair(elem_id, side_index)];

                  // Create space to store the data if it doesn't already exist.
                  if (array.empty())
                    array.resize(n_vars);

                  array[var].assign(cursor, cursor + n_qp_this_elem);
                  std::advance(cursor, n_qp_this_elem);
                }
            } // if (rank != 0)
        } // end for (var)
    } // end for (bf)

  // Now that the scattering is done, delete non-local Elem
  // information from processor 0's _local_side_eim_basis_functions data
  // structure.
  if (rank == 0)
    {
      for (processor_id_type p=1; p<n_procs; ++p)
        {
          for (auto e : make_range(start_elem_ids_index[p], end_elem_ids_index[p]))
            {
              auto elem_id = gathered_local_elem_ids[e];
              auto side_index = gathered_local_side_indices[e];

              // Delete this Elem's information from every basis function.
              for (auto & bf_map : _local_side_eim_basis_functions)
                bf_map.erase(std::make_pair(elem_id, side_index));
            } // end for (e)
        } // end for proc_id
    } // if (rank == 0)
}

side_gather_bfs()

void RBEIMEvaluation::side_gather_bfs ( )

private

Same as gather_bfs() except for side data.

Definition at line 1832 of file rb_eim_evaluation.C.

References _local_side_eim_basis_functions, libMesh::ParallelObject::comm(), TIMPI::Communicator::gather(), libMesh::index_range(), TIMPI::Communicator::max(), libMesh::ParallelObject::n_processors(), n_vars, libMesh::ParallelObject::processor_id(), and TIMPI::Communicator::verify().

Referenced by write_out_side_basis_functions().

{
  // We need to gather _local_side_eim_basis_functions data from other
  // procs for printing.
  //
  // Ideally, this could be accomplished by simply calling:
  // this->comm().gather(/*root_id=*/0, _local_side_eim_basis_functions);
  //
  // but the data structure seems to be too complicated for this to
  // work automatically. (I get some error about the function called
  // being "private within this context".) Therefore, we have to
  // gather the information manually.

  // So we can avoid calling this many times below
  auto n_procs = this->n_processors();

  // In serial there's nothing to gather
  if (n_procs == 1)
    return;

  // Current assumption is that the number of basis functions stored on
  // each processor is the same, the only thing that differs is the number
  // of elements, so make sure that is the case now.
  auto n_bf = _local_side_eim_basis_functions.size();
  this->comm().verify(n_bf);

  // This function should never be called if there are no basis
  // functions, so if it was, something went wrong.
  libmesh_error_msg_if(!n_bf, "SideRBEIMEvaluation::gather_bfs() should not be called with 0 basis functions.");

  // The number of variables should be the same on all processors
  // and we can get this from _local_side_eim_basis_functions. However,
  // it may be that some processors have no local elements, so on
  // those processors we cannot look up the size from
  // _local_side_eim_basis_functions. As a result we use comm().max(n_vars)
  // to make sure all processors agree on the final value.
  std::size_t n_vars =
    _local_side_eim_basis_functions[0].empty() ? 0 : _local_side_eim_basis_functions[0].begin()->second.size();
  this->comm().max(n_vars);

  // Gather list of (elem,side) pairs stored on each processor to proc 0.  We
  // use basis function 0 as an example and assume all the basis
  // functions are distributed similarly.
  std::vector<std::pair<dof_id_type,unsigned int>> elem_side_pairs;
  elem_side_pairs.reserve(_local_side_eim_basis_functions[0].size());
  for (const auto & pr : _local_side_eim_basis_functions[0])
    elem_side_pairs.push_back(pr.first);
  this->comm().gather(/*root_id=*/0, elem_side_pairs);

  // Store the number of qps per Elem on this processor. Again, use
  // basis function 0 (and variable 0) to get this information, then
  // apply it to all basis functions.
  std::vector<unsigned int> n_qp_per_elem_side;
  n_qp_per_elem_side.reserve(_local_side_eim_basis_functions[0].size());
  for (const auto & pr : _local_side_eim_basis_functions[0])
    {
      // array[n_vars][n_qp] per (elem,side). We get the number of QPs
      // for variable 0, assuming they are all the same.
      const auto & array = pr.second;
      n_qp_per_elem_side.push_back(array[0].size());
    }

  // Before gathering, compute the total amount of local qp data for
  // each var, which is the sum of the entries in the "n_qp_per_elem_side" array.
  // This will be used to reserve space in a vector below.
  auto n_local_qp_data =
    std::accumulate(n_qp_per_elem_side.begin(),
                    n_qp_per_elem_side.end(),
                    0u);

  // Gather the number of qps per Elem for each processor onto processor 0.
  this->comm().gather(/*root_id=*/0, n_qp_per_elem_side);

  // Sanity check: On processor 0, this checks that we have gathered the same number
  // of (elem,side) pairs and qp counts.
  libmesh_error_msg_if(elem_side_pairs.size() != n_qp_per_elem_side.size(),
                       "Must gather same number of Elem ids as qps per Elem.");

  // Reserve space to store contiguous vectors of qp data for each var
  std::vector<std::vector<Number>> gathered_qp_data(n_vars);
  for (auto var : index_range(gathered_qp_data))
    gathered_qp_data[var].reserve(n_local_qp_data);

  // Now we construct a vector for each basis function, for each
  // variable, which is ordered according to:
  // [ [qp vals for Elem 0], [qp vals for Elem 1], ... [qp vals for Elem N] ]
  // and gather it to processor 0.
  for (auto bf : index_range(_local_side_eim_basis_functions))
    {
      // Clear any data from previous bf
      for (auto var : index_range(gathered_qp_data))
        gathered_qp_data[var].clear();

      for (const auto & pr : _local_side_eim_basis_functions[bf])
        {
          // array[n_vars][n_qp] per (elem,side) pair
          const auto & array = pr.second;
          for (auto var : index_range(array))
            {
              // Insert all qp values for this var
              gathered_qp_data[var].insert(/*insert at*/gathered_qp_data[var].end(),
                                           /*data start*/array[var].begin(),
                                           /*data end*/array[var].end());
            }
        }

      // Reference to the data map for the current basis function.
      auto & bf_map = _local_side_eim_basis_functions[bf];

      for (auto var : index_range(gathered_qp_data))
        {
          // For each var, gather gathered_qp_data[var] onto processor
          // 0. There apparently is not a gather overload for
          // vector-of-vectors...
          this->comm().gather(/*root_id=*/0, gathered_qp_data[var]);

          // On processor 0, iterate over the gathered_qp_data[var]
          // vector we just gathered, filling in the "small" vectors
          // for each Elem. Note: here we ignore the fact that we
          // already have the data on processor 0 and just overwrite
          // it, this makes the indexing logic a bit simpler.
          if (this->processor_id() == 0)
            {
              auto cursor = gathered_qp_data[var].begin();
              for (auto i : index_range(elem_side_pairs))
                {
                  auto elem_side_pair = elem_side_pairs[i];
                  auto n_qp_this_elem_side = n_qp_per_elem_side[i];

                  // Get reference to the [n_vars][n_qp] array for
                  // this Elem. We assign() into the vector of
                  // quadrature point values, which allocates space if
                  // it doesn't already exist.
                  auto & array = bf_map[elem_side_pair];

                  // Possibly allocate space if this is data for a new
                  // element we haven't seen before.
                  if (array.empty())
                    array.resize(n_vars);

                  array[var].assign(cursor, cursor + n_qp_this_elem_side);
                  std::advance(cursor, n_qp_this_elem_side);
                }
            }
        }
    } // end loop over basis functions
}

use_eim_error_indicator()

bool RBEIMEvaluation::use_eim_error_indicator ( ) const

virtual

Virtual function to indicate if we use the EIM error indicator in this case.

This indicates if we will generate the data during the Offline training for the EIM error indicator. In EIM solves, the error indicator will only be used if set_eim_error_indicator_active() is set to true, since we want to be able to enable or disable the error indicator depending on the type of solve we are doing (e.g. EIM solves during training do not need the error indicator).

Definition at line 2970 of file rb_eim_evaluation.C.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder(), libMesh::RBEIMConstruction::reinit_eim_projection_matrix(), set_eim_error_indicator_active(), libMesh::RBEIMConstruction::train_eim_approximation_with_greedy(), and libMesh::RBEIMConstruction::train_eim_approximation_with_POD().

{
  // Return false by default, but we override this in subclasses
  // for cases where we want to use the error indicator.
  return false;
}

write_out_basis_functions()

void RBEIMEvaluation::write_out_basis_functions	(	const std::string &	directory_name = "offline_data",
		bool	write_binary_basis_functions = true
	)

Write out all the basis functions to file.

sys is used for file IO directory_name specifies which directory to write files to read_binary_basis_functions indicates whether to write binary or ASCII data

Note: this is not currently a virtual function and is not related to the RBEvaluation function of the same name.

Definition at line 988 of file rb_eim_evaluation.C.

References get_parametrized_function(), write_out_interior_basis_functions(), write_out_node_basis_functions(), and write_out_side_basis_functions().

{
  LOG_SCOPE("write_out_basis_functions()", "RBEIMEvaluation");

  if (get_parametrized_function().on_mesh_sides())
    write_out_side_basis_functions(directory_name, write_binary_basis_functions);
  else if (get_parametrized_function().on_mesh_nodes())
    write_out_node_basis_functions(directory_name, write_binary_basis_functions);
  else
    write_out_interior_basis_functions(directory_name, write_binary_basis_functions);
}

write_out_interior_basis_functions()

void RBEIMEvaluation::write_out_interior_basis_functions ( const std::string &  directory_name, bool  write_binary_basis_functions  )

private

Method that writes out element interior EIM basis functions.

This may be called by write_out_basis_functions().

Definition at line 1002 of file rb_eim_evaluation.C.

References _local_eim_basis_functions, libMesh::ParallelObject::comm(), libMesh::ENCODE, gather_bfs(), libMesh::index_range(), libMesh::Utility::mkdir(), libMesh::MeshTools::n_elem(), n_vars, libMesh::ParallelObject::processor_id(), TIMPI::Communicator::verify(), and libMesh::WRITE.

Referenced by write_out_basis_functions().

{
  LOG_SCOPE("write_out_interior_basis_functions()", "RBEIMEvaluation");

  // Quick return if there is no work to do. Note: make sure all procs
  // agree there is no work to do.
  bool is_empty = _local_eim_basis_functions.empty();
  this->comm().verify(is_empty);

  if (is_empty)
    return;

  // Gather basis function data from other procs, storing it in
  // _local_eim_basis_functions, so that we can then print everything
  // from processor 0.
  this->gather_bfs();

  // Write values from processor 0 only.
  if (this->processor_id() == 0)
    {
      // Make a directory to store all the data files
      Utility::mkdir(directory_name.c_str());

      // Create filename
      std::ostringstream file_name;
      const std::string basis_function_suffix = (write_binary_basis_functions ? ".xdr" : ".dat");
      file_name << directory_name << "/" << "bf_data" << basis_function_suffix;

      // Create XDR writer object
      Xdr xdr(file_name.str(), write_binary_basis_functions ? ENCODE : WRITE);

      // Write number of basis functions to file. Note: the
      // Xdr::data() function takes non-const references, so you can't
      // pass e.g. vec.size() to that interface.
      auto n_bf = _local_eim_basis_functions.size();
      xdr.data(n_bf, "# Number of basis functions");

      // We assume that each basis function has data for the same
      // number of elements as basis function 0, which is equal to the
      // size of the map.
      auto n_elem = _local_eim_basis_functions[0].size();
      xdr.data(n_elem, "# Number of elements");

      // We assume that each element has the same number of variables,
      // and we get the number of vars from the first element of the
      // first basis function.
      auto n_vars = _local_eim_basis_functions[0].begin()->second.size();
      xdr.data(n_vars, "# Number of variables");

      // We assume that the list of elements for each basis function
      // is the same as basis function 0. We also assume that all vars
      // have the same number of qps.
      std::vector<unsigned int> n_qp_per_elem;
      n_qp_per_elem.reserve(n_elem);
      dof_id_type expected_elem_id = 0;
      for (const auto & [actual_elem_id, array] : _local_eim_basis_functions[0])
        {
          // Note: Currently we require that the Elems are numbered
          // contiguously from [0..n_elem).  This allows us to avoid
          // writing the Elem ids to the Xdr file, but if we need to
          // generalize this assumption later, we can.
          libmesh_error_msg_if(actual_elem_id != expected_elem_id++,
                               "RBEIMEvaluation currently assumes a contiguous Elem numbering starting from 0.");

          // array[n_vars][n_qp] per Elem. We get the number of QPs
          // for variable 0, assuming they are all the same.
          n_qp_per_elem.push_back(array[0].size());
        }
      xdr.data(n_qp_per_elem, "# Number of QPs per Elem");

      // The total amount of qp data for each var is the sum of the
      // entries in the "n_qp_per_elem" array.
      auto n_qp_data =
        std::accumulate(n_qp_per_elem.begin(),
                        n_qp_per_elem.end(),
                        0u);

      // Reserve space to store contiguous vectors of qp data for each var
      std::vector<std::vector<Number>> qp_data(n_vars);
      for (auto var : index_range(qp_data))
        qp_data[var].reserve(n_qp_data);

      // Now we construct a vector for each basis function, for each
      // variable which is ordered according to:
      // [ [qp vals for Elem 0], [qp vals for Elem 1], ... [qp vals for Elem N] ]
      // and write it to file.
      for (auto bf : index_range(_local_eim_basis_functions))
        {
          // Clear any data from previous bf
          for (auto var : index_range(qp_data))
            qp_data[var].clear();

          for (const auto & pr : _local_eim_basis_functions[bf])
            {
              // array[n_vars][n_qp] per Elem
              const auto & array = pr.second;
              for (auto var : index_range(array))
                {
                  // Insert all qp values for this var
                  qp_data[var].insert(/*insert at*/qp_data[var].end(),
                                      /*data start*/array[var].begin(),
                                      /*data end*/array[var].end());
                }
            }

          // Write all the var values for this bf
          for (auto var : index_range(qp_data))
            xdr.data_stream(qp_data[var].data(), qp_data[var].size(), /*line_break=*/qp_data[var].size());
        }
    }
}

write_out_node_basis_functions()

void RBEIMEvaluation::write_out_node_basis_functions ( const std::string &  directory_name, bool  write_binary_basis_functions  )

private

Method that writes out element node EIM basis functions.

This may be called by write_out_basis_functions().

Definition at line 1232 of file rb_eim_evaluation.C.

References _local_node_eim_basis_functions, libMesh::ParallelObject::comm(), libMesh::ENCODE, libMesh::index_range(), libMesh::Utility::mkdir(), n_vars, node_gather_bfs(), libMesh::ParallelObject::processor_id(), TIMPI::Communicator::verify(), and libMesh::WRITE.

Referenced by write_out_basis_functions().

{
  LOG_SCOPE("write_out_node_basis_functions()", "RBEIMEvaluation");

  // Quick return if there is no work to do. Note: make sure all procs
  // agree there is no work to do.
  bool is_empty = _local_node_eim_basis_functions.empty();
  this->comm().verify(is_empty);

  if (is_empty)
    return;

  // Gather basis function data from other procs, storing it in
  // _local_node_eim_basis_functions, so that we can then print everything
  // from processor 0.
  this->node_gather_bfs();

  // Write values from processor 0 only.
  if (this->processor_id() == 0)
    {
      // Make a directory to store all the data files
      Utility::mkdir(directory_name.c_str());

      // Create filename
      std::ostringstream file_name;
      const std::string basis_function_suffix = (write_binary_basis_functions ? ".xdr" : ".dat");
      file_name << directory_name << "/" << "bf_data" << basis_function_suffix;

      // Create XDR writer object
      Xdr xdr(file_name.str(), write_binary_basis_functions ? ENCODE : WRITE);

      // Write number of basis functions to file. Note: the
      // Xdr::data() function takes non-const references, so you can't
      // pass e.g. vec.size() to that interface.
      auto n_bf = _local_node_eim_basis_functions.size();
      xdr.data(n_bf, "# Number of basis functions");

      // We assume that each basis function has data for the same
      // number of elements as basis function 0, which is equal to the
      // size of the map.
      auto n_node = _local_node_eim_basis_functions[0].size();
      xdr.data(n_node, "# Number of nodes");

      // We assume that each element has the same number of variables,
      // and we get the number of vars from the first element of the
      // first basis function.
      auto n_vars = _local_node_eim_basis_functions[0].begin()->second.size();
      xdr.data(n_vars, "# Number of variables");

      // We write out the following arrays:
      // - node IDs
      std::vector<unsigned int> node_ids;
      node_ids.reserve(n_node);
      for (const auto & pr : _local_node_eim_basis_functions[0])
        {
          node_ids.push_back(pr.first);
        }
      xdr.data(node_ids, "# Node IDs");

      // Now we construct a vector for each basis function, for each
      // variable which is ordered according to:
      // [ [val for Node 0], [val for Node 1], ... [val for Node N] ]
      // and write it to file.

      std::vector<std::vector<Number>> var_data(n_vars);
      for (unsigned int var=0; var<n_vars; var++)
        var_data[var].resize(n_node);

      for (auto bf : index_range(_local_node_eim_basis_functions))
        {
          unsigned int node_counter = 0;
          for (const auto & pr : _local_node_eim_basis_functions[bf])
            {
              // array[n_vars] per Node
              const auto & array = pr.second;
              for (auto var : index_range(array))
                {
                  // Based on the error check above, we know that node_id is numbered
                  // contiguously from [0..nodes], so we can use it as the vector
                  // index here.
                  var_data[var][node_counter] = array[var];
                }

              node_counter++;
            }

          // Write all the var values for this bf
          for (auto var : index_range(var_data))
            xdr.data_stream(var_data[var].data(), var_data[var].size(), /*line_break=*/var_data[var].size());
        }
    }
}

write_out_projected_basis_functions()

void RBEIMEvaluation::write_out_projected_basis_functions	(	EquationSystems &	es,
		const std::string &	directory_name = "offline_data"
	)

Project all basis functions using project_qp_data_map_onto_system() and then write out the resulting vectors.

Definition at line 2926 of file rb_eim_evaluation.C.

References get_basis_function(), get_eim_vars_to_project_and_write(), get_n_basis_functions(), libMesh::EquationSystems::get_system(), libMesh::index_range(), libMesh::make_range(), project_qp_data_map_onto_system(), libMesh::System::solution, and libMesh::RBEvaluation::write_out_vectors().

{
  if (get_eim_vars_to_project_and_write().empty())
    return;

  unsigned int var_group_idx = 0;
  for (const auto & eim_vargroup : get_eim_vars_to_project_and_write())
    {
      std::vector<std::unique_ptr<NumericVector<Number>>> projected_bfs;

      const auto & sys_name = eim_vargroup.eim_sys_name;
      System & sys = es.get_system(sys_name);

      for (unsigned int bf_index : make_range(get_n_basis_functions()))
        {
          project_qp_data_map_onto_system(
            sys,
            get_basis_function(bf_index),
            eim_vargroup);

          projected_bfs.emplace_back(sys.solution->clone());
        }

      // Create projected_bfs_ptrs so that we can call RBEvaluation::write_out_vectors()
      std::vector<NumericVector<Number>*> projected_bfs_ptrs(projected_bfs.size());
      for (unsigned int i : index_range(projected_bfs))
        {
          projected_bfs_ptrs[i] = projected_bfs[i].get();
        }

      RBEvaluation::write_out_vectors(sys,
                                      projected_bfs_ptrs,
                                      directory_name,
                                      "projected_bf_vargroup_" + std::to_string(var_group_idx));
      var_group_idx++;
    }
}

write_out_side_basis_functions()

void RBEIMEvaluation::write_out_side_basis_functions ( const std::string &  directory_name, bool  write_binary_basis_functions  )

private

Method that writes out element side EIM basis functions.

This may be called by write_out_basis_functions().

Definition at line 1116 of file rb_eim_evaluation.C.

References _local_side_eim_basis_functions, libMesh::ParallelObject::comm(), libMesh::ENCODE, libMesh::index_range(), libMesh::Utility::mkdir(), libMesh::MeshTools::n_elem(), n_vars, libMesh::ParallelObject::processor_id(), side_gather_bfs(), TIMPI::Communicator::verify(), and libMesh::WRITE.

Referenced by write_out_basis_functions().

{
  LOG_SCOPE("write_out_side_basis_functions()", "RBEIMEvaluation");

  // Quick return if there is no work to do. Note: make sure all procs
  // agree there is no work to do.
  bool is_empty = _local_side_eim_basis_functions.empty();
  this->comm().verify(is_empty);

  if (is_empty)
    return;

  // Gather basis function data from other procs, storing it in
  // _local_side_eim_basis_functions, so that we can then print everything
  // from processor 0.
  this->side_gather_bfs();

  // Write values from processor 0 only.
  if (this->processor_id() == 0)
    {
      // Make a directory to store all the data files
      Utility::mkdir(directory_name.c_str());

      // Create filename
      std::ostringstream file_name;
      const std::string basis_function_suffix = (write_binary_basis_functions ? ".xdr" : ".dat");
      file_name << directory_name << "/" << "bf_data" << basis_function_suffix;

      // Create XDR writer object
      Xdr xdr(file_name.str(), write_binary_basis_functions ? ENCODE : WRITE);

      // Write number of basis functions to file. Note: the
      // Xdr::data() function takes non-const references, so you can't
      // pass e.g. vec.size() to that interface.
      auto n_bf = _local_side_eim_basis_functions.size();
      xdr.data(n_bf, "# Number of basis functions");

      // We assume that each basis function has data for the same
      // number of (elem,side) pairs as basis function 0, which is equal to the
      // size of the map.
      auto n_elem = _local_side_eim_basis_functions[0].size();
      xdr.data(n_elem, "# Number of (elem,side) pairs");

      // We assume that each element has the same number of variables,
      // and we get the number of vars from the first element of the
      // first basis function.
      auto n_vars = _local_side_eim_basis_functions[0].begin()->second.size();
      xdr.data(n_vars, "# Number of variables");

      // We write out the following arrays:
      // - element IDs
      // - side indices
      // - n_qp_per_elem_side
      std::vector<unsigned int> n_qp_per_elem_side;
      std::vector<unsigned int> elem_ids;
      std::vector<unsigned int> side_indices;
      elem_ids.reserve(n_elem);
      side_indices.reserve(n_elem);
      n_qp_per_elem_side.reserve(n_elem);
      for (const auto & [elem_side_pair, array] : _local_side_eim_basis_functions[0])
        {
          elem_ids.push_back(elem_side_pair.first);
          side_indices.push_back(elem_side_pair.second);

          // array[n_vars][n_qp] per Elem. We get the number of QPs
          // for variable 0, assuming they are all the same.
          n_qp_per_elem_side.push_back(array[0].size());
        }
      xdr.data(elem_ids, "# Elem IDs");
      xdr.data(side_indices, "# Side indices");
      xdr.data(n_qp_per_elem_side, "# Number of QPs per Elem");

      // The total amount of qp data for each var is the sum of the
      // entries in the "n_qp_per_elem" array.
      auto n_qp_data =
        std::accumulate(n_qp_per_elem_side.begin(),
                        n_qp_per_elem_side.end(),
                        0u);

      // Reserve space to store contiguous vectors of qp data for each var
      std::vector<std::vector<Number>> qp_data(n_vars);
      for (auto var : index_range(qp_data))
        qp_data[var].reserve(n_qp_data);

      // Now we construct a vector for each basis function, for each
      // variable which is ordered according to:
      // [ [qp vals for Elem 0], [qp vals for Elem 1], ... [qp vals for Elem N] ]
      // and write it to file.
      for (auto bf : index_range(_local_side_eim_basis_functions))
        {
          // Clear any data from previous bf
          for (auto var : index_range(qp_data))
            qp_data[var].clear();

          for (const auto & pr : _local_side_eim_basis_functions[bf])
            {
              // array[n_vars][n_qp] per Elem
              const auto & array = pr.second;
              for (auto var : index_range(array))
                {
                  // Insert all qp values for this var
                  qp_data[var].insert(/*insert at*/qp_data[var].end(),
                                      /*data start*/array[var].begin(),
                                      /*data end*/array[var].end());
                }
            }

          // Write all the var values for this bf
          for (auto var : index_range(qp_data))
            xdr.data_stream(qp_data[var].data(), qp_data[var].size(), /*line_break=*/qp_data[var].size());
        }
    }
}

write_parameter_data_to_files()

void libMesh::RBParametrized::write_parameter_data_to_files ( const std::string &  continuous_param_file_name, const std::string &  discrete_param_file_name, const bool  write_binary_data  )

inherited

Write out the parameter ranges to files.

Definition at line 197 of file rb_parametrized.C.

References libMesh::RBParametrized::write_discrete_parameter_values_to_file(), and libMesh::RBParametrized::write_parameter_ranges_to_file().

Referenced by libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), and libMesh::RBEvaluation::legacy_write_offline_data_to_files().

{
  write_parameter_ranges_to_file(continuous_param_file_name, write_binary_data);
  write_discrete_parameter_values_to_file(discrete_param_file_name, write_binary_data);
}

Member Data Documentation

_communicator

const Parallel::Communicator& libMesh::ParallelObject::_communicator

protectedinherited

Definition at line 120 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::ParallelObject::comm(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), libMesh::ParallelObject::processor_id(), and libMesh::BoundaryInfo::regenerate_id_sets().

_counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info().

_eim_solutions_for_training_set

std::vector<DenseVector<Number> > libMesh::RBEIMEvaluation::_eim_solutions_for_training_set

private

Storage for EIM solutions from the training set.

This is typically used in the case that we have is_lookup_table==true in our RBParametrizedFunction, since in that case we need to store all the EIM solutions on the training set so that we do not always need to refer to the lookup table itself (since in some cases, like in the Online stage, the lookup table is not available).

Definition at line 730 of file rb_eim_evaluation.h.

Referenced by get_eim_solutions_for_training_set(), and rb_eim_solves().

_eim_vars_to_project_and_write

std::vector<EIMVarGroupPlottingInfo> libMesh::RBEIMEvaluation::_eim_vars_to_project_and_write

protected

This vector specifies which EIM variables will be projected and written out in write_out_projected_basis_functions().

By default this is an empty set, but can be updated in subclasses to specify the EIM variables that are relevant for visualization.

We identify groups of variables with one or more variables in a group. The purpose of using a group is often we plot multiple components of a tensor-valued or vector-valued quantity, so it makes sense to refer to the entire group of variables together in those cases.

Definition at line 651 of file rb_eim_evaluation.h.

Referenced by get_eim_vars_to_project_and_write().

_enable_print_counter

bool libMesh::ReferenceCounter::_enable_print_counter = true

staticprotectedinherited

Flag to control whether reference count information is printed when print_info is called.

Definition at line 143 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info(), and libMesh::ReferenceCounter::print_info().

_error_indicator_interpolation_row

DenseVector<Number> libMesh::RBEIMEvaluation::_error_indicator_interpolation_row

private

Here we store an extra row of the interpolation matrix which is used to compute the EIM error indicator.

This stores the EIM basis function values at the extra point associated with the error indicator.

Definition at line 873 of file rb_eim_evaluation.h.

Referenced by get_eim_error_indicator(), get_error_indicator_interpolation_row(), and set_error_indicator_interpolation_row().

_interpolation_matrix

DenseMatrix<Number> libMesh::RBEIMEvaluation::_interpolation_matrix

private

Dense matrix that stores the lower triangular interpolation matrix that can be used.

Definition at line 745 of file rb_eim_evaluation.h.

Referenced by clear(), get_interpolation_matrix(), rb_eim_solve(), rb_eim_solves(), resize_data_structures(), and set_interpolation_matrix_entry().

_interpolation_points_comp

std::vector<unsigned int> libMesh::RBEIMEvaluation::_interpolation_points_comp

private

In the case of a "vector-valued" EIM, this vector determines which component of the parameterized function we sample at each EIM point.

Definition at line 756 of file rb_eim_evaluation.h.

Referenced by add_interpolation_data(), add_interpolation_points_comp(), add_node_interpolation_data(), add_side_interpolation_data(), clear(), get_interpolation_points_comp(), rb_eim_solves(), and resize_data_structures().

_interpolation_points_spatial_indices

std::vector<std::vector<unsigned int> > libMesh::RBEIMEvaluation::_interpolation_points_spatial_indices

private

Here we store the spatial indices that were initialized by initialize_spatial_indices_at_interp_pts().

These are relevant in the case that _parametrized_function is defined by indexing into separate data based on the mesh-based data.

Definition at line 764 of file rb_eim_evaluation.h.

Referenced by add_interpolation_points_spatial_indices(), clear(), get_interpolation_points_spatial_indices(), get_n_interpolation_points_spatial_indices(), initialize_interpolation_points_spatial_indices(), initialize_param_fn_spatial_indices(), and resize_data_structures().

_is_eim_error_indicator_active

bool libMesh::RBEIMEvaluation::_is_eim_error_indicator_active

private

Indicate if the EIM error indicator is active in RB EIM solves.

Note that this is distinct from use_eim_error_indicator(), since use_eim_error_indicator() indicates if this RBEIMEvaluation has an EIM error indicator defined, whereas _is_eim_error_indicator_active is used to turn on or off the error indicator. This primary purpose of _is_eim_error_indicator_active is to turn the error indicator off during EIM training (when it is not relevant) and to turn it on during "online solves".

Definition at line 866 of file rb_eim_evaluation.h.

Referenced by rb_eim_solves(), and set_eim_error_indicator_active().

_local_eim_basis_functions

std::vector<QpDataMap> libMesh::RBEIMEvaluation::_local_eim_basis_functions

private

The EIM basis functions.

We store values at quadrature points on elements that are local to this processor. The indexing is as follows: basis function index –> element ID –> variable –> quadrature point –> value We use a map to index the element ID, since the IDs on this processor in general will not start at zero.

Definition at line 788 of file rb_eim_evaluation.h.

Referenced by add_basis_function(), decrement_vector(), distribute_bfs(), gather_bfs(), get_basis_function(), get_eim_basis_function_value(), get_eim_basis_function_values_at_qps(), get_n_basis_functions(), print_local_eim_basis_functions(), read_in_interior_basis_functions(), set_n_basis_functions(), and write_out_interior_basis_functions().

_local_node_eim_basis_functions

std::vector<NodeDataMap> libMesh::RBEIMEvaluation::_local_node_eim_basis_functions

private

The EIM basis functions on element nodes (e.g.

on a nodeset). We store values at nodes that are local to this processor. The indexing is as follows: basis function index –> node ID –> variable –> value We use a map to index the node ID, since the IDs on this processor in general will not start at zero.

Definition at line 808 of file rb_eim_evaluation.h.

Referenced by add_node_basis_function(), get_eim_basis_function_node_local_value(), get_eim_basis_function_node_value(), get_n_basis_functions(), get_node_basis_function(), node_decrement_vector(), node_distribute_bfs(), node_gather_bfs(), print_local_eim_basis_functions(), read_in_node_basis_functions(), set_n_basis_functions(), and write_out_node_basis_functions().

_local_side_eim_basis_functions

std::vector<SideQpDataMap> libMesh::RBEIMEvaluation::_local_side_eim_basis_functions

private

The EIM basis functions on element sides.

We store values at quadrature points on elements that are local to this processor. The indexing is as follows: basis function index –> (element ID,side index) –> variable –> quadrature point –> value We use a map to index the element ID, since the IDs on this processor in general will not start at zero.

Definition at line 798 of file rb_eim_evaluation.h.

Referenced by add_side_basis_function(), get_eim_basis_function_side_value(), get_eim_basis_function_side_values_at_qps(), get_n_basis_functions(), get_side_basis_function(), print_local_eim_basis_functions(), read_in_side_basis_functions(), set_n_basis_functions(), side_decrement_vector(), side_distribute_bfs(), side_gather_bfs(), and write_out_side_basis_functions().

_mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 of file reference_counter.h.

_n_objects

Threads::atomic< unsigned int > libMesh::ReferenceCounter::_n_objects

staticprotectedinherited

The number of objects.

Print the reference count information when the number returns to 0.

Definition at line 132 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::n_objects(), libMesh::ReferenceCounter::ReferenceCounter(), and libMesh::ReferenceCounter::~ReferenceCounter().

_parametrized_function

std::unique_ptr<RBParametrizedFunction> libMesh::RBEIMEvaluation::_parametrized_function

private

Store the parametrized function that will be approximated by this EIM system.

Note that the parametrized function may have more than one component, and each component is approximated by a separate variable in the EIM system.

Definition at line 772 of file rb_eim_evaluation.h.

Referenced by get_parametrized_function(), and set_parametrized_function().

_preserve_rb_eim_solutions

bool libMesh::RBEIMEvaluation::_preserve_rb_eim_solutions

private

Boolean to indicate if we skip updating _rb_eim_solutions in rb_eim_solves().

This is relevant for cases when we set up _rb_eim_solutions elsewhere and we want to avoid changing it.

Definition at line 855 of file rb_eim_evaluation.h.

Referenced by get_preserve_rb_eim_solutions(), rb_eim_solves(), and set_preserve_rb_eim_solutions().

_rb_eim_error_indicators

std::vector<Real> libMesh::RBEIMEvaluation::_rb_eim_error_indicators

private

If we're using the EIM error indicator, then we store the error indicator values corresponding to _rb_eim_solutions here.

Definition at line 720 of file rb_eim_evaluation.h.

Referenced by get_rb_eim_error_indicators(), and rb_eim_solves().

_rb_eim_solutions

std::vector<DenseVector<Number> > libMesh::RBEIMEvaluation::_rb_eim_solutions

private

The EIM solution coefficients from the most recent call to rb_eim_solves().

Definition at line 714 of file rb_eim_evaluation.h.

Referenced by get_rb_eim_solutions(), get_rb_eim_solutions_entries(), rb_eim_solves(), and set_rb_eim_solutions().

_rb_eim_solves_mus

std::vector<RBParameters> libMesh::RBEIMEvaluation::_rb_eim_solves_mus

private

The parameters and the number of basis functions that were used in the most recent call to rb_eim_solves().

We store this so that we can check if we can skip calling rb_eim_solves() again if the inputs haven't changed.

Definition at line 738 of file rb_eim_evaluation.h.

Referenced by rb_eim_solves().

_rb_eim_solves_N

unsigned int libMesh::RBEIMEvaluation::_rb_eim_solves_N

private

Definition at line 739 of file rb_eim_evaluation.h.

Referenced by rb_eim_solves().

_rb_eim_theta_objects

std::vector<std::unique_ptr<RBTheta> > libMesh::RBEIMEvaluation::_rb_eim_theta_objects

private

The vector of RBTheta objects that are created to point to this RBEIMEvaluation.

Definition at line 778 of file rb_eim_evaluation.h.

Referenced by clear(), get_eim_theta_objects(), and initialize_eim_theta_objects().

_scale_components_in_enrichment

std::set<unsigned int> libMesh::RBEIMEvaluation::_scale_components_in_enrichment

protected

This set that specifies which EIM variables will be scaled during EIM enrichment so that their maximum value matches the maximum value across all variables.

This is helpful in cases where some components are much smaller in magnitude than others, since in those cases if we do not apply component scaling to the small components then the accuracy of the EIM approximation for those components will not be controlled well by the EIM enrichment process.

Definition at line 662 of file rb_eim_evaluation.h.

Referenced by scale_components_in_enrichment().

_vec_eval_input

VectorizedEvalInput libMesh::RBEIMEvaluation::_vec_eval_input

private

We store the EIM interpolation point data in this object.

Definition at line 750 of file rb_eim_evaluation.h.

Referenced by add_interpolation_data(), add_interpolation_points_boundary_id(), add_interpolation_points_elem_id(), add_interpolation_points_elem_type(), add_interpolation_points_JxW_all_qp(), add_interpolation_points_node_id(), add_interpolation_points_phi_i_all_qp(), add_interpolation_points_phi_i_qp(), add_interpolation_points_qp(), add_interpolation_points_side_index(), add_interpolation_points_subdomain_id(), add_interpolation_points_xyz(), add_interpolation_points_xyz_perturbations(), add_node_interpolation_data(), add_side_interpolation_data(), clear(), get_interpolation_points_boundary_id(), get_interpolation_points_elem_id(), get_interpolation_points_elem_type(), get_interpolation_points_JxW_all_qp(), get_interpolation_points_node_id(), get_interpolation_points_phi_i_all_qp(), get_interpolation_points_phi_i_qp(), get_interpolation_points_qp(), get_interpolation_points_side_index(), get_interpolation_points_subdomain_id(), get_interpolation_points_xyz(), get_interpolation_points_xyz_perturbations(), get_n_interpolation_points(), get_vec_eval_input(), initialize_interpolation_points_spatial_indices(), initialize_param_fn_spatial_indices(), rb_eim_solves(), and resize_data_structures().

eim_error_indicator_normalization

EimErrorIndicatorNormalization libMesh::RBEIMEvaluation::eim_error_indicator_normalization

Definition at line 636 of file rb_eim_evaluation.h.

Referenced by get_eim_error_indicator().

verbose_mode

bool libMesh::RBParametrized::verbose_mode

inherited

Public boolean to toggle verbose mode.

Definition at line 191 of file rb_parametrized.h.

Referenced by libMesh::RBParametrized::check_if_valid_params().

---

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

• include/reduced_basis/rb_eim_evaluation.h
• src/reduced_basis/rb_eim_evaluation.C