oomph::TrilinosPreconditionerBase Class Reference

Base class for Trilinos preconditioners as oomph-lib preconditioner. More...

#include <trilinos_preconditioners.h>

Inheritance diagram for oomph::TrilinosPreconditionerBase:

Public Member Functions
	TrilinosPreconditionerBase ()
	Constructor. More...
virtual	~TrilinosPreconditionerBase ()
	Destructor. More...
void	clean_up_memory ()
	deletes the preconditioner, matrices and maps More...
	TrilinosPreconditionerBase (const TrilinosPreconditionerBase &)=delete
	Broken copy constructor. More...
void	setup ()
	Broken assignment operator. More...
void	setup (Epetra_CrsMatrix *epetra_matrix_pt)
void	preconditioner_solve (const DoubleVector &r, DoubleVector &z)
	applies the preconditioner More...
Epetra_Operator *&	epetra_operator_pt ()
Epetra_Operator *	epetra_operator_pt () const
Public Member Functions inherited from oomph::Preconditioner
	Preconditioner ()
	Constructor. More...
	Preconditioner (const Preconditioner &)=delete
	Broken copy constructor. More...
void	operator= (const Preconditioner &)=delete
	Broken assignment operator. More...
virtual	~Preconditioner ()
	Destructor (empty) More...
virtual void	preconditioner_solve_transpose (const DoubleVector &r, DoubleVector &z)
void	setup (DoubleMatrixBase *matrix_pt)
void	setup (const Problem *problem_pt, DoubleMatrixBase *matrix_pt)
void	enable_silent_preconditioner_setup ()
	Set up the block preconditioner quietly! More...
void	disable_silent_preconditioner_setup ()
	Be verbose in the block preconditioner setup. More...
virtual DoubleMatrixBase *	matrix_pt () const
	Get function for matrix pointer. More...
virtual void	set_matrix_pt (DoubleMatrixBase *matrix_pt)
	Set the matrix pointer. More...
virtual const OomphCommunicator *	comm_pt () const
	Get function for comm pointer. More...
virtual void	set_comm_pt (const OomphCommunicator *const comm_pt)
	Set the communicator pointer. More...
double	setup_time () const
	Returns the time to setup the preconditioner. More...
virtual void	turn_into_subsidiary_block_preconditioner (BlockPreconditioner< CRDoubleMatrix > *master_block_prec_pt, const Vector< unsigned > &doftype_in_master_preconditioner_coarse)
virtual void	turn_into_subsidiary_block_preconditioner (BlockPreconditioner< CRDoubleMatrix > *master_block_prec_pt, const Vector< unsigned > &doftype_in_master_preconditioner_coarse, const Vector< Vector< unsigned >> &doftype_coarsen_map_coarse)
Public Member Functions inherited from oomph::DistributableLinearAlgebraObject
	DistributableLinearAlgebraObject ()
	Default constructor - create a distribution. More...
	DistributableLinearAlgebraObject (const DistributableLinearAlgebraObject &matrix)=delete
	Broken copy constructor. More...
void	operator= (const DistributableLinearAlgebraObject &)=delete
	Broken assignment operator. More...
virtual	~DistributableLinearAlgebraObject ()
	Destructor. More...
LinearAlgebraDistribution *	distribution_pt () const
	access to the LinearAlgebraDistribution More...
unsigned	nrow () const
	access function to the number of global rows. More...
unsigned	nrow_local () const
	access function for the num of local rows on this processor. More...
unsigned	nrow_local (const unsigned &p) const
	access function for the num of local rows on this processor. More...
unsigned	first_row () const
	access function for the first row on this processor More...
unsigned	first_row (const unsigned &p) const
	access function for the first row on this processor More...
bool	distributed () const
	distribution is serial or distributed More...
bool	distribution_built () const
void	build_distribution (const LinearAlgebraDistribution *const dist_pt)
void	build_distribution (const LinearAlgebraDistribution &dist)

Static Public Attributes
static double	Cumulative_preconditioner_solve_time = 0.0

Protected Member Functions
virtual void	setup_trilinos_preconditioner (Epetra_CrsMatrix *epetra_matrix_pt)=0
Protected Member Functions inherited from oomph::DistributableLinearAlgebraObject
void	clear_distribution ()

Protected Attributes
Epetra_Operator *	Epetra_preconditioner_pt
Epetra_CrsMatrix *	Epetra_matrix_pt
Protected Attributes inherited from oomph::Preconditioner
bool	Silent_preconditioner_setup
	Boolean to indicate whether or not the build should be done silently. More...
std::ostream *	Stream_pt
	Pointer to the output stream – defaults to std::cout. More...

Detailed Description

Base class for Trilinos preconditioners as oomph-lib preconditioner.

Constructor & Destructor Documentation

TrilinosPreconditionerBase() [1/2]

oomph::TrilinosPreconditionerBase::TrilinosPreconditionerBase ( )

inline

Constructor.

    {
      // Initialise pointers
      Epetra_preconditioner_pt = 0;
      Epetra_matrix_pt = 0;
    }

References Epetra_matrix_pt, and Epetra_preconditioner_pt.

~TrilinosPreconditionerBase()

virtual oomph::TrilinosPreconditionerBase::~TrilinosPreconditionerBase ( )

inlinevirtual

Destructor.

    {
      clean_up_memory();
    }

References clean_up_memory().

TrilinosPreconditionerBase() [2/2]

oomph::TrilinosPreconditionerBase::TrilinosPreconditionerBase ( const TrilinosPreconditionerBase &  )

delete

Broken copy constructor.

Member Function Documentation

clean_up_memory()

void oomph::TrilinosPreconditionerBase::clean_up_memory ( )

inlinevirtual

deletes the preconditioner, matrices and maps

Reimplemented from oomph::Preconditioner.

    {
      // delete the Epetra preconditioner
      delete Epetra_preconditioner_pt;
      Epetra_preconditioner_pt = 0;
 
      // delete the epetra matrix
      delete Epetra_matrix_pt;
      Epetra_matrix_pt = 0;
    }

References Epetra_matrix_pt, and Epetra_preconditioner_pt.

Referenced by setup(), and ~TrilinosPreconditionerBase().

epetra_operator_pt() [1/2]

Epetra_Operator*& oomph::TrilinosPreconditionerBase::epetra_operator_pt ( )

inline

Access function to Epetra_preconditioner_pt. For use with TrilinosAztecOOSolver

    {
      return Epetra_preconditioner_pt;
    }

References Epetra_preconditioner_pt.

Referenced by oomph::TrilinosAztecOOSolver::solver_setup().

epetra_operator_pt() [2/2]

Epetra_Operator* oomph::TrilinosPreconditionerBase::epetra_operator_pt ( ) const

inline

Access function to Epetra_preconditioner_pt (const version) For use with TrilinosAztecOOSolver

    {
      return Epetra_preconditioner_pt;
    }

References Epetra_preconditioner_pt.

preconditioner_solve()

void oomph::TrilinosPreconditionerBase::preconditioner_solve ( const DoubleVector &  r, DoubleVector &  z  )

virtual

applies the preconditioner

preconditioner_solve - applies the preconditioner to the vector r taking distributed oomph-lib vectors (DistributedVector<double>) as arguments.

Implements oomph::Preconditioner.

  {
    // Get ready to do cumulative timings
    double t_start = TimingHelpers::timer();
 
#ifdef PARANOID
    // check preconditioner data exists
    if (Epetra_preconditioner_pt == 0)
    {
      std::ostringstream error_message;
      error_message << "preconditioner_solve requires that solver data has "
                    << "been set up" << std::endl;
      throw OomphLibError(
        error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
 
    if (*this->distribution_pt() != r.distribution_pt())
    {
      std::ostringstream error_message;
      error_message << "The rhs vector and the matrix must have the same "
                    << "distribution.\n";
      throw OomphLibError(
        error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    // create Epetra version of r
    Epetra_Vector* epetra_r_pt =
      TrilinosEpetraHelpers::create_distributed_epetra_vector(r);
 
    // create an empty Epetra vector for z
    Epetra_Vector* epetra_z_pt =
      TrilinosEpetraHelpers::create_distributed_epetra_vector(
        this->distribution_pt());
 
    // Apply preconditioner
    Epetra_preconditioner_pt->ApplyInverse(*epetra_r_pt, *epetra_z_pt);
 
    // Copy result to z
    z.build(this->distribution_pt(), 0.0);
    TrilinosEpetraHelpers::copy_to_oomphlib_vector(epetra_z_pt, z);
 
    // clean up memory
    delete epetra_r_pt;
    delete epetra_z_pt;
 
 
    // Add to cumulative solve time
    double t_end = TimingHelpers::timer();
    Cumulative_preconditioner_solve_time += (t_end - t_start);
  }

References oomph::DoubleVector::build(), oomph::TrilinosEpetraHelpers::copy_to_oomphlib_vector(), oomph::TrilinosEpetraHelpers::create_distributed_epetra_vector(), Cumulative_preconditioner_solve_time, oomph::DistributableLinearAlgebraObject::distribution_pt(), Epetra_preconditioner_pt, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, UniformPSDSelfTest::r, and oomph::TimingHelpers::timer().

setup() [1/2]

void oomph::TrilinosPreconditionerBase::setup ( )

virtual

Broken assignment operator.

Function to set up a preconditioner for the linear system defined by matrix_pt. This function must be called before using preconditioner_solve. NOTE 1. matrix_pt must point to an object of class CRDoubleMatrix or DistributedCRDoubleMatrix This method should be called by oomph-lib solvers and preconditioners

Implements oomph::Preconditioner.

  {
    // clean up the memory
    clean_up_memory();
 
#ifdef PARANOID
    // check the matrix is square
    if (matrix_pt()->nrow() != matrix_pt()->ncol())
    {
      std::ostringstream error_message;
      error_message << "Preconditioners require a square matrix. "
                    << "Matrix is " << matrix_pt()->nrow() << " by "
                    << matrix_pt()->ncol() << std::endl;
      throw OomphLibError(
        error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
 
    // get a pointer to the cr double matrix
    CRDoubleMatrix* cr_matrix_pt = dynamic_cast<CRDoubleMatrix*>(matrix_pt());
 
#ifdef PARANOID
    if (cr_matrix_pt == 0)
    {
      throw OomphLibError("Matrix must be of type CRDoubleMatrix",
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    // build the distribution of this preconditioner
    this->build_distribution(cr_matrix_pt->distribution_pt());
 
    // create the matrices
    Epetra_matrix_pt = TrilinosEpetraHelpers::create_distributed_epetra_matrix(
      cr_matrix_pt, this->distribution_pt());
 
    // set up preconditioner
    setup_trilinos_preconditioner(Epetra_matrix_pt);
  }

References oomph::DistributableLinearAlgebraObject::build_distribution(), clean_up_memory(), oomph::TrilinosEpetraHelpers::create_distributed_epetra_matrix(), oomph::DistributableLinearAlgebraObject::distribution_pt(), Epetra_matrix_pt, oomph::Preconditioner::matrix_pt(), oomph::DoubleMatrixBase::ncol(), oomph::DistributableLinearAlgebraObject::nrow(), oomph::DoubleMatrixBase::nrow(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and setup_trilinos_preconditioner().

Referenced by oomph::TrilinosAztecOOSolver::solver_setup().

setup() [2/2]

void oomph::TrilinosPreconditionerBase::setup

(

Epetra_CrsMatrix *

epetra_matrix_pt

)

Function to setup a preconditioner for the linear system defined by the oomph-lib oomph_matrix_pt and Epetra epetra_matrix_pt matrices. This method is called by Trilinos solvers.

  {
    // clean up old data
    clean_up_memory();
 
    // first try CRDoubleMatrix
    CRDoubleMatrix* cr_matrix_pt = dynamic_cast<CRDoubleMatrix*>(matrix_pt());
    if (cr_matrix_pt == 0)
    {
      std::ostringstream error_message;
      error_message << "TrilinosSolver only work with "
                    << "DistributedCRDoubleMatrix matrices" << std::endl;
      throw OomphLibError(
        error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
 
    // setup the specific preconditioner
    setup_trilinos_preconditioner(epetra_matrix_pt);
  }

References clean_up_memory(), oomph::Preconditioner::matrix_pt(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and setup_trilinos_preconditioner().

setup_trilinos_preconditioner()

virtual void oomph::TrilinosPreconditionerBase::setup_trilinos_preconditioner ( Epetra_CrsMatrix *  epetra_matrix_pt )

protectedpure virtual

Function to set up a specific Trilinos preconditioner. This is called by setup(...).

Implemented in oomph::TrilinosIFPACKPreconditioner, and oomph::TrilinosMLPreconditioner.

Referenced by setup().

Member Data Documentation

Cumulative_preconditioner_solve_time

double oomph::TrilinosPreconditionerBase::Cumulative_preconditioner_solve_time = 0.0

static

Static double that accumulates the preconditioner solve time of all instantiations of this class. Reset it manually, e.g. after every Newton solve.

//////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// Static double that accumulates the preconditioner solve time of all instantiations of this class. Reset it manually, e.g. after every Newton solve.

Referenced by preconditioner_solve().

Epetra_matrix_pt

Epetra_CrsMatrix* oomph::TrilinosPreconditionerBase::Epetra_matrix_pt

protected

Pointer used to store the epetra matrix - only used when this preconditioner is setup using the oomph-lib interface

Referenced by clean_up_memory(), setup(), and TrilinosPreconditionerBase().

Epetra_preconditioner_pt

Epetra_Operator* oomph::TrilinosPreconditionerBase::Epetra_preconditioner_pt

protected

The preconditioner which will be set up using function setup_trilinos_preconditioner(...)

Referenced by clean_up_memory(), epetra_operator_pt(), preconditioner_solve(), oomph::TrilinosMLPreconditioner::setup_trilinos_preconditioner(), oomph::TrilinosIFPACKPreconditioner::setup_trilinos_preconditioner(), and TrilinosPreconditionerBase().

---

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

• trilinos_preconditioners.h
• trilinos_preconditioners.cc