#include <general_purpose_space_time_subsidiary_block_preconditioner.h>

Inheritance diagram for oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner:

Public Member Functions
	SpaceTimeNavierStokesSubsidiaryPreconditioner ()
	Constructor. (By default this preconditioner is upper triangular). More...

virtual	~SpaceTimeNavierStokesSubsidiaryPreconditioner ()
	Destructor - delete the preconditioner matrices. More...

virtual void	clean_up_memory ()
	Clean up the memory. More...

	SpaceTimeNavierStokesSubsidiaryPreconditioner (const SpaceTimeNavierStokesSubsidiaryPreconditioner &)=delete
	Broken copy constructor. More...

void	operator= (const SpaceTimeNavierStokesSubsidiaryPreconditioner &)=delete
	Broken assignment operator. More...

void	setup ()
	Setup the preconditioner. More...

void	preconditioner_solve (const DoubleVector &r, DoubleVector &z)
	Apply preconditioner to r. More...

void	enable_doc_memory_usage ()
	Document the memory usage. More...

void	disable_doc_memory_usage ()
	Don't document the memory usage! More...

double	get_memory_usage_in_bytes ()
	Get the memory statistics. More...

	SpaceTimeNavierStokesSubsidiaryPreconditioner ()
	Constructor. (By default this preconditioner is upper triangular). More...

virtual	~SpaceTimeNavierStokesSubsidiaryPreconditioner ()
	Destructor - delete the preconditioner matrices. More...

virtual void	clean_up_memory ()
	Clean up the memory. More...

	SpaceTimeNavierStokesSubsidiaryPreconditioner (const SpaceTimeNavierStokesSubsidiaryPreconditioner &)=delete
	Broken copy constructor. More...

void	operator= (const SpaceTimeNavierStokesSubsidiaryPreconditioner &)=delete
	Broken assignment operator. More...

void	setup ()
	Setup the preconditioner. More...

void	preconditioner_solve (const DoubleVector &r, DoubleVector &z)
	Apply preconditioner to r. More...

void	enable_doc_memory_usage ()
	Document the memory usage. More...

void	disable_doc_memory_usage ()
	Don't document the memory usage! More...

double	get_memory_usage_in_bytes ()
	Get the memory statistics. More...

void	setup (DoubleMatrixBase *matrix_pt)

void	setup (const Problem problem_pt, DoubleMatrixBase matrix_pt)

virtual void	setup ()=0

void	setup (DoubleMatrixBase *matrix_pt)

void	setup (const Problem problem_pt, DoubleMatrixBase matrix_pt)

virtual void	setup ()=0

Public Member Functions inherited from oomph::BlockPreconditioner< CRDoubleMatrix >
	BlockPreconditioner ()
	Constructor. More...

	BlockPreconditioner (const BlockPreconditioner &)=delete
	Broken copy constructor. More...

virtual	~BlockPreconditioner ()
	Destructor. More...

void	operator= (const BlockPreconditioner &)=delete
	Broken assignment operator. More...

CRDoubleMatrix *	matrix_pt () const

void	turn_on_recursive_debug_flag ()

void	turn_off_recursive_debug_flag ()

void	turn_on_debug_flag ()
	Toggles on the debug flag. More...

void	turn_off_debug_flag ()
	Toggles off the debug flag. More...

void	turn_into_subsidiary_block_preconditioner (BlockPreconditioner< CRDoubleMatrix > *master_block_prec_pt, const Vector< unsigned > &doftype_in_master_preconditioner_coarse)

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)

virtual void	block_setup ()

void	block_setup (const Vector< unsigned > &dof_to_block_map)

void	get_block (const unsigned &i, const unsigned &j, CRDoubleMatrix &output_matrix, const bool &ignore_replacement_block=false) const

CRDoubleMatrix	get_block (const unsigned &i, const unsigned &j, const bool &ignore_replacement_block=false) const

void	set_master_matrix_pt (CRDoubleMatrix *in_matrix_pt)
	Set the matrix_pt in the upper-most master preconditioner. More...

void	get_block_other_matrix (const unsigned &i, const unsigned &j, CRDoubleMatrix *in_matrix_pt, CRDoubleMatrix &output_matrix)

void	get_blocks (DenseMatrix< bool > &required_blocks, DenseMatrix< CRDoubleMatrix * > &block_matrix_pt) const

void	get_dof_level_block (const unsigned &i, const unsigned &j, CRDoubleMatrix &output_block, const bool &ignore_replacement_block=false) const

void	get_dof_level_block (const unsigned &block_i, const unsigned &block_j, CRDoubleMatrix &output_block, const bool &ignore_replacement_block) const

CRDoubleMatrix	get_concatenated_block (const VectorMatrix< BlockSelector > &selected_block)

void	get_concatenated_block_vector (const Vector< unsigned > &block_vec_number, const DoubleVector &v, DoubleVector &b)

void	return_concatenated_block_vector (const Vector< unsigned > &block_vec_number, const DoubleVector &b, DoubleVector &v) const
	Takes concatenated block ordered vector, b, and copies its. More...

void	get_block_vectors (const Vector< unsigned > &block_vec_number, const DoubleVector &v, Vector< DoubleVector > &s) const

void	get_block_vectors (const DoubleVector &v, Vector< DoubleVector > &s) const

void	return_block_vectors (const Vector< unsigned > &block_vec_number, const Vector< DoubleVector > &s, DoubleVector &v) const

void	return_block_vectors (const Vector< DoubleVector > &s, DoubleVector &v) const

void	get_block_vector (const unsigned &n, const DoubleVector &v, DoubleVector &b) const

void	return_block_vector (const unsigned &n, const DoubleVector &b, DoubleVector &v) const

void	get_block_ordered_preconditioner_vector (const DoubleVector &v, DoubleVector &w)

void	return_block_ordered_preconditioner_vector (const DoubleVector &w, DoubleVector &v) const

unsigned	nblock_types () const
	Return the number of block types. More...

unsigned	ndof_types () const
	Return the total number of DOF types. More...

const Mesh *	mesh_pt (const unsigned &i) const

unsigned	nmesh () const

int	block_number (const unsigned &i_dof) const
	Return the block number corresponding to a global index i_dof. More...

int	index_in_block (const unsigned &i_dof) const

const LinearAlgebraDistribution *	block_distribution_pt (const unsigned &b) const
	Access function to the block distributions (const version). More...

LinearAlgebraDistribution *	block_distribution_pt (const unsigned b)
	Access function to the block distributions (non-const version). More...

LinearAlgebraDistribution *	dof_block_distribution_pt (const unsigned &b)
	Access function to the dof-level block distributions. More...

const LinearAlgebraDistribution *	master_distribution_pt () const

unsigned	ndof_types_in_mesh (const unsigned &i) const

bool	is_subsidiary_block_preconditioner () const

bool	is_master_block_preconditioner () const

void	set_block_output_to_files (const std::string &basefilename)

void	disable_block_output_to_files ()
	Turn off output of blocks (by clearing the basefilename string). More...

bool	block_output_on () const
	Test if output of blocks is on or not. More...

void	output_blocks_to_files (const std::string &basefilename, const unsigned &precision=8) const

void	post_block_matrix_assembly_partial_clear ()

BlockPreconditioner< CRDoubleMatrix > *	master_block_preconditioner_pt () const
	Access function to the master block preconditioner pt. More...

void	clear_block_preconditioner_base ()

void	document ()

Vector< Vector< unsigned > >	doftype_coarsen_map_fine () const

Vector< unsigned >	get_fine_grain_dof_types_in (const unsigned &i) const

unsigned	nfine_grain_dof_types_in (const unsigned &i) const

MapMatrix< unsigned, CRDoubleMatrix * >	replacement_dof_block_pt () const
	Access function to the replaced dof-level blocks. More...

void	setup_matrix_vector_product (MatrixVectorProduct matvec_prod_pt, CRDoubleMatrix block_pt, const Vector< unsigned > &block_col_indices)

void	setup_matrix_vector_product (MatrixVectorProduct matvec_prod_pt, CRDoubleMatrix block_pt, const unsigned &block_col_index)

void	internal_get_block_ordered_preconditioner_vector (const DoubleVector &v, DoubleVector &w) const

void	internal_return_block_ordered_preconditioner_vector (const DoubleVector &w, DoubleVector &v) const

unsigned	internal_nblock_types () const

unsigned	internal_ndof_types () const

void	internal_return_block_vector (const unsigned &n, const DoubleVector &b, DoubleVector &v) const

void	internal_get_block_vector (const unsigned &n, const DoubleVector &v, DoubleVector &b) const

void	internal_get_block_vectors (const Vector< unsigned > &block_vec_number, const DoubleVector &v, Vector< DoubleVector > &s) const

void	internal_get_block_vectors (const DoubleVector &v, Vector< DoubleVector > &s) const

void	internal_return_block_vectors (const Vector< unsigned > &block_vec_number, const Vector< DoubleVector > &s, DoubleVector &v) const

void	internal_return_block_vectors (const Vector< DoubleVector > &s, DoubleVector &v) const

void	internal_get_block (const unsigned &i, const unsigned &j, CRDoubleMatrix &output_block) const

void	internal_get_block (const unsigned &block_i, const unsigned &block_j, CRDoubleMatrix &output_block) const

int	internal_block_number (const unsigned &i_dof) const

int	internal_index_in_block (const unsigned &i_dof) const

const LinearAlgebraDistribution *	internal_block_distribution_pt (const unsigned &b) const
	Access function to the internal block distributions. More...

void	insert_auxiliary_block_distribution (const Vector< unsigned > &block_vec_number, LinearAlgebraDistribution *dist_pt)

void	block_matrix_test (const unsigned &i, const unsigned &j, const CRDoubleMatrix *block_matrix_pt) const

int	get_index_of_value (const Vector< myType > &vec, const myType val, const bool sorted=false) 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 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)

Private Attributes
Preconditioner *	F_preconditioner_pt
	Pointer to the 'preconditioner' for the F matrix. More...

Preconditioner *	P_preconditioner_pt
	Pointer to the 'preconditioner' for the pressure matrix. More...

bool	Using_default_f_preconditioner
	Flag indicating whether the default F preconditioner is used. More...

bool	Using_default_p_preconditioner
	Flag indicating whether the default P preconditioner is used. More...

bool	Preconditioner_has_been_setup

bool	Compute_memory_statistics

double	Memory_usage_in_bytes

MatrixVectorProduct *	F_mat_vec_pt
	MatrixVectorProduct operator for F. More...

MatrixVectorProduct *	G_mat_vec_pt
	MatrixVectorProduct operator for G. More...

Additional Inherited Members
Protected Member Functions inherited from oomph::BlockPreconditioner< CRDoubleMatrix >
void	set_nmesh (const unsigned &n)

void	set_mesh (const unsigned &i, const Mesh *const mesh_pt, const bool &allow_multiple_element_type_in_mesh=false)

void	set_replacement_dof_block (const unsigned &block_i, const unsigned &block_j, CRDoubleMatrix *replacement_dof_block_pt)

bool	any_mesh_distributed () const

int	internal_dof_number (const unsigned &i_dof) const

unsigned	internal_index_in_dof (const unsigned &i_dof) const

unsigned	internal_block_dimension (const unsigned &b) const

unsigned	internal_dof_block_dimension (const unsigned &i) const

unsigned	master_nrow () const

unsigned	internal_master_dof_number (const unsigned &b) const

const LinearAlgebraDistribution *	internal_preconditioner_matrix_distribution_pt () const

const LinearAlgebraDistribution *	preconditioner_matrix_distribution_pt () const

Protected Member Functions inherited from oomph::DistributableLinearAlgebraObject
void	clear_distribution ()

Protected Attributes inherited from oomph::BlockPreconditioner< CRDoubleMatrix >
MapMatrix< unsigned, CRDoubleMatrix * >	Replacement_dof_block_pt
	The replacement dof-level blocks. More...

Vector< LinearAlgebraDistribution * >	Block_distribution_pt
	The distribution for the blocks. More...

Vector< Vector< unsigned > >	Block_to_dof_map_coarse

Vector< Vector< unsigned > >	Block_to_dof_map_fine
	Mapping for the block types to the most fine grain dof types. More...

Vector< Vector< unsigned > >	Doftype_coarsen_map_coarse

Vector< Vector< unsigned > >	Doftype_coarsen_map_fine

Vector< LinearAlgebraDistribution * >	Internal_block_distribution_pt
	Storage for the default distribution for each internal block. More...

Vector< LinearAlgebraDistribution * >	Dof_block_distribution_pt

Vector< unsigned >	Allow_multiple_element_type_in_mesh

Vector< const Mesh * >	Mesh_pt

Vector< unsigned >	Ndof_types_in_mesh

unsigned	Internal_nblock_types

unsigned	Internal_ndof_types

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

General purpose block triangular preconditioner. By default this is Upper triangular. Also, by default SuperLUPreconditioner (or SuperLUDistPreconditioner) is used to solve the subsidiary systems, but other preconditioners can be used by setting them using passing a pointer to a function of type SubsidiaryPreconditionerFctPt to the method subsidiary_preconditioner_function_pt().

Constructor & Destructor Documentation

◆ SpaceTimeNavierStokesSubsidiaryPreconditioner() [1/4]

oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::SpaceTimeNavierStokesSubsidiaryPreconditioner ( )

inline

Constructor. (By default this preconditioner is upper triangular).

       : BlockPreconditioner<CRDoubleMatrix>()
     {
       // By default, don't store the memory statistics of this preconditioner
       Compute_memory_statistics = false;
  
       // Initialise the value of Memory_usage_in_bytes
       Memory_usage_in_bytes = 0.0;
  
       // Flag to indicate that the preconditioner has been setup
       // previously -- if setup() is called again, data can
       // be wiped.
       Preconditioner_has_been_setup = false;
  
       // By default we use SuperLU for both p and f blocks
       Using_default_p_preconditioner = true;
       Using_default_f_preconditioner = true;
  
       // Set default preconditioners (inexact solvers) -- they are
       // members of this class!
       P_preconditioner_pt = 0;
       F_preconditioner_pt = 0;
  
       // Null the momentum block matrix-vector product helper
       F_mat_vec_pt = 0;
  
       // Null the gradient block matrix-vector product helper
       G_mat_vec_pt = 0;
     }

References Compute_memory_statistics, F_mat_vec_pt, F_preconditioner_pt, G_mat_vec_pt, Memory_usage_in_bytes, P_preconditioner_pt, Preconditioner_has_been_setup, Using_default_f_preconditioner, and Using_default_p_preconditioner.

◆ ~SpaceTimeNavierStokesSubsidiaryPreconditioner() [1/2]

virtual oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::~SpaceTimeNavierStokesSubsidiaryPreconditioner ( )

inlinevirtual

Destructor - delete the preconditioner matrices.

     {
       // Call the auxiliary clean up function
       this->clean_up_memory();
     } // End of ~SpaceTimeNavierStokesSubsidiaryPreconditioner

References clean_up_memory().

◆ SpaceTimeNavierStokesSubsidiaryPreconditioner() [2/4]

oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::SpaceTimeNavierStokesSubsidiaryPreconditioner ( const SpaceTimeNavierStokesSubsidiaryPreconditioner & )

delete

Broken copy constructor.

◆ SpaceTimeNavierStokesSubsidiaryPreconditioner() [3/4]

oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::SpaceTimeNavierStokesSubsidiaryPreconditioner ( )

inline

Constructor. (By default this preconditioner is upper triangular).

       : BlockPreconditioner<CRDoubleMatrix>()
     {
       // By default, don't store the memory statistics of this preconditioner
       Compute_memory_statistics = false;
  
       // Initialise the value of Memory_usage_in_bytes
       Memory_usage_in_bytes = 0.0;
  
       // Flag to indicate that the preconditioner has been setup
       // previously -- if setup() is called again, data can
       // be wiped.
       Preconditioner_has_been_setup = false;
  
       // By default we use SuperLU for both p and f blocks
       Using_default_p_preconditioner = true;
       Using_default_f_preconditioner = true;
  
       // Set default preconditioners (inexact solvers) -- they are
       // members of this class!
       P_preconditioner_pt = 0;
       F_preconditioner_pt = 0;
  
       // Null the momentum block matrix-vector product helper
       F_mat_vec_pt = 0;
  
       // Null the gradient block matrix-vector product helper
       G_mat_vec_pt = 0;
     }

References Compute_memory_statistics, F_mat_vec_pt, F_preconditioner_pt, G_mat_vec_pt, Memory_usage_in_bytes, P_preconditioner_pt, Preconditioner_has_been_setup, Using_default_f_preconditioner, and Using_default_p_preconditioner.

◆ ~SpaceTimeNavierStokesSubsidiaryPreconditioner() [2/2]

virtual oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::~SpaceTimeNavierStokesSubsidiaryPreconditioner ( )

inlinevirtual

Destructor - delete the preconditioner matrices.

     {
       // Call the auxiliary clean up function
       this->clean_up_memory();
     } // End of ~SpaceTimeNavierStokesSubsidiaryPreconditioner

References clean_up_memory().

◆ SpaceTimeNavierStokesSubsidiaryPreconditioner() [4/4]

oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::SpaceTimeNavierStokesSubsidiaryPreconditioner ( const SpaceTimeNavierStokesSubsidiaryPreconditioner & )

delete

Broken copy constructor.

Member Function Documentation

◆ clean_up_memory() [1/2]

virtual void oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::clean_up_memory ( )

inlinevirtual

Clean up the memory.

Reimplemented from oomph::Preconditioner.

     {
       // If we've actually set the preconditioner up
       if (Preconditioner_has_been_setup)
       {
         // Delete matvecs
         delete F_mat_vec_pt;
         F_mat_vec_pt = 0;
  
         delete G_mat_vec_pt;
         G_mat_vec_pt = 0;
  
         // Delete the momentum block solver
         delete F_preconditioner_pt;
         F_preconditioner_pt = 0;
  
         // Delete the Schur complement solver
         delete P_preconditioner_pt;
         P_preconditioner_pt = 0;
       } // if (Preconditioner_has_been_setup)
     } // End of clean_up_memory

References F_mat_vec_pt, F_preconditioner_pt, G_mat_vec_pt, P_preconditioner_pt, and Preconditioner_has_been_setup.

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

◆ clean_up_memory() [2/2]

virtual void oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::clean_up_memory ( )

inlinevirtual

Clean up the memory.

Reimplemented from oomph::Preconditioner.

     {
       // If we've actually set the preconditioner up
       if (Preconditioner_has_been_setup)
       {
         // Delete matvecs
         delete F_mat_vec_pt;
         F_mat_vec_pt = 0;
  
         delete G_mat_vec_pt;
         G_mat_vec_pt = 0;
  
         // Delete stuff from velocity solve
         if (Using_default_f_preconditioner)
         {
           delete F_preconditioner_pt;
           F_preconditioner_pt = 0;
         }
  
         // Delete stuff from Schur complement approx
         if (Using_default_p_preconditioner)
         {
           delete P_preconditioner_pt;
           P_preconditioner_pt = 0;
         }
       } // if (Preconditioner_has_been_setup)
     } // End of clean_up_memory

References F_mat_vec_pt, F_preconditioner_pt, G_mat_vec_pt, P_preconditioner_pt, Preconditioner_has_been_setup, Using_default_f_preconditioner, and Using_default_p_preconditioner.

◆ disable_doc_memory_usage() [1/2]

void oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::disable_doc_memory_usage ( )

inline

Don't document the memory usage!

Set the appropriate flag to false

     {
       Compute_memory_statistics = false;
     } // End of disable_doc_memory_usage

References Compute_memory_statistics.

◆ disable_doc_memory_usage() [2/2]

void oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::disable_doc_memory_usage ( )

inline

Don't document the memory usage!

Set the appropriate flag to false

     {
       Compute_memory_statistics = false;
     } // End of disable_doc_memory_usage

References Compute_memory_statistics.

◆ enable_doc_memory_usage() [1/2]

void oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::enable_doc_memory_usage ( )

inline

Document the memory usage.

Set the appropriate flag to true

     {
       Compute_memory_statistics = true;
     } // End of enable_doc_memory_usage

References Compute_memory_statistics.

Referenced by oomph::GMRESBlockPreconditioner::setup().

◆ enable_doc_memory_usage() [2/2]

void oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::enable_doc_memory_usage ( )

inline

Document the memory usage.

Set the appropriate flag to true

     {
       Compute_memory_statistics = true;
     } // End of enable_doc_memory_usage

References Compute_memory_statistics.

◆ get_memory_usage_in_bytes() [1/2]

double oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::get_memory_usage_in_bytes ( )

inline

Get the memory statistics.

     {
       // Has the preconditioner even been set up yet?
       if (Preconditioner_has_been_setup)
       {
         // Were we meant to compute the statistics?
         if (Compute_memory_statistics)
         {
           // Return the appropriate variable value
           return Memory_usage_in_bytes;
         }
         else
         {
           // Allocate storage for an output stream
           std::ostringstream warning_message_stream;
  
           // Create a warning message
           warning_message_stream
             << "The memory statistics have not been calculated "
             << "so I'm returning\nthe value zero." << std::endl;
  
           // Give the user a warning
           OomphLibWarning(warning_message_stream.str(),
                           OOMPH_CURRENT_FUNCTION,
                           OOMPH_EXCEPTION_LOCATION);
  
           // Return the value zero
           return 0.0;
         }
       }
       // If the preconditioner hasn't been set up yet
       else
       {
         // Allocate storage for an output stream
         std::ostringstream warning_message_stream;
  
         // Create a warning message
         warning_message_stream
           << "The preconditioner hasn't even been set up yet "
           << "so I'm returning\nthe value zero." << std::endl;
  
         // Give the user a warning
         OomphLibWarning(warning_message_stream.str(),
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
  
         // Return the value zero
         return 0.0;
       } // if (Preconditioner_has_been_setup)
     } // End of get_memory_usage_in_bytes

References Compute_memory_statistics, Memory_usage_in_bytes, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and Preconditioner_has_been_setup.

Referenced by oomph::BandedBlockTriangularPreconditioner< MATRIX >::setup().

◆ get_memory_usage_in_bytes() [2/2]

double oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::get_memory_usage_in_bytes ( )

inline

Get the memory statistics.

     {
       // Has the preconditioner even been set up yet?
       if (Preconditioner_has_been_setup)
       {
         // Were we meant to compute the statistics?
         if (Compute_memory_statistics)
         {
           // Return the appropriate variable value
           return Memory_usage_in_bytes;
         }
         else
         {
           // Allocate storage for an output stream
           std::ostringstream warning_message_stream;
  
           // Create a warning message
           warning_message_stream
             << "The memory statistics have not been calculated "
             << "so I'm returning\nthe value zero." << std::endl;
  
           // Give the user a warning
           OomphLibWarning(warning_message_stream.str(),
                           OOMPH_CURRENT_FUNCTION,
                           OOMPH_EXCEPTION_LOCATION);
  
           // Return the value zero
           return 0.0;
         }
       }
       // If the preconditioner hasn't been set up yet
       else
       {
         // Allocate storage for an output stream
         std::ostringstream warning_message_stream;
  
         // Create a warning message
         warning_message_stream
           << "The preconditioner hasn't even been set up yet "
           << "so I'm returning\nthe value zero." << std::endl;
  
         // Give the user a warning
         OomphLibWarning(warning_message_stream.str(),
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
  
         // Return the value zero
         return 0.0;
       } // if (Preconditioner_has_been_setup)
     } // End of get_memory_usage_in_bytes

References Compute_memory_statistics, Memory_usage_in_bytes, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and Preconditioner_has_been_setup.

◆ operator=() [1/2]

void oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::operator= ( const SpaceTimeNavierStokesSubsidiaryPreconditioner & )

delete

Broken assignment operator.

◆ operator=() [2/2]

void oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::operator= ( const SpaceTimeNavierStokesSubsidiaryPreconditioner & )

delete

Broken assignment operator.

◆ preconditioner_solve() [1/2]

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

virtual

Apply preconditioner to r.

Preconditioner solve for the block triangular preconditioner.

Implements oomph::Preconditioner.

   {
     // If z is not set up then give it the same distribution
     if (!z.distribution_pt()->built())
     {
       // Build z with the same distribution as r
       z.build(r.distribution_pt(), 0.0);
     }
  
     // -----------------------------------------------------------------------
     // Step 1 - apply approximate Schur inverse to pressure unknowns (block 1)
     // -----------------------------------------------------------------------
     // First working vectors
     DoubleVector temp_vec;
  
     // Second working vector
     DoubleVector another_temp_vec;
  
     // Copy pressure values from residual vector to temp_vec:
     // Loop over all entries in the global vector (this one
     // includes velocity and pressure dofs in some random fashion)
     this->get_block_vector(1, r, temp_vec);
  
     // Compute the vector P^{-1}r_p
     P_preconditioner_pt->preconditioner_solve(temp_vec, another_temp_vec);
  
     // Now clear the vector storing r_p
     temp_vec.clear();
  
     // Now compute G(P^{-1}r_p)
     G_mat_vec_pt->multiply(another_temp_vec, temp_vec);
  
     // Clear the vector storing P^{-1}r_p
     another_temp_vec.clear();
  
     // Now update to get F(GP^{-1}r_p)
     F_mat_vec_pt->multiply(temp_vec, another_temp_vec);
  
     // Clear the vector storing GP^{-1}r_p
     temp_vec.clear();
  
     // Now compute D(FGP^{-1}r_p)=G^{T}(FGP^{-1}r_p)
     G_mat_vec_pt->multiply_transpose(another_temp_vec, temp_vec);
  
     // Clear the vector storing FGP^{-1}r_p
     another_temp_vec.clear();
  
     // Finally, compute the full approximation to -z_p;
     // -z_p=P^{-1}(DFG)P^{-1}r_p NOTE: We'll move the sign over in the next step
     P_preconditioner_pt->preconditioner_solve(temp_vec, another_temp_vec);
  
     // Rebuild temp_vec with another_temp_vec's distribution with all
     // entries initialised to zero
     temp_vec.build(another_temp_vec.distribution_pt(), 0.0);
  
     // Now fix the sign and store the result in temp_vec
     temp_vec -= another_temp_vec;
  
     // Now copy temp_vec (i.e. z_p) back into the global vector z
     return_block_vector(1, temp_vec, z);
  
     // ------------------------------------------------------------
     // Step 2 - apply preconditioner to velocity unknowns (block 0)
     // ------------------------------------------------------------
     // Clear the vector storing z_p=-P^{-1}(DFG)P^{-1}r_p
     temp_vec.clear();
  
     // Recall that another_temp_vec (computed above) contains the negative
     // of the solution of the Schur complement system, -z_p. Multiply by G
     // and store the result in temp_vec (vector resizes itself).
     G_mat_vec_pt->multiply(another_temp_vec, temp_vec);
  
     // Now clear the vector storing P^{-1}(DFG)P^{-1}r_p
     another_temp_vec.clear();
  
     // Get the residual vector entries associated with the velocities, r_u
     get_block_vector(0, r, another_temp_vec);
  
     // Update the result to get r_u-Gz_p
     another_temp_vec += temp_vec;
  
     // Compute the solution z_u which satisfies z_u=F^{-1}(r_u-Gz_p)
     F_preconditioner_pt->preconditioner_solve(another_temp_vec, temp_vec);
  
     // Now store the result in the global solution vector
     return_block_vector(0, temp_vec, z);
   } // End of preconditioner_solve

References oomph::DoubleVector::build(), oomph::LinearAlgebraDistribution::built(), oomph::DoubleVector::clear(), oomph::DistributableLinearAlgebraObject::distribution_pt(), F_mat_vec_pt, F_preconditioner_pt, G_mat_vec_pt, oomph::BlockPreconditioner< CRDoubleMatrix >::get_block_vector(), oomph::MatrixVectorProduct::multiply(), oomph::MatrixVectorProduct::multiply_transpose(), P_preconditioner_pt, oomph::Preconditioner::preconditioner_solve(), UniformPSDSelfTest::r, and oomph::BlockPreconditioner< CRDoubleMatrix >::return_block_vector().

Referenced by oomph::GMRESBlockPreconditioner::preconditioner_solve(), and oomph::GMRESBlockPreconditioner::update().

◆ preconditioner_solve() [2/2]

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

virtual

Apply preconditioner to r.

Implements oomph::Preconditioner.

◆ setup() [1/8]

void oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::setup ( )

virtual

Setup the preconditioner.

Setup for the block triangular preconditioner.

///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////

Implements oomph::Preconditioner.

   {
     // For debugging...
     bool doc_block_matrices = false;
  
     // Clean up any previously created data
     clean_up_memory();
  
     // If we're meant to build silently
     if (this->Silent_preconditioner_setup == true)
     {
       // Store the output stream pointer
       this->Stream_pt = oomph_info.stream_pt();
  
       // Now set the oomph_info stream pointer to the null stream to
       // disable all possible output
       oomph_info.stream_pt() = &oomph_nullstream;
     }
  
 #ifdef PARANOID
     // If the upcast was unsuccessful
     if (dynamic_cast<CRDoubleMatrix*>(this->matrix_pt()) == 0)
     {
       // Allocate space for an error message
       std::ostringstream error_message;
  
       // Create the error message
       error_message << "NavierStokesSchurComplementPreconditioner only works "
                     << "with CRDoubleMatrix matrices" << std::endl;
  
       // Throw the error message
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // Start the timer for the block setup
     double t_block_setup_start = TimingHelpers::timer();
  
     // Set up block look up schemes (done automatically in the
     // BlockPreconditioner base class, based on the information
     // provided in the block-preconditionable elements in the problem)
  
     // This preconditioner has two types of block:
     //        Type 0: Velocity - Corresponding to DOF type 0 & 1
     //        Type 1: Pressure - Corresponding to DOF type 2
     unsigned n_dof_types = 0;
  
     // If this has been set up as a subsidiary preconditioner
     if (this->is_subsidiary_block_preconditioner())
     {
       // Get the number of dof types (will be told by the master preconditioner)
       n_dof_types = this->ndof_types();
  
       // DRAIG: Delete
       oomph_info << "Number of dof types: " << n_dof_types << std::endl;
  
       // Make sure there's only 3 dof types for now!
       if (n_dof_types != 3)
       {
         // Allocate space for an error message
         std::ostringstream error_message;
  
         // Create the error message
         error_message << "Should only be 3 dof types! You have " << n_dof_types
                       << " dof types!" << std::endl;
  
         // Throw an error
         throw OomphLibError(error_message.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
     }
     else
     {
       // Throw an error
       throw OomphLibError("Can only be used as a subsidiary preconditioner!",
                           OOMPH_CURRENT_FUNCTION,
                           OOMPH_EXCEPTION_LOCATION);
     } // if (this->is_subsidiary_block_preconditioner())
  
     // Allocate storage for the dof-to-block mapping
     Vector<unsigned> dof_to_block_map(n_dof_types);
  
     // The last dof type (the pressure) should have it's own block type
     dof_to_block_map[n_dof_types - 1] = 1;
  
     // Call the generic block setup function
     this->block_setup(dof_to_block_map);
  
     // Stop the timer
     double t_block_setup_finish = TimingHelpers::timer();
  
     // Calculate the time difference
     double block_setup_time = t_block_setup_finish - t_block_setup_start;
  
     // Document the time taken
     oomph_info << "Time for block_setup(...) [sec]: " << block_setup_time
                << std::endl;
  
     // Get the number of block types
     unsigned n_block_type = this->nblock_types();
  
     // How many block types are there? Should only be 2...
     oomph_info << "Number of block types: " << n_block_type << std::endl;
  
     // Allocate storage for the momentum block
     CRDoubleMatrix* f_pt = new CRDoubleMatrix;
  
     // Allocate storage for the divergence block
     CRDoubleMatrix* d_pt = new CRDoubleMatrix;
  
     // Allocate storage for the gradient block
     CRDoubleMatrix* g_pt = new CRDoubleMatrix;
  
     // Allocate storage for the pressure Poisson matrix
     CRDoubleMatrix* p_matrix_pt = new CRDoubleMatrix;
  
     // Get the momentum block F
     this->get_block(0, 0, *f_pt);
  
     // Get the divergence block, D
     this->get_block(1, 0, *d_pt);
  
     // Get gradient matrix, G=D^T
     this->get_block(0, 1, *g_pt);
  
     // Calculate the pressure Poisson-like matrix
     d_pt->multiply(*g_pt, *p_matrix_pt);
  
     // If the user wants the block matrices themselves
     if (doc_block_matrices)
     {
       // Filename suffix (defaults should be an empty string)
       std::string suffix = "";
  
       // Create space for all of the blocks
       DenseMatrix<CRDoubleMatrix*> block_matrix_pt(
         n_block_type, n_block_type, 0);
  
       // Loop over the block rows
       for (unsigned i = 0; i < n_block_type; i++)
       {
         // Loop over the block columns
         for (unsigned j = 0; j < n_block_type; j++)
         {
           // Allocate space for the matrix
           block_matrix_pt(i, j) = new CRDoubleMatrix;
  
           // Get the block
           this->get_block(i, j, *block_matrix_pt(i, j));
         }
       } // for (unsigned i=0;i<n_block_type;i++)
  
       // Space for the full matrix
       CRDoubleMatrix* j_pt = new CRDoubleMatrix;
  
       // Concatenate the sub-blocks to get the full matrix
       CRDoubleMatrixHelpers::concatenate(block_matrix_pt, *j_pt);
  
       // Output the matrix in MATLAB form
       j_pt->sparse_indexed_output_with_offset("j_" + suffix + ".csv");
  
       // Tell the user
       oomph_info << "Done output of j_" + suffix + ".csv" << std::endl;
  
       // Loop over the block rows
       for (unsigned i = 0; i < n_block_type; i++)
       {
         // Loop over the block columns
         for (unsigned j = 0; j < n_block_type; j++)
         {
           // Clear up this block
           delete block_matrix_pt(i, j);
  
           // Make it a null pointer
           block_matrix_pt(i, j) = 0;
         }
       } // for (unsigned i=0;i<n_block_type;i++)
  
       // Now clear up j_pt
       delete j_pt;
  
       // Make it a null pointer
       j_pt = 0;
  
       // Output the matrix in MATLAB form
       f_pt->sparse_indexed_output_with_offset("f_matrix" + suffix + ".dat");
  
       // Tell the user
       oomph_info << "Done output of f_matrix" + suffix + ".dat" << std::endl;
  
       // Output the matrix in MATLAB form
       d_pt->sparse_indexed_output_with_offset("d_matrix" + suffix + ".dat");
  
       // Tell the user
       oomph_info << "Done output of d_matrix" + suffix + ".dat" << std::endl;
  
       // Output the matrix in MATLAB form
       g_pt->sparse_indexed_output_with_offset("g_matrix" + suffix + ".dat");
  
       // Tell the user
       oomph_info << "Done output of g_matrix" + suffix + ".dat" << std::endl;
  
       // Output the matrix in MATLAB form
       p_matrix_pt->sparse_indexed_output_with_offset("p_matrix" + suffix +
                                                      ".dat");
  
       // Tell the user
       oomph_info << "Done output of p_matrix" + suffix + ".dat" << std::endl;
  
       // Exit
       exit(0);
     }
  
     // Kill divergence matrix because we don't need it any more
     delete d_pt;
  
     // Make it a null pointer
     d_pt = 0;
  
     // Make a new matrix-vector product
     F_mat_vec_pt = new MatrixVectorProduct;
  
     // Make a new matrix-vector product
     G_mat_vec_pt = new MatrixVectorProduct;
  
     // Set the matrix-vector product up
     this->setup_matrix_vector_product(F_mat_vec_pt, f_pt, 0);
  
     // Set the matrix-vector product up
     this->setup_matrix_vector_product(G_mat_vec_pt, g_pt, 1);
  
     // Do we need to doc. the memory statistics?
     if (Compute_memory_statistics)
     {
       // Initialise the memory usage variable
       Memory_usage_in_bytes = 0.0;
  
       // How many rows are there in the momentum block?
       unsigned n_row_f = f_pt->nrow();
  
       // How many nonzeros are there in the momentum block?
       unsigned n_nnz_f = f_pt->nnz();
  
       // Update the memory usage variable. NOTE: This calculation is done by
       // taking into account the storage scheme for a compressed row matrix
       Memory_usage_in_bytes += ((2 * ((n_row_f + 1) * sizeof(int))) +
                                 (n_nnz_f * (sizeof(int) + sizeof(double))));
  
       // How many rows are there in the gradient block?
       unsigned n_row_g = g_pt->nrow();
  
       // How many nonzeros are there in the gradient block?
       unsigned n_nnz_g = g_pt->nnz();
  
       // Update the memory usage variable
       Memory_usage_in_bytes += ((2 * ((n_row_g + 1) * sizeof(int))) +
                                 (n_nnz_g * (sizeof(int) + sizeof(double))));
     }
  
     // Kill the gradient matrix because we don't need it any more
     delete g_pt;
  
     // Make it a null pointer
     g_pt = 0;
  
 #ifdef OOMPH_HAS_HYPRE
     // Assign the preconditioner for the P block
     P_preconditioner_pt = new HyprePreconditioner;
  
     // Set parameters for use as preconditioner on Poisson-type problem
     Hypre_default_settings::set_defaults_for_2D_poisson_problem(
       static_cast<HyprePreconditioner*>(P_preconditioner_pt));
  
     // Indicate that we're not using the default preconditioner
     Using_default_p_preconditioner = false;
  
     // Assign the preconditioner for the P block
     F_preconditioner_pt = new HyprePreconditioner;
  
     // Indicate that we're not using the default preconditioner
     Using_default_f_preconditioner = false;
 #endif
  
     /*
       // Assign the preconditioner for the F block
       F_preconditioner_pt=new BlockDiagonalPreconditioner<CRDoubleMatrix>;
  
       // Number of velocity dof types
       unsigned n_velocity_dof_types=2;
  
       // Create space for the dof-to-block map
       Vector<unsigned> dof_map(n_velocity_dof_types,0);
  
       // Loop over the velocity dofs
       for (unsigned i=0;i<n_velocity_dof_types;i++)
       {
       // Seperate the velocity dofs out (by giving each component its own block)
       dof_map[i]=i;
       }
  
       // Turn it into a subsidiary preconditioner
       dynamic_cast<BlockPreconditioner<CRDoubleMatrix>*>(F_preconditioner_pt)->
       turn_into_subsidiary_block_preconditioner(this,dof_map);
  
       // Pass a pointer to the global system matrix
       F_preconditioner_pt->setup(this->matrix_pt());
     */
  
     // If the P preconditioner has not been set
     if (P_preconditioner_pt == 0)
     {
       // Just use SuperLU
       P_preconditioner_pt = new SuperLUPreconditioner;
  
       // Indicate that we're using the default preconditioner
       Using_default_p_preconditioner = true;
     } // if (P_preconditioner_pt==0)
  
     // Compute the LU decomposition of P
     P_preconditioner_pt->setup(p_matrix_pt);
  
     // If we need to document the memory statistics
     if (Compute_memory_statistics)
     {
       // If we're using SuperLU as the preconditioner
       if (Using_default_p_preconditioner)
       {
         // Add on the memory needed to store and calculate the LU factors of P
         Memory_usage_in_bytes +=
           dynamic_cast<SuperLUPreconditioner*>(P_preconditioner_pt)
             ->get_total_memory_needed_for_superlu();
       }
       // Using Hypre which just really means we just store the matrix P
       else
       {
         // How many rows are there in the momentum block?
         unsigned n_row_p = p_matrix_pt->nrow();
  
         // How many nonzeros are there in the momentum block?
         unsigned n_nnz_p = p_matrix_pt->nnz();
  
         // Update the memory usage variable. NOTE: This calculation is done by
         // taking into account the storage scheme for a compressed row matrix
         Memory_usage_in_bytes += ((2 * ((n_row_p + 1) * sizeof(int))) +
                                   (n_nnz_p * (sizeof(int) + sizeof(double))));
       }
     } // if (Compute_memory_statistics)
  
     // Now delete the actual matrix P, we don't need it anymore
     delete p_matrix_pt;
  
     // Make it a null pointer
     p_matrix_pt = 0;
  
     // If the F preconditioner has not been setup
     if (F_preconditioner_pt == 0)
     {
       // Just use SuperLU
       F_preconditioner_pt = new SuperLUPreconditioner;
  
       // Indicate that we're using the default preconditioner
       Using_default_f_preconditioner = true;
     } // if (F_preconditioner_pt==0)
  
     // Compute the LU decomposition of F
     F_preconditioner_pt->setup(f_pt);
  
     // If we need to document the memory statistics
     if (Compute_memory_statistics)
     {
       // If we're using SuperLU as the preconditioner
       if (Using_default_f_preconditioner)
       {
         // Add on the memory needed to store and calculate the LU factors of P
         Memory_usage_in_bytes +=
           dynamic_cast<SuperLUPreconditioner*>(F_preconditioner_pt)
             ->get_total_memory_needed_for_superlu();
       }
       // Using Hypre which just really means we store the matrix F (again, as
       // it is duplicated inside Hypre)
       else
       {
         // How many rows are there in the momentum block?
         unsigned n_row_f = f_pt->nrow();
  
         // How many nonzeros are there in the momentum block?
         unsigned n_nnz_f = f_pt->nnz();
  
         // Update the memory usage variable. NOTE: This calculation is done by
         // taking into account the storage scheme for a compressed row matrix
         Memory_usage_in_bytes += ((2 * ((n_row_f + 1) * sizeof(int))) +
                                   (n_nnz_f * (sizeof(int) + sizeof(double))));
       }
     } // if (Compute_memory_statistics)
  
     // Now delete the matrix, we don't need it anymore
     delete f_pt;
  
     // Make it a null pointer
     f_pt = 0;
  
     // Remember that the preconditioner has been setup so the stored
     // information can be wiped when we come here next...
     Preconditioner_has_been_setup = true;
  
     // If we're meant to build silently, reassign the oomph stream pointer
     if (this->Silent_preconditioner_setup == true)
     {
       // Store the output stream pointer
       oomph_info.stream_pt() = this->Stream_pt;
  
       // Reset our own stream pointer
       this->Stream_pt = 0;
     }
   } // End of setup

References oomph::BlockPreconditioner< CRDoubleMatrix >::block_setup(), clean_up_memory(), Compute_memory_statistics, oomph::CRDoubleMatrixHelpers::concatenate(), F_mat_vec_pt, F_preconditioner_pt, G_mat_vec_pt, oomph::BlockPreconditioner< CRDoubleMatrix >::get_block(), i, int(), oomph::BlockPreconditioner< CRDoubleMatrix >::is_subsidiary_block_preconditioner(), j, oomph::BlockPreconditioner< CRDoubleMatrix >::matrix_pt(), Memory_usage_in_bytes, oomph::CRDoubleMatrix::multiply(), oomph::BlockPreconditioner< CRDoubleMatrix >::nblock_types(), oomph::BlockPreconditioner< CRDoubleMatrix >::ndof_types(), oomph::CRDoubleMatrix::nnz(), oomph::CRDoubleMatrix::nrow(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, oomph::oomph_nullstream, P_preconditioner_pt, Preconditioner_has_been_setup, oomph::Hypre_default_settings::set_defaults_for_2D_poisson_problem(), oomph::Preconditioner::setup(), oomph::BlockPreconditioner< CRDoubleMatrix >::setup_matrix_vector_product(), oomph::Preconditioner::Silent_preconditioner_setup, oomph::CRDoubleMatrix::sparse_indexed_output_with_offset(), oomph::OomphInfo::stream_pt(), oomph::Preconditioner::Stream_pt, oomph::Global_string_for_annotation::string(), oomph::TimingHelpers::timer(), Using_default_f_preconditioner, and Using_default_p_preconditioner.

Referenced by oomph::GMRESBlockPreconditioner::setup().

◆ setup() [2/8]

void oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::setup ( )

virtual

Setup the preconditioner.

Implements oomph::Preconditioner.