libMesh::RBParametrizedFunction Class Reference

A simple functor class that provides a RBParameter-dependent function. More...

#include <rb_parametrized_function.h>

Inheritance diagram for libMesh::RBParametrizedFunction:

Public Member Functions
	RBParametrizedFunction ()
	Constructor.
	RBParametrizedFunction (RBParametrizedFunction &&)=default
	Special functions.
	RBParametrizedFunction (const RBParametrizedFunction &)=default
RBParametrizedFunction &	operator= (const RBParametrizedFunction &)=default
RBParametrizedFunction &	operator= (RBParametrizedFunction &&)=default
virtual	~RBParametrizedFunction ()
virtual unsigned int	get_n_components () const =0
	Specify the number of components in this parametrized function.
virtual Number	evaluate_comp (const RBParameters &mu, unsigned int comp, const Point &xyz, dof_id_type elem_id, unsigned int qp, subdomain_id_type subdomain_id, const std::vector< Point > &xyz_perturb, const std::vector< Real > &phi_i_qp)
	Evaluate the parametrized function at the specified point for parameter mu.
virtual Number	side_evaluate_comp (const RBParameters &mu, unsigned int comp, const Point &xyz, dof_id_type elem_id, unsigned int side_index, unsigned int qp, subdomain_id_type subdomain_id, boundary_id_type boundary_id, const std::vector< Point > &xyz_perturb, const std::vector< Real > &phi_i_qp)
	Same as evaluate_comp() but for element sides.
virtual Number	node_evaluate_comp (const RBParameters &mu, unsigned int comp, const Point &xyz, dof_id_type node_id, boundary_id_type boundary_id)
	Same as evaluate_comp() but for element nodes.
virtual std::vector< Number >	evaluate (const RBParameters &mu, const Point &xyz, dof_id_type elem_id, unsigned int qp, subdomain_id_type subdomain_id, const std::vector< Point > &xyz_perturb, const std::vector< Real > &phi_i_qp)
	Evaluate the parametrized function at the specified point for parameter mu.
virtual std::vector< Number >	side_evaluate (const RBParameters &mu, const Point &xyz, dof_id_type elem_id, unsigned int side_index, unsigned int qp, subdomain_id_type subdomain_id, boundary_id_type boundary_id, const std::vector< Point > &xyz_perturb, const std::vector< Real > &phi_i_qp)
	Same as evaluate() but for element sides.
virtual std::vector< Number >	node_evaluate (const RBParameters &mu, const Point &xyz, dof_id_type node_id, boundary_id_type boundary_id)
	Same as evaluate() but for element nodes.
virtual void	vectorized_evaluate (const std::vector< RBParameters > &mus, const VectorizedEvalInput &v, std::vector< std::vector< std::vector< Number > > > &output)
	Vectorized version of evaluate.
virtual void	side_vectorized_evaluate (const std::vector< RBParameters > &mus, const VectorizedEvalInput &v, std::vector< std::vector< std::vector< Number > > > &output)
	Same as vectorized_evaluate() but on element sides.
virtual void	node_vectorized_evaluate (const std::vector< RBParameters > &mus, const VectorizedEvalInput &v, std::vector< std::vector< std::vector< Number > > > &output)
	Same as vectorized_evaluate() but on element nodes.
virtual void	preevaluate_parametrized_function_on_mesh (const RBParameters &mu, const std::unordered_map< dof_id_type, std::vector< Point > > &all_xyz, const std::unordered_map< dof_id_type, subdomain_id_type > &sbd_ids, const std::unordered_map< dof_id_type, std::vector< std::vector< Point > > > &all_xyz_perturb, const System &sys)
	Store the result of vectorized_evaluate.
virtual void	preevaluate_parametrized_function_on_mesh_sides (const RBParameters &mu, const std::map< std::pair< dof_id_type, unsigned int >, std::vector< Point > > &side_all_xyz, const std::map< std::pair< dof_id_type, unsigned int >, subdomain_id_type > &sbd_ids, const std::map< std::pair< dof_id_type, unsigned int >, boundary_id_type > &side_boundary_ids, const std::map< std::pair< dof_id_type, unsigned int >, unsigned int > &side_types, const std::map< std::pair< dof_id_type, unsigned int >, std::vector< std::vector< Point > > > &side_all_xyz_perturb, const System &sys)
	Same as preevaluate_parametrized_function_on_mesh() except for mesh sides.
virtual void	preevaluate_parametrized_function_on_mesh_nodes (const RBParameters &mu, const std::unordered_map< dof_id_type, Point > &all_xyz, const std::unordered_map< dof_id_type, boundary_id_type > &node_boundary_ids, const System &sys)
	Same as preevaluate_parametrized_function_on_mesh() except for mesh nodes.
virtual Number	lookup_preevaluated_value_on_mesh (unsigned int comp, dof_id_type elem_id, unsigned int qp) const
	Look up the preevaluate values of the parametrized function for component comp, element elem_id, and quadrature point qp.
virtual Number	lookup_preevaluated_side_value_on_mesh (unsigned int comp, dof_id_type elem_id, unsigned int side_index, unsigned int qp) const
	Look up the preevaluated values of the parametrized function for component comp, element elem_id, side_index, and quadrature point qp.
virtual Number	lookup_preevaluated_node_value_on_mesh (unsigned int comp, dof_id_type node_id) const
	Look up the preevaluate values of the parametrized function for component comp, node node_id.
virtual void	initialize_lookup_table ()
	If this parametrized function is defined based on a lookup table then we can call this function to initialize the table.
Number	get_parameter_independent_data (const std::string &property_name, subdomain_id_type sbd_id) const
	Get the value stored in _parameter_independent_data associated with region_name and property_name.
const std::set< boundary_id_type > &	get_parametrized_function_boundary_ids () const
	For RBParametrizedFunctions defined on element sides or nodes, we get/set the boundary IDs that this parametrized function is defined on.
void	set_parametrized_function_boundary_ids (const std::set< boundary_id_type > &boundary_ids, bool is_nodal_boundary)
bool	on_mesh_sides () const
bool	on_mesh_nodes () const
virtual void	get_spatial_indices (std::vector< std::vector< unsigned int > > &spatial_indices, const VectorizedEvalInput &v)
	In some cases a parametrized function is defined based on array data that we index into based on the spatial data from the mesh (e.g.
virtual void	initialize_spatial_indices (const std::vector< std::vector< unsigned int > > &spatial_indices, const VectorizedEvalInput &v)
	The Online stage counterpart of get_spatial_indices().
virtual void	preevaluate_parametrized_function_cleanup ()
	Virtual function that performs cleanup after each "preevaluate parametrized function" evaluation.
const std::unordered_map< std::string, std::set< dof_id_type > > &	get_rb_property_map () const
	Function that returns a reference to the rb_property_map stored in the RBParametrizedFunction.
void	add_rb_property_map_entry (std::string &property_name, std::set< dof_id_type > &entity_ids)
	Function that adds a property to the RBParametrizedFunction rb_property_map.
virtual void	add_interpolation_data_to_rb_property_map (const Parallel::Communicator &comm, std::unordered_map< std::string, std::set< dof_id_type > > &rb_property_map, dof_id_type elem_id)
	Virtual function that can be overridden in RBParametrizedFunction subclasses to store properties in the rb_property_map.

Public Attributes
std::vector< std::vector< std::vector< Number > > >	preevaluated_values
	Storage for pre-evaluated values.
std::unordered_map< dof_id_type, std::vector< unsigned int > >	mesh_to_preevaluated_values_map
	Indexing into preevaluated_values for the case where the preevaluated values were obtained from evaluations at elements/quadrature points on a mesh.
std::map< std::pair< dof_id_type, unsigned int >, std::vector< unsigned int > >	mesh_to_preevaluated_side_values_map
	Similar to the above except this map stores the data on element sides.
std::unordered_map< dof_id_type, unsigned int >	mesh_to_preevaluated_node_values_map
	Indexing into preevaluated_values for the case where the preevaluated values were obtained from evaluations at elements/quadrature points on a mesh.
bool	requires_xyz_perturbations
	Boolean to indicate whether this parametrized function requires xyz perturbations in order to evaluate function values.
bool	requires_all_elem_qp_data
	Boolean to indicate whether this parametrized function requires data from all qps on the current element at each qp location.
bool	requires_all_elem_center_data
	Boolean to indicate whether this parametrized function requires data from the center on the current element.
bool	is_lookup_table
	Boolean to indicate if this parametrized function is defined based on a lookup table or not.
std::string	lookup_table_param_name
	If this is a lookup table, then lookup_table_param_name specifies the parameter that is used to index into the lookup table.
Real	fd_delta
	The finite difference step size in the case that this function in the case that this function uses finite differencing.

Protected Attributes
std::map< std::string, std::map< subdomain_id_type, Number > >	_parameter_independent_data
	In some cases we need to store parameter-independent data which is related to this function but since it is parameter-indepedent should not be returned as part of evaluate().
std::set< boundary_id_type >	_parametrized_function_boundary_ids
	In the case of an RBParametrizedFunction defined on element sides, this defines the set of boundary IDs that the function is defined on.
bool	_is_nodal_boundary
	In the case that _parametrized_function_boundary_ids is not empty, then this parametrized function is defined on a mesh boundary.
std::unordered_map< std::string, std::set< dof_id_type > >	_rb_property_map
	Generic property map used to store data during mesh pre-evaluation.

Detailed Description

A simple functor class that provides a RBParameter-dependent function.

Author

David Knezevic

Date

2012

Provides a reduced basis parameterized function.

Definition at line 114 of file rb_parametrized_function.h.

Constructor & Destructor Documentation

RBParametrizedFunction() [1/3]

libMesh::RBParametrizedFunction::RBParametrizedFunction

(

)

Constructor.

Definition at line 59 of file rb_parametrized_function.C.

:
requires_xyz_perturbations(false),
requires_all_elem_qp_data(false),
requires_all_elem_center_data(false),
is_lookup_table(false),
fd_delta(1.e-6),
_is_nodal_boundary(false)
{}

RBParametrizedFunction() [2/3]

libMesh::RBParametrizedFunction::RBParametrizedFunction ( RBParametrizedFunction &&  )

default

Special functions.

• This class can be default copy/move assigned/constructed.
• The destructor is defaulted out-of-line.

RBParametrizedFunction() [3/3]

libMesh::RBParametrizedFunction::RBParametrizedFunction ( const RBParametrizedFunction &  )

default

~RBParametrizedFunction()

libMesh::RBParametrizedFunction::~RBParametrizedFunction ( )

virtualdefault

Member Function Documentation

add_interpolation_data_to_rb_property_map()

void libMesh::RBParametrizedFunction::add_interpolation_data_to_rb_property_map ( const Parallel::Communicator &  comm, std::unordered_map< std::string, std::set< dof_id_type > > &  rb_property_map, dof_id_type  elem_id  )

virtual

Virtual function that can be overridden in RBParametrizedFunction subclasses to store properties in the rb_property_map.

Definition at line 844 of file rb_parametrized_function.C.

{
  // No-op by default
}

Referenced by libMesh::RBEIMEvaluation::add_interpolation_data().

add_rb_property_map_entry()

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

Function that adds a property to the RBParametrizedFunction rb_property_map.

The function checks that there is no duplicated properties before adding the property to the map.

Definition at line 838 of file rb_parametrized_function.C.

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

References _rb_property_map.

evaluate()

std::vector< Number > libMesh::RBParametrizedFunction::evaluate ( const RBParameters &  mu, const Point &  xyz, dof_id_type  elem_id, unsigned int  qp, subdomain_id_type  subdomain_id, const std::vector< Point > &  xyz_perturb, const std::vector< Real > &  phi_i_qp  )

virtual

Evaluate the parametrized function at the specified point for parameter mu.

If requires_xyz_perturbations==false, then xyz_perturb will not be used.

In this case we evaluate for all components.

Definition at line 122 of file rb_parametrized_function.C.

{
  // This method should be overridden in subclasses, so we just give a not implemented error message here
  libmesh_not_implemented();
 
  return std::vector<Number>();
}

Referenced by evaluate_comp(), and vectorized_evaluate().

evaluate_comp()

Number libMesh::RBParametrizedFunction::evaluate_comp ( const RBParameters &  mu, unsigned int  comp, const Point &  xyz, dof_id_type  elem_id, unsigned int  qp, subdomain_id_type  subdomain_id, const std::vector< Point > &  xyz_perturb, const std::vector< Real > &  phi_i_qp  )

virtual

Evaluate the parametrized function at the specified point for parameter mu.

If requires_xyz_perturbations==false, then xyz_perturb will not be used.

In this case we return the value for component comp only, but the base class implementation simply calls the vector-returning evaluate() function below and returns the comp'th component, so derived classes should provide a more efficient routine or just call the vector-returning function instead.

Definition at line 72 of file rb_parametrized_function.C.

{
  std::vector<Number> values = evaluate(mu, xyz, elem_id, qp, subdomain_id, xyz_perturb, phi_i_qp);
 
  libmesh_error_msg_if(comp >= values.size(), "Error: Invalid value of comp");
 
  return values[comp];
}

References evaluate().

get_n_components()

virtual unsigned int libMesh::RBParametrizedFunction::get_n_components ( ) const

pure virtual

Specify the number of components in this parametrized function.

A scalar-valued function has one component, a vector-valued function has more than one component.

Implemented in ShiftedGaussian, and Gxyz.

Referenced by libMesh::RBEIMConstruction::initialize_parametrized_functions_in_training_set(), node_vectorized_evaluate(), side_vectorized_evaluate(), and vectorized_evaluate().

get_parameter_independent_data()

Number libMesh::RBParametrizedFunction::get_parameter_independent_data	(	const std::string &	property_name,
		subdomain_id_type	sbd_id
	)		const

Get the value stored in _parameter_independent_data associated with region_name and property_name.

Definition at line 810 of file rb_parametrized_function.C.

{
  return libmesh_map_find(libmesh_map_find(_parameter_independent_data, property_name), sbd_id);
}

References _parameter_independent_data.

get_parametrized_function_boundary_ids()

const std::set< boundary_id_type > & libMesh::RBParametrizedFunction::get_parametrized_function_boundary_ids

(

)

const

For RBParametrizedFunctions defined on element sides or nodes, we get/set the boundary IDs that this parametrized function is defined on.

Definition at line 852 of file rb_parametrized_function.C.

{
  return _parametrized_function_boundary_ids;
}

References _parametrized_function_boundary_ids.

Referenced by libMesh::RBEIMConstruction::initialize_qp_data(), libMesh::RBEIMEvaluation::node_distribute_bfs(), on_mesh_nodes(), on_mesh_sides(), and libMesh::RBEIMEvaluation::side_distribute_bfs().

get_rb_property_map()

const std::unordered_map< std::string, std::set< dof_id_type > > & libMesh::RBParametrizedFunction::get_rb_property_map

(

)

const

Function that returns a reference to the rb_property_map stored in the RBParametrizedFunction.

Definition at line 833 of file rb_parametrized_function.C.

{
  return _rb_property_map;
}

References _rb_property_map.

Referenced by libMesh::RBEIMEvaluation::initialize_rb_property_map().

get_spatial_indices()

void libMesh::RBParametrizedFunction::get_spatial_indices ( std::vector< std::vector< unsigned int > > &  spatial_indices, const VectorizedEvalInput &  v  )

virtual

In some cases a parametrized function is defined based on array data that we index into based on the spatial data from the mesh (e.g.

element, node, or side indices). We refer to the indices that we use to index into this array data as "spatial indices". This method sets spatial_indices based on the provided mesh-based indices.

Note that spatial_indices is defined as a doubly-nested vector so that we can handle the case where the spatial function evaluation requires us to have indices from all nodes of an element, since in that case we need a vector of indices (one per node) for each point. Other cases, such as when we define the parametrized function based on the element index only, only require a singly-nested vector which we handle as a special case of the doubly-nested vector.

This method is typically used in the Offline stage in order to generate and store the relevant spatial indices.

This method is a no-op by default, but it can be overridden in subclasses to provide the relevant behavior.

Definition at line 816 of file rb_parametrized_function.C.

{
  // No-op by default
}

Referenced by libMesh::RBEIMEvaluation::initialize_interpolation_points_spatial_indices().

initialize_lookup_table()

void libMesh::RBParametrizedFunction::initialize_lookup_table ( )

virtual

If this parametrized function is defined based on a lookup table then we can call this function to initialize the table.

This is a no-op by default, but it can be overridden in subclasses as needed.

Definition at line 805 of file rb_parametrized_function.C.

{
  // No-op by default, override in subclasses as needed
}

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

initialize_spatial_indices()

void libMesh::RBParametrizedFunction::initialize_spatial_indices ( const std::vector< std::vector< unsigned int > > &  spatial_indices, const VectorizedEvalInput &  v  )

virtual

The Online stage counterpart of get_spatial_indices().

This method is used to initialize the spatial index data in this object so that we can evaluate it during an Online solve.

Definition at line 822 of file rb_parametrized_function.C.

{
  // No-op by default
}

Referenced by libMesh::RBEIMEvaluation::initialize_param_fn_spatial_indices().

lookup_preevaluated_node_value_on_mesh()

Number libMesh::RBParametrizedFunction::lookup_preevaluated_node_value_on_mesh ( unsigned int  comp, dof_id_type  node_id  ) const

virtual

Look up the preevaluate values of the parametrized function for component comp, node node_id.

Definition at line 793 of file rb_parametrized_function.C.

{
  unsigned int index =
    libmesh_map_find(mesh_to_preevaluated_node_values_map, node_id);
 
  libmesh_error_msg_if(preevaluated_values.size() != 1, "Error: we expect only one parameter index");
  libmesh_error_msg_if(index >= preevaluated_values[0].size(), "Error: invalid index");
 
  return preevaluated_values[0][index][comp];
}

References mesh_to_preevaluated_node_values_map, and preevaluated_values.

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

lookup_preevaluated_side_value_on_mesh()

Number libMesh::RBParametrizedFunction::lookup_preevaluated_side_value_on_mesh ( unsigned int  comp, dof_id_type  elem_id, unsigned int  side_index, unsigned int  qp  ) const

virtual

Look up the preevaluated values of the parametrized function for component comp, element elem_id, side_index, and quadrature point qp.

Definition at line 776 of file rb_parametrized_function.C.

{
  const std::vector<unsigned int> & indices_at_qps =
    libmesh_map_find(mesh_to_preevaluated_side_values_map, std::make_pair(elem_id,side_index));
 
  libmesh_error_msg_if(qp >= indices_at_qps.size(), "Error: invalid qp");
 
  unsigned int index = indices_at_qps[qp];
  libmesh_error_msg_if(preevaluated_values.size() != 1, "Error: we expect only one parameter index");
  libmesh_error_msg_if(index >= preevaluated_values[0].size(), "Error: invalid index");
 
  return preevaluated_values[0][index][comp];
}

References mesh_to_preevaluated_side_values_map, and preevaluated_values.

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

lookup_preevaluated_value_on_mesh()

Number libMesh::RBParametrizedFunction::lookup_preevaluated_value_on_mesh ( unsigned int  comp, dof_id_type  elem_id, unsigned int  qp  ) const

virtual

Look up the preevaluate values of the parametrized function for component comp, element elem_id, and quadrature point qp.

Definition at line 760 of file rb_parametrized_function.C.

{
  const std::vector<unsigned int> & indices_at_qps =
    libmesh_map_find(mesh_to_preevaluated_values_map, elem_id);
 
  libmesh_error_msg_if(qp >= indices_at_qps.size(), "Error: invalid qp");
 
  unsigned int index = indices_at_qps[qp];
  libmesh_error_msg_if(preevaluated_values.size() != 1, "Error: we expect only one parameter index");
  libmesh_error_msg_if(index >= preevaluated_values[0].size(), "Error: invalid index");
 
  return preevaluated_values[0][index][comp];
}

References mesh_to_preevaluated_values_map, and preevaluated_values.

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

node_evaluate()

std::vector< Number > libMesh::RBParametrizedFunction::node_evaluate ( const RBParameters &  mu, const Point &  xyz, dof_id_type  node_id, boundary_id_type  boundary_id  )

virtual

Same as evaluate() but for element nodes.

Definition at line 154 of file rb_parametrized_function.C.

{
  // This method should be overridden in subclasses, so we just give a not implemented error message here
  libmesh_not_implemented();
 
  return std::vector<Number>();
}

Referenced by node_evaluate_comp(), and node_vectorized_evaluate().

node_evaluate_comp()

Number libMesh::RBParametrizedFunction::node_evaluate_comp ( const RBParameters &  mu, unsigned int  comp, const Point &  xyz, dof_id_type  node_id, boundary_id_type  boundary_id  )

virtual

Same as evaluate_comp() but for element nodes.

Definition at line 108 of file rb_parametrized_function.C.

{
  std::vector<Number> values = node_evaluate(mu, xyz, node_id, boundary_id);
 
  libmesh_error_msg_if(comp >= values.size(), "Error: Invalid value of comp");
 
  return values[comp];
}

References node_evaluate().

node_vectorized_evaluate()

void libMesh::RBParametrizedFunction::node_vectorized_evaluate ( const std::vector< RBParameters > &  mus, const VectorizedEvalInput &  v, std::vector< std::vector< std::vector< Number > > > &  output  )

virtual

Same as vectorized_evaluate() but on element nodes.

The base class implementation of this function loops over the input "mus" vector and calls node_evaluate() for each entry. The node_evaluate() function may be overridden in derived classes.

Definition at line 335 of file rb_parametrized_function.C.

{
  LOG_SCOPE("node_vectorized_evaluate()", "RBParametrizedFunction");
 
  output.clear();
  unsigned int n_points = v.all_xyz.size();
 
  // The number of components returned by this RBParametrizedFunction
  auto n_components = this->get_n_components();
 
  // We first loop over all mus and all n_points, calling node_evaluate()
  // for each and storing the results.  It is easier to first
  // pre-compute all the values before filling output, since, in the
  // case of multi-sample RBParameters, the ordering of the loops is a
  // bit complicated otherwise.
  std::vector<std::vector<std::vector<Number>>> all_evals(mus.size());
  for (auto mu_index : index_range(mus))
    {
      // Allocate enough space to store all points for the current mu
      all_evals[mu_index].resize(n_points);
      for (auto point_index : index_range(all_evals[mu_index]))
        {
          // Evaluate all samples for the current mu at the current interpolation point
          all_evals[mu_index][point_index] =
            this->node_evaluate(mus[mu_index],
                                v.all_xyz[point_index],
                                v.node_ids[point_index],
                                v.boundary_ids[point_index]);
 
          // The vector returned by node_evaluate() should contain:
          // n_components * mus[mu_index].n_samples()
          // entries. That is, for multi-sample RBParameters objects,
          // the vector will be packed with entries as follows:
          // [sample0_component0, sample0_component1, ..., sample0_componentN,
          //  sample1_component0, sample1_component1, ..., sample1_componentN,
          //  ...
          //  sampleM_component0, sampleM_component1, ..., sampleM_componentN]
          auto n_samples = mus[mu_index].n_samples();
          auto received_data = all_evals[mu_index][point_index].size();
          libmesh_error_msg_if(received_data != n_components * n_samples,
                               "Recieved " << received_data <<
                               " evaluated values but expected to receive " << n_components * n_samples);
        }
    }
 
  // TODO: move this code for computing the total number of samples
  // represented by a std::vector of RBParameters objects to a helper
  // function.
  unsigned int output_size = 0;
  for (const auto & mu : mus)
    output_size += mu.n_samples();
 
  output.resize(output_size);
 
  // We use traditional for-loops here (rather than range-based) so that we can declare and
  // increment multiple loop counters all within the local scope of the for-loop.
  for (auto [mu_index, output_index] = std::make_tuple(0u, 0u); mu_index < mus.size(); ++mu_index)
    {
      auto n_samples = mus[mu_index].n_samples();
      for (auto mu_sample_idx = 0u; mu_sample_idx < n_samples; ++mu_sample_idx, ++output_index)
        {
          output[output_index].resize(n_points);
          for (auto point_index : make_range(n_points))
            {
              output[output_index][point_index].resize(n_components);
 
              for (auto comp : make_range(n_components))
                output[output_index][point_index][comp] = all_evals[mu_index][point_index][n_components*mu_sample_idx + comp];
            }
        }
    }
}

References libMesh::VectorizedEvalInput::all_xyz, libMesh::VectorizedEvalInput::boundary_ids, get_n_components(), libMesh::index_range(), libMesh::make_range(), node_evaluate(), and libMesh::VectorizedEvalInput::node_ids.

Referenced by preevaluate_parametrized_function_on_mesh_nodes(), and libMesh::RBEIMEvaluation::rb_eim_solves().

on_mesh_nodes()

bool libMesh::RBParametrizedFunction::on_mesh_nodes

(

)

const

Returns

true if this parametrized function is defined on mesh nodes.

Definition at line 868 of file rb_parametrized_function.C.

{
  return !get_parametrized_function_boundary_ids().empty() && _is_nodal_boundary;
}

References _is_nodal_boundary, and get_parametrized_function_boundary_ids().

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder(), libMesh::RBEIMConstruction::apply_normalization_to_solution_snapshots(), libMesh::RBEIMConstruction::enrich_eim_approximation(), libMesh::RBEIMConstruction::get_random_point_from_training_sample(), libMesh::RBEIMConstruction::initialize_parametrized_functions_in_training_set(), libMesh::RBEIMConstruction::initialize_qp_data(), libMesh::RBDataDeserialization::load_rb_eim_evaluation_data(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), libMesh::RBEIMConstruction::train_eim_approximation_with_POD(), and libMesh::RBEIMConstruction::update_eim_matrices().

on_mesh_sides()

bool libMesh::RBParametrizedFunction::on_mesh_sides

(

)

const

Returns

true if this parametrized function is defined on mesh sides.

Definition at line 863 of file rb_parametrized_function.C.

{
  return !get_parametrized_function_boundary_ids().empty() && !_is_nodal_boundary;
}

References _is_nodal_boundary, and get_parametrized_function_boundary_ids().

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder(), libMesh::RBEIMConstruction::apply_normalization_to_solution_snapshots(), libMesh::RBEIMConstruction::compute_max_eim_error(), libMesh::RBEIMConstruction::enrich_eim_approximation(), libMesh::RBEIMConstruction::get_random_point_from_training_sample(), libMesh::RBEIMConstruction::initialize_parametrized_functions_in_training_set(), libMesh::RBDataDeserialization::load_rb_eim_evaluation_data(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), libMesh::RBEIMConstruction::train_eim_approximation_with_POD(), and libMesh::RBEIMConstruction::update_eim_matrices().

operator=() [1/2]

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

default

operator=() [2/2]

RBParametrizedFunction & libMesh::RBParametrizedFunction::operator= ( RBParametrizedFunction &&  )

default

preevaluate_parametrized_function_cleanup()

void libMesh::RBParametrizedFunction::preevaluate_parametrized_function_cleanup ( )

virtual

Virtual function that performs cleanup after each "preevaluate parametrized function" evaluation.

This function is a no-op by default, but it can be overridden in subclasses in order to do necessary cleanup, such as clearing cached data.

Definition at line 828 of file rb_parametrized_function.C.

{
  // No-op by default
}

Referenced by preevaluate_parametrized_function_on_mesh(), preevaluate_parametrized_function_on_mesh_nodes(), and preevaluate_parametrized_function_on_mesh_sides().

preevaluate_parametrized_function_on_mesh()

void libMesh::RBParametrizedFunction::preevaluate_parametrized_function_on_mesh ( const RBParameters &  mu, const std::unordered_map< dof_id_type, std::vector< Point > > &  all_xyz, const std::unordered_map< dof_id_type, subdomain_id_type > &  sbd_ids, const std::unordered_map< dof_id_type, std::vector< std::vector< Point > > > &  all_xyz_perturb, const System &  sys  )

virtual

Store the result of vectorized_evaluate.

This is helpful during EIM training, since we can pre-evaluate and store the parameterized function for each training sample. If requires_xyz_perturbations==false, then all_xyz_perturb will not be used.

Definition at line 410 of file rb_parametrized_function.C.

{
  mesh_to_preevaluated_values_map.clear();
 
  unsigned int n_elems = all_xyz.size();
  unsigned int n_points = 0;
  for (const auto & xyz_pair : all_xyz)
  {
    const std::vector<Point> & xyz_vec = xyz_pair.second;
    n_points += xyz_vec.size();
  }
 
  VectorizedEvalInput v;
  v.all_xyz.resize(n_points);
  v.elem_ids.resize(n_points);
  v.qps.resize(n_points);
  v.sbd_ids.resize(n_points);
  v.all_xyz_perturb.resize(n_points);
  v.phi_i_qp.resize(n_points);
  v.elem_types.resize(n_points);
 
  if (requires_all_elem_qp_data)
    {
      v.elem_id_to_local_index.clear();
      v.JxW_all_qp.resize(n_elems);
      v.phi_i_all_qp.resize(n_elems);
    }
  if (requires_all_elem_center_data)
    {
      v.dxyzdxi_elem_center.resize(n_elems);
      v.dxyzdeta_elem_center.resize(n_elems);
      // At the time of writing, the quadrature order is only used in conjunction with element
      // center data so we should not compute it elsewhere for now.
      v.qrule_orders.resize(n_elems);
    }
 
  // Empty vector to be used when xyz perturbations are not required
  std::vector<Point> empty_perturbs;
 
  // In order to compute phi_i_qp, we initialize a FEMContext
  FEMContext con(sys);
  for (auto dim : con.elem_dimensions())
    {
      auto fe = con.get_element_fe(/*var=*/0, dim);
      fe->get_JxW();
      fe->get_phi();
      fe->get_dxyzdxi();
      fe->get_dxyzdeta();
    }
 
  unsigned int counter = 0;
  unsigned int elem_counter = 0;
  for (const auto & [elem_id, xyz_vec] : all_xyz)
    {
      subdomain_id_type subdomain_id = libmesh_map_find(sbd_ids, elem_id);
 
      // The amount of data to be stored for each component
      auto n_qp = xyz_vec.size();
      mesh_to_preevaluated_values_map[elem_id].resize(n_qp);
 
      // Also initialize phi in order to compute phi_i_qp
      const Elem & elem_ref = sys.get_mesh().elem_ref(elem_id);
      con.pre_fe_reinit(sys, &elem_ref);
 
      auto elem_fe = con.get_element_fe(/*var=*/0, elem_ref.dim());
      const std::vector<std::vector<Real>> & phi = elem_fe->get_phi();
      const std::vector<Real> & JxW = elem_fe->get_JxW();
      const auto & dxyzdxi = elem_fe->get_dxyzdxi();
      const auto & dxyzdeta = elem_fe->get_dxyzdeta();
 
      elem_fe->reinit(&elem_ref);
 
      for (auto qp : index_range(xyz_vec))
        {
          mesh_to_preevaluated_values_map[elem_id][qp] = counter;
 
          v.all_xyz[counter] = xyz_vec[qp];
          v.elem_ids[counter] = elem_id;
          v.qps[counter] = qp;
          v.sbd_ids[counter] = subdomain_id;
          v.elem_types[counter] = elem_ref.type();
 
          v.phi_i_qp[counter].resize(phi.size());
          for(auto i : index_range(phi))
            v.phi_i_qp[counter][i] = phi[i][qp];
 
          if (requires_xyz_perturbations)
            {
              const auto & qps_and_perturbs =
                libmesh_map_find(all_xyz_perturb, elem_id);
              libmesh_error_msg_if(qp >= qps_and_perturbs.size(), "Error: Invalid qp");
 
              v.all_xyz_perturb[counter] = qps_and_perturbs[qp];
            }
          else
            {
              v.all_xyz_perturb[counter] = empty_perturbs;
            }
 
          if (requires_all_elem_qp_data)
            {
              if (v.elem_id_to_local_index.count(elem_id) == 0)
                {
                  // In this case we store data for all qps on this element
                  // at each point.
                  v.JxW_all_qp[elem_counter].resize(JxW.size());
                  for(auto i : index_range(JxW))
                    v.JxW_all_qp[elem_counter][i] = JxW[i];
 
                  v.phi_i_all_qp[elem_counter].resize(phi.size());
                  for(auto i : index_range(phi))
                  {
                    v.phi_i_all_qp[elem_counter][i].resize(phi[i].size());
                    for(auto j : index_range(phi[i]))
                      v.phi_i_all_qp[elem_counter][i][j] = phi[i][j];
                  }
                  v.elem_id_to_local_index[elem_id] = elem_counter;
                }
            }
 
          counter++;
        }
 
      // Here we presume that if requires_all_elem_center_data is set to true
      // then requires_all_elem_qp_data is also set to true so that elem_id_to_local_index entry
      // for this elem has already been set.
      if (requires_all_elem_center_data)
        {
          // Get data derivatives at vertex average
          std::vector<Point> nodes = { elem_ref.reference_elem()->vertex_average() };
          elem_fe->reinit (&elem_ref, &nodes);
          // Set qrule_order here to prevent calling getter multiple times.
          Order qrule_order = con.get_element_qrule().get_order();
 
          // We add qrule_order in this loop as it is used in conjunction with elem center
          // quantities for now.
          v.qrule_orders[elem_counter] = qrule_order;
          Point dxyzdxi_pt, dxyzdeta_pt;
          if (con.get_elem_dim()>0)
            dxyzdxi_pt = dxyzdxi[0];
          if (con.get_elem_dim()>1)
            dxyzdeta_pt = dxyzdeta[0];
          // Here we do an implicit conversion from RealGradient which is a VectorValue<Real>
          // which in turn is a TypeVector<T> to a Point which is a TypeVector<Real>.
          // They are essentially the same thing. This helps us limiting the number of includes
          // in serialization and deserialization as RealGradient is a typedef and we cannot
          // forward declare typedefs. As a result we leverage the fact that point.h is already
          // included in most places we need RealGradient.
          v.dxyzdxi_elem_center[elem_counter] = dxyzdxi_pt;
          v.dxyzdeta_elem_center[elem_counter] = dxyzdeta_pt;
        }
      elem_counter++;
    }
 
  std::vector<RBParameters> mus {mu};
  vectorized_evaluate(mus, v, preevaluated_values);
 
  preevaluate_parametrized_function_cleanup();
}

References libMesh::VectorizedEvalInput::all_xyz, libMesh::VectorizedEvalInput::all_xyz_perturb, dim, libMesh::Elem::dim(), libMesh::VectorizedEvalInput::dxyzdeta_elem_center, libMesh::VectorizedEvalInput::dxyzdxi_elem_center, libMesh::FEMContext::elem_dimensions(), libMesh::VectorizedEvalInput::elem_id_to_local_index, libMesh::VectorizedEvalInput::elem_ids, libMesh::MeshBase::elem_ref(), libMesh::VectorizedEvalInput::elem_types, libMesh::FEMContext::get_elem_dim(), libMesh::FEMContext::get_element_fe(), libMesh::FEMContext::get_element_qrule(), libMesh::System::get_mesh(), libMesh::QBase::get_order(), libMesh::index_range(), libMesh::VectorizedEvalInput::JxW_all_qp, mesh_to_preevaluated_values_map, libMesh::VectorizedEvalInput::phi_i_all_qp, libMesh::VectorizedEvalInput::phi_i_qp, libMesh::FEMContext::pre_fe_reinit(), preevaluate_parametrized_function_cleanup(), preevaluated_values, libMesh::VectorizedEvalInput::qps, libMesh::VectorizedEvalInput::qrule_orders, libMesh::Elem::reference_elem(), requires_all_elem_center_data, requires_all_elem_qp_data, requires_xyz_perturbations, libMesh::VectorizedEvalInput::sbd_ids, libMesh::Elem::type(), vectorized_evaluate(), and libMesh::Elem::vertex_average().

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

preevaluate_parametrized_function_on_mesh_nodes()

void libMesh::RBParametrizedFunction::preevaluate_parametrized_function_on_mesh_nodes ( const RBParameters &  mu, const std::unordered_map< dof_id_type, Point > &  all_xyz, const std::unordered_map< dof_id_type, boundary_id_type > &  node_boundary_ids, const System &  sys  )

virtual

Same as preevaluate_parametrized_function_on_mesh() except for mesh nodes.

Definition at line 723 of file rb_parametrized_function.C.

{
  mesh_to_preevaluated_node_values_map.clear();
 
  unsigned int n_points = all_xyz.size();
 
  VectorizedEvalInput v;
  v.all_xyz.resize(n_points);
  v.node_ids.resize(n_points);
  v.boundary_ids.resize(n_points);
 
  // Empty vector to be used when xyz perturbations are not required
  std::vector<Point> empty_perturbs;
 
  unsigned int counter = 0;
  for (const auto & [node_id, p] : all_xyz)
    {
      boundary_id_type boundary_id = libmesh_map_find(node_boundary_ids, node_id);
 
      mesh_to_preevaluated_node_values_map[node_id] = counter;
 
      v.all_xyz[counter] = p;
      v.node_ids[counter] = node_id;
      v.boundary_ids[counter] = boundary_id;
 
      counter++;
    }
 
  std::vector<RBParameters> mus {mu};
  node_vectorized_evaluate(mus, v, preevaluated_values);
 
  preevaluate_parametrized_function_cleanup();
}

References libMesh::VectorizedEvalInput::all_xyz, libMesh::VectorizedEvalInput::boundary_ids, mesh_to_preevaluated_node_values_map, libMesh::VectorizedEvalInput::node_ids, node_vectorized_evaluate(), preevaluate_parametrized_function_cleanup(), and preevaluated_values.

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

preevaluate_parametrized_function_on_mesh_sides()

void libMesh::RBParametrizedFunction::preevaluate_parametrized_function_on_mesh_sides ( const RBParameters &  mu, const std::map< std::pair< dof_id_type, unsigned int >, std::vector< Point > > &  side_all_xyz, const std::map< std::pair< dof_id_type, unsigned int >, subdomain_id_type > &  sbd_ids, const std::map< std::pair< dof_id_type, unsigned int >, boundary_id_type > &  side_boundary_ids, const std::map< std::pair< dof_id_type, unsigned int >, unsigned int > &  side_types, const std::map< std::pair< dof_id_type, unsigned int >, std::vector< std::vector< Point > > > &  side_all_xyz_perturb, const System &  sys  )

virtual

Same as preevaluate_parametrized_function_on_mesh() except for mesh sides.

Definition at line 574 of file rb_parametrized_function.C.

{
  mesh_to_preevaluated_side_values_map.clear();
 
  unsigned int n_points = 0;
  for (const auto & xyz_pair : side_all_xyz)
  {
    const std::vector<Point> & xyz_vec = xyz_pair.second;
    n_points += xyz_vec.size();
  }
 
  VectorizedEvalInput v;
  v.all_xyz.resize(n_points);
  v.elem_ids.resize(n_points);
  v.side_indices.resize(n_points);
  v.qps.resize(n_points);
  v.sbd_ids.resize(n_points);
  v.boundary_ids.resize(n_points);
  v.all_xyz_perturb.resize(n_points);
  v.phi_i_qp.resize(n_points);
 
  // Empty vector to be used when xyz perturbations are not required
  std::vector<Point> empty_perturbs;
 
  // In order to compute phi_i_qp, we initialize a FEMContext
  FEMContext con(sys);
  for (auto dim : con.elem_dimensions())
    {
      auto fe = con.get_element_fe(/*var=*/0, dim);
      fe->get_phi();
 
      auto side_fe = con.get_side_fe(/*var=*/0, dim);
      side_fe->get_phi();
    }
 
  unsigned int counter = 0;
  for (const auto & xyz_pair : side_all_xyz)
    {
      auto elem_side_pair = xyz_pair.first;
      dof_id_type elem_id = elem_side_pair.first;
      unsigned int side_index = elem_side_pair.second;
 
      const std::vector<Point> & xyz_vec = xyz_pair.second;
 
      subdomain_id_type subdomain_id = libmesh_map_find(sbd_ids, elem_side_pair);
      boundary_id_type boundary_id = libmesh_map_find(side_boundary_ids, elem_side_pair);
      unsigned int side_type = libmesh_map_find(side_types, elem_side_pair);
 
      // The amount of data to be stored for each component
      auto n_qp = xyz_vec.size();
      mesh_to_preevaluated_side_values_map[elem_side_pair].resize(n_qp);
 
      const Elem & elem_ref = sys.get_mesh().elem_ref(elem_id);
      con.pre_fe_reinit(sys, &elem_ref);
 
      // side_type == 0 --> standard side
      // side_type == 1 --> shellface
      if (side_type == 0)
        {
          std::unique_ptr<const Elem> elem_side;
          elem_ref.build_side_ptr(elem_side, side_index);
 
          auto side_fe = con.get_side_fe(/*var=*/0, elem_ref.dim());
          side_fe->reinit(&elem_ref, side_index);
 
          const std::vector<std::vector<Real>> & phi = side_fe->get_phi();
          for (auto qp : index_range(xyz_vec))
            {
              mesh_to_preevaluated_side_values_map[elem_side_pair][qp] = counter;
 
              v.all_xyz[counter] = xyz_vec[qp];
              v.elem_ids[counter] = elem_side_pair.first;
              v.side_indices[counter] = elem_side_pair.second;
              v.qps[counter] = qp;
              v.sbd_ids[counter] = subdomain_id;
              v.boundary_ids[counter] = boundary_id;
 
              v.phi_i_qp[counter].resize(phi.size());
              for(auto i : index_range(phi))
                v.phi_i_qp[counter][i] = phi[i][qp];
 
              if (requires_xyz_perturbations)
                {
                  const auto & qps_and_perturbs =
                    libmesh_map_find(side_all_xyz_perturb, elem_side_pair);
                  libmesh_error_msg_if(qp >= qps_and_perturbs.size(), "Error: Invalid qp");
 
                  v.all_xyz_perturb[counter] = qps_and_perturbs[qp];
                }
              else
                {
                  v.all_xyz_perturb[counter] = empty_perturbs;
                }
              counter++;
            }
        }
      else if (side_type == 1)
        {
          auto elem_fe = con.get_element_fe(/*var=*/0, elem_ref.dim());
          const std::vector<std::vector<Real>> & phi = elem_fe->get_phi();
 
          elem_fe->reinit(&elem_ref);
 
          for (auto qp : index_range(xyz_vec))
            {
              mesh_to_preevaluated_side_values_map[elem_side_pair][qp] = counter;
 
              v.all_xyz[counter] = xyz_vec[qp];
              v.elem_ids[counter] = elem_side_pair.first;
              v.side_indices[counter] = elem_side_pair.second;
              v.qps[counter] = qp;
              v.sbd_ids[counter] = subdomain_id;
              v.boundary_ids[counter] = boundary_id;
 
              v.phi_i_qp[counter].resize(phi.size());
              for(auto i : index_range(phi))
                v.phi_i_qp[counter][i] = phi[i][qp];
 
              if (requires_xyz_perturbations)
                {
                  const auto & qps_and_perturbs =
                    libmesh_map_find(side_all_xyz_perturb, elem_side_pair);
                  libmesh_error_msg_if(qp >= qps_and_perturbs.size(), "Error: Invalid qp");
 
                  v.all_xyz_perturb[counter] = qps_and_perturbs[qp];
                }
              else
                {
                  v.all_xyz_perturb[counter] = empty_perturbs;
                }
              counter++;
            }
        }
      else
        libmesh_error_msg ("Unrecognized side_type: " << side_type);
    }
 
  std::vector<RBParameters> mus {mu};
  side_vectorized_evaluate(mus, v, preevaluated_values);
 
  preevaluate_parametrized_function_cleanup();
}

References libMesh::VectorizedEvalInput::all_xyz, libMesh::VectorizedEvalInput::all_xyz_perturb, libMesh::VectorizedEvalInput::boundary_ids, libMesh::Elem::build_side_ptr(), dim, libMesh::Elem::dim(), libMesh::FEMContext::elem_dimensions(), libMesh::VectorizedEvalInput::elem_ids, libMesh::MeshBase::elem_ref(), libMesh::FEMContext::get_element_fe(), libMesh::System::get_mesh(), libMesh::FEMContext::get_side_fe(), libMesh::index_range(), mesh_to_preevaluated_side_values_map, libMesh::VectorizedEvalInput::phi_i_qp, libMesh::FEMContext::pre_fe_reinit(), preevaluate_parametrized_function_cleanup(), preevaluated_values, libMesh::VectorizedEvalInput::qps, requires_xyz_perturbations, libMesh::VectorizedEvalInput::sbd_ids, libMesh::VectorizedEvalInput::side_indices, and side_vectorized_evaluate().

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

set_parametrized_function_boundary_ids()

void libMesh::RBParametrizedFunction::set_parametrized_function_boundary_ids	(	const std::set< boundary_id_type > &	boundary_ids,
		bool	is_nodal_boundary
	)

Definition at line 857 of file rb_parametrized_function.C.

{
  _parametrized_function_boundary_ids = boundary_ids;
  _is_nodal_boundary = is_nodal_boundary;
}

References _is_nodal_boundary, and _parametrized_function_boundary_ids.

side_evaluate()

std::vector< Number > libMesh::RBParametrizedFunction::side_evaluate ( const RBParameters &  mu, const Point &  xyz, dof_id_type  elem_id, unsigned int  side_index, unsigned int  qp, subdomain_id_type  subdomain_id, boundary_id_type  boundary_id, const std::vector< Point > &  xyz_perturb, const std::vector< Real > &  phi_i_qp  )

virtual

Same as evaluate() but for element sides.

Definition at line 137 of file rb_parametrized_function.C.

{
  // This method should be overridden in subclasses, so we just give a not implemented error message here
  libmesh_not_implemented();
 
  return std::vector<Number>();
}

Referenced by side_evaluate_comp(), and side_vectorized_evaluate().

side_evaluate_comp()

Number libMesh::RBParametrizedFunction::side_evaluate_comp ( const RBParameters &  mu, unsigned int  comp, const Point &  xyz, dof_id_type  elem_id, unsigned int  side_index, unsigned int  qp, subdomain_id_type  subdomain_id, boundary_id_type  boundary_id, const std::vector< Point > &  xyz_perturb, const std::vector< Real > &  phi_i_qp  )

virtual

Same as evaluate_comp() but for element sides.

Definition at line 89 of file rb_parametrized_function.C.

{
  std::vector<Number> values = side_evaluate(mu, xyz, elem_id, side_index, qp, subdomain_id, boundary_id, xyz_perturb, phi_i_qp);
 
  libmesh_error_msg_if(comp >= values.size(), "Error: Invalid value of comp");
 
  return values[comp];
}

References side_evaluate().

side_vectorized_evaluate()

void libMesh::RBParametrizedFunction::side_vectorized_evaluate ( const std::vector< RBParameters > &  mus, const VectorizedEvalInput &  v, std::vector< std::vector< std::vector< Number > > > &  output  )

virtual

Same as vectorized_evaluate() but on element sides.

The base class implementation of this function loops over the input "mus" vector and calls side_evaluate() for each entry. The side_evaluate() function may be overridden in derived classes.

Definition at line 249 of file rb_parametrized_function.C.

{
  LOG_SCOPE("side_vectorized_evaluate()", "RBParametrizedFunction");
 
  output.clear();
  unsigned int n_points = v.all_xyz.size();
 
  libmesh_error_msg_if(v.sbd_ids.size() != n_points, "Error: invalid vector sizes");
  libmesh_error_msg_if(requires_xyz_perturbations && (v.all_xyz_perturb.size() != n_points), "Error: invalid vector sizes");
 
  // Dummy vector to be used when xyz perturbations are not required
  std::vector<Point> empty_perturbs;
 
  // The number of components returned by this RBParametrizedFunction
  auto n_components = this->get_n_components();
 
  // We first loop over all mus and all n_points, calling side_evaluate()
  // for each and storing the results.  It is easier to first
  // pre-compute all the values before filling output, since, in the
  // case of multi-sample RBParameters, the ordering of the loops is a
  // bit complicated otherwise.
  std::vector<std::vector<std::vector<Number>>> all_evals(mus.size());
  for (auto mu_index : index_range(mus))
    {
      // Allocate enough space to store all points for the current mu
      all_evals[mu_index].resize(n_points);
      for (auto point_index : index_range(all_evals[mu_index]))
        {
          // Evaluate all samples for the current mu at the current interpolation point
          all_evals[mu_index][point_index] =
            this->side_evaluate(mus[mu_index],
                                v.all_xyz[point_index],
                                v.elem_ids[point_index],
                                v.side_indices[point_index],
                                v.qps[point_index],
                                v.sbd_ids[point_index],
                                v.boundary_ids[point_index],
                                requires_xyz_perturbations ? v.all_xyz_perturb[point_index] : empty_perturbs,
                                v.phi_i_qp[point_index]);
 
          // The vector returned by side_evaluate() should contain:
          // n_components * mus[mu_index].n_samples()
          // entries. That is, for multi-sample RBParameters objects,
          // the vector will be packed with entries as follows:
          // [sample0_component0, sample0_component1, ..., sample0_componentN,
          //  sample1_component0, sample1_component1, ..., sample1_componentN,
          //  ...
          //  sampleM_component0, sampleM_component1, ..., sampleM_componentN]
          auto n_samples = mus[mu_index].n_samples();
          auto received_data = all_evals[mu_index][point_index].size();
          libmesh_error_msg_if(received_data != n_components * n_samples,
                               "Recieved " << received_data <<
                               " evaluated values but expected to receive " << n_components * n_samples);
        }
    }
 
  // TODO: move this code for computing the total number of samples
  // represented by a std::vector of RBParameters objects to a helper
  // function.
  unsigned int output_size = 0;
  for (const auto & mu : mus)
    output_size += mu.n_samples();
 
  output.resize(output_size);
 
  // We use traditional for-loops here (rather than range-based) so that we can declare and
  // increment multiple loop counters all within the local scope of the for-loop.
  for (auto [mu_index, output_index] = std::make_tuple(0u, 0u); mu_index < mus.size(); ++mu_index)
    {
      auto n_samples = mus[mu_index].n_samples();
      for (auto mu_sample_idx = 0u; mu_sample_idx < n_samples; ++mu_sample_idx, ++output_index)
        {
          output[output_index].resize(n_points);
          for (auto point_index : make_range(n_points))
            {
              output[output_index][point_index].resize(n_components);
 
              for (auto comp : make_range(n_components))
                output[output_index][point_index][comp] = all_evals[mu_index][point_index][n_components*mu_sample_idx + comp];
            }
        }
    }
}

References libMesh::VectorizedEvalInput::all_xyz, libMesh::VectorizedEvalInput::all_xyz_perturb, libMesh::VectorizedEvalInput::boundary_ids, libMesh::VectorizedEvalInput::elem_ids, get_n_components(), libMesh::index_range(), libMesh::make_range(), libMesh::VectorizedEvalInput::phi_i_qp, libMesh::VectorizedEvalInput::qps, requires_xyz_perturbations, libMesh::VectorizedEvalInput::sbd_ids, side_evaluate(), and libMesh::VectorizedEvalInput::side_indices.

Referenced by preevaluate_parametrized_function_on_mesh_sides(), and libMesh::RBEIMEvaluation::rb_eim_solves().

vectorized_evaluate()

void libMesh::RBParametrizedFunction::vectorized_evaluate ( const std::vector< RBParameters > &  mus, const VectorizedEvalInput &  v, std::vector< std::vector< std::vector< Number > > > &  output  )

virtual

Vectorized version of evaluate.

If requires_xyz_perturbations==false, then all_xyz_perturb will not be used.

The base class implementation of this function loops over the input "mus" vector and calls evaluate() for each entry. The evaluate() function may be overridden in derived classes.

Definition at line 165 of file rb_parametrized_function.C.

{
  LOG_SCOPE("vectorized_evaluate()", "RBParametrizedFunction");
 
  output.clear();
  unsigned int n_points = v.all_xyz.size();
 
  libmesh_error_msg_if(v.sbd_ids.size() != n_points, "Error: invalid vector sizes");
  libmesh_error_msg_if(requires_xyz_perturbations && (v.all_xyz_perturb.size() != n_points), "Error: invalid vector sizes");
 
  // Dummy vector to be used when xyz perturbations are not required
  std::vector<Point> empty_perturbs;
 
  // The number of components returned by this RBParametrizedFunction
  auto n_components = this->get_n_components();
 
  // We first loop over all mus and all n_points, calling evaluate()
  // for each and storing the results.  It is easier to first
  // pre-compute all the values before filling output, since, in the
  // case of multi-sample RBParameters, the ordering of the loops is a
  // bit complicated otherwise.
  std::vector<std::vector<std::vector<Number>>> all_evals(mus.size());
  for (auto mu_index : index_range(mus))
    {
      // Allocate enough space to store all points for the current mu
      all_evals[mu_index].resize(n_points);
      for (auto point_index : index_range(all_evals[mu_index]))
        {
          // Evaluate all samples for the current mu at the current interpolation point
          all_evals[mu_index][point_index] =
            this->evaluate(mus[mu_index],
                           v.all_xyz[point_index],
                           v.elem_ids[point_index],
                           v.qps[point_index],
                           v.sbd_ids[point_index],
                           requires_xyz_perturbations ? v.all_xyz_perturb[point_index] : empty_perturbs,
                           v.phi_i_qp[point_index]);
 
          // The vector returned by evaluate() should contain:
          // n_components * mus[mu_index].n_samples()
          // entries. That is, for multi-sample RBParameters objects,
          // the vector will be packed with entries as follows:
          // [sample0_component0, sample0_component1, ..., sample0_componentN,
          //  sample1_component0, sample1_component1, ..., sample1_componentN,
          //  ...
          //  sampleM_component0, sampleM_component1, ..., sampleM_componentN]
          auto n_samples = mus[mu_index].n_samples();
          auto received_data = all_evals[mu_index][point_index].size();
          libmesh_error_msg_if(received_data != n_components * n_samples,
                               "Recieved " << received_data <<
                               " evaluated values but expected to receive " << n_components * n_samples);
        }
    }
 
  // TODO: move this code for computing the total number of samples
  // represented by a std::vector of RBParameters objects to a helper
  // function.
  unsigned int output_size = 0;
  for (const auto & mu : mus)
    output_size += mu.n_samples();
 
  output.resize(output_size);
 
  // We use traditional for-loops here (rather than range-based) so that we can declare and
  // increment multiple loop counters all within the local scope of the for-loop.
  for (auto [mu_index, output_index] = std::make_tuple(0u, 0u); mu_index < mus.size(); ++mu_index)
    {
      auto n_samples = mus[mu_index].n_samples();
      for (auto mu_sample_idx = 0u; mu_sample_idx < n_samples; ++mu_sample_idx, ++output_index)
        {
          output[output_index].resize(n_points);
          for (auto point_index : make_range(n_points))
            {
              output[output_index][point_index].resize(n_components);
 
              for (auto comp : make_range(n_components))
                output[output_index][point_index][comp] = all_evals[mu_index][point_index][n_components*mu_sample_idx + comp];
            }
        }
    }
}

References libMesh::VectorizedEvalInput::all_xyz, libMesh::VectorizedEvalInput::all_xyz_perturb, libMesh::VectorizedEvalInput::elem_ids, evaluate(), get_n_components(), libMesh::index_range(), libMesh::make_range(), libMesh::VectorizedEvalInput::phi_i_qp, libMesh::VectorizedEvalInput::qps, requires_xyz_perturbations, and libMesh::VectorizedEvalInput::sbd_ids.

Referenced by preevaluate_parametrized_function_on_mesh(), and libMesh::RBEIMEvaluation::rb_eim_solves().

Member Data Documentation

_is_nodal_boundary

bool libMesh::RBParametrizedFunction::_is_nodal_boundary

protected

In the case that _parametrized_function_boundary_ids is not empty, then this parametrized function is defined on a mesh boundary.

This boolean indicates if the mesh boundary under consideration is a set of sides, or a set of nodes.

Definition at line 492 of file rb_parametrized_function.h.

Referenced by on_mesh_nodes(), on_mesh_sides(), and set_parametrized_function_boundary_ids().

_parameter_independent_data

std::map<std::string, std::map<subdomain_id_type, Number> > libMesh::RBParametrizedFunction::_parameter_independent_data

protected

In some cases we need to store parameter-independent data which is related to this function but since it is parameter-indepedent should not be returned as part of evaluate().

We index this data by "property name" --> subdomain_id --> value.

Definition at line 479 of file rb_parametrized_function.h.

Referenced by get_parameter_independent_data().

_parametrized_function_boundary_ids

std::set<boundary_id_type> libMesh::RBParametrizedFunction::_parametrized_function_boundary_ids

protected

In the case of an RBParametrizedFunction defined on element sides, this defines the set of boundary IDs that the function is defined on.

Definition at line 485 of file rb_parametrized_function.h.

Referenced by get_parametrized_function_boundary_ids(), and set_parametrized_function_boundary_ids().

_rb_property_map

std::unordered_map<std::string, std::set<dof_id_type> > libMesh::RBParametrizedFunction::_rb_property_map

protected

Generic property map used to store data during mesh pre-evaluation.

It should be initialized from a vectorized_evaluate() call during the mesh pre-evaluation. Then this RBParametrizedFunction rb_property_map is used to fill the RBEIMEvaluation VectorizedEvalInput rb_property_map with the same properties but interpolation point data only instead of the entire mesh.

Definition at line 500 of file rb_parametrized_function.h.

Referenced by add_rb_property_map_entry(), and get_rb_property_map().

fd_delta

Real libMesh::RBParametrizedFunction::fd_delta

The finite difference step size in the case that this function in the case that this function uses finite differencing.

Definition at line 468 of file rb_parametrized_function.h.

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

is_lookup_table

bool libMesh::RBParametrizedFunction::is_lookup_table

Boolean to indicate if this parametrized function is defined based on a lookup table or not.

If it is defined based on a lookup table, then the evaluation functions will access a discrete parameter to determine the index to lookup.

Definition at line 456 of file rb_parametrized_function.h.

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

lookup_table_param_name

std::string libMesh::RBParametrizedFunction::lookup_table_param_name

If this is a lookup table, then lookup_table_param_name specifies the parameter that is used to index into the lookup table.

Definition at line 462 of file rb_parametrized_function.h.

Referenced by libMesh::RBEIMEvaluation::rb_eim_solves(), and libMesh::RBEIMConstruction::set_rb_construction_parameters().

mesh_to_preevaluated_node_values_map

std::unordered_map<dof_id_type, unsigned int> libMesh::RBParametrizedFunction::mesh_to_preevaluated_node_values_map

Indexing into preevaluated_values for the case where the preevaluated values were obtained from evaluations at elements/quadrature points on a mesh.

The indexing here is: node_id --> point_index

Definition at line 427 of file rb_parametrized_function.h.

Referenced by lookup_preevaluated_node_value_on_mesh(), and preevaluate_parametrized_function_on_mesh_nodes().

mesh_to_preevaluated_side_values_map

std::map<std::pair<dof_id_type,unsigned int>, std::vector<unsigned int> > libMesh::RBParametrizedFunction::mesh_to_preevaluated_side_values_map

Similar to the above except this map stores the data on element sides.

The indexing here is: (elem_id,side index) --> qp --> point_index

Definition at line 419 of file rb_parametrized_function.h.

Referenced by lookup_preevaluated_side_value_on_mesh(), and preevaluate_parametrized_function_on_mesh_sides().

mesh_to_preevaluated_values_map

std::unordered_map<dof_id_type, std::vector<unsigned int> > libMesh::RBParametrizedFunction::mesh_to_preevaluated_values_map

Indexing into preevaluated_values for the case where the preevaluated values were obtained from evaluations at elements/quadrature points on a mesh.

The indexing here is: elem_id --> qp --> point_index Then preevaluated_values[0][point_index] provides the vector of component values at that point.

Definition at line 412 of file rb_parametrized_function.h.

Referenced by lookup_preevaluated_value_on_mesh(), and preevaluate_parametrized_function_on_mesh().

preevaluated_values

std::vector<std::vector<std::vector<Number> > > libMesh::RBParametrizedFunction::preevaluated_values

Storage for pre-evaluated values.

The indexing is given by: parameter index --> point index --> component index --> value.

Definition at line 402 of file rb_parametrized_function.h.

Referenced by lookup_preevaluated_node_value_on_mesh(), lookup_preevaluated_side_value_on_mesh(), lookup_preevaluated_value_on_mesh(), preevaluate_parametrized_function_on_mesh(), preevaluate_parametrized_function_on_mesh_nodes(), and preevaluate_parametrized_function_on_mesh_sides().

requires_all_elem_center_data

bool libMesh::RBParametrizedFunction::requires_all_elem_center_data

Boolean to indicate whether this parametrized function requires data from the center on the current element.

Definition at line 449 of file rb_parametrized_function.h.

Referenced by preevaluate_parametrized_function_on_mesh().

requires_all_elem_qp_data

bool libMesh::RBParametrizedFunction::requires_all_elem_qp_data

Boolean to indicate whether this parametrized function requires data from all qps on the current element at each qp location.

This can be necessary in certain cases, e.g. when the parametrized function depends on "element average" quantities.

Definition at line 443 of file rb_parametrized_function.h.

Referenced by preevaluate_parametrized_function_on_mesh().

requires_xyz_perturbations

bool libMesh::RBParametrizedFunction::requires_xyz_perturbations

Boolean to indicate whether this parametrized function requires xyz perturbations in order to evaluate function values.

An example of where perturbations are required is when the parametrized function is based on finite difference approximations to derivatives.

Definition at line 435 of file rb_parametrized_function.h.

Referenced by libMesh::RBEIMConstruction::initialize_qp_data(), preevaluate_parametrized_function_on_mesh(), preevaluate_parametrized_function_on_mesh_sides(), side_vectorized_evaluate(), and vectorized_evaluate().

---

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

• include/reduced_basis/rb_parametrized_function.h
• src/reduced_basis/rb_parametrized_function.C