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. More...
virtual	~RBParametrized ()
	Destructor. More...
virtual void	clear ()
	Clear all the data structures associated with the system. More...
void	initialize_parameters (const RBParameters &mu_min_in, const RBParameters &mu_max_in, const std::map< std::string, std::vector< Real >> &discrete_parameter_values)
	Initialize the parameter ranges and set current_parameters. More...
void	initialize_parameters (const RBParametrized &rb_parametrized)
	Initialize the parameter ranges and set current_parameters. More...
unsigned int	get_n_params () const
	Get the number of parameters. More...
unsigned int	get_n_continuous_params () const
	Get the number of continuous parameters. More...
unsigned int	get_n_discrete_params () const
	Get the number of discrete parameters. More...
std::set< std::string >	get_parameter_names () const
	Get a set that stores the parameter names. More...
const RBParameters &	get_parameters () const
	Get the current parameters. More...
void	set_parameters (const RBParameters &params)
	Set the current parameters to params. More...
const RBParameters &	get_parameters_min () const
	Get an RBParameters object that specifies the minimum allowable value for each parameter. More...
const RBParameters &	get_parameters_max () const
	Get an RBParameters object that specifies the maximum allowable value for each parameter. More...
Real	get_parameter_min (const std::string &param_name) const
	Get minimum allowable value of parameter param_name. More...
Real	get_parameter_max (const std::string &param_name) const
	Get maximum allowable value of parameter param_name. More...
void	print_parameters () const
	Print the current parameters. More...
void	write_parameter_data_to_files (const std::string &continuous_param_file_name, const std::string &discrete_param_file_name, const bool write_binary_data)
	Write out the parameter ranges to files. More...
void	read_parameter_data_from_files (const std::string &continuous_param_file_name, const std::string &discrete_param_file_name, const bool read_binary_data)
	Read in the parameter ranges from files. More...
bool	is_discrete_parameter (const std::string &mu_name) const
	Is parameter mu_name discrete? More...
const std::map< std::string, std::vector< Real > > &	get_discrete_parameter_values () const
	Get a const reference to the discrete parameter values. More...
void	print_discrete_parameter_values () const
	Print out all the discrete parameter values. More...

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

Public Attributes
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)
	Increments the construction counter. More...
void	increment_destructor_count (const std::string &name)
	Increments the destruction counter. More...

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

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

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

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

Detailed Description

This class is part of the rbOOmit framework.

This class defines basic functionality of a parametrized object.

Author

David J. Knezevic

Date

2011

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

Constructor & Destructor Documentation

RBParametrized()

libMesh::RBParametrized::RBParametrized

(

)

Constructor.

Definition at line 37 of file rb_parametrized.C.

  :
  verbose_mode(false),
  parameters_initialized(false)
{
  parameters.clear();
  parameters_min.clear();
  parameters_max.clear();
}

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

~RBParametrized()

libMesh::RBParametrized::~RBParametrized ( )

virtual

Destructor.

Definition at line 47 of file rb_parametrized.C.

{
  this->clear();
}

References clear().

Member Function Documentation

clear()

void libMesh::RBParametrized::clear ( )

virtual

Clear all the data structures associated with the system.

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

Definition at line 52 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.

Referenced by ~RBParametrized().

disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 106 of file reference_counter.C.

{
  _enable_print_counter = false;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

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

enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Definition at line 100 of file reference_counter.C.

{
  _enable_print_counter = true;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

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

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

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

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

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

References _discrete_parameter_values, and parameters_initialized.

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

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

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

get_n_continuous_params()

unsigned int libMesh::RBParametrized::get_n_continuous_params

(

)

const

Get the number of continuous parameters.

Definition at line 125 of file rb_parametrized.C.

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

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

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

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

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

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

Referenced by libMesh::RBConstruction::compute_max_error_bound(), libMesh::RBEIMTheta::evaluate(), get_n_continuous_params(), libMesh::RBSCMConstruction::print_info(), libMesh::RBConstruction::print_info(), and valid_params().

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

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

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

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

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

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

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

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

get_parameter_names()

std::set< std::string > libMesh::RBParametrized::get_parameter_names

(

)

const

Get a set that stores the parameter names.

Definition at line 144 of file rb_parametrized.C.

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

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

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

get_parameters()

const RBParameters & libMesh::RBParametrized::get_parameters

(

)

const

Get the current parameters.

Definition at line 166 of file rb_parametrized.C.

{
  if (!parameters_initialized)
    libmesh_error_msg("Error: parameters not initialized in RBParametrized::get_current_parameters");
 
  return parameters;
}

References parameters, and parameters_initialized.

Referenced by libMesh::TransientRBConstruction::add_scaled_mass_matrix(), libMesh::TransientRBEvaluation::cache_online_residual_terms(), libMesh::RBEIMConstruction::compute_best_fit_error(), libMesh::RBEvaluation::compute_residual_dual_norm(), libMesh::RBSCMConstruction::compute_SCM_bounds_on_training_set(), libMesh::RBSCMConstruction::enrich_C_J(), libMesh::RBEIMConstruction::enrich_RB_space(), libMesh::RBEIMTheta::evaluate(), libMesh::RBEIMEvaluation::evaluate_parametrized_function(), libMesh::RBSCMConstruction::evaluate_stability_constant(), libMesh::RBConstruction::get_RB_error_bound(), libMesh::RBSCMEvaluation::get_SCM_LB(), libMesh::RBSCMEvaluation::get_SCM_UB(), SimpleRBEvaluation::get_stability_lower_bound(), libMesh::RBConstruction::greedy_termination_test(), libMesh::RBSCMEvaluation::legacy_read_offline_data_from_files(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::RBSCMConstruction::print_info(), libMesh::RBConstruction::print_info(), print_parameters(), libMesh::RBSCMConstruction::process_parameters_file(), libMesh::TransientRBEvaluation::rb_solve(), libMesh::RBEvaluation::rb_solve(), libMesh::RBEIMEvaluation::rb_solve(), libMesh::RBSCMEvaluation::save_current_parameters(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_assembly(), libMesh::TransientRBConstruction::truth_solve(), libMesh::RBEIMConstruction::truth_solve(), libMesh::RBConstruction::truth_solve(), libMesh::TransientRBEvaluation::uncached_compute_residual_dual_norm(), and libMesh::RBConstruction::update_greedy_param_list().

get_parameters_max()

const RBParameters & libMesh::RBParametrized::get_parameters_max

(

)

const

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

Definition at line 182 of file rb_parametrized.C.

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

References 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(), 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 174 of file rb_parametrized.C.

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

References 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(), and write_parameter_ranges_to_file().

increment_constructor_count()

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

inlineprotectedinherited

Increments the construction counter.

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

Definition at line 181 of file reference_counter.h.

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

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

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

increment_destructor_count()

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

inlineprotectedinherited

Increments the destruction counter.

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

Definition at line 194 of file reference_counter.h.

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

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

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

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

Definition at line 60 of file rb_parametrized.C.

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

References _discrete_parameter_values, libMesh::RBParameters::get_value(), libMesh::RBParameters::n_parameters(), 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::RBEIMConstruction::initialize_parametrized_functions_in_training_set(), 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(), and libMesh::RBConstruction::train_reduced_basis().

initialize_parameters() [2/2]

void libMesh::RBParametrized::initialize_parameters

(

const RBParametrized &

rb_parametrized

)

Initialize the parameter ranges and set current_parameters.

Definition at line 108 of file rb_parametrized.C.

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

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

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

References _discrete_parameter_values, and parameters_initialized.

Referenced by libMesh::RBDataSerialization::add_parameter_ranges_to_builder(), libMesh::RBConstruction::print_info(), valid_params(), 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 453 of file rb_parametrized.C.

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

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

Referenced by 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 83 of file reference_counter.h.

  { return _n_objects; }

References libMesh::ReferenceCounter::_n_objects.

print_discrete_parameter_values()

void libMesh::RBParametrized::print_discrete_parameter_values

(

)

const

Print out all the discrete parameter values.

Definition at line 389 of file rb_parametrized.C.

{
  for (const auto & pr : get_discrete_parameter_values())
    {
      libMesh::out << "Discrete parameter " << pr.first << ", values: ";
 
      const std::vector<Real> & values = pr.second;
      for (const auto & value : values)
        libMesh::out << value << " ";
      libMesh::out << std::endl;
    }
}

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

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

print_info()

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

staticinherited

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

Definition at line 87 of file reference_counter.C.

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

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

print_parameters()

void libMesh::RBParametrized::print_parameters

(

)

const

Print the current parameters.

Definition at line 206 of file rb_parametrized.C.

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

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

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

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

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

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

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

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

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

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

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

Referenced by read_parameter_data_from_files().

set_parameters()

void libMesh::RBParametrized::set_parameters

(

const RBParameters &

params

)

Set the current parameters to params.

Definition at line 155 of file rb_parametrized.C.

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

References parameters, parameters_initialized, and valid_params().

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

valid_params()

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

private

Helper function to check that params is valid.

Definition at line 402 of file rb_parametrized.C.

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

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

Referenced by set_parameters().

write_discrete_parameter_values_to_file()

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

private

Write out the discrete parameter values to file.

Definition at line 255 of file rb_parametrized.C.

{
  // write out the discrete parameters, if we have any
  if (get_n_discrete_params() > 0)
    {
      // The writing mode: ENCODE for binary, WRITE for ASCII
      XdrMODE mode = write_binary_data ? ENCODE : WRITE;
 
      Xdr discrete_parameters_out(file_name, mode);
      unsigned int n_discrete_params = get_n_discrete_params();
      discrete_parameters_out << n_discrete_params;
 
      for (const auto & pr : get_discrete_parameter_values())
        {
          std::string param_name = pr.first;
          unsigned int n_discrete_values = cast_int<unsigned int>
            (pr.second.size());
          discrete_parameters_out << param_name << n_discrete_values;
 
          for (unsigned int i=0; i<n_discrete_values; i++)
            {
              Real discrete_value = pr.second[i];
              discrete_parameters_out << discrete_value;
            }
        }
    }
}

References libMesh::ENCODE, 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 214 of file rb_parametrized.C.

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

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

{
  // The writing mode: ENCODE for binary, WRITE for ASCII
  XdrMODE mode = write_binary_data ? ENCODE : WRITE;
 
  // Write out the parameter ranges
  Xdr parameter_ranges_out(file_name, mode);
  unsigned int n_continuous_params = get_n_continuous_params();
  parameter_ranges_out << n_continuous_params;
 
  for (const auto & pr : get_parameters_min())
    {
      std::string param_name = pr.first;
      if (!is_discrete_parameter(param_name))
        {
          Real param_value = pr.second;
          parameter_ranges_out << param_name << param_value;
        }
    }
 
  for (const auto & pr : get_parameters_max())
    {
      std::string param_name = pr.first;
      if (!is_discrete_parameter(param_name))
        {
          Real param_value = pr.second;
          parameter_ranges_out << param_name << param_value;
        }
    }
  parameter_ranges_out.close();
}

References libMesh::Xdr::close(), libMesh::ENCODE, get_n_continuous_params(), get_parameters_max(), get_parameters_min(), 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 122 of file reference_counter.h.

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

_discrete_parameter_values

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

private

Map that defines the allowable values of any discrete parameters.

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

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

_mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 135 of file reference_counter.h.

_n_objects

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

staticprotectedinherited

The number of objects.

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

Definition at line 130 of file reference_counter.h.

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

parameters

RBParameters libMesh::RBParametrized::parameters

private

Vector storing the current parameters.

Definition at line 224 of file rb_parametrized.h.

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

parameters_initialized

bool libMesh::RBParametrized::parameters_initialized

private

Flag indicating whether the parameters have been initialized.

Definition at line 219 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_parameter_names(), 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 230 of file rb_parametrized.h.

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

parameters_min

RBParameters libMesh::RBParametrized::parameters_min

private

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

Definition at line 229 of file rb_parametrized.h.

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

verbose_mode

bool libMesh::RBParametrized::verbose_mode

Public boolean to toggle verbose mode.

Definition at line 170 of file rb_parametrized.h.

Referenced by 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