libMesh::RBEIMEvaluation Class Reference

This class is part of the rbOOmit framework. More...

#include <rb_eim_evaluation.h>

Inheritance diagram for libMesh::RBEIMEvaluation:

Public Types
typedef RBEvaluation	Parent
	The type of the parent. More...

Public Member Functions
	RBEIMEvaluation (const libMesh::Parallel::Communicator &comm_in)
	Constructor. More...
virtual	~RBEIMEvaluation ()
	Destructor. More...
virtual void	clear () override
	Clear this object. More...
virtual void	resize_data_structures (const unsigned int Nmax, bool resize_error_bound_data=true) override
	Resize the data structures for storing data associated with this object. More...
void	attach_parametrized_function (RBParametrizedFunction *pf)
	Attach the parametrized function that we will approximate using the Empirical Interpolation Method. More...
unsigned int	get_n_parametrized_functions () const
	Get the number of parametrized functions that have been attached to this system. More...
ReplicatedMesh &	get_interpolation_points_mesh ()
	Get a writable reference to the interpolation points mesh. More...
Number	evaluate_parametrized_function (unsigned int var_index, const Point &p, const Elem &elem)
virtual Real	rb_solve (unsigned int N) override
	Calculate the EIM approximation to parametrized_function using the first N EIM basis functions. More...
void	rb_solve (DenseVector< Number > &EIM_rhs)
	Calculate the EIM approximation for the given right-hand side vector EIM_rhs. More...
virtual Real	get_error_bound_normalization () override
void	initialize_eim_theta_objects ()
	Build a vector of RBTheta objects that accesses the components of the RB_solution member variable of this RBEvaluation. More...
std::vector< std::unique_ptr< RBTheta > > &	get_eim_theta_objects ()
virtual std::unique_ptr< RBTheta >	build_eim_theta (unsigned int index)
	Build a theta object corresponding to EIM index index. More...
virtual void	legacy_write_offline_data_to_files (const std::string &directory_name="offline_data", const bool write_binary_data=true) override
	Write out all the data to text files in order to segregate the Offline stage from the Online stage. More...
virtual void	legacy_read_offline_data_from_files (const std::string &directory_name="offline_data", bool read_error_bound_data=true, const bool read_binary_data=true) override
	Read in the saved Offline reduced basis data to initialize the system for Online solves. More...
void	set_rb_theta_expansion (RBThetaExpansion &rb_theta_expansion_in)
	Set the RBThetaExpansion object. More...
RBThetaExpansion &	get_rb_theta_expansion ()
	Get a reference to the rb_theta_expansion. More...
bool	is_rb_theta_expansion_initialized () const
NumericVector< Number > &	get_basis_function (unsigned int i)
	Get a reference to the i^th basis function. More...
virtual Real	compute_residual_dual_norm (const unsigned int N)
	Compute the dual norm of the residual for the solution saved in RB_solution_vector. More...
virtual Real	residual_scaling_denom (Real alpha_LB)
	Specifies the residual scaling on the denominator to be used in the a posteriori error bound. More...
Real	eval_output_dual_norm (unsigned int n, const RBParameters &mu)
	Evaluate the dual norm of output n for the current parameters. More...
virtual Real	get_stability_lower_bound ()
	Get a lower bound for the stability constant (e.g. More...
virtual unsigned int	get_n_basis_functions () const
	Get the current number of basis functions. More...
virtual void	set_n_basis_functions (unsigned int n_bfs)
	Set the number of basis functions. More...
virtual void	clear_riesz_representors ()
	Clear all the Riesz representors that are used to compute the RB residual (and hence error bound). More...
virtual void	write_out_basis_functions (System &sys, const std::string &directory_name="offline_data", const bool write_binary_basis_functions=true)
	Write out all the basis functions to file. More...
virtual void	write_out_vectors (System &sys, std::vector< NumericVector< Number > * > &vectors, const std::string &directory_name="offline_data", const std::string &data_name="bf", const bool write_binary_basis_functions=true)
	Same as write_out_basis_functions, except in this case we pass in the vectors to be written. More...
virtual void	read_in_basis_functions (System &sys, const std::string &directory_name="offline_data", const bool read_binary_basis_functions=true)
	Read in all the basis functions from file. More...
void	read_in_vectors (System &sys, std::vector< std::unique_ptr< NumericVector< Number >>> &vectors, const std::string &directory_name, const std::string &data_name, const bool read_binary_vectors)
	Same as read_in_basis_functions, except in this case we pass in the vectors to be written. More...
void	read_in_vectors_from_multiple_files (System &sys, std::vector< std::vector< std::unique_ptr< NumericVector< Number >>> * > multiple_vectors, const std::vector< std::string > &multiple_directory_names, const std::vector< std::string > &multiple_data_names, const bool read_binary_vectors)
	Performs read_in_vectors for a list of directory names and data names. More...
void	initialize_parameters (const RBParameters &mu_min_in, const RBParameters &mu_max_in, const std::map< std::string, std::vector< Real >> &discrete_parameter_values)
	Initialize the parameter ranges and set current_parameters. More...
void	initialize_parameters (const RBParametrized &rb_parametrized)
	Initialize the parameter ranges and set current_parameters. More...
unsigned int	get_n_params () const
	Get the number of parameters. More...
unsigned int	get_n_continuous_params () const
	Get the number of continuous parameters. More...
unsigned int	get_n_discrete_params () const
	Get the number of discrete parameters. More...
std::set< std::string >	get_parameter_names () const
	Get a set that stores the parameter names. More...
const RBParameters &	get_parameters () const
	Get the current parameters. More...
void	set_parameters (const RBParameters &params)
	Set the current parameters to params. More...
const RBParameters &	get_parameters_min () const
	Get an RBParameters object that specifies the minimum allowable value for each parameter. More...
const RBParameters &	get_parameters_max () const
	Get an RBParameters object that specifies the maximum allowable value for each parameter. More...
Real	get_parameter_min (const std::string &param_name) const
	Get minimum allowable value of parameter param_name. More...
Real	get_parameter_max (const std::string &param_name) const
	Get maximum allowable value of parameter param_name. More...
void	print_parameters () const
	Print the current parameters. More...
void	write_parameter_data_to_files (const std::string &continuous_param_file_name, const std::string &discrete_param_file_name, const bool write_binary_data)
	Write out the parameter ranges to files. More...
void	read_parameter_data_from_files (const std::string &continuous_param_file_name, const std::string &discrete_param_file_name, const bool read_binary_data)
	Read in the parameter ranges from files. More...
bool	is_discrete_parameter (const std::string &mu_name) const
	Is parameter mu_name discrete? More...
const std::map< std::string, std::vector< Real > > &	get_discrete_parameter_values () const
	Get a const reference to the discrete parameter values. More...
void	print_discrete_parameter_values () const
	Print out all the discrete parameter values. More...
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

Static Public Member Functions
static Real	get_closest_value (Real value, const std::vector< Real > &list_of_values)
static std::string	get_info ()
	Gets a string containing the reference information. More...
static void	print_info (std::ostream &out=libMesh::out)
	Prints the reference information, by default to libMesh::out. More...
static unsigned int	n_objects ()
	Prints the number of outstanding (created, but not yet destroyed) objects. More...
static void	enable_print_counter_info ()
	Methods to enable/disable the reference counter output from print_info() More...
static void	disable_print_counter_info ()

Public Attributes
DenseMatrix< Number >	interpolation_matrix
	Dense matrix that stores the lower triangular interpolation matrix that can be used. More...
std::vector< Point >	interpolation_points
	The list of interpolation points, i.e. More...
std::vector< unsigned int >	interpolation_points_var
	The corresponding list of variables indices at which the interpolation points were identified. More...
std::vector< Elem * >	interpolation_points_elem
	The corresponding list of elements at which the interpolation points were identified. More...
std::vector< std::unique_ptr< NumericVector< Number > > >	basis_functions
	The libMesh vectors storing the finite element coefficients of the RB basis functions. More...
std::vector< RBParameters >	greedy_param_list
	The list of parameters selected by the Greedy algorithm in generating the Reduced Basis associated with this RBEvaluation object. More...
DenseMatrix< Number >	RB_inner_product_matrix
	The inner product matrix. More...
std::vector< DenseMatrix< Number > >	RB_Aq_vector
	Dense matrices for the RB computations. More...
std::vector< DenseVector< Number > >	RB_Fq_vector
	Dense vector for the RHS. More...
DenseVector< Number >	RB_solution
	The RB solution vector. More...
std::vector< std::vector< DenseVector< Number > > >	RB_output_vectors
	The vectors storing the RB output vectors. More...
std::vector< Number >	RB_outputs
	The vectors storing the RB output values and corresponding error bounds. More...
std::vector< Real >	RB_output_error_bounds
std::vector< Number >	Fq_representor_innerprods
	Vectors storing the residual representor inner products to be used in computing the residuals online. More...
std::vector< std::vector< std::vector< Number > > >	Fq_Aq_representor_innerprods
	Vectors storing the residual representor inner products to be used in computing the residuals online. More...
std::vector< std::vector< std::vector< Number > > >	Aq_Aq_representor_innerprods
std::vector< std::vector< Number > >	output_dual_innerprods
	The vector storing the dual norm inner product terms for each output. More...
std::vector< std::vector< std::unique_ptr< NumericVector< Number > > > >	Aq_representor
	Vector storing the residual representors associated with the left-hand side. More...
bool	evaluate_RB_error_bound
	Boolean to indicate whether we evaluate a posteriori error bounds when rb_solve is called. More...
bool	compute_RB_inner_product
	Boolean flag to indicate whether we compute the RB_inner_product_matrix. More...
bool	verbose_mode
	Public boolean to toggle verbose mode. More...

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

Protected Member Functions
void	assert_file_exists (const std::string &file_name)
	Helper function that checks if file_name exists. More...
void	increment_constructor_count (const std::string &name)
	Increments the construction counter. More...
void	increment_destructor_count (const std::string &name)
	Increments the destruction counter. More...

Protected Attributes
const Parallel::Communicator &	_communicator

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

Private Member Functions
void	legacy_write_out_interpolation_points_elem (const std::string &directory_name)
	Write out interpolation_points_elem by putting the elements into a mesh and writing out the mesh. More...
void	legacy_read_in_interpolation_points_elem (const std::string &directory_name)
	Read int interpolation_points_elem from a mesh. More...
void	write_parameter_ranges_to_file (const std::string &file_name, const bool write_binary)
	Write out the parameter ranges to file. More...
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. More...
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. More...
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. More...
bool	valid_params (const RBParameters &params)
	Helper function to check that params is valid. More...

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

Private Attributes
std::vector< RBParametrizedFunction * >	_parametrized_functions
	This vector stores the parametrized functions that will be approximated in this EIM system. More...
std::vector< std::unique_ptr< RBTheta > >	_rb_eim_theta_objects
	The vector of RBTheta objects that are created to point to this RBEIMEvaluation. More...
RBThetaExpansion	_empty_rb_theta_expansion
	We initialize RBEIMEvaluation so that it has an "empty" RBThetaExpansion, because this isn't used at all in the EIM. More...
RBParameters	_previous_parameters
	Store the parameters at which the previous solve was performed (so we can avoid an unnecessary repeat solve). More...
unsigned int	_previous_N
	Store the number of basis functions used for the previous solve (so we can avoid an unnecessary repeat solve). More...
Real	_previous_error_bound
	Store the previous error bound returned by rb_solve (so we can return it if we are avoiding an unnecessary repeat solve). More...
ReplicatedMesh	_interpolation_points_mesh
	Mesh object that we use to store copies of the elements associated with interpolation points. More...
RBThetaExpansion *	rb_theta_expansion
	A pointer to to the object that stores the theta expansion. More...
bool	parameters_initialized
	Flag indicating whether the parameters have been initialized. More...
RBParameters	parameters
	Vector storing the current parameters. More...
RBParameters	parameters_min
	Vectors that define the ranges (min and max) for the parameters. More...
RBParameters	parameters_max
std::map< std::string, std::vector< Real > >	_discrete_parameter_values
	Map that defines the allowable values of any discrete parameters. More...

Detailed Description

This class is part of the rbOOmit framework.

RBEIMEvaluation extends RBEvaluation to encapsulate the code and data required to perform "online" evaluations for EIM approximations.

Author

David J. Knezevic

Date

2011

Definition at line 51 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 117 of file reference_counter.h.

Parent

typedef RBEvaluation libMesh::RBEIMEvaluation::Parent

The type of the parent.

Definition at line 68 of file rb_eim_evaluation.h.

Constructor & Destructor Documentation

RBEIMEvaluation()

RBEIMEvaluation::RBEIMEvaluation

(

const libMesh::Parallel::Communicator &

comm_in

)

Constructor.

Definition at line 39 of file rb_eim_evaluation.C.

  :
  RBEvaluation(comm_in),
  _previous_N(0),
  _previous_error_bound(-1),
  _interpolation_points_mesh(comm_in)
{
  // Indicate that we need to compute the RB
  // inner product matrix in this case
  compute_RB_inner_product = true;
 
  // initialize to the empty RBThetaExpansion object
  set_rb_theta_expansion(_empty_rb_theta_expansion);
 
  // Let's not renumber the _interpolation_points_mesh
  _interpolation_points_mesh.allow_renumbering(false);
}

References _empty_rb_theta_expansion, _interpolation_points_mesh, libMesh::MeshBase::allow_renumbering(), libMesh::RBEvaluation::compute_RB_inner_product, and libMesh::RBEvaluation::set_rb_theta_expansion().

~RBEIMEvaluation()

RBEIMEvaluation::~RBEIMEvaluation ( )

virtual

Destructor.

Definition at line 57 of file rb_eim_evaluation.C.

{
  this->clear();
}

References clear().

Member Function Documentation

assert_file_exists()

void libMesh::RBEvaluation::assert_file_exists ( const std::string &  file_name )

protectedinherited

Helper function that checks if file_name exists.

Definition at line 874 of file rb_evaluation.C.

{
  if (!std::ifstream(file_name.c_str()))
    libmesh_error_msg("File missing: " + file_name);
}

Referenced by libMesh::TransientRBEvaluation::legacy_read_offline_data_from_files(), legacy_read_offline_data_from_files(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), and libMesh::RBEvaluation::read_in_vectors_from_multiple_files().

attach_parametrized_function()

void RBEIMEvaluation::attach_parametrized_function

(

RBParametrizedFunction *

pf

)

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

Definition at line 87 of file rb_eim_evaluation.C.

{
  _parametrized_functions.push_back(pf);
}

References _parametrized_functions.

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

{
  return libmesh_make_unique<RBEIMTheta>(*this, index);
}

Referenced by initialize_eim_theta_objects().

clear()

void RBEIMEvaluation::clear ( )

overridevirtual

Clear this object.

Reimplemented from libMesh::RBEvaluation.

Definition at line 62 of file rb_eim_evaluation.C.

{
  Parent::clear();
 
  interpolation_points.clear();
  interpolation_points_var.clear();
  interpolation_points_elem.clear();
  _interpolation_points_mesh.clear();
 
  // Delete any RBTheta objects that were created
  _rb_eim_theta_objects.clear();
}

References _interpolation_points_mesh, _rb_eim_theta_objects, libMesh::RBEvaluation::clear(), libMesh::ReplicatedMesh::clear(), interpolation_points, interpolation_points_elem, and interpolation_points_var.

Referenced by ~RBEIMEvaluation().

clear_riesz_representors()

void libMesh::RBEvaluation::clear_riesz_representors ( )

virtualinherited

Clear all the Riesz representors that are used to compute the RB residual (and hence error bound).

This is useful since once we complete the Greedy we may not need the representors any more.

Reimplemented in libMesh::TransientRBEvaluation.

Definition at line 411 of file rb_evaluation.C.

{
  Aq_representor.clear();
}

References libMesh::RBEvaluation::Aq_representor.

Referenced by libMesh::RBEvaluation::clear(), libMesh::TransientRBEvaluation::clear_riesz_representors(), and libMesh::RBEvaluation::resize_data_structures().

comm()

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

inlineinherited

Returns

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

Definition at line 94 of file parallel_object.h.

  { return _communicator; }

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_tao_equality_constraints(), libMesh::__libmesh_tao_equality_constraints_jacobian(), libMesh::__libmesh_tao_gradient(), libMesh::__libmesh_tao_hessian(), libMesh::__libmesh_tao_inequality_constraints(), libMesh::__libmesh_tao_inequality_constraints_jacobian(), libMesh::__libmesh_tao_objective(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult_add(), libMesh::EquationSystems::_read_impl(), libMesh::MeshRefinement::_refine_elements(), libMesh::MeshRefinement::_smooth_flags(), libMesh::DofMap::add_constraints_to_send_list(), add_cube_convex_hull_to_mesh(), libMesh::PetscDMWrapper::add_dofs_helper(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::ImplicitSystem::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::DynaIO::add_spline_constraints(), libMesh::System::add_vector(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::assemble_affine_expansion(), libMesh::FEMSystem::assemble_qoi(), libMesh::MeshCommunication::assign_global_indices(), libMesh::DofMap::attach_matrix(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::PetscDMWrapper::build_section(), libMesh::PetscDMWrapper::build_sf(), libMesh::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::RBConstruction::compute_output_dual_innerprods(), libMesh::RBConstruction::compute_residual_dual_norm_slow(), libMesh::RBSCMConstruction::compute_SCM_bounds_on_training_set(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshTools::create_bounding_box(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshTools::create_nodal_bounding_box(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::MeshTools::create_subdomain_bounding_box(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::DTKSolutionTransfer::DTKSolutionTransfer(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::RBEIMConstruction::enrich_RB_space(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::RBConstruction::enrich_RB_space(), libMesh::EpetraVector< T >::EpetraVector(), AssembleOptimization::equality_constraints(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::RBEIMConstruction::evaluate_mesh_function(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_error_tolerance(), libMesh::MeshRefinement::flag_elements_by_mean_stddev(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::DofMap::gather_constraints(), libMesh::MeshfreeInterpolation::gather_remote_data(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::LocationMap< T >::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::EigenSystem::init_matrices(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::RBEIMConstruction::initialize_rb_construction(), integrate_function(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::libmesh_petsc_preconditioner_apply(), libMesh::libmesh_petsc_snes_fd_residual(), libMesh::libmesh_petsc_snes_jacobian(), libMesh::libmesh_petsc_snes_mffd_residual(), libMesh::libmesh_petsc_snes_postcheck(), libMesh::libmesh_petsc_snes_residual(), libMesh::libmesh_petsc_snes_residual_helper(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_new_nodes_parallel_consistent(), libMesh::MeshCommunication::make_node_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_unique_ids_parallel_consistent(), libMesh::MeshCommunication::make_nodes_parallel_consistent(), libMesh::MeshCommunication::make_p_levels_parallel_consistent(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::FEMSystem::mesh_position_set(), LinearElasticityWithContact::move_mesh(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::DofMap::n_constrained_dofs(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::ReplicatedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::MeshTools::paranoid_n_levels(), libMesh::petsc_auto_fieldsplit(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::print_dof_constraints(), FEMParameters::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::System::read_legacy_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::DistributedMesh::renumber_dof_objects(), LinearElasticityWithContact::residual_and_jacobian(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::RBEIMConstruction::set_explicit_sys_subvector(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::split_mesh(), libMesh::BoundaryInfo::sync(), libMesh::MeshRefinement::test_level_one(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), libMesh::MeshRefinement::test_unflagged(), SystemsTest::testBlockRestrictedVarNDofs(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), SystemsTest::testProjectCubeWithMeshFunction(), CheckpointIOTest::testSplitter(), libMesh::MeshTools::total_weight(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_assembly(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::RBEIMConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::VTKIO::write_nodal_data(), libMesh::RBEvaluation::write_out_vectors(), libMesh::TransientRBConstruction::write_riesz_representors_to_files(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::RBDataSerialization::RBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::TransientRBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::RBEIMEvaluationSerialization::write_to_file(), and libMesh::RBDataSerialization::RBSCMEvaluationSerialization::write_to_file().

compute_residual_dual_norm()

Real libMesh::RBEvaluation::compute_residual_dual_norm ( const unsigned int  N )

virtualinherited

Compute the dual norm of the residual for the solution saved in RB_solution_vector.

Reimplemented in libMesh::TransientRBEvaluation.

Definition at line 302 of file rb_evaluation.C.

{
  LOG_SCOPE("compute_residual_dual_norm()", "RBEvaluation");
 
  const RBParameters & mu = get_parameters();
 
  // Use the stored representor inner product values
  // to evaluate the residual norm
  Number residual_norm_sq = 0.;
 
  unsigned int q=0;
  for (unsigned int q_f1=0; q_f1<rb_theta_expansion->get_n_F_terms(); q_f1++)
    {
      for (unsigned int q_f2=q_f1; q_f2<rb_theta_expansion->get_n_F_terms(); q_f2++)
        {
          Real delta = (q_f1==q_f2) ? 1. : 2.;
          residual_norm_sq += delta * libmesh_real(
                                                   rb_theta_expansion->eval_F_theta(q_f1, mu)
                                                   * libmesh_conj(rb_theta_expansion->eval_F_theta(q_f2, mu)) * Fq_representor_innerprods[q] );
 
          q++;
        }
    }
 
  for (unsigned int q_f=0; q_f<rb_theta_expansion->get_n_F_terms(); q_f++)
    {
      for (unsigned int q_a=0; q_a<rb_theta_expansion->get_n_A_terms(); q_a++)
        {
          for (unsigned int i=0; i<N; i++)
            {
              Real delta = 2.;
              residual_norm_sq +=
                delta * libmesh_real( rb_theta_expansion->eval_F_theta(q_f, mu) *
                                      libmesh_conj(rb_theta_expansion->eval_A_theta(q_a, mu)) *
                                      libmesh_conj(RB_solution(i)) * Fq_Aq_representor_innerprods[q_f][q_a][i] );
            }
        }
    }
 
  q=0;
  for (unsigned int q_a1=0; q_a1<rb_theta_expansion->get_n_A_terms(); q_a1++)
    {
      for (unsigned int q_a2=q_a1; q_a2<rb_theta_expansion->get_n_A_terms(); q_a2++)
        {
          Real delta = (q_a1==q_a2) ? 1. : 2.;
 
          for (unsigned int i=0; i<N; i++)
            {
              for (unsigned int j=0; j<N; j++)
                {
                  residual_norm_sq +=
                    delta * libmesh_real( libmesh_conj(rb_theta_expansion->eval_A_theta(q_a1, mu)) *
                                          rb_theta_expansion->eval_A_theta(q_a2, mu) *
                                          libmesh_conj(RB_solution(i)) * RB_solution(j) * Aq_Aq_representor_innerprods[q][i][j] );
                }
            }
 
          q++;
        }
    }
 
  if (libmesh_real(residual_norm_sq) < 0.)
    {
      //    libMesh::out << "Warning: Square of residual norm is negative "
      //                 << "in RBSystem::compute_residual_dual_norm()" << std::endl;
 
      //     Sometimes this is negative due to rounding error,
      //     but when this occurs the error is on the order of 1.e-10,
      //     so shouldn't affect error bound much...
      residual_norm_sq = std::abs(residual_norm_sq);
    }
 
  return std::sqrt( libmesh_real(residual_norm_sq) );
}

References std::abs(), libMesh::RBEvaluation::Aq_Aq_representor_innerprods, libMesh::RBThetaExpansion::eval_A_theta(), libMesh::RBThetaExpansion::eval_F_theta(), libMesh::RBEvaluation::Fq_Aq_representor_innerprods, libMesh::RBEvaluation::Fq_representor_innerprods, libMesh::RBThetaExpansion::get_n_A_terms(), libMesh::RBThetaExpansion::get_n_F_terms(), libMesh::RBParametrized::get_parameters(), libMesh::libmesh_conj(), libMesh::libmesh_real(), libMesh::RBEvaluation::RB_solution, libMesh::RBEvaluation::rb_theta_expansion, libMesh::Real, and std::sqrt().

Referenced by libMesh::RBEvaluation::rb_solve().

disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 106 of file reference_counter.C.

{
  _enable_print_counter = false;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

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

enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Definition at line 100 of file reference_counter.C.

{
  _enable_print_counter = true;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

eval_output_dual_norm()

Real libMesh::RBEvaluation::eval_output_dual_norm ( unsigned int  n, const RBParameters &  mu  )

inherited

Evaluate the dual norm of output n for the current parameters.

Definition at line 392 of file rb_evaluation.C.

{
  Number output_bound_sq = 0.;
  unsigned int q=0;
  for (unsigned int q_l1=0; q_l1<rb_theta_expansion->get_n_output_terms(n); q_l1++)
    {
      for (unsigned int q_l2=q_l1; q_l2<rb_theta_expansion->get_n_output_terms(n); q_l2++)
        {
          Real delta = (q_l1==q_l2) ? 1. : 2.;
          output_bound_sq += delta * libmesh_real(
                                                  libmesh_conj(rb_theta_expansion->eval_output_theta(n,q_l1,mu))*
                                                  rb_theta_expansion->eval_output_theta(n,q_l2,mu) * output_dual_innerprods[n][q] );
          q++;
        }
    }
 
  return libmesh_real(std::sqrt( output_bound_sq ));
}

References libMesh::RBThetaExpansion::eval_output_theta(), libMesh::RBThetaExpansion::get_n_output_terms(), libMesh::libmesh_conj(), libMesh::libmesh_real(), libMesh::RBEvaluation::output_dual_innerprods, libMesh::RBEvaluation::rb_theta_expansion, libMesh::Real, and std::sqrt().

Referenced by libMesh::TransientRBEvaluation::rb_solve(), and libMesh::RBEvaluation::rb_solve().

evaluate_parametrized_function()

Number RBEIMEvaluation::evaluate_parametrized_function	(	unsigned int	var_index,
		const Point &	p,
		const Elem &	elem
	)

Returns

The value of the parametrized function that is being approximated at the point p. var_index specifies the variable (i.e. the parametrized function index) to be evaluated. elem specifies the element of the mesh that contains p.

Definition at line 103 of file rb_eim_evaluation.C.

{
  if (var_index >= get_n_parametrized_functions())
    libmesh_error_msg("Error: We must have var_index < get_n_parametrized_functions() in evaluate_parametrized_function.");
 
  return _parametrized_functions[var_index]->evaluate(get_parameters(), p, elem);
}

References _parametrized_functions, get_n_parametrized_functions(), and libMesh::RBParametrized::get_parameters().

Referenced by rb_solve(), and libMesh::RBEIMConstruction::truth_solve().

get_basis_function()

NumericVector< Number > & libMesh::RBEvaluation::get_basis_function ( unsigned int  i )

inherited

Get a reference to the i^th basis function.

Definition at line 202 of file rb_evaluation.C.

{
  libmesh_assert_less (i, basis_functions.size());
 
  return *(basis_functions[i]);
}

References libMesh::RBEvaluation::basis_functions.

Referenced by libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::RBEIMConstruction::enrich_RB_space(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::RBEIMConstruction::load_basis_function(), libMesh::RBConstruction::load_basis_function(), libMesh::RBEIMConstruction::load_rb_solution(), libMesh::RBEIMAssembly::RBEIMAssembly(), libMesh::RBEIMConstruction::update_RB_system_matrices(), and libMesh::TransientRBConstruction::update_RB_system_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 433 of file rb_parametrized.C.

{
  if (list_of_values.empty())
    libmesh_error_msg("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 std::abs(), 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 381 of file rb_parametrized.C.

{
  if (!parameters_initialized)
    libmesh_error_msg("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::get_n_discrete_params(), libMesh::RBParametrized::initialize_parameters(), libMesh::RBParametrized::print_discrete_parameter_values(), libMesh::RBParametrized::valid_params(), and libMesh::RBParametrized::write_discrete_parameter_values_to_file().

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

{
  return _rb_eim_theta_objects;
}

References _rb_eim_theta_objects.

get_error_bound_normalization()

Real RBEIMEvaluation::get_error_bound_normalization ( )

overridevirtual

Returns

A scaling factor that we can use to provide a consistent scaling of the RB error bound across different parameter values.

Reimplemented from libMesh::RBEvaluation.

Definition at line 198 of file rb_eim_evaluation.C.

{
  // Just set the normalization factor to 1 in this case.
  // Users can override this method if specific behavior
  // is required.
 
  return 1.;
}

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 & pr : _counts)
    {
      const std::string name(pr.first);
      const unsigned int creations    = pr.second.first;
      const unsigned int destructions = pr.second.second;
 
      oss << "| " << name << " reference count information:\n"
          << "|  Creations:    " << creations    << '\n'
          << "|  Destructions: " << destructions << '\n';
    }
 
  oss << " ---------------------------------------------------------------------------- \n";
 
  return oss.str();
 
#else
 
  return "";
 
#endif
}

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

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

get_interpolation_points_mesh()

ReplicatedMesh & RBEIMEvaluation::get_interpolation_points_mesh

(

)

Get a writable reference to the interpolation points mesh.

Definition at line 98 of file rb_eim_evaluation.C.

{
  return _interpolation_points_mesh;
}

References _interpolation_points_mesh.

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

get_n_basis_functions()

virtual unsigned int libMesh::RBEvaluation::get_n_basis_functions ( ) const

inlinevirtualinherited

Get the current number of basis functions.

Definition at line 145 of file rb_evaluation.h.

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

References libMesh::RBEvaluation::basis_functions.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder(), libMesh::RBDataSerialization::add_rb_evaluation_data_to_builder(), libMesh::RBDataSerialization::add_transient_rb_evaluation_data_to_builder(), libMesh::TransientRBConstruction::assemble_affine_expansion(), libMesh::RBEIMConstruction::compute_best_fit_error(), libMesh::RBEIMConstruction::enrich_RB_space(), libMesh::RBConstruction::enrich_RB_space(), libMesh::RBEIMTheta::evaluate(), libMesh::RBConstruction::greedy_termination_test(), libMesh::RBEIMConstruction::initialize_eim_assembly_objects(), initialize_eim_theta_objects(), legacy_read_in_interpolation_points_elem(), libMesh::TransientRBEvaluation::legacy_read_offline_data_from_files(), legacy_read_offline_data_from_files(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), legacy_write_offline_data_to_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_rb_eim_evaluation_data(), libMesh::RBEIMConstruction::load_rb_solution(), libMesh::RBConstruction::load_rb_solution(), libMesh::TransientRBConstruction::load_rb_solution(), libMesh::RBConstruction::print_basis_function_orthogonality(), libMesh::TransientRBEvaluation::rb_solve(), libMesh::RBEvaluation::rb_solve(), rb_solve(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::recompute_all_residual_terms(), libMesh::RBEvaluation::resize_data_structures(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::RBConstruction::train_reduced_basis(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::RBEIMConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::TransientRBConstruction::write_riesz_representors_to_files(), and libMesh::RBConstruction::write_riesz_representors_to_files().

get_n_continuous_params()

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

inherited

Get the number of continuous parameters.

Definition at line 125 of file rb_parametrized.C.

{
  if (!parameters_initialized)
    libmesh_error_msg("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 135 of file rb_parametrized.C.

{
  if (!parameters_initialized)
    libmesh_error_msg("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_parametrized_functions()

unsigned int RBEIMEvaluation::get_n_parametrized_functions

(

)

const

Get the number of parametrized functions that have been attached to this system.

Definition at line 92 of file rb_eim_evaluation.C.

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

References _parametrized_functions.

Referenced by evaluate_parametrized_function().

get_n_params()

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

inherited

Get the number of parameters.

Definition at line 115 of file rb_parametrized.C.

{
  if (!parameters_initialized)
    libmesh_error_msg("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::RBConstruction::compute_max_error_bound(), libMesh::RBEIMTheta::evaluate(), libMesh::RBParametrized::get_n_continuous_params(), libMesh::RBSCMConstruction::print_info(), libMesh::RBConstruction::print_info(), and libMesh::RBParametrized::valid_params().

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

{
  if (!parameters_initialized)
    libmesh_error_msg("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::RBSCMConstruction::print_info(), libMesh::RBConstruction::print_info(), and libMesh::RBParametrized::valid_params().

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

{
  if (!parameters_initialized)
    libmesh_error_msg("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::RBSCMConstruction::print_info(), libMesh::RBConstruction::print_info(), and libMesh::RBParametrized::valid_params().

get_parameter_names()

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

inherited

Get a set that stores the parameter names.

Definition at line 144 of file rb_parametrized.C.

{
  if (!parameters_initialized)
    libmesh_error_msg("Error: parameters not initialized in RBParametrized::get_parameter_names");
 
  std::set<std::string> parameter_names;
  parameters_min.get_parameter_names(parameter_names);
 
  return parameter_names;
}

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

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

get_parameters()

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

inherited

Get the current parameters.

Definition at line 166 of file rb_parametrized.C.

{
  if (!parameters_initialized)
    libmesh_error_msg("Error: parameters not initialized in RBParametrized::get_current_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::RBEIMConstruction::compute_best_fit_error(), libMesh::RBEvaluation::compute_residual_dual_norm(), libMesh::RBSCMConstruction::compute_SCM_bounds_on_training_set(), libMesh::RBSCMConstruction::enrich_C_J(), libMesh::RBEIMConstruction::enrich_RB_space(), libMesh::RBEIMTheta::evaluate(), evaluate_parametrized_function(), 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::RBSCMEvaluation::legacy_read_offline_data_from_files(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), 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(), rb_solve(), libMesh::RBSCMEvaluation::save_current_parameters(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_assembly(), libMesh::TransientRBConstruction::truth_solve(), libMesh::RBEIMConstruction::truth_solve(), libMesh::RBConstruction::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 182 of file rb_parametrized.C.

{
  if (!parameters_initialized)
    libmesh_error_msg("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(), 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 174 of file rb_parametrized.C.

{
  if (!parameters_initialized)
    libmesh_error_msg("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(), and libMesh::RBParametrized::write_parameter_ranges_to_file().

get_rb_theta_expansion()

RBThetaExpansion & libMesh::RBEvaluation::get_rb_theta_expansion ( )

inherited

Get a reference to the rb_theta_expansion.

Definition at line 88 of file rb_evaluation.C.

{
  if (!is_rb_theta_expansion_initialized())
    libmesh_error_msg("Error: rb_theta_expansion hasn't been initialized yet");
 
  return *rb_theta_expansion;
}

References libMesh::RBEvaluation::is_rb_theta_expansion_initialized(), and libMesh::RBEvaluation::rb_theta_expansion.

Referenced by libMesh::RBDataSerialization::add_rb_evaluation_data_to_builder(), libMesh::RBDataSerialization::add_transient_rb_evaluation_data_to_builder(), libMesh::TransientRBEvaluation::cache_online_residual_terms(), libMesh::RBConstruction::get_rb_theta_expansion(), libMesh::TransientRBEvaluation::legacy_read_offline_data_from_files(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_rb_evaluation_data(), libMesh::RBDataDeserialization::load_transient_rb_evaluation_data(), libMesh::TransientRBEvaluation::rb_solve(), libMesh::TransientRBEvaluation::resize_data_structures(), and libMesh::TransientRBEvaluation::uncached_compute_residual_dual_norm().

get_stability_lower_bound()

Real libMesh::RBEvaluation::get_stability_lower_bound ( )

virtualinherited

Get a lower bound for the stability constant (e.g.

coercivity constant or inf-sup constant) at the current parameter value.

Reimplemented in SimpleRBEvaluation, SimpleRBEvaluation, SimpleRBEvaluation, SimpleRBEvaluation, SimpleRBEvaluation, and ElasticityRBEvaluation.

Definition at line 377 of file rb_evaluation.C.

{
  // Return a default value of 1, this function should
  // be overloaded to specify a problem-dependent stability
  // factor lower bound
  return 1.;
}

Referenced by libMesh::TransientRBEvaluation::rb_solve(), and libMesh::RBEvaluation::rb_solve().

increment_constructor_count()

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

inlineprotectedinherited

Increments the construction counter.

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

Definition at line 181 of file reference_counter.h.

{
  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
  std::pair<unsigned int, unsigned int> & p = _counts[name];
 
  p.first++;
}

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

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

increment_destructor_count()

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

inlineprotectedinherited

Increments the destruction counter.

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

Definition at line 194 of file reference_counter.h.

{
  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
  std::pair<unsigned int, unsigned int> & p = _counts[name];
 
  p.second++;
}

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

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::~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 207 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 (unsigned int i=0; i<get_n_basis_functions(); i++)
    _rb_eim_theta_objects.emplace_back(build_eim_theta(i));
}

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

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.

Definition at line 60 of file rb_parametrized.C.

{
  // Check that the min/max vectors are valid
  {
    const std::string err_string = "Error: Invalid mu_min/mu_max in RBParameters constructor.";
    bool valid_min_max = (mu_min_in.n_parameters() == mu_max_in.n_parameters());
    if (!valid_min_max)
      libmesh_error_msg(err_string);
 
    else
      {
        for (const auto & pr : mu_min_in)
          {
            const std::string & param_name = pr.first;
            if (mu_min_in.get_value(param_name) > mu_max_in.get_value(param_name))
              libmesh_error_msg(err_string);
          }
      }
  }
 
  parameters_min = mu_min_in;
  parameters_max = mu_max_in;
 
  // Add in min/max values due to the discrete parameters
    for (const auto & pr : discrete_parameter_values)
      {
        if (pr.second.empty())
          libmesh_error_msg("Error: List of discrete parameters for " << pr.first << " is empty.");
 
        Real min_val = *std::min_element(pr.second.begin(), pr.second.end());
        Real max_val = *std::max_element(pr.second.begin(), pr.second.end());
 
        libmesh_assert_less_equal(min_val,max_val);
 
        parameters_min.set_value(pr.first, min_val);
        parameters_max.set_value(pr.first, 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::get_value(), libMesh::RBParameters::n_parameters(), 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::RBEIMConstruction::initialize_parametrized_functions_in_training_set(), 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(), and libMesh::RBConstruction::train_reduced_basis().

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

is_discrete_parameter()

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

inherited

Is parameter mu_name discrete?

Definition at line 373 of file rb_parametrized.C.

{
  if (!parameters_initialized)
    libmesh_error_msg("Error: parameters not initialized in RBParametrized::is_discrete_parameter");
 
  return (_discrete_parameter_values.find(mu_name) != _discrete_parameter_values.end());
}

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

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

is_rb_theta_expansion_initialized()

bool libMesh::RBEvaluation::is_rb_theta_expansion_initialized ( ) const

inherited

Returns

true if the theta expansion has been initialized.

Definition at line 96 of file rb_evaluation.C.

{
  if (rb_theta_expansion)
    {
      return true;
    }
  else
    {
      return false;
    }
}

References libMesh::RBEvaluation::rb_theta_expansion.

Referenced by libMesh::RBEvaluation::get_rb_theta_expansion().

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 453 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 std::abs(), libMesh::RBParametrized::get_closest_value(), libMesh::Real, and value.

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

legacy_read_in_interpolation_points_elem()

void RBEIMEvaluation::legacy_read_in_interpolation_points_elem ( const std::string &  directory_name )

private

Read int interpolation_points_elem from a mesh.

Definition at line 468 of file rb_eim_evaluation.C.

{
  _interpolation_points_mesh.read(directory_name + "/interpolation_points_mesh.xda");
 
  // We have an element for each EIM basis function
  unsigned int n_bfs = this->get_n_basis_functions();
 
  std::vector<dof_id_type> interpolation_elem_ids;
  {
    // These are just integers, so no need for a binary format here
    std::ifstream interpolation_elem_ids_in
      ((directory_name + "/interpolation_elem_ids.dat").c_str(), std::ifstream::in);
 
    if (!interpolation_elem_ids_in)
      libmesh_error_msg("RB data missing: " + directory_name + "/interpolation_elem_ids.dat");
 
    for (unsigned int i=0; i<n_bfs; i++)
      {
        dof_id_type elem_id;
        interpolation_elem_ids_in >> elem_id;
        interpolation_elem_ids.push_back(elem_id);
      }
    interpolation_elem_ids_in.close();
  }
 
  interpolation_points_elem.resize(n_bfs);
  for (unsigned int i=0; i<n_bfs; i++)
    {
      interpolation_points_elem[i] =
        _interpolation_points_mesh.elem_ptr(interpolation_elem_ids[i]);
    }
}

References _interpolation_points_mesh, libMesh::ReplicatedMesh::elem_ptr(), libMesh::RBEvaluation::get_n_basis_functions(), interpolation_points_elem, and libMesh::UnstructuredMesh::read().

Referenced by legacy_read_offline_data_from_files().

legacy_read_offline_data_from_files()

void RBEIMEvaluation::legacy_read_offline_data_from_files ( const std::string &  directory_name = "offline_data", bool  read_error_bound_data = true, const bool  read_binary_data = true  )

overridevirtual

Read in the saved Offline reduced basis data to initialize the system for Online solves.

Note

This is a legacy method, use RBDataSerialization instead.

Reimplemented from libMesh::RBEvaluation.

Definition at line 387 of file rb_eim_evaluation.C.

{
  LOG_SCOPE("legacy_read_offline_data_from_files()", "RBEIMEvaluation");
 
  Parent::legacy_read_offline_data_from_files(directory_name, read_error_bound_data);
 
  // First, find out how many basis functions we had when Greedy terminated
  // This was set in RBSystem::read_offline_data_from_files
  unsigned int n_bfs = this->get_n_basis_functions();
 
  // The writing mode: DECODE for binary, READ for ASCII
  XdrMODE mode = read_binary_data ? DECODE : READ;
 
  // The suffix to use for all the files that are written out
  const std::string suffix = read_binary_data ? ".xdr" : ".dat";
 
  // Stream for creating file names
  std::ostringstream file_name;
 
  // Read in the interpolation matrix
  file_name.str("");
  file_name << directory_name << "/interpolation_matrix" << suffix;
  assert_file_exists(file_name.str());
 
  Xdr interpolation_matrix_in(file_name.str(), mode);
 
  for (unsigned int i=0; i<n_bfs; i++)
    {
      for (unsigned int j=0; j<=i; j++)
        {
          Number value;
          interpolation_matrix_in >> value;
          interpolation_matrix(i,j) = value;
        }
    }
  interpolation_matrix_in.close();
 
  // Next read in interpolation_points
  file_name.str("");
  file_name << directory_name << "/interpolation_points" << suffix;
  assert_file_exists(file_name.str());
 
  Xdr interpolation_points_in(file_name.str(), mode);
 
  for (unsigned int i=0; i<n_bfs; i++)
    {
      Real x_val, y_val, z_val = 0.;
      interpolation_points_in >> x_val;
 
      if (LIBMESH_DIM >= 2)
        interpolation_points_in >> y_val;
 
      if (LIBMESH_DIM >= 3)
        interpolation_points_in >> z_val;
 
      Point p(x_val, y_val, z_val);
      interpolation_points.push_back(p);
    }
  interpolation_points_in.close();
 
  // Next read in interpolation_points_var
  file_name.str("");
  file_name << directory_name << "/interpolation_points_var" << suffix;
  assert_file_exists(file_name.str());
 
  Xdr interpolation_points_var_in(file_name.str(), mode);
 
  for (unsigned int i=0; i<n_bfs; i++)
    {
      unsigned int var;
      interpolation_points_var_in >> var;
      interpolation_points_var.push_back(var);
    }
  interpolation_points_var_in.close();
 
  // Read in the elements corresponding to the interpolation points
  legacy_read_in_interpolation_points_elem(directory_name);
}

References libMesh::RBEvaluation::assert_file_exists(), libMesh::DECODE, libMesh::RBEvaluation::get_n_basis_functions(), interpolation_matrix, interpolation_points, interpolation_points_var, legacy_read_in_interpolation_points_elem(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::READ, libMesh::Real, and value.

legacy_write_offline_data_to_files()

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

overridevirtual

Write out all the data to text files in order to segregate the Offline stage from the Online stage.

Note

This is a legacy method, use RBDataSerialization instead.

Reimplemented from libMesh::RBEvaluation.

Definition at line 225 of file rb_eim_evaluation.C.

{
  LOG_SCOPE("legacy_write_offline_data_to_files()", "RBEIMEvaluation");
 
  Parent::legacy_write_offline_data_to_files(directory_name);
 
  // Get the number of basis functions
  unsigned int n_bfs = get_n_basis_functions();
 
  // The writing mode: ENCODE for binary, WRITE for ASCII
  XdrMODE mode = read_binary_data ? ENCODE : WRITE;
 
  // The suffix to use for all the files that are written out
  const std::string suffix = read_binary_data ? ".xdr" : ".dat";
 
  if (this->processor_id() == 0)
    {
      std::ostringstream file_name;
 
      // Next write out the interpolation_matrix
      file_name.str("");
      file_name << directory_name << "/interpolation_matrix" << suffix;
      Xdr interpolation_matrix_out(file_name.str(), mode);
 
      for (unsigned int i=0; i<n_bfs; i++)
        {
          for (unsigned int j=0; j<=i; j++)
            {
              interpolation_matrix_out << interpolation_matrix(i,j);
            }
        }
 
      // Next write out interpolation_points
      file_name.str("");
      file_name << directory_name << "/interpolation_points" << suffix;
      Xdr interpolation_points_out(file_name.str(), mode);
 
      for (unsigned int i=0; i<n_bfs; i++)
        {
          interpolation_points_out << interpolation_points[i](0);
 
          if (LIBMESH_DIM >= 2)
            interpolation_points_out << interpolation_points[i](1);
 
          if (LIBMESH_DIM >= 3)
            interpolation_points_out << interpolation_points[i](2);
        }
      interpolation_points_out.close();
 
      // Next write out interpolation_points_var
      file_name.str("");
      file_name << directory_name << "/interpolation_points_var" << suffix;
      Xdr interpolation_points_var_out(file_name.str(), mode);
 
      for (unsigned int i=0; i<n_bfs; i++)
        {
          interpolation_points_var_out << interpolation_points_var[i];
        }
      interpolation_points_var_out.close();
    }
 
  // Write out the elements associated with the interpolation points.
  // This uses mesh I/O, hence we have to do it on all processors.
  legacy_write_out_interpolation_points_elem(directory_name);
}

References libMesh::ENCODE, libMesh::RBEvaluation::get_n_basis_functions(), interpolation_matrix, interpolation_points, interpolation_points_var, libMesh::RBEvaluation::legacy_write_offline_data_to_files(), legacy_write_out_interpolation_points_elem(), libMesh::ParallelObject::processor_id(), and libMesh::WRITE.

legacy_write_out_interpolation_points_elem()

void RBEIMEvaluation::legacy_write_out_interpolation_points_elem ( const std::string &  directory_name )

private

Write out interpolation_points_elem by putting the elements into a mesh and writing out the mesh.

Definition at line 292 of file rb_eim_evaluation.C.

{
  _interpolation_points_mesh.clear();
 
  // Maintain a set of node IDs to make sure we don't insert
  // the same node into _interpolation_points_mesh more than once
  std::set<dof_id_type> node_ids;
  std::map<dof_id_type, dof_id_type> node_id_map;
 
  unsigned int new_node_id = 0;
  for (const auto & old_elem : interpolation_points_elem)
      for (unsigned int n=0; n<old_elem->n_nodes(); n++)
        {
          Node & node_ref = old_elem->node_ref(n);
          dof_id_type old_node_id = node_ref.id();
 
          // Check if this node has already been added. This
          // could happen if some of the elements are neighbors.
          if (node_ids.find(old_node_id) == node_ids.end())
            {
              node_ids.insert(old_node_id);
              _interpolation_points_mesh.add_point(node_ref, new_node_id, /* proc_id */ 0);
 
              node_id_map[old_node_id] = new_node_id;
 
              new_node_id++;
            }
        }
 
  // Maintain a map of elem IDs to make sure we don't insert
  // the same elem into _interpolation_points_mesh more than once
  std::map<dof_id_type,dof_id_type> elem_id_map;
  std::vector<dof_id_type> interpolation_elem_ids(interpolation_points_elem.size());
  dof_id_type new_elem_id = 0;
  for (auto i : index_range(interpolation_elem_ids))
    {
      Elem * old_elem = interpolation_points_elem[i];
 
      dof_id_type old_elem_id = old_elem->id();
 
      // Only insert the element into the mesh if it hasn't already been inserted
      std::map<dof_id_type,dof_id_type>::iterator id_it = elem_id_map.find(old_elem_id);
      if (id_it == elem_id_map.end())
        {
          Elem * new_elem = Elem::build(old_elem->type(), /*parent*/ nullptr).release();
          new_elem->subdomain_id() = old_elem->subdomain_id();
 
          // Assign all the nodes
          for (unsigned int n=0; n<new_elem->n_nodes(); n++)
            {
              dof_id_type old_node_id = old_elem->node_id(n);
              new_elem->set_node(n) =
                _interpolation_points_mesh.node_ptr( node_id_map[old_node_id] );
            }
 
          // Just set all proc_ids to 0
          new_elem->processor_id() = 0;
 
          // Add the element to the mesh
          _interpolation_points_mesh.add_elem(new_elem);
 
          // Set the id of new_elem appropriately
          new_elem->set_id(new_elem_id);
          interpolation_elem_ids[i] = new_elem->id();
          elem_id_map[old_elem_id] = new_elem->id();
 
          new_elem_id++;
        }
      else
        {
          interpolation_elem_ids[i] = id_it->second;
        }
 
    }
 
  libmesh_assert(new_elem_id == _interpolation_points_mesh.n_elem());
 
  _interpolation_points_mesh.write(directory_name + "/interpolation_points_mesh.xda");
 
  // Also, write out the vector that tells us which element each entry
  // of interpolation_points_elem corresponds to. This allows us to handle
  // the case in which elements are repeated in interpolation_points_elem.
  if (processor_id() == 0)
    {
      // These are just integers, so no need for a binary format here
      std::ofstream interpolation_elem_ids_out
        ((directory_name + "/interpolation_elem_ids.dat").c_str(), std::ofstream::out);
 
      for (const auto & id : interpolation_elem_ids)
        interpolation_elem_ids_out << id << std::endl;
 
      interpolation_elem_ids_out.close();
    }
}

References _interpolation_points_mesh, libMesh::ReplicatedMesh::add_elem(), libMesh::ReplicatedMesh::add_point(), libMesh::Elem::build(), libMesh::ReplicatedMesh::clear(), libMesh::DofObject::id(), libMesh::index_range(), interpolation_points_elem, libMesh::libmesh_assert(), libMesh::ReplicatedMesh::n_elem(), libMesh::Elem::n_nodes(), libMesh::Elem::node_id(), libMesh::ReplicatedMesh::node_ptr(), libMesh::out, libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::DofObject::set_id(), libMesh::Elem::set_node(), libMesh::Elem::subdomain_id(), libMesh::Elem::type(), and libMesh::UnstructuredMesh::write().

Referenced by legacy_write_offline_data_to_files().

n_objects()

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

inlinestaticinherited

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

Definition at line 83 of file reference_counter.h.

  { return _n_objects; }

References libMesh::ReferenceCounter::_n_objects.

n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns

The number of processors in the group.

Definition at line 100 of file parallel_object.h.

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

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::DofMap::add_constraints_to_send_list(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::EnsightIO::EnsightIO(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::partition(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::prepare_send_list(), libMesh::DofMap::print_dof_constraints(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), libMesh::CheckpointIO::read_nodes(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::System::read_serialized_vector(), libMesh::DistributedMesh::renumber_dof_objects(), OverlappingFunctorTest::run_partitioner_test(), libMesh::DofMap::scatter_constraints(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), CheckpointIOTest::testSplitter(), WriteVecAndScalar::testWrite(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::VTKIO::write_nodal_data(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

print_discrete_parameter_values()

void libMesh::RBParametrized::print_discrete_parameter_values ( ) const

inherited

Print out all the discrete parameter values.

Definition at line 389 of file rb_parametrized.C.

{
  for (const auto & pr : get_discrete_parameter_values())
    {
      libMesh::out << "Discrete parameter " << pr.first << ", values: ";
 
      const std::vector<Real> & values = pr.second;
      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::RBSCMConstruction::print_info(), and libMesh::RBConstruction::print_info().

print_info()

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

staticinherited

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

Definition at line 87 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().

print_parameters()

void libMesh::RBParametrized::print_parameters ( ) const

inherited

Print the current parameters.

Definition at line 206 of file rb_parametrized.C.

{
  if (!parameters_initialized)
    libmesh_error_msg("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 libMesh::RBConstruction::train_reduced_basis().

processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns

The rank of this processor in the group.

Definition at line 106 of file parallel_object.h.

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

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::EquationSystems::_read_impl(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::ExodusII_IO_Helper::close(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::compute_communication_map_parameters(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_node_communication_maps(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::DistributedMesh::delete_elem(), libMesh::DistributedMesh::delete_node(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMap::end_dof(), libMesh::DofMap::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::RBEIMConstruction::evaluate_mesh_function(), libMesh::MeshFunction::find_element(), libMesh::MeshFunction::find_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMap::first_dof(), libMesh::DofMap::first_old_dof(), libMesh::Nemesis_IO_Helper::get_cmap_params(), libMesh::Nemesis_IO_Helper::get_eb_info_global(), libMesh::Nemesis_IO_Helper::get_elem_cmap(), libMesh::Nemesis_IO_Helper::get_elem_map(), libMesh::DofMap::get_info(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::DofMap::get_local_constraints(), libMesh::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), HeatSystem::init_data(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::DistributedMesh::insert_elem(), libMesh::DofMap::is_evaluable(), libMesh::SparsityPattern::Build::join(), libMesh::DofMap::last_dof(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), legacy_write_offline_data_to_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), legacy_write_out_interpolation_points_elem(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DofMap::local_variable_indices(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMap::n_local_dofs(), libMesh::System::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::SparsityPattern::Build::operator()(), libMesh::DistributedMesh::own_node(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::print_dof_constraints(), libMesh::Nemesis_IO_Helper::put_cmap_params(), libMesh::Nemesis_IO_Helper::put_elem_cmap(), libMesh::Nemesis_IO_Helper::put_elem_map(), libMesh::Nemesis_IO_Helper::put_loadbal_param(), libMesh::Nemesis_IO_Helper::put_node_cmap(), libMesh::Nemesis_IO_Helper::put_node_map(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::System::read_legacy_data(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::System::read_serialized_data(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::LaplaceMeshSmoother::smooth(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusCopyElementSolution(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), CheckpointIOTest::testSplitter(), WriteVecAndScalar::testWrite(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_element_values_element_major(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO::write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::System::write_header(), libMesh::ExodusII_IO::write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::VTKIO::write_nodal_data(), libMesh::UCDIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::RBEvaluation::write_out_vectors(), write_output_solvedata(), libMesh::System::write_parallel_data(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::System::write_serialized_data(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::System::write_serialized_vector(), libMesh::System::write_serialized_vectors(), libMesh::ExodusII_IO_Helper::write_sideset_data(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), libMesh::ExodusII_IO_Helper::write_timestep(), and libMesh::ExodusII_IO::write_timestep_discontinuous().

rb_solve() [1/2]

void RBEIMEvaluation::rb_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 RB_solution.

Definition at line 181 of file rb_eim_evaluation.C.

{
  LOG_SCOPE("rb_solve()", "RBEIMEvaluation");
 
  if (EIM_rhs.size() > get_n_basis_functions())
    libmesh_error_msg("ERROR: N cannot be larger than the number of basis functions in rb_solve");
 
  if (EIM_rhs.size()==0)
    libmesh_error_msg("ERROR: N must be greater than 0 in rb_solve");
 
  const unsigned int N = EIM_rhs.size();
  DenseMatrix<Number> interpolation_matrix_N;
  interpolation_matrix.get_principal_submatrix(N, interpolation_matrix_N);
 
  interpolation_matrix_N.lu_solve(EIM_rhs, RB_solution);
}

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

rb_solve() [2/2]

Real RBEIMEvaluation::rb_solve ( unsigned int  N )

overridevirtual

Calculate the EIM approximation to parametrized_function using the first N EIM basis functions.

Store the solution coefficients in the member RB_solution.

Returns

The EIM a posteriori error bound.

Reimplemented from libMesh::RBEvaluation.

Definition at line 113 of file rb_eim_evaluation.C.

{
  // Short-circuit if we are using the same parameters and value of N
  if ((_previous_parameters == get_parameters()) && (_previous_N == N))
    {
      return _previous_error_bound;
    }
 
  // Otherwise, update _previous parameters, _previous_N
  _previous_parameters = get_parameters();
  _previous_N = N;
 
  LOG_SCOPE("rb_solve()", "RBEIMEvaluation");
 
  if (N > get_n_basis_functions())
    libmesh_error_msg("ERROR: N cannot be larger than the number of basis functions in rb_solve");
 
  if (N==0)
    libmesh_error_msg("ERROR: N must be greater than 0 in rb_solve");
 
  // Get the rhs by sampling parametrized_function
  // at the first N interpolation_points
  DenseVector<Number> EIM_rhs(N);
  for (unsigned int i=0; i<N; i++)
    {
      EIM_rhs(i) = evaluate_parametrized_function(interpolation_points_var[i],
                                                  interpolation_points[i],
                                                  *interpolation_points_elem[i]);
    }
 
 
 
  DenseMatrix<Number> interpolation_matrix_N;
  interpolation_matrix.get_principal_submatrix(N, interpolation_matrix_N);
 
  interpolation_matrix_N.lu_solve(EIM_rhs, RB_solution);
 
  // Optionally evaluate an a posteriori error bound. The EIM error estimate
  // recommended in the literature is based on using "next" EIM point, so
  // we skip this if N == get_n_basis_functions()
  if (evaluate_RB_error_bound && (N != get_n_basis_functions()))
    {
      // Compute the a posteriori error bound
      // First, sample the parametrized function at x_{N+1}
      Number g_at_next_x = evaluate_parametrized_function(interpolation_points_var[N],
                                                          interpolation_points[N],
                                                          *interpolation_points_elem[N]);
 
      // Next, evaluate the EIM approximation at x_{N+1}
      Number EIM_approx_at_next_x = 0.;
      for (unsigned int j=0; j<N; j++)
        {
          EIM_approx_at_next_x += RB_solution(j) * interpolation_matrix(N,j);
        }
 
      Real error_estimate = std::abs(g_at_next_x - EIM_approx_at_next_x);
 
      _previous_error_bound = error_estimate;
      return error_estimate;
    }
  else // Don't evaluate an error bound
    {
      _previous_error_bound = -1.;
      return -1.;
    }
 
}

References _previous_error_bound, _previous_N, _previous_parameters, std::abs(), evaluate_parametrized_function(), libMesh::RBEvaluation::evaluate_RB_error_bound, libMesh::RBEvaluation::get_n_basis_functions(), libMesh::RBParametrized::get_parameters(), libMesh::DenseMatrix< T >::get_principal_submatrix(), interpolation_matrix, interpolation_points, interpolation_points_elem, interpolation_points_var, libMesh::DenseMatrix< T >::lu_solve(), libMesh::RBEvaluation::RB_solution, and libMesh::Real.

Referenced by libMesh::RBEIMConstruction::enrich_RB_space(), and libMesh::RBEIMTheta::evaluate().

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 340 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 libMesh::RBEvaluation::read_in_basis_functions ( System &  sys, const std::string &  directory_name = "offline_data", const bool  read_binary_basis_functions = true  )

virtualinherited

Read in all the basis functions from file.

Parameters

sys	Used for file IO.
directory_name	Specifies which directory to write files to.
read_binary_basis_functions	Indicates whether to expect binary or ASCII data.

Definition at line 958 of file rb_evaluation.C.

{
  LOG_SCOPE("read_in_basis_functions()", "RBEvaluation");
 
  read_in_vectors(sys,
                  basis_functions,
                  directory_name,
                  "bf",
                  read_binary_basis_functions);
}

References libMesh::RBEvaluation::basis_functions, and libMesh::RBEvaluation::read_in_vectors().

read_in_vectors()

void libMesh::RBEvaluation::read_in_vectors ( System &  sys, std::vector< std::unique_ptr< NumericVector< Number >>> &  vectors, const std::string &  directory_name, const std::string &  data_name, const bool  read_binary_vectors  )

inherited

Same as read_in_basis_functions, except in this case we pass in the vectors to be written.

We assume that the size of vectors indicates the number of vectors that need to be read in.

Definition at line 971 of file rb_evaluation.C.

{
  std::vector<std::vector<std::unique_ptr<NumericVector<Number>>> *> vectors_vec;
  vectors_vec.push_back(&vectors);
 
  std::vector<std::string> directory_name_vec;
  directory_name_vec.push_back(directory_name);
 
  std::vector<std::string> data_name_vec;
  data_name_vec.push_back(data_name);
 
  read_in_vectors_from_multiple_files(sys,
                                      vectors_vec,
                                      directory_name_vec,
                                      data_name_vec,
                                      read_binary_vectors);
}

References libMesh::RBEvaluation::read_in_vectors_from_multiple_files().

Referenced by libMesh::RBEvaluation::read_in_basis_functions().

read_in_vectors_from_multiple_files()

void libMesh::RBEvaluation::read_in_vectors_from_multiple_files ( System &  sys, std::vector< std::vector< std::unique_ptr< NumericVector< Number >>> * >  multiple_vectors, const std::vector< std::string > &  multiple_directory_names, const std::vector< std::string > &  multiple_data_names, const bool  read_binary_vectors  )

inherited

Performs read_in_vectors for a list of directory names and data names.

Reading in vectors requires us to renumber the dofs in a partition-independent way. This function only renumbers the dofs once at the start (and reverts it at the end), which can save a lot of work compared to renumbering on every read.

Definition at line 993 of file rb_evaluation.C.

{
  LOG_SCOPE("read_in_vectors_from_multiple_files()", "RBEvaluation");
 
  std::size_t n_files = multiple_vectors.size();
  std::size_t n_directories = multiple_directory_names.size();
  libmesh_assert((n_files == n_directories) && (n_files == multiple_data_names.size()));
 
  if (n_files == 0)
    return;
 
  // Make sure processors are synced up before we begin
  this->comm().barrier();
 
  std::ostringstream file_name;
  const std::string basis_function_suffix = (read_binary_vectors ? ".xdr" : ".dat");
 
  // Following EquationSystemsIO::read, we use a temporary numbering (node major)
  // before writing out the data. For the sake of efficiency, we do this once for
  // all the vectors that we read in.
  MeshTools::Private::globally_renumber_nodes_and_elements(sys.get_mesh());
 
  for (std::size_t data_index=0; data_index<n_directories; data_index++)
    {
      std::vector<std::unique_ptr<NumericVector<Number>>> & vectors = *multiple_vectors[data_index];
 
      // Allocate storage for each vector
      for (auto & vec : vectors)
        {
          // vectors should all be nullptr, otherwise we get a memory leak when
          // we create the new vectors in RBEvaluation::read_in_vectors.
          if (vec)
            libmesh_error_msg("Non-nullptr vector passed to read_in_vectors_from_multiple_files");
 
          vec = NumericVector<Number>::build(sys.comm());
 
          vec->init (sys.n_dofs(),
                     sys.n_local_dofs(),
                     false,
                     PARALLEL);
        }
 
      file_name.str("");
      file_name << multiple_directory_names[data_index]
                << "/" << multiple_data_names[data_index]
                << "_data" << basis_function_suffix;
 
      // On processor zero check to be sure the file exists
      if (this->processor_id() == 0)
        {
          struct stat stat_info;
          int stat_result = stat(file_name.str().c_str(), &stat_info);
 
          if (stat_result != 0)
            libmesh_error_msg("File does not exist: " << file_name.str());
        }
 
      assert_file_exists(file_name.str());
      Xdr vector_data(file_name.str(),
                      read_binary_vectors ? DECODE : READ);
 
      // Read the header data. This block of code is based on EquationSystems::_read_impl.
      {
        std::string version;
        vector_data.data(version);
 
        const std::string libMesh_label = "libMesh-";
        std::string::size_type lm_pos = version.find(libMesh_label);
        if (lm_pos==std::string::npos)
          libmesh_error_msg("version info missing in Xdr header");
 
        std::istringstream iss(version.substr(lm_pos + libMesh_label.size()));
        int ver_major = 0, ver_minor = 0, ver_patch = 0;
        char dot;
        iss >> ver_major >> dot >> ver_minor >> dot >> ver_patch;
        vector_data.set_version(LIBMESH_VERSION_ID(ver_major, ver_minor, ver_patch));
 
        // Actually read the header data. When we do this, set read_header=false
        // so taht we do not reinit sys, since we assume that it has already been
        // set up properly (e.g. the appropriate variables have already been added).
        sys.read_header(vector_data, version, /*read_header=*/false, /*read_additional_data=*/false);
      }
 
      // Comply with the System::read_serialized_vectors() interface which uses dumb pointers.
      std::vector<NumericVector<Number> *> vec_in;
      for (auto & vec : vectors)
        vec_in.push_back(vec.get());
 
      sys.read_serialized_vectors (vector_data, vec_in);
    }
 
  // Undo the temporary renumbering
  sys.get_mesh().fix_broken_node_and_element_numbering();
}

References libMesh::RBEvaluation::assert_file_exists(), libMesh::NumericVector< T >::build(), libMesh::ParallelObject::comm(), libMesh::Xdr::data(), libMesh::DECODE, libMesh::MeshBase::fix_broken_node_and_element_numbering(), libMesh::System::get_mesh(), libMesh::MeshTools::Private::globally_renumber_nodes_and_elements(), libMesh::libmesh_assert(), libMesh::System::n_dofs(), libMesh::System::n_local_dofs(), libMesh::PARALLEL, libMesh::ParallelObject::processor_id(), libMesh::READ, libMesh::System::read_header(), and libMesh::System::read_serialized_vectors().

Referenced by libMesh::RBEvaluation::read_in_vectors().

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

residual_scaling_denom()

Real libMesh::RBEvaluation::residual_scaling_denom ( Real  alpha_LB )

virtualinherited

Specifies the residual scaling on the denominator to be used in the a posteriori error bound.

Override in subclass in order to obtain the desired error bound.

Definition at line 385 of file rb_evaluation.C.

{
  // Here we implement the residual scaling for a coercive
  // problem.
  return alpha_LB;
}

Referenced by libMesh::TransientRBEvaluation::rb_solve(), and libMesh::RBEvaluation::rb_solve().

resize_data_structures()

void RBEIMEvaluation::resize_data_structures ( const unsigned int  Nmax, bool  resize_error_bound_data = true  )

overridevirtual

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

Reimplemented from libMesh::RBEvaluation.

Definition at line 75 of file rb_eim_evaluation.C.

{
  Parent::resize_data_structures(Nmax, resize_error_bound_data);
 
  // Resize the data structures relevant to the EIM system
  interpolation_points.clear();
  interpolation_points_var.clear();
  interpolation_points_elem.clear();
  interpolation_matrix.resize(Nmax,Nmax);
}

References interpolation_matrix, interpolation_points, interpolation_points_elem, interpolation_points_var, libMesh::DenseMatrix< T >::resize(), and libMesh::RBEvaluation::resize_data_structures().

set_n_basis_functions()

void libMesh::RBEvaluation::set_n_basis_functions ( unsigned int  n_bfs )

virtualinherited

Set the number of basis functions.

Useful when reading in stored data.

Definition at line 78 of file rb_evaluation.C.

{
  basis_functions.resize(n_bfs);
}

References libMesh::RBEvaluation::basis_functions.

Referenced by libMesh::RBEvaluation::clear(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), and libMesh::RBDataDeserialization::load_rb_evaluation_data().

set_parameters()

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

inherited

Set the current parameters to params.

Definition at line 155 of file rb_parametrized.C.

{
  if (!parameters_initialized)
    libmesh_error_msg("Error: parameters not initialized in RBParametrized::set_current_parameters");
 
  valid_params(params); // Terminates if params has the wrong number of parameters
 
  // Make a copy of params (default assignment operator just does memberwise copy, which is sufficient here)
  this->parameters = params;
}

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

Referenced by libMesh::RBEIMConstruction::compute_best_fit_error(), libMesh::RBSCMConstruction::compute_SCM_bounds_on_training_set(), libMesh::RBEIMConstruction::enrich_RB_space(), libMesh::RBEIMTheta::evaluate(), libMesh::RBConstruction::get_RB_error_bound(), SimpleRBEvaluation::get_stability_lower_bound(), libMesh::RBParametrized::initialize_parameters(), libMesh::RBSCMEvaluation::reload_current_parameters(), libMesh::RBSCMEvaluation::set_current_parameters_from_C_J(), and libMesh::RBEIMConstruction::truth_solve().

set_rb_theta_expansion()

void libMesh::RBEvaluation::set_rb_theta_expansion ( RBThetaExpansion &  rb_theta_expansion_in )

inherited

Set the RBThetaExpansion object.

Definition at line 83 of file rb_evaluation.C.

{
  rb_theta_expansion = &rb_theta_expansion_in;
}

References libMesh::RBEvaluation::rb_theta_expansion.

Referenced by RBEIMEvaluation(), and SimpleRBEvaluation::SimpleRBEvaluation().

valid_params()

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

privateinherited

Helper function to check that params is valid.

Definition at line 402 of file rb_parametrized.C.

{
  if (params.n_parameters() != get_n_params())
    libmesh_error_msg("Error: Number of parameters don't match");
 
  else
    {
      bool valid = true;
      for (const auto & pr : params)
        {
          const std::string & param_name = pr.first;
          valid = valid && ( (get_parameter_min(param_name) <= params.get_value(param_name)) &&
                             (params.get_value(param_name) <= get_parameter_max(param_name)) );
 
          if (is_discrete_parameter(param_name))
            {
              // make sure params.get_value(param_name) is sufficiently close
              // to one of the discrete parameter values
              valid = valid && is_value_in_list(params.get_value(param_name),
                                                get_discrete_parameter_values().find(param_name)->second,
                                                TOLERANCE);
            }
        }
 
      if (!valid && verbose_mode)
        libMesh::out << "Warning: parameter is outside parameter range" << std::endl;
 
      return valid;
    }
}

References libMesh::RBParametrized::get_discrete_parameter_values(), libMesh::RBParametrized::get_n_params(), libMesh::RBParametrized::get_parameter_max(), libMesh::RBParametrized::get_parameter_min(), libMesh::RBParametrized::is_discrete_parameter(), libMesh::RBParametrized::is_value_in_list(), libMesh::RBParameters::n_parameters(), libMesh::out, libMesh::TOLERANCE, libMesh::Quality::valid(), and libMesh::RBParametrized::verbose_mode.

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

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 255 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;
 
      for (const auto & pr : get_discrete_parameter_values())
        {
          std::string param_name = pr.first;
          unsigned int 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 libMesh::RBEvaluation::write_out_basis_functions ( System &  sys, const std::string &  directory_name = "offline_data", const bool  write_binary_basis_functions = true  )

virtualinherited

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 expect binary or ASCII data

Definition at line 880 of file rb_evaluation.C.

{
  LOG_SCOPE("write_out_basis_functions()", "RBEvaluation");
 
  std::vector<NumericVector<Number>*> basis_functions_ptrs;
  for(std::size_t i=0; i<basis_functions.size(); i++)
  {
    basis_functions_ptrs.push_back(basis_functions[i].get());
  }
 
  write_out_vectors(sys,
                    basis_functions_ptrs,
                    directory_name,
                    "bf",
                    write_binary_basis_functions);
}

References libMesh::RBEvaluation::basis_functions, libMesh::ReferenceElem::get(), and libMesh::RBEvaluation::write_out_vectors().

Referenced by main().

write_out_vectors()

void libMesh::RBEvaluation::write_out_vectors ( System &  sys, std::vector< NumericVector< Number > * > &  vectors, const std::string &  directory_name = "offline_data", const std::string &  data_name = "bf", const bool  write_binary_basis_functions = true  )

virtualinherited

Same as write_out_basis_functions, except in this case we pass in the vectors to be written.

Definition at line 899 of file rb_evaluation.C.

{
  LOG_SCOPE("write_out_vectors()", "RBEvaluation");
 
  if (this->processor_id() == 0)
    {
      // Make a directory to store all the data files
      Utility::mkdir(directory_name.c_str());
    }
 
  // Make sure processors are synced up before we begin
  this->comm().barrier();
 
  std::ostringstream file_name;
  const std::string basis_function_suffix = (write_binary_vectors ? ".xdr" : ".dat");
 
  file_name << directory_name << "/" << data_name << "_data" << basis_function_suffix;
  Xdr bf_data(file_name.str(),
              write_binary_vectors ? ENCODE : WRITE);
 
  std::string version("libMesh-" + libMesh::get_io_compatibility_version());
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
  version += " with infinite elements";
#endif
  bf_data.data(version ,"# File Format Identifier");
 
  sys.write_header(bf_data, /*(unused arg)*/ version, /*write_additional_data=*/false);
 
  // Following EquationSystemsIO::write, we use a temporary numbering (node major)
  // before writing out the data
  MeshTools::Private::globally_renumber_nodes_and_elements(sys.get_mesh());
 
  // Write all vectors at once.
  {
    // Note the API wants pointers to constant vectors, hence this...
    std::vector<const NumericVector<Number> *> bf_out;
    for (const auto & vec : vectors)
      bf_out.push_back(vec);
 
    // for (auto & val : vectors)
    //   bf_out.push_back(val);
    sys.write_serialized_vectors (bf_data, bf_out);
  }
 
 
  // set the current version
  bf_data.set_version(LIBMESH_VERSION_ID(LIBMESH_MAJOR_VERSION,
                                         LIBMESH_MINOR_VERSION,
                                         LIBMESH_MICRO_VERSION));
 
 
  // Undo the temporary renumbering
  sys.get_mesh().fix_broken_node_and_element_numbering();
}

References libMesh::ParallelObject::comm(), libMesh::ENCODE, libMesh::MeshBase::fix_broken_node_and_element_numbering(), libMesh::get_io_compatibility_version(), libMesh::System::get_mesh(), libMesh::MeshTools::Private::globally_renumber_nodes_and_elements(), libMesh::Utility::mkdir(), libMesh::ParallelObject::processor_id(), libMesh::WRITE, libMesh::System::write_header(), and libMesh::System::write_serialized_vectors().

Referenced by libMesh::RBEvaluation::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 214 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 222 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;
 
  for (const auto & pr : get_parameters_min())
    {
      std::string param_name = pr.first;
      if (!is_discrete_parameter(param_name))
        {
          Real param_value = pr.second;
          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 = pr.second;
          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::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 112 of file parallel_object.h.

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

_counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 122 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info(), libMesh::ReferenceCounter::increment_constructor_count(), and libMesh::ReferenceCounter::increment_destructor_count().

_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 235 of file rb_parametrized.h.

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

_empty_rb_theta_expansion

RBThetaExpansion libMesh::RBEIMEvaluation::_empty_rb_theta_expansion

private

We initialize RBEIMEvaluation so that it has an "empty" RBThetaExpansion, because this isn't used at all in the EIM.

Definition at line 225 of file rb_eim_evaluation.h.

Referenced by RBEIMEvaluation().

_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 141 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info(), and libMesh::ReferenceCounter::print_info().

_interpolation_points_mesh

ReplicatedMesh libMesh::RBEIMEvaluation::_interpolation_points_mesh

private

Mesh object that we use to store copies of the elements associated with interpolation points.

Definition at line 249 of file rb_eim_evaluation.h.

Referenced by clear(), get_interpolation_points_mesh(), legacy_read_in_interpolation_points_elem(), legacy_write_out_interpolation_points_elem(), and RBEIMEvaluation().

_mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 135 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 130 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::n_objects(), libMesh::ReferenceCounter::ReferenceCounter(), and libMesh::ReferenceCounter::~ReferenceCounter().

_parametrized_functions

std::vector<RBParametrizedFunction *> libMesh::RBEIMEvaluation::_parametrized_functions

private

This vector stores the parametrized functions that will be approximated in this EIM system.

Definition at line 213 of file rb_eim_evaluation.h.

Referenced by attach_parametrized_function(), evaluate_parametrized_function(), and get_n_parametrized_functions().

_previous_error_bound

Real libMesh::RBEIMEvaluation::_previous_error_bound

private

Store the previous error bound returned by rb_solve (so we can return it if we are avoiding an unnecessary repeat solve).

Definition at line 243 of file rb_eim_evaluation.h.

Referenced by rb_solve().

_previous_N

unsigned int libMesh::RBEIMEvaluation::_previous_N

private

Store the number of basis functions used for the previous solve (so we can avoid an unnecessary repeat solve).

Definition at line 237 of file rb_eim_evaluation.h.

Referenced by rb_solve().

_previous_parameters

RBParameters libMesh::RBEIMEvaluation::_previous_parameters

private

Store the parameters at which the previous solve was performed (so we can avoid an unnecessary repeat solve).

Definition at line 231 of file rb_eim_evaluation.h.

Referenced by rb_solve().

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

Referenced by clear(), get_eim_theta_objects(), and initialize_eim_theta_objects().

Aq_Aq_representor_innerprods

std::vector<std::vector<std::vector<Number> > > libMesh::RBEvaluation::Aq_Aq_representor_innerprods

inherited

Definition at line 300 of file rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_rb_evaluation_data_to_builder(), libMesh::TransientRBEvaluation::cache_online_residual_terms(), libMesh::RBEvaluation::compute_residual_dual_norm(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_rb_evaluation_data(), libMesh::RBEvaluation::resize_data_structures(), libMesh::TransientRBEvaluation::uncached_compute_residual_dual_norm(), and libMesh::RBConstruction::update_residual_terms().

Aq_representor

std::vector<std::vector<std::unique_ptr<NumericVector<Number> > > > libMesh::RBEvaluation::Aq_representor

inherited

Vector storing the residual representors associated with the left-hand side.

These are basis dependent and hence stored here, whereas the Fq_representors are stored in RBSystem.

Definition at line 316 of file rb_evaluation.h.

Referenced by libMesh::RBEvaluation::clear_riesz_representors(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::RBEvaluation::resize_data_structures(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), and libMesh::RBConstruction::write_riesz_representors_to_files().

basis_functions

std::vector<std::unique_ptr<NumericVector<Number> > > libMesh::RBEvaluation::basis_functions

inherited

The libMesh vectors storing the finite element coefficients of the RB basis functions.

Definition at line 241 of file rb_evaluation.h.

Referenced by libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::RBEvaluation::clear(), libMesh::RBEIMConstruction::enrich_RB_space(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::RBConstruction::enrich_RB_space(), libMesh::RBEvaluation::get_basis_function(), libMesh::RBEvaluation::get_n_basis_functions(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::RBEvaluation::read_in_basis_functions(), libMesh::RBEvaluation::set_n_basis_functions(), and libMesh::RBEvaluation::write_out_basis_functions().

compute_RB_inner_product

bool libMesh::RBEvaluation::compute_RB_inner_product

inherited

Boolean flag to indicate whether we compute the RB_inner_product_matrix.

Definition at line 327 of file rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_rb_evaluation_data_to_builder(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_rb_evaluation_data(), RBEIMEvaluation(), libMesh::RBEvaluation::resize_data_structures(), and libMesh::TransientRBEvaluation::TransientRBEvaluation().

evaluate_RB_error_bound

bool libMesh::RBEvaluation::evaluate_RB_error_bound

inherited

Boolean to indicate whether we evaluate a posteriori error bounds when rb_solve is called.

Definition at line 322 of file rb_evaluation.h.

Referenced by libMesh::RBEIMConstruction::compute_best_fit_error(), libMesh::TransientRBEvaluation::rb_solve(), libMesh::RBEvaluation::rb_solve(), and rb_solve().

Fq_Aq_representor_innerprods

std::vector<std::vector<std::vector<Number> > > libMesh::RBEvaluation::Fq_Aq_representor_innerprods

inherited

Vectors storing the residual representor inner products to be used in computing the residuals online.

We store the Aq-dependent representor inner products because they depend on a reduced basis space. The basis independent representors are stored in RBSystem.

Definition at line 299 of file rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_rb_evaluation_data_to_builder(), libMesh::TransientRBEvaluation::cache_online_residual_terms(), libMesh::RBEvaluation::compute_residual_dual_norm(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_rb_evaluation_data(), libMesh::RBEvaluation::resize_data_structures(), libMesh::TransientRBEvaluation::uncached_compute_residual_dual_norm(), and libMesh::RBConstruction::update_residual_terms().

Fq_representor_innerprods

std::vector<Number> libMesh::RBEvaluation::Fq_representor_innerprods

inherited

Vectors storing the residual representor inner products to be used in computing the residuals online.

These values are independent of a basis, hence they can be copied over directly from an RBSystem.

Definition at line 290 of file rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_rb_evaluation_data_to_builder(), libMesh::TransientRBEvaluation::cache_online_residual_terms(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBEvaluation::compute_residual_dual_norm(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_rb_evaluation_data(), libMesh::RBEvaluation::resize_data_structures(), and libMesh::TransientRBEvaluation::uncached_compute_residual_dual_norm().

greedy_param_list

std::vector<RBParameters> libMesh::RBEvaluation::greedy_param_list

inherited

The list of parameters selected by the Greedy algorithm in generating the Reduced Basis associated with this RBEvaluation object.

Definition at line 247 of file rb_evaluation.h.

Referenced by libMesh::RBEvaluation::clear(), libMesh::RBConstruction::get_greedy_parameter(), libMesh::RBConstruction::greedy_termination_test(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBConstruction::train_reduced_basis(), and libMesh::RBConstruction::update_greedy_param_list().

interpolation_matrix

DenseMatrix<Number> libMesh::RBEIMEvaluation::interpolation_matrix

Dense matrix that stores the lower triangular interpolation matrix that can be used.

Definition at line 176 of file rb_eim_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder(), legacy_read_offline_data_from_files(), legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_rb_eim_evaluation_data(), rb_solve(), resize_data_structures(), and libMesh::RBEIMConstruction::update_RB_system_matrices().

interpolation_points

std::vector<Point> libMesh::RBEIMEvaluation::interpolation_points

The list of interpolation points, i.e.

locations at which the basis functions are maximized.

Definition at line 182 of file rb_eim_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder(), clear(), libMesh::RBEIMConstruction::enrich_RB_space(), legacy_read_offline_data_from_files(), legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_rb_eim_evaluation_data(), rb_solve(), resize_data_structures(), and libMesh::RBEIMConstruction::update_RB_system_matrices().

interpolation_points_elem

std::vector<Elem *> libMesh::RBEIMEvaluation::interpolation_points_elem

The corresponding list of elements at which the interpolation points were identified.

Definition at line 194 of file rb_eim_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder(), clear(), libMesh::RBEIMConstruction::enrich_RB_space(), legacy_read_in_interpolation_points_elem(), legacy_write_out_interpolation_points_elem(), libMesh::RBDataDeserialization::load_rb_eim_evaluation_data(), rb_solve(), and resize_data_structures().

interpolation_points_var

std::vector<unsigned int> libMesh::RBEIMEvaluation::interpolation_points_var

The corresponding list of variables indices at which the interpolation points were identified.

Definition at line 188 of file rb_eim_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_rb_eim_evaluation_data_to_builder(), clear(), libMesh::RBEIMConstruction::enrich_RB_space(), legacy_read_offline_data_from_files(), legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_rb_eim_evaluation_data(), rb_solve(), resize_data_structures(), and libMesh::RBEIMConstruction::update_RB_system_matrices().

output_dual_innerprods

std::vector<std::vector<Number > > libMesh::RBEvaluation::output_dual_innerprods

inherited

The vector storing the dual norm inner product terms for each output.

These values are independent of a basis, hence they can be copied over directly from an RBSystem.

Definition at line 308 of file rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_rb_evaluation_data_to_builder(), libMesh::RBConstruction::compute_output_dual_innerprods(), libMesh::RBEvaluation::eval_output_dual_norm(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_rb_evaluation_data(), and libMesh::RBEvaluation::resize_data_structures().

parameters

RBParameters libMesh::RBParametrized::parameters

privateinherited

Vector storing the current parameters.

Definition at line 224 of file rb_parametrized.h.

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

parameters_initialized

bool libMesh::RBParametrized::parameters_initialized

privateinherited

Flag indicating whether the parameters have been initialized.

Definition at line 219 of file rb_parametrized.h.

Referenced by libMesh::RBParametrized::clear(), libMesh::RBParametrized::get_discrete_parameter_values(), libMesh::RBParametrized::get_n_continuous_params(), libMesh::RBParametrized::get_n_discrete_params(), libMesh::RBParametrized::get_n_params(), libMesh::RBParametrized::get_parameter_max(), libMesh::RBParametrized::get_parameter_min(), libMesh::RBParametrized::get_parameter_names(), libMesh::RBParametrized::get_parameters(), libMesh::RBParametrized::get_parameters_max(), libMesh::RBParametrized::get_parameters_min(), libMesh::RBParametrized::initialize_parameters(), libMesh::RBParametrized::is_discrete_parameter(), libMesh::RBParametrized::print_parameters(), and libMesh::RBParametrized::set_parameters().

parameters_max

RBParameters libMesh::RBParametrized::parameters_max

privateinherited

Definition at line 230 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(), libMesh::RBParametrized::initialize_parameters(), and libMesh::RBParametrized::RBParametrized().

parameters_min

RBParameters libMesh::RBParametrized::parameters_min

privateinherited

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

Definition at line 229 of file rb_parametrized.h.

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

RB_Aq_vector

std::vector<DenseMatrix<Number> > libMesh::RBEvaluation::RB_Aq_vector

inherited

Dense matrices for the RB computations.

Definition at line 260 of file rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_rb_evaluation_data_to_builder(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_rb_evaluation_data(), libMesh::TransientRBEvaluation::rb_solve(), libMesh::RBEvaluation::rb_solve(), libMesh::RBEvaluation::resize_data_structures(), and libMesh::RBConstruction::update_RB_system_matrices().

RB_Fq_vector

std::vector<DenseVector<Number> > libMesh::RBEvaluation::RB_Fq_vector

inherited

Dense vector for the RHS.

Definition at line 265 of file rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_rb_evaluation_data_to_builder(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_rb_evaluation_data(), libMesh::TransientRBEvaluation::rb_solve(), libMesh::RBEvaluation::rb_solve(), libMesh::RBEvaluation::resize_data_structures(), and libMesh::RBConstruction::update_RB_system_matrices().

RB_inner_product_matrix

DenseMatrix<Number> libMesh::RBEvaluation::RB_inner_product_matrix

inherited

The inner product matrix.

This should be close to the identity, we need to calculate this rather than assume diagonality in order to accurately perform projections since orthogonality degrades with increasing N.

Definition at line 255 of file rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_rb_evaluation_data_to_builder(), libMesh::RBEIMConstruction::compute_best_fit_error(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_rb_evaluation_data(), libMesh::RBEvaluation::resize_data_structures(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::RBEIMConstruction::update_RB_system_matrices(), and libMesh::RBConstruction::update_RB_system_matrices().

RB_output_error_bounds

std::vector<Real > libMesh::RBEvaluation::RB_output_error_bounds

inherited

Definition at line 282 of file rb_evaluation.h.

Referenced by libMesh::RBEvaluation::rb_solve(), and libMesh::RBEvaluation::resize_data_structures().

RB_output_vectors

std::vector<std::vector<DenseVector<Number> > > libMesh::RBEvaluation::RB_output_vectors

inherited

The vectors storing the RB output vectors.

Definition at line 275 of file rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_rb_evaluation_data_to_builder(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_rb_evaluation_data(), libMesh::TransientRBEvaluation::rb_solve(), libMesh::RBEvaluation::rb_solve(), libMesh::RBEvaluation::resize_data_structures(), and libMesh::RBConstruction::update_RB_system_matrices().

RB_outputs

std::vector<Number > libMesh::RBEvaluation::RB_outputs

inherited

The vectors storing the RB output values and corresponding error bounds.

Definition at line 281 of file rb_evaluation.h.

Referenced by libMesh::RBEvaluation::rb_solve(), and libMesh::RBEvaluation::resize_data_structures().

RB_solution

DenseVector<Number> libMesh::RBEvaluation::RB_solution

inherited

The RB solution vector.

Definition at line 270 of file rb_evaluation.h.

Referenced by libMesh::RBEIMConstruction::compute_best_fit_error(), libMesh::TransientRBEvaluation::compute_residual_dual_norm(), libMesh::RBEvaluation::compute_residual_dual_norm(), libMesh::RBEIMConstruction::enrich_RB_space(), libMesh::RBEIMTheta::evaluate(), libMesh::RBEIMConstruction::load_rb_solution(), libMesh::RBConstruction::load_rb_solution(), libMesh::TransientRBEvaluation::rb_solve(), libMesh::RBEvaluation::rb_solve(), rb_solve(), libMesh::TransientRBEvaluation::rb_solve_again(), and libMesh::TransientRBEvaluation::uncached_compute_residual_dual_norm().

rb_theta_expansion

RBThetaExpansion* libMesh::RBEvaluation::rb_theta_expansion

privateinherited

A pointer to to the object that stores the theta expansion.

This is not a std::unique_ptr since we may want to share it.

Note

A shared_ptr would be a good option here.

Definition at line 344 of file rb_evaluation.h.

Referenced by libMesh::RBEvaluation::compute_residual_dual_norm(), libMesh::RBEvaluation::eval_output_dual_norm(), libMesh::RBEvaluation::get_rb_theta_expansion(), libMesh::RBEvaluation::is_rb_theta_expansion_initialized(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEvaluation::rb_solve(), libMesh::RBEvaluation::resize_data_structures(), and libMesh::RBEvaluation::set_rb_theta_expansion().

verbose_mode

bool libMesh::RBParametrized::verbose_mode

inherited

Public boolean to toggle verbose mode.

Definition at line 170 of file rb_parametrized.h.

Referenced by libMesh::RBParametrized::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