#include <transient_rb_evaluation.h>

Inheritance diagram for libMesh::TransientRBEvaluation:

Public Types
typedef RBEvaluation	Parent
Public Member Functions
	TransientRBEvaluation (const Parallel::Communicator &comm_in LIBMESH_CAN_DEFAULT_TO_COMMWORLD)
	~TransientRBEvaluation ()
virtual void	clear ()
virtual void	resize_data_structures (const unsigned int Nmax, bool resize_error_bound_data=true)
virtual Real	rb_solve (unsigned int N)
virtual Real	rb_solve_again ()
virtual Real	get_rb_solution_norm ()
virtual Real	residual_scaling_numer (Real alpha_LB)
virtual Real	compute_residual_dual_norm (const unsigned int N)
virtual Real	uncached_compute_residual_dual_norm (const unsigned int N)
void	cache_online_residual_terms (const unsigned int N)
virtual void	clear_riesz_representors ()
virtual void	write_offline_data_to_files (const std::string &directory_name="offline_data", const bool write_binary_data=true)
virtual void	read_offline_data_from_files (const std::string &directory_name="offline_data", bool read_error_bound_data=true, const bool read_binary_data=true)
void	set_rb_theta_expansion (RBThetaExpansion &rb_theta_expansion_in)
RBThetaExpansion &	get_rb_theta_expansion ()
bool	is_rb_theta_expansion_initialized () const
NumericVector< Number > &	get_basis_function (unsigned int i)
virtual Real	residual_scaling_denom (Real alpha_LB)
Real	eval_output_dual_norm (unsigned int n, const RBParameters &mu)
virtual Real	get_stability_lower_bound ()
virtual unsigned int	get_n_basis_functions () const
virtual void	set_n_basis_functions (unsigned int n_bfs)
virtual void	write_out_basis_functions (System &sys, const std::string &directory_name="offline_data", const bool write_binary_basis_functions=true)
virtual 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)
virtual void	read_in_basis_functions (System &sys, const std::string &directory_name="offline_data", const bool read_binary_basis_functions=true)
void	read_in_vectors (System &sys, std::vector< NumericVector< Number > * > &vectors, const std::string &directory_name, const std::string &data_name, const bool read_binary_vectors)
void	read_in_vectors_from_multiple_files (System &sys, std::vector< std::vector< 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)
void	initialize_parameters (const RBParameters &mu_min_in, const RBParameters &mu_max_in, const std::map< std::string, std::vector< Real > > &discrete_parameter_values)
void	initialize_parameters (const RBParametrized &rb_parametrized)
unsigned int	get_n_params () const
unsigned int	get_n_continuous_params () const
unsigned int	get_n_discrete_params () const
std::set< std::string >	get_parameter_names () const
const RBParameters &	get_parameters () const
void	set_parameters (const RBParameters &params)
const RBParameters &	get_parameters_min () const
const RBParameters &	get_parameters_max () const
Real	get_parameter_min (const std::string &param_name) const
Real	get_parameter_max (const std::string &param_name) const
void	print_parameters () const
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)
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)
bool	is_discrete_parameter (const std::string &mu_name) const
const std::map< std::string, std::vector< Real > > &	get_discrete_parameter_values () const
void	print_discrete_parameter_values () const
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const
Real	get_delta_t () const
void	set_delta_t (const Real delta_t_in)
Real	get_euler_theta () const
void	set_euler_theta (const Real euler_theta_in)
unsigned int	get_time_step () const
void	set_time_step (const unsigned int k)
unsigned int	get_n_time_steps () const
void	set_n_time_steps (const unsigned int K)
Real	get_control (const unsigned int k) const
void	set_control (const std::vector< Real > &control)
void	process_temporal_parameters_file (const std::string &parameters_filename)
void	pull_temporal_discretization_data (RBTemporalDiscretization &other)
Static Public Member Functions
static std::string	get_io_version_string ()
static Real	get_closest_value (Real value, const std::vector< Real > &list_of_values)
static std::string	get_info ()
static void	print_info (std::ostream &out=libMesh::out)
static unsigned int	n_objects ()
static void	enable_print_counter_info ()
static void	disable_print_counter_info ()
Public Attributes
DenseMatrix< Number >	RB_L2_matrix
DenseMatrix< Number >	RB_LHS_matrix
DenseMatrix< Number >	RB_RHS_matrix
DenseVector< Number >	RB_RHS_save
std::vector< DenseMatrix < Number > >	RB_M_q_vector
std::vector< std::vector < Number > >	RB_outputs_all_k
std::vector< std::vector< Real > >	RB_output_error_bounds_all_k
DenseVector< Number >	old_RB_solution
std::vector< DenseVector < Number > >	RB_temporal_solution_data
std::vector< Real >	error_bound_all_k
std::vector< Real >	initial_L2_error_all_N
std::vector< DenseVector < Number > >	RB_initial_condition_all_N
std::vector< std::vector < std::vector< Number > > >	Fq_Mq_representor_innerprods
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
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 < NumericVector< Number > * > >	M_q_representor
bool	_rb_solve_data_cached
std::vector< NumericVector < Number > * >	basis_functions
std::vector< RBParameters >	greedy_param_list
DenseMatrix< Number >	RB_inner_product_matrix
std::vector< DenseMatrix < Number > >	RB_Aq_vector
std::vector< DenseVector < Number > >	RB_Fq_vector
DenseVector< Number >	RB_solution
std::vector< std::vector < DenseVector< Number > > >	RB_output_vectors
std::vector< Number >	RB_outputs
std::vector< Real >	RB_output_error_bounds
std::vector< Number >	Fq_representor_innerprods
std::vector< std::vector < std::vector< Number > > >	Fq_Aq_representor_innerprods
std::vector< std::vector < std::vector< Number > > >	Aq_Aq_representor_innerprods
std::vector< std::vector < Number > >	output_dual_innerprods
std::vector< std::vector < NumericVector< Number > * > >	Aq_representor
bool	evaluate_RB_error_bound
bool	compute_RB_inner_product
bool	verbose_mode
Protected Types
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts
Protected Member Functions
void	increment_constructor_count (const std::string &name)
void	increment_destructor_count (const std::string &name)
Protected Attributes
const Parallel::Communicator &	_communicator
Static Protected Attributes
static Counts	_counts
static Threads::atomic < unsigned int >	_n_objects
static Threads::spin_mutex	_mutex
static bool	_enable_print_counter = true

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,). See Martin Grepl's thesis for more details.

Author:: David J. Knezevic, 2011

Definition at line 54 of file transient_rb_evaluation.h.

Member Typedef Documentation

typedef std::map<std::string, std::pair<unsigned int, unsigned int> > libMesh::ReferenceCounter::Counts [protected, inherited]

Data structure to log the information. The log is identified by the class name.

Definition at line 113 of file reference_counter.h.

typedef RBEvaluation libMesh::TransientRBEvaluation::Parent

The type of the parent.

Definition at line 72 of file transient_rb_evaluation.h.

Constructor & Destructor Documentation

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

Constructor.

libMesh::TransientRBEvaluation::~TransientRBEvaluation ( )

Destructor.

Member Function Documentation

void libMesh::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.)

virtual void libMesh::TransientRBEvaluation::clear ( ) [virtual]

Clear this TransientRBEvaluation object. Override to also clear the M_q representors

Reimplemented from libMesh::RBEvaluation.

virtual void libMesh::TransientRBEvaluation::clear_riesz_representors ( ) [virtual]

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.

const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const [inline, inherited]

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

Definition at line 86 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

  { return _communicator; }

virtual Real libMesh::TransientRBEvaluation::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.

void libMesh::ReferenceCounter::disable_print_counter_info ( ) [static, inherited]

Definition at line 106 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

{
  _enable_print_counter = false;
  return;
}

void libMesh::ReferenceCounter::enable_print_counter_info ( ) [static, inherited]

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

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

{
  _enable_print_counter = true;
  return;
}

Real libMesh::RBEvaluation::eval_output_dual_norm	(	unsigned int	n,
		const RBParameters &	mu
	)		`[inherited]`

Evaluate the dual norm of output n for the current parameters.

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

Get a reference to the i^th basis function.

static Real libMesh::RBParametrized::get_closest_value	(	Real	value,
		const std::vector< Real > &	list_of_values
	)		`[static, inherited]`

Helper function that returns the closest entry to value from list_of_values.

Real libMesh::RBTemporalDiscretization::get_control ( const unsigned int k ) const [inherited]

Get/set the RHS control.

Real libMesh::RBTemporalDiscretization::get_delta_t ( ) const [inherited]

Get/set delta_t, the time-step size.

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.

Real libMesh::RBTemporalDiscretization::get_euler_theta ( ) const [inherited]

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

std::string libMesh::ReferenceCounter::get_info ( ) [static, inherited]

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

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

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

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

  std::ostringstream oss;

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

  for (Counts::iterator it = _counts.begin();
       it != _counts.end(); ++it)
    {
      const std::string name(it->first);
      const unsigned int creations    = it->second.first;
      const unsigned int destructions = it->second.second;

      oss << "| " << name << " reference count information:\n"
          << "|  Creations:    " << creations    << '\n'
          << "|  Destructions: " << destructions << '\n';
    }

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

  return oss.str();

#else

  return "";

#endif
}

static std::string libMesh::RBEvaluation::get_io_version_string ( ) [static, inherited]

Version string that we need to use for writing/reading basis functions.

virtual unsigned int libMesh::RBEvaluation::get_n_basis_functions ( ) const [inline, virtual, inherited]

Get the current number of basis functions.

Definition at line 148 of file rb_evaluation.h.

References libMesh::RBEvaluation::basis_functions.

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

unsigned int libMesh::RBParametrized::get_n_continuous_params ( ) const [inherited]

Get the number of continuous parameters.

unsigned int libMesh::RBParametrized::get_n_discrete_params ( ) const [inherited]

Get the number of discrete parameters.

unsigned int libMesh::RBParametrized::get_n_params ( ) const [inherited]

Get the number of parameters.

unsigned int libMesh::RBTemporalDiscretization::get_n_time_steps ( ) const [inherited]

Get/set the total number of time-steps.

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

Get maximum allowable value of parameter param_name.

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

Get minimum allowable value of parameter param_name.

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

Get a set that stores the parameter names.

const RBParameters& libMesh::RBParametrized::get_parameters ( ) const [inherited]

Get the current parameters.

const RBParameters& libMesh::RBParametrized::get_parameters_max ( ) const [inherited]

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

const RBParameters& libMesh::RBParametrized::get_parameters_min ( ) const [inherited]

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

virtual Real libMesh::TransientRBEvaluation::get_rb_solution_norm ( ) [virtual]

Override to return the L2 norm of RB_solution.

Reimplemented from libMesh::RBEvaluation.

RBThetaExpansion& libMesh::RBEvaluation::get_rb_theta_expansion ( ) [inherited]

Get a reference to the rb_theta_expansion.

virtual Real libMesh::RBEvaluation::get_stability_lower_bound ( ) [virtual, inherited]

Get a lower bound for the stability constant (e.g. coercivity constant or inf-sup constant) at the current parameter value.

unsigned int libMesh::RBTemporalDiscretization::get_time_step ( ) const [inherited]

Get/set the current time-step.

void libMesh::ReferenceCounter::increment_constructor_count ( const std::string & name ) [inline, protected, inherited]

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

Definition at line 163 of file reference_counter.h.

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

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

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

  p.first++;
}

void libMesh::ReferenceCounter::increment_destructor_count ( const std::string & name ) [inline, protected, inherited]

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

Definition at line 176 of file reference_counter.h.

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

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

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

  p.second++;
}

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.

void libMesh::RBParametrized::initialize_parameters ( const RBParametrized & rb_parametrized ) [inherited]

Initialize the parameter ranges and set current_parameters.

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

Is parameter mu_name discrete?

bool libMesh::RBEvaluation::is_rb_theta_expansion_initialized ( ) const [inherited]

Returns:: true if the theta expansion has been initialized.

static unsigned int libMesh::ReferenceCounter::n_objects ( ) [inline, static, inherited]

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

Definition at line 79 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

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

  { return _n_objects; }

processor_id_type libMesh::ParallelObject::n_processors ( ) const [inline, inherited]

Returns:: the number of processors in the group.

Definition at line 92 of file parallel_object.h.

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

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

void libMesh::RBParametrized::print_discrete_parameter_values ( ) const [inherited]

Print out all the discrete parameter values.

void libMesh::ReferenceCounter::print_info ( std::ostream & out = libMesh::out ) [static, inherited]

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

Definition at line 88 of file reference_counter.C.

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

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

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

void libMesh::RBParametrized::print_parameters ( ) const [inherited]

Print the current parameters.

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

Read in and initialize parameters from parameters_filename.

processor_id_type libMesh::ParallelObject::processor_id ( ) const [inline, inherited]

Returns:: the rank of this processor in the group.

Definition at line 98 of file parallel_object.h.

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

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

void libMesh::RBTemporalDiscretization::pull_temporal_discretization_data ( RBTemporalDiscretization & other ) [inherited]

Pull the temporal discretization data from other.

virtual Real libMesh::TransientRBEvaluation::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.

virtual Real libMesh::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).

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

Read in all the basis functions from 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

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

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.

void libMesh::RBEvaluation::read_in_vectors_from_multiple_files	(	System &	sys,
		std::vector< std::vector< 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
	)		`[inherited]`

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

virtual void libMesh::TransientRBEvaluation::read_offline_data_from_files	(	const std::string &	directory_name = `"offline_data"`,
		bool	read_error_bound_data = `true`,
		const bool	read_binary_data = `true`
	)		`[virtual]`

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

Reimplemented from libMesh::RBEvaluation.

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.

virtual Real libMesh::RBEvaluation::residual_scaling_denom ( Real alpha_LB ) [virtual, inherited]

Specifies the residual scaling on the denominator to be used in the a posteriori error bound. Overload in subclass in order to obtain the desired error bound.

virtual Real libMesh::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.

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

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.

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

void libMesh::RBTemporalDiscretization::set_delta_t ( const Real delta_t_in ) [inherited]

void libMesh::RBTemporalDiscretization::set_euler_theta ( const Real euler_theta_in ) [inherited]

virtual void libMesh::RBEvaluation::set_n_basis_functions ( unsigned int n_bfs ) [inline, virtual, inherited]

Set the number of basis functions. Useful when reading in stored data.

Definition at line 155 of file rb_evaluation.h.

References libMesh::RBEvaluation::basis_functions.

{ basis_functions.resize(n_bfs); }

void libMesh::RBTemporalDiscretization::set_n_time_steps ( const unsigned int K ) [inherited]

void libMesh::RBParametrized::set_parameters ( const RBParameters & params ) [inherited]

Set the current parameters to params

void libMesh::RBEvaluation::set_rb_theta_expansion ( RBThetaExpansion & rb_theta_expansion_in ) [inherited]

Set the RBThetaExpansion object.

void libMesh::RBTemporalDiscretization::set_time_step ( const unsigned int k ) [inherited]

virtual Real libMesh::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.

virtual void libMesh::TransientRBEvaluation::write_offline_data_to_files	(	const std::string &	directory_name = `"offline_data"`,
		const bool	write_binary_data = `true`
	)		`[virtual]`

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

Reimplemented from libMesh::RBEvaluation.

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

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

virtual 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`
	)		`[virtual, inherited]`

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

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.

Member Data Documentation

const Parallel::Communicator& libMesh::ParallelObject::_communicator [protected, inherited]

Definition at line 104 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_solution_vector(), libMesh::ParallelObject::comm(), libMesh::EquationSystems::get_solution(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), and libMesh::ParallelObject::processor_id().

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts [static, protected, inherited]

Actually holds the data.

Definition at line 118 of file reference_counter.h.

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

bool libMesh::ReferenceCounter::_enable_print_counter = true [static, protected, inherited]

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

Definition at line 137 of file reference_counter.h.

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

Threads::spin_mutex libMesh::ReferenceCounter::_mutex [static, protected, inherited]

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 131 of file reference_counter.h.

Threads::atomic< unsigned int > libMesh::ReferenceCounter::_n_objects [static, protected, inherited]

The number of objects. Print the reference count information when the number returns to 0.

Definition at line 126 of file reference_counter.h.

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

bool libMesh::TransientRBEvaluation::_rb_solve_data_cached

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

Definition at line 249 of file transient_rb_evaluation.h.

std::vector< std::vector< std::vector<Number> > > libMesh::RBEvaluation::Aq_Aq_representor_innerprods [inherited]

Definition at line 304 of file rb_evaluation.h.

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

Definition at line 226 of file transient_rb_evaluation.h.

std::vector< std::vector< 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 320 of file rb_evaluation.h.

std::vector< NumericVector<Number>* > libMesh::RBEvaluation::basis_functions [inherited]

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

Definition at line 245 of file rb_evaluation.h.

Referenced by libMesh::RBEvaluation::get_n_basis_functions(), and libMesh::RBEvaluation::set_n_basis_functions().

DenseMatrix<Number> libMesh::TransientRBEvaluation::cached_Aq_Aq_matrix

Definition at line 235 of file transient_rb_evaluation.h.

DenseMatrix<Number> libMesh::TransientRBEvaluation::cached_Aq_Mq_matrix

Definition at line 237 of file transient_rb_evaluation.h.

DenseVector<Number> libMesh::TransientRBEvaluation::cached_Fq_Aq_vector

Definition at line 234 of file transient_rb_evaluation.h.

DenseVector<Number> libMesh::TransientRBEvaluation::cached_Fq_Mq_vector

Definition at line 236 of file transient_rb_evaluation.h.

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 233 of file transient_rb_evaluation.h.

DenseMatrix<Number> libMesh::TransientRBEvaluation::cached_Mq_Mq_matrix

Definition at line 238 of file transient_rb_evaluation.h.

bool libMesh::RBEvaluation::compute_RB_inner_product [inherited]

Boolean flag to indicate whether we compute the RB_inner_product_matrix.

Definition at line 331 of file rb_evaluation.h.

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 206 of file transient_rb_evaluation.h.

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 326 of file rb_evaluation.h.

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 303 of file rb_evaluation.h.

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 224 of file transient_rb_evaluation.h.

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 294 of file rb_evaluation.h.

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 251 of file rb_evaluation.h.

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

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

Definition at line 212 of file transient_rb_evaluation.h.

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

Vector storing the mass matrix representors. These are basis dependent and hence stored here.

Definition at line 244 of file transient_rb_evaluation.h.

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

Definition at line 225 of file transient_rb_evaluation.h.

DenseVector<Number> libMesh::TransientRBEvaluation::old_RB_solution

The RB solution at the previous time-level.

Definition at line 195 of file transient_rb_evaluation.h.

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 312 of file rb_evaluation.h.

std::vector< DenseMatrix<Number> > libMesh::RBEvaluation::RB_Aq_vector [inherited]

Dense matrices for the RB computations.

Definition at line 264 of file rb_evaluation.h.

std::vector< DenseVector<Number> > libMesh::RBEvaluation::RB_Fq_vector [inherited]

Dense vector for the RHS.

Definition at line 269 of file rb_evaluation.h.

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 218 of file transient_rb_evaluation.h.

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 259 of file rb_evaluation.h.

DenseMatrix<Number> libMesh::TransientRBEvaluation::RB_L2_matrix

Dense RB L2 matrix.

Definition at line 166 of file transient_rb_evaluation.h.

DenseMatrix<Number> libMesh::TransientRBEvaluation::RB_LHS_matrix

Cached data for subsequent solves.

Definition at line 171 of file transient_rb_evaluation.h.

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

Dense matrices for the RB mass matrices.

Definition at line 178 of file transient_rb_evaluation.h.

std::vector< Real > libMesh::RBEvaluation::RB_output_error_bounds [inherited]

Definition at line 286 of file rb_evaluation.h.