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

#include <transient_rb_evaluation.h>

Inheritance diagram for libMesh::TransientRBEvaluation:

Public Types
typedef RBEvaluation	Parent
	The type of the parent.

Public Member Functions
	TransientRBEvaluation (const Parallel::Communicator &comm_in)
	Constructor.

	TransientRBEvaluation (TransientRBEvaluation &&)=default
	Special functions.

	TransientRBEvaluation (const TransientRBEvaluation &)=delete

TransientRBEvaluation &	operator= (const TransientRBEvaluation &)=delete

TransientRBEvaluation &	operator= (TransientRBEvaluation &&)=default

virtual	~TransientRBEvaluation ()

virtual void	clear () override
	Clear this TransientRBEvaluation object.

virtual void	resize_data_structures (const unsigned int Nmax, bool resize_error_bound_data=true) override
	Resize and clear the data vectors corresponding to the value of `Nmax`.

virtual Real	rb_solve (unsigned int N) override
	Perform online solve with the N RB basis functions, for the set of parameters in current_params, where 0 <= N <= RB_size.

virtual Real	rb_solve_again ()
	If a solve has already been performed, then we cached some data and we can perform a new solve much more rapidly (with the same parameters but a possibly different initial condition/rhs control).

virtual Real	get_error_bound_normalization () override

virtual Real	residual_scaling_numer (Real alpha_LB)
	Specifies the residual scaling on the numerator to be used in the a posteriori error bound.

virtual Real	compute_residual_dual_norm (const unsigned int N) override
	Compute the dual norm of the residual for the solution saved in RB_solution_vector.

virtual Real	uncached_compute_residual_dual_norm (const unsigned int N)
	Compute the dual norm of the residual for the solution saved in RB_solution.

void	cache_online_residual_terms (const unsigned int N)
	Helper function for caching the terms in the online residual assembly that do not change in time.

virtual void	clear_riesz_representors () override
	Clear all the Riesz representors that are used to compute the RB residual (and hence error bound).

virtual void	legacy_write_offline_data_to_files (const std::string &directory_name="offline_data", const bool write_binary_data=true) override
	Write out all the data to text files in order to segregate the Offline stage from the Online stage.

virtual void	legacy_read_offline_data_from_files (const std::string &directory_name="offline_data", bool read_error_bound_data=true, const bool read_binary_data=true) override
	Read in the saved Offline reduced basis data to initialize the system for Online solves.

virtual Real	rb_solve (unsigned int N)
	Perform online solve for current_params with the N basis functions.

virtual Real	rb_solve (unsigned int N, const std::vector< Number > *evaluated_thetas)
	Perform online solve for current_params with the N basis functions.

virtual Real	compute_residual_dual_norm (const unsigned int N)
	Compute the dual norm of the residual for the solution saved in RB_solution.

virtual Real	compute_residual_dual_norm (const unsigned int N, const std::vector< Number > *evaluated_thetas)
	Compute the dual norm of the residual for the solution saved in RB_solution.

void	set_rb_theta_expansion (RBThetaExpansion &rb_theta_expansion_in)
	Set the RBThetaExpansion object.

RBThetaExpansion &	get_rb_theta_expansion ()
	Get a reference to the rb_theta_expansion.

const RBThetaExpansion &	get_rb_theta_expansion () const

bool	is_rb_theta_expansion_initialized () const

NumericVector< Number > &	get_basis_function (unsigned int i)
	Get a reference to the i^th basis function.

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

virtual Real	residual_scaling_denom (Real alpha_LB)
	Specifies the residual scaling on the denominator to be used in the a posteriori error bound.

Real	eval_output_dual_norm (unsigned int n, const std::vector< Number > *evaluated_thetas)
	Evaluate the dual norm of output `n` for the current parameters, or using the pre-evaluted theta values provided in the "evaluated_thetas" array.

virtual Real	get_stability_lower_bound ()
	Get a lower bound for the stability constant (e.g.

virtual unsigned int	get_n_basis_functions () const
	Get the current number of basis functions.

virtual void	set_n_basis_functions (unsigned int n_bfs)
	Set the number of basis functions.

virtual void	write_out_basis_functions (System &sys, const std::string &directory_name="offline_data", const bool write_binary_basis_functions=true)
	Write out all the basis functions to file.

virtual void	read_in_basis_functions (System &sys, const std::string &directory_name="offline_data", const bool read_binary_basis_functions=true)
	Read in all the basis functions from file.

void	initialize_parameters (const RBParameters &mu_min_in, const RBParameters &mu_max_in, const std::map< std::string, std::vector< Real > > &discrete_parameter_values)
	Initialize the parameter ranges and set current_parameters.

void	initialize_parameters (const RBParametrized &rb_parametrized)
	Initialize the parameter ranges and set current_parameters.

unsigned int	get_n_params () const
	Get the number of parameters.

unsigned int	get_n_continuous_params () const
	Get the number of continuous parameters.

unsigned int	get_n_discrete_params () const
	Get the number of discrete parameters.

const RBParameters &	get_parameters () const
	Get the current parameters.

bool	set_parameters (const RBParameters &params)
	Set the current parameters to `params` The parameters are checked for validity; an error is thrown if the number of parameters or samples is different than expected.

const RBParameters &	get_parameters_min () const
	Get an RBParameters object that specifies the minimum allowable value for each parameter.

const RBParameters &	get_parameters_max () const
	Get an RBParameters object that specifies the maximum allowable value for each parameter.

Real	get_parameter_min (const std::string &param_name) const
	Get minimum allowable value of parameter `param_name`.

Real	get_parameter_max (const std::string &param_name) const
	Get maximum allowable value of parameter `param_name`.

void	print_parameters () const
	Print the current parameters.

void	write_parameter_data_to_files (const std::string &continuous_param_file_name, const std::string &discrete_param_file_name, const bool write_binary_data)
	Write out the parameter ranges to files.

void	read_parameter_data_from_files (const std::string &continuous_param_file_name, const std::string &discrete_param_file_name, const bool read_binary_data)
	Read in the parameter ranges from files.

bool	is_discrete_parameter (const std::string &mu_name) const
	Is parameter `mu_name` discrete?

const std::map< std::string, std::vector< Real > > &	get_discrete_parameter_values () const
	Get a const reference to the discrete parameter values.

void	print_discrete_parameter_values () const
	Print out all the discrete parameter values.

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Real	get_delta_t () const
	Get/set delta_t, the time-step size.

void	set_delta_t (const Real delta_t_in)

Real	get_euler_theta () const
	Get/set euler_theta, parameter that determines the temporal discretization.

void	set_euler_theta (const Real euler_theta_in)

unsigned int	get_time_step () const
	Get/set the current time-step.

void	set_time_step (const unsigned int k)

unsigned int	get_n_time_steps () const
	Get/set the total number of time-steps.

void	set_n_time_steps (const unsigned int K)

Real	get_control (const unsigned int k) const
	Get/set the RHS control.

void	set_control (const std::vector< Real > &control)

void	process_temporal_parameters_file (const std::string &parameters_filename)
	Read in and initialize parameters from `parameters_filename`.

void	pull_temporal_discretization_data (RBTemporalDiscretization &other)
	Pull the temporal discretization data from `other`.

Static Public Member Functions
static void	write_out_vectors (System &sys, std::vector< NumericVector< Number > * > &vectors, const std::string &directory_name="offline_data", const std::string &data_name="bf", const bool write_binary_basis_functions=true)
	Same as write_out_basis_functions, except in this case we pass in the vectors to be written.

static void	read_in_vectors (System &sys, std::vector< std::unique_ptr< NumericVector< Number > > > &vectors, const std::string &directory_name, const std::string &data_name, const bool read_binary_vectors)
	Same as read_in_basis_functions, except in this case we pass in the vectors to be written.

static void	read_in_vectors_from_multiple_files (System &sys, std::vector< std::vector< std::unique_ptr< NumericVector< Number > > > * > multiple_vectors, const std::vector< std::string > &multiple_directory_names, const std::vector< std::string > &multiple_data_names, const bool read_binary_vectors)
	Performs read_in_vectors for a list of directory names and data names.

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

static std::string	get_info ()
	Gets a string containing the reference information.

static void	print_info (std::ostream &out_stream=libMesh::out)
	Prints the reference information, by default to `libMesh::out`.

static unsigned int	n_objects ()
	Prints the number of outstanding (created, but not yet destroyed) objects.

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

static void	disable_print_counter_info ()

Public Attributes
DenseMatrix< Number >	RB_L2_matrix
	Dense RB L2 matrix.

DenseMatrix< Number >	RB_LHS_matrix
	Cached data for subsequent solves.

DenseMatrix< Number >	RB_RHS_matrix

DenseVector< Number >	RB_RHS_save

std::vector< DenseMatrix< Number > >	RB_M_q_vector
	Dense matrices for the RB mass matrices.

std::vector< std::vector< Number > >	RB_outputs_all_k
	The RB outputs for all time-levels from the most recent rb_solve.

std::vector< std::vector< Real > >	RB_output_error_bounds_all_k
	The error bounds for each RB output for all time-levels from the most recent rb_solve.

DenseVector< Number >	old_RB_solution
	The RB solution at the previous time-level.

std::vector< DenseVector< Number > >	RB_temporal_solution_data
	Array storing the solution data at each time level from the most recent solve.

std::vector< Real >	error_bound_all_k
	The error bound data for all time-levels from the most recent rb_solve.

std::vector< Real >	initial_L2_error_all_N
	Vector storing initial L2 error for all 1 <= N <= RB_size.

std::vector< DenseVector< Number > >	RB_initial_condition_all_N
	The RB initial conditions (i.e.

std::vector< std::vector< std::vector< Number > > >	Fq_Mq_representor_innerprods
	Vectors storing the residual representor inner products to be used in computing the residuals online.

std::vector< std::vector< std::vector< Number > > >	Mq_Mq_representor_innerprods

std::vector< std::vector< std::vector< std::vector< Number > > > >	Aq_Mq_representor_innerprods

Number	cached_Fq_term
	Cached residual terms.

DenseVector< Number >	cached_Fq_Aq_vector

DenseMatrix< Number >	cached_Aq_Aq_matrix

DenseVector< Number >	cached_Fq_Mq_vector

DenseMatrix< Number >	cached_Aq_Mq_matrix

DenseMatrix< Number >	cached_Mq_Mq_matrix

std::vector< std::vector< std::unique_ptr< NumericVector< Number > > > >	M_q_representor
	Vector storing the mass matrix representors.

bool	_rb_solve_data_cached
	Check that the data has been cached in case of using rb_solve_again.

std::vector< std::unique_ptr< NumericVector< Number > > >	basis_functions
	The libMesh vectors storing the finite element coefficients of the RB basis functions.

std::vector< RBParameters >	greedy_param_list
	The list of parameters selected by the Greedy algorithm in generating the Reduced Basis associated with this RBEvaluation object.

DenseMatrix< Number >	RB_inner_product_matrix
	The inner product matrix.

std::vector< DenseMatrix< Number > >	RB_Aq_vector
	Dense matrices for the RB computations.

std::vector< DenseVector< Number > >	RB_Fq_vector
	Dense vector for the RHS.

DenseVector< Number >	RB_solution
	The RB solution vector.

std::vector< std::vector< DenseVector< Number > > >	RB_output_vectors
	The vectors storing the RB output vectors.

std::vector< Number >	RB_outputs
	The vectors storing the RB output values and corresponding error bounds.

std::vector< Real >	RB_output_error_bounds

std::vector< Number >	Fq_representor_innerprods
	Vectors storing the residual representor inner products to be used in computing the residuals online.

std::vector< std::vector< std::vector< Number > > >	Fq_Aq_representor_innerprods
	Vectors storing the residual representor inner products to be used in computing the residuals online.

std::vector< std::vector< std::vector< Number > > >	Aq_Aq_representor_innerprods

std::vector< std::vector< Number > >	output_dual_innerprods
	The vector storing the dual norm inner product terms for each output.

std::vector< std::vector< std::unique_ptr< NumericVector< Number > > > >	Aq_representor
	Vector storing the residual representors associated with the left-hand side.

bool	evaluate_RB_error_bound
	Boolean to indicate whether we evaluate a posteriori error bounds when rb_solve is called.

bool	compute_RB_inner_product
	Boolean flag to indicate whether we compute the RB_inner_product_matrix.

bool	verbose_mode
	Public boolean to toggle verbose mode.

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

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

void	increment_destructor_count (const std::string &name) noexcept
	Increments the destruction counter.

Static Protected Member Functions
static void	assert_file_exists (const std::string &file_name)
	Helper function that checks if `file_name` exists.

Protected Attributes
const Parallel::Communicator &	_communicator

Static Protected Attributes
static Counts	_counts
	Actually holds the data.

static Threads::atomic< unsigned int >	_n_objects
	The number of objects.

static Threads::spin_mutex	_mutex
	Mutual exclusion object to enable thread-safe reference counting.

static bool	_enable_print_counter = true
	Flag to control whether reference count information is printed when print_info is called.

Private Member Functions
void	check_evaluated_thetas_size (const std::vector< Number > *evaluated_thetas) const
	For interfaces like rb_solve() and compute_residual_dual_norm() that optinally take a vector of "pre-evaluated" theta values, this function checks to make sure that, when provided, it is the right size.

void	write_parameter_ranges_to_file (const std::string &file_name, const bool write_binary)
	Write out the parameter ranges to file.

void	write_discrete_parameter_values_to_file (const std::string &file_name, const bool write_binary_data)
	Write out the discrete parameter values to file.

void	read_parameter_ranges_from_file (const std::string &file_name, const bool read_binary, RBParameters &param_min, RBParameters &param_max)
	Read in the parameter ranges from file.

void	read_discrete_parameter_values_from_file (const std::string &file_name, const bool read_binary_data, std::map< std::string, std::vector< Real > > &discrete_parameter_values_in)
	Read in the discrete parameter values from file, if we have any.

bool	check_if_valid_params (const RBParameters &params) const
	Helper function to check that `params` is valid:

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

Private Attributes
RBThetaExpansion *	rb_theta_expansion
	A pointer to to the object that stores the theta expansion.

bool	parameters_initialized
	Flag indicating whether the parameters have been initialized.

RBParameters	parameters
	Vector storing the current parameters.

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

RBParameters	parameters_max

std::map< std::string, std::vector< Real > >	_discrete_parameter_values
	Map that defines the allowable values of any discrete parameters.

Real	_delta_t
	The time-step size.

Real	_euler_theta
	The parameter that determines the generalized Euler scheme discretization that we employ.

unsigned int	_current_time_step
	The current time-step.

unsigned int	_n_time_steps
	The number of time-steps.

std::vector< Real >	_control
	The RHS control (scalar function of time).

Detailed Description

This class is part of the rbOOmit framework.

TransientRBEvaluation extends RBEvaluation to encapsulate the code and data required to perform "online" RB evaluations for Linear Time Invariant (LTI) transient problems.

We can handle time controls on the RHS as h(t)*f(x, \( \mu \)). See Martin Grepl's thesis for more details.

Author: David J. Knezevic

Date: 2011

Definition at line 50 of file transient_rb_evaluation.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.

◆ Parent

typedef RBEvaluation libMesh::TransientRBEvaluation::Parent

The type of the parent.

Definition at line 74 of file transient_rb_evaluation.h.

Constructor & Destructor Documentation

◆ TransientRBEvaluation() [1/3]

TransientRBEvaluation::TransientRBEvaluation ( const Parallel::Communicator & comm_in )

Constructor.

Definition at line 39 of file transient_rb_evaluation.C.

                                                                                 :
  RBEvaluation(comm_in),
  _rb_solve_data_cached(false)
{
  // Indicate that we need to compute the RB
  // inner product matrix in this case
  compute_RB_inner_product = true;
}

References libMesh::RBEvaluation::compute_RB_inner_product.

◆ TransientRBEvaluation() [2/3]

libMesh::TransientRBEvaluation::TransientRBEvaluation ( TransientRBEvaluation && )

default

Special functions.

This class contains unique_ptrs, so it can't be default copy constructed/assigned.
The destructor is defaulted out of line.

◆ TransientRBEvaluation() [3/3]

libMesh::TransientRBEvaluation::TransientRBEvaluation ( const TransientRBEvaluation & )

delete

◆ ~TransientRBEvaluation()

TransientRBEvaluation::~TransientRBEvaluation ( )

virtualdefault

Member Function Documentation

◆ assert_file_exists()

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

staticprotectedinherited

Helper function that checks if file_name exists.

Definition at line 977 of file rb_evaluation.C.

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

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

◆ cache_online_residual_terms()

void TransientRBEvaluation::cache_online_residual_terms ( const unsigned int N )

Helper function for caching the terms in the online residual assembly that do not change in time.

(This is only useful when the parameter is fixed in time.)

Definition at line 417 of file transient_rb_evaluation.C.

{
  LOG_SCOPE("cache_online_residual_terms()", "TransientRBEvaluation");
 
  const RBParameters mu = get_parameters();
 
  TransientRBThetaExpansion & trans_theta_expansion =
    cast_ref<TransientRBThetaExpansion &>(get_rb_theta_expansion());
  const unsigned int Q_m = trans_theta_expansion.get_n_M_terms();
  const unsigned int Q_a = trans_theta_expansion.get_n_A_terms();
  const unsigned int Q_f = trans_theta_expansion.get_n_F_terms();
 
  cached_Fq_term = 0.;
  unsigned int q=0;
  for (unsigned int q_f1=0; q_f1<Q_f; q_f1++)
    {
      Number cached_theta_q_f1 = trans_theta_expansion.eval_F_theta(q_f1,mu);
      for (unsigned int q_f2=q_f1; q_f2<Q_f; q_f2++)
        {
          Real delta = (q_f1==q_f2) ? 1. : 2.;
          cached_Fq_term += delta*cached_theta_q_f1*trans_theta_expansion.eval_F_theta(q_f2,mu) *
            Fq_representor_innerprods[q];
 
          q++;
        }
    }
 
  cached_Fq_Aq_vector.resize(N);
  for (unsigned int q_f=0; q_f<Q_f; q_f++)
    {
      Number cached_theta_q_f = trans_theta_expansion.eval_F_theta(q_f,mu);
      for (unsigned int q_a=0; q_a<Q_a; q_a++)
        {
          Number cached_theta_q_a = trans_theta_expansion.eval_A_theta(q_a,mu);
          for (unsigned int i=0; i<N; i++)
            {
              cached_Fq_Aq_vector(i) += 2.*cached_theta_q_f*cached_theta_q_a*
                Fq_Aq_representor_innerprods[q_f][q_a][i];
            }
        }
    }
 
  cached_Aq_Aq_matrix.resize(N,N);
  q=0;
  for (unsigned int q_a1=0; q_a1<Q_a; q_a1++)
    {
      Number cached_theta_q_a1 = trans_theta_expansion.eval_A_theta(q_a1,mu);
      for (unsigned int q_a2=q_a1; q_a2<Q_a; q_a2++)
        {
          Number cached_theta_q_a2 = trans_theta_expansion.eval_A_theta(q_a2,mu);
          Real delta = (q_a1==q_a2) ? 1. : 2.;
 
          for (unsigned int i=0; i<N; i++)
            {
              for (unsigned int j=0; j<N; j++)
                {
                  cached_Aq_Aq_matrix(i,j) += delta*
                    cached_theta_q_a1*cached_theta_q_a2*
                    Aq_Aq_representor_innerprods[q][i][j];
                }
            }
          q++;
        }
    }
 
  cached_Fq_Mq_vector.resize(N);
  for (unsigned int q_f=0; q_f<Q_f; q_f++)
    {
      Number cached_theta_q_f = trans_theta_expansion.eval_F_theta(q_f,mu);
      for (unsigned int q_m=0; q_m<Q_m; q_m++)
        {
          Number cached_theta_q_m = trans_theta_expansion.eval_M_theta(q_m,mu);
          for (unsigned int i=0; i<N; i++)
            {
              cached_Fq_Mq_vector(i) += 2.*cached_theta_q_f * cached_theta_q_m * Fq_Mq_representor_innerprods[q_f][q_m][i];
            }
        }
    }
 
  cached_Aq_Mq_matrix.resize(N,N);
  for (unsigned int q_a=0; q_a<Q_a; q_a++)
    {
      Number cached_theta_q_a = trans_theta_expansion.eval_A_theta(q_a,mu);
 
      for (unsigned int q_m=0; q_m<Q_m; q_m++)
        {
          Number cached_theta_q_m = trans_theta_expansion.eval_M_theta(q_m,mu);
 
          for (unsigned int i=0; i<N; i++)
            {
              for (unsigned int j=0; j<N; j++)
                {
                  cached_Aq_Mq_matrix(i,j) += 2.*cached_theta_q_a*cached_theta_q_m*Aq_Mq_representor_innerprods[q_a][q_m][i][j];
                }
            }
        }
    }
 
  cached_Mq_Mq_matrix.resize(N,N);
  q=0;
  for (unsigned int q_m1=0; q_m1<Q_m; q_m1++)
    {
      Number cached_theta_q_m1 = trans_theta_expansion.eval_M_theta(q_m1,mu);
      for (unsigned int q_m2=q_m1; q_m2<Q_m; q_m2++)
        {
          Number cached_theta_q_m2 = trans_theta_expansion.eval_M_theta(q_m2,mu);
          Real delta = (q_m1==q_m2) ? 1. : 2.;
 
          for (unsigned int i=0; i<N; i++)
            {
              for (unsigned int j=0; j<N; j++)
                {
                  cached_Mq_Mq_matrix(i,j) += delta*
                    cached_theta_q_m1*cached_theta_q_m2*
                    Mq_Mq_representor_innerprods[q][i][j];
                }
            }
          q++;
        }
    }
}

References libMesh::RBEvaluation::Aq_Aq_representor_innerprods, Aq_Mq_representor_innerprods, cached_Aq_Aq_matrix, cached_Aq_Mq_matrix, cached_Fq_Aq_vector, cached_Fq_Mq_vector, cached_Fq_term, cached_Mq_Mq_matrix, libMesh::RBThetaExpansion::eval_A_theta(), libMesh::RBThetaExpansion::eval_F_theta(), libMesh::TransientRBThetaExpansion::eval_M_theta(), libMesh::RBEvaluation::Fq_Aq_representor_innerprods, Fq_Mq_representor_innerprods, libMesh::RBEvaluation::Fq_representor_innerprods, libMesh::RBThetaExpansion::get_n_A_terms(), libMesh::RBThetaExpansion::get_n_F_terms(), libMesh::TransientRBThetaExpansion::get_n_M_terms(), libMesh::RBParametrized::get_parameters(), libMesh::RBEvaluation::get_rb_theta_expansion(), Mq_Mq_representor_innerprods, libMesh::Real, libMesh::DenseVector< T >::resize(), and libMesh::DenseMatrix< T >::resize().

Referenced by rb_solve().

◆ check_evaluated_thetas_size()

void libMesh::RBEvaluation::check_evaluated_thetas_size ( const std::vector< Number > * evaluated_thetas ) const

privateinherited

For interfaces like rb_solve() and compute_residual_dual_norm() that optinally take a vector of "pre-evaluated" theta values, this function checks to make sure that, when provided, it is the right size.

Definition at line 1196 of file rb_evaluation.C.

{
  if (rb_theta_expansion && evaluated_thetas)
    {
      auto actual_size = evaluated_thetas->size();
      auto expected_size =
        rb_theta_expansion->get_n_A_terms() +
        rb_theta_expansion->get_n_F_terms() +
        rb_theta_expansion->get_total_n_output_terms();
 
      libmesh_error_msg_if(actual_size != expected_size,
                           "ERROR: Evaluated thetas vector has size " <<
                           actual_size << ", but we expected " <<
                           rb_theta_expansion->get_n_A_terms() << " A term(s), " <<
                           rb_theta_expansion->get_n_F_terms() << " F term(s), and " <<
                           rb_theta_expansion->get_total_n_output_terms() << " output term(s), " <<
                           "for a total of " << expected_size << " terms.");
    }
}

References libMesh::RBThetaExpansion::get_n_A_terms(), libMesh::RBThetaExpansion::get_n_F_terms(), libMesh::RBThetaExpansion::get_total_n_output_terms(), and libMesh::RBEvaluation::rb_theta_expansion.

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

◆ check_if_valid_params()

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

privateinherited

Helper function to check that params is valid:

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

Definition at line 378 of file rb_parametrized.C.

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

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

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

◆ clear()

void TransientRBEvaluation::clear ( )

overridevirtual

Clear this TransientRBEvaluation object.

Override to also clear the M_q representors

Reimplemented from libMesh::RBEvaluation.

Definition at line 50 of file transient_rb_evaluation.C.

{
  Parent::clear();
 
  clear_riesz_representors();
}

References libMesh::RBEvaluation::clear(), and clear_riesz_representors().

◆ clear_riesz_representors()

void TransientRBEvaluation::clear_riesz_representors ( )

overridevirtual

Clear all the Riesz representors that are used to compute the RB residual (and hence error bound).

This is useful since once we complete the Greedy we may not need the representors any more. Override to clear the M_q representors.

Reimplemented from libMesh::RBEvaluation.

Definition at line 57 of file transient_rb_evaluation.C.

{
  Parent::clear_riesz_representors();
 
  // Delete the M_q representors
  M_q_representor.clear();
}

References libMesh::RBEvaluation::clear_riesz_representors(), and M_q_representor.

Referenced by clear().

◆ comm()

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

inlineinherited

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

Definition at line 97 of file parallel_object.h.

98 { return _communicator; }

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition parallel_object.h:120

References libMesh::ParallelObject::_communicator.

◆ compute_residual_dual_norm() [1/3]

Real libMesh::RBEvaluation::compute_residual_dual_norm ( const unsigned int N )

virtual

Compute the dual norm of the residual for the solution saved in RB_solution.

This function uses the cached time-independent data.

Reimplemented from libMesh::RBEvaluation.

Definition at line 137 of file rb_evaluation.C.

{
  return compute_residual_dual_norm(N, nullptr);
}

References libMesh::RBEvaluation::RB_Fq_vector.

◆ compute_residual_dual_norm() [2/3]

Real TransientRBEvaluation::compute_residual_dual_norm ( const unsigned int N )

overridevirtual

Compute the dual norm of the residual for the solution saved in RB_solution_vector.

Reimplemented from libMesh::RBEvaluation.

Definition at line 539 of file transient_rb_evaluation.C.

{
  LOG_SCOPE("compute_residual_dual_norm()", "TransientRBEvaluation");
 
  // This assembly assumes we have already called cache_online_residual_terms
  // and that the rb_solve parameter is constant in time
 
  const Real dt          = get_delta_t();
  const Real euler_theta = get_euler_theta();
  const Real current_control = get_control(get_time_step());
 
  DenseVector<Number> RB_u_euler_theta(N);
  DenseVector<Number> mass_coeffs(N);
  for (unsigned int i=0; i<N; i++)
    {
      RB_u_euler_theta(i)  = euler_theta*RB_solution(i) +
        (1.-euler_theta)*old_RB_solution(i);
      mass_coeffs(i) = -(RB_solution(i) - old_RB_solution(i))/dt;
    }
 
  Number residual_norm_sq = current_control*current_control*cached_Fq_term;
 
  residual_norm_sq += current_control*RB_u_euler_theta.dot(cached_Fq_Aq_vector);
  residual_norm_sq += current_control*mass_coeffs.dot(cached_Fq_Mq_vector);
 
  for (unsigned int i=0; i<N; i++)
    for (unsigned int j=0; j<N; j++)
      {
        residual_norm_sq += RB_u_euler_theta(i)*RB_u_euler_theta(j)*cached_Aq_Aq_matrix(i,j);
        residual_norm_sq += mass_coeffs(i)*mass_coeffs(j)*cached_Mq_Mq_matrix(i,j);
        residual_norm_sq += RB_u_euler_theta(i)*mass_coeffs(j)*cached_Aq_Mq_matrix(i,j);
      }
 
 
  if (libmesh_real(residual_norm_sq) < 0)
    {
      libMesh::out << "Warning: Square of residual norm is negative "
                   << "in TransientRBEvaluation::compute_residual_dual_norm()" << std::endl;
 
      // Sometimes this is negative due to rounding error,
      // but error is on the order of 1.e-10, so shouldn't
      // affect result
      residual_norm_sq = std::abs(residual_norm_sq);
    }
 
  return libmesh_real(std::sqrt( residual_norm_sq ));
}

References cached_Aq_Aq_matrix, cached_Aq_Mq_matrix, cached_Fq_Aq_vector, cached_Fq_Mq_vector, cached_Fq_term, cached_Mq_Mq_matrix, libMesh::DenseVector< T >::dot(), libMesh::RBTemporalDiscretization::get_control(), libMesh::RBTemporalDiscretization::get_delta_t(), libMesh::RBTemporalDiscretization::get_euler_theta(), libMesh::RBTemporalDiscretization::get_time_step(), libMesh::libmesh_real(), old_RB_solution, libMesh::out, libMesh::RBEvaluation::RB_solution, and libMesh::Real.

Referenced by rb_solve().

◆ compute_residual_dual_norm() [3/3]

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

virtual

Compute the dual norm of the residual for the solution saved in RB_solution.

This function uses the cached time-independent data.

Reimplemented from libMesh::RBEvaluation.

Definition at line 143 of file rb_evaluation.C.

{
  LOG_SCOPE("compute_residual_dual_norm()", "RBEvaluation");
 
  // In case the theta functions have been pre-evaluated, first check the size for consistency
  this->check_evaluated_thetas_size(evaluated_thetas);
 
  // If evaluated_thetas is provided, then mu is not actually used for anything
  const RBParameters & mu = get_parameters();
 
  const unsigned int n_A_terms = rb_theta_expansion->get_n_A_terms();
  const unsigned int n_F_terms = rb_theta_expansion->get_n_F_terms();
 
  // Use the stored representor inner product values
  // to evaluate the residual norm
  Number residual_norm_sq = 0.;
 
  // Lambdas to help with evaluating F_theta and A_theta functions
  // using either the pre-evaluated thetas (if provided) or by calling
  // eval_{F,A}_theta()
  auto eval_F = [&](unsigned int index)
    {
      return (evaluated_thetas) ? (*evaluated_thetas)[index + n_A_terms] : rb_theta_expansion->eval_F_theta(index, mu);
    };
  auto eval_A = [&](unsigned int index)
    {
      return (evaluated_thetas) ? (*evaluated_thetas)[index] : rb_theta_expansion->eval_A_theta(index, mu);
    };
 
  unsigned int q=0;
  for (unsigned int q_f1=0; q_f1<n_F_terms; q_f1++)
    {
      const Number val_q_f1 = eval_F(q_f1);
 
      for (unsigned int q_f2=q_f1; q_f2<n_F_terms; q_f2++)
        {
          const Number val_q_f2 = eval_F(q_f2);
 
          Real delta = (q_f1==q_f2) ? 1. : 2.;
          residual_norm_sq += delta * libmesh_real(val_q_f1 * libmesh_conj(val_q_f2) * Fq_representor_innerprods[q] );
 
          q++;
        }
    }
 
  for (unsigned int q_f=0; q_f<n_F_terms; q_f++)
    {
      const Number val_q_f = eval_F(q_f);
 
      for (unsigned int q_a=0; q_a<n_A_terms; q_a++)
        {
          const Number val_q_a = eval_A(q_a);
 
          for (unsigned int i=0; i<N; i++)
            {
              Real delta = 2.;
              residual_norm_sq +=
                delta * libmesh_real( val_q_f * libmesh_conj(val_q_a) *
                                      libmesh_conj(RB_solution(i)) * Fq_Aq_representor_innerprods[q_f][q_a][i] );
            }
        }
    }
 
  q=0;
  for (unsigned int q_a1=0; q_a1<n_A_terms; q_a1++)
    {
      const Number val_q_a1 = eval_A(q_a1);
 
      for (unsigned int q_a2=q_a1; q_a2<n_A_terms; q_a2++)
        {
          const Number val_q_a2 = eval_A(q_a2);
 
          Real delta = (q_a1==q_a2) ? 1. : 2.;
 
          for (unsigned int i=0; i<N; i++)
            {
              for (unsigned int j=0; j<N; j++)
                {
                  residual_norm_sq +=
                    delta * libmesh_real( libmesh_conj(val_q_a1) * val_q_a2 *
                                          libmesh_conj(RB_solution(i)) * RB_solution(j) * Aq_Aq_representor_innerprods[q][i][j] );
                }
            }
 
          q++;
        }
    }
 
  if (libmesh_real(residual_norm_sq) < 0.)
    {
      //    libMesh::out << "Warning: Square of residual norm is negative "
      //                 << "in RBSystem::compute_residual_dual_norm()" << std::endl;
 
      //     Sometimes this is negative due to rounding error,
      //     but when this occurs the error is on the order of 1.e-10,
      //     so shouldn't affect error bound much...
      residual_norm_sq = std::abs(residual_norm_sq);
    }
 
  return std::sqrt( libmesh_real(residual_norm_sq) );
}

References libMesh::RBThetaExpansion::get_n_output_terms(), libMesh::RBEvaluation::RB_output_vectors, and libMesh::RBEvaluation::rb_theta_expansion.

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 100 of file reference_counter.C.

{
  _enable_print_counter = false;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

◆ enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Enabled by default.

Definition at line 94 of file reference_counter.C.

{
  _enable_print_counter = true;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

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

◆ eval_output_dual_norm()

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

inherited

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

Definition at line 474 of file rb_evaluation.C.

{
  // Return value
  Number output_bound_sq = 0.;
 
  // mu is only used if evaluated_thetas == nullptr
  const RBParameters & mu = this->get_parameters();
 
  // Index into output_dual_innerprods
  unsigned int q=0;
  for (unsigned int q_l1=0; q_l1<rb_theta_expansion->get_n_output_terms(n); q_l1++)
    {
      for (unsigned int q_l2=q_l1; q_l2<rb_theta_expansion->get_n_output_terms(n); q_l2++)
        {
          Real delta = (q_l1==q_l2) ? 1. : 2.;
 
          Number val_l1 =
            evaluated_thetas ?
            (*evaluated_thetas)[rb_theta_expansion->output_index_1D(n, q_l1) + rb_theta_expansion->get_n_A_terms() + rb_theta_expansion->get_n_F_terms()] :
            rb_theta_expansion->eval_output_theta(n, q_l1, mu);
 
          Number val_l2 =
            evaluated_thetas ?
            (*evaluated_thetas)[rb_theta_expansion->output_index_1D(n, q_l2) + rb_theta_expansion->get_n_A_terms() + rb_theta_expansion->get_n_F_terms()] :
            rb_theta_expansion->eval_output_theta(n, q_l2, mu);
 
          output_bound_sq += delta * libmesh_real(
            libmesh_conj(val_l1) * val_l2 * output_dual_innerprods[n][q]);
 
          q++;
        }
    }
 
  return libmesh_real(std::sqrt( output_bound_sq ));
}

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

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

◆ get_basis_function() [1/2]

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

inherited

Get a reference to the i^th basis function.

Definition at line 207 of file rb_evaluation.C.

{
  libmesh_assert_less (i, basis_functions.size());
 
  return *(basis_functions[i]);
}

References libMesh::RBEvaluation::basis_functions.

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

◆ get_basis_function() [2/2]

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

inherited

Definition at line 214 of file rb_evaluation.C.

{
  libmesh_assert_less (i, basis_functions.size());
 
  return *(basis_functions[i]);
}

References libMesh::RBEvaluation::basis_functions.

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

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

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

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

◆ get_control()

Real libMesh::RBTemporalDiscretization::get_control ( const unsigned int k ) const

inherited

Get/set the RHS control.

Definition at line 79 of file rb_temporal_discretization.C.

{
  libmesh_assert_less_equal (k, get_n_time_steps());
  return _control[k];
}

References libMesh::RBTemporalDiscretization::_control, and libMesh::RBTemporalDiscretization::get_n_time_steps().

Referenced by compute_residual_dual_norm(), rb_solve(), rb_solve_again(), and libMesh::TransientRBConstruction::truth_assembly().

◆ get_delta_t()

Real libMesh::RBTemporalDiscretization::get_delta_t ( ) const

inherited

Get/set delta_t, the time-step size.

Definition at line 36 of file rb_temporal_discretization.C.

{
  return _delta_t;
}

References libMesh::RBTemporalDiscretization::_delta_t.

Referenced by libMesh::RBDataSerialization::add_transient_rb_evaluation_data_to_builder(), compute_residual_dual_norm(), legacy_write_offline_data_to_files(), libMesh::TransientRBConstruction::print_info(), libMesh::RBTemporalDiscretization::process_temporal_parameters_file(), libMesh::RBTemporalDiscretization::pull_temporal_discretization_data(), rb_solve(), residual_scaling_numer(), libMesh::TransientRBConstruction::truth_assembly(), and uncached_compute_residual_dual_norm().

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

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

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

◆ get_error_bound_normalization()

Real TransientRBEvaluation::get_error_bound_normalization ( )

overridevirtual

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

Reimplemented from libMesh::RBEvaluation.

Definition at line 403 of file transient_rb_evaluation.C.

{
  // Just set the normalization factor to 1 in this case.
  // Users can override this method if specific behavior
  // is required.
 
  return 1.;
}

◆ get_euler_theta()

Real libMesh::RBTemporalDiscretization::get_euler_theta ( ) const

inherited

Get/set euler_theta, parameter that determines the temporal discretization.

Definition at line 46 of file rb_temporal_discretization.C.

{
  return _euler_theta;
}

References libMesh::RBTemporalDiscretization::_euler_theta.

Referenced by libMesh::RBDataSerialization::add_transient_rb_evaluation_data_to_builder(), compute_residual_dual_norm(), legacy_write_offline_data_to_files(), libMesh::TransientRBConstruction::print_info(), libMesh::RBTemporalDiscretization::process_temporal_parameters_file(), libMesh::RBTemporalDiscretization::pull_temporal_discretization_data(), rb_solve(), libMesh::TransientRBConstruction::truth_assembly(), and uncached_compute_residual_dual_norm().

◆ get_info()

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

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

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

References libMesh::ReferenceCounter::_counts.

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

◆ get_n_basis_functions()

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

inlinevirtualinherited

Get the current number of basis functions.

Definition at line 169 of file rb_evaluation.h.

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

References libMesh::RBEvaluation::basis_functions.

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

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

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

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

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

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

References libMesh::RBParameters::n_parameters(), 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::RBEIMConstruction::print_info(), libMesh::RBSCMConstruction::print_info(), libMesh::RBConstruction::print_info(), libMesh::RBEIMEvaluation::set_eim_error_indicator_active(), and libMesh::RBConstruction::train_reduced_basis_with_POD().

◆ get_n_time_steps()

unsigned int libMesh::RBTemporalDiscretization::get_n_time_steps ( ) const

inherited

Get/set the total number of time-steps.

Definition at line 68 of file rb_temporal_discretization.C.

{
  return _n_time_steps;
}

References libMesh::RBTemporalDiscretization::_n_time_steps.

Referenced by libMesh::RBDataSerialization::add_transient_rb_evaluation_data_to_builder(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::RBTemporalDiscretization::get_control(), legacy_write_offline_data_to_files(), libMesh::TransientRBConstruction::print_info(), libMesh::RBTemporalDiscretization::process_temporal_parameters_file(), libMesh::RBTemporalDiscretization::pull_temporal_discretization_data(), rb_solve(), rb_solve_again(), libMesh::RBTemporalDiscretization::set_time_step(), and libMesh::TransientRBConstruction::truth_solve().

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

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

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

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

◆ get_parameter_min()

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

inherited

Get minimum allowable value of parameter param_name.

Definition at line 164 of file rb_parametrized.C.

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

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

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

◆ get_parameters()

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

inherited

Get the current parameters.

Definition at line 143 of file rb_parametrized.C.

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

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

Referenced by libMesh::TransientRBConstruction::add_scaled_mass_matrix(), cache_online_residual_terms(), libMesh::RBEvaluation::compute_residual_dual_norm(), libMesh::RBSCMConstruction::compute_SCM_bounds_on_training_set(), libMesh::RBSCMConstruction::enrich_C_J(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::RBEvaluation::eval_output_dual_norm(), libMesh::RBSCMConstruction::evaluate_stability_constant(), libMesh::RBConstruction::get_RB_error_bound(), libMesh::RBSCMEvaluation::get_SCM_LB(), libMesh::RBSCMEvaluation::get_SCM_UB(), SimpleRBEvaluation::get_stability_lower_bound(), libMesh::RBConstruction::greedy_termination_test(), libMesh::RBEIMConstruction::initialize_parametrized_functions_in_training_set(), libMesh::RBSCMEvaluation::legacy_read_offline_data_from_files(), main(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::RBConstruction::preevaluate_thetas(), libMesh::RBEIMConstruction::print_info(), libMesh::RBSCMConstruction::print_info(), libMesh::RBConstruction::print_info(), libMesh::RBParametrized::print_parameters(), libMesh::RBSCMConstruction::process_parameters_file(), rb_solve(), libMesh::RBEvaluation::rb_solve(), libMesh::RBSCMEvaluation::save_current_parameters(), libMesh::RBEIMConstruction::train_eim_approximation_with_greedy(), libMesh::RBEIMConstruction::train_eim_approximation_with_POD(), libMesh::RBConstruction::truth_assembly(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_solve(), libMesh::TransientRBConstruction::truth_solve(), 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 157 of file rb_parametrized.C.

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

References 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(), libMesh::RBEIMConstruction::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 150 of file rb_parametrized.C.

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

References 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(), libMesh::RBEIMConstruction::set_rb_construction_parameters(), and libMesh::RBParametrized::write_parameter_ranges_to_file().

◆ get_rb_theta_expansion() [1/2]

RBThetaExpansion & libMesh::RBEvaluation::get_rb_theta_expansion ( )

inherited

Get a reference to the rb_theta_expansion.

Definition at line 85 of file rb_evaluation.C.

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

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

Referenced by libMesh::RBDataSerialization::add_rb_evaluation_data_to_builder(), libMesh::RBDataSerialization::add_transient_rb_evaluation_data_to_builder(), cache_online_residual_terms(), libMesh::RBConstruction::get_rb_theta_expansion(), libMesh::RBConstruction::get_rb_theta_expansion(), legacy_read_offline_data_from_files(), legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_rb_evaluation_data(), libMesh::RBDataDeserialization::load_transient_rb_evaluation_data(), main(), libMesh::RBConstruction::preevaluate_thetas(), rb_solve(), resize_data_structures(), and uncached_compute_residual_dual_norm().

◆ get_rb_theta_expansion() [2/2]

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

inherited

Definition at line 93 of file rb_evaluation.C.

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

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

◆ get_stability_lower_bound()

Real libMesh::RBEvaluation::get_stability_lower_bound ( )

virtualinherited

Get a lower bound for the stability constant (e.g.

coercivity constant or inf-sup constant) at the current parameter value.

Reimplemented in SimpleRBEvaluation, SimpleRBEvaluation, SimpleRBEvaluation, ElasticityRBEvaluation, SimpleRBEvaluation, and SimpleRBEvaluation.

Definition at line 459 of file rb_evaluation.C.

{
  // Return a default value of 1, this function should
  // be overloaded to specify a problem-dependent stability
  // factor lower bound
  return 1.;
}

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

◆ get_time_step()

unsigned int libMesh::RBTemporalDiscretization::get_time_step ( ) const

inherited

Get/set the current time-step.

Definition at line 57 of file rb_temporal_discretization.C.

{
  return _current_time_step;
}

References libMesh::RBTemporalDiscretization::_current_time_step.

Referenced by libMesh::RBDataSerialization::add_transient_rb_evaluation_data_to_builder(), compute_residual_dual_norm(), libMesh::TransientRBConstruction::get_error_temporal_data(), legacy_write_offline_data_to_files(), libMesh::TransientRBConstruction::load_rb_solution(), libMesh::RBTemporalDiscretization::pull_temporal_discretization_data(), rb_solve(), libMesh::TransientRBConstruction::set_error_temporal_data(), and libMesh::TransientRBConstruction::truth_assembly().

◆ increment_constructor_count()

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

inlineprotectednoexceptinherited

Increments the construction counter.

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

Definition at line 183 of file reference_counter.h.

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

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

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

◆ increment_destructor_count()

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

inlineprotectednoexceptinherited

Increments the destruction counter.

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

Definition at line 207 of file reference_counter.h.

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

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

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

◆ initialize_parameters() [1/2]

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

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.

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

References libMesh::RBParametrized::_discrete_parameter_values, libMesh::RBParameters::begin_serialized(), libMesh::RBParameters::end_serialized(), libMesh::RBParameters::n_parameters(), libMesh::RBParameters::n_samples(), 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::RBConstruction::set_rb_construction_parameters(), libMesh::RBEIMConstruction::set_rb_construction_parameters(), RBParametersTest::testRBParametrized(), libMesh::RBEIMConstruction::train_eim_approximation_with_greedy(), libMesh::RBEIMConstruction::train_eim_approximation_with_POD(), libMesh::RBConstruction::train_reduced_basis_with_greedy(), and libMesh::RBConstruction::train_reduced_basis_with_POD().

◆ initialize_parameters() [2/2]

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

inherited

Initialize the parameter ranges and set current_parameters.

Definition at line 96 of file rb_parametrized.C.

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

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

◆ is_discrete_parameter()

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

inherited

Is parameter mu_name discrete?

Definition at line 351 of file rb_parametrized.C.

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

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

◆ is_rb_theta_expansion_initialized()

bool libMesh::RBEvaluation::is_rb_theta_expansion_initialized ( ) const

inherited

Returns: true if the theta expansion has been initialized.

Definition at line 101 of file rb_evaluation.C.

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

References libMesh::RBEvaluation::rb_theta_expansion.

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

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

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

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

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

◆ legacy_read_offline_data_from_files()

void TransientRBEvaluation::legacy_read_offline_data_from_files	(	const std::string &	directory_name = `"offline_data"`,
		bool	read_error_bound_data = `true`,
		const bool	read_binary_data = `true`
	)

overridevirtual

Read in the saved Offline reduced basis data to initialize the system for Online solves.

Note: This is a legacy method, use RBDataSerialization instead.

Reimplemented from libMesh::RBEvaluation.

Definition at line 890 of file transient_rb_evaluation.C.

{
  LOG_SCOPE("legacy_read_offline_data_from_files()", "TransientRBEvaluation");
 
  Parent::legacy_read_offline_data_from_files(directory_name);
 
  TransientRBThetaExpansion & trans_theta_expansion =
    cast_ref<TransientRBThetaExpansion &>(get_rb_theta_expansion());
  const unsigned int Q_m = trans_theta_expansion.get_n_M_terms();
  const unsigned int Q_a = trans_theta_expansion.get_n_A_terms();
  const unsigned int Q_f = trans_theta_expansion.get_n_F_terms();
 
  // First, find out how many basis functions we had when Greedy terminated
  // This was set in RBSystem::read_offline_data_from_files
  unsigned int n_bfs = this->get_n_basis_functions();
 
  // The reading mode: DECODE for binary, READ for ASCII
  XdrMODE mode = read_binary_data ? DECODE : READ;
 
  // The suffix to use for all the files that are written out
  const std::string suffix = read_binary_data ? ".xdr" : ".dat";
 
  // The string stream we'll use to make the file names
  std::ostringstream file_name;
 
  // Write out the temporal discretization data
  file_name.str("");
  file_name << directory_name << "/temporal_discretization_data" << suffix;
  assert_file_exists(file_name.str());
 
  Xdr temporal_discretization_data_in(file_name.str(), mode);
 
  Real real_value; unsigned int int_value;
  temporal_discretization_data_in >> real_value; set_delta_t(real_value);
  temporal_discretization_data_in >> real_value; set_euler_theta(real_value);
  temporal_discretization_data_in >> int_value; set_n_time_steps(int_value);
  temporal_discretization_data_in >> int_value; set_time_step(int_value);
  temporal_discretization_data_in.close();
 
  file_name.str("");
  file_name << directory_name << "/RB_L2_matrix" << suffix;
  assert_file_exists(file_name.str());
 
  Xdr RB_L2_matrix_in(file_name.str(), mode);
 
  for (unsigned int i=0; i<n_bfs; i++)
    {
      for (unsigned int j=0; j<n_bfs; j++)
        {
          Number value;
          RB_L2_matrix_in >> value;
          RB_L2_matrix(i,j) = value;
        }
    }
  RB_L2_matrix_in.close();
 
  // Read in the M_q matrices
  for (unsigned int q_m=0; q_m<Q_m; q_m++)
    {
      file_name.str("");
      file_name << directory_name << "/RB_M_";
      file_name << std::setw(3)
                << std::setprecision(0)
                << std::setfill('0')
                << std::right
                << q_m;
 
      file_name << suffix;
      assert_file_exists(file_name.str());
 
      Xdr RB_M_q_m_in(file_name.str(), mode);
 
      for (unsigned int i=0; i<n_bfs; i++)
        {
          for (unsigned int j=0; j<n_bfs; j++)
            {
              Number value;
              RB_M_q_m_in >> value;
              RB_M_q_vector[q_m](i,j) = value;
            }
        }
      RB_M_q_m_in.close();
    }
 
 
  // Read in the initial condition data
  // and the initial L2 error for all N
  file_name.str("");
  file_name << directory_name << "/initial_conditions" << suffix;
  assert_file_exists(file_name.str());
 
  Xdr initial_conditions_in(file_name.str(), mode);
 
  file_name.str("");
  file_name << directory_name << "/initial_L2_error" << suffix;
  assert_file_exists(file_name.str());
 
  Xdr initial_L2_error_in(file_name.str(), mode);
 
  for (unsigned int i=0; i<n_bfs; i++)
    {
      initial_L2_error_in >> initial_L2_error_all_N[i];
      for (unsigned int j=0; j<=i; j++)
        {
          initial_conditions_in >> RB_initial_condition_all_N[i](j);
        }
    }
  initial_conditions_in.close();
  initial_L2_error_in.close();
 
 
  if (read_error_bound_data)
    {
      // Next read in the Fq_Mq representor norm data
      file_name.str("");
      file_name << directory_name << "/Fq_Mq_terms" << suffix;
      assert_file_exists(file_name.str());
 
      Xdr RB_Fq_Mq_terms_in(file_name.str(), mode);
 
      for (unsigned int q_f=0; q_f<Q_f; q_f++)
        {
          for (unsigned int q_m=0; q_m<Q_m; q_m++)
            {
              for (unsigned int i=0; i<n_bfs; i++)
                {
                  RB_Fq_Mq_terms_in >> Fq_Mq_representor_innerprods[q_f][q_m][i];
                }
            }
        }
      RB_Fq_Mq_terms_in.close();
 
      // Next read in the Mq_Mq representor norm data
      file_name.str("");
      file_name << directory_name << "/Mq_Mq_terms" << suffix;
      assert_file_exists(file_name.str());
 
      Xdr RB_Mq_Mq_terms_in(file_name.str(), mode);
 
      unsigned int Q_m_hat = Q_m*(Q_m+1)/2;
      for (unsigned int q=0; q<Q_m_hat; q++)
        {
          for (unsigned int i=0; i<n_bfs; i++)
            {
              for (unsigned int j=0; j<n_bfs; j++)
                {
                  RB_Mq_Mq_terms_in >> Mq_Mq_representor_innerprods[q][i][j];
                }
            }
        }
      RB_Mq_Mq_terms_in.close();
 
      // Next read in the Aq_Mq representor norm data
      file_name.str("");
      file_name << directory_name << "/Aq_Mq_terms" << suffix;
      assert_file_exists(file_name.str());
 
      Xdr RB_Aq_Mq_terms_in(file_name.str(), mode);
 
      for (unsigned int q_a=0; q_a<Q_a; q_a++)
        {
          for (unsigned int q_m=0; q_m<Q_m; q_m++)
            {
              for (unsigned int i=0; i<n_bfs; i++)
                {
                  for (unsigned int j=0; j<n_bfs; j++)
                    {
                      RB_Aq_Mq_terms_in >> Aq_Mq_representor_innerprods[q_a][q_m][i][j];
                    }
                }
            }
        }
      RB_Aq_Mq_terms_in.close();
    }
}

References Aq_Mq_representor_innerprods, libMesh::RBEvaluation::assert_file_exists(), libMesh::Xdr::close(), libMesh::DECODE, Fq_Mq_representor_innerprods, libMesh::RBThetaExpansion::get_n_A_terms(), libMesh::RBEvaluation::get_n_basis_functions(), libMesh::RBThetaExpansion::get_n_F_terms(), libMesh::TransientRBThetaExpansion::get_n_M_terms(), libMesh::RBEvaluation::get_rb_theta_expansion(), initial_L2_error_all_N, libMesh::RBEvaluation::legacy_read_offline_data_from_files(), Mq_Mq_representor_innerprods, RB_initial_condition_all_N, RB_L2_matrix, RB_M_q_vector, libMesh::READ, libMesh::Real, libMesh::RBTemporalDiscretization::set_delta_t(), libMesh::RBTemporalDiscretization::set_euler_theta(), libMesh::RBTemporalDiscretization::set_n_time_steps(), libMesh::RBTemporalDiscretization::set_time_step(), and value.

◆ legacy_write_offline_data_to_files()

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

overridevirtual

Write out all the data to text files in order to segregate the Offline stage from the Online stage.

Note: This is a legacy method, use RBDataSerialization instead.

Reimplemented from libMesh::RBEvaluation.

Definition at line 738 of file transient_rb_evaluation.C.

{
  LOG_SCOPE("legacy_write_offline_data_to_files()", "TransientRBEvaluation");
 
  Parent::legacy_write_offline_data_to_files(directory_name);
 
  TransientRBThetaExpansion & trans_theta_expansion =
    cast_ref<TransientRBThetaExpansion &>(get_rb_theta_expansion());
  const unsigned int Q_m = trans_theta_expansion.get_n_M_terms();
  const unsigned int Q_a = trans_theta_expansion.get_n_A_terms();
  const unsigned int Q_f = trans_theta_expansion.get_n_F_terms();
 
  const unsigned int n_bfs = get_n_basis_functions();
 
  // The writing mode: ENCODE for binary, WRITE for ASCII
  XdrMODE mode = write_binary_data ? ENCODE : WRITE;
 
  // The suffix to use for all the files that are written out
  const std::string suffix = write_binary_data ? ".xdr" : ".dat";
 
  if (this->processor_id() == 0)
    {
      std::ostringstream file_name;
 
      // Write out the temporal discretization data
      file_name.str("");
      file_name << directory_name << "/temporal_discretization_data" << suffix;
      Xdr temporal_discretization_data_out(file_name.str(), mode);
 
      Real real_value; unsigned int int_value;
      real_value = get_delta_t(); temporal_discretization_data_out << real_value;
      real_value = get_euler_theta(); temporal_discretization_data_out << real_value;
      int_value = get_n_time_steps(); temporal_discretization_data_out << int_value;
      int_value = get_time_step(); temporal_discretization_data_out << int_value;
      temporal_discretization_data_out.close();
 
 
      // Write out the L2 matrix
      file_name.str("");
      file_name << directory_name << "/RB_L2_matrix" << suffix;
      Xdr RB_L2_matrix_out(file_name.str(), mode);
 
      for (unsigned int i=0; i<n_bfs; i++)
        {
          for (unsigned int j=0; j<n_bfs; j++)
            {
              RB_L2_matrix_out << RB_L2_matrix(i,j);
            }
        }
      RB_L2_matrix_out.close();
 
      // Write out the M_q matrices
      for (unsigned int q_m=0; q_m<Q_m; q_m++)
        {
          file_name.str("");
          file_name << directory_name << "/RB_M_";
          file_name << std::setw(3)
                    << std::setprecision(0)
                    << std::setfill('0')
                    << std::right
                    << q_m;
          file_name << suffix;
          Xdr RB_M_q_m_out(file_name.str(), mode);
 
          for (unsigned int i=0; i<n_bfs; i++)
            {
              for (unsigned int j=0; j<n_bfs; j++)
                {
                  RB_M_q_m_out << RB_M_q_vector[q_m](i,j);
                }
            }
          RB_M_q_m_out.close();
        }
 
      // Write out the initial condition data
      // and the initial L2 error for all N
      file_name.str("");
      file_name << directory_name << "/initial_conditions" << suffix;
      Xdr initial_conditions_out(file_name.str(), mode);
      file_name.str("");
      file_name << directory_name << "/initial_L2_error" << suffix;
      Xdr initial_L2_error_out(file_name.str(), mode);
 
      for (unsigned int i=0; i<n_bfs; i++)
        {
          initial_L2_error_out << initial_L2_error_all_N[i];
          for (unsigned int j=0; j<=i; j++)
            {
              initial_conditions_out << RB_initial_condition_all_N[i](j);
            }
        }
      initial_conditions_out.close();
      initial_L2_error_out.close();
 
      // Next write out the Fq_Mq representor norm data
      file_name.str("");
      file_name << directory_name << "/Fq_Mq_terms" << suffix;
      Xdr RB_Fq_Mq_terms_out(file_name.str(), mode);
 
      for (unsigned int q_f=0; q_f<Q_f; q_f++)
        {
          for (unsigned int q_m=0; q_m<Q_m; q_m++)
            {
              for (unsigned int i=0; i<n_bfs; i++)
                {
                  RB_Fq_Mq_terms_out << Fq_Mq_representor_innerprods[q_f][q_m][i];
                }
            }
        }
      RB_Fq_Mq_terms_out.close();
 
      // Next write out the Mq_Mq representor norm data
      file_name.str("");
      file_name << directory_name << "/Mq_Mq_terms" << suffix;
      Xdr RB_Mq_Mq_terms_out(file_name.str(), mode);
 
      unsigned int Q_m_hat = Q_m*(Q_m+1)/2;
      for (unsigned int q=0; q<Q_m_hat; q++)
        {
          for (unsigned int i=0; i<n_bfs; i++)
            {
              for (unsigned int j=0; j<n_bfs; j++)
                {
                  RB_Mq_Mq_terms_out << Mq_Mq_representor_innerprods[q][i][j];
                }
            }
        }
      RB_Mq_Mq_terms_out.close();
 
      // Next write out the Aq_Mq representor norm data
      file_name.str("");
      file_name << directory_name << "/Aq_Mq_terms" << suffix;
      Xdr RB_Aq_Mq_terms_out(file_name.str(), mode);
 
      for (unsigned int q_a=0; q_a<Q_a; q_a++)
        {
          for (unsigned int q_m=0; q_m<Q_m; q_m++)
            {
              for (unsigned int i=0; i<n_bfs; i++)
                {
                  for (unsigned int j=0; j<n_bfs; j++)
                    {
                      RB_Aq_Mq_terms_out << Aq_Mq_representor_innerprods[q_a][q_m][i][j];
                    }
                }
            }
        }
      RB_Aq_Mq_terms_out.close();
    }
}

References Aq_Mq_representor_innerprods, libMesh::Xdr::close(), libMesh::ENCODE, Fq_Mq_representor_innerprods, libMesh::RBTemporalDiscretization::get_delta_t(), libMesh::RBTemporalDiscretization::get_euler_theta(), libMesh::RBThetaExpansion::get_n_A_terms(), libMesh::RBEvaluation::get_n_basis_functions(), libMesh::RBThetaExpansion::get_n_F_terms(), libMesh::TransientRBThetaExpansion::get_n_M_terms(), libMesh::RBTemporalDiscretization::get_n_time_steps(), libMesh::RBEvaluation::get_rb_theta_expansion(), libMesh::RBTemporalDiscretization::get_time_step(), initial_L2_error_all_N, libMesh::RBEvaluation::legacy_write_offline_data_to_files(), Mq_Mq_representor_innerprods, libMesh::ParallelObject::processor_id(), RB_initial_condition_all_N, RB_L2_matrix, RB_M_q_vector, libMesh::Real, and libMesh::WRITE.

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

86 { return _n_objects; }

libMesh::ReferenceCounter::_n_objects

static Threads::atomic< unsigned int > _n_objects

The number of objects.

Definition reference_counter.h:132

References libMesh::ReferenceCounter::_n_objects.

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

◆ n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns: The number of processors in the group.

Definition at line 103 of file parallel_object.h.

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

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

◆ operator=() [1/2]

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

delete

◆ operator=() [2/2]

TransientRBEvaluation & libMesh::TransientRBEvaluation::operator= ( TransientRBEvaluation && )

default

◆ print_discrete_parameter_values()

void libMesh::RBParametrized::print_discrete_parameter_values ( ) const

inherited

Print out all the discrete parameter values.

Definition at line 366 of file rb_parametrized.C.

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

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

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

◆ print_info()

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

staticinherited

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

Definition at line 81 of file reference_counter.C.

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

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

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

◆ print_parameters()

void libMesh::RBParametrized::print_parameters ( ) const

inherited

Print the current parameters.

Definition at line 178 of file rb_parametrized.C.

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

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

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

◆ process_temporal_parameters_file()

void libMesh::RBTemporalDiscretization::process_temporal_parameters_file ( const std::string & parameters_filename )

inherited

Read in and initialize parameters from parameters_filename.

Definition at line 93 of file rb_temporal_discretization.C.

{
  // Read in data from parameters_filename
  GetPot infile(parameters_filename);
 
  // Read in parameters related to temporal discretization
  unsigned int n_time_steps_in = infile("n_time_steps", get_n_time_steps());
  const Real delta_t_in        = infile("delta_t",      get_delta_t());
  const Real euler_theta_in    = infile("euler_theta",  get_euler_theta());
 
  // and set the relevant member variables
  set_n_time_steps(n_time_steps_in);
  set_delta_t(delta_t_in);
  set_euler_theta(euler_theta_in);
  set_time_step(0);
}

References libMesh::RBTemporalDiscretization::get_delta_t(), libMesh::RBTemporalDiscretization::get_euler_theta(), libMesh::RBTemporalDiscretization::get_n_time_steps(), libMesh::Real, libMesh::RBTemporalDiscretization::set_delta_t(), libMesh::RBTemporalDiscretization::set_euler_theta(), libMesh::RBTemporalDiscretization::set_n_time_steps(), and libMesh::RBTemporalDiscretization::set_time_step().

Referenced by libMesh::TransientRBConstruction::process_parameters_file().

◆ processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns: The rank of this processor in the group.

Definition at line 114 of file parallel_object.h.

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

libMesh::Parallel::Communicator::rank

processor_id_type rank() const

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

◆ pull_temporal_discretization_data()

void libMesh::RBTemporalDiscretization::pull_temporal_discretization_data ( RBTemporalDiscretization & other )

inherited

Pull the temporal discretization data from other.

Definition at line 110 of file rb_temporal_discretization.C.

{
  this->set_delta_t( other.get_delta_t() );
  this->set_euler_theta( other.get_euler_theta() );
  this->set_n_time_steps( other.get_n_time_steps() );
  this->set_time_step( other.get_time_step() );
  this->set_control( other._control );
}

Referenced by libMesh::TransientRBConstruction::process_parameters_file().

◆ rb_solve() [1/3]

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

virtual

Perform online solve for current_params with the N basis functions.

Overridden to perform a time-dependent solve.

Reimplemented from libMesh::RBEvaluation.

Definition at line 118 of file rb_evaluation.C.

{
  return rb_solve(N, nullptr);
}

◆ rb_solve() [2/3]

Real TransientRBEvaluation::rb_solve ( unsigned int N )

overridevirtual

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

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

Reimplemented from libMesh::RBEvaluation.

Definition at line 151 of file transient_rb_evaluation.C.

{
  LOG_SCOPE("rb_solve()", "TransientRBEvaluation");
 
  libmesh_error_msg_if(N > get_n_basis_functions(),
                       "ERROR: N cannot be larger than the number of basis functions in rb_solve");
 
  const RBParameters & mu = get_parameters();
 
  TransientRBThetaExpansion & trans_theta_expansion =
    cast_ref<TransientRBThetaExpansion &>(get_rb_theta_expansion());
  const unsigned int Q_m = trans_theta_expansion.get_n_M_terms();
  const unsigned int Q_a = trans_theta_expansion.get_n_A_terms();
  const unsigned int Q_f = trans_theta_expansion.get_n_F_terms();
 
  const unsigned int n_time_steps = get_n_time_steps();
  const Real dt                   = get_delta_t();
  const Real euler_theta          = get_euler_theta();
 
  // Resize the RB and error bound vectors
  error_bound_all_k.resize(n_time_steps+1);
  RB_outputs_all_k.resize(trans_theta_expansion.get_n_outputs());
  RB_output_error_bounds_all_k.resize(trans_theta_expansion.get_n_outputs());
  for (unsigned int n=0; n<trans_theta_expansion.get_n_outputs(); n++)
    {
      RB_outputs_all_k[n].resize(n_time_steps+1, 0.);
      RB_output_error_bounds_all_k[n].resize(n_time_steps+1, 0.);
    }
 
  // First assemble the mass matrix
  DenseMatrix<Number> RB_mass_matrix_N(N,N);
  RB_mass_matrix_N.zero();
  DenseMatrix<Number> RB_M_q_m;
  for (unsigned int q_m=0; q_m<Q_m; q_m++)
    {
      RB_M_q_vector[q_m].get_principal_submatrix(N, RB_M_q_m);
      RB_mass_matrix_N.add(trans_theta_expansion.eval_M_theta(q_m, mu), RB_M_q_m);
    }
 
  RB_LHS_matrix.resize(N,N);
  RB_LHS_matrix.zero();
 
  RB_RHS_matrix.resize(N,N);
  RB_RHS_matrix.zero();
 
  RB_LHS_matrix.add(1./dt, RB_mass_matrix_N);
  RB_RHS_matrix.add(1./dt, RB_mass_matrix_N);
 
  DenseMatrix<Number> RB_Aq_a;
  for (unsigned int q_a=0; q_a<Q_a; q_a++)
    {
      RB_Aq_vector[q_a].get_principal_submatrix(N, RB_Aq_a);
 
      RB_LHS_matrix.add(       euler_theta*trans_theta_expansion.eval_A_theta(q_a,mu), RB_Aq_a);
      RB_RHS_matrix.add( -(1.-euler_theta)*trans_theta_expansion.eval_A_theta(q_a,mu), RB_Aq_a);
    }
 
  // Add forcing terms
  DenseVector<Number> RB_Fq_f;
  RB_RHS_save.resize(N);
  RB_RHS_save.zero();
  for (unsigned int q_f=0; q_f<Q_f; q_f++)
    {
      RB_Fq_vector[q_f].get_principal_subvector(N, RB_Fq_f);
      RB_RHS_save.add(trans_theta_expansion.eval_F_theta(q_f,mu), RB_Fq_f);
    }
 
  // Set system time level to 0
  set_time_step(0);
 
  // Resize/clear the solution vector
  RB_solution.resize(N);
 
  // Load the initial condition into RB_solution
  if (N > 0)
    {
      RB_solution = RB_initial_condition_all_N[N-1];
    }
 
  // Resize/clear the old solution vector
  old_RB_solution.resize(N);
 
  // Initialize the RB rhs
  DenseVector<Number> RB_rhs(N);
  RB_rhs.zero();
 
  // Initialize the vectors storing solution data
  RB_temporal_solution_data.resize(n_time_steps+1);
  for (unsigned int time_level=0; time_level<=n_time_steps; time_level++)
    {
      RB_temporal_solution_data[time_level].resize(N);
    }
  // and load the initial data
  RB_temporal_solution_data[0] = RB_solution;
 
  // Set outputs at initial time
  {
    DenseVector<Number> RB_output_vector_N;
    for (unsigned int n=0; n<trans_theta_expansion.get_n_outputs(); n++)
      {
        RB_outputs_all_k[n][0] = 0.;
        for (unsigned int q_l=0; q_l<trans_theta_expansion.get_n_output_terms(n); q_l++)
          {
            RB_output_vectors[n][q_l].get_principal_subvector(N, RB_output_vector_N);
            RB_outputs_all_k[n][0] += trans_theta_expansion.eval_output_theta(n,q_l,mu)*RB_output_vector_N.dot(RB_solution);
          }
      }
  }
 
  // Initialize error bounds, if necessary
  Real error_bound_sum = 0.;
  Real alpha_LB = 0.;
  if (evaluate_RB_error_bound)
    {
      if (N > 0)
        {
          error_bound_sum += pow( initial_L2_error_all_N[N-1], 2.);
        }
 
      // Set error bound at the initial time
      error_bound_all_k[get_time_step()] = std::sqrt(error_bound_sum);
 
      // Compute the outputs and associated error bounds at the initial time
      DenseVector<Number> RB_output_vector_N;
      for (unsigned int n=0; n<trans_theta_expansion.get_n_outputs(); n++)
        {
          RB_outputs_all_k[n][0] = 0.;
          for (unsigned int q_l=0; q_l<trans_theta_expansion.get_n_output_terms(n); q_l++)
            {
              RB_output_vectors[n][q_l].get_principal_subvector(N, RB_output_vector_N);
              RB_outputs_all_k[n][0] += trans_theta_expansion.eval_output_theta(n,q_l,mu)*RB_output_vector_N.dot(RB_solution);
            }
 
          RB_output_error_bounds_all_k[n][0] = error_bound_all_k[0] * eval_output_dual_norm(n, nullptr);
        }
 
      alpha_LB = get_stability_lower_bound();
 
      // Precompute time-invariant parts of the dual norm of the residual.
      cache_online_residual_terms(N);
    }
 
  for (unsigned int time_level=1; time_level<=n_time_steps; time_level++)
    {
      set_time_step(time_level);
      old_RB_solution = RB_solution;
 
      // Compute RB_rhs, as RB_LHS_matrix x old_RB_solution
      RB_RHS_matrix.vector_mult(RB_rhs, old_RB_solution);
 
      // Add forcing terms
      RB_rhs.add(get_control(time_level), RB_RHS_save);
 
      if (N > 0)
        {
          RB_LHS_matrix.lu_solve(RB_rhs, RB_solution);
        }
 
      // Save RB_solution for current time level
      RB_temporal_solution_data[time_level] = RB_solution;
 
      // Evaluate outputs
      DenseVector<Number> RB_output_vector_N;
      for (unsigned int n=0; n<trans_theta_expansion.get_n_outputs(); n++)
        {
          RB_outputs_all_k[n][time_level] = 0.;
          for (unsigned int q_l=0; q_l<trans_theta_expansion.get_n_output_terms(n); q_l++)
            {
              RB_output_vectors[n][q_l].get_principal_subvector(N, RB_output_vector_N);
              RB_outputs_all_k[n][time_level] += trans_theta_expansion.eval_output_theta(n,q_l,mu)*
                RB_output_vector_N.dot(RB_solution);
            }
        }
 
      // Calculate RB error bounds
      if (evaluate_RB_error_bound)
        {
          // Evaluate the dual norm of the residual for RB_solution_vector
          // Real epsilon_N = uncached_compute_residual_dual_norm(N);
          Real epsilon_N = compute_residual_dual_norm(N);
 
          error_bound_sum += residual_scaling_numer(alpha_LB) * pow(epsilon_N, 2.);
 
          // store error bound at time-level _k
          error_bound_all_k[time_level] = std::sqrt(error_bound_sum/residual_scaling_denom(alpha_LB));
 
          // Now evaluated output error bounds
          for (unsigned int n=0; n<trans_theta_expansion.get_n_outputs(); n++)
            {
              RB_output_error_bounds_all_k[n][time_level] = error_bound_all_k[time_level] *
                eval_output_dual_norm(n, nullptr);
            }
        }
    }
 
  _rb_solve_data_cached = true ;
 
  if (evaluate_RB_error_bound) // Calculate the error bounds
    {
      return error_bound_all_k[n_time_steps];
    }
  else // Don't calculate the error bounds
    {
      // Just return -1. if we did not compute the error bound
      return -1.;
    }
}

◆ rb_solve() [3/3]

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

virtual

Perform online solve for current_params with the N basis functions.

Overridden to perform a time-dependent solve.

Reimplemented from libMesh::RBEvaluation.

Definition at line 124 of file rb_evaluation.C.

{
  LOG_SCOPE("rb_solve()", "RBEvaluation");
 
  libmesh_error_msg_if(N > get_n_basis_functions(),
                       "ERROR: N cannot be larger than the number of basis functions in rb_solve");
 
  // In case the theta functions have been pre-evaluated, first check the size for consistency. The
  // size of the input "evaluated_thetas" vector must match the sum of the "A", "F", and "output" terms
  // in the expansion.
  this->check_evaluated_thetas_size(evaluated_thetas);
 
  const RBParameters & mu = get_parameters();
 
  // Resize (and clear) the solution vector
  RB_solution.resize(N);
 
  // Assemble the RB system
  DenseMatrix<Number> RB_system_matrix(N,N);
  RB_system_matrix.zero();
 
  DenseMatrix<Number> RB_Aq_a;
  for (unsigned int q_a=0; q_a<rb_theta_expansion->get_n_A_terms(); q_a++)
    {
      RB_Aq_vector[q_a].get_principal_submatrix(N, RB_Aq_a);
 
      if (evaluated_thetas)
        RB_system_matrix.add((*evaluated_thetas)[q_a], RB_Aq_a);
      else
        RB_system_matrix.add(rb_theta_expansion->eval_A_theta(q_a, mu), RB_Aq_a);
    }
 
  // Assemble the RB rhs
  DenseVector<Number> RB_rhs(N);
  RB_rhs.zero();
 
  DenseVector<Number> RB_Fq_f;
  for (unsigned int q_f=0; q_f<rb_theta_expansion->get_n_F_terms(); q_f++)
    {
      RB_Fq_vector[q_f].get_principal_subvector(N, RB_Fq_f);
 
      if (evaluated_thetas)
        RB_rhs.add((*evaluated_thetas)[q_f+rb_theta_expansion->get_n_A_terms()], RB_Fq_f);
      else
        RB_rhs.add(rb_theta_expansion->eval_F_theta(q_f, mu), RB_Fq_f);
    }
 
  // Solve the linear system
  if (N > 0)
    {
      RB_system_matrix.lu_solve(RB_rhs, RB_solution);
    }
 
  // Place to store the output of get_principal_subvector() calls
  DenseVector<Number> RB_output_vector_N;
 
  // Evaluate RB outputs
  unsigned int output_counter = 0;
  for (unsigned int n=0; n<rb_theta_expansion->get_n_outputs(); n++)
    {
      RB_outputs[n] = 0.;
      for (unsigned int q_l=0; q_l<rb_theta_expansion->get_n_output_terms(n); q_l++)
        {
          RB_output_vectors[n][q_l].get_principal_subvector(N, RB_output_vector_N);
 
          // Compute dot product with current output vector and RB_solution
          auto dot_prod = RB_output_vector_N.dot(RB_solution);
 
          // Determine the coefficient depending on whether or not
          // pre-evaluated thetas were provided. Note that if
          // pre-evaluated thetas were provided, they must come after
          // the "A" and "F" thetas and be in "row-major" order. In
          // other words, there is a possibly "ragged" 2D array of
          // output thetas ordered by output index "n" and term index
          // "q_l" which is accessed in row-major order.
          auto coeff = evaluated_thetas ?
            (*evaluated_thetas)[output_counter + rb_theta_expansion->get_n_A_terms() + rb_theta_expansion->get_n_F_terms()] :
            rb_theta_expansion->eval_output_theta(n, q_l, mu);
 
          // Finally, accumulate the result in RB_outputs[n]
          RB_outputs[n] += coeff * dot_prod;
 
          // Go to next output
          output_counter++;
        }
    }
 
  if (evaluate_RB_error_bound) // Calculate the error bounds
    {
      // Evaluate the dual norm of the residual for RB_solution_vector
      Real epsilon_N = compute_residual_dual_norm(N, evaluated_thetas);
 
      // Get lower bound for coercivity constant
      const Real alpha_LB = get_stability_lower_bound();
      // alpha_LB needs to be positive to get a valid error bound
      libmesh_assert_greater ( alpha_LB, 0. );
 
      // Evaluate the (absolute) error bound
      Real abs_error_bound = epsilon_N / residual_scaling_denom(alpha_LB);
 
      // Now compute the output error bounds
      for (unsigned int n=0; n<rb_theta_expansion->get_n_outputs(); n++)
        RB_output_error_bounds[n] = abs_error_bound * this->eval_output_dual_norm(n, evaluated_thetas);
 
      return abs_error_bound;
    }
  else // Don't calculate the error bounds
    {
      // Just return -1. if we did not compute the error bound
      return -1.;
    }
}

References libMesh::RBEvaluation::RB_Aq_vector.

◆ rb_solve_again()

Real TransientRBEvaluation::rb_solve_again ( )

virtual

If a solve has already been performed, then we cached some data and we can perform a new solve much more rapidly (with the same parameters but a possibly different initial condition/rhs control).

Definition at line 359 of file transient_rb_evaluation.C.

{
  libmesh_assert(_rb_solve_data_cached);
 
  const unsigned int n_time_steps = get_n_time_steps();
  // Set system time level to 0
  set_time_step(0);
 
  // Resize/clear the solution vector
  const unsigned int N = RB_RHS_save.size();
  RB_solution.resize(N);
 
  // Load the initial condition into RB_solution
  if (N > 0)
    RB_solution = RB_initial_condition_all_N[N-1];
 
  // Resize/clear the old solution vector
  old_RB_solution.resize(N);
 
  // Initialize the RB rhs
  DenseVector<Number> RB_rhs(N);
  RB_rhs.zero();
 
  for (unsigned int time_level=1; time_level<=n_time_steps; time_level++)
    {
      set_time_step(time_level);
      old_RB_solution = RB_solution;
 
      // Compute RB_rhs, as *RB_lhs_matrix x old_RB_solution
      RB_RHS_matrix.vector_mult(RB_rhs, old_RB_solution);
 
      // Add forcing terms
      RB_rhs.add(get_control(time_level), RB_RHS_save);
 
      if (N > 0)
        RB_LHS_matrix.lu_solve(RB_rhs, RB_solution);
    }
 
  {
    // Just return -1. We did not compute the error bound
    return -1.;
  }
}

References _rb_solve_data_cached, libMesh::DenseVector< T >::add(), libMesh::RBTemporalDiscretization::get_control(), libMesh::RBTemporalDiscretization::get_n_time_steps(), libMesh::libmesh_assert(), libMesh::DenseMatrix< T >::lu_solve(), old_RB_solution, RB_initial_condition_all_N, RB_LHS_matrix, RB_RHS_matrix, RB_RHS_save, libMesh::RBEvaluation::RB_solution, libMesh::DenseVector< T >::resize(), libMesh::RBTemporalDiscretization::set_time_step(), libMesh::DenseVector< T >::size(), libMesh::DenseMatrix< T >::vector_mult(), and libMesh::DenseVector< T >::zero().

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

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

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

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

◆ read_in_basis_functions()

void libMesh::RBEvaluation::read_in_basis_functions	(	System &	sys,
		const std::string &	directory_name = `"offline_data"`,
		const bool	read_binary_basis_functions = `true`
	)

virtualinherited

Read in all the basis functions from file.

Parameters

sys	Used for file IO.
directory_name	Specifies which directory to write files to.
read_binary_basis_functions	Indicates whether to expect binary or ASCII data.

Definition at line 1065 of file rb_evaluation.C.

{
  LOG_SCOPE("read_in_basis_functions()", "RBEvaluation");
 
  read_in_vectors(sys,
                  basis_functions,
                  directory_name,
                  "bf",
                  read_binary_basis_functions);
}

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

Referenced by main().

◆ read_in_vectors()

void libMesh::RBEvaluation::read_in_vectors	(	System &	sys,
		std::vector< std::unique_ptr< NumericVector< Number > > > &	vectors,
		const std::string &	directory_name,
		const std::string &	data_name,
		const bool	read_binary_vectors
	)

staticinherited

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

We assume that the size of vectors indicates the number of vectors that need to be read in.

Definition at line 1078 of file rb_evaluation.C.

{
  std::vector<std::vector<std::unique_ptr<NumericVector<Number>>> *> vectors_vec;
  vectors_vec.push_back(&vectors);
 
  std::vector<std::string> directory_name_vec;
  directory_name_vec.push_back(directory_name);
 
  std::vector<std::string> data_name_vec;
  data_name_vec.push_back(data_name);
 
  read_in_vectors_from_multiple_files(sys,
                                      vectors_vec,
                                      directory_name_vec,
                                      data_name_vec,
                                      read_binary_vectors);
}

References libMesh::RBEvaluation::read_in_vectors_from_multiple_files().

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

◆ read_in_vectors_from_multiple_files()

void libMesh::RBEvaluation::read_in_vectors_from_multiple_files	(	System &	sys,
		std::vector< std::vector< std::unique_ptr< NumericVector< Number > > > * >	multiple_vectors,
		const std::vector< std::string > &	multiple_directory_names,
		const std::vector< std::string > &	multiple_data_names,
		const bool	read_binary_vectors
	)

staticinherited

Performs read_in_vectors for a list of directory names and data names.

Reading in vectors requires us to renumber the dofs in a partition-independent way. This function only renumbers the dofs once at the start (and reverts it at the end), which can save a lot of work compared to renumbering on every read.

Definition at line 1100 of file rb_evaluation.C.

{
  LOG_SCOPE("read_in_vectors_from_multiple_files()", "RBEvaluation");
 
  std::size_t n_files = multiple_vectors.size();
  std::size_t n_directories = multiple_directory_names.size();
  libmesh_assert((n_files == n_directories) && (n_files == multiple_data_names.size()));
 
  if (n_files == 0)
    return;
 
  // Make sure processors are synced up before we begin
  sys.comm().barrier();
 
  std::ostringstream file_name;
  const std::string basis_function_suffix = (read_binary_vectors ? ".xdr" : ".dat");
 
  // Following EquationSystemsIO::read, we use a temporary numbering (node major)
  // before writing out the data. For the sake of efficiency, we do this once for
  // all the vectors that we read in.
  MeshTools::Private::globally_renumber_nodes_and_elements(sys.get_mesh());
 
  for (std::size_t data_index=0; data_index<n_directories; data_index++)
    {
      std::vector<std::unique_ptr<NumericVector<Number>>> & vectors = *multiple_vectors[data_index];
 
      // Allocate storage for each vector
      for (auto & vec : vectors)
        {
          // vectors should all be nullptr, otherwise we get a memory leak when
          // we create the new vectors in RBEvaluation::read_in_vectors.
          libmesh_error_msg_if(vec, "Non-nullptr vector passed to read_in_vectors_from_multiple_files");
 
          vec = NumericVector<Number>::build(sys.comm());
 
          vec->init (sys.n_dofs(),
                     sys.n_local_dofs(),
                     false,
                     PARALLEL);
        }
 
      file_name.str("");
      file_name << multiple_directory_names[data_index]
                << "/" << multiple_data_names[data_index]
                << "_data" << basis_function_suffix;
 
      // On processor zero check to be sure the file exists
      if (sys.comm().rank() == 0)
        {
          struct stat stat_info;
          int stat_result = stat(file_name.str().c_str(), &stat_info);
 
          libmesh_error_msg_if(stat_result != 0, "File does not exist: " << file_name.str());
        }
 
      assert_file_exists(file_name.str());
      Xdr vector_data(file_name.str(),
                      read_binary_vectors ? DECODE : READ);
 
      // Read the header data. This block of code is based on EquationSystems::_read_impl.
      {
        std::string version;
        vector_data.data(version);
 
        const std::string libMesh_label = "libMesh-";
        std::string::size_type lm_pos = version.find(libMesh_label);
        libmesh_error_msg_if(lm_pos == std::string::npos, "version info missing in Xdr header");
 
        std::istringstream iss(version.substr(lm_pos + libMesh_label.size()));
        int ver_major = 0, ver_minor = 0, ver_patch = 0;
        char dot;
        iss >> ver_major >> dot >> ver_minor >> dot >> ver_patch;
        vector_data.set_version(LIBMESH_VERSION_ID(ver_major, ver_minor, ver_patch));
 
        // Actually read the header data. When we do this, set read_header=false
        // so that we do not reinit sys, since we assume that it has already been
        // set up properly (e.g. the appropriate variables have already been added).
        sys.read_header(vector_data, version, /*read_header=*/false, /*read_additional_data=*/false);
      }
 
      // Comply with the System::read_serialized_vectors() interface which uses dumb pointers.
      std::vector<NumericVector<Number> *> vec_in;
      for (auto & vec : vectors)
        vec_in.push_back(vec.get());
 
      sys.read_serialized_vectors (vector_data, vec_in);
    }
 
  // Undo the temporary renumbering
  sys.get_mesh().fix_broken_node_and_element_numbering();
}

References libMesh::RBEvaluation::assert_file_exists(), libMesh::Parallel::Communicator::barrier(), libMesh::NumericVector< T >::build(), libMesh::ParallelObject::comm(), libMesh::Xdr::data(), libMesh::DECODE, libMesh::MeshBase::fix_broken_node_and_element_numbering(), libMesh::System::get_mesh(), libMesh::MeshTools::Private::globally_renumber_nodes_and_elements(), libMesh::libmesh_assert(), libMesh::System::n_dofs(), libMesh::System::n_local_dofs(), libMesh::PARALLEL, libMesh::Parallel::Communicator::rank(), libMesh::READ, libMesh::System::read_header(), and libMesh::System::read_serialized_vectors().

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

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

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

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

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

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

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

◆ residual_scaling_denom()

Real libMesh::RBEvaluation::residual_scaling_denom ( Real alpha_LB )

virtualinherited

Specifies the residual scaling on the denominator to be used in the a posteriori error bound.

Override in subclass in order to obtain the desired error bound.

Definition at line 467 of file rb_evaluation.C.

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

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

◆ residual_scaling_numer()

Real TransientRBEvaluation::residual_scaling_numer ( Real alpha_LB )

virtual

Specifies the residual scaling on the numerator to be used in the a posteriori error bound.

Override in subclass in order to obtain the desired error bound.

Definition at line 412 of file transient_rb_evaluation.C.

{
  return get_delta_t();
}

References libMesh::RBTemporalDiscretization::get_delta_t().

Referenced by rb_solve().

◆ resize_data_structures()

void TransientRBEvaluation::resize_data_structures	(	const unsigned int	Nmax,
		bool	resize_error_bound_data = `true`
	)

overridevirtual

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

Optionally resize the data structures required for the error bound. Overridden to resize data relevant in the time-dependent case.

Reimplemented from libMesh::RBEvaluation.

Definition at line 65 of file transient_rb_evaluation.C.

{
  LOG_SCOPE("resize_data_structures()", "TransientRBEvaluation");
 
  Parent::resize_data_structures(Nmax, resize_error_bound_data);
 
  RB_L2_matrix.resize(Nmax,Nmax);
  RB_LHS_matrix.resize(Nmax,Nmax);
  RB_RHS_matrix.resize(Nmax,Nmax);
  RB_RHS_save.resize(Nmax);
 
  TransientRBThetaExpansion & trans_theta_expansion =
    cast_ref<TransientRBThetaExpansion &>(get_rb_theta_expansion());
  const unsigned int Q_m = trans_theta_expansion.get_n_M_terms();
  const unsigned int Q_a = trans_theta_expansion.get_n_A_terms();
  const unsigned int Q_f = trans_theta_expansion.get_n_F_terms();
 
  // Allocate dense matrices for RB solves
  RB_M_q_vector.resize(Q_m);
  for (unsigned int q=0; q<Q_m; q++)
    {
      // Initialize the memory for the RB matrices
      RB_M_q_vector[q].resize(Nmax,Nmax);
    }
 
  // Initialize the initial condition storage
  RB_initial_condition_all_N.resize(Nmax);
  for (auto i : make_range(RB_initial_condition_all_N.size()))
    {
      // The i^th row holds a vector of length i+1
      RB_initial_condition_all_N[i].resize(i+1);
    }
 
  initial_L2_error_all_N.resize(Nmax, 0.);
 
 
  if (resize_error_bound_data)
    {
      // Initialize vectors for the norms of the representors
      Fq_Mq_representor_innerprods.resize(Q_f);
      for (unsigned int i=0; i<Q_f; i++)
        {
          Fq_Mq_representor_innerprods[i].resize(Q_m);
          for (unsigned int j=0; j<Q_m; j++)
            {
              Fq_Mq_representor_innerprods[i][j].resize(Nmax, 0.);
            }
        }
 
      unsigned int Q_m_hat = Q_m*(Q_m+1)/2;
      Mq_Mq_representor_innerprods.resize(Q_m_hat);
      for (unsigned int i=0; i<Q_m_hat; i++)
        {
          Mq_Mq_representor_innerprods[i].resize(Nmax);
          for (unsigned int j=0; j<Nmax; j++)
            {
              Mq_Mq_representor_innerprods[i][j].resize(Nmax, 0.);
            }
        }
 
      Aq_Mq_representor_innerprods.resize(Q_a);
      for (unsigned int i=0; i<Q_a; i++)
        {
          Aq_Mq_representor_innerprods[i].resize(Q_m);
          for (unsigned int j=0; j<Q_m; j++)
            {
              Aq_Mq_representor_innerprods[i][j].resize(Nmax);
              for (unsigned int k=0; k<Nmax; k++)
                {
                  Aq_Mq_representor_innerprods[i][j][k].resize(Nmax, 0.);
                }
            }
        }
 
      // Resize M_q_representor
      // This is cleared in the call to clear_riesz_representors
      // in Parent::resize_RB_data, so just resize here
      M_q_representor.resize(Q_m);
      for (unsigned int q_m=0; q_m<Q_m; q_m++)
        {
          M_q_representor[q_m].resize(Nmax);
        }
    }
}

References Aq_Mq_representor_innerprods, Fq_Mq_representor_innerprods, libMesh::RBThetaExpansion::get_n_A_terms(), libMesh::RBThetaExpansion::get_n_F_terms(), libMesh::TransientRBThetaExpansion::get_n_M_terms(), libMesh::RBEvaluation::get_rb_theta_expansion(), initial_L2_error_all_N, M_q_representor, libMesh::make_range(), Mq_Mq_representor_innerprods, RB_initial_condition_all_N, RB_L2_matrix, RB_LHS_matrix, RB_M_q_vector, RB_RHS_matrix, RB_RHS_save, libMesh::DenseVector< T >::resize(), libMesh::DenseMatrix< T >::resize(), and libMesh::RBEvaluation::resize_data_structures().

◆ set_control()

void libMesh::RBTemporalDiscretization::set_control ( const std::vector< Real > & control )

inherited

Definition at line 85 of file rb_temporal_discretization.C.

{
  libmesh_assert_less_equal(control.size(),_n_time_steps+1);
  _control = control;
  // If the input vector is smaller than the number of time steps (+1), we complete it with zeros
  _control.resize(_n_time_steps+1);
}

References libMesh::RBTemporalDiscretization::_control, and libMesh::RBTemporalDiscretization::_n_time_steps.

Referenced by libMesh::RBTemporalDiscretization::pull_temporal_discretization_data().

◆ set_delta_t()

void libMesh::RBTemporalDiscretization::set_delta_t ( const Real delta_t_in )

inherited

Definition at line 41 of file rb_temporal_discretization.C.

{
  _delta_t = delta_t_in;
}

References libMesh::RBTemporalDiscretization::_delta_t.

Referenced by legacy_read_offline_data_from_files(), libMesh::RBDataDeserialization::load_transient_rb_evaluation_data(), libMesh::RBTemporalDiscretization::process_temporal_parameters_file(), and libMesh::RBTemporalDiscretization::pull_temporal_discretization_data().

◆ set_euler_theta()

void libMesh::RBTemporalDiscretization::set_euler_theta ( const Real euler_theta_in )

inherited

Definition at line 51 of file rb_temporal_discretization.C.

{
  libmesh_assert((0. <= euler_theta_in ) && (euler_theta_in <= 1.));
  _euler_theta = euler_theta_in;
}

References libMesh::RBTemporalDiscretization::_euler_theta, and libMesh::libmesh_assert().

Referenced by legacy_read_offline_data_from_files(), libMesh::RBDataDeserialization::load_transient_rb_evaluation_data(), libMesh::RBTemporalDiscretization::process_temporal_parameters_file(), and libMesh::RBTemporalDiscretization::pull_temporal_discretization_data().

◆ set_n_basis_functions()

void libMesh::RBEvaluation::set_n_basis_functions ( unsigned int n_bfs )

virtualinherited

Set the number of basis functions.

Useful when reading in stored data.

Definition at line 75 of file rb_evaluation.C.

{
  basis_functions.resize(n_bfs);
}

References libMesh::RBEvaluation::basis_functions.

Referenced by libMesh::RBEvaluation::clear(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), and libMesh::RBDataDeserialization::load_rb_evaluation_data().

◆ set_n_time_steps()

void libMesh::RBTemporalDiscretization::set_n_time_steps ( const unsigned int K )

inherited

Definition at line 73 of file rb_temporal_discretization.C.

{
  _n_time_steps = K;
  _control.assign(_n_time_steps+1,1.0);
}

References libMesh::RBTemporalDiscretization::_control, and libMesh::RBTemporalDiscretization::_n_time_steps.

Referenced by legacy_read_offline_data_from_files(), libMesh::RBDataDeserialization::load_transient_rb_evaluation_data(), libMesh::RBTemporalDiscretization::process_temporal_parameters_file(), and libMesh::RBTemporalDiscretization::pull_temporal_discretization_data().

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

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

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

◆ set_rb_theta_expansion()

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

inherited

Set the RBThetaExpansion object.

Definition at line 80 of file rb_evaluation.C.

{
  rb_theta_expansion = &rb_theta_expansion_in;
}

References libMesh::RBEvaluation::rb_theta_expansion.

Referenced by ElasticityRBEvaluation::ElasticityRBEvaluation(), SimpleRBEvaluation::SimpleRBEvaluation(), and SimpleRBEvaluation::SimpleRBEvaluation().

◆ set_time_step()

void libMesh::RBTemporalDiscretization::set_time_step ( const unsigned int k )

inherited

Definition at line 62 of file rb_temporal_discretization.C.

{
  libmesh_assert_less_equal (k, get_n_time_steps());
  this->_current_time_step = k;
}

References libMesh::RBTemporalDiscretization::_current_time_step, and libMesh::RBTemporalDiscretization::get_n_time_steps().

Referenced by legacy_read_offline_data_from_files(), libMesh::RBDataDeserialization::load_transient_rb_evaluation_data(), libMesh::RBTemporalDiscretization::process_temporal_parameters_file(), libMesh::RBTemporalDiscretization::pull_temporal_discretization_data(), rb_solve(), rb_solve_again(), and libMesh::TransientRBConstruction::truth_solve().

◆ uncached_compute_residual_dual_norm()

Real TransientRBEvaluation::uncached_compute_residual_dual_norm ( const unsigned int N )

virtual

Compute the dual norm of the residual for the solution saved in RB_solution.

This function does not used the cached data and therefore also works when the parameter changes as a function of time.

Definition at line 587 of file transient_rb_evaluation.C.

{
  LOG_SCOPE("uncached_compute_residual_dual_norm()", "TransientRBEvaluation");
 
  // Use the stored representor inner product values
  // to evaluate the residual norm
 
  const RBParameters & mu = get_parameters();
 
  TransientRBThetaExpansion & trans_theta_expansion =
    cast_ref<TransientRBThetaExpansion &>(get_rb_theta_expansion());
  const unsigned int Q_m = trans_theta_expansion.get_n_M_terms();
  const unsigned int Q_a = trans_theta_expansion.get_n_A_terms();
  const unsigned int Q_f = trans_theta_expansion.get_n_F_terms();
 
  const Real dt          = get_delta_t();
  const Real euler_theta = get_euler_theta();
 
  std::vector<Number> RB_u_euler_theta(N);
  std::vector<Number> mass_coeffs(N);
  for (unsigned int i=0; i<N; i++)
    {
      RB_u_euler_theta[i]  = euler_theta*RB_solution(i) +
        (1.-euler_theta)*old_RB_solution(i);
      mass_coeffs[i] = -(RB_solution(i) - old_RB_solution(i))/dt;
    }
 
  Number residual_norm_sq = 0.;
 
  unsigned int q=0;
  for (unsigned int q_f1=0; q_f1<Q_f; q_f1++)
    {
      Number cached_theta_q_f1 = trans_theta_expansion.eval_F_theta(q_f1,mu);
      for (unsigned int q_f2=q_f1; q_f2<Q_f; q_f2++)
        {
          Real delta = (q_f1==q_f2) ? 1. : 2.;
          residual_norm_sq += delta*cached_theta_q_f1*trans_theta_expansion.eval_F_theta(q_f2,mu) * Fq_representor_innerprods[q];
 
          q++;
        }
    }
 
  for (unsigned int q_f=0; q_f<Q_f; q_f++)
    {
      Number cached_theta_q_f = trans_theta_expansion.eval_F_theta(q_f,mu);
      for (unsigned int q_a=0; q_a<Q_a; q_a++)
        {
          Number cached_theta_q_a = trans_theta_expansion.eval_A_theta(q_a,mu);
          for (unsigned int i=0; i<N; i++)
            {
              residual_norm_sq += 2.*RB_u_euler_theta[i]*cached_theta_q_f*cached_theta_q_a*
                Fq_Aq_representor_innerprods[q_f][q_a][i];
            }
        }
    }
 
  q=0;
  for (unsigned int q_a1=0; q_a1<Q_a; q_a1++)
    {
      Number cached_theta_q_a1 = trans_theta_expansion.eval_A_theta(q_a1,mu);
      for (unsigned int q_a2=q_a1; q_a2<Q_a; q_a2++)
        {
          Number cached_theta_q_a2 = trans_theta_expansion.eval_A_theta(q_a2,mu);
          Real delta = (q_a1==q_a2) ? 1. : 2.;
 
          for (unsigned int i=0; i<N; i++)
            {
              for (unsigned int j=0; j<N; j++)
                {
                  residual_norm_sq += delta*RB_u_euler_theta[i]*RB_u_euler_theta[j]*
                    cached_theta_q_a1*cached_theta_q_a2*
                    Aq_Aq_representor_innerprods[q][i][j];
                }
            }
          q++;
        }
    }
 
  // Now add the terms due to the time-derivative
  q=0;
  for (unsigned int q_m1=0; q_m1<Q_m; q_m1++)
    {
      Number cached_theta_q_m1 = trans_theta_expansion.eval_M_theta(q_m1,mu);
      for (unsigned int q_m2=q_m1; q_m2<Q_m; q_m2++)
        {
          Number cached_theta_q_m2 = trans_theta_expansion.eval_M_theta(q_m2,mu);
          Real delta = (q_m1==q_m2) ? 1. : 2.;
 
          for (unsigned int i=0; i<N; i++)
            {
              for (unsigned int j=0; j<N; j++)
                {
                  residual_norm_sq += delta*mass_coeffs[i]*mass_coeffs[j]*
                    cached_theta_q_m1*cached_theta_q_m2*
                    Mq_Mq_representor_innerprods[q][i][j];
                }
            }
          q++;
        }
    }
 
  for (unsigned int q_f=0; q_f<Q_f; q_f++)
    {
      Number cached_theta_q_f = trans_theta_expansion.eval_F_theta(q_f,mu);
      for (unsigned int q_m=0; q_m<Q_m; q_m++)
        {
          Number cached_theta_q_m = trans_theta_expansion.eval_M_theta(q_m,mu);
          for (unsigned int i=0; i<N; i++)
            {
              residual_norm_sq += 2.*mass_coeffs[i]*cached_theta_q_f * cached_theta_q_m * Fq_Mq_representor_innerprods[q_f][q_m][i];
            }
        }
    }
 
  for (unsigned int q_a=0; q_a<Q_a; q_a++)
    {
      Number cached_theta_q_a = trans_theta_expansion.eval_A_theta(q_a,mu);
 
      for (unsigned int q_m=0; q_m<Q_m; q_m++)
        {
          Number cached_theta_q_m = trans_theta_expansion.eval_M_theta(q_m,mu);
 
          for (unsigned int i=0; i<N; i++)
            {
              for (unsigned int j=0; j<N; j++)
                {
                  residual_norm_sq += 2.*RB_u_euler_theta[i]*mass_coeffs[j]*
                    cached_theta_q_a*cached_theta_q_m*
                    Aq_Mq_representor_innerprods[q_a][q_m][i][j];
                }
            }
        }
    }
 
  if (libmesh_real(residual_norm_sq) < 0)
    {
      libMesh::out << "Warning: Square of residual norm is negative "
                   << "in TransientRBEvaluation::compute_residual_dual_norm()" << std::endl;
 
      // Sometimes this is negative due to rounding error,
      // but error is on the order of 1.e-10, so shouldn't
      // affect result
      residual_norm_sq = std::abs(residual_norm_sq);
    }
 
  //   libMesh::out << "slow residual_sq = " << slow_residual_norm_sq
  //                << ", fast residual_sq = " << residual_norm_sq << std::endl;
 
  return libmesh_real(std::sqrt( residual_norm_sq ));
}

References libMesh::RBEvaluation::Aq_Aq_representor_innerprods, Aq_Mq_representor_innerprods, libMesh::RBThetaExpansion::eval_A_theta(), libMesh::RBThetaExpansion::eval_F_theta(), libMesh::TransientRBThetaExpansion::eval_M_theta(), libMesh::RBEvaluation::Fq_Aq_representor_innerprods, Fq_Mq_representor_innerprods, libMesh::RBEvaluation::Fq_representor_innerprods, libMesh::RBTemporalDiscretization::get_delta_t(), libMesh::RBTemporalDiscretization::get_euler_theta(), libMesh::RBThetaExpansion::get_n_A_terms(), libMesh::RBThetaExpansion::get_n_F_terms(), libMesh::TransientRBThetaExpansion::get_n_M_terms(), libMesh::RBParametrized::get_parameters(), libMesh::RBEvaluation::get_rb_theta_expansion(), libMesh::libmesh_real(), Mq_Mq_representor_innerprods, old_RB_solution, libMesh::out, libMesh::RBEvaluation::RB_solution, and libMesh::Real.

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

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

References libMesh::ENCODE, 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_out_basis_functions()

void libMesh::RBEvaluation::write_out_basis_functions	(	System &	sys,
		const std::string &	directory_name = `"offline_data"`,
		const bool	write_binary_basis_functions = `true`
	)

virtualinherited

Write out all the basis functions to file.

sys is used for file IO directory_name specifies which directory to write files to read_binary_basis_functions indicates whether to expect binary or ASCII data

Definition at line 982 of file rb_evaluation.C.

{
  LOG_SCOPE("write_out_basis_functions()", "RBEvaluation");
 
  std::vector<NumericVector<Number>*> basis_functions_ptrs;
  for (std::size_t i=0; i<basis_functions.size(); i++)
  {
    basis_functions_ptrs.push_back(basis_functions[i].get());
  }
 
  write_out_vectors(sys,
                    basis_functions_ptrs,
                    directory_name,
                    "bf",
                    write_binary_basis_functions);
}

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

Referenced by main().

◆ write_out_vectors()

void libMesh::RBEvaluation::write_out_vectors	(	System &	sys,
		std::vector< NumericVector< Number > * > &	vectors,
		const std::string &	directory_name = `"offline_data"`,
		const std::string &	data_name = `"bf"`,
		const bool	write_binary_basis_functions = `true`
	)

staticinherited

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

Definition at line 1001 of file rb_evaluation.C.

{
  LOG_SCOPE("write_out_vectors()", "RBEvaluation");
 
  if (sys.comm().rank() == 0)
    {
      // Make a directory to store all the data files
      Utility::mkdir(directory_name.c_str());
    }
 
  // Make sure processors are synced up before we begin
  sys.comm().barrier();
 
  std::ostringstream file_name;
  const std::string basis_function_suffix = (write_binary_vectors ? ".xdr" : ".dat");
 
  file_name << directory_name << "/" << data_name << "_data" << basis_function_suffix;
  Xdr bf_data(file_name.str(),
              write_binary_vectors ? ENCODE : WRITE);
 
  // Following EquationSystems::write(), we should only write the header information
  // if we're proc 0
  if (sys.comm().rank() == 0)
    {
      std::string version("libMesh-" + libMesh::get_io_compatibility_version());
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
      version += " with infinite elements";
#endif
      bf_data.data(version ,"# File Format Identifier");
 
      sys.write_header(bf_data, /*(unused arg)*/ version, /*write_additional_data=*/false);
    }
 
  // Following EquationSystemsIO::write, we use a temporary numbering (node major)
  // before writing out the data
  MeshTools::Private::globally_renumber_nodes_and_elements(sys.get_mesh());
 
  // Write all vectors at once.
  {
    // Note the API wants pointers to constant vectors, hence this...
    std::vector<const NumericVector<Number> *> bf_out;
    for (const auto & vec : vectors)
      bf_out.push_back(vec);
 
    // for (auto & val : vectors)
    //   bf_out.push_back(val);
    sys.write_serialized_vectors (bf_data, bf_out);
  }
 
 
  // set the current version
  bf_data.set_version(LIBMESH_VERSION_ID(LIBMESH_MAJOR_VERSION,
                                         LIBMESH_MINOR_VERSION,
                                         LIBMESH_MICRO_VERSION));
 
 
  // Undo the temporary renumbering
  sys.get_mesh().fix_broken_node_and_element_numbering();
}

References libMesh::Parallel::Communicator::barrier(), libMesh::ParallelObject::comm(), libMesh::ENCODE, libMesh::MeshBase::fix_broken_node_and_element_numbering(), libMesh::get_io_compatibility_version(), libMesh::System::get_mesh(), libMesh::MeshTools::Private::globally_renumber_nodes_and_elements(), libMesh::Utility::mkdir(), libMesh::Parallel::Communicator::rank(), libMesh::WRITE, libMesh::System::write_header(), and libMesh::System::write_serialized_vectors().

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

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

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

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

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

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

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

Member Data Documentation

◆ _communicator

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

protectedinherited

Definition at line 120 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::StaticCondensation::close(), libMesh::ParallelObject::comm(), libMesh::CondensedEigenSystem::initialize_condensed_matrices(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), libMesh::ParallelObject::processor_id(), libMesh::BoundaryInfo::regenerate_id_sets(), libMesh::StaticCondensationDofMap::reinit(), and libMesh::BoundaryInfo::synchronize_global_id_set().

◆ _control

std::vector<Real> libMesh::RBTemporalDiscretization::_control

privateinherited

The RHS control (scalar function of time).

A function h(t) that is used in the RHS as h(t)*f(x, \( \mu \)). See Martin Grepl's thesis

Definition at line 130 of file rb_temporal_discretization.h.

Referenced by libMesh::RBTemporalDiscretization::get_control(), libMesh::RBTemporalDiscretization::pull_temporal_discretization_data(), libMesh::RBTemporalDiscretization::set_control(), and libMesh::RBTemporalDiscretization::set_n_time_steps().

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

◆ _current_time_step

unsigned int libMesh::RBTemporalDiscretization::_current_time_step

privateinherited

The current time-step.

Definition at line 118 of file rb_temporal_discretization.h.

Referenced by libMesh::RBTemporalDiscretization::get_time_step(), and libMesh::RBTemporalDiscretization::set_time_step().

◆ _delta_t

Real libMesh::RBTemporalDiscretization::_delta_t

privateinherited

The time-step size.

Definition at line 104 of file rb_temporal_discretization.h.

Referenced by libMesh::RBTemporalDiscretization::get_delta_t(), and libMesh::RBTemporalDiscretization::set_delta_t().

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

◆ _euler_theta

Real libMesh::RBTemporalDiscretization::_euler_theta

privateinherited

The parameter that determines the generalized Euler scheme discretization that we employ.

euler_theta = 0 —> Forward Euler euler_theta = 0.5 —> Crank-Nicolson euler_theta = 1 —> Backward Euler

Definition at line 113 of file rb_temporal_discretization.h.

Referenced by libMesh::RBTemporalDiscretization::get_euler_theta(), and libMesh::RBTemporalDiscretization::set_euler_theta().

◆ _mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 of file reference_counter.h.

◆ _n_objects

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

staticprotectedinherited

The number of objects.

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

Definition at line 132 of file reference_counter.h.

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

◆ _n_time_steps

unsigned int libMesh::RBTemporalDiscretization::_n_time_steps

privateinherited

The number of time-steps.

Definition at line 123 of file rb_temporal_discretization.h.

Referenced by libMesh::RBTemporalDiscretization::get_n_time_steps(), libMesh::RBTemporalDiscretization::set_control(), and libMesh::RBTemporalDiscretization::set_n_time_steps().

◆ _rb_solve_data_cached

bool libMesh::TransientRBEvaluation::_rb_solve_data_cached

Check that the data has been cached in case of using rb_solve_again.

Definition at line 258 of file transient_rb_evaluation.h.

Referenced by rb_solve(), and rb_solve_again().

◆ Aq_Aq_representor_innerprods

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

inherited

Definition at line 324 of file rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_rb_evaluation_data_to_builder(), cache_online_residual_terms(), libMesh::RBEvaluation::compute_residual_dual_norm(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_rb_evaluation_data(), uncached_compute_residual_dual_norm(), and libMesh::RBConstruction::update_residual_terms().

◆ Aq_Mq_representor_innerprods

std::vector<std::vector<std::vector<std::vector<Number> > > > libMesh::TransientRBEvaluation::Aq_Mq_representor_innerprods

Definition at line 235 of file transient_rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_transient_rb_evaluation_data_to_builder(), cache_online_residual_terms(), legacy_read_offline_data_from_files(), legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_transient_rb_evaluation_data(), resize_data_structures(), uncached_compute_residual_dual_norm(), and libMesh::TransientRBConstruction::update_residual_terms().

◆ Aq_representor

std::vector<std::vector<std::unique_ptr<NumericVector<Number> > > > libMesh::RBEvaluation::Aq_representor

inherited

Vector storing the residual representors associated with the left-hand side.

These are basis dependent and hence stored here, whereas the Fq_representors are stored in RBSystem.

Definition at line 340 of file rb_evaluation.h.

Referenced by libMesh::RBEvaluation::clear_riesz_representors(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), and libMesh::RBConstruction::write_riesz_representors_to_files().

◆ basis_functions

std::vector<std::unique_ptr<NumericVector<Number> > > libMesh::RBEvaluation::basis_functions

inherited

The libMesh vectors storing the finite element coefficients of the RB basis functions.

Definition at line 265 of file rb_evaluation.h.

Referenced by libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::RBEvaluation::clear(), libMesh::RBConstruction::enrich_RB_space(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::RBEvaluation::get_basis_function(), libMesh::RBEvaluation::get_basis_function(), libMesh::RBEvaluation::get_n_basis_functions(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::RBEvaluation::read_in_basis_functions(), libMesh::RBEvaluation::set_n_basis_functions(), libMesh::RBConstruction::train_reduced_basis_with_POD(), and libMesh::RBEvaluation::write_out_basis_functions().

◆ cached_Aq_Aq_matrix

DenseMatrix<Number> libMesh::TransientRBEvaluation::cached_Aq_Aq_matrix

Definition at line 244 of file transient_rb_evaluation.h.

Referenced by cache_online_residual_terms(), and compute_residual_dual_norm().

◆ cached_Aq_Mq_matrix

DenseMatrix<Number> libMesh::TransientRBEvaluation::cached_Aq_Mq_matrix

Definition at line 246 of file transient_rb_evaluation.h.

Referenced by cache_online_residual_terms(), and compute_residual_dual_norm().

◆ cached_Fq_Aq_vector

DenseVector<Number> libMesh::TransientRBEvaluation::cached_Fq_Aq_vector

Definition at line 243 of file transient_rb_evaluation.h.

Referenced by cache_online_residual_terms(), and compute_residual_dual_norm().

◆ cached_Fq_Mq_vector

DenseVector<Number> libMesh::TransientRBEvaluation::cached_Fq_Mq_vector

Definition at line 245 of file transient_rb_evaluation.h.

Referenced by cache_online_residual_terms(), and compute_residual_dual_norm().

◆ cached_Fq_term

Number libMesh::TransientRBEvaluation::cached_Fq_term

Cached residual terms.

These can be used to accelerate residual calculations when we have an LTI system.

Definition at line 242 of file transient_rb_evaluation.h.

Referenced by cache_online_residual_terms(), and compute_residual_dual_norm().

◆ cached_Mq_Mq_matrix

DenseMatrix<Number> libMesh::TransientRBEvaluation::cached_Mq_Mq_matrix

Definition at line 247 of file transient_rb_evaluation.h.

Referenced by cache_online_residual_terms(), and compute_residual_dual_norm().

◆ compute_RB_inner_product

bool libMesh::RBEvaluation::compute_RB_inner_product

inherited

Boolean flag to indicate whether we compute the RB_inner_product_matrix.

Definition at line 351 of file rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_rb_evaluation_data_to_builder(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_rb_evaluation_data(), and TransientRBEvaluation().

◆ error_bound_all_k

std::vector<Real > libMesh::TransientRBEvaluation::error_bound_all_k

The error bound data for all time-levels from the most recent rb_solve.

Definition at line 215 of file transient_rb_evaluation.h.

Referenced by rb_solve().

◆ evaluate_RB_error_bound

bool libMesh::RBEvaluation::evaluate_RB_error_bound

inherited

Boolean to indicate whether we evaluate a posteriori error bounds when rb_solve is called.

Definition at line 346 of file rb_evaluation.h.

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

◆ Fq_Aq_representor_innerprods

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

inherited

Vectors storing the residual representor inner products to be used in computing the residuals online.

We store the Aq-dependent representor inner products because they depend on a reduced basis space. The basis independent representors are stored in RBSystem.

Definition at line 323 of file rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_rb_evaluation_data_to_builder(), cache_online_residual_terms(), libMesh::RBEvaluation::compute_residual_dual_norm(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_rb_evaluation_data(), uncached_compute_residual_dual_norm(), and libMesh::RBConstruction::update_residual_terms().

◆ Fq_Mq_representor_innerprods

std::vector<std::vector<std::vector<Number> > > libMesh::TransientRBEvaluation::Fq_Mq_representor_innerprods

Vectors storing the residual representor inner products to be used in computing the residuals online.

Definition at line 233 of file transient_rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_transient_rb_evaluation_data_to_builder(), cache_online_residual_terms(), legacy_read_offline_data_from_files(), legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_transient_rb_evaluation_data(), resize_data_structures(), uncached_compute_residual_dual_norm(), and libMesh::TransientRBConstruction::update_residual_terms().

◆ Fq_representor_innerprods

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

inherited

Vectors storing the residual representor inner products to be used in computing the residuals online.

These values are independent of a basis, hence they can be copied over directly from an RBSystem.

Definition at line 314 of file rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_rb_evaluation_data_to_builder(), cache_online_residual_terms(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBEvaluation::compute_residual_dual_norm(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_rb_evaluation_data(), and uncached_compute_residual_dual_norm().

◆ greedy_param_list

std::vector<RBParameters> libMesh::RBEvaluation::greedy_param_list

inherited

The list of parameters selected by the Greedy algorithm in generating the Reduced Basis associated with this RBEvaluation object.

Definition at line 271 of file rb_evaluation.h.

Referenced by libMesh::RBEvaluation::clear(), libMesh::RBConstruction::get_greedy_parameter(), libMesh::RBConstruction::greedy_termination_test(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBConstruction::train_reduced_basis_with_greedy(), and libMesh::RBConstruction::update_greedy_param_list().

◆ initial_L2_error_all_N

std::vector<Real> libMesh::TransientRBEvaluation::initial_L2_error_all_N

Vector storing initial L2 error for all 1 <= N <= RB_size.

Definition at line 221 of file transient_rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_transient_rb_evaluation_data_to_builder(), legacy_read_offline_data_from_files(), legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_transient_rb_evaluation_data(), rb_solve(), resize_data_structures(), and libMesh::TransientRBConstruction::update_RB_initial_condition_all_N().

◆ M_q_representor

std::vector<std::vector<std::unique_ptr<NumericVector<Number> > > > libMesh::TransientRBEvaluation::M_q_representor

Vector storing the mass matrix representors.

These are basis dependent and hence stored here.

Definition at line 253 of file transient_rb_evaluation.h.

Referenced by clear_riesz_representors(), resize_data_structures(), libMesh::TransientRBConstruction::update_residual_terms(), and libMesh::TransientRBConstruction::write_riesz_representors_to_files().

◆ Mq_Mq_representor_innerprods

std::vector<std::vector<std::vector<Number> > > libMesh::TransientRBEvaluation::Mq_Mq_representor_innerprods

Definition at line 234 of file transient_rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_transient_rb_evaluation_data_to_builder(), cache_online_residual_terms(), legacy_read_offline_data_from_files(), legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_transient_rb_evaluation_data(), resize_data_structures(), uncached_compute_residual_dual_norm(), and libMesh::TransientRBConstruction::update_residual_terms().

◆ old_RB_solution

DenseVector<Number> libMesh::TransientRBEvaluation::old_RB_solution

The RB solution at the previous time-level.

Definition at line 204 of file transient_rb_evaluation.h.

Referenced by compute_residual_dual_norm(), rb_solve(), rb_solve_again(), and uncached_compute_residual_dual_norm().

◆ output_dual_innerprods

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

inherited

The vector storing the dual norm inner product terms for each output.

These values are independent of a basis, hence they can be copied over directly from an RBSystem.

Definition at line 332 of file rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_rb_evaluation_data_to_builder(), libMesh::RBConstruction::compute_output_dual_innerprods(), libMesh::RBEvaluation::eval_output_dual_norm(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), and libMesh::RBDataDeserialization::load_rb_evaluation_data().

◆ parameters

RBParameters libMesh::RBParametrized::parameters

privateinherited

Vector storing the current parameters.

Definition at line 239 of file rb_parametrized.h.

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

◆ parameters_initialized

bool libMesh::RBParametrized::parameters_initialized

privateinherited

Flag indicating whether the parameters have been initialized.

Definition at line 234 of file rb_parametrized.h.

◆ parameters_max

RBParameters libMesh::RBParametrized::parameters_max

privateinherited

Definition at line 245 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(), and libMesh::RBParametrized::initialize_parameters().

◆ parameters_min

RBParameters libMesh::RBParametrized::parameters_min

privateinherited

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

Definition at line 244 of file rb_parametrized.h.

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

◆ RB_Aq_vector

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

inherited

Dense matrices for the RB computations.

Definition at line 284 of file rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_rb_evaluation_data_to_builder(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_rb_evaluation_data(), rb_solve(), libMesh::RBEvaluation::rb_solve(), rb_solve(), and libMesh::RBConstruction::update_RB_system_matrices().

◆ RB_Fq_vector

std::vector<DenseVector<Number> > libMesh::RBEvaluation::RB_Fq_vector

inherited

Dense vector for the RHS.

Definition at line 289 of file rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_rb_evaluation_data_to_builder(), compute_residual_dual_norm(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_rb_evaluation_data(), rb_solve(), libMesh::RBEvaluation::rb_solve(), and libMesh::RBConstruction::update_RB_system_matrices().

◆ RB_initial_condition_all_N

std::vector<DenseVector<Number> > libMesh::TransientRBEvaluation::RB_initial_condition_all_N

The RB initial conditions (i.e.

L2 projection of the truth initial condition) for each N.

Definition at line 227 of file transient_rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_transient_rb_evaluation_data_to_builder(), legacy_read_offline_data_from_files(), legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_transient_rb_evaluation_data(), rb_solve(), rb_solve_again(), resize_data_structures(), and libMesh::TransientRBConstruction::update_RB_initial_condition_all_N().

◆ RB_inner_product_matrix

DenseMatrix<Number> libMesh::RBEvaluation::RB_inner_product_matrix

inherited

The inner product matrix.

This should be close to the identity, we need to calculate this rather than assume diagonality in order to accurately perform projections since orthogonality degrades with increasing N.

Definition at line 279 of file rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_rb_evaluation_data_to_builder(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_rb_evaluation_data(), libMesh::TransientRBConstruction::set_error_temporal_data(), and libMesh::RBConstruction::update_RB_system_matrices().

◆ RB_L2_matrix

DenseMatrix<Number> libMesh::TransientRBEvaluation::RB_L2_matrix

Dense RB L2 matrix.

Definition at line 175 of file transient_rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_transient_rb_evaluation_data_to_builder(), legacy_read_offline_data_from_files(), legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_transient_rb_evaluation_data(), resize_data_structures(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), and libMesh::TransientRBConstruction::update_RB_system_matrices().

◆ RB_LHS_matrix

DenseMatrix<Number> libMesh::TransientRBEvaluation::RB_LHS_matrix

Cached data for subsequent solves.

Definition at line 180 of file transient_rb_evaluation.h.

Referenced by rb_solve(), rb_solve_again(), and resize_data_structures().

◆ RB_M_q_vector

std::vector<DenseMatrix<Number> > libMesh::TransientRBEvaluation::RB_M_q_vector

Dense matrices for the RB mass matrices.

Definition at line 187 of file transient_rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_transient_rb_evaluation_data_to_builder(), legacy_read_offline_data_from_files(), legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_transient_rb_evaluation_data(), rb_solve(), resize_data_structures(), and libMesh::TransientRBConstruction::update_RB_system_matrices().

◆ RB_output_error_bounds

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

inherited

Definition at line 306 of file rb_evaluation.h.

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

◆ RB_output_error_bounds_all_k

std::vector<std::vector<Real> > libMesh::TransientRBEvaluation::RB_output_error_bounds_all_k

The error bounds for each RB output for all time-levels from the most recent rb_solve.

Definition at line 199 of file transient_rb_evaluation.h.

Referenced by rb_solve().

◆ RB_output_vectors

std::vector<std::vector<DenseVector<Number> > > libMesh::RBEvaluation::RB_output_vectors

inherited

The vectors storing the RB output vectors.

Definition at line 299 of file rb_evaluation.h.

Referenced by libMesh::RBDataSerialization::add_rb_evaluation_data_to_builder(), compute_residual_dual_norm(), libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBDataDeserialization::load_rb_evaluation_data(), rb_solve(), libMesh::RBEvaluation::rb_solve(), and libMesh::RBConstruction::update_RB_system_matrices().

◆ RB_outputs

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

inherited

The vectors storing the RB output values and corresponding error bounds.

Definition at line 305 of file rb_evaluation.h.

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

◆ RB_outputs_all_k

std::vector<std::vector<Number> > libMesh::TransientRBEvaluation::RB_outputs_all_k

The RB outputs for all time-levels from the most recent rb_solve.

Definition at line 193 of file transient_rb_evaluation.h.

Referenced by rb_solve().

◆ RB_RHS_matrix

DenseMatrix<Number> libMesh::TransientRBEvaluation::RB_RHS_matrix

Definition at line 181 of file transient_rb_evaluation.h.

Referenced by rb_solve(), rb_solve_again(), and resize_data_structures().

◆ RB_RHS_save

DenseVector<Number> libMesh::TransientRBEvaluation::RB_RHS_save

Definition at line 182 of file transient_rb_evaluation.h.

Referenced by rb_solve(), rb_solve_again(), and resize_data_structures().

◆ RB_solution

DenseVector<Number> libMesh::RBEvaluation::RB_solution

inherited

The RB solution vector.

Definition at line 294 of file rb_evaluation.h.

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

◆ RB_temporal_solution_data

std::vector<DenseVector<Number> > libMesh::TransientRBEvaluation::RB_temporal_solution_data

Array storing the solution data at each time level from the most recent solve.

Definition at line 209 of file transient_rb_evaluation.h.

Referenced by libMesh::TransientRBConstruction::load_rb_solution(), and rb_solve().

◆ rb_theta_expansion

RBThetaExpansion* libMesh::RBEvaluation::rb_theta_expansion

privateinherited

A pointer to to the object that stores the theta expansion.

This is not a std::unique_ptr since we may want to share it.

Note: A shared_ptr would be a good option here.

Definition at line 368 of file rb_evaluation.h.

◆ verbose_mode

bool libMesh::RBParametrized::verbose_mode

inherited

Public boolean to toggle verbose mode.

Definition at line 181 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/transient_rb_evaluation.h
src/reduced_basis/transient_rb_evaluation.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Counts

◆ Parent

Constructor & Destructor Documentation

◆ TransientRBEvaluation() [1/3]

◆ TransientRBEvaluation() [2/3]

◆ TransientRBEvaluation() [3/3]

◆ ~TransientRBEvaluation()

Member Function Documentation

◆ assert_file_exists()

◆ cache_online_residual_terms()

◆ check_evaluated_thetas_size()

◆ check_if_valid_params()

◆ clear()

◆ clear_riesz_representors()

◆ comm()

◆ compute_residual_dual_norm() [1/3]

◆ compute_residual_dual_norm() [2/3]

◆ compute_residual_dual_norm() [3/3]

◆ disable_print_counter_info()

◆ enable_print_counter_info()

◆ eval_output_dual_norm()

◆ get_basis_function() [1/2]

◆ get_basis_function() [2/2]

◆ get_closest_value()

◆ get_control()

◆ get_delta_t()

◆ get_discrete_parameter_values()

◆ get_error_bound_normalization()

◆ get_euler_theta()

◆ get_info()

◆ get_n_basis_functions()

◆ get_n_continuous_params()

◆ get_n_discrete_params()

◆ get_n_params()

◆ get_n_time_steps()

◆ get_parameter_max()

◆ get_parameter_min()

◆ get_parameters()

◆ get_parameters_max()

◆ get_parameters_min()

◆ get_rb_theta_expansion() [1/2]

◆ get_rb_theta_expansion() [2/2]

◆ get_stability_lower_bound()

◆ get_time_step()

◆ increment_constructor_count()

◆ increment_destructor_count()

◆ initialize_parameters() [1/2]

◆ initialize_parameters() [2/2]

◆ is_discrete_parameter()

◆ is_rb_theta_expansion_initialized()

◆ is_value_in_list()

◆ legacy_read_offline_data_from_files()

◆ legacy_write_offline_data_to_files()

◆ n_objects()

◆ n_processors()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ print_discrete_parameter_values()

◆ print_info()

◆ print_parameters()

◆ process_temporal_parameters_file()

◆ processor_id()

◆ pull_temporal_discretization_data()

◆ rb_solve() [1/3]

◆ rb_solve() [2/3]

◆ rb_solve() [3/3]