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...
	RBConstructionBase (RBConstructionBase &&)=default
	Special functions. More...
RBConstructionBase &	operator= (RBConstructionBase &&)=delete
	RBConstructionBase (const RBConstructionBase &)=delete
RBConstructionBase &	operator= (const RBConstructionBase &)=delete
virtual	~RBConstructionBase ()
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...
void	set_normalize_solution_snapshots (bool value)
	Set the boolean option that indicates if we normalization solution snapshots or not. More...
numeric_index_type	get_n_training_samples () const
	Get the number of global 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, const unsigned int n_global_training_samples, const std::map< std::string, bool > &log_param_scale, const 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 (const std::map< std::string, std::vector< RBParameter >> &new_training_set)
	Overwrite the training parameters with new_training_set. More...
void	set_training_parameter_values (const std::string &param_name, const std::vector< RBParameter > &values)
	Overwrite the local training samples for param_name using values. More...
void	broadcast_parameters (const unsigned int proc_id)
	Broadcasts parameters from processor proc_id to all processors. More...
void	set_training_random_seed (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	initialize_parameters (const RBParameters &mu_min_in, const RBParameters &mu_max_in, const std::map< std::string, std::vector< Real >> &discrete_parameter_values)
	Initialize the parameter ranges and set current_parameters. More...
void	initialize_parameters (const RBParametrized &rb_parametrized)
	Initialize the parameter ranges and set current_parameters. More...
unsigned int	get_n_params () const
	Get the number of parameters. More...
unsigned int	get_n_continuous_params () const
	Get the number of continuous parameters. More...
unsigned int	get_n_discrete_params () const
	Get the number of discrete parameters. More...
std::set< std::string >	get_parameter_names () const
	Get a set that stores the parameter names. More...
const RBParameters &	get_parameters () const
	Get the current parameters. More...
bool	set_parameters (const RBParameters &params)
	Set the current parameters to params The parameters are checked for validity; an error is thrown if the number of parameters or samples is different than expected. More...
const RBParameters &	get_parameters_min () const
	Get an RBParameters object that specifies the minimum allowable value for each parameter. More...
const RBParameters &	get_parameters_max () const
	Get an RBParameters object that specifies the maximum allowable value for each parameter. More...
Real	get_parameter_min (const std::string &param_name) const
	Get minimum allowable value of parameter param_name. More...
Real	get_parameter_max (const std::string &param_name) const
	Get maximum allowable value of parameter param_name. More...
void	print_parameters () const
	Print the current parameters. More...
void	write_parameter_data_to_files (const std::string &continuous_param_file_name, const std::string &discrete_param_file_name, const bool write_binary_data)
	Write out the parameter ranges to files. More...
void	read_parameter_data_from_files (const std::string &continuous_param_file_name, const std::string &discrete_param_file_name, const bool read_binary_data)
	Read in the parameter ranges from files. More...
bool	is_discrete_parameter (const std::string &mu_name) const
	Is parameter mu_name discrete? More...
const std::map< std::string, std::vector< Real > > &	get_discrete_parameter_values () const
	Get a const reference to the discrete parameter values. More...
void	print_discrete_parameter_values () const
	Print out all the discrete parameter values. More...

Static Public Member Functions
static std::pair< std::size_t, std::size_t >	generate_training_parameters_random (const Parallel::Communicator &communicator, const std::map< std::string, bool > &log_param_scale, std::map< std::string, std::vector< RBParameter >> &local_training_parameters_in, const unsigned int n_global_training_samples_in, const RBParameters &min_parameters, const RBParameters &max_parameters, const int training_parameters_random_seed=-1, const bool serial_training_set=false)
	Static helper function for generating a randomized set of parameters. More...
static std::pair< std::size_t, std::size_t >	generate_training_parameters_deterministic (const Parallel::Communicator &communicator, const std::map< std::string, bool > &log_param_scale, std::map< std::string, std::vector< RBParameter >> &local_training_parameters_in, const unsigned int n_global_training_samples_in, const RBParameters &min_parameters, const RBParameters &max_parameters, const bool serial_training_set=false)
	Static helper function for generating a deterministic set of parameters. More...
static Real	get_closest_value (Real value, const std::vector< Real > &list_of_values)
static std::string	get_info ()
	Gets a string containing the reference information. More...
static void	print_info (std::ostream &out_stream=libMesh::out)
	Prints the reference information, by default to libMesh::out. More...
static unsigned int	n_objects ()
	Prints the number of outstanding (created, but not yet destroyed) objects. More...
static void	enable_print_counter_info ()
	Methods to enable/disable the reference counter output from print_info() More...
static void	disable_print_counter_info ()

Public Attributes
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 global_index)
	Return the RBParameters in index global_index of the global training set. More...
void	set_params_from_training_set (unsigned int global_index)
	Set parameters to the RBParameters stored in index global_index of the global training set. More...
virtual void	set_params_from_training_set_and_broadcast (unsigned int global_index)
	Load the specified training parameter and then broadcast to all processors. More...
void	increment_constructor_count (const std::string &name) noexcept
	Increments the construction counter. More...
void	increment_destructor_count (const std::string &name) noexcept
	Increments the destruction counter. More...

Static Protected Member Functions
static void	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...

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...
bool	_normalize_solution_snapshots
	Set this boolean to true if we want to normalize solution snapshots used in training to have norm of 1. 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 Attributes
bool	_training_parameters_initialized
	Boolean flag to indicate whether or not the parameter ranges have been initialized. More...
std::map< std::string, std::vector< RBParameter > >	_training_parameters
	The training samples for each parameter. More...
numeric_index_type	_first_local_index
	The first sample-vector index from the global vector which is stored in the _training_parameters on this processor. More...
numeric_index_type	_n_local_training_samples
numeric_index_type	_n_global_training_samples
int	_training_parameters_random_seed
	If < 0, use std::time() * processor_id() to seed the random number generator for the training parameters (default). 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 55 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 119 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 82 of file rb_construction_base.h.

Constructor & Destructor Documentation

RBConstructionBase() [1/3]

template<class Base >

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

Constructor.

Definition at line 95 of file rb_construction_base.C.

  : Base(es, name_in, number_in),
    quiet_mode(true),
    serial_training_set(false),
    _normalize_solution_snapshots(false),
    _training_parameters_initialized(false),
    _first_local_index(0),
    _n_local_training_samples(0),
    _n_global_training_samples(0),
    _training_parameters_random_seed(-1) // by default, use std::time to seed RNG
{
}

RBConstructionBase() [2/3]

template<class Base>

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

default

Special functions.

• This class has the same restrictions as the union of its potential base classes (currently LinearImplicitSystem and EigenSystem).
• Destructor is defaulted out-of-line.

RBConstructionBase() [3/3]

template<class Base>

libMesh::RBConstructionBase< Base >::RBConstructionBase ( const RBConstructionBase< Base > &  )

delete

~RBConstructionBase()

template<class Base >

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

virtualdefault

Member Function Documentation

broadcast_parameters()

template<class Base >

void libMesh::RBConstructionBase< Base >::broadcast_parameters

(

const unsigned int

proc_id

)

Broadcasts parameters from processor proc_id to all processors.

This broadcasts the RBParameters object from .get_parameters(), and then sets it on all processors with .set_parameters().

Definition at line 720 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();
  libmesh_error_msg_if(current_parameters.n_samples()!=1,
      "Only single-sample RBParameter objects can be broadcast.");

  // Serialize the current_parameters to current_parameters_vector in order to broadcast.
  // We handle multiple samples and vector values.
  // However, the vector values are assumed to remain the same size across samples.
  const std::size_t nparams = current_parameters.n_parameters();
  const std::size_t nsamples = current_parameters.n_samples();

  // First we get the sizes of all the parameter value vectors.
  std::vector<std::size_t> param_value_sizes;
  param_value_sizes.reserve(nparams);
  for (const auto & pr : current_parameters)
    param_value_sizes.push_back(pr.second[0].size());

  // Broadcast the sizes vector and reserve memory.
  this->comm().broadcast(param_value_sizes, proc_id);
  std::size_t buffsize = std::accumulate(param_value_sizes.cbegin(), param_value_sizes.cend(), 0ul);
  std::vector<Real> serialized_parameters;
  serialized_parameters.reserve(buffsize);

  // Then we serialize the parameters/sample/value vectors into a single vector.
  for (const auto & pr : current_parameters)
    {
      for (const auto sample_idx : make_range(nsamples))
        serialized_parameters.insert(serialized_parameters.end(),
                                     pr.second[sample_idx].cbegin(),
                                     pr.second[sample_idx].cend());
    }

  // Do the broadcasts.
  this->comm().broadcast(serialized_parameters, proc_id);

  // Deserialize into the copy of the RBParameters object.
  std::size_t param_idx = 0;
  auto val_idx = serialized_parameters.cbegin();
  for (const auto & pr : current_parameters)
    {
      const std::size_t param_value_size = param_value_sizes[param_idx];
      for (const auto sample_idx: make_range(nsamples))
        {
          auto end_val_idx = std::next(val_idx,param_value_size);
          RBParameter sample_val(val_idx, end_val_idx);
          current_parameters.set_value(pr.first, sample_idx, sample_val);
          val_idx = end_val_idx;
        }
      ++param_idx;
    }

  // Overwrite 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::RBEIMConstruction, libMesh::TransientSystem< RBConstruction >, libMesh::RBSCMConstruction, and libMesh::TransientRBConstruction.

Definition at line 114 of file rb_construction_base.C.

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

{
  // 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 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

{
  _enable_print_counter = false;
  return;
}

enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Definition at line 94 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

{
  _enable_print_counter = true;
  return;
}

generate_training_parameters_deterministic()

template<class Base >

std::pair< std::size_t, std::size_t > libMesh::RBConstructionBase< Base >::generate_training_parameters_deterministic ( const Parallel::Communicator &  communicator, const std::map< std::string, bool > &  log_param_scale, std::map< std::string, std::vector< RBParameter >> &  local_training_parameters_in, const unsigned int  n_global_training_samples_in, const RBParameters &  min_parameters, const RBParameters &  max_parameters, const bool  serial_training_set = false  )

static

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. The parameter n_global_training_samples_in is the total number of parameters to generate, and they will be split across all the processors (unless serial_training_set=true) in the local_training_parameters_in map.

Returns

a pair of {first_local_index,last_local_index}

Definition at line 572 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 {0,0};

  if (num_params > 3)
    libmesh_not_implemented_msg("ERROR: Deterministic training sample generation "
                                "not implemented for more than three parameters.");

  // TODO - we don't support vector-data here yet. This would only apply in the case where
  //        min or max are vector-valued, and all the generated points need to stay within those ranges.
  //        But typically we expect that if we're calling this function, we only have 1 min and 1 max,
  //        so the generated values are single-valued as well. The .get_value() calls will throw an error
  //        if this is not the case.

  // Reinitialize training_parameters_in (but don't remove existing keys!)
  const auto &[n_local_training_samples, first_local_index] =
      calculate_n_local_samples_and_index(communicator, n_global_training_samples_in,
                                         serial_training_set);
  const auto last_local_index = first_local_index + n_local_training_samples;
  for (const auto & pr : min_parameters)
    local_training_parameters_in[pr.first] = std::vector<RBParameter>(n_local_training_samples);

  // n_training_samples_per_param has 3 entries, but entries after "num_params"
  // are unused so we just set their value to 1. We need to set it to 1 (rather
  // than 0) so that we don't skip the inner part of the triply-nested loop over
  // n_training_samples_per_param below.
  std::vector<unsigned int> n_training_samples_per_param(3);
  for (unsigned int param=0; param<3; param++)
    {
      if (param < num_params)
        {
          n_training_samples_per_param[param] =
            static_cast<unsigned int>( std::round(std::pow(static_cast<Real>(n_global_training_samples_in), 1./num_params)) );
        }
      else
        {
          n_training_samples_per_param[param] = 1;
        }
    }

  {
    // The current implementation assumes that we have the same number of
    // samples in each parameter, so we check that n_training_samples_in
    // is consistent with this assumption.
    unsigned int total_samples_check = 1;
    for (unsigned int n_samples : n_training_samples_per_param)
      {
        total_samples_check *= n_samples;
      }

    libmesh_error_msg_if(total_samples_check != n_global_training_samples_in,
                         "Error: Number of training samples = "
                         << n_global_training_samples_in
                         << " does not enable a uniform grid of samples with "
                         << num_params << " parameters. Try "
                         << total_samples_check << " samples instead?");
  }

  // First we make a list of training samples associated with each parameter,
  // then we take a tensor product to obtain the final set of training samples.
  std::vector<std::vector<Real>> training_samples_per_param(num_params);
  {
    unsigned int i = 0;
    for (const auto & pr : min_parameters)
      {
        const std::string & param_name = pr.first;
        const bool use_log_scaling = libmesh_map_find(log_param_scale, param_name);
        Real min_param = min_parameters.get_value(param_name);
        Real max_param = max_parameters.get_value(param_name);

        training_samples_per_param[i].resize(n_training_samples_per_param[i]);

        for (unsigned int j=0; j<n_training_samples_per_param[i]; j++)
          {
            // Generate log10 scaled training parameters
            if (use_log_scaling)
              {
                Real epsilon = 1.e-6; // Prevent rounding errors triggering asserts
                Real log_min   = std::log10(min_param + epsilon);
                Real log_range = std::log10( (max_param-epsilon) / (min_param+epsilon) );
                Real step_size = log_range /
                  std::max((unsigned int)1,(n_training_samples_per_param[i]-1));

                if (j<(n_training_samples_per_param[i]-1))
                  {
                    training_samples_per_param[i][j] = std::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_samples_per_param[i][j] = max_param;
                  }
              }
            else
              {
                // Generate linearly scaled training parameters
                Real step_size = (max_param - min_param) /
                  std::max((unsigned int)1,(n_training_samples_per_param[i]-1));
                training_samples_per_param[i][j] = j*step_size + min_param;
              }

          }
        i++;
      }
  }

  // Now load into training_samples_in
  {
    std::vector<unsigned int> indices(3);
    unsigned int index_count = 0;
    for (indices[0]=0; indices[0]<n_training_samples_per_param[0]; indices[0]++)
      {
        for (indices[1]=0; indices[1]<n_training_samples_per_param[1]; indices[1]++)
          {
            for (indices[2]=0; indices[2]<n_training_samples_per_param[2]; indices[2]++)
              {
                unsigned int param_count = 0;
                for (const auto & pr : min_parameters)
                  {
                    std::vector<RBParameter> & training_vector =
                      libmesh_map_find(local_training_parameters_in, pr.first);
                    if (first_local_index <= index_count && index_count < last_local_index)
                      training_vector[index_count - first_local_index] =
                        {training_samples_per_param[param_count][indices[param_count]]};

                    param_count++;
                  }
                index_count++;
              }
          }
      }
  }
  return {first_local_index, first_local_index+n_local_training_samples};
}

generate_training_parameters_random()

template<class Base >

std::pair< std::size_t, std::size_t > libMesh::RBConstructionBase< Base >::generate_training_parameters_random ( const Parallel::Communicator &  communicator, const std::map< std::string, bool > &  log_param_scale, std::map< std::string, std::vector< RBParameter >> &  local_training_parameters_in, const unsigned int  n_global_training_samples_in, const RBParameters &  min_parameters, const RBParameters &  max_parameters, const int  training_parameters_random_seed = -1, const bool  serial_training_set = false  )

static

Static helper function for generating a randomized set of parameters.

The parameter n_global_training_samples_in is the total number of parameters to generate, and they will be split across all the processors (unless serial_training_set=true) in the local_training_parameters_in map.

Returns

a pair of {first_local_index,last_local_index}

Definition at line 472 of file rb_construction_base.C.

{
  const unsigned int num_params = min_parameters.n_parameters();
  libmesh_error_msg_if(num_params!=max_parameters.n_parameters(),
    "Number of parameters must be identical for min/max.");

  // Clear training_parameters_in
  local_training_parameters_in.clear();

  if (num_params == 0)
    return {0,0};

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

  // TODO - we don't support vector-data here yet. This would only apply in the case where
  //        min or max are vector-valued, and all the generated points need to stay within those ranges.
  //        But typically we expect that if we're calling this function, we only have 1 min and 1 max,
  //        so the generated values are single-valued as well. The .get_value() calls will throw an error
  //        if this is not the case.

  // initialize training_parameters_in
  const auto & [n_local_training_samples, first_local_index] =
      calculate_n_local_samples_and_index(communicator, n_global_training_samples_in,
                                          serial_training_set);
  for (const auto & pr : min_parameters)
    local_training_parameters_in[pr.first] = std::vector<RBParameter>(n_local_training_samples);

  // finally, set the values
  for (auto & [param_name, sample_vector] : local_training_parameters_in)
    {
      for (auto i : make_range(n_local_training_samples))
        {
          Real random_number = static_cast<Real>(std::rand()) / RAND_MAX; // in range [0,1]

          // Generate log10 scaled training parameters
          if (libmesh_map_find(log_param_scale, param_name))
            {
              Real log_min   = std::log10(min_parameters.get_value(param_name));
              Real log_range = std::log10(max_parameters.get_value(param_name) / min_parameters.get_value(param_name));

              sample_vector[i] = {std::pow(Real(10.), log_min + random_number*log_range )};
            }
          // Generate linearly scaled training parameters
          else
            {
              sample_vector[i] = {
                  random_number * (max_parameters.get_value(param_name) -
                                   min_parameters.get_value(param_name)) +
                  min_parameters.get_value(param_name)};
            }
        }
    }
  return {first_local_index, first_local_index+n_local_training_samples};
}

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

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

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

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

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

  return closest_val;
}

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

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

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

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

  return _discrete_parameter_values;
}

get_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 191 of file rb_construction_base.C.

{
  libmesh_error_msg_if(!_training_parameters_initialized,
                       "Error: training parameters must first be initialized.");

  // First we check if there are no parameters here, and in that case we
  // return 0 for a serial training set and comm().rank() for a parallel
  // training set. This is consistent with get_n_training_samples(), and
  // avoids accessing training_parameters.begin() when training_parameters
  // is empty.
  if (_training_parameters.empty())
    {
      if (serial_training_set)
        return 0;
      else
        return this->comm().rank();
    }

  return _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 134 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.

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

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

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

  std::ostringstream oss;

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

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

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

  return oss.str();

#else

  return "";

#endif
}

get_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 213 of file rb_construction_base.C.

{
  libmesh_error_msg_if(!_training_parameters_initialized,
                       "Error: training parameters must first be initialized.");

  if (_training_parameters.empty())
    return 0;

  return _first_local_index + _n_local_training_samples;
}

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 175 of file rb_construction_base.C.

{
  libmesh_error_msg_if(!_training_parameters_initialized,
                       "Error: training parameters must first be initialized.");

  // First we check if there are no parameters here, and in that case we
  // return 1 for both serial and parallel training sets. This is consistent
  // with get_n_training_samples(), and avoids accessing
  // training_parameters.begin() when training_parameters is empty.
  if (_training_parameters.empty())
    return 1;

  return _n_local_training_samples;
}

get_n_continuous_params()

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

inherited

Get the number of continuous parameters.

Definition at line 112 of file rb_parametrized.C.

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

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

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

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

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

get_n_discrete_params()

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

inherited

Get the number of discrete parameters.

Definition at line 121 of file rb_parametrized.C.

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

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

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

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

get_n_params()

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

inherited

Get the number of parameters.

Definition at line 103 of file rb_parametrized.C.

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

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

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

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

  return parameters_min.n_parameters();
}

get_n_training_samples()

template<class Base >

numeric_index_type libMesh::RBConstructionBase< Base >::get_n_training_samples

(

)

const

Get the number of global training samples.

Definition at line 153 of file rb_construction_base.C.

{
  libmesh_error_msg_if(!_training_parameters_initialized,
                       "Error: training parameters must first be initialized.");

  // First we check if there are no parameters here, and in that case we
  // return 1 since a single training sample is sufficient to generate an
  // RB approximation if there are no parameters. Note that in parallel,
  // and when we don't have a serial training set, set return comm().size()
  // so that each processor is assigned a single (empty) training sample.
  if (_training_parameters.empty())
    {
      if (serial_training_set)
        return 1;
      else
        return this->comm().size();
    }

  return _n_global_training_samples;
}

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

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

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

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

  return parameters_max.get_value(param_name);
}

get_parameter_min()

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

inherited

Get minimum allowable value of parameter param_name.

Definition at line 178 of file rb_parametrized.C.

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

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

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

  return parameters_min.get_value(param_name);
}

get_parameter_names()

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

inherited

Get a set that stores the parameter names.

Deprecated:

to avoid making it too easy to create copies that in most circumstances aren't needed. If this functionality really is required, call get_parameters_min().get_parameters_map() and loop over the keys directly.

Definition at line 130 of file rb_parametrized.C.

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

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

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

  return parameter_names;
}

get_parameters()

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

inherited

Get the current parameters.

Definition at line 157 of file rb_parametrized.C.

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

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

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

  return parameters;
}

get_parameters_max()

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

inherited

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

Definition at line 171 of file rb_parametrized.C.

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

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

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

  return parameters_max;
}

get_parameters_min()

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

inherited

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

Definition at line 164 of file rb_parametrized.C.

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

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

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

  return parameters_min;
}

get_params_from_training_set()

template<class Base >

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

protected

Return the RBParameters in index global_index of the global training set.

Why do we use an index here? RBParameters supports loading the full sample set. This seems probably unnecessary now to load individually. Maybe it's a memory issue?

Definition at line 231 of file rb_construction_base.C.

{
  libmesh_error_msg_if(!_training_parameters_initialized,
                       "Error: training parameters must first be initialized.");

  // If the _training_parameters are empty, return an empty RBParameters.
  // Otherwise, create a new RBParameters object from the single sample requested.
  RBParameters params;
  if (!_training_parameters.empty())
    {
      libmesh_error_msg_if((global_index < this->get_first_local_training_index()) ||
                           (global_index >= this->get_last_local_training_index()),
                           "Error: index "
                           << global_index
                           << " must be within range: "
                           << this->get_first_local_training_index()
                           << " - "
                           << this->get_last_local_training_index());

      const numeric_index_type local_index = global_index - get_first_local_training_index();
      for (const auto & [param_name, sample_vector] : _training_parameters)
        params.set_value(param_name, sample_vector[local_index]);

      // Copy all extra values into the new RBParameters.
      // We assume that the samples may be indexed differently for extra parameters,
      // so we don't just copy the local_index value.
      const auto & mine = get_parameters();
      for (const auto & [key, extra_sample_vector] :
           as_range(mine.extra_begin(), mine.extra_end()))
        {
          for (const auto idx : index_range(extra_sample_vector))
            params.set_extra_value(key, idx, extra_sample_vector[idx]);
        }
    }

  return params;
}

increment_constructor_count()

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

inlineprotectednoexceptinherited

Increments the construction counter.

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

Definition at line 183 of file reference_counter.h.

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

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

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

increment_destructor_count()

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

inlineprotectednoexceptinherited

Increments the destruction counter.

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

Definition at line 207 of file reference_counter.h.

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

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

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

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 SimpleRBConstruction, SimpleRBConstruction, SimpleRBConstruction, SimpleRBConstruction, SimpleRBConstruction, SimpleRBConstruction, ElasticityRBConstruction, SimpleEIMConstruction, and SimpleEIMConstruction.

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

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

Definition at line 53 of file rb_parametrized.C.

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

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

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

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

  parameters_min = mu_min_in;
  parameters_max = mu_max_in;

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

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

      libmesh_assert_less_equal(min_val, max_val);

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

    _discrete_parameter_values = discrete_parameter_values;

  parameters_initialized = true;

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

initialize_parameters() [2/2]

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

inherited

Initialize the parameter ranges and set current_parameters.

Definition at line 96 of file rb_parametrized.C.

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

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

initialize_training_parameters()

template<class Base >

void libMesh::RBConstructionBase< Base >::initialize_training_parameters ( const RBParameters &  mu_min, const RBParameters &  mu_max, const unsigned int  n_global_training_samples, const std::map< std::string, bool > &  log_param_scale, const 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.

n_global_training_samples is the total number of samples to generate, which will be distributed across all the processors.

Definition at line 292 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)
    {
      const auto [first_local_index, last_local_index] =
        generate_training_parameters_deterministic(this->comm(),
                                                   log_param_scale,
                                                   _training_parameters,
                                                   n_global_training_samples,
                                                   mu_min,
                                                   mu_max,
                                                   serial_training_set);
      _first_local_index = first_local_index;
      _n_local_training_samples = last_local_index-first_local_index;
    }
  else
    {
      // Generate random training samples for all parameters
      const auto [first_local_index, last_local_index] =
        generate_training_parameters_random(this->comm(),
                                            log_param_scale,
                                            _training_parameters,
                                            n_global_training_samples,
                                            mu_min,
                                            mu_max,
                                            this->_training_parameters_random_seed,
                                            serial_training_set);
      _first_local_index = first_local_index;
      _n_local_training_samples = last_local_index-first_local_index;
    }
  _n_global_training_samples = _n_local_training_samples;

  if (!serial_training_set)
    this->comm().sum(_n_global_training_samples);

  // For each parameter that only allows discrete values, we "snap" to the nearest
  // allowable discrete value
  if (get_n_discrete_params() > 0)
    {
      for (auto & [param_name, sample_vector] : _training_parameters)
        {
          if (is_discrete_parameter(param_name))
            {
              const std::vector<Real> & discrete_values =
                libmesh_map_find(get_discrete_parameter_values(), param_name);

              for (const auto sample_idx : index_range(sample_vector))
                {
                  // Round all values to the closest discrete value.
                  std::vector<Real> discretized_vector(sample_vector[sample_idx].size());
                  std::transform(sample_vector[sample_idx].cbegin(),
                                 sample_vector[sample_idx].cend(),
                                 discretized_vector.begin(),
                                 [&discrete_values](const Real & val) {
                                   return get_closest_value(val, discrete_values);
                                 });
                  sample_vector[sample_idx] = discretized_vector;
                }
            }
        }
    }

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

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

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

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

  return _discrete_parameter_values.count(mu_name);
}

is_quiet()

template<class Base>

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

inline

Is the system in quiet mode?

Definition at line 106 of file rb_construction_base.h.

  { return this->quiet_mode; }

load_training_set()

template<class Base >

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

virtual

Overwrite the training parameters with new_training_set.

This training set is assumed to contain only the samples local to this processor.

Definition at line 379 of file rb_construction_base.C.

{
  // Make sure we're running this on all processors at the same time
  libmesh_parallel_only(this->comm());

  // First, make sure that an initial training set has already been generated
  libmesh_error_msg_if(!_training_parameters_initialized,
                       "Error: load_training_set cannot be used to initialize parameters");

  // Make sure that the training set has the correct number of parameters
  const unsigned int n_params = get_n_params();
  libmesh_error_msg_if(new_training_set.size() > n_params,
                       "Error: new_training_set should not have more than get_n_params() parameters.");

  // Check that (new_training_set.size() == get_n_params()) is the same on all processes so that
  // we go into the same branch of the "if" statement below on all processes.
  const bool size_matches = (new_training_set.size() == n_params);
  libmesh_assert(this->comm().verify(size_matches));

  if (size_matches)
    {
      // If new_training_set stores values for all parameters, then we overwrite
      // _training_parameters with new_training_set.

      // Get the number of local and global training parameters
      _first_local_index = 0;
      _n_local_training_samples =
        cast_int<numeric_index_type>(new_training_set.begin()->second.size());
      _n_global_training_samples = _n_local_training_samples;

      if (!serial_training_set)
        {
          this->comm().sum(_n_global_training_samples);

          // Set the first/last indices.
          std::vector<numeric_index_type> local_sizes (this->n_processors(), 0);
          local_sizes[this->processor_id()] = _n_local_training_samples;
          this->comm().sum(local_sizes);

          // first_local_index is the sum of local_sizes
          // for all processor ids less than ours
          for (auto p : make_range(this->processor_id()))
            _first_local_index += local_sizes[p];
        }

      // Ensure that the parameters are the same.
      for (const auto & pr : _training_parameters)
        libmesh_error_msg_if(!new_training_set.count(pr.first),
                             "Parameters must be identical in order to overwrite dataset.");

      // Copy the values from the new_training_set to the internal training_parameters.
      _training_parameters = new_training_set;
    }
  else
    {
      // If new_training_set stores values for a subset of the parameters, then we keep the
      // length of training_parameters unchanged and overwrite the entries of the specified
      // parameters from new_training_set. Note that we repeatedly loop over new_training_set
      // to fill up the entire length of the sample_vector.
      for (auto & [param_name, sample_vector]: _training_parameters)
        {
          if (new_training_set.count(param_name))
            {
              for (const auto i : make_range(get_local_n_training_samples()))
                {
                  const unsigned int num_new_samples = libmesh_map_find(new_training_set,param_name).size();
                  libmesh_error_msg_if (num_new_samples==0, "new_training_set set should not be empty");

                  const unsigned int new_training_set_index = i % num_new_samples;
                  sample_vector[i] = libmesh_map_find(new_training_set,param_name)[new_training_set_index];
                }
            }
        }
    }
}

n_objects()

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

inlinestaticinherited

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

Definition at line 85 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

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

  { return _n_objects; }

operator=() [1/2]

template<class Base>

RBConstructionBase& libMesh::RBConstructionBase< Base >::operator= ( RBConstructionBase< Base > &&  )

delete

operator=() [2/2]

template<class Base>

RBConstructionBase& libMesh::RBConstructionBase< Base >::operator= ( const RBConstructionBase< Base > &  )

delete

print_discrete_parameter_values()

void libMesh::RBParametrized::print_discrete_parameter_values ( ) const

inherited

Print out all the discrete parameter values.

Definition at line 380 of file rb_parametrized.C.

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

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

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

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

print_info()

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

staticinherited

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

Definition at line 81 of file reference_counter.C.

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

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

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

print_parameters()

void libMesh::RBParametrized::print_parameters ( ) const

inherited

Print the current parameters.

Definition at line 192 of file rb_parametrized.C.

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

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

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

  get_parameters().print();
}

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

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

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

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

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

  initialize_parameters(param_min, param_max, discrete_parameter_values_in);
}

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

template<class Base >

void libMesh::RBConstructionBase< Base >::set_normalize_solution_snapshots

(

bool

value

)

Set the boolean option that indicates if we normalization solution snapshots or not.

Definition at line 147 of file rb_construction_base.C.

{
  _normalize_solution_snapshots = value;
}

set_parameters()

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

inherited

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

We

Returns

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

Definition at line 143 of file rb_parametrized.C.

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

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

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

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

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

  return valid_params;
}

set_params_from_training_set()

template<class Base >

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

protected

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

Definition at line 225 of file rb_construction_base.C.

{
  set_parameters(get_params_from_training_set(global_index));
}

set_params_from_training_set_and_broadcast()

template<class Base >

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

protectedvirtual

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

Definition at line 270 of file rb_construction_base.C.

{
  libmesh_error_msg_if(!_training_parameters_initialized,
                       "Error: training parameters must first be initialized.");

  processor_id_type root_id = 0;
  if ((this->get_first_local_training_index() <= global_index) &&
      (global_index < this->get_last_local_training_index()))
    {
      // Set parameters on only one processor
      set_params_from_training_set(global_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 100 of file rb_construction_base.h.

  { this->quiet_mode = quiet_mode_in; }

set_training_parameter_values()

template<class Base >

void libMesh::RBConstructionBase< Base >::set_training_parameter_values	(	const std::string &	param_name,
		const std::vector< RBParameter > &	values
	)

Overwrite the local training samples for param_name using values.

This assumes that values.size() matches get_local_n_training_samples().

Definition at line 456 of file rb_construction_base.C.

{
  libmesh_error_msg_if(!_training_parameters_initialized,
    "Training parameters must be initialized before calling set_training_parameter_values");
  libmesh_error_msg_if(values.size() != get_local_n_training_samples(),
    "Inconsistent sizes");

  // Copy the new data, overwriting the old data.
  auto & training_vector = libmesh_map_find(_training_parameters, param_name);
  training_vector = values;
}

set_training_random_seed()

template<class Base >

void libMesh::RBConstructionBase< Base >::set_training_random_seed

(

int

seed

)

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

Definition at line 780 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 87 of file rb_construction_base.h.

{ return *this; }

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

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

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

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

Member Data Documentation

_counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

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

_enable_print_counter

bool libMesh::ReferenceCounter::_enable_print_counter = true

staticprotectedinherited

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

Definition at line 143 of file reference_counter.h.

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

_first_local_index

template<class Base>

numeric_index_type libMesh::RBConstructionBase< Base >::_first_local_index

private

The first sample-vector index from the global vector which is stored in the _training_parameters on this processor.

_n_local_training_samples is equivalent to the .size() of any vector in _training_parameters.

Definition at line 313 of file rb_construction_base.h.

_mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 of file reference_counter.h.

_n_global_training_samples

template<class Base>

numeric_index_type libMesh::RBConstructionBase< Base >::_n_global_training_samples

private

Definition at line 315 of file rb_construction_base.h.

_n_local_training_samples

template<class Base>

numeric_index_type libMesh::RBConstructionBase< Base >::_n_local_training_samples

private

Definition at line 314 of file rb_construction_base.h.

_n_objects

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

staticprotectedinherited

The number of objects.

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

Definition at line 132 of file reference_counter.h.

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

_normalize_solution_snapshots

template<class Base>

bool libMesh::RBConstructionBase< Base >::_normalize_solution_snapshots

protected

Set this boolean to true if we want to normalize solution snapshots used in training to have norm of 1.

This is relevant if snapshots have differing magnitudes and we want to approximate them all with equal accuracy.

Definition at line 281 of file rb_construction_base.h.

_training_parameters

template<class Base>

std::map<std::string, std::vector<RBParameter> > libMesh::RBConstructionBase< Base >::_training_parameters

private

The training samples for each parameter.

When serial_training_set is true, the map contains all samples of all parameters. Otherwise, the sample vectors will only contain the values for the local samples as defined by _first_local_index and _n_local_training_samples. Mapped from parameter_name -> sample_vector -> value_vector.

Definition at line 306 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 297 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 323 of file rb_construction_base.h.

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 288 of file rb_construction_base.h.

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 265 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 273 of file rb_construction_base.h.

verbose_mode

bool libMesh::RBParametrized::verbose_mode

inherited

Public boolean to toggle verbose mode.

Definition at line 193 of file rb_parametrized.h.

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