ElasticityRBEvaluation Class Reference

#include <rb_classes.h>

Inheritance diagram for ElasticityRBEvaluation:

Public Member Functions
	ElasticityRBEvaluation (const Parallel::Communicator &comm)
	Constructor. More...
virtual Real	get_stability_lower_bound ()
	Return a "dummy" lower bound for the coercivity constant. More...
virtual void	clear () override
	Clear this RBEvaluation object. 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...
const RBThetaExpansion &	get_rb_theta_expansion () const
bool	is_rb_theta_expansion_initialized () const
virtual void	resize_data_structures (const unsigned int Nmax, bool resize_error_bound_data=true)
	Resize and clear the data vectors corresponding to the value of Nmax. More...
NumericVector< Number > &	get_basis_function (unsigned int i)
	Get a reference to the i^th basis function. More...
const NumericVector< Number > &	get_basis_function (unsigned int i) const
virtual Real	rb_solve (unsigned int N)
	Perform online solve with the N RB basis functions, for the set of parameters in current_params, where 0 <= N <= RB_size. More...
virtual Real	rb_solve (unsigned int N, const std::vector< Number > *evaluated_thetas)
	The same as above, except that we pass in evaluated_thetas instead of recomputing the theta values. More...
virtual Real	get_error_bound_normalization ()
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	compute_residual_dual_norm (const unsigned int N, const std::vector< Number > *evaluated_thetas)
	The same as above, except that we pass in evaluated thetas instead of recomputing the theta values. 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...
Real	eval_output_dual_norm (unsigned int n, const std::vector< Number > *evaluated_thetas)
	Evaluate the dual norm of output n for the current parameters, or using the pre-evaluted theta values provided in the "evaluated_thetas" array. 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	legacy_write_offline_data_to_files (const std::string &directory_name="offline_data", const bool write_binary_data=true)
	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)
	Read in the saved Offline reduced basis data to initialize the system for Online solves. 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	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	initialize_parameters (const RBParameters &mu_min_in, const RBParameters &mu_max_in, const std::map< std::string, std::vector< Real >> &discrete_parameter_values)
	Initialize the parameter ranges and set current_parameters. More...
void	initialize_parameters (const RBParametrized &rb_parametrized)
	Initialize the parameter ranges and set current_parameters. More...
unsigned int	get_n_params () const
	Get the number of parameters. More...
unsigned int	get_n_continuous_params () const
	Get the number of continuous parameters. More...
unsigned int	get_n_discrete_params () const
	Get the number of discrete parameters. More...
std::set< std::string >	get_parameter_names () const
	Get a set that stores the parameter names. More...
const RBParameters &	get_parameters () const
	Get the current parameters. More...
bool	set_parameters (const RBParameters &params)
	Set the current parameters to params The parameters are checked for validity; an error is thrown if the number of parameters or samples is different than expected. More...
const RBParameters &	get_parameters_min () const
	Get an RBParameters object that specifies the minimum allowable value for each parameter. More...
const RBParameters &	get_parameters_max () const
	Get an RBParameters object that specifies the maximum allowable value for each parameter. More...
Real	get_parameter_min (const std::string &param_name) const
	Get minimum allowable value of parameter param_name. More...
Real	get_parameter_max (const std::string &param_name) const
	Get maximum allowable value of parameter param_name. More...
void	print_parameters () const
	Print the current parameters. More...
void	write_parameter_data_to_files (const std::string &continuous_param_file_name, const std::string &discrete_param_file_name, const bool write_binary_data)
	Write out the parameter ranges to files. More...
void	read_parameter_data_from_files (const std::string &continuous_param_file_name, const std::string &discrete_param_file_name, const bool read_binary_data)
	Read in the parameter ranges from files. More...
bool	is_discrete_parameter (const std::string &mu_name) const
	Is parameter mu_name discrete? More...
const std::map< std::string, std::vector< Real > > &	get_discrete_parameter_values () const
	Get a const reference to the discrete parameter values. More...
void	print_discrete_parameter_values () const
	Print out all the discrete parameter values. More...
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

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

Public Attributes
ElasticityThetaExpansion	elasticity_theta_expansion
	The object that stores the "theta" expansion of the parameter dependent PDE, i.e. 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	increment_constructor_count (const std::string &name) noexcept
	Increments the construction counter. More...
void	increment_destructor_count (const std::string &name) noexcept
	Increments the destruction counter. More...

Static Protected Member Functions
static void	assert_file_exists (const std::string &file_name)
	Helper function that checks if file_name exists. 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...

Detailed Description

Definition at line 19 of file rb_classes.h.

Member Typedef Documentation

Counts

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

protectedinherited

Data structure to log the information.

The log is identified by the class name.

Definition at line 119 of file reference_counter.h.

Constructor & Destructor Documentation

ElasticityRBEvaluation()

ElasticityRBEvaluation::ElasticityRBEvaluation ( const Parallel::Communicator &  comm )

inline

Constructor.

Just set the theta expansion.

Definition at line 26 of file rb_classes.h.

    : RBEvaluation(comm)
  {
    set_rb_theta_expansion(elasticity_theta_expansion);
  }

Member Function Documentation

assert_file_exists()

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

staticprotectedinherited

Helper function that checks if file_name exists.

Definition at line 985 of file rb_evaluation.C.

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

{
  libmesh_error_msg_if(!std::ifstream(file_name.c_str()), "File missing: " << file_name);
}

clear()

void libMesh::RBEvaluation::clear ( )

overridevirtualinherited

Clear this RBEvaluation object.

Delete the basis functions and clear and extra data in subclasses.

Reimplemented from libMesh::RBParametrized.

Reimplemented in libMesh::TransientRBEvaluation.

Definition at line 59 of file rb_evaluation.C.

References libMesh::RBEvaluation::basis_functions, libMesh::RBEvaluation::clear_riesz_representors(), libMesh::RBEvaluation::greedy_param_list, and libMesh::RBEvaluation::set_n_basis_functions().

Referenced by libMesh::TransientRBEvaluation::clear().

{
  LOG_SCOPE("clear()", "RBEvaluation");

  // Clear the basis functions
  basis_functions.clear();
  set_n_basis_functions(0);

  clear_riesz_representors();

  // Clear the Greedy param list
  for (auto & plist : greedy_param_list)
    plist.clear();
  greedy_param_list.clear();
}

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 519 of file rb_evaluation.C.

References libMesh::RBEvaluation::Aq_representor.

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

{
  Aq_representor.clear();
}

comm()

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

inlineinherited

Returns

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

Definition at line 97 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

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

  { return _communicator; }

compute_residual_dual_norm() [1/2]

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 351 of file rb_evaluation.C.

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

{
  return compute_residual_dual_norm(N, nullptr);
}

compute_residual_dual_norm() [2/2]

Real libMesh::RBEvaluation::compute_residual_dual_norm ( const unsigned int  N, const std::vector< Number > *  evaluated_thetas  )

virtualinherited

The same as above, except that we pass in evaluated thetas instead of recomputing the theta values.

Definition at line 356 of file rb_evaluation.C.

References std::abs(), libMesh::RBEvaluation::Aq_Aq_representor_innerprods, libMesh::RBEvaluation::check_evaluated_thetas_size(), 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().

{
  LOG_SCOPE("compute_residual_dual_norm()", "RBEvaluation");

  // In case the theta functions have been pre-evaluated, first check the size for consistency
  this->check_evaluated_thetas_size(evaluated_thetas);

  // If evaluated_thetas is provided, then mu is not actually used for anything
  const RBParameters & mu = get_parameters();

  const unsigned int n_A_terms = rb_theta_expansion->get_n_A_terms();
  const unsigned int n_F_terms = rb_theta_expansion->get_n_F_terms();

  // Use the stored representor inner product values
  // to evaluate the residual norm
  Number residual_norm_sq = 0.;

  // Lambdas to help with evaluating F_theta and A_theta functions
  // using either the pre-evaluated thetas (if provided) or by calling
  // eval_{F,A}_theta()
  auto eval_F = [&](unsigned int index)
    {
      return (evaluated_thetas) ? (*evaluated_thetas)[index + n_A_terms] : rb_theta_expansion->eval_F_theta(index, mu);
    };
  auto eval_A = [&](unsigned int index)
    {
      return (evaluated_thetas) ? (*evaluated_thetas)[index] : rb_theta_expansion->eval_A_theta(index, mu);
    };

  unsigned int q=0;
  for (unsigned int q_f1=0; q_f1<n_F_terms; q_f1++)
    {
      const Number val_q_f1 = eval_F(q_f1);

      for (unsigned int q_f2=q_f1; q_f2<n_F_terms; q_f2++)
        {
          const Number val_q_f2 = eval_F(q_f2);

          Real delta = (q_f1==q_f2) ? 1. : 2.;
          residual_norm_sq += delta * libmesh_real(val_q_f1 * libmesh_conj(val_q_f2) * Fq_representor_innerprods[q] );

          q++;
        }
    }

  for (unsigned int q_f=0; q_f<n_F_terms; q_f++)
    {
      const Number val_q_f = eval_F(q_f);

      for (unsigned int q_a=0; q_a<n_A_terms; q_a++)
        {
          const Number val_q_a = eval_A(q_a);

          for (unsigned int i=0; i<N; i++)
            {
              Real delta = 2.;
              residual_norm_sq +=
                delta * libmesh_real( val_q_f * libmesh_conj(val_q_a) *
                                      libmesh_conj(RB_solution(i)) * Fq_Aq_representor_innerprods[q_f][q_a][i] );
            }
        }
    }

  q=0;
  for (unsigned int q_a1=0; q_a1<n_A_terms; q_a1++)
    {
      const Number val_q_a1 = eval_A(q_a1);

      for (unsigned int q_a2=q_a1; q_a2<n_A_terms; q_a2++)
        {
          const Number val_q_a2 = eval_A(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(val_q_a1) * val_q_a2 *
                                          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) );
}

disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

{
  _enable_print_counter = false;
  return;
}

enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Definition at line 94 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

{
  _enable_print_counter = true;
  return;
}

eval_output_dual_norm() [1/2]

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.

This function is

Definition at line 474 of file rb_evaluation.C.

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

{
  libmesh_deprecated();

  // Call non-deprecated version of this function, ignoring input mu
  return this->eval_output_dual_norm(n, nullptr);
}

eval_output_dual_norm() [2/2]

Real libMesh::RBEvaluation::eval_output_dual_norm ( unsigned int  n, const std::vector< Number > *  evaluated_thetas  )

inherited

Evaluate the dual norm of output n for the current parameters, or using the pre-evaluted theta values provided in the "evaluated_thetas" array.

Definition at line 482 of file rb_evaluation.C.

References libMesh::RBThetaExpansion::eval_output_theta(), libMesh::RBThetaExpansion::get_n_A_terms(), libMesh::RBThetaExpansion::get_n_F_terms(), libMesh::RBThetaExpansion::get_n_output_terms(), libMesh::RBParametrized::get_parameters(), libMesh::libmesh_conj(), libMesh::libmesh_real(), libMesh::RBEvaluation::output_dual_innerprods, libMesh::RBThetaExpansion::output_index_1D(), libMesh::RBEvaluation::rb_theta_expansion, libMesh::Real, and std::sqrt().

{
  // Return value
  Number output_bound_sq = 0.;

  // mu is only used if evaluated_thetas == nullptr
  const RBParameters & mu = this->get_parameters();

  // Index into output_dual_innerprods
  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.;

          Number val_l1 =
            evaluated_thetas ?
            (*evaluated_thetas)[rb_theta_expansion->output_index_1D(n, q_l1) + rb_theta_expansion->get_n_A_terms() + rb_theta_expansion->get_n_F_terms()] :
            rb_theta_expansion->eval_output_theta(n, q_l1, mu);

          Number val_l2 =
            evaluated_thetas ?
            (*evaluated_thetas)[rb_theta_expansion->output_index_1D(n, q_l2) + rb_theta_expansion->get_n_A_terms() + rb_theta_expansion->get_n_F_terms()] :
            rb_theta_expansion->eval_output_theta(n, q_l2, mu);

          output_bound_sq += delta * libmesh_real(
            libmesh_conj(val_l1) * val_l2 * output_dual_innerprods[n][q]);

          q++;
        }
    }

  return libmesh_real(std::sqrt( output_bound_sq ));
}

get_basis_function() [1/2]

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

inherited

Get a reference to the i^th basis function.

Definition at line 207 of file rb_evaluation.C.

References libMesh::RBEvaluation::basis_functions.

Referenced by libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::RBConstruction::load_basis_function(), and libMesh::TransientRBConstruction::update_RB_system_matrices().

{
  libmesh_assert_less (i, basis_functions.size());

  return *(basis_functions[i]);
}

get_basis_function() [2/2]

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

inherited

Definition at line 214 of file rb_evaluation.C.

References libMesh::RBEvaluation::basis_functions.

{
  libmesh_assert_less (i, basis_functions.size());

  return *(basis_functions[i]);
}

get_closest_value()

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

staticinherited

Returns

The closest entry to value from list_of_values.

Definition at line 443 of file rb_parametrized.C.

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

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

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

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

  return closest_val;
}

get_discrete_parameter_values()

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

inherited

Get a const reference to the discrete parameter values.

Definition at line 370 of file rb_parametrized.C.

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

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

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

  return _discrete_parameter_values;
}

get_error_bound_normalization()

Real libMesh::RBEvaluation::get_error_bound_normalization ( )

virtualinherited

Returns

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

Reimplemented in libMesh::TransientRBEvaluation.

Definition at line 340 of file rb_evaluation.C.

References libMesh::RBEvaluation::rb_solve(), and libMesh::Real.

Referenced by libMesh::RBConstruction::get_RB_error_bound().

{
  // Normalize the error based on the error bound in the
  // case of an empty reduced basis. The error bound is based
  // on the residual F - AU, so with an empty basis this gives
  // a value based on the norm of F at the current parameters.

  Real normalization = rb_solve(0);
  return normalization;
}

get_info()

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

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

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

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

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

  std::ostringstream oss;

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

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

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

  return oss.str();

#else

  return "";

#endif
}

get_n_basis_functions()

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

inlinevirtualinherited

Get the current number of basis functions.

Definition at line 181 of file rb_evaluation.h.

References libMesh::RBEvaluation::basis_functions.

Referenced by libMesh::RBDataSerialization::add_rb_evaluation_data_to_builder(), libMesh::RBDataSerialization::add_transient_rb_evaluation_data_to_builder(), libMesh::TransientRBConstruction::assemble_affine_expansion(), libMesh::RBConstruction::compute_residual_dual_norm_slow(), libMesh::RBConstruction::enrich_RB_space(), libMesh::RBConstruction::greedy_termination_test(), libMesh::TransientRBEvaluation::legacy_read_offline_data_from_files(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::TransientRBConstruction::load_rb_solution(), libMesh::RBConstruction::load_rb_solution(), libMesh::RBConstruction::print_basis_function_orthogonality(), libMesh::TransientRBEvaluation::rb_solve(), libMesh::RBEvaluation::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_with_greedy(), libMesh::RBConstruction::train_reduced_basis_with_POD(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::TransientRBConstruction::write_riesz_representors_to_files(), and libMesh::RBConstruction::write_riesz_representors_to_files().

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

get_n_continuous_params()

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

inherited

Get the number of continuous parameters.

Definition at line 112 of file rb_parametrized.C.

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

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

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

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

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

get_n_discrete_params()

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

inherited

Get the number of discrete parameters.

Definition at line 121 of file rb_parametrized.C.

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

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

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

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

get_n_params()

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

inherited

Get the number of parameters.

Definition at line 103 of file rb_parametrized.C.

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

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

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

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

  return parameters_min.n_parameters();
}

get_parameter_max()

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

inherited

Get maximum allowable value of parameter param_name.

Definition at line 183 of file rb_parametrized.C.

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

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

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

  return parameters_max.get_value(param_name);
}

get_parameter_min()

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

inherited

Get minimum allowable value of parameter param_name.

Definition at line 176 of file rb_parametrized.C.

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

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

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

  return parameters_min.get_value(param_name);
}

get_parameter_names()

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

inherited

Get a set that stores the parameter names.

Definition at line 129 of file rb_parametrized.C.

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

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

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

  return parameter_names;
}

get_parameters()

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

inherited

Get the current parameters.

Definition at line 155 of file rb_parametrized.C.

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

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

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

  return parameters;
}

get_parameters_max()

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

inherited

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

Definition at line 169 of file rb_parametrized.C.

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

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

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

  return parameters_max;
}

get_parameters_min()

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

inherited

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

Definition at line 162 of file rb_parametrized.C.

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

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

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

  return parameters_min;
}

get_rb_theta_expansion() [1/2]

RBThetaExpansion & libMesh::RBEvaluation::get_rb_theta_expansion ( )

inherited

Get a reference to the rb_theta_expansion.

Definition at line 85 of file rb_evaluation.C.

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::RBConstruction::preevaluate_thetas(), libMesh::TransientRBEvaluation::rb_solve(), libMesh::TransientRBEvaluation::resize_data_structures(), and libMesh::TransientRBEvaluation::uncached_compute_residual_dual_norm().

{
  libmesh_error_msg_if(!is_rb_theta_expansion_initialized(),
                       "Error: rb_theta_expansion hasn't been initialized yet");

  return *rb_theta_expansion;
}

get_rb_theta_expansion() [2/2]

const RBThetaExpansion & libMesh::RBEvaluation::get_rb_theta_expansion ( ) const

inherited

Definition at line 93 of file rb_evaluation.C.

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

{
  libmesh_error_msg_if(!is_rb_theta_expansion_initialized(),
                       "Error: rb_theta_expansion hasn't been initialized yet");

  return *rb_theta_expansion;
}

get_stability_lower_bound()

virtual Real ElasticityRBEvaluation::get_stability_lower_bound ( )

inlinevirtual

Return a "dummy" lower bound for the coercivity constant.

To do this rigorously we should use the SCM classes.

Reimplemented from libMesh::RBEvaluation.

Definition at line 36 of file rb_classes.h.

{ return 1.; }

increment_constructor_count()

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

inlineprotectednoexceptinherited

Increments the construction counter.

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

Definition at line 183 of file reference_counter.h.

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

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

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

increment_destructor_count()

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

inlineprotectednoexceptinherited

Increments the destruction counter.

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

Definition at line 207 of file reference_counter.h.

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

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

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

initialize_parameters() [1/2]

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

inherited

Initialize the parameter ranges and set current_parameters.

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

Definition at line 53 of file rb_parametrized.C.

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

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

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

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

  parameters_min = mu_min_in;
  parameters_max = mu_max_in;

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

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

      libmesh_assert_less_equal(min_val, max_val);

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

    _discrete_parameter_values = discrete_parameter_values;

  parameters_initialized = true;

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

initialize_parameters() [2/2]

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

inherited

Initialize the parameter ranges and set current_parameters.

Definition at line 96 of file rb_parametrized.C.

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

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

is_discrete_parameter()

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

inherited

Is parameter mu_name discrete?

Definition at line 363 of file rb_parametrized.C.

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

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

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

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

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 101 of file rb_evaluation.C.

References libMesh::RBEvaluation::rb_theta_expansion.

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

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

legacy_read_offline_data_from_files()

void libMesh::RBEvaluation::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  )

virtualinherited

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 in libMesh::TransientRBEvaluation.

Definition at line 752 of file rb_evaluation.C.

References libMesh::RBEvaluation::Aq_Aq_representor_innerprods, libMesh::RBEvaluation::assert_file_exists(), libMesh::RBEvaluation::basis_functions, libMesh::Xdr::close(), libMesh::RBEvaluation::compute_RB_inner_product, libMesh::DECODE, libMesh::RBEvaluation::Fq_Aq_representor_innerprods, libMesh::RBEvaluation::Fq_representor_innerprods, libMesh::RBThetaExpansion::get_n_A_terms(), libMesh::RBThetaExpansion::get_n_F_terms(), libMesh::RBThetaExpansion::get_n_output_terms(), libMesh::RBThetaExpansion::get_n_outputs(), libMesh::RBEvaluation::output_dual_innerprods, libMesh::RBEvaluation::RB_Aq_vector, libMesh::RBEvaluation::RB_Fq_vector, libMesh::RBEvaluation::RB_inner_product_matrix, libMesh::RBEvaluation::RB_output_vectors, libMesh::RBEvaluation::rb_theta_expansion, libMesh::READ, libMesh::RBParametrized::read_parameter_data_from_files(), libMesh::RBEvaluation::resize_data_structures(), libMesh::RBEvaluation::set_n_basis_functions(), and value.

Referenced by libMesh::TransientRBEvaluation::legacy_read_offline_data_from_files().

{
  LOG_SCOPE("legacy_read_offline_data_from_files()", "RBEvaluation");

  // The reading 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";

  // The string stream we'll use to make the file names
  std::ostringstream file_name;

  // First, find out how many basis functions we had when Greedy terminated
  unsigned int n_bfs;
  {
    file_name << directory_name << "/n_bfs" << suffix;
    assert_file_exists(file_name.str());

    Xdr n_bfs_in(file_name.str(), mode);
    n_bfs_in >> n_bfs;
    n_bfs_in.close();
  }
  resize_data_structures(n_bfs, read_error_bound_data);

  // Read in the parameter ranges
  file_name.str("");
  file_name << directory_name << "/parameter_ranges" << suffix;
  std::string continuous_param_file_name = file_name.str();

  // Read in the discrete parameter values
  file_name.str("");
  file_name << directory_name << "/discrete_parameter_values" << suffix;
  std::string discrete_param_file_name = file_name.str();
  read_parameter_data_from_files(continuous_param_file_name,
                                 discrete_param_file_name,
                                 read_binary_data);

  // Read in output data in multiple files
  for (unsigned int n=0; n<rb_theta_expansion->get_n_outputs(); n++)
    {
      for (unsigned int q_l=0; q_l<rb_theta_expansion->get_n_output_terms(n); q_l++)
        {
          file_name.str("");
          file_name << directory_name << "/output_";
          file_name << std::setw(3)
                    << std::setprecision(0)
                    << std::setfill('0')
                    << std::right
                    << n;
          file_name << "_";
          file_name << std::setw(3)
                    << std::setprecision(0)
                    << std::setfill('0')
                    << std::right
                    << q_l;
          file_name << suffix;
          assert_file_exists(file_name.str());

          Xdr output_n_in(file_name.str(), mode);

          for (unsigned int j=0; j<n_bfs; j++)
            {
              Number value;
              output_n_in >> value;
              RB_output_vectors[n][q_l](j) = value;
            }
          output_n_in.close();
        }
    }

  if (compute_RB_inner_product)
    {
      // Next read in the inner product matrix
      file_name.str("");
      file_name << directory_name << "/RB_inner_product_matrix" << suffix;
      assert_file_exists(file_name.str());

      Xdr RB_inner_product_matrix_in(file_name.str(), mode);

      for (unsigned int i=0; i<n_bfs; i++)
        {
          for (unsigned int j=0; j<n_bfs; j++)
            {
              Number value;
              RB_inner_product_matrix_in >> value;
              RB_inner_product_matrix(i,j) = value;
            }
        }
      RB_inner_product_matrix_in.close();
    }

  // Next read in the Fq vectors
  for (unsigned int q_f=0; q_f<rb_theta_expansion->get_n_F_terms(); q_f++)
    {
      file_name.str("");
      file_name << directory_name << "/RB_F_";
      file_name << std::setw(3)
                << std::setprecision(0)
                << std::setfill('0')
                << std::right
                << q_f;
      file_name << suffix;
      assert_file_exists(file_name.str());

      Xdr RB_Fq_f_in(file_name.str(), mode);

      for (unsigned int i=0; i<n_bfs; i++)
        {
          Number value;
          RB_Fq_f_in >> value;
          RB_Fq_vector[q_f](i) = value;
        }
      RB_Fq_f_in.close();
    }

  // Next read in the Aq matrices
  for (unsigned int q_a=0; q_a<rb_theta_expansion->get_n_A_terms(); q_a++)
    {
      file_name.str("");
      file_name << directory_name << "/RB_A_";
      file_name << std::setw(3)
                << std::setprecision(0)
                << std::setfill('0')
                << std::right
                << q_a;
      file_name << suffix;
      assert_file_exists(file_name.str());

      Xdr RB_Aq_a_in(file_name.str(), mode);

      for (unsigned int i=0; i<n_bfs; i++)
        {
          for (unsigned int j=0; j<n_bfs; j++)
            {
              Number  value;
              RB_Aq_a_in >> value;
              RB_Aq_vector[q_a](i,j) = value;
            }
        }
      RB_Aq_a_in.close();
    }


  if (read_error_bound_data)
    {
      // Next read in Fq representor norm data
      file_name.str("");
      file_name << directory_name << "/Fq_innerprods" << suffix;
      assert_file_exists(file_name.str());

      Xdr RB_Fq_innerprods_in(file_name.str(), mode);

      unsigned int Q_f_hat = rb_theta_expansion->get_n_F_terms()*(rb_theta_expansion->get_n_F_terms()+1)/2;
      for (unsigned int i=0; i<Q_f_hat; i++)
        {
          RB_Fq_innerprods_in >> Fq_representor_innerprods[i];
        }
      RB_Fq_innerprods_in.close();

      // Read in output data
      for (unsigned int n=0; n<rb_theta_expansion->get_n_outputs(); n++)
        {
          file_name.str("");
          file_name << directory_name << "/output_";
          file_name << std::setw(3)
                    << std::setprecision(0)
                    << std::setfill('0')
                    << std::right
                    << n;
          file_name << "_dual_innerprods" << suffix;
          assert_file_exists(file_name.str());

          Xdr output_dual_innerprods_in(file_name.str(), mode);

          unsigned int Q_l_hat = rb_theta_expansion->get_n_output_terms(n)*(rb_theta_expansion->get_n_output_terms(n)+1)/2;
          for (unsigned int q=0; q<Q_l_hat; q++)
            {
              output_dual_innerprods_in >> output_dual_innerprods[n][q];
            }
          output_dual_innerprods_in.close();
        }


      // Next read in Fq_Aq representor norm data
      file_name.str("");
      file_name << directory_name << "/Fq_Aq_innerprods" << suffix;
      assert_file_exists(file_name.str());

      Xdr RB_Fq_Aq_innerprods_in(file_name.str(), mode);

      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_bfs; i++)
                {
                  RB_Fq_Aq_innerprods_in >> Fq_Aq_representor_innerprods[q_f][q_a][i];
                }
            }
        }
      RB_Fq_Aq_innerprods_in.close();

      // Next read in Aq_Aq representor norm data
      file_name.str("");
      file_name << directory_name << "/Aq_Aq_innerprods" << suffix;
      assert_file_exists(file_name.str());

      Xdr RB_Aq_Aq_innerprods_in(file_name.str(), mode);

      unsigned int Q_a_hat = rb_theta_expansion->get_n_A_terms()*(rb_theta_expansion->get_n_A_terms()+1)/2;
      for (unsigned int i=0; i<Q_a_hat; i++)
        {
          for (unsigned int j=0; j<n_bfs; j++)
            {
              for (unsigned int l=0; l<n_bfs; l++)
                {
                  RB_Aq_Aq_innerprods_in >> Aq_Aq_representor_innerprods[i][j][l];
                }
            }
        }
      RB_Aq_Aq_innerprods_in.close();
    }

  // Resize basis_functions even if we don't read them in so that
  // get_n_bfs() returns the correct value. Initialize the pointers
  // to nullptr.
  basis_functions.clear();
  set_n_basis_functions(n_bfs);
}

legacy_write_offline_data_to_files()

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

virtualinherited

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 in libMesh::TransientRBEvaluation.

Definition at line 524 of file rb_evaluation.C.

References libMesh::RBEvaluation::Aq_Aq_representor_innerprods, libMesh::Xdr::close(), libMesh::RBEvaluation::compute_RB_inner_product, libMesh::ENCODE, libMesh::RBEvaluation::Fq_Aq_representor_innerprods, libMesh::RBEvaluation::Fq_representor_innerprods, libMesh::RBThetaExpansion::get_n_A_terms(), libMesh::RBEvaluation::get_n_basis_functions(), libMesh::RBThetaExpansion::get_n_F_terms(), libMesh::RBThetaExpansion::get_n_output_terms(), libMesh::RBThetaExpansion::get_n_outputs(), libMesh::RBEvaluation::greedy_param_list, libMesh::Utility::mkdir(), libMesh::RBEvaluation::output_dual_innerprods, libMesh::ParallelObject::processor_id(), libMesh::RBEvaluation::RB_Aq_vector, libMesh::RBEvaluation::RB_Fq_vector, libMesh::RBEvaluation::RB_inner_product_matrix, libMesh::RBEvaluation::RB_output_vectors, libMesh::RBEvaluation::rb_theta_expansion, libMesh::Real, libMesh::WRITE, and libMesh::RBParametrized::write_parameter_data_to_files().

Referenced by libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), and main().

{
  LOG_SCOPE("legacy_write_offline_data_to_files()", "RBEvaluation");

  // 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 = write_binary_data ? ENCODE : WRITE;

  // The suffix to use for all the files that are written out
  const std::string suffix = write_binary_data ? ".xdr" : ".dat";

  if (this->processor_id() == 0)
    {

      // Make a directory to store all the data files
      Utility::mkdir(directory_name.c_str());
      //    if (mkdir(directory_name.c_str(), 0777) == -1)
      //    {
      //      libMesh::out << "In RBEvaluation::write_offline_data_to_files, directory "
      //                   << directory_name << " already exists, overwriting contents." << std::endl;
      //    }

      // First, write out how many basis functions we have generated
      std::ostringstream file_name;
      {
        file_name << directory_name << "/n_bfs" << suffix;
        Xdr n_bfs_out(file_name.str(), mode);
        n_bfs_out << n_bfs;
        n_bfs_out.close();
      }

      // Write out the parameter ranges
      file_name.str("");
      file_name << directory_name << "/parameter_ranges" << suffix;
      std::string continuous_param_file_name = file_name.str();

      // Write out the discrete parameter values
      file_name.str("");
      file_name << directory_name << "/discrete_parameter_values" << suffix;
      std::string discrete_param_file_name = file_name.str();

      write_parameter_data_to_files(continuous_param_file_name,
                                    discrete_param_file_name,
                                    write_binary_data);

      // Write out Fq representor norm data
      file_name.str("");
      file_name << directory_name << "/Fq_innerprods" << suffix;
      Xdr RB_Fq_innerprods_out(file_name.str(), mode);
      unsigned int Q_f_hat = rb_theta_expansion->get_n_F_terms()*(rb_theta_expansion->get_n_F_terms()+1)/2;
      for (unsigned int i=0; i<Q_f_hat; i++)
        {
          RB_Fq_innerprods_out << Fq_representor_innerprods[i];
        }
      RB_Fq_innerprods_out.close();

      // Write out output data
      for (unsigned int n=0; n<rb_theta_expansion->get_n_outputs(); n++)
        {
          file_name.str("");
          file_name << directory_name << "/output_";
          file_name << std::setw(3)
                    << std::setprecision(0)
                    << std::setfill('0')
                    << std::right
                    << n;

          file_name << "_dual_innerprods" << suffix;
          Xdr output_dual_innerprods_out(file_name.str(), mode);

          unsigned int Q_l_hat = rb_theta_expansion->get_n_output_terms(n)*(rb_theta_expansion->get_n_output_terms(n)+1)/2;
          for (unsigned int q=0; q<Q_l_hat; q++)
            {
              output_dual_innerprods_out << output_dual_innerprods[n][q];
            }
          output_dual_innerprods_out.close();
        }


      // Write out output data to multiple files
      for (unsigned int n=0; n<rb_theta_expansion->get_n_outputs(); n++)
        {
          for (unsigned int q_l=0; q_l<rb_theta_expansion->get_n_output_terms(n); q_l++)
            {
              file_name.str("");
              file_name << directory_name << "/output_";
              file_name << std::setw(3)
                        << std::setprecision(0)
                        << std::setfill('0')
                        << std::right
                        << n;
              file_name << "_";
              file_name << std::setw(3)
                        << std::setprecision(0)
                        << std::setfill('0')
                        << std::right
                        << q_l;
              file_name << suffix;
              Xdr output_n_out(file_name.str(), mode);

              for (unsigned int j=0; j<n_bfs; j++)
                {
                  output_n_out << RB_output_vectors[n][q_l](j);
                }
              output_n_out.close();
            }
        }

      if (compute_RB_inner_product)
        {
          // Next write out the inner product matrix
          file_name.str("");
          file_name << directory_name << "/RB_inner_product_matrix" << suffix;
          Xdr RB_inner_product_matrix_out(file_name.str(), mode);
          for (unsigned int i=0; i<n_bfs; i++)
            {
              for (unsigned int j=0; j<n_bfs; j++)
                {
                  RB_inner_product_matrix_out << RB_inner_product_matrix(i,j);
                }
            }
          RB_inner_product_matrix_out.close();
        }

      // Next write out the Fq vectors
      for (unsigned int q_f=0; q_f<rb_theta_expansion->get_n_F_terms(); q_f++)
        {
          file_name.str("");
          file_name << directory_name << "/RB_F_";
          file_name << std::setw(3)
                    << std::setprecision(0)
                    << std::setfill('0')
                    << std::right
                    << q_f;
          file_name << suffix;
          Xdr RB_Fq_f_out(file_name.str(), mode);

          for (unsigned int i=0; i<n_bfs; i++)
            {
              RB_Fq_f_out << RB_Fq_vector[q_f](i);
            }
          RB_Fq_f_out.close();
        }

      // Next write out the Aq matrices
      for (unsigned int q_a=0; q_a<rb_theta_expansion->get_n_A_terms(); q_a++)
        {
          file_name.str("");
          file_name << directory_name << "/RB_A_";
          file_name << std::setw(3)
                    << std::setprecision(0)
                    << std::setfill('0')
                    << std::right
                    << q_a;
          file_name << suffix;
          Xdr RB_Aq_a_out(file_name.str(), mode);

          for (unsigned int i=0; i<n_bfs; i++)
            {
              for (unsigned int j=0; j<n_bfs; j++)
                {
                  RB_Aq_a_out << RB_Aq_vector[q_a](i,j);
                }
            }
          RB_Aq_a_out.close();
        }

      // Next write out Fq_Aq representor norm data
      file_name.str("");
      file_name << directory_name << "/Fq_Aq_innerprods" << suffix;
      Xdr RB_Fq_Aq_innerprods_out(file_name.str(), mode);

      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_bfs; i++)
                {
                  RB_Fq_Aq_innerprods_out << Fq_Aq_representor_innerprods[q_f][q_a][i];
                }
            }
        }
      RB_Fq_Aq_innerprods_out.close();

      // Next write out Aq_Aq representor norm data
      file_name.str("");
      file_name << directory_name << "/Aq_Aq_innerprods" << suffix;
      Xdr RB_Aq_Aq_innerprods_out(file_name.str(), mode);

      unsigned int Q_a_hat = rb_theta_expansion->get_n_A_terms()*(rb_theta_expansion->get_n_A_terms()+1)/2;
      for (unsigned int i=0; i<Q_a_hat; i++)
        {
          for (unsigned int j=0; j<n_bfs; j++)
            {
              for (unsigned int l=0; l<n_bfs; l++)
                {
                  RB_Aq_Aq_innerprods_out << Aq_Aq_representor_innerprods[i][j][l];
                }
            }
        }
      RB_Aq_Aq_innerprods_out.close();

      // Also, write out the greedily selected parameters
      {
        file_name.str("");
        file_name << directory_name << "/greedy_params" << suffix;
        Xdr greedy_params_out(file_name.str(), mode);

        for (const auto & param : greedy_param_list)
          for (const auto & pr : param)
            for (const auto & value_vector : pr.second)
              {
                // Need to make a copy of the value so that it's not const
                // Xdr is not templated on const's
                libmesh_error_msg_if(value_vector.size() != 1,
                                     "Error: multi-value RB parameters are not yet supported here.");
                Real param_value = value_vector[0];
                greedy_params_out << param_value;
              }
        greedy_params_out.close();
      }

    }
}

n_objects()

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

inlinestaticinherited

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

Definition at line 85 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

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

  { return _n_objects; }

n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns

The number of processors in the group.

Definition at line 103 of file parallel_object.h.

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

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

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

print_discrete_parameter_values()

void libMesh::RBParametrized::print_discrete_parameter_values ( ) const

inherited

Print out all the discrete parameter values.

Definition at line 377 of file rb_parametrized.C.

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

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

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

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

print_info()

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

staticinherited

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

Definition at line 81 of file reference_counter.C.

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

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

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

print_parameters()

void libMesh::RBParametrized::print_parameters ( ) const

inherited

Print the current parameters.

Definition at line 190 of file rb_parametrized.C.

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

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

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

  get_parameters().print();
}

processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns

The rank of this processor in the group.

Definition at line 114 of file parallel_object.h.

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

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

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

rb_solve() [1/2]

Real libMesh::RBEvaluation::rb_solve ( unsigned int  N )

virtualinherited

Perform online solve with the N RB basis functions, for the set of parameters in current_params, where 0 <= N <= RB_size.

Returns

The (absolute) error bound associated with the RB approximation. With an empty RB space (N=0), our RB solution is zero, but we still obtain a meaningful error bound associated with the forcing terms.

Reimplemented in libMesh::TransientRBEvaluation.

Definition at line 221 of file rb_evaluation.C.

Referenced by libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::RBEvaluation::get_error_bound_normalization(), and libMesh::RBConstruction::get_RB_error_bound().

{
  return rb_solve(N, nullptr);
}

rb_solve() [2/2]

Real libMesh::RBEvaluation::rb_solve ( unsigned int  N, const std::vector< Number > *  evaluated_thetas  )

virtualinherited

The same as above, except that we pass in evaluated_thetas instead of recomputing the theta values.

Definition at line 226 of file rb_evaluation.C.

References libMesh::DenseVector< T >::add(), libMesh::DenseMatrix< T >::add(), libMesh::RBEvaluation::check_evaluated_thetas_size(), libMesh::RBEvaluation::compute_residual_dual_norm(), libMesh::DenseVector< T >::dot(), libMesh::RBThetaExpansion::eval_A_theta(), libMesh::RBThetaExpansion::eval_F_theta(), libMesh::RBEvaluation::eval_output_dual_norm(), libMesh::RBThetaExpansion::eval_output_theta(), libMesh::RBEvaluation::evaluate_RB_error_bound, libMesh::RBThetaExpansion::get_n_A_terms(), libMesh::RBEvaluation::get_n_basis_functions(), libMesh::RBThetaExpansion::get_n_F_terms(), libMesh::RBThetaExpansion::get_n_output_terms(), libMesh::RBThetaExpansion::get_n_outputs(), libMesh::RBParametrized::get_parameters(), libMesh::RBEvaluation::get_stability_lower_bound(), libMesh::DenseMatrix< T >::lu_solve(), libMesh::RBEvaluation::RB_Aq_vector, libMesh::RBEvaluation::RB_Fq_vector, libMesh::RBEvaluation::RB_output_error_bounds, libMesh::RBEvaluation::RB_output_vectors, libMesh::RBEvaluation::RB_outputs, libMesh::RBEvaluation::RB_solution, libMesh::RBEvaluation::rb_theta_expansion, libMesh::Real, libMesh::RBEvaluation::residual_scaling_denom(), libMesh::DenseVector< T >::resize(), libMesh::DenseMatrix< T >::zero(), and libMesh::DenseVector< T >::zero().

{
  LOG_SCOPE("rb_solve()", "RBEvaluation");

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

  // In case the theta functions have been pre-evaluated, first check the size for consistency. The
  // size of the input "evaluated_thetas" vector must match the sum of the "A", "F", and "output" terms
  // in the expansion.
  this->check_evaluated_thetas_size(evaluated_thetas);

  const RBParameters & mu = get_parameters();

  // Resize (and clear) the solution vector
  RB_solution.resize(N);

  // Assemble the RB system
  DenseMatrix<Number> RB_system_matrix(N,N);
  RB_system_matrix.zero();

  DenseMatrix<Number> RB_Aq_a;
  for (unsigned int q_a=0; q_a<rb_theta_expansion->get_n_A_terms(); q_a++)
    {
      RB_Aq_vector[q_a].get_principal_submatrix(N, RB_Aq_a);

      if (evaluated_thetas)
        RB_system_matrix.add((*evaluated_thetas)[q_a], RB_Aq_a);
      else
        RB_system_matrix.add(rb_theta_expansion->eval_A_theta(q_a, mu), RB_Aq_a);
    }

  // Assemble the RB rhs
  DenseVector<Number> RB_rhs(N);
  RB_rhs.zero();

  DenseVector<Number> RB_Fq_f;
  for (unsigned int q_f=0; q_f<rb_theta_expansion->get_n_F_terms(); q_f++)
    {
      RB_Fq_vector[q_f].get_principal_subvector(N, RB_Fq_f);

      if (evaluated_thetas)
        RB_rhs.add((*evaluated_thetas)[q_f+rb_theta_expansion->get_n_A_terms()], RB_Fq_f);
      else
        RB_rhs.add(rb_theta_expansion->eval_F_theta(q_f, mu), RB_Fq_f);
    }

  // Solve the linear system
  if (N > 0)
    {
      RB_system_matrix.lu_solve(RB_rhs, RB_solution);
    }

  // Place to store the output of get_principal_subvector() calls
  DenseVector<Number> RB_output_vector_N;

  // Evaluate RB outputs
  unsigned int output_counter = 0;
  for (unsigned int n=0; n<rb_theta_expansion->get_n_outputs(); n++)
    {
      RB_outputs[n] = 0.;
      for (unsigned int q_l=0; q_l<rb_theta_expansion->get_n_output_terms(n); q_l++)
        {
          RB_output_vectors[n][q_l].get_principal_subvector(N, RB_output_vector_N);

          // Compute dot product with current output vector and RB_solution
          auto dot_prod = RB_output_vector_N.dot(RB_solution);

          // Determine the coefficient depending on whether or not
          // pre-evaluated thetas were provided. Note that if
          // pre-evaluated thetas were provided, they must come after
          // the "A" and "F" thetas and be in "row-major" order. In
          // other words, there is a possibly "ragged" 2D array of
          // output thetas ordered by output index "n" and term index
          // "q_l" which is accessed in row-major order.
          auto coeff = evaluated_thetas ?
            (*evaluated_thetas)[output_counter + rb_theta_expansion->get_n_A_terms() + rb_theta_expansion->get_n_F_terms()] :
            rb_theta_expansion->eval_output_theta(n, q_l, mu);

          // Finally, accumulate the result in RB_outputs[n]
          RB_outputs[n] += coeff * dot_prod;

          // Go to next output
          output_counter++;
        }
    }

  if (evaluate_RB_error_bound) // Calculate the error bounds
    {
      // Evaluate the dual norm of the residual for RB_solution_vector
      Real epsilon_N = compute_residual_dual_norm(N, evaluated_thetas);

      // Get lower bound for coercivity constant
      const Real alpha_LB = get_stability_lower_bound();
      // alpha_LB needs to be positive to get a valid error bound
      libmesh_assert_greater ( alpha_LB, 0. );

      // Evaluate the (absolute) error bound
      Real abs_error_bound = epsilon_N / residual_scaling_denom(alpha_LB);

      // Now compute the output error bounds
      for (unsigned int n=0; n<rb_theta_expansion->get_n_outputs(); n++)
        RB_output_error_bounds[n] = abs_error_bound * this->eval_output_dual_norm(n, evaluated_thetas);

      return abs_error_bound;
    }
  else // Don't calculate the error bounds
    {
      // Just return -1. if we did not compute the error bound
      return -1.;
    }
}

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 1073 of file rb_evaluation.C.

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

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

  read_in_vectors(sys,
                  basis_functions,
                  directory_name,
                  "bf",
                  read_binary_basis_functions);
}

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  )

staticinherited

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 1086 of file rb_evaluation.C.

References libMesh::RBEvaluation::read_in_vectors_from_multiple_files().

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

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

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  )

staticinherited

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 1108 of file rb_evaluation.C.

References libMesh::RBEvaluation::assert_file_exists(), TIMPI::Communicator::barrier(), 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, TIMPI::Communicator::rank(), libMesh::READ, libMesh::System::read_header(), and libMesh::System::read_serialized_vectors().

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

{
  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
  sys.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.
          libmesh_error_msg_if(vec, "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 (sys.comm().rank() == 0)
        {
          struct stat stat_info;
          int stat_result = stat(file_name.str().c_str(), &stat_info);

          libmesh_error_msg_if(stat_result != 0, "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);
        libmesh_error_msg_if(lm_pos == std::string::npos, "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 that 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();
}

read_parameter_data_from_files()

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

inherited

Read in the parameter ranges from files.

Definition at line 274 of file rb_parametrized.C.

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

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

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

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

  initialize_parameters(param_min, param_max, discrete_parameter_values_in);
}

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 467 of file rb_evaluation.C.

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

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

resize_data_structures()

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

virtualinherited

Resize and clear the data vectors corresponding to the value of Nmax.

Optionally resize the data structures required for the error bound. Override to also clear and resize any extra data in subclasses.

Reimplemented in libMesh::TransientRBEvaluation.

Definition at line 113 of file rb_evaluation.C.

References libMesh::RBEvaluation::Aq_Aq_representor_innerprods, libMesh::RBEvaluation::Aq_representor, libMesh::RBEvaluation::clear_riesz_representors(), libMesh::RBEvaluation::compute_RB_inner_product, libMesh::RBEvaluation::Fq_Aq_representor_innerprods, libMesh::RBEvaluation::Fq_representor_innerprods, libMesh::RBThetaExpansion::get_n_A_terms(), libMesh::RBEvaluation::get_n_basis_functions(), libMesh::RBThetaExpansion::get_n_F_terms(), libMesh::RBThetaExpansion::get_n_output_terms(), libMesh::RBThetaExpansion::get_n_outputs(), libMesh::RBEvaluation::output_dual_innerprods, libMesh::RBEvaluation::RB_Aq_vector, libMesh::RBEvaluation::RB_Fq_vector, libMesh::RBEvaluation::RB_inner_product_matrix, libMesh::RBEvaluation::RB_output_error_bounds, libMesh::RBEvaluation::RB_output_vectors, libMesh::RBEvaluation::RB_outputs, libMesh::RBEvaluation::rb_theta_expansion, and libMesh::DenseMatrix< T >::resize().

Referenced by libMesh::RBConstruction::enrich_basis_from_rhs_terms(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::RBDataDeserialization::load_rb_evaluation_data(), libMesh::TransientRBEvaluation::resize_data_structures(), libMesh::RBConstruction::train_reduced_basis_with_greedy(), and libMesh::RBConstruction::train_reduced_basis_with_POD().

{
  LOG_SCOPE("resize_data_structures()", "RBEvaluation");

  libmesh_error_msg_if(Nmax < this->get_n_basis_functions(),
                       "Error: Cannot set Nmax to be less than the current number of basis functions.");

  // Resize/clear inner product matrix
  if (compute_RB_inner_product)
    RB_inner_product_matrix.resize(Nmax,Nmax);

  // Allocate dense matrices for RB solves
  RB_Aq_vector.resize(rb_theta_expansion->get_n_A_terms());

  for (unsigned int q=0; q<rb_theta_expansion->get_n_A_terms(); q++)
    {
      // Initialize the memory for the RB matrices
      RB_Aq_vector[q].resize(Nmax,Nmax);
    }

  RB_Fq_vector.resize(rb_theta_expansion->get_n_F_terms());

  for (unsigned int q=0; q<rb_theta_expansion->get_n_F_terms(); q++)
    {
      // Initialize the memory for the RB vectors
      RB_Fq_vector[q].resize(Nmax);
    }


  // Initialize the RB output vectors
  RB_output_vectors.resize(rb_theta_expansion->get_n_outputs());
  for (unsigned int n=0; n<rb_theta_expansion->get_n_outputs(); n++)
    {
      RB_output_vectors[n].resize(rb_theta_expansion->get_n_output_terms(n));
      for (unsigned int q_l=0; q_l<rb_theta_expansion->get_n_output_terms(n); q_l++)
        {
          RB_output_vectors[n][q_l].resize(Nmax);
        }
    }

  // Initialize vectors storing output data
  RB_outputs.resize(rb_theta_expansion->get_n_outputs(), 0.);


  if (resize_error_bound_data)
    {
      // Initialize vectors for the norms of the Fq representors
      unsigned int Q_f_hat = rb_theta_expansion->get_n_F_terms()*(rb_theta_expansion->get_n_F_terms()+1)/2;
      Fq_representor_innerprods.resize(Q_f_hat);

      // Initialize vectors for the norms of the representors
      Fq_Aq_representor_innerprods.resize(rb_theta_expansion->get_n_F_terms());
      for (unsigned int i=0; i<rb_theta_expansion->get_n_F_terms(); i++)
        {
          Fq_Aq_representor_innerprods[i].resize(rb_theta_expansion->get_n_A_terms());
          for (unsigned int j=0; j<rb_theta_expansion->get_n_A_terms(); j++)
            {
              Fq_Aq_representor_innerprods[i][j].resize(Nmax, 0.);
            }
        }

      unsigned int Q_a_hat = rb_theta_expansion->get_n_A_terms()*(rb_theta_expansion->get_n_A_terms()+1)/2;
      Aq_Aq_representor_innerprods.resize(Q_a_hat);
      for (unsigned int i=0; i<Q_a_hat; i++)
        {
          Aq_Aq_representor_innerprods[i].resize(Nmax);
          for (unsigned int j=0; j<Nmax; j++)
            {
              Aq_Aq_representor_innerprods[i][j].resize(Nmax, 0.);
            }
        }

      RB_output_error_bounds.resize(rb_theta_expansion->get_n_outputs(), 0.);

      // Resize the output dual norm vectors
      output_dual_innerprods.resize(rb_theta_expansion->get_n_outputs());
      for (unsigned int n=0; n<rb_theta_expansion->get_n_outputs(); n++)
        {
          unsigned int Q_l_hat = rb_theta_expansion->get_n_output_terms(n)*(rb_theta_expansion->get_n_output_terms(n)+1)/2;
          output_dual_innerprods[n].resize(Q_l_hat);
        }

      // Clear and resize the vector of Aq_representors
      clear_riesz_representors();

      Aq_representor.resize(rb_theta_expansion->get_n_A_terms());
      for (unsigned int q_a=0; q_a<rb_theta_expansion->get_n_A_terms(); q_a++)
        {
          Aq_representor[q_a].resize(Nmax);
        }
    }
}

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

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

{
  basis_functions.resize(n_bfs);
}

set_parameters()

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

inherited

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

We

Returns

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

Definition at line 141 of file rb_parametrized.C.

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

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

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

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

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

  return valid_params;
}

set_rb_theta_expansion()

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

inherited

Set the RBThetaExpansion object.

Definition at line 80 of file rb_evaluation.C.

References libMesh::RBEvaluation::rb_theta_expansion.

Referenced by SimpleRBEvaluation::SimpleRBEvaluation().

{
  rb_theta_expansion = &rb_theta_expansion_in;
}

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 990 of file rb_evaluation.C.

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

Referenced by main().

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

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  )

staticinherited

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

Definition at line 1009 of file rb_evaluation.C.

References TIMPI::Communicator::barrier(), 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(), TIMPI::Communicator::rank(), libMesh::WRITE, libMesh::System::write_header(), and libMesh::System::write_serialized_vectors().

Referenced by libMesh::RBEvaluation::write_out_basis_functions(), and libMesh::RBEIMEvaluation::write_out_projected_basis_functions().

{
  LOG_SCOPE("write_out_vectors()", "RBEvaluation");

  if (sys.comm().rank() == 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
  sys.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);

  // Following EquationSystems::write(), we should only write the header information
  // if we're proc 0
  if (sys.comm().rank() == 0)
    {
      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();
}

write_parameter_data_to_files()

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

inherited

Write out the parameter ranges to files.

Definition at line 197 of file rb_parametrized.C.

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

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

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

Member Data Documentation

_communicator

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

protectedinherited

Definition at line 120 of file parallel_object.h.

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

_counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

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

_enable_print_counter

bool libMesh::ReferenceCounter::_enable_print_counter = true

staticprotectedinherited

Flag to control whether reference count information is printed when print_info is called.

Definition at line 143 of file reference_counter.h.

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

_mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 of file reference_counter.h.

_n_objects

Threads::atomic< unsigned int > libMesh::ReferenceCounter::_n_objects

staticprotectedinherited

The number of objects.

Print the reference count information when the number returns to 0.

Definition at line 132 of file reference_counter.h.

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

Aq_Aq_representor_innerprods

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

inherited

Definition at line 336 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 352 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 277 of file rb_evaluation.h.

Referenced by libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::RBEvaluation::clear(), 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(), libMesh::RBConstruction::train_reduced_basis_with_POD(), 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 363 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::RBEvaluation::resize_data_structures(), and libMesh::TransientRBEvaluation::TransientRBEvaluation().

elasticity_theta_expansion

ElasticityThetaExpansion ElasticityRBEvaluation::elasticity_theta_expansion

The object that stores the "theta" expansion of the parameter dependent PDE, i.e.

the set of parameter-dependent functions in the affine expansion of the PDE.

Definition at line 42 of file rb_classes.h.

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 358 of file rb_evaluation.h.

Referenced by libMesh::TransientRBEvaluation::rb_solve(), and libMesh::RBEvaluation::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 335 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 326 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 283 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_with_greedy(), and libMesh::RBConstruction::update_greedy_param_list().

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

RB_Aq_vector

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

inherited

Dense matrices for the RB computations.

Definition at line 296 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 301 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 291 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::RBEvaluation::resize_data_structures(), libMesh::TransientRBConstruction::set_error_temporal_data(), and libMesh::RBConstruction::update_RB_system_matrices().

RB_output_error_bounds

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

inherited

Definition at line 318 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 311 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 317 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 306 of file rb_evaluation.h.

Referenced by libMesh::TransientRBEvaluation::compute_residual_dual_norm(), libMesh::RBEvaluation::compute_residual_dual_norm(), libMesh::RBConstruction::load_rb_solution(), libMesh::TransientRBEvaluation::rb_solve(), libMesh::RBEvaluation::rb_solve(), libMesh::TransientRBEvaluation::rb_solve_again(), and libMesh::TransientRBEvaluation::uncached_compute_residual_dual_norm().

verbose_mode

bool libMesh::RBParametrized::verbose_mode

inherited

Public boolean to toggle verbose mode.

Definition at line 191 of file rb_parametrized.h.

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

---

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

• examples/reduced_basis/reduced_basis_ex5/rb_classes.h