Abstract base class for operator objects using libmesh in the backend. More...

#include <LibMeshOperatorBase.h>

Inheritance diagram for QUESO::LibMeshOperatorBase:

Collaboration diagram for QUESO::LibMeshOperatorBase:

Public Member Functions
virtual void	assemble ()=0
	Must implement this for the solve to work. More...

virtual void	print_info () const =0
	Print libmesh related information. More...

virtual void	save_converged_evals (const std::string &filename) const
	Save the eigenvalues to file `filename`. More...

virtual void	save_converged_evec (const std::string &filename, unsigned int i) const
	Save converged eigenfunction `i` to `filename`. More...

virtual unsigned int	get_num_converged () const
	Return the number of converged eigenpairs. More...

virtual double	get_eigenvalue (unsigned int i) const
	Return eigenvalue `i`. More...

virtual double	get_inverted_eigenvalue (unsigned int i) const
	Return the reciprocal of eigenvalue `i`. More...

virtual libMesh::EquationSystems &	get_equation_systems () const
	Return the internal libmesh equation systems object. More...

virtual SharedPtr < FunctionBase >::Type	inverse_kl_transform (std::vector< double > &xi, double alpha) const
	Given coefficients `xi`, computes the Karhunen-Loeve transform. More...

Constructor/Destructor methods
	LibMeshOperatorBase (const FunctionOperatorBuilder &builder, libMesh::MeshBase &m)
	Constuct an operator on the mesh `m` using a builder `builder`. More...

	~LibMeshOperatorBase ()
	Destructor. More...

Public Member Functions inherited from QUESO::OperatorBase
	OperatorBase ()
	Constructor. More...

virtual	~OperatorBase ()
	Destructor. More...

Protected Attributes
SharedPtr < libMesh::EquationSystems > ::Type	equation_systems

const FunctionOperatorBuilder &	builder

unsigned int	num_req_pairs
	The number of requested eigenpairs. More...

unsigned int	nconv
	The number of converged eigenpairs. More...

Detailed Description

Abstract base class for operator objects using libmesh in the backend.

Definition at line 57 of file LibMeshOperatorBase.h.

Constructor & Destructor Documentation

QUESO::LibMeshOperatorBase::LibMeshOperatorBase	(	const FunctionOperatorBuilder &	builder,
		libMesh::MeshBase &	m
	)

Constuct an operator on the mesh m using a builder builder.

A FunctionOperatorBuilder object is just one that a FEM library backend can use to set up various options. Polynomial type, polynomial order, and the number of eigenpairs to request are good examples.

Definition at line 50 of file LibMeshOperatorBase.C.

References equation_systems.

   : OperatorBase(),
     equation_systems(new libMesh::EquationSystems(m)),
     builder(builder)
 {
 #ifndef LIBMESH_HAVE_SLEPC
   if (m.processor_id() == 0)
     std::cerr << "ERROR: This example requires libMesh to be\n"
               << "compiled with SLEPc eigen solvers support!"
               << std::endl;
 #else
 
 #ifdef LIBMESH_DEFAULT_SINGLE_PRECISION
   // SLEPc currently gives us a nasty crash with Real==float
   libmesh_example_assert(false, "--disable-singleprecision");
 #endif
 
 #ifdef LIBMESH_USE_COMPLEX_NUMBERS
   // SLEPc currently gives us an "inner product not well defined" with
   // Number==complex
   libmesh_example_assert(false, "--disable-complex");
 #endif
 
   // Create a CondensedEigenSystem named "Eigensystem" and (for convenience)
   // use a reference to the system we create.
   this->equation_systems->add_system<libMesh::CondensedEigenSystem>("Eigensystem");
 
 #endif // LIBMESH_HAVE_SLEPC
 }

QUESO::LibMeshOperatorBase::~LibMeshOperatorBase ( )

Destructor.

Definition at line 81 of file LibMeshOperatorBase.C.

82 {

83 }

Member Function Documentation

virtual void QUESO::LibMeshOperatorBase::assemble ( )

pure virtual

Must implement this for the solve to work.

This gets called by libMesh to do the assembly for the eigenvalue problem

Implemented in QUESO::LibMeshNegativeLaplacianOperator.

double QUESO::LibMeshOperatorBase::get_eigenvalue ( unsigned int i ) const

virtual

Return eigenvalue i.

You can store them however you want, but having some kind of order to them is useful for InfiniteDimensionalMeasure

Implements QUESO::OperatorBase.

Definition at line 122 of file LibMeshOperatorBase.C.

References equation_systems, and nconv.

Referenced by get_inverted_eigenvalue().

 {
   if (i < this->nconv) {
     std::pair<libMesh::Real, libMesh::Real> eval;
     SharedPtr<libMesh::EquationSystems>::Type es(this->equation_systems);
     eval = es->get_system<libMesh::EigenSystem>("Eigensystem").get_eigenpair(i);
     return eval.first;
   }
   else {
     return -1;
   }
 }

libMesh::EquationSystems & QUESO::LibMeshOperatorBase::get_equation_systems ( ) const

virtual

Return the internal libmesh equation systems object.

Definition at line 140 of file LibMeshOperatorBase.C.

References equation_systems.

 {
   return *this->equation_systems;
 }

double QUESO::LibMeshOperatorBase::get_inverted_eigenvalue ( unsigned int i ) const

virtual

Return the reciprocal of eigenvalue i.

Implements QUESO::OperatorBase.

Definition at line 135 of file LibMeshOperatorBase.C.

References get_eigenvalue().

 {
   return 1.0 / this->get_eigenvalue(i);
 }

unsigned int QUESO::LibMeshOperatorBase::get_num_converged ( ) const

virtual

Return the number of converged eigenpairs.

Implements QUESO::OperatorBase.

Definition at line 118 of file LibMeshOperatorBase.C.

References nconv.

Referenced by inverse_kl_transform().

                                                           {
   return this->nconv;
 }

SharedPtr< FunctionBase >::Type QUESO::LibMeshOperatorBase::inverse_kl_transform	(	std::vector< double > &	xi,
		double	alpha
	)		const

virtual

Given coefficients xi, computes the Karhunen-Loeve transform.

This transform goes from coefficient space to physical space using this as the precision operator: / pow(, alpha / 2.0) (x) where the lambda are eigenvalues of the precision operator, this, and the (x) are eigenfunctions of the precision operator, this

Implements QUESO::OperatorBase.

Definition at line 146 of file LibMeshOperatorBase.C.

References builder, equation_systems, QUESO::LibMeshFunction::get_equation_systems(), and get_num_converged().

 {
   unsigned int i;
   SharedPtr<libMesh::EquationSystems>::Type es(this->equation_systems);
   LibMeshFunction *kl = new LibMeshFunction(this->builder, es->get_mesh());
 
   // Make sure all procs in libmesh mpi communicator all have the same xi.  No,
   // I can't set the seed in QUESO.  That would mess with the QUESO
   // communicator.
   this->equation_systems->comm().broadcast(xi);
 
   SharedPtr<libMesh::EquationSystems>::Type kl_eq_sys(kl->get_equation_systems());
 
   std::pair<libMesh::Real, libMesh::Real> eval;
   for (i = 0; i < this->get_num_converged(); i++) {
     eval = es->get_system<libMesh::EigenSystem>("Eigensystem").get_eigenpair(i);
     kl_eq_sys->get_system<libMesh::ExplicitSystem>("Function").solution->add(
         xi[i] / pow(eval.first, alpha / 2.0),
         *es->get_system<libMesh::EigenSystem>("Eigensystem").solution);
   }
 
   SharedPtr<FunctionBase>::Type ap(kl);
   return ap;
 }

virtual void QUESO::LibMeshOperatorBase::print_info ( ) const

pure virtual

Print libmesh related information.

Implemented in QUESO::LibMeshNegativeLaplacianOperator.

void QUESO::LibMeshOperatorBase::save_converged_evals ( const std::string & filename ) const

virtual

Save the eigenvalues to file filename.

Definition at line 85 of file LibMeshOperatorBase.C.

References equation_systems, and nconv.

 {
   unsigned int i;
   std::ofstream evals_file(filename.c_str());
 
   std::pair<libMesh::Real, libMesh::Real> eval;
   for (i = 0; i < this->nconv; i++) {
     eval = this->equation_systems
                ->get_system<libMesh::EigenSystem>("Eigensystem").get_eigenpair(i);
     if (equation_systems->processor_id() == 0) {
       evals_file << eval.first << " " << eval.second << std::endl;
     }
   }
   if (this->equation_systems->processor_id() == 0) {
     evals_file.close();
   }
 }

void QUESO::LibMeshOperatorBase::save_converged_evec	(	const std::string &	filename,
		unsigned int	i
	)		const

virtual

Save converged eigenfunction i to filename.

Definition at line 103 of file LibMeshOperatorBase.C.

References equation_systems, and nconv.

 {
   if (i < this->nconv) {
     SharedPtr<libMesh::EquationSystems>::Type es(this->equation_systems);
     es->get_system<libMesh::EigenSystem>("Eigensystem").get_eigenpair(i);
     libMesh::ExodusII_IO(es->get_mesh()).write_equation_systems(filename, *es);
   }
   else {
     std::cerr << "Warning: eigenpair " << i
               << " did not converge. Not saving."
               << std::endl;
   }
 }