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_SUM , RESIDUAL_RHS , 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.

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.

typedef std::map< dof_id_type, std::vector< Number > >	NodeDataMap
	Type of the data structure used to map from (node id) -> [n_vars] data.

Public Member Functions
	RBEIMEvaluation (const Parallel::Communicator &comm)
	Constructor.

	RBEIMEvaluation (RBEIMEvaluation &&)=default
	Special functions.

	RBEIMEvaluation (const RBEIMEvaluation &)=delete

RBEIMEvaluation &	operator= (const RBEIMEvaluation &)=delete

RBEIMEvaluation &	operator= (RBEIMEvaluation &&)=default

virtual	~RBEIMEvaluation ()

virtual void	clear () override
	Clear this object.

void	resize_data_structures (const unsigned int Nmax)
	Resize the data structures for storing data associated with this object.

void	set_parametrized_function (std::unique_ptr< RBParametrizedFunction > pf)
	Set the parametrized function that we will approximate using the Empirical Interpolation Method.

RBParametrizedFunction &	get_parametrized_function ()
	Get a reference to the parametrized function.

const RBParametrizedFunction &	get_parametrized_function () const
	Get a const reference to the parametrized function.

DenseVector< Number >	rb_eim_solve (DenseVector< Number > &EIM_rhs)
	Calculate the EIM approximation for the given right-hand side vector `EIM_rhs`.

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.

void	initialize_interpolation_points_spatial_indices ()
	Initialize _interpolation_points_spatial_indices.

void	initialize_param_fn_spatial_indices ()
	The Online counterpart of initialize_interpolation_points_spatial_indices().

unsigned int	get_n_basis_functions () const
	Return the current number of EIM basis functions.

unsigned int	get_n_interpolation_points () const
	Return the number of interpolation points.

unsigned int	get_n_elems () const
	Return the number of unique elements containing interpolation points.

unsigned int	get_n_properties () const
	Return the number of properties stored in the rb_property_map.

void	set_n_basis_functions (unsigned int n_bfs)
	Set the number of basis functions.

void	decrement_vector (QpDataMap &v, const DenseVector< Number > &coeffs)
	Subtract coeffs[i]*basis_function[i] from `v`.

void	side_decrement_vector (SideQpDataMap &v, const DenseVector< Number > &coeffs)
	Same as decrement_vector() except for Side data.

void	node_decrement_vector (NodeDataMap &v, const DenseVector< Number > &coeffs)
	Same as decrement_vector() except for node data.

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

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`.

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`.

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.

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.

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.

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.

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.

const QpDataMap &	get_basis_function (unsigned int i) const
	Get a reference to the i^th basis function.

const SideQpDataMap &	get_side_basis_function (unsigned int i) const
	Get a reference to the i^th side basis function.

const NodeDataMap &	get_node_basis_function (unsigned int i) const
	Get a reference to the i^th node basis function.

void	set_rb_eim_solutions (const std::vector< DenseVector< Number > > &rb_eim_solutions)
	Set _rb_eim_solutions.

const std::vector< DenseVector< Number > > &	get_rb_eim_solutions () const
	Return the EIM solution coefficients from the most recent call to rb_eim_solves().

std::vector< Number >	get_rb_eim_solutions_entries (unsigned int index) const
	Return entry `index` for each solution in _rb_eim_solutions.

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.

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.

const std::vector< std::pair< Real, Real > > &	get_rb_eim_error_indicators () const
	Return the EIM error indicator values from the most recent call to rb_eim_solves().

void	add_interpolation_points_xyz (Point p)
	Set the data associated with EIM interpolation points.

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_qrule_order (Order qrule_order)

void	add_elem_center_dxyzdxi (const Point &dxyzdxi)

void	add_elem_center_dxyzdeta (const Point &dxyzdxi)

void	add_interpolation_points_spatial_indices (const std::vector< unsigned int > &spatial_indices)

void	add_elem_id_local_index_map_entry (dof_id_type elem_id, unsigned int local_index)

void	add_rb_property_map_entry (std::string &property_name, std::set< dof_id_type > &entity_ids)

Point	get_interpolation_points_xyz (unsigned int index) const
	Get the data associated with EIM interpolation points.

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

Order	get_interpolation_points_qrule_order (unsigned int index) const

const Point &	get_elem_center_dxyzdxi (unsigned int index) const

const Point &	get_elem_center_dxyzdeta (unsigned int index) const

const std::vector< unsigned int > &	get_interpolation_points_spatial_indices (unsigned int index) const

const std::map< dof_id_type, unsigned int > &	get_elem_id_to_local_index_map () const

const std::unordered_map< std::string, std::set< dof_id_type > > &	get_rb_property_map () 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.

void	set_interpolation_matrix_entry (unsigned int i, unsigned int j, Number value)
	Set entry of the EIM interpolation matrix.

const DenseMatrix< Number > &	get_interpolation_matrix () const
	Get the EIM interpolation matrix.

void	add_basis_function (const QpDataMap &bf)
	Add `bf` to our EIM basis.

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, Order qrule_order, const Point &dxyz_dxi_elem_center, const Point &dxyz_deta_elem_center)
	Add interpolation data associated with a new basis function.

void	add_side_basis_function (const SideQpDataMap &side_bf)
	Add `side_bf` to our EIM basis.

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.

void	add_node_basis_function (const NodeDataMap &node_bf)
	Add `node_bf` to our EIM basis.

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.

void	set_preserve_rb_eim_solutions (bool preserve_rb_eim_solutions)
	Set _preserve_rb_eim_solutions.

bool	get_preserve_rb_eim_solutions () const
	Get _preserve_rb_eim_solutions.

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.

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.

virtual void	project_qp_data_vector_onto_system (System &sys, const std::vector< Number > &bf_data, const EIMVarGroupPlottingInfo &eim_vargroup, const std::map< std::string, std::string > &extra_options)
	Project the EIM basis function data stored in `bf_data` onto sys.solution.

const std::vector< EIMVarGroupPlottingInfo > &	get_eim_vars_to_project_and_write () const
	Get _eim_vars_to_project_and_write.

const std::set< unsigned int > &	scale_components_in_enrichment () const
	Get _scale_components_in_enrichment.

virtual bool	use_eim_error_indicator () const
	Virtual function to indicate if we use the EIM error indicator in this case.

void	set_eim_error_indicator_active (bool is_active)
	Activate/decative the error indicator in EIM solves.

const DenseVector< Number > &	get_error_indicator_interpolation_row () const
	Get/set _extra_points_interpolation_matrix.

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.

const VectorizedEvalInput &	get_vec_eval_input () const
	Get the VectorizedEvalInput data.

void	initialize_rb_property_map ()
	Initialize the rb_property_map of RBEIMEvaluation (this) from the rb_property_map stored in RBParametrizedFunction with empty entries but identical keys.

std::vector< std::vector< std::vector< Number > > >	get_interior_basis_functions_as_vecs ()
	Get all interior basis functions in the form of std::vectors.

std::map< std::string, std::size_t >	get_interior_basis_function_sizes (std::vector< unsigned int > &n_qp_per_elem)
	Get data that defines the sizes of interior EIM basis functions.

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.

void	initialize_parameters (const RBParametrized &rb_parametrized)
	Initialize the parameter ranges and set current_parameters.

unsigned int	get_n_params () const
	Get the number of parameters.

unsigned int	get_n_continuous_params () const
	Get the number of continuous parameters.

unsigned int	get_n_discrete_params () const
	Get the number of discrete parameters.

const RBParameters &	get_parameters () const
	Get the current parameters.

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.

const RBParameters &	get_parameters_min () const
	Get an RBParameters object that specifies the minimum allowable value for each parameter.

const RBParameters &	get_parameters_max () const
	Get an RBParameters object that specifies the maximum allowable value for each parameter.

Real	get_parameter_min (const std::string &param_name) const
	Get minimum allowable value of parameter `param_name`.

Real	get_parameter_max (const std::string &param_name) const
	Get maximum allowable value of parameter `param_name`.

void	print_parameters () const
	Print the current parameters.

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.

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.

bool	is_discrete_parameter (const std::string &mu_name) const
	Is parameter `mu_name` discrete?

const std::map< std::string, std::vector< Real > > &	get_discrete_parameter_values () const
	Get a const reference to the discrete parameter values.

void	print_discrete_parameter_values () const
	Print out all the discrete parameter values.

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`.

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.

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.

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.

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.

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.

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.

static void	print_info (std::ostream &out_stream=libMesh::out)
	Prints the reference information, by default to `libMesh::out`.

static unsigned int	n_objects ()
	Prints the number of outstanding (created, but not yet destroyed) objects.

static void	enable_print_counter_info ()
	Methods to enable/disable the reference counter output from print_info().

static void	disable_print_counter_info ()

Public Attributes
EimErrorIndicatorNormalization	eim_error_indicator_normalization

bool	limit_eim_error_indicator_to_one
	If this boolean is true then we clamp EIM error indicator values to be at most 1.

bool	verbose_mode
	Public boolean to toggle verbose mode.

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

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

void	increment_destructor_count (const std::string &name) noexcept
	Increments the destruction counter.

Protected Attributes
std::vector< EIMVarGroupPlottingInfo >	_eim_vars_to_project_and_write
	This vector specifies which EIM variables we want to write to disk and/or project to nodes for plotting purposes.

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.

const Parallel::Communicator &	_communicator

Static Protected Attributes
static Counts	_counts
	Actually holds the data.

static Threads::atomic< unsigned int >	_n_objects
	The number of objects.

static Threads::spin_mutex	_mutex
	Mutual exclusion object to enable thread-safe reference counting.

static bool	_enable_print_counter = true
	Flag to control whether reference count information is printed when print_info is called.

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.

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.

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.

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.

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.

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.

std::vector< std::vector< Number > >	get_interior_basis_function_as_vec_helper (unsigned int n_vars, unsigned int n_qp_data, unsigned int bf_index)
	Helper function called by write_out_interior_basis_functions() to get basis function `bf_index` stored as a std::vector per variable.

void	print_local_eim_basis_functions () const
	Print the contents of _local_eim_basis_functions to libMesh::out.

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

void	side_gather_bfs ()
	Same as gather_bfs() except for side data.

void	node_gather_bfs ()
	Same as gather_bfs() except for node data.

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.

void	side_distribute_bfs (const System &sys)
	Same as distribute_bfs() except for side data.

void	node_distribute_bfs (const System &sys)
	Same as distribute_bfs() except for node data.

void	write_parameter_ranges_to_file (const std::string &file_name, const bool write_binary)
	Write out the parameter ranges to file.

void	write_discrete_parameter_values_to_file (const std::string &file_name, const bool write_binary_data)
	Write out the discrete parameter values to file.

void	read_parameter_ranges_from_file (const std::string &file_name, const bool read_binary, RBParameters &param_min, RBParameters &param_max)
	Read in the parameter ranges from file.

void	read_discrete_parameter_values_from_file (const std::string &file_name, const bool read_binary_data, std::map< std::string, std::vector< Real > > &discrete_parameter_values_in)
	Read in the discrete parameter values from file, if we have any.

bool	check_if_valid_params (const RBParameters &params) const
	Helper function to check that `params` is valid:

Static Private Member Functions
static bool	is_value_in_list (Real value, const std::vector< Real > &list_of_values, Real tol)
	Helper function to check if the specified value is in the list of values (within a tolerance given by `tol`).

Private Attributes
std::vector< DenseVector< Number > >	_rb_eim_solutions
	The EIM solution coefficients from the most recent call to rb_eim_solves().

std::vector< std::pair< Real, 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.

std::vector< DenseVector< Number > >	_eim_solutions_for_training_set
	Storage for EIM solutions from the training set.

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().

unsigned int	_rb_eim_solves_N

DenseMatrix< Number >	_interpolation_matrix
	Dense matrix that stores the lower triangular interpolation matrix that can be used.

VectorizedEvalInput	_vec_eval_input
	We store the EIM interpolation point data in this object.

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.

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().

std::unique_ptr< RBParametrizedFunction >	_parametrized_function
	Store the parametrized function that will be approximated by this EIM system.

std::vector< std::unique_ptr< RBTheta > >	_rb_eim_theta_objects
	The vector of RBTheta objects that are created to point to this RBEIMEvaluation.

std::vector< QpDataMap >	_local_eim_basis_functions
	The EIM basis functions.

std::vector< SideQpDataMap >	_local_side_eim_basis_functions
	The EIM basis functions on element sides.

std::vector< NodeDataMap >	_local_node_eim_basis_functions
	The EIM basis functions on element nodes (e.g.

bool	_preserve_rb_eim_solutions
	Boolean to indicate if we skip updating _rb_eim_solutions in rb_eim_solves().

bool	_is_eim_error_indicator_active
	Indicate if the EIM error indicator is active in RB EIM solves.

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.

bool	parameters_initialized
	Flag indicating whether the parameters have been initialized.

RBParameters	parameters
	Vector storing the current parameters.

RBParameters	parameters_min
	Vectors that define the ranges (min and max) for the parameters.

RBParameters	parameters_max

std::map< std::string, std::vector< Real > >	_discrete_parameter_values
	Map that defines the allowable values of any discrete parameters.

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 111 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 146 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 136 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 141 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_SUM: Use the sum of the terms in the EIM residual to determine the error indicator normalization. This ensures that the error indicator value will be at most 1.0, which may be a desirable property of the indicator.

RHS: Use only the right-hand side value for the EIM residual to determine the error indicator normalization.

MAX_RHS: Use the maximum value in the EIM RHS vector to determine the error indicator normalization (default). This is helpful when the values at some EIM points are much larger than others, since in this scenario we typically want to normalize the error indicator based on the largest values in order to avoid overestimating the error.

Enumerator
RESIDUAL_SUM
RESIDUAL_RHS
MAX_RHS

Definition at line 715 of file rb_eim_evaluation.h.

715{ RESIDUAL_SUM, RESIDUAL_RHS, MAX_RHS };

libMesh::RBEIMEvaluation::RESIDUAL_RHS

@ RESIDUAL_RHS

Definition rb_eim_evaluation.h:715

libMesh::RBEIMEvaluation::MAX_RHS

@ MAX_RHS

Definition rb_eim_evaluation.h:715

libMesh::RBEIMEvaluation::RESIDUAL_SUM

@ RESIDUAL_SUM

Definition rb_eim_evaluation.h:715

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::MAX_RHS),
limit_eim_error_indicator_to_one(true),
_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 963 of file rb_eim_evaluation.C.

{
  _local_eim_basis_functions.emplace_back(bf);
}

References _local_eim_basis_functions.

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

◆ add_elem_center_dxyzdeta()

void RBEIMEvaluation::add_elem_center_dxyzdeta ( const Point & dxyzdxi )

Definition at line 778 of file rb_eim_evaluation.C.

{
  _vec_eval_input.dxyzdeta_elem_center.emplace_back(dxyzdeta);
}

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

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

◆ add_elem_center_dxyzdxi()

void RBEIMEvaluation::add_elem_center_dxyzdxi ( const Point & dxyzdxi )

Definition at line 773 of file rb_eim_evaluation.C.

{
  _vec_eval_input.dxyzdxi_elem_center.emplace_back(dxyzdxi);
}

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

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

◆ add_elem_id_local_index_map_entry()

void RBEIMEvaluation::add_elem_id_local_index_map_entry	(	dof_id_type	elem_id,
		unsigned int	local_index
	)

Definition at line 793 of file rb_eim_evaluation.C.

{
  // Try to insert object and return an error if object already inserted as duplicated should not happen.
  bool insert_succeed = _vec_eval_input.elem_id_to_local_index.insert({elem_id, local_index}).second;
  libmesh_error_msg_if(!insert_succeed, "Entry already added, duplicate detected.");
}

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

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

◆ 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,
		Order	qrule_order,
		const Point &	dxyz_dxi_elem_center,
		const Point &	dxyz_deta_elem_center
	)

Add interpolation data associated with a new basis function.

Definition at line 969 of file rb_eim_evaluation.C.

{
  _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);
 
  // The following quantities are indexed by elem id to prevent duplicated data
  // If an entry is already present then we should not need to add that data again as it is element
  // based so it should be identical between 2 points if they refer to the same element id.
  if (_vec_eval_input.elem_id_to_local_index.count(elem_id) == 0)
  {
    unsigned int local_index = _vec_eval_input.JxW_all_qp.size();
    // Maybe check that getting local index from a a different source is still ok.
    _vec_eval_input.elem_id_to_local_index[elem_id] = local_index;
    _vec_eval_input.JxW_all_qp.emplace_back(JxW_all_qp);
    _vec_eval_input.phi_i_all_qp.emplace_back(phi_i_all_qp);
    _vec_eval_input.qrule_orders.emplace_back(qrule_order);
    _vec_eval_input.dxyzdxi_elem_center.emplace_back(dxyzdxi_elem_center);
    _vec_eval_input.dxyzdeta_elem_center.emplace_back(dxyzdeta_elem_center);
  }
 
  // add_interpolation_data_to_property_map is a virtual function that aims to add only the property data
  // required by the corresponding rb_parametrized_function.
  // Right now, only elem_ids are supported but if subdomain_ids need to be stored for a property
  // it can be added to the list of arguments and used in the overridden subclass function, the map type
  // might also required an update to support various id types.
  get_parametrized_function().add_interpolation_data_to_rb_property_map(this->comm(),
                                                                        _vec_eval_input.rb_property_map,
                                                                        elem_id);
}

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

◆ add_interpolation_points_boundary_id()

void RBEIMEvaluation::add_interpolation_points_boundary_id ( boundary_id_type b_id )

Definition at line 723 of file rb_eim_evaluation.C.

{
  _vec_eval_input.boundary_ids.emplace_back(b_id);
}

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

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

◆ add_interpolation_points_comp()

void RBEIMEvaluation::add_interpolation_points_comp ( unsigned int comp )

Definition at line 713 of file rb_eim_evaluation.C.

{
  _interpolation_points_comp.emplace_back(comp);
}

References _interpolation_points_comp.

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

◆ add_interpolation_points_elem_id()

void RBEIMEvaluation::add_interpolation_points_elem_id ( dof_id_type elem_id )

Definition at line 733 of file rb_eim_evaluation.C.

{
  _vec_eval_input.elem_ids.emplace_back(elem_id);
}

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

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

◆ add_interpolation_points_elem_type()

void RBEIMEvaluation::add_interpolation_points_elem_type ( ElemType elem_type )

Definition at line 753 of file rb_eim_evaluation.C.

{
  _vec_eval_input.elem_types.emplace_back(elem_type);
}

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

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

◆ add_interpolation_points_JxW_all_qp()

void RBEIMEvaluation::add_interpolation_points_JxW_all_qp ( const std::vector< Real > & JxW_all_qp )

Definition at line 758 of file rb_eim_evaluation.C.

{
  _vec_eval_input.JxW_all_qp.emplace_back(JxW_all_qp);
}

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

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

◆ add_interpolation_points_node_id()

void RBEIMEvaluation::add_interpolation_points_node_id ( dof_id_type node_id )

Definition at line 743 of file rb_eim_evaluation.C.

{
  _vec_eval_input.node_ids.emplace_back(node_id);
}

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

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

◆ 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 763 of file rb_eim_evaluation.C.

{
  _vec_eval_input.phi_i_all_qp.emplace_back(phi_i_all_qp);
}

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

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

◆ add_interpolation_points_phi_i_qp()

void RBEIMEvaluation::add_interpolation_points_phi_i_qp ( const std::vector< Real > & phi_i_qp )

Definition at line 768 of file rb_eim_evaluation.C.

{
  _vec_eval_input.phi_i_qp.emplace_back(phi_i_qp);
}

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

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

◆ add_interpolation_points_qp()

void RBEIMEvaluation::add_interpolation_points_qp ( unsigned int qp )

Definition at line 748 of file rb_eim_evaluation.C.

{
  _vec_eval_input.qps.emplace_back(qp);
}

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

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

◆ add_interpolation_points_qrule_order()

void RBEIMEvaluation::add_interpolation_points_qrule_order ( Order qrule_order )

Definition at line 783 of file rb_eim_evaluation.C.

{
  _vec_eval_input.qrule_orders.emplace_back(qrule_order);
}

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

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

◆ add_interpolation_points_side_index()

void RBEIMEvaluation::add_interpolation_points_side_index ( unsigned int side_index )

Definition at line 738 of file rb_eim_evaluation.C.

{
  _vec_eval_input.side_indices.emplace_back(side_index);
}

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

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

◆ add_interpolation_points_spatial_indices()

void RBEIMEvaluation::add_interpolation_points_spatial_indices ( const std::vector< unsigned int > & spatial_indices )

Definition at line 788 of file rb_eim_evaluation.C.

{
  _interpolation_points_spatial_indices.emplace_back(spatial_indices);
}

References _interpolation_points_spatial_indices.

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

◆ add_interpolation_points_subdomain_id()

void RBEIMEvaluation::add_interpolation_points_subdomain_id ( subdomain_id_type sbd_id )

Definition at line 718 of file rb_eim_evaluation.C.

{
  _vec_eval_input.sbd_ids.emplace_back(sbd_id);
}

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

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

◆ add_interpolation_points_xyz()

void RBEIMEvaluation::add_interpolation_points_xyz ( Point p )

Set the data associated with EIM interpolation points.

Definition at line 708 of file rb_eim_evaluation.C.

{
  _vec_eval_input.all_xyz.emplace_back(p);
}

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

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

◆ add_interpolation_points_xyz_perturbations()

void RBEIMEvaluation::add_interpolation_points_xyz_perturbations ( const std::vector< Point > & perturbs )

Definition at line 728 of file rb_eim_evaluation.C.

{
  _vec_eval_input.all_xyz_perturb.emplace_back(perturbs);
}

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

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

◆ add_node_basis_function()

void RBEIMEvaluation::add_node_basis_function ( const NodeDataMap & node_bf )

Add node_bf to our EIM basis.

Definition at line 1055 of file rb_eim_evaluation.C.

{
  _local_node_eim_basis_functions.emplace_back(node_bf);
}

References _local_node_eim_basis_functions.

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

◆ 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 1061 of file rb_eim_evaluation.C.

{
  _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();
  _vec_eval_input.qrule_orders.emplace_back(INVALID_ORDER);
  _vec_eval_input.dxyzdxi_elem_center.emplace_back();
  _vec_eval_input.dxyzdeta_elem_center.emplace_back();
}

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

◆ add_rb_property_map_entry()

void RBEIMEvaluation::add_rb_property_map_entry	(	std::string &	property_name,
		std::set< dof_id_type > &	entity_ids
	)

Definition at line 800 of file rb_eim_evaluation.C.

{
  bool insert_succeed = _vec_eval_input.rb_property_map.insert({property_name, entity_ids}).second;
  libmesh_error_msg_if(!insert_succeed, "Entry already added, duplicate detected.");
}

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

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

◆ add_side_basis_function()

void RBEIMEvaluation::add_side_basis_function ( const SideQpDataMap & side_bf )

Add side_bf to our EIM basis.

Definition at line 1018 of file rb_eim_evaluation.C.

{
  _local_side_eim_basis_functions.emplace_back(side_bf);
}

References _local_side_eim_basis_functions.

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

◆ 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 1024 of file rb_eim_evaluation.C.

{
  _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();
  _vec_eval_input.qrule_orders.emplace_back(INVALID_ORDER);
  _vec_eval_input.dxyzdxi_elem_center.emplace_back();
  _vec_eval_input.dxyzdeta_elem_center.emplace_back();
}

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

◆ 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 429 of file rb_eim_evaluation.C.

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

Referenced by initialize_eim_theta_objects().

◆ check_if_valid_params()

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

privateinherited

Helper function to check that params is valid:

same number of parameters (error)
parameter values are within the min/max range (warning)
discrete values are correctly discrete within tolerance (warning) Warnings are only printed if "verbose_mode" is true.

Definition at line 378 of file rb_parametrized.C.

{
  // Check if number of parameters are correct.
  libmesh_error_msg_if(params.n_parameters() != get_n_params(),
                       "Error: Number of parameters don't match; found "
                       << params.n_parameters() << ", expected "
                       << get_n_params());
 
  bool is_valid = true;
  std::string prev_param_name = "";
  for (const auto & [param_name, sample_vec] : params)
    {
      std::size_t sample_idx = 0;
      const Real & min_value = get_parameter_min(param_name);
      const Real & max_value = get_parameter_max(param_name);
      for (const auto & value_vec : sample_vec)
        {
          for (const auto & value : value_vec)
            {
              // Check every parameter value (including across samples and vector-values)
              // to ensure it's within the min/max range.
              const bool outside_range = ((value < min_value) || (value > max_value));
              is_valid = is_valid && !outside_range;
              if (outside_range && verbose_mode)
                {
                  libMesh::out << "Warning: parameter " << param_name << " value="
                               << value << " outside acceptable range: ("
                               << min_value << ", " << max_value << ")";
                }
 
              // For discrete params, make sure params.get_value(param_name) is sufficiently
              // close to one of the discrete parameter values.
              // Note that vector-values not yet supported in discrete parameters,
              // and the .get_sample_value() call will throw an error if the user
              // tries to do it.
              if (const auto it = get_discrete_parameter_values().find(param_name);
                  it != get_discrete_parameter_values().end())
                {
                  const bool is_value_discrete =
                    is_value_in_list(params.get_sample_value(param_name, sample_idx),
                                     it->second,
                                     TOLERANCE);
                  is_valid = is_valid && is_value_discrete;
                  if (!is_value_discrete && verbose_mode)
                    libMesh::out << "Warning: parameter " << param_name << " value="
                                 << value << " is not in discrete value list.";
                }
            }
          ++sample_idx;
        }
    }
  return is_valid;
}

References libMesh::RBParametrized::get_discrete_parameter_values(), libMesh::RBParametrized::get_n_params(), libMesh::RBParametrized::get_parameter_max(), libMesh::RBParametrized::get_parameter_min(), libMesh::RBParameters::get_sample_value(), libMesh::RBParametrized::is_value_in_list(), libMesh::RBParameters::n_parameters(), libMesh::out, libMesh::Real, libMesh::TOLERANCE, value, and libMesh::RBParametrized::verbose_mode.

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

◆ clear()

void RBEIMEvaluation::clear ( )

overridevirtual

Clear this object.

Reimplemented from libMesh::RBParametrized.

Definition at line 61 of file rb_eim_evaluation.C.

{
  _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();
}

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(), gather_bfs(), node_distribute_bfs(), side_distribute_bfs(), side_gather_bfs(), and write_out_side_basis_functions().

◆ 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.

98 { return _communicator; }

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition parallel_object.h:120

References libMesh::ParallelObject::_communicator.

◆ decrement_vector()

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

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

Definition at line 340 of file rb_eim_evaluation.C.

{
  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];
            }
    }
}

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().

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 100 of file reference_counter.C.

{
  _enable_print_counter = false;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

◆ 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 2297 of file rb_eim_evaluation.C.

{
  // 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)
}

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

Referenced by read_in_interior_basis_functions().

◆ enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Enabled by default.

Definition at line 94 of file reference_counter.C.

{
  _enable_print_counter = true;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

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

◆ 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 1878 of file rb_eim_evaluation.C.

{
  // 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();
  libmesh_assert(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
}

References _local_eim_basis_functions, clear(), libMesh::ParallelObject::comm(), libMesh::Parallel::Communicator::gather(), libMesh::index_range(), libMesh::libmesh_assert(), libMesh::Parallel::Communicator::max(), libMesh::ParallelObject::n_processors(), n_vars, and libMesh::ParallelObject::processor_id().

Referenced by get_interior_basis_functions_as_vecs(), and write_out_interior_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 650 of file rb_eim_evaluation.C.

{
  return _local_eim_basis_functions[i];
}

References _local_eim_basis_functions.

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

◆ 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 432 of file rb_parametrized.C.

{
  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;
}

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

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

◆ 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 359 of file rb_parametrized.C.

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

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().

◆ 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 588 of file rb_eim_evaluation.C.

{
  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);
}

References _local_node_eim_basis_functions, and get_parametrized_function_node_local_value().

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

◆ 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 601 of file rb_eim_evaluation.C.

{
  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);
}

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

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

◆ 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 631 of file rb_eim_evaluation.C.

{
  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);
}

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

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

◆ 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 571 of file rb_eim_evaluation.C.

{
  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);
}

References _local_side_eim_basis_functions, and get_parametrized_function_side_values_at_qps().

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

◆ 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 615 of file rb_eim_evaluation.C.

{
  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);
}

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

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

◆ 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 556 of file rb_eim_evaluation.C.

{
  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);
}

References _local_eim_basis_functions, and get_parametrized_function_values_at_qps().

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

◆ 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 3053 of file rb_eim_evaluation.C.

{
  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_SUM)
  {
    // This normalization is based on the sum of terms from the "EIM residual" calculation
    // used in the calculation of error_indicator_val. This ensures that the error indicator
    // will always be less than or equal to one, which is a useful property for an error
    // indicator.
    normalization =
      std::abs(error_indicator_rhs) + std::abs(EIM_val_at_error_indicator_pt);
  }
  else if (eim_error_indicator_normalization == RESIDUAL_RHS)
  {
    // Normalize with respect to the right-hand side from the "EIM residual" calculation.
    normalization = std::abs(error_indicator_rhs);
  }
  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.
  // But we return the "original normalization" as well (as opposed to the modified
  // normalization) since that can be useful information since it can indicate that
  // the EIM approximation was identically zero, for example.
  Real orig_normalization = normalization;
  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.
  //
  // We also optionally clamp the relative error indicator to 1.0 since this typically
  // indicators 100% error and hence it may be the maximum value that we want to see.
  Real rel_error_indicator = std::abs(error_indicator_val) / normalization;
  if (limit_eim_error_indicator_to_one && (rel_error_indicator > 1.0))
    rel_error_indicator = 1.0;
 
  return std::make_pair(rel_error_indicator, orig_normalization);
}

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

Referenced by rb_eim_solves().

◆ get_eim_solutions_for_training_set() [1/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 698 of file rb_eim_evaluation.C.

{
  return _eim_solutions_for_training_set;
}

References _eim_solutions_for_training_set.

◆ get_eim_solutions_for_training_set() [2/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 693 of file rb_eim_evaluation.C.

{
  return _eim_solutions_for_training_set;
}

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().

◆ 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 424 of file rb_eim_evaluation.C.

{
  return _rb_eim_theta_objects;
}

References _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 3025 of file rb_eim_evaluation.C.

{
  return _eim_vars_to_project_and_write;
}

References _eim_vars_to_project_and_write.

◆ get_elem_center_dxyzdeta()

const Point & RBEIMEvaluation::get_elem_center_dxyzdeta ( unsigned int index ) const

Definition at line 914 of file rb_eim_evaluation.C.

{
  libmesh_error_msg_if(index >= _vec_eval_input.dxyzdeta_elem_center.size(), "Error: Invalid index");
 
  return _vec_eval_input.dxyzdeta_elem_center[index];
}

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

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

◆ get_elem_center_dxyzdxi()

const Point & RBEIMEvaluation::get_elem_center_dxyzdxi ( unsigned int index ) const

Definition at line 907 of file rb_eim_evaluation.C.

{
  libmesh_error_msg_if(index >= _vec_eval_input.dxyzdxi_elem_center.size(), "Error: Invalid index");
 
  return _vec_eval_input.dxyzdxi_elem_center[index];
}

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

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

◆ get_elem_id_to_local_index_map()

const std::map< dof_id_type, unsigned int > & RBEIMEvaluation::get_elem_id_to_local_index_map ( ) const

Definition at line 883 of file rb_eim_evaluation.C.

{
  return _vec_eval_input.elem_id_to_local_index;
}

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

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

◆ get_error_indicator_interpolation_row()

const DenseVector< Number > & RBEIMEvaluation::get_error_indicator_interpolation_row ( ) const

Get/set _extra_points_interpolation_matrix.

Definition at line 3131 of file rb_eim_evaluation.C.

{
  return _error_indicator_interpolation_row;
}

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

◆ 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.

{
#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
}

References libMesh::ReferenceCounter::_counts.

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

◆ get_interior_basis_function_as_vec_helper()

std::vector< std::vector< Number > > RBEIMEvaluation::get_interior_basis_function_as_vec_helper	(	unsigned int	n_vars,
		unsigned int	n_qp_data,
		unsigned int	bf_index
	)

private

Helper function called by write_out_interior_basis_functions() to get basis function bf_index stored as a std::vector per variable.

Definition at line 1235 of file rb_eim_evaluation.C.

{
  LOG_SCOPE("get_interior_basis_function_as_vec_helper()", "RBEIMEvaluation");
 
  std::vector<std::vector<Number>> qp_data(n_vars);
 
  // Reserve enough capacity in qp_data in order to do the insertions below
  // without further memory allocation.
  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.
 
  libmesh_error_msg_if(bf_index >= _local_eim_basis_functions.size(), "bf_index not valid");
  for (const auto & pr : _local_eim_basis_functions[bf_index])
    {
      // 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());
        }
    }
 
  return qp_data;
}

References _local_eim_basis_functions, libMesh::index_range(), and n_vars.

Referenced by get_interior_basis_functions_as_vecs(), and write_out_interior_basis_functions().

◆ get_interior_basis_function_sizes()

std::map< std::string, std::size_t > RBEIMEvaluation::get_interior_basis_function_sizes ( std::vector< unsigned int > & n_qp_per_elem )

Get data that defines the sizes of interior EIM basis functions.

Definition at line 1181 of file rb_eim_evaluation.C.

{
  std::map<std::string,std::size_t> interior_basis_function_sizes;
 
  // 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();
  interior_basis_function_sizes["n_bf"] = n_bf;
 
  // 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();
  interior_basis_function_sizes["n_elem"] = n_elem;
 
  // 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();
  interior_basis_function_sizes["n_vars"] = n_vars;
 
  // 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.
  n_qp_per_elem.clear();
  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());
    }
 
  // 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);
  interior_basis_function_sizes["n_qp_data"] = n_qp_data;
 
  return interior_basis_function_sizes;
}

References _local_eim_basis_functions, and n_vars.

Referenced by get_interior_basis_functions_as_vecs(), and write_out_interior_basis_functions().

◆ get_interior_basis_functions_as_vecs()

std::vector< std::vector< std::vector< Number > > > RBEIMEvaluation::get_interior_basis_functions_as_vecs ( )

Get all interior basis functions in the form of std::vectors.

This can provide a convenient format for processing the basis function data, or writing it to disk.

Indexing is as follows: basis function index --> variable index --> data at qps per elems

In parallel we gather basis functions to processor 0 and hence we only return non-empty data on processor 0.

Definition at line 1272 of file rb_eim_evaluation.C.

{
  LOG_SCOPE("get_interior_basis_function_as_vec()", "RBEIMEvaluation");
 
  std::vector<std::vector<std::vector<Number>>> interior_basis_functions;
 
  // 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();
  libmesh_assert(this->comm().verify(is_empty));
 
  if (is_empty)
    return interior_basis_functions;
 
  // 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();
 
  if (this->processor_id() == 0)
    {
      std::vector<unsigned int> n_qp_per_elem;
      std::map<std::string,std::size_t> interior_basis_function_sizes =
        get_interior_basis_function_sizes(n_qp_per_elem);
 
      for (auto bf_index : index_range(_local_eim_basis_functions))
        interior_basis_functions.emplace_back(
          get_interior_basis_function_as_vec_helper(
            libmesh_map_find(interior_basis_function_sizes,"n_vars"),
            libmesh_map_find(interior_basis_function_sizes,"n_qp_data"),
            bf_index));
    }
 
  return interior_basis_functions;
}

References _local_eim_basis_functions, libMesh::ParallelObject::comm(), gather_bfs(), get_interior_basis_function_as_vec_helper(), get_interior_basis_function_sizes(), libMesh::index_range(), libMesh::libmesh_assert(), and libMesh::ParallelObject::processor_id().

◆ get_interpolation_matrix()

const DenseMatrix< Number > & RBEIMEvaluation::get_interpolation_matrix ( ) const

Get the EIM interpolation matrix.

Definition at line 948 of file rb_eim_evaluation.C.

{
  return _interpolation_matrix;
}

References _interpolation_matrix.

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

◆ get_interpolation_points_boundary_id()

boundary_id_type RBEIMEvaluation::get_interpolation_points_boundary_id ( unsigned int index ) const

Definition at line 827 of file rb_eim_evaluation.C.

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

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

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

◆ get_interpolation_points_comp()

unsigned int RBEIMEvaluation::get_interpolation_points_comp ( unsigned int index ) const

Definition at line 813 of file rb_eim_evaluation.C.

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

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().

◆ get_interpolation_points_elem_id()

dof_id_type RBEIMEvaluation::get_interpolation_points_elem_id ( unsigned int index ) const

Definition at line 841 of file rb_eim_evaluation.C.

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

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().

◆ get_interpolation_points_elem_type()

ElemType RBEIMEvaluation::get_interpolation_points_elem_type ( unsigned int index ) const

Definition at line 869 of file rb_eim_evaluation.C.

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

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

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

◆ get_interpolation_points_JxW_all_qp()

const std::vector< Real > & RBEIMEvaluation::get_interpolation_points_JxW_all_qp ( unsigned int index ) const

Definition at line 876 of file rb_eim_evaluation.C.

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

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

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

◆ get_interpolation_points_node_id()

dof_id_type RBEIMEvaluation::get_interpolation_points_node_id ( unsigned int index ) const

Definition at line 855 of file rb_eim_evaluation.C.

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

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().

◆ 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 893 of file rb_eim_evaluation.C.

{
  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];
}

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

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

◆ get_interpolation_points_phi_i_qp()

const std::vector< Real > & RBEIMEvaluation::get_interpolation_points_phi_i_qp ( unsigned int index ) const

Definition at line 900 of file rb_eim_evaluation.C.

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

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

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

◆ get_interpolation_points_qp()

unsigned int RBEIMEvaluation::get_interpolation_points_qp ( unsigned int index ) const

Definition at line 862 of file rb_eim_evaluation.C.

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

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().

◆ get_interpolation_points_qrule_order()

Order RBEIMEvaluation::get_interpolation_points_qrule_order ( unsigned int index ) const

Definition at line 921 of file rb_eim_evaluation.C.

{
  libmesh_error_msg_if(index >= _vec_eval_input.qrule_orders.size(), "Error: Invalid index");
 
  return _vec_eval_input.qrule_orders[index];
}

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

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

◆ get_interpolation_points_side_index()

unsigned int RBEIMEvaluation::get_interpolation_points_side_index ( unsigned int index ) const

Definition at line 848 of file rb_eim_evaluation.C.

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

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().

◆ get_interpolation_points_spatial_indices()

const std::vector< unsigned int > & RBEIMEvaluation::get_interpolation_points_spatial_indices ( unsigned int index ) const

Definition at line 928 of file rb_eim_evaluation.C.

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

References _interpolation_points_spatial_indices.

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

◆ get_interpolation_points_subdomain_id()

subdomain_id_type RBEIMEvaluation::get_interpolation_points_subdomain_id ( unsigned int index ) const

Definition at line 820 of file rb_eim_evaluation.C.

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

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

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

◆ 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 806 of file rb_eim_evaluation.C.

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

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

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

◆ get_interpolation_points_xyz_perturbations()

const std::vector< Point > & RBEIMEvaluation::get_interpolation_points_xyz_perturbations ( unsigned int index ) const

Definition at line 834 of file rb_eim_evaluation.C.

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

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

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

◆ get_n_basis_functions()

unsigned int RBEIMEvaluation::get_n_basis_functions ( ) const

Return the current number of EIM basis functions.

Definition at line 305 of file rb_eim_evaluation.C.

{
  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();
}

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

◆ 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.

{
  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());
}

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().

◆ 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.

{
  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());
}

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().

◆ get_n_elems()

unsigned int RBEIMEvaluation::get_n_elems ( ) const

Return the number of unique elements containing interpolation points.

Definition at line 320 of file rb_eim_evaluation.C.

{
  return _vec_eval_input.elem_id_to_local_index.size();
}

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

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

◆ 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 315 of file rb_eim_evaluation.C.

{
  return _vec_eval_input.all_xyz.size();
}

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().

◆ 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 935 of file rb_eim_evaluation.C.

{
  return _interpolation_points_spatial_indices.size();
}

References _interpolation_points_spatial_indices.

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

◆ 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.

{
  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();
}

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::RBEIMConstruction::print_info(), libMesh::RBSCMConstruction::print_info(), libMesh::RBConstruction::print_info(), set_eim_error_indicator_active(), and libMesh::RBConstruction::train_reduced_basis_with_POD().

◆ get_n_properties()

unsigned int RBEIMEvaluation::get_n_properties ( ) const

Return the number of properties stored in the rb_property_map.

Definition at line 325 of file rb_eim_evaluation.C.

{
  return _vec_eval_input.rb_property_map.size();
}

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

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

◆ 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 662 of file rb_eim_evaluation.C.

{
  return _local_node_eim_basis_functions[i];
}

References _local_node_eim_basis_functions.

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

◆ 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 171 of file rb_parametrized.C.

{
  libmesh_error_msg_if(!parameters_initialized, "Error: parameters not initialized in RBParametrized::get_parameter_max");
 
  return parameters_max.get_value(param_name);
}

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

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

◆ 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 164 of file rb_parametrized.C.

{
  libmesh_error_msg_if(!parameters_initialized, "Error: parameters not initialized in RBParametrized::get_parameter_min");
 
  return parameters_min.get_value(param_name);
}

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

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

◆ get_parameters()

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

inherited

Get the current parameters.

Definition at line 143 of file rb_parametrized.C.

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

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(), main(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::RBConstruction::preevaluate_thetas(), libMesh::RBEIMConstruction::print_info(), libMesh::RBSCMConstruction::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::RBConstruction::truth_assembly(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_solve(), libMesh::TransientRBConstruction::truth_solve(), libMesh::TransientRBEvaluation::uncached_compute_residual_dual_norm(), and libMesh::RBConstruction::update_greedy_param_list().

◆ 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 157 of file rb_parametrized.C.

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

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::RBConstruction::set_rb_construction_parameters(), libMesh::RBEIMConstruction::set_rb_construction_parameters(), and libMesh::RBParametrized::write_parameter_ranges_to_file().

◆ 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 150 of file rb_parametrized.C.

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

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::RBConstruction::set_rb_construction_parameters(), libMesh::RBEIMConstruction::set_rb_construction_parameters(), and libMesh::RBParametrized::write_parameter_ranges_to_file().

◆ get_parametrized_function() [1/2]

RBParametrizedFunction & RBEIMEvaluation::get_parametrized_function ( )

Get a reference to the parametrized function.

Definition at line 92 of file rb_eim_evaluation.C.

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

References _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 99 of file rb_eim_evaluation.C.

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

References _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 477 of file rb_eim_evaluation.C.

{
  LOG_SCOPE("get_parametrized_function_node_local_value()", "RBEIMConstruction");
 
  if (const auto it = pf.find(node_id);
      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.;
}

Referenced by get_eim_basis_function_node_local_value(), and get_parametrized_function_node_value().

◆ 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 542 of file rb_eim_evaluation.C.

{
  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;
}

References libMesh::ParallelObject::comm(), get_parametrized_function_node_local_value(), libMesh::Parallel::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().

◆ 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 518 of file rb_eim_evaluation.C.

{
  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;
}

References libMesh::ParallelObject::comm(), get_parametrized_function_side_values_at_qps(), libMesh::Parallel::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().

◆ 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 455 of file rb_eim_evaluation.C.

{
  LOG_SCOPE("get_parametrized_function_side_values_at_qps()", "RBEIMConstruction");
 
  values.clear();
 
  if (const auto it = pf.find(std::make_pair(elem_id, side_index));
      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];
  }
}

Referenced by get_eim_basis_function_side_values_at_qps(), and get_parametrized_function_side_value().

◆ 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 495 of file rb_eim_evaluation.C.

{
  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;
}

References libMesh::ParallelObject::comm(), get_parametrized_function_values_at_qps(), libMesh::Parallel::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().

◆ 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 434 of file rb_eim_evaluation.C.

{
  LOG_SCOPE("get_parametrized_function_values_at_qps()", "RBEIMConstruction");
 
  values.clear();
 
  if (const auto it = pf.find(elem_id);
      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];
  }
}

Referenced by get_eim_basis_function_values_at_qps(), and get_parametrized_function_value().

◆ get_preserve_rb_eim_solutions()

bool RBEIMEvaluation::get_preserve_rb_eim_solutions ( ) const

Get _preserve_rb_eim_solutions.

Definition at line 958 of file rb_eim_evaluation.C.

{
  return _preserve_rb_eim_solutions;
}

References _preserve_rb_eim_solutions.

◆ get_rb_eim_error_indicators()

const std::vector< std::pair< Real, Real > > & RBEIMEvaluation::get_rb_eim_error_indicators ( ) const

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

The first entry of each pair is the normalized error indicator, and the second entry is the normalization factor.

Definition at line 703 of file rb_eim_evaluation.C.

{
  return _rb_eim_error_indicators;
}

References _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 672 of file rb_eim_evaluation.C.

{
  return _rb_eim_solutions;
}

References _rb_eim_solutions.

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

◆ 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 677 of file rb_eim_evaluation.C.

{
  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;
}

References _rb_eim_solutions, and libMesh::index_range().

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

◆ get_rb_property_map()

const std::unordered_map< std::string, std::set< dof_id_type > > & RBEIMEvaluation::get_rb_property_map ( ) const

Definition at line 888 of file rb_eim_evaluation.C.

{
  return _vec_eval_input.rb_property_map;
}

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

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

◆ 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 656 of file rb_eim_evaluation.C.

{
  return _local_side_eim_basis_functions[i];
}

References _local_side_eim_basis_functions.

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

◆ get_vec_eval_input()

const VectorizedEvalInput & RBEIMEvaluation::get_vec_eval_input ( ) const

Get the VectorizedEvalInput data.

Definition at line 3117 of file rb_eim_evaluation.C.

{
  return _vec_eval_input;
}

References _vec_eval_input.

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

◆ 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.

{
  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();
  }
}

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

Referenced by libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), and libMesh::ReferenceCountedObject< T >::ReferenceCountedObject().

◆ 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.

{
  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();
  }
}

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

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

◆ 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 416 of file rb_eim_evaluation.C.

{
  // 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));
}

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

◆ 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 291 of file rb_eim_evaluation.C.

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

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().

◆ 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 299 of file rb_eim_evaluation.C.

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

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().

◆ 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.

{
  // 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);
}

References libMesh::RBParametrized::_discrete_parameter_values, libMesh::RBParameters::begin_serialized(), libMesh::RBParameters::end_serialized(), libMesh::RBParameters::n_parameters(), libMesh::RBParameters::n_samples(), 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::RBConstruction::set_rb_construction_parameters(), libMesh::RBEIMConstruction::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().

◆ 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.

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

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

◆ initialize_rb_property_map()

void RBEIMEvaluation::initialize_rb_property_map ( )

Initialize the rb_property_map of RBEIMEvaluation (this) from the rb_property_map stored in RBParametrizedFunction with empty entries but identical keys.

Definition at line 3122 of file rb_eim_evaluation.C.

{
  const auto & rb_property_map = get_parametrized_function().get_rb_property_map();
  // Initialize rb_eim_eval VectorizedEvaluateInput from the one in rb_parametrized_function with
  // empty sets as it will be filled by subclasses virtual functions.
  for (const auto & [key, val] : rb_property_map)
    _vec_eval_input.rb_property_map[key] = {};
}

References _vec_eval_input, get_parametrized_function(), libMesh::RBParametrizedFunction::get_rb_property_map(), and libMesh::VectorizedEvalInput::rb_property_map.

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

◆ is_discrete_parameter()

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

inherited

Is parameter mu_name discrete?

Definition at line 351 of file rb_parametrized.C.

{
  libmesh_error_msg_if(!parameters_initialized,
                       "Error: parameters not initialized in RBParametrized::is_discrete_parameter");
 
  return _discrete_parameter_values.count(mu_name);
}

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().

◆ is_value_in_list()

bool libMesh::RBParametrized::is_value_in_list	(	Real	value,
		const std::vector< Real > &	list_of_values,
		Real	tol
	)

staticprivateinherited

Helper function to check if the specified value is in the list of values (within a tolerance given by tol).

Definition at line 451 of file rb_parametrized.C.

{
  Real closest_value = get_closest_value(value, list_of_values);
 
  // Check if relative tolerance is satisfied
  Real rel_error = std::abs(value - closest_value) / std::abs(value);
  if (rel_error <= tol)
    {
      return true;
    }
 
  // If relative tolerance isn't satisfied, we should still check an absolute
  // error, since relative tolerance can be misleading if value is close to zero
  Real abs_error = std::abs(value - closest_value);
  return (abs_error <= tol);
}

References libMesh::RBParametrized::get_closest_value(), libMesh::Real, and value.

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

◆ 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.

86 { return _n_objects; }

libMesh::ReferenceCounter::_n_objects

static Threads::atomic< unsigned int > _n_objects

The number of objects.

Definition reference_counter.h:132

References libMesh::ReferenceCounter::_n_objects.

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

◆ 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.

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

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

◆ 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 392 of file rb_eim_evaluation.C.

{
  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];
          }
    }
}

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().

◆ node_distribute_bfs()

void RBEIMEvaluation::node_distribute_bfs ( const System & sys )

private

Same as distribute_bfs() except for node data.

Definition at line 2795 of file rb_eim_evaluation.C.

{
  // 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)
}

References _local_node_eim_basis_functions, libMesh::Parallel::Communicator::broadcast(), clear(), libMesh::ParallelObject::comm(), libMesh::Parallel::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(), libMesh::Parallel::Communicator::rank(), libMesh::Parallel::Communicator::scatter(), and libMesh::Parallel::Communicator::size().

Referenced by read_in_node_basis_functions().

◆ node_gather_bfs()

void RBEIMEvaluation::node_gather_bfs ( )

private

Same as gather_bfs() except for node data.

Definition at line 2174 of file rb_eim_evaluation.C.

{
  // 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();
  libmesh_assert(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
}

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

Referenced by write_out_node_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 366 of file rb_parametrized.C.

{
  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;
    }
}

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

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

◆ 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.

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

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

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

◆ 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 1827 of file rb_eim_evaluation.C.

{
  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;
        }
    }
}

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

◆ print_parameters()

void libMesh::RBParametrized::print_parameters ( ) const

inherited

Print the current parameters.

Definition at line 178 of file rb_parametrized.C.

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

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

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

◆ 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.

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

libMesh::Parallel::Communicator::rank

processor_id_type rank() const

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

◆ project_qp_data_vector_onto_system()

void RBEIMEvaluation::project_qp_data_vector_onto_system	(	System &	sys,
		const std::vector< Number > &	bf_data,
		const EIMVarGroupPlottingInfo &	eim_vargroup,
		const std::map< std::string, std::string > &	extra_options
	)

virtual

Project the EIM basis function data stored in bf_data onto sys.solution.

The intent of this function is to work with the data format provided by get_interior_basis_functions_as_vecs(). That format can be easily serialized, if needed, and hence can be used to provide bf_data after reading in data from disk, for example.

extra_options can be used to pass extra information to this method, e.g. options related to how to perform the projection.

This is a no-op by default, implement in sub-classes if needed.

Definition at line 3017 of file rb_eim_evaluation.C.

{
  // No-op by default, implement in subclasses if needed
}

◆ 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 106 of file rb_eim_evaluation.C.

{
  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;
}

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().

◆ 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 125 of file rb_eim_evaluation.C.

{
  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);
          }
 
        counter++;
      }
  }
}

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::DenseVector< T >::get_principal_subvector(), libMesh::index_range(), libMesh::libmesh_ignore(), libMesh::RBParametrizedFunction::lookup_table_param_name, 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().

◆ read_discrete_parameter_values_from_file()

void libMesh::RBParametrized::read_discrete_parameter_values_from_file	(	const std::string &	file_name,
		const bool	read_binary_data,
		std::map< std::string, std::vector< Real > > &	discrete_parameter_values_in
	)

privateinherited

Read in the discrete parameter values from file, if we have any.

Definition at line 318 of file rb_parametrized.C.

{
  // read in the discrete parameters, if we have any
  std::ifstream check_if_file_exists(file_name.c_str());
  if (check_if_file_exists.good())
    {
      // The reading mode: DECODE for binary, READ for ASCII
      XdrMODE mode = read_binary_data ? DECODE : READ;
 
      // Read in the parameter ranges
      Xdr discrete_parameter_values_in(file_name, mode);
      unsigned int n_discrete_params;
      discrete_parameter_values_in >> n_discrete_params;
 
      for (unsigned int i=0; i<n_discrete_params; i++)
        {
          std::string param_name;
          discrete_parameter_values_in >> param_name;
 
          unsigned int n_discrete_values;
          discrete_parameter_values_in >> n_discrete_values;
 
          std::vector<Real> discrete_values(n_discrete_values);
          for (auto & val : discrete_values)
            discrete_parameter_values_in >> val;
 
          discrete_parameter_values[param_name] = discrete_values;
        }
    }
}

References libMesh::DECODE, and libMesh::READ.

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

◆ 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 1520 of file rb_eim_evaluation.C.

{
  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);
}

References get_n_basis_functions(), get_parametrized_function(), read_in_interior_basis_functions(), read_in_node_basis_functions(), and read_in_side_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 1539 of file rb_eim_evaluation.C.

{
  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);
}

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

Referenced by read_in_basis_functions().

◆ 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 1746 of file rb_eim_evaluation.C.

{
  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);
}

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

Referenced by read_in_basis_functions().

◆ 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 1638 of file rb_eim_evaluation.C.

{
  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);
}

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

Referenced by read_in_basis_functions().

◆ 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 262 of file rb_parametrized.C.

{
  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);
}

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

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

◆ read_parameter_ranges_from_file()

void libMesh::RBParametrized::read_parameter_ranges_from_file	(	const std::string &	file_name,
		const bool	read_binary,
		RBParameters &	param_min,
		RBParameters &	param_max
	)

privateinherited

Read in the parameter ranges from file.

Initialize parameters to the "minimum" parameter values.

Definition at line 281 of file rb_parametrized.C.

{
  // The reading mode: DECODE for binary, READ for ASCII
  XdrMODE mode = read_binary_data ? DECODE : READ;
 
  // Read in the parameter ranges
  Xdr parameter_ranges_in(file_name, mode);
  unsigned int n_continuous_params;
  parameter_ranges_in >> n_continuous_params;
 
  for (unsigned int i=0; i<n_continuous_params; i++)
    {
      std::string param_name;
      Real param_value;
 
      parameter_ranges_in >> param_name;
      parameter_ranges_in >> param_value;
 
      param_min.set_value(param_name, param_value);
    }
  for (unsigned int i=0; i<n_continuous_params; i++)
    {
      std::string param_name;
      Real param_value;
 
      parameter_ranges_in >> param_name;
      parameter_ranges_in >> param_value;
 
      param_max.set_value(param_name, param_value);
    }
 
  parameter_ranges_in.close();
}

References libMesh::Xdr::close(), libMesh::DECODE, libMesh::READ, libMesh::Real, and libMesh::RBParameters::set_value().

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

◆ 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 75 of file rb_eim_evaluation.C.

{
  // 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);
}

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().

◆ scale_components_in_enrichment()

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

Get _scale_components_in_enrichment.

Definition at line 3030 of file rb_eim_evaluation.C.

{
  return _scale_components_in_enrichment;
}

References _scale_components_in_enrichment.

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

◆ 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 3042 of file rb_eim_evaluation.C.

{
  // 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());
}

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().

◆ set_error_indicator_interpolation_row()

void RBEIMEvaluation::set_error_indicator_interpolation_row ( const DenseVector< Number > & error_indicator_row )

Definition at line 3136 of file rb_eim_evaluation.C.

{
  _error_indicator_interpolation_row = extra_point_row;
}

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

◆ 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 940 of file rb_eim_evaluation.C.

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

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().

◆ 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 330 of file rb_eim_evaluation.C.

{
  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);
}

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().

◆ 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 129 of file rb_parametrized.C.

{
  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;
}

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(), main(), libMesh::RBSCMEvaluation::reload_current_parameters(), libMesh::RBSCMEvaluation::set_current_parameters_from_C_J(), and RBParametersTest::testRBParametrized().

◆ 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 87 of file rb_eim_evaluation.C.

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

References _parametrized_function.

◆ 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 953 of file rb_eim_evaluation.C.

{
  _preserve_rb_eim_solutions = preserve_rb_eim_solutions;
}

References _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 667 of file rb_eim_evaluation.C.

{
  _rb_eim_solutions = rb_eim_solutions;
}

References _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 366 of file rb_eim_evaluation.C.

{
  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];
            }
    }
}

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().

◆ side_distribute_bfs()

void RBEIMEvaluation::side_distribute_bfs ( const System & sys )

private

Same as distribute_bfs() except for side data.

Definition at line 2520 of file rb_eim_evaluation.C.

{
  // 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)
}

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

Referenced by read_in_side_basis_functions().

◆ side_gather_bfs()

void RBEIMEvaluation::side_gather_bfs ( )

private

Same as gather_bfs() except for side data.

Definition at line 2026 of file rb_eim_evaluation.C.

{
  // 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();
  libmesh_assert(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
}

References _local_side_eim_basis_functions, clear(), libMesh::ParallelObject::comm(), libMesh::Parallel::Communicator::gather(), libMesh::index_range(), libMesh::libmesh_assert(), libMesh::Parallel::Communicator::max(), libMesh::ParallelObject::n_processors(), n_vars, and libMesh::ParallelObject::processor_id().

Referenced by write_out_side_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 3035 of file rb_eim_evaluation.C.

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

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().

◆ write_discrete_parameter_values_to_file()

void libMesh::RBParametrized::write_discrete_parameter_values_to_file	(	const std::string &	file_name,
		const bool	write_binary_data
	)

privateinherited

Write out the discrete parameter values to file.

Definition at line 230 of file rb_parametrized.C.

{
  // write out the discrete parameters, if we have any
  if (get_n_discrete_params() > 0)
    {
      // The writing mode: ENCODE for binary, WRITE for ASCII
      XdrMODE mode = write_binary_data ? ENCODE : WRITE;
 
      Xdr discrete_parameters_out(file_name, mode);
      unsigned int n_discrete_params = get_n_discrete_params();
      discrete_parameters_out << n_discrete_params;
 
      // Note: the following loops are not candidates for structured
      // bindings syntax because the Xdr APIs which they call are not
      // defined for const references. We must therefore make copies
      // to call these functions.
      for (const auto & pr : get_discrete_parameter_values())
        {
          std::string param_name = pr.first;
          auto n_discrete_values = cast_int<unsigned int>(pr.second.size());
          discrete_parameters_out << param_name << n_discrete_values;
 
          for (unsigned int i=0; i<n_discrete_values; i++)
            {
              Real discrete_value = pr.second[i];
              discrete_parameters_out << discrete_value;
            }
        }
    }
}

References libMesh::ENCODE, libMesh::RBParametrized::get_discrete_parameter_values(), libMesh::RBParametrized::get_n_discrete_params(), libMesh::Real, and libMesh::WRITE.

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

◆ 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 1088 of file rb_eim_evaluation.C.

{
  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);
}

References get_parametrized_function(), write_out_interior_basis_functions(), write_out_node_basis_functions(), and write_out_side_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 1102 of file rb_eim_evaluation.C.

{
  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();
  libmesh_assert(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)
    {
      std::vector<unsigned int> n_qp_per_elem;
      auto interior_basis_function_sizes =
        get_interior_basis_function_sizes(n_qp_per_elem);
 
      // 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 = libmesh_map_find(interior_basis_function_sizes,"n_bf");
      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 = libmesh_map_find(interior_basis_function_sizes,"n_elem");
      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 = libmesh_map_find(interior_basis_function_sizes,"n_vars");
      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.
      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 = libmesh_map_find(interior_basis_function_sizes,"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 : index_range(_local_eim_basis_functions))
        {
          auto qp_data = get_interior_basis_function_as_vec_helper(n_vars, n_qp_data, bf_index);
 
          // 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());
        }
    }
}

References _local_eim_basis_functions, libMesh::ParallelObject::comm(), libMesh::ENCODE, gather_bfs(), get_interior_basis_function_as_vec_helper(), get_interior_basis_function_sizes(), libMesh::index_range(), libMesh::libmesh_assert(), libMesh::Utility::mkdir(), n_vars, libMesh::ParallelObject::processor_id(), and libMesh::WRITE.

Referenced by write_out_basis_functions().

◆ 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 1425 of file rb_eim_evaluation.C.

{
  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();
  libmesh_assert(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());
        }
    }
}

References _local_node_eim_basis_functions, libMesh::ParallelObject::comm(), libMesh::Xdr::data(), libMesh::ENCODE, libMesh::index_range(), libMesh::libmesh_assert(), libMesh::Utility::mkdir(), n_vars, node_gather_bfs(), libMesh::ParallelObject::processor_id(), and libMesh::WRITE.

Referenced by write_out_basis_functions().

◆ 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 1309 of file rb_eim_evaluation.C.

{
  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();
  libmesh_assert(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());
        }
    }
}

References _local_side_eim_basis_functions, clear(), libMesh::ParallelObject::comm(), libMesh::Xdr::data(), libMesh::ENCODE, libMesh::index_range(), libMesh::libmesh_assert(), libMesh::Utility::mkdir(), n_vars, libMesh::ParallelObject::processor_id(), side_gather_bfs(), and libMesh::WRITE.

Referenced by write_out_basis_functions().

◆ 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 185 of file rb_parametrized.C.

{
  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);
}

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

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

◆ write_parameter_ranges_to_file()

void libMesh::RBParametrized::write_parameter_ranges_to_file	(	const std::string &	file_name,
		const bool	write_binary
	)

privateinherited

Write out the parameter ranges to file.

Definition at line 193 of file rb_parametrized.C.

{
  // The writing mode: ENCODE for binary, WRITE for ASCII
  XdrMODE mode = write_binary_data ? ENCODE : WRITE;
 
  // Write out the parameter ranges
  Xdr parameter_ranges_out(file_name, mode);
  unsigned int n_continuous_params = get_n_continuous_params();
  parameter_ranges_out << n_continuous_params;
 
  // Note: the following loops are not candidates for structured
  // bindings syntax because the Xdr APIs which they call are not
  // defined for const references. We must therefore make copies to
  // call these functions.
  for (const auto & pr : get_parameters_min())
    {
      std::string param_name = pr.first;
      if (!is_discrete_parameter(param_name))
        {
          Real param_value = get_parameters_min().get_value(param_name);
          parameter_ranges_out << param_name << param_value;
        }
    }
  for (const auto & pr : get_parameters_max())
    {
      std::string param_name = pr.first;
      if (!is_discrete_parameter(param_name))
        {
          Real param_value = get_parameters_max().get_value(param_name);
          parameter_ranges_out << param_name << param_value;
        }
    }
 
  parameter_ranges_out.close();
}

References libMesh::Xdr::close(), libMesh::ENCODE, libMesh::RBParametrized::get_n_continuous_params(), libMesh::RBParametrized::get_parameters_max(), libMesh::RBParametrized::get_parameters_min(), libMesh::RBParameters::get_value(), libMesh::RBParametrized::is_discrete_parameter(), libMesh::Real, and libMesh::WRITE.

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

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::StaticCondensation::close(), libMesh::ParallelObject::comm(), libMesh::CondensedEigenSystem::initialize_condensed_matrices(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), libMesh::ParallelObject::processor_id(), libMesh::BoundaryInfo::regenerate_id_sets(), libMesh::StaticCondensationDofMap::reinit(), and libMesh::BoundaryInfo::synchronize_global_id_set().

◆ _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().

◆ _discrete_parameter_values

std::map<std::string, std::vector<Real> > libMesh::RBParametrized::_discrete_parameter_values

privateinherited

Map that defines the allowable values of any discrete parameters.

Definition at line 250 of file rb_parametrized.h.

Referenced by libMesh::RBParametrized::get_discrete_parameter_values(), libMesh::RBParametrized::initialize_parameters(), and libMesh::RBParametrized::is_discrete_parameter().

◆ _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 828 of file rb_eim_evaluation.h.

Referenced by get_eim_solutions_for_training_set(), 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 we want to write to disk and/or project to nodes for plotting purposes.

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 740 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 971 of file rb_eim_evaluation.h.

Referenced by get_eim_error_indicator().

◆ _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 843 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 854 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 862 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 964 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 886 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_interior_basis_function_as_vec_helper(), get_interior_basis_function_sizes(), get_interior_basis_functions_as_vecs(), 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 906 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 896 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(), libMesh::ReferenceCounter::ReferenceCounter(), 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 870 of file rb_eim_evaluation.h.

Referenced by get_parametrized_function(), 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 953 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<std::pair<Real,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 818 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 812 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 836 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 837 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 876 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 751 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 848 of file rb_eim_evaluation.h.

◆ eim_error_indicator_normalization

EimErrorIndicatorNormalization libMesh::RBEIMEvaluation::eim_error_indicator_normalization

Definition at line 717 of file rb_eim_evaluation.h.

Referenced by get_eim_error_indicator().

◆ limit_eim_error_indicator_to_one

bool libMesh::RBEIMEvaluation::limit_eim_error_indicator_to_one

If this boolean is true then we clamp EIM error indicator values to be at most 1.

This is often desirable since we typically think of the error indicator as a percentage, and a value of 1 means 100% error. We set this to true by default.

Definition at line 725 of file rb_eim_evaluation.h.

Referenced by get_eim_error_indicator().

◆ parameters

RBParameters libMesh::RBParametrized::parameters

privateinherited

Vector storing the current parameters.

Definition at line 239 of file rb_parametrized.h.

Referenced by libMesh::RBParametrized::clear(), libMesh::RBParametrized::get_parameters(), and libMesh::RBParametrized::set_parameters().

◆ parameters_initialized

bool libMesh::RBParametrized::parameters_initialized

privateinherited

Flag indicating whether the parameters have been initialized.

Definition at line 234 of file rb_parametrized.h.

◆ parameters_max

RBParameters libMesh::RBParametrized::parameters_max

privateinherited

Definition at line 245 of file rb_parametrized.h.

Referenced by libMesh::RBParametrized::clear(), libMesh::RBParametrized::get_n_params(), libMesh::RBParametrized::get_parameter_max(), libMesh::RBParametrized::get_parameters_max(), and libMesh::RBParametrized::initialize_parameters().

◆ parameters_min

RBParameters libMesh::RBParametrized::parameters_min

privateinherited

Vectors that define the ranges (min and max) for the parameters.

Definition at line 244 of file rb_parametrized.h.

Referenced by libMesh::RBParametrized::clear(), libMesh::RBParametrized::get_n_params(), libMesh::RBParametrized::get_parameter_min(), libMesh::RBParametrized::get_parameters_min(), and libMesh::RBParametrized::initialize_parameters().

◆ verbose_mode

bool libMesh::RBParametrized::verbose_mode

inherited

Public boolean to toggle verbose mode.

Definition at line 181 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

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Counts

◆ NodeDataMap

◆ QpDataMap

◆ SideQpDataMap

Member Enumeration Documentation

◆ EimErrorIndicatorNormalization

Constructor & Destructor Documentation

◆ RBEIMEvaluation() [1/3]

◆ RBEIMEvaluation() [2/3]

◆ RBEIMEvaluation() [3/3]

◆ ~RBEIMEvaluation()

Member Function Documentation

◆ add_basis_function()

◆ add_elem_center_dxyzdeta()

◆ add_elem_center_dxyzdxi()

◆ add_elem_id_local_index_map_entry()

◆ add_interpolation_data()

◆ add_interpolation_points_boundary_id()

◆ add_interpolation_points_comp()

◆ 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_qrule_order()

◆ add_interpolation_points_side_index()

◆ add_interpolation_points_spatial_indices()

◆ add_interpolation_points_subdomain_id()

◆ add_interpolation_points_xyz()

◆ add_interpolation_points_xyz_perturbations()

◆ add_node_basis_function()

◆ add_node_interpolation_data()

◆ add_rb_property_map_entry()

◆ add_side_basis_function()

◆ add_side_interpolation_data()

◆ build_eim_theta()

◆ check_if_valid_params()

◆ clear()

◆ comm()

◆ decrement_vector()

◆ disable_print_counter_info()

◆ distribute_bfs()

◆ enable_print_counter_info()

◆ gather_bfs()

◆ get_basis_function()

◆ get_closest_value()

◆ get_discrete_parameter_values()

◆ get_eim_basis_function_node_local_value()

◆ get_eim_basis_function_node_value()

◆ get_eim_basis_function_side_value()

◆ get_eim_basis_function_side_values_at_qps()

◆ get_eim_basis_function_value()

◆ get_eim_basis_function_values_at_qps()

◆ get_eim_error_indicator()

◆ get_eim_solutions_for_training_set() [1/2]

◆ get_eim_solutions_for_training_set() [2/2]

◆ get_eim_theta_objects()

◆ get_eim_vars_to_project_and_write()

◆ get_elem_center_dxyzdeta()

◆ get_elem_center_dxyzdxi()

◆ get_elem_id_to_local_index_map()

◆ get_error_indicator_interpolation_row()

◆ get_info()

◆ get_interior_basis_function_as_vec_helper()

◆ get_interior_basis_function_sizes()