libMesh::RBParametrized Class Reference

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

#include <rb_parametrized.h>

Inheritance diagram for libMesh::RBParametrized:

Public Member Functions
	RBParametrized ()
	Constructor.
	RBParametrized (RBParametrized &&)=default
	Special functions.
RBParametrized &	operator= (RBParametrized &&)=default
	RBParametrized (const RBParametrized &)=default
RBParametrized &	operator= (const RBParametrized &)=default
virtual	~RBParametrized ()
virtual void	clear ()
	Clear all the data structures associated with the system.
void	initialize_parameters (const RBParameters &mu_min_in, const RBParameters &mu_max_in, const std::map< std::string, std::vector< Real > > &discrete_parameter_values)
	Initialize the parameter ranges and set current_parameters.
void	initialize_parameters (const RBParametrized &rb_parametrized)
	Initialize the parameter ranges and set current_parameters.
unsigned int	get_n_params () const
	Get the number of parameters.
unsigned int	get_n_continuous_params () const
	Get the number of continuous parameters.
unsigned int	get_n_discrete_params () const
	Get the number of discrete parameters.
const RBParameters &	get_parameters () const
	Get the current parameters.
bool	set_parameters (const RBParameters &params)
	Set the current parameters to params The parameters are checked for validity; an error is thrown if the number of parameters or samples is different than expected.
const RBParameters &	get_parameters_min () const
	Get an RBParameters object that specifies the minimum allowable value for each parameter.
const RBParameters &	get_parameters_max () const
	Get an RBParameters object that specifies the maximum allowable value for each parameter.
Real	get_parameter_min (const std::string &param_name) const
	Get minimum allowable value of parameter param_name.
Real	get_parameter_max (const std::string &param_name) const
	Get maximum allowable value of parameter param_name.
void	print_parameters () const
	Print the current parameters.
void	write_parameter_data_to_files (const std::string &continuous_param_file_name, const std::string &discrete_param_file_name, const bool write_binary_data)
	Write out the parameter ranges to files.
void	read_parameter_data_from_files (const std::string &continuous_param_file_name, const std::string &discrete_param_file_name, const bool read_binary_data)
	Read in the parameter ranges from files.
bool	is_discrete_parameter (const std::string &mu_name) const
	Is parameter mu_name discrete?
const std::map< std::string, std::vector< Real > > &	get_discrete_parameter_values () const
	Get a const reference to the discrete parameter values.
void	print_discrete_parameter_values () const
	Print out all the discrete parameter values.

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

Public Attributes
bool	verbose_mode
	Public boolean to toggle verbose mode.

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

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

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

Private Member Functions
void	write_parameter_ranges_to_file (const std::string &file_name, const bool write_binary)
	Write out the parameter ranges to file.
void	write_discrete_parameter_values_to_file (const std::string &file_name, const bool write_binary_data)
	Write out the discrete parameter values to file.
void	read_parameter_ranges_from_file (const std::string &file_name, const bool read_binary, RBParameters &param_min, RBParameters &param_max)
	Read in the parameter ranges from file.
void	read_discrete_parameter_values_from_file (const std::string &file_name, const bool read_binary_data, std::map< std::string, std::vector< Real > > &discrete_parameter_values_in)
	Read in the discrete parameter values from file, if we have any.
bool	check_if_valid_params (const RBParameters &params) const
	Helper function to check that params is valid:

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

Private Attributes
bool	parameters_initialized
	Flag indicating whether the parameters have been initialized.
RBParameters	parameters
	Vector storing the current parameters.
RBParameters	parameters_min
	Vectors that define the ranges (min and max) for the parameters.
RBParameters	parameters_max
std::map< std::string, std::vector< Real > >	_discrete_parameter_values
	Map that defines the allowable values of any discrete parameters.

Detailed Description

This class is part of the rbOOmit framework.

This class defines basic functionality of a parametrized object.

Author

David J. Knezevic

Date

2011

Definition at line 45 of file rb_parametrized.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

RBParametrized() [1/3]

libMesh::RBParametrized::RBParametrized

(

)

Constructor.

Definition at line 36 of file rb_parametrized.C.

  :
  verbose_mode(false),
  parameters_initialized(false)
{
}

RBParametrized() [2/3]

libMesh::RBParametrized::RBParametrized ( RBParametrized &&  )

default

Special functions.

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

RBParametrized() [3/3]

libMesh::RBParametrized::RBParametrized ( const RBParametrized &  )

default

~RBParametrized()

libMesh::RBParametrized::~RBParametrized ( )

virtualdefault

Member Function Documentation

check_if_valid_params()

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

private

Helper function to check that params is valid:

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

Definition at line 378 of file rb_parametrized.C.

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

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

Referenced by set_parameters().

clear()

void libMesh::RBParametrized::clear ( )

virtual

Clear all the data structures associated with the system.

Reimplemented in libMesh::RBConstructionBase< Base >, libMesh::RBConstructionBase< CondensedEigenSystem >, libMesh::RBConstructionBase< LinearImplicitSystem >, libMesh::RBConstructionBase< System >, libMesh::RBConstruction, libMesh::RBEIMConstruction, libMesh::RBEIMEvaluation, libMesh::RBEvaluation, libMesh::RBSCMConstruction, libMesh::TransientRBConstruction, libMesh::TransientRBEvaluation, and libMesh::TransientSystem< RBConstruction >.

Definition at line 45 of file rb_parametrized.C.

{
  parameters.clear();
  parameters_min.clear();
  parameters_max.clear();
  parameters_initialized = false;
}

References libMesh::RBParameters::clear(), parameters, parameters_initialized, parameters_max, and parameters_min.

disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 100 of file reference_counter.C.

{
  _enable_print_counter = false;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Enabled by default.

Definition at line 94 of file reference_counter.C.

{
  _enable_print_counter = true;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

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

get_closest_value()

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

static

Returns

The closest entry to value from list_of_values.

Definition at line 432 of file rb_parametrized.C.

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

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

Referenced by is_value_in_list().

get_discrete_parameter_values()

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

(

)

const

Get a const reference to the discrete parameter values.

Definition at line 359 of file rb_parametrized.C.

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

References _discrete_parameter_values, and parameters_initialized.

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

get_info()

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

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
 
  std::ostringstream oss;
 
  oss << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";
 
  for (const auto & [name, cd] : _counts)
    oss << "| " << name << " reference count information:\n"
        << "|  Creations:    " << cd.first    << '\n'
        << "|  Destructions: " << cd.second << '\n';
 
  oss << " ---------------------------------------------------------------------------- \n";
 
  return oss.str();
 
#else
 
  return "";
 
#endif
}

References libMesh::ReferenceCounter::_counts.

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

get_n_continuous_params()

unsigned int libMesh::RBParametrized::get_n_continuous_params

(

)

const

Get the number of continuous parameters.

Definition at line 112 of file rb_parametrized.C.

{
  libmesh_error_msg_if(!parameters_initialized, "Error: parameters not initialized in RBParametrized::get_n_continuous_params");
 
  libmesh_assert(get_n_params() >= get_n_discrete_params());
 
  return static_cast<unsigned int>(get_n_params() - get_n_discrete_params());
}

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

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

get_n_discrete_params()

unsigned int libMesh::RBParametrized::get_n_discrete_params

(

)

const

Get the number of discrete parameters.

Definition at line 121 of file rb_parametrized.C.

{
  libmesh_error_msg_if(!parameters_initialized, "Error: parameters not initialized in RBParametrized::get_n_discrete_params");
 
  return cast_int<unsigned int>
    (get_discrete_parameter_values().size());
}

References get_discrete_parameter_values(), and parameters_initialized.

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

get_n_params()

unsigned int libMesh::RBParametrized::get_n_params

(

)

const

Get the number of parameters.

Definition at line 103 of file rb_parametrized.C.

{
  libmesh_error_msg_if(!parameters_initialized, "Error: parameters not initialized in RBParametrized::get_n_params");
 
  libmesh_assert_equal_to ( parameters_min.n_parameters(), parameters_max.n_parameters() );
 
  return parameters_min.n_parameters();
}

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

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

get_parameter_max()

Real libMesh::RBParametrized::get_parameter_max

(

const std::string &

param_name

)

const

Get maximum allowable value of parameter param_name.

Definition at line 171 of file rb_parametrized.C.

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

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

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

get_parameter_min()

Real libMesh::RBParametrized::get_parameter_min

(

const std::string &

param_name

)

const

Get minimum allowable value of parameter param_name.

Definition at line 164 of file rb_parametrized.C.

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

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

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

get_parameters()

const RBParameters & libMesh::RBParametrized::get_parameters

(

)

const

Get the current parameters.

Definition at line 143 of file rb_parametrized.C.

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

References parameters, and parameters_initialized.

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

get_parameters_max()

const RBParameters & libMesh::RBParametrized::get_parameters_max

(

)

const

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

Definition at line 157 of file rb_parametrized.C.

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

References parameters_initialized, and parameters_max.

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

get_parameters_min()

const RBParameters & libMesh::RBParametrized::get_parameters_min

(

)

const

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

Definition at line 150 of file rb_parametrized.C.

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

References parameters_initialized, and parameters_min.

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

increment_constructor_count()

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

inlineprotectednoexceptinherited

Increments the construction counter.

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

Definition at line 183 of file reference_counter.h.

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

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

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

increment_destructor_count()

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

inlineprotectednoexceptinherited

Increments the destruction counter.

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

Definition at line 207 of file reference_counter.h.

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

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

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

initialize_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
	)

Initialize the parameter ranges and set current_parameters.

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

Definition at line 53 of file rb_parametrized.C.

{
  // Check that the min/max vectors have the same size.
  libmesh_error_msg_if(mu_min_in.n_parameters() != mu_max_in.n_parameters(),
                       "Error: Invalid mu_min/mu_max in initialize_parameters(), different number of parameters.");
  libmesh_error_msg_if(mu_min_in.n_samples() != 1 ||
                       mu_max_in.n_samples() != 1,
                       "Error: Invalid mu_min/mu_max in initialize_parameters(), only 1 sample supported.");
 
  // Ensure all the values are valid for min and max.
  auto pr_min = mu_min_in.begin_serialized();
  auto pr_max = mu_max_in.begin_serialized();
  for (; pr_min != mu_min_in.end_serialized(); ++pr_min, ++pr_max)
    libmesh_error_msg_if((*pr_min).second > (*pr_max).second,
                         "Error: Invalid mu_min/mu_max in RBParameters constructor.");
 
  parameters_min = mu_min_in;
  parameters_max = mu_max_in;
 
  // Add in min/max values due to the discrete parameters
  for (const auto & [name, vals] : discrete_parameter_values)
    {
      libmesh_error_msg_if(vals.empty(), "Error: List of discrete parameters for " << name << " is empty.");
 
      Real min_val = *std::min_element(vals.begin(), vals.end());
      Real max_val = *std::max_element(vals.begin(), vals.end());
 
      libmesh_assert_less_equal(min_val, max_val);
 
      parameters_min.set_value(name, min_val);
      parameters_max.set_value(name, max_val);
    }
 
    _discrete_parameter_values = discrete_parameter_values;
 
  parameters_initialized = true;
 
  // Initialize the current parameters to parameters_min
  set_parameters(parameters_min);
}

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

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

initialize_parameters() [2/2]

void libMesh::RBParametrized::initialize_parameters

(

const RBParametrized &

rb_parametrized

)

Initialize the parameter ranges and set current_parameters.

Definition at line 96 of file rb_parametrized.C.

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

References get_discrete_parameter_values(), get_parameters_max(), get_parameters_min(), and initialize_parameters().

is_discrete_parameter()

bool libMesh::RBParametrized::is_discrete_parameter

(

const std::string &

mu_name

)

const

Is parameter mu_name discrete?

Definition at line 351 of file rb_parametrized.C.

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

References _discrete_parameter_values, and parameters_initialized.

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

is_value_in_list()

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

staticprivate

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

Definition at line 451 of file rb_parametrized.C.

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

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

Referenced by check_if_valid_params().

n_objects()

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

inlinestaticinherited

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

Definition at line 85 of file reference_counter.h.

  { return _n_objects; }

References libMesh::ReferenceCounter::_n_objects.

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

operator=() [1/2]

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

default

operator=() [2/2]

RBParametrized & libMesh::RBParametrized::operator= ( RBParametrized &&  )

default

print_discrete_parameter_values()

void libMesh::RBParametrized::print_discrete_parameter_values

(

)

const

Print out all the discrete parameter values.

Definition at line 366 of file rb_parametrized.C.

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

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

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

print_info()

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

staticinherited

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

Definition at line 81 of file reference_counter.C.

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

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

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

print_parameters()

void libMesh::RBParametrized::print_parameters

(

)

const

Print the current parameters.

Definition at line 178 of file rb_parametrized.C.

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

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

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

read_discrete_parameter_values_from_file()

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

private

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

Definition at line 318 of file rb_parametrized.C.

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

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

Referenced by read_parameter_data_from_files().

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
	)

Read in the parameter ranges from files.

Definition at line 262 of file rb_parametrized.C.

{
  RBParameters param_min;
  RBParameters param_max;
  read_parameter_ranges_from_file(continuous_param_file_name,
                                  read_binary_data,
                                  param_min,
                                  param_max);
 
  std::map<std::string, std::vector<Real>> discrete_parameter_values_in;
  read_discrete_parameter_values_from_file(discrete_param_file_name,
                                           read_binary_data,
                                           discrete_parameter_values_in);
 
  initialize_parameters(param_min, param_max, discrete_parameter_values_in);
}

References initialize_parameters(), read_discrete_parameter_values_from_file(), and read_parameter_ranges_from_file().

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

read_parameter_ranges_from_file()

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

private

Read in the parameter ranges from file.

Initialize parameters to the "minimum" parameter values.

Definition at line 281 of file rb_parametrized.C.

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

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

Referenced by read_parameter_data_from_files().

set_parameters()

bool libMesh::RBParametrized::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.

We

Returns

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

Definition at line 129 of file rb_parametrized.C.

{
  libmesh_error_msg_if(!parameters_initialized, "Error: parameters not initialized in RBParametrized::set_parameters");
 
  // Terminate if params has the wrong number of parameters or samples.
  // If the parameters are outside the min/max range, return false.
  const bool valid_params = check_if_valid_params(params);
 
  // Make a copy of params (default assignment operator just does memberwise copy, which is sufficient here)
  this->parameters = params;
 
  return valid_params;
}

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

write_discrete_parameter_values_to_file()

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

private

Write out the discrete parameter values to file.

Definition at line 230 of file rb_parametrized.C.

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

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

Referenced by write_parameter_data_to_files().

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
	)

Write out the parameter ranges to files.

Definition at line 185 of file rb_parametrized.C.

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

References write_discrete_parameter_values_to_file(), and write_parameter_ranges_to_file().

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

write_parameter_ranges_to_file()

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

private

Write out the parameter ranges to file.

Definition at line 193 of file rb_parametrized.C.

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

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

Referenced by write_parameter_data_to_files().

Member Data Documentation

_counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

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

_discrete_parameter_values

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

private

Map that defines the allowable values of any discrete parameters.

Definition at line 250 of file rb_parametrized.h.

Referenced by get_discrete_parameter_values(), initialize_parameters(), and is_discrete_parameter().

_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(), libMesh::ReferenceCounter::ReferenceCounter(), libMesh::ReferenceCounter::ReferenceCounter(), and libMesh::ReferenceCounter::~ReferenceCounter().

parameters

RBParameters libMesh::RBParametrized::parameters

private

Vector storing the current parameters.

Definition at line 239 of file rb_parametrized.h.

Referenced by clear(), get_parameters(), and set_parameters().

parameters_initialized

bool libMesh::RBParametrized::parameters_initialized

private

Flag indicating whether the parameters have been initialized.

Definition at line 234 of file rb_parametrized.h.

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

parameters_max

RBParameters libMesh::RBParametrized::parameters_max

private

Definition at line 245 of file rb_parametrized.h.

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

parameters_min

RBParameters libMesh::RBParametrized::parameters_min

private

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

Definition at line 244 of file rb_parametrized.h.

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

verbose_mode

bool libMesh::RBParametrized::verbose_mode

Public boolean to toggle verbose mode.

Definition at line 181 of file rb_parametrized.h.

Referenced by check_if_valid_params().

---

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

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