libMesh::RBConstructionBase< Base > Class Template Reference

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

#include <rb_construction_base.h>

Inheritance diagram for libMesh::RBConstructionBase< Base >:

Public Types
typedef RBConstructionBase< Base >	sys_type
	The type of system. More...

Public Member Functions
	RBConstructionBase (EquationSystems &es, const std::string &name, const unsigned int number)
	Constructor. More...
virtual	~RBConstructionBase ()
	Destructor. More...
sys_type &	system ()
virtual void	clear ()
	Clear all the data structures associated with the system. More...
void	set_quiet_mode (bool quiet_mode_in)
	Set the quiet_mode flag. More...
bool	is_quiet () const
	Is the system in quiet mode? More...
numeric_index_type	get_n_training_samples () const
	Get the total number of training samples. More...
numeric_index_type	get_local_n_training_samples () const
	Get the total number of training samples local to this processor. More...
numeric_index_type	get_first_local_training_index () const
	Get the first local index of the training parameters. More...
numeric_index_type	get_last_local_training_index () const
	Get the last local index of the training parameters. More...
virtual void	initialize_training_parameters (const RBParameters &mu_min, const RBParameters &mu_max, unsigned int n_training_parameters, std::map< std::string, bool > log_param_scale, bool deterministic=true)
	Initialize the parameter ranges and indicate whether deterministic or random training parameters should be used and whether or not we want the parameters to be scaled logarithmically. More...
virtual void	load_training_set (std::map< std::string, std::vector< Number >> &new_training_set)
	Overwrite the training parameters with new_training_set. More...
void	broadcast_parameters (unsigned int proc_id)
	Broadcasts parameters on processor proc_id to all processors. More...
void	set_training_random_seed (unsigned int seed)
	Set the seed that is used to randomly generate training parameters. More...
void	set_deterministic_training_parameter_name (const std::string &name)
	In some cases we only want to allow discrete parameter values, instead of parameters that may take any value in a specified interval. More...
const std::string &	get_deterministic_training_parameter_name () const
	Get the name of the parameter that we will generate deterministic training parameters for. More...
void	set_deterministic_training_parameter_repeats (unsigned int repeats)
	Set the number of times each sample of the deterministic training parameter is repeated. More...
unsigned int	get_deterministic_training_parameter_repeats () const
	Get the number of times each sample of the deterministic training parameter is repeated. 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
virtual void	init_data ()
	Initializes the member data fields associated with the system, so that, e.g., assemble() may be used. More...
RBParameters	get_params_from_training_set (unsigned int index)
	Return the RBParameters in index index of training set. More...
void	set_params_from_training_set (unsigned int index)
	Set parameters to the RBParameters stored in index index of the training set. More...
virtual void	set_params_from_training_set_and_broadcast (unsigned int index)
	Load the specified training parameter and then broadcast to all processors. More...
void	increment_constructor_count (const std::string &name)
	Increments the construction counter. More...
void	increment_destructor_count (const std::string &name)
	Increments the destruction counter. More...

Static Protected Member Functions
static void	get_global_max_error_pair (const Parallel::Communicator &communicator, std::pair< numeric_index_type, Real > &error_pair)
	Static function to return the error pair (index,error) that is corresponds to the largest error on all processors. More...
static void	generate_training_parameters_random (const Parallel::Communicator &communicator, std::map< std::string, bool > log_param_scale, std::map< std::string, std::unique_ptr< NumericVector< Number >>> &training_parameters_in, unsigned int n_training_samples_in, const RBParameters &min_parameters, const RBParameters &max_parameters, int training_parameters_random_seed=-1, bool serial_training_set=false)
	Static helper function for generating a randomized set of parameters. More...
static void	generate_training_parameters_deterministic (const Parallel::Communicator &communicator, std::map< std::string, bool > log_param_scale, std::map< std::string, std::unique_ptr< NumericVector< Number >>> &training_parameters_in, unsigned int n_training_samples_in, const RBParameters &min_parameters, const RBParameters &max_parameters, bool serial_training_set=false)
	Static helper function for generating a deterministic set of parameters. More...

Protected Attributes
bool	quiet_mode
	Flag to indicate whether we print out extra information during the Offline stage. More...
bool	serial_training_set
	This boolean flag indicates whether or not the training set should be the same on all processors. More...
std::unique_ptr< NumericVector< Number > >	inner_product_storage_vector
	We keep an extra temporary vector that is useful for performing inner products (avoids unnecessary memory allocation/deallocation). 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	training_parameters_initialized
	Boolean flag to indicate whether or not the parameter ranges have been initialized. More...
std::map< std::string, std::unique_ptr< NumericVector< Number > > >	training_parameters
	The training samples. More...
int	training_parameters_random_seed
	If < 0, use std::time() * processor_id() to seed the random number generator for the training parameters (default). More...
bool	parameters_initialized
	Flag indicating whether the parameters have been initialized. More...
RBParameters	parameters
	Vector storing the current parameters. More...
RBParameters	parameters_min
	Vectors that define the ranges (min and max) for the parameters. More...
RBParameters	parameters_max
std::map< std::string, std::vector< Real > >	_discrete_parameter_values
	Map that defines the allowable values of any discrete parameters. More...

Detailed Description

template<class Base>
class libMesh::RBConstructionBase< Base >

This class is part of the rbOOmit framework.

This is the base class for the Construction stage of the certified reduced basis (RB) method. We template the Base class so that we can derive from the appropriate libMesh System type (e.g. LinearImplicitSystem for standard reduced basis, EigenSystem for SCM) at compile time.

Author

David J. Knezevic

Date

2009

Definition at line 54 of file rb_construction_base.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.

sys_type

template<class Base>

typedef RBConstructionBase<Base> libMesh::RBConstructionBase< Base >::sys_type

The type of system.

Definition at line 74 of file rb_construction_base.h.

Constructor & Destructor Documentation

RBConstructionBase()

template<class Base >

libMesh::RBConstructionBase< Base >::RBConstructionBase	(	EquationSystems &	es,
		const std::string &	name,
		const unsigned int	number
	)

Constructor.

Initializes required data structures.

Definition at line 46 of file rb_construction_base.C.

  : Base(es, name_in, number_in),
    quiet_mode(true),
    serial_training_set(false),
    training_parameters_initialized(false),
    training_parameters_random_seed(-1) // by default, use std::time to seed RNG
{
  training_parameters.clear();
}

~RBConstructionBase()

template<class Base >

libMesh::RBConstructionBase< Base >::~RBConstructionBase ( )

virtual

Destructor.

Definition at line 59 of file rb_construction_base.C.

{
  this->clear();
}

Member Function Documentation

broadcast_parameters()

template<class Base >

void libMesh::RBConstructionBase< Base >::broadcast_parameters

(

unsigned int

proc_id

)

Broadcasts parameters on processor proc_id to all processors.

Definition at line 600 of file rb_construction_base.C.

{
  libmesh_assert_less (proc_id, this->n_processors());
 
  // create a copy of the current parameters
  RBParameters current_parameters = get_parameters();
 
  // copy current_parameters to current_parameters_vector in order to broadcast
  std::vector<Real> current_parameters_vector;
 
  for (const auto & pr : current_parameters)
    current_parameters_vector.push_back(pr.second);
 
  // do the broadcast
  this->comm().broadcast(current_parameters_vector, proc_id);
 
  // update the copy of the RBParameters object
  unsigned int count = 0;
  for (const auto & pr : current_parameters)
    {
      const std::string & param_name = pr.first;
      current_parameters.set_value(param_name, current_parameters_vector[count]);
      count++;
    }
 
  // set the parameters globally
  set_parameters(current_parameters);
}

clear()

template<class Base >

void libMesh::RBConstructionBase< Base >::clear ( )

virtual

Clear all the data structures associated with the system.

Reimplemented from libMesh::RBParametrized.

Reimplemented in libMesh::RBConstruction, libMesh::TransientSystem< RBConstruction >, libMesh::RBSCMConstruction, libMesh::RBEIMConstruction, and libMesh::TransientRBConstruction.

Definition at line 65 of file rb_construction_base.C.

{
  // clear the parent data
  Base::clear();
  RBParametrized::clear();
  training_parameters.clear();
}

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.

generate_training_parameters_deterministic()

template<class Base >

void libMesh::RBConstructionBase< Base >::generate_training_parameters_deterministic ( const Parallel::Communicator &  communicator, std::map< std::string, bool >  log_param_scale, std::map< std::string, std::unique_ptr< NumericVector< Number >>> &  training_parameters_in, unsigned int  n_training_samples_in, const RBParameters &  min_parameters, const RBParameters &  max_parameters, bool  serial_training_set = false  )

staticprotected

Static helper function for generating a deterministic set of parameters.

Only works with 1 or 2 parameters (as defined by the lengths of min/max parameters vectors), otherwise throws an error.

Definition at line 412 of file rb_construction_base.C.

{
  libmesh_assert_equal_to ( min_parameters.n_parameters(), max_parameters.n_parameters() );
  const unsigned int num_params = min_parameters.n_parameters();
 
  if (num_params == 0)
    return;
 
  if (num_params > 2)
    {
      libMesh::out << "ERROR: Deterministic training sample generation "
                   << " not implemented for more than two parameters." << std::endl;
      libmesh_not_implemented();
    }
 
  // Clear training_parameters_in (but don't remove existing keys!)
  for (auto & pr : training_parameters_in)
    pr.second.reset(nullptr);
 
  // Initialize training_parameters_in
    for (const auto & pr : min_parameters)
      {
        const std::string & param_name = pr.first;
        training_parameters_in[param_name] = NumericVector<Number>::build(communicator);
 
        if (!serial_training_set)
          {
            // Calculate the number of training parameters local to this processor
            unsigned int n_local_training_samples;
            unsigned int quotient  = n_training_samples_in/communicator.size();
            unsigned int remainder = n_training_samples_in%communicator.size();
            if (communicator.rank() < remainder)
              n_local_training_samples = (quotient + 1);
            else
              n_local_training_samples = quotient;
 
            training_parameters_in[param_name]->init(n_training_samples_in, n_local_training_samples, false, PARALLEL);
          }
        else
          {
            training_parameters_in[param_name]->init(n_training_samples_in, false, SERIAL);
          }
      }
 
  if (num_params == 1)
    {
      NumericVector<Number> * training_vector = training_parameters_in.begin()->second.get();
      bool use_log_scaling = log_param_scale.begin()->second;
      Real min_param = min_parameters.begin()->second;
      Real max_param = max_parameters.begin()->second;
 
      numeric_index_type first_index = training_vector->first_local_index();
      for (auto i : IntRange<numeric_index_type>(0, training_vector->local_size()))
        {
          numeric_index_type index = first_index+i;
          if (use_log_scaling)
            {
              Real epsilon = 1.e-6; // Prevent rounding errors triggering asserts
              Real log_min   = log10(min_param + epsilon);
              Real log_range = log10( (max_param-epsilon) / (min_param+epsilon) );
              Real step_size = log_range /
                std::max((unsigned int)1,(n_training_samples_in-1));
 
              if (index<(n_training_samples_in-1))
                {
                  training_vector->set(index, pow(10., log_min + index*step_size ));
                }
              else
                {
                  // due to rounding error, the last parameter can be slightly
                  // bigger than max_parameters, hence snap back to the max
                  training_vector->set(index, max_param);
                }
            }
          else
            {
              // Generate linearly scaled training parameters
              Real step_size = (max_param - min_param) /
                std::max((unsigned int)1,(n_training_samples_in-1));
              training_vector->set(index, index*step_size + min_param);
            }
        }
    }
 
 
  // This is for two parameters
  if (num_params == 2)
    {
      // First make sure n_training_samples_in is a square number
      unsigned int n_training_parameters_per_var = static_cast<unsigned int>( std::sqrt(static_cast<Real>(n_training_samples_in)) );
      if ((n_training_parameters_per_var*n_training_parameters_per_var) != n_training_samples_in)
        libmesh_error_msg("Error: Number of training parameters = " \
                          << n_training_samples_in \
                          << ".\n" \
                          << "Deterministic training set generation with two parameters requires\n " \
                          << "the number of training parameters to be a perfect square.");
 
      // make a matrix to store all the parameters, put them in vector form afterwards
      std::vector<std::vector<Real>> training_parameters_matrix(num_params);
 
      unsigned int i = 0;
      for (const auto & pr : min_parameters)
        {
          const std::string & param_name = pr.first;
          Real min_param = pr.second;
          bool use_log_scaling = log_param_scale[param_name];
          Real max_param = max_parameters.get_value(param_name);
 
          training_parameters_matrix[i].resize(n_training_parameters_per_var);
 
          for (unsigned int j=0; j<n_training_parameters_per_var; j++)
            {
              // Generate log10 scaled training parameters
              if (use_log_scaling)
                {
                  Real epsilon = 1.e-6; // Prevent rounding errors triggering asserts
                  Real log_min   = log10(min_param + epsilon);
                  Real log_range = log10( (max_param-epsilon) / (min_param+epsilon) );
                  Real step_size = log_range /
                    std::max((unsigned int)1,(n_training_parameters_per_var-1));
 
                  if (j<(n_training_parameters_per_var-1))
                    {
                      training_parameters_matrix[i][j] = pow(10., log_min + j*step_size );
                    }
                  else
                    {
                      // due to rounding error, the last parameter can be slightly
                      // bigger than max_parameters, hence snap back to the max
                      training_parameters_matrix[i][j] = max_param;
                    }
                }
              else
                {
                  // Generate linearly scaled training parameters
                  Real step_size = (max_param - min_param) /
                    std::max((unsigned int)1,(n_training_parameters_per_var-1));
                  training_parameters_matrix[i][j] = j*step_size + min_param;
                }
 
            }
          i++;
        }
 
      // now load into training_samples_in:
      std::map<std::string, std::unique_ptr<NumericVector<Number>>>::iterator new_it = training_parameters_in.begin();
 
      NumericVector<Number> * training_vector_0 = new_it->second.get();
      ++new_it;
      NumericVector<Number> * training_vector_1 = new_it->second.get();
 
      for (unsigned int index1=0; index1<n_training_parameters_per_var; index1++)
        {
          for (unsigned int index2=0; index2<n_training_parameters_per_var; index2++)
            {
              unsigned int index = index1*n_training_parameters_per_var + index2;
 
              if ((training_vector_0->first_local_index() <= index) &&
                  (index < training_vector_0->last_local_index()))
                {
                  training_vector_0->set(index, training_parameters_matrix[0][index1]);
                  training_vector_1->set(index, training_parameters_matrix[1][index2]);
                }
            }
        }
 
      //     libMesh::out << "n_training_samples = " << n_training_samples_in << std::endl;
      //     for (unsigned int index=0; index<n_training_samples_in; index++)
      //     {
      //         libMesh::out << "training parameters for index="<<index<<":"<<std::endl;
      //         for (unsigned int param=0; param<num_params; param++)
      //         {
      //           libMesh::out << " " << (*training_parameters_in[param])(index);
      //         }
      //         libMesh::out << std::endl << std::endl;
      //     }
 
    }
}

generate_training_parameters_random()

template<class Base >

void libMesh::RBConstructionBase< Base >::generate_training_parameters_random ( const Parallel::Communicator &  communicator, std::map< std::string, bool >  log_param_scale, std::map< std::string, std::unique_ptr< NumericVector< Number >>> &  training_parameters_in, unsigned int  n_training_samples_in, const RBParameters &  min_parameters, const RBParameters &  max_parameters, int  training_parameters_random_seed = -1, bool  serial_training_set = false  )

staticprotected

Static helper function for generating a randomized set of parameters.

Definition at line 300 of file rb_construction_base.C.

{
  libmesh_assert_equal_to ( min_parameters.n_parameters(), max_parameters.n_parameters() );
  const unsigned int num_params = min_parameters.n_parameters();
 
  // Clear training_parameters_in
  training_parameters_in.clear();
 
  if (num_params == 0)
    return;
 
  if (training_parameters_random_seed < 0)
    {
      if (!serial_training_set)
        {
          // seed the random number generator with the system time
          // and the processor ID so that the seed is different
          // on different processors
          std::srand( static_cast<unsigned>( std::time(0)*(1+communicator.rank()) ));
        }
      else
        {
          // seed the random number generator with the system time
          // only so that the seed is the same on all processors
          //
          // Note that we broadcast the time on processor 0 to make
          // sure all processors agree.
          unsigned int current_time = static_cast<unsigned>( std::time(0) );
          communicator.broadcast(current_time, 0);
          std::srand(current_time);
        }
    }
  else
    {
      if (!serial_training_set)
        {
          // seed the random number generator with the provided value
          // and the processor ID so that the seed is different
          // on different processors
          std::srand( static_cast<unsigned>( training_parameters_random_seed*(1+communicator.rank()) ));
        }
      else
        {
          // seed the random number generator with the provided value
          // so that the seed is the same on all processors
          std::srand( static_cast<unsigned>( training_parameters_random_seed ));
        }
    }
 
  // initialize training_parameters_in
    for (const auto & pr : min_parameters)
      {
        const std::string & param_name = pr.first;
        training_parameters_in[param_name] = NumericVector<Number>::build(communicator);
 
        if (!serial_training_set)
          {
            // Calculate the number of training parameters local to this processor
            unsigned int n_local_training_samples;
            unsigned int quotient  = n_training_samples_in/communicator.size();
            unsigned int remainder = n_training_samples_in%communicator.size();
            if (communicator.rank() < remainder)
              n_local_training_samples = (quotient + 1);
            else
              n_local_training_samples = quotient;
 
            training_parameters_in[param_name]->init(n_training_samples_in, n_local_training_samples, false, PARALLEL);
          }
        else
          {
            training_parameters_in[param_name]->init(n_training_samples_in, false, SERIAL);
          }
      }
 
  // finally, set the values
  for (auto & pr : training_parameters_in)
    {
      const std::string & param_name = pr.first;
      NumericVector<Number> * training_vector = pr.second.get();
 
      numeric_index_type first_index = training_vector->first_local_index();
      for (auto i : IntRange<numeric_index_type>(0, training_vector->local_size()))
        {
          numeric_index_type index = first_index + i;
          Real random_number = static_cast<Real>(std::rand()) / RAND_MAX; // in range [0,1]
 
          // Generate log10 scaled training parameters
          if (log_param_scale[param_name])
            {
              Real log_min   = log10(min_parameters.get_value(param_name));
              Real log_range = log10(max_parameters.get_value(param_name) / min_parameters.get_value(param_name));
 
              training_vector->set(index, pow(10., log_min + random_number*log_range ) );
            }
          // Generate linearly scaled training parameters
          else
            {
              training_vector->set(index, random_number*(max_parameters.get_value(param_name) - min_parameters.get_value(param_name))
                                   + min_parameters.get_value(param_name));
            }
        }
    }
}

get_closest_value()

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

staticinherited

Returns

The closest entry to value from list_of_values.

Definition at line 433 of file rb_parametrized.C.

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

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

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

get_deterministic_training_parameter_name()

template<class Base>

const std::string& libMesh::RBConstructionBase< Base >::get_deterministic_training_parameter_name

(

)

const

Get the name of the parameter that we will generate deterministic training parameters for.

get_deterministic_training_parameter_repeats()

template<class Base>

unsigned int libMesh::RBConstructionBase< Base >::get_deterministic_training_parameter_repeats

(

)

const

Get the number of times each sample of the deterministic training parameter is repeated.

get_discrete_parameter_values()

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

inherited

Get a const reference to the discrete parameter values.

Definition at line 381 of file rb_parametrized.C.

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

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

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

get_first_local_training_index()

template<class Base >

numeric_index_type libMesh::RBConstructionBase< Base >::get_first_local_training_index

(

)

const

Get the first local index of the training parameters.

Definition at line 116 of file rb_construction_base.C.

{
  libmesh_assert(training_parameters_initialized);
  return training_parameters.begin()->second->first_local_index();
}

get_global_max_error_pair()

template<class Base >

void libMesh::RBConstructionBase< Base >::get_global_max_error_pair ( const Parallel::Communicator &  communicator, std::pair< numeric_index_type, Real > &  error_pair  )

staticprotected

Static function to return the error pair (index,error) that is corresponds to the largest error on all processors.

Definition at line 85 of file rb_construction_base.C.

{
  // Set error_pair.second to the maximum global value and also
  // find which processor contains the maximum value
  unsigned int proc_ID_index;
  communicator.maxloc(error_pair.second, proc_ID_index);
 
  // Then broadcast error_pair.first from proc_ID_index
  communicator.broadcast(error_pair.first, proc_ID_index);
}

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

template<class Base >

numeric_index_type libMesh::RBConstructionBase< Base >::get_last_local_training_index

(

)

const

Get the last local index of the training parameters.

Definition at line 123 of file rb_construction_base.C.

{
  libmesh_assert(training_parameters_initialized);
  return training_parameters.begin()->second->last_local_index();
}

get_local_n_training_samples()

template<class Base >

numeric_index_type libMesh::RBConstructionBase< Base >::get_local_n_training_samples

(

)

const

Get the total number of training samples local to this processor.

Definition at line 109 of file rb_construction_base.C.

{
  libmesh_assert(training_parameters_initialized);
  return training_parameters.begin()->second->local_size();
}

get_n_continuous_params()

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

inherited

Get the number of continuous parameters.

Definition at line 125 of file rb_parametrized.C.

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

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

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

get_n_discrete_params()

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

inherited

Get the number of discrete parameters.

Definition at line 135 of file rb_parametrized.C.

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

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

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

get_n_params()

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

inherited

Get the number of parameters.

Definition at line 115 of file rb_parametrized.C.

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

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

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

get_n_training_samples()

template<class Base >

numeric_index_type libMesh::RBConstructionBase< Base >::get_n_training_samples

(

)

const

Get the total number of training samples.

Definition at line 98 of file rb_construction_base.C.

{
  libmesh_assert(training_parameters_initialized);
 
  if (training_parameters.empty())
    return 0;
 
  return training_parameters.begin()->second->size();
}

get_parameter_max()

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

inherited

Get maximum allowable value of parameter param_name.

Definition at line 198 of file rb_parametrized.C.

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

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

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

get_parameter_min()

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

inherited

Get minimum allowable value of parameter param_name.

Definition at line 190 of file rb_parametrized.C.

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

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

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

get_parameter_names()

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

inherited

Get a set that stores the parameter names.

Definition at line 144 of file rb_parametrized.C.

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

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

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

get_parameters()

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

inherited

Get the current parameters.

Definition at line 166 of file rb_parametrized.C.

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

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

Referenced by libMesh::TransientRBConstruction::add_scaled_mass_matrix(), libMesh::TransientRBEvaluation::cache_online_residual_terms(), libMesh::RBEIMConstruction::compute_best_fit_error(), libMesh::RBEvaluation::compute_residual_dual_norm(), libMesh::RBSCMConstruction::compute_SCM_bounds_on_training_set(), libMesh::RBSCMConstruction::enrich_C_J(), libMesh::RBEIMConstruction::enrich_RB_space(), libMesh::RBEIMTheta::evaluate(), 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(), libMesh::RBParametrized::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

inherited

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

Definition at line 182 of file rb_parametrized.C.

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

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

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

get_parameters_min()

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

inherited

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

Definition at line 174 of file rb_parametrized.C.

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

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

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

get_params_from_training_set()

template<class Base >

RBParameters libMesh::RBConstructionBase< Base >::get_params_from_training_set ( unsigned int  index )

protected

Return the RBParameters in index index of training set.

Definition at line 136 of file rb_construction_base.C.

{
  libmesh_assert(training_parameters_initialized);
 
  libmesh_assert( (this->get_first_local_training_index() <= index) &&
                  (index < this->get_last_local_training_index()) );
 
  RBParameters params;
  for (const auto & pr : training_parameters)
    {
      const std::string & param_name = pr.first;
      Real param_value = libmesh_real((*(pr.second))(index));
      params.set_value(param_name, param_value);
    }
 
  // Add potential extra values
  const auto & mine = get_parameters();
  for (const auto & pr : as_range(mine.extra_begin(), mine.extra_end()))
    params.set_extra_value(pr.first, pr.second);
 
  return params;
}

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

init_data()

template<class Base >

void libMesh::RBConstructionBase< Base >::init_data ( )

protectedvirtual

Initializes the member data fields associated with the system, so that, e.g., assemble() may be used.

Reimplemented in libMesh::RBEIMConstruction, SimpleRBConstruction, SimpleRBConstruction, SimpleRBConstruction, SimpleRBConstruction, SimpleRBConstruction, SimpleRBConstruction, and ElasticityRBConstruction.

Definition at line 74 of file rb_construction_base.C.

{
  Base::init_data();
 
  // Initialize the inner product storage vector, which is useful for
  // storing intermediate results when evaluating inner products
  inner_product_storage_vector = NumericVector<Number>::build(this->comm());
  inner_product_storage_vector->init (this->n_dofs(), this->n_local_dofs(), false, PARALLEL);
}

initialize_parameters() [1/2]

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

inherited

Initialize the parameter ranges and set current_parameters.

Definition at line 60 of file rb_parametrized.C.

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

References libMesh::RBParametrized::_discrete_parameter_values, libMesh::RBParameters::get_value(), libMesh::RBParameters::n_parameters(), libMesh::RBParametrized::parameters_initialized, libMesh::RBParametrized::parameters_max, libMesh::RBParametrized::parameters_min, libMesh::Real, libMesh::RBParametrized::set_parameters(), and libMesh::RBParameters::set_value().

Referenced by libMesh::RBConstruction::enrich_basis_from_rhs_terms(), libMesh::RBParametrized::initialize_parameters(), libMesh::RBEIMConstruction::initialize_parametrized_functions_in_training_set(), libMesh::RBDataDeserialization::load_parameter_ranges(), libMesh::RBSCMConstruction::perform_SCM_greedy(), libMesh::RBSCMConstruction::process_parameters_file(), libMesh::RBParametrized::read_parameter_data_from_files(), libMesh::RBConstruction::set_rb_construction_parameters(), and libMesh::RBConstruction::train_reduced_basis().

initialize_parameters() [2/2]

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

inherited

Initialize the parameter ranges and set current_parameters.

Definition at line 108 of file rb_parametrized.C.

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

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

initialize_training_parameters()

template<class Base >

void libMesh::RBConstructionBase< Base >::initialize_training_parameters ( const RBParameters &  mu_min, const RBParameters &  mu_max, unsigned int  n_training_parameters, std::map< std::string, bool >  log_param_scale, bool  deterministic = true  )

virtual

Initialize the parameter ranges and indicate whether deterministic or random training parameters should be used and whether or not we want the parameters to be scaled logarithmically.

Definition at line 181 of file rb_construction_base.C.

{
  if(!is_quiet())
    {
      // Print out some info about the training set initialization
      libMesh::out << "Initializing training parameters with "
                  << (deterministic ? "deterministic " : "random " )
                  << "training set..." << std::endl;
 
      for (const auto & pr : log_param_scale)
        libMesh::out << "Parameter "
                     << pr.first
                     << ": log scaling = "
                     << pr.second
                     << std::endl;
 
      libMesh::out << std::endl;
    }
 
  if (deterministic)
    {
      generate_training_parameters_deterministic(this->comm(),
                                                 log_param_scale,
                                                 training_parameters,
                                                 n_training_samples,
                                                 mu_min,
                                                 mu_max,
                                                 serial_training_set);
    }
  else
    {
      // Generate random training samples for all parameters
      generate_training_parameters_random(this->comm(),
                                          log_param_scale,
                                          training_parameters,
                                          n_training_samples,
                                          mu_min,
                                          mu_max,
                                          this->training_parameters_random_seed,
                                          serial_training_set);
    }
 
  // For each parameter that only allows discrete values, we "snap" to the nearest
  // allowable discrete value
  if (get_n_discrete_params() > 0)
    {
      for (const auto & pr : training_parameters)
        {
          const std::string & param_name = pr.first;
          if (is_discrete_parameter(param_name))
            {
              std::vector<Real> discrete_values =
                get_discrete_parameter_values().find(param_name)->second;
 
              NumericVector<Number> * training_vector = pr.second.get();
 
              for (numeric_index_type index=training_vector->first_local_index();
                   index<training_vector->last_local_index();
                   index++)
                {
                  Real value = libmesh_real((*training_vector)(index));
                  Real nearest_discrete_value = get_closest_value(value, discrete_values);
                  training_vector->set(index, nearest_discrete_value);
                }
            }
        }
    }
 
  training_parameters_initialized = true;
}

is_discrete_parameter()

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

inherited

Is parameter mu_name discrete?

Definition at line 373 of file rb_parametrized.C.

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

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

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

is_quiet()

template<class Base>

bool libMesh::RBConstructionBase< Base >::is_quiet ( ) const

inline

Is the system in quiet mode?

Definition at line 98 of file rb_construction_base.h.

  { return this->quiet_mode; }

is_value_in_list()

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

staticprivateinherited

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

Definition at line 453 of file rb_parametrized.C.

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

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

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

load_training_set()

template<class Base >

void libMesh::RBConstructionBase< Base >::load_training_set ( std::map< std::string, std::vector< Number >> &  new_training_set )

virtual

Overwrite the training parameters with new_training_set.

Definition at line 257 of file rb_construction_base.C.

{
  // First, make sure that an initial training set has already been
  // generated
  if (!training_parameters_initialized)
    libmesh_error_msg("Error: load_training_set cannot be used to initialize parameters");
 
  // Make sure that the training set has the correct number of parameters
  if (new_training_set.size() != get_n_params())
    libmesh_error_msg("Error: Incorrect number of parameters in load_training_set.");
 
  // Delete the training set vectors (but don't remove the existing keys!)
  for (auto & pr : training_parameters)
    pr.second.reset(nullptr);
 
  // Get the number of local and global training parameters
  numeric_index_type n_local_training_samples  =
    cast_int<numeric_index_type>(new_training_set.begin()->second.size());
  numeric_index_type n_global_training_samples = n_local_training_samples;
  this->comm().sum(n_global_training_samples);
 
  for (auto & pr : training_parameters)
    {
      pr.second = NumericVector<Number>::build(this->comm());
      pr.second->init(n_global_training_samples, n_local_training_samples, false, PARALLEL);
    }
 
  for (auto & pr : training_parameters)
    {
      const std::string & param_name = pr.first;
      NumericVector<Number> * training_vector = pr.second.get();
 
      numeric_index_type first_index = training_vector->first_local_index();
      for (numeric_index_type i=0; i<n_local_training_samples; i++)
        {
          numeric_index_type index = first_index + i;
          training_vector->set(index, new_training_set[param_name][i]);
        }
    }
}

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

inherited

Print out all the discrete parameter values.

Definition at line 389 of file rb_parametrized.C.

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

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

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

print_info()

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

staticinherited

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

Definition at line 87 of file reference_counter.C.

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

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

print_parameters()

void libMesh::RBParametrized::print_parameters ( ) const

inherited

Print the current parameters.

Definition at line 206 of file rb_parametrized.C.

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

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

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

read_discrete_parameter_values_from_file()

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

privateinherited

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

Definition at line 340 of file rb_parametrized.C.

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

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

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

read_parameter_data_from_files()

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

inherited

Read in the parameter ranges from files.

Definition at line 284 of file rb_parametrized.C.

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

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

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

read_parameter_ranges_from_file()

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

privateinherited

Read in the parameter ranges from file.

Initialize parameters to the "minimum" parameter values.

Definition at line 303 of file rb_parametrized.C.

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

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

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

set_deterministic_training_parameter_name()

template<class Base>

void libMesh::RBConstructionBase< Base >::set_deterministic_training_parameter_name

(

const std::string &

name

)

In some cases we only want to allow discrete parameter values, instead of parameters that may take any value in a specified interval.

Here we provide a method to set the d Set the discrete values for parameter mu that are allowed in the training set. This must be called before the training set is generated. Set the name of the parameter that we will generate deterministic training parameters for. Defaults to "NONE".

set_deterministic_training_parameter_repeats()

template<class Base>

void libMesh::RBConstructionBase< Base >::set_deterministic_training_parameter_repeats

(

unsigned int

repeats

)

Set the number of times each sample of the deterministic training parameter is repeated.

set_parameters()

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

inherited

Set the current parameters to params.

Definition at line 155 of file rb_parametrized.C.

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

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

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

set_params_from_training_set()

template<class Base >

void libMesh::RBConstructionBase< Base >::set_params_from_training_set ( unsigned int  index )

protected

Set parameters to the RBParameters stored in index index of the training set.

Definition at line 130 of file rb_construction_base.C.

{
  set_parameters(get_params_from_training_set(index));
}

set_params_from_training_set_and_broadcast()

template<class Base >

void libMesh::RBConstructionBase< Base >::set_params_from_training_set_and_broadcast ( unsigned int  index )

protectedvirtual

Load the specified training parameter and then broadcast to all processors.

Definition at line 160 of file rb_construction_base.C.

{
  libmesh_assert(training_parameters_initialized);
 
  processor_id_type root_id = 0;
  if ((this->get_first_local_training_index() <= index) &&
      (index < this->get_last_local_training_index()))
    {
      // Set parameters on only one processor
      set_params_from_training_set(index);
 
      // set root_id, only non-zero on one processor
      root_id = this->processor_id();
    }
 
  // broadcast
  this->comm().max(root_id);
  broadcast_parameters(root_id);
}

set_quiet_mode()

template<class Base>

void libMesh::RBConstructionBase< Base >::set_quiet_mode ( bool  quiet_mode_in )

inline

Set the quiet_mode flag.

If quiet == false then we print out a lot of extra information during the Offline stage.

Definition at line 92 of file rb_construction_base.h.

  { this->quiet_mode = quiet_mode_in; }

set_training_random_seed()

template<class Base >

void libMesh::RBConstructionBase< Base >::set_training_random_seed

(

unsigned int

seed

)

Set the seed that is used to randomly generate training parameters.

Definition at line 630 of file rb_construction_base.C.

{
  this->training_parameters_random_seed = seed;
}

system()

template<class Base>

sys_type& libMesh::RBConstructionBase< Base >::system ( )

inline

Returns

A reference to *this.

Definition at line 79 of file rb_construction_base.h.

{ return *this; }

valid_params()

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

privateinherited

Helper function to check that params is valid.

Definition at line 402 of file rb_parametrized.C.

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

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

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

write_discrete_parameter_values_to_file()

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

privateinherited

Write out the discrete parameter values to file.

Definition at line 255 of file rb_parametrized.C.

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

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

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

write_parameter_data_to_files()

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

inherited

Write out the parameter ranges to files.

Definition at line 214 of file rb_parametrized.C.

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

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

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

write_parameter_ranges_to_file()

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

privateinherited

Write out the parameter ranges to file.

Definition at line 222 of file rb_parametrized.C.

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

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

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

Member Data Documentation

_counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 122 of file reference_counter.h.

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

_discrete_parameter_values

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

privateinherited

Map that defines the allowable values of any discrete parameters.

Definition at line 235 of file rb_parametrized.h.

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

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

inner_product_storage_vector

template<class Base>

std::unique_ptr<NumericVector<Number> > libMesh::RBConstructionBase< Base >::inner_product_storage_vector

protected

We keep an extra temporary vector that is useful for performing inner products (avoids unnecessary memory allocation/deallocation).

Definition at line 254 of file rb_construction_base.h.

parameters

RBParameters libMesh::RBParametrized::parameters

privateinherited

Vector storing the current parameters.

Definition at line 224 of file rb_parametrized.h.

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

parameters_initialized

bool libMesh::RBParametrized::parameters_initialized

privateinherited

Flag indicating whether the parameters have been initialized.

Definition at line 219 of file rb_parametrized.h.

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

parameters_max

RBParameters libMesh::RBParametrized::parameters_max

privateinherited

Definition at line 230 of file rb_parametrized.h.

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

parameters_min

RBParameters libMesh::RBParametrized::parameters_min

privateinherited

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

Definition at line 229 of file rb_parametrized.h.

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

quiet_mode

template<class Base>

bool libMesh::RBConstructionBase< Base >::quiet_mode

protected

Flag to indicate whether we print out extra information during the Offline stage.

Definition at line 239 of file rb_construction_base.h.

Referenced by libMesh::RBConstructionBase< CondensedEigenSystem >::is_quiet(), and libMesh::RBConstructionBase< CondensedEigenSystem >::set_quiet_mode().

serial_training_set

template<class Base>

bool libMesh::RBConstructionBase< Base >::serial_training_set

protected

This boolean flag indicates whether or not the training set should be the same on all processors.

By default it is false, but in the case of the Empirical Interpolation Method (RBEIMConstruction), for example, we need the training set to be identical on all processors.

Definition at line 247 of file rb_construction_base.h.

training_parameters

template<class Base>

std::map<std::string, std::unique_ptr<NumericVector<Number> > > libMesh::RBConstructionBase< Base >::training_parameters

private

The training samples.

Definition at line 268 of file rb_construction_base.h.

training_parameters_initialized

template<class Base>

bool libMesh::RBConstructionBase< Base >::training_parameters_initialized

private

Boolean flag to indicate whether or not the parameter ranges have been initialized.

Definition at line 263 of file rb_construction_base.h.

training_parameters_random_seed

template<class Base>

int libMesh::RBConstructionBase< Base >::training_parameters_random_seed

private

If < 0, use std::time() * processor_id() to seed the random number generator for the training parameters (default).

If >= 0, use the provided value * processor_id() as the random number generator seed.

Definition at line 276 of file rb_construction_base.h.

verbose_mode

bool libMesh::RBParametrized::verbose_mode

inherited

Public boolean to toggle verbose mode.

Definition at line 170 of file rb_parametrized.h.

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

---

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

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