#include <general_purpose_space_time_block_preconditioner.h>

Inheritance diagram for oomph::BandedBlockTriangularPreconditioner< MATRIX >:

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

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

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

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

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

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

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

void	set_block_bandwidth (const int &block_bandwidth)
	Set the block bandwidth of the preconditioner. More...

int	block_bandwidth ()
	Get the block bandwidth of the preconditioner. More...

void	upper_triangular ()
	Use as an upper triangular preconditioner. More...

void	lower_triangular ()
	Use as a lower triangular preconditioner. More...

bool	is_upper_triangular ()
	Is this being used as an upper triangular preconditioner? 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...

Public Member Functions inherited from oomph::GeneralPurposeBlockPreconditioner< MATRIX >
	GeneralPurposeBlockPreconditioner ()
	constructor More...

virtual	~GeneralPurposeBlockPreconditioner ()

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

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

void	set_subsidiary_preconditioner_function (SubsidiaryPreconditionerFctPt sub_prec_fn)
	access function to set the subsidiary preconditioner function. More...

void	reset_subsidiary_preconditioner_function_to_default ()
	Reset the subsidiary preconditioner function to its default. More...

void	set_subsidiary_preconditioner_pt (Preconditioner *prec, const unsigned &i)

Preconditioner *	subsidiary_preconditioner_pt (const unsigned &i) const

void	set_dof_to_block_map (Vector< unsigned > &dof_to_block_map)
	Specify a DOF to block map. More...

void	add_mesh (const Mesh *mesh_pt, const bool &allow_multiple_element_type_in_mesh=false)

unsigned	gp_nmesh ()

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

virtual	~BlockPreconditioner ()
	Destructor. More...

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

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

MATRIX *	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< MATRIX > *master_block_prec_pt, const Vector< unsigned > &doftype_in_master_preconditioner_coarse)

void	turn_into_subsidiary_block_preconditioner (BlockPreconditioner< MATRIX > *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, MATRIX &output_matrix, const bool &ignore_replacement_block=false) const

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

void	set_master_matrix_pt (MATRIX *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, MATRIX *in_matrix_pt, MATRIX &output_matrix)

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

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

MATRIX	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< MATRIX > *	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, MATRIX &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 MATRIX *block_matrix_pt) const

template<typename myType >
int	get_index_of_value (const Vector< myType > &vec, const myType val, const bool sorted=false) const

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

void	get_dof_level_block (const unsigned &block_i, const unsigned &block_j, CRDoubleMatrix &output_block, const bool &ignore_replacement_block) 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)

Protected Attributes
DenseMatrix< MatrixVectorProduct * >	Off_diagonal_matrix_vector_products
	Matrix of matrix-vector product operators for the off diagonals. More...

Protected Attributes inherited from oomph::GeneralPurposeBlockPreconditioner< MATRIX >
Vector< Preconditioner * >	Subsidiary_preconditioner_pt
	List of preconditioners to use for the blocks to be solved. More...

SubsidiaryPreconditionerFctPt	Subsidiary_preconditioner_creation_function_pt

Protected Attributes inherited from oomph::BlockPreconditioner< MATRIX >
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...

Private Attributes
int	Block_bandwidth

bool	Upper_triangular
	Boolean indicating upper or lower triangular. More...

bool	Preconditioner_has_been_setup

bool	Compute_memory_statistics

double	Memory_usage_in_bytes

Additional Inherited Members
Public Types inherited from oomph::GeneralPurposeBlockPreconditioner< MATRIX >
typedef Preconditioner (	SubsidiaryPreconditionerFctPt) ()

Protected Member Functions inherited from oomph::GeneralPurposeBlockPreconditioner< MATRIX >
void	gp_preconditioner_set_all_meshes ()
	Set the mesh in the block preconditioning framework. More...

void	gp_preconditioner_block_setup ()
	Modified block setup for general purpose block preconditioners. More...

void	fill_in_subsidiary_preconditioners (const unsigned &nprec_needed)

Protected Member Functions inherited from oomph::BlockPreconditioner< MATRIX >
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 ()

Detailed Description

template<typename MATRIX>
class oomph::BandedBlockTriangularPreconditioner< MATRIX >

General purpose block triangular preconditioner. By default this operates as an upper triangular preconditioner. 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

◆ BandedBlockTriangularPreconditioner() [1/2]

template<typename MATRIX >

oomph::BandedBlockTriangularPreconditioner< MATRIX >::BandedBlockTriangularPreconditioner ( )

inline

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

       : GeneralPurposeBlockPreconditioner<MATRIX>()
     {
       // Default to upper triangular
       Upper_triangular = true;
  
       // Default is to assume every block above the diagonal is non-empty
       Block_bandwidth = -1;
  
       // The preconditioner has been created but it hasn't been set up yet
       Preconditioner_has_been_setup = false;
  
       // 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;
     } // End of BandedBlockTriangularPreconditioner

References oomph::BandedBlockTriangularPreconditioner< MATRIX >::Block_bandwidth, oomph::BandedBlockTriangularPreconditioner< MATRIX >::Compute_memory_statistics, oomph::BandedBlockTriangularPreconditioner< MATRIX >::Memory_usage_in_bytes, oomph::BandedBlockTriangularPreconditioner< MATRIX >::Preconditioner_has_been_setup, and oomph::BandedBlockTriangularPreconditioner< MATRIX >::Upper_triangular.

◆ ~BandedBlockTriangularPreconditioner()

template<typename MATRIX >

virtual oomph::BandedBlockTriangularPreconditioner< MATRIX >::~BandedBlockTriangularPreconditioner ( )

inlinevirtual

Destructor - delete the preconditioner matrices.

     {
       // Forward the call to a helper clean-up function
       this->clean_up_memory();
     } // End of ~BandedBlockTriangularPreconditioner

References oomph::BandedBlockTriangularPreconditioner< MATRIX >::clean_up_memory().

◆ BandedBlockTriangularPreconditioner() [2/2]

template<typename MATRIX >

oomph::BandedBlockTriangularPreconditioner< MATRIX >::BandedBlockTriangularPreconditioner ( const BandedBlockTriangularPreconditioner< MATRIX > & )

delete

Broken copy constructor.

Member Function Documentation

◆ block_bandwidth()

template<typename MATRIX >

int oomph::BandedBlockTriangularPreconditioner< MATRIX >::block_bandwidth ( )

inline

Get the block bandwidth of the preconditioner.

     {
       // Store it
       return Block_bandwidth;
     } // End of block_bandwidth

References oomph::BandedBlockTriangularPreconditioner< MATRIX >::Block_bandwidth.

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

◆ clean_up_memory()

template<typename MATRIX >

virtual void oomph::BandedBlockTriangularPreconditioner< MATRIX >::clean_up_memory ( )

inlinevirtual

Clean up the memory.

Reimplemented from oomph::GeneralPurposeBlockPreconditioner< MATRIX >.

     {
       // Delete anything in Off_diagonal_matrix_vector_products
       for (unsigned i = 0, ni = Off_diagonal_matrix_vector_products.nrow();
            i < ni;
            i++)
       {
         for (unsigned j = 0, nj = Off_diagonal_matrix_vector_products.ncol();
              j < nj;
              j++)
         {
           // Delete the matrix-vector product
           delete Off_diagonal_matrix_vector_products(i, j);
  
           // Make it a null pointer
           Off_diagonal_matrix_vector_products(i, j) = 0;
         }
       } // for (unsigned i=0,ni=Off_diagonal_matrix_vector_products.nrow();...
  
       // Clean up the base class too
       GeneralPurposeBlockPreconditioner<MATRIX>::clean_up_memory();
     } // End of clean_up_memory

References oomph::GeneralPurposeBlockPreconditioner< MATRIX >::clean_up_memory(), i, j, and oomph::BandedBlockTriangularPreconditioner< MATRIX >::Off_diagonal_matrix_vector_products.

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

◆ disable_doc_memory_usage()

template<typename MATRIX >

void oomph::BandedBlockTriangularPreconditioner< MATRIX >::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 oomph::BandedBlockTriangularPreconditioner< MATRIX >::Compute_memory_statistics.

◆ enable_doc_memory_usage()

template<typename MATRIX >

void oomph::BandedBlockTriangularPreconditioner< MATRIX >::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 oomph::BandedBlockTriangularPreconditioner< MATRIX >::Compute_memory_statistics.

Referenced by UnsteadyHeatProblem< ELEMENT >::set_up_spacetime_solver().

◆ get_memory_usage_in_bytes()

template<typename MATRIX >

double oomph::BandedBlockTriangularPreconditioner< MATRIX >::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 oomph::BandedBlockTriangularPreconditioner< MATRIX >::Compute_memory_statistics, oomph::BandedBlockTriangularPreconditioner< MATRIX >::Memory_usage_in_bytes, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::BandedBlockTriangularPreconditioner< MATRIX >::Preconditioner_has_been_setup.

◆ is_upper_triangular()

template<typename MATRIX >

bool oomph::BandedBlockTriangularPreconditioner< MATRIX >::is_upper_triangular ( )

inline

Is this being used as an upper triangular preconditioner?

     {
       // Return the value of the Upper_triangular flag
       return Upper_triangular;
     } // End of is_upper_triangular

References oomph::BandedBlockTriangularPreconditioner< MATRIX >::Upper_triangular.

◆ lower_triangular()

template<typename MATRIX >

void oomph::BandedBlockTriangularPreconditioner< MATRIX >::lower_triangular ( )

inline

Use as a lower triangular preconditioner.

     {
       // Update the Upper_triangular flag
       Upper_triangular = false;
     } // End of lower_triangular

References oomph::BandedBlockTriangularPreconditioner< MATRIX >::Upper_triangular.

Referenced by UnsteadyHeatProblem< ELEMENT >::set_up_spacetime_solver().

◆ operator=()

template<typename MATRIX >

void oomph::BandedBlockTriangularPreconditioner< MATRIX >::operator= ( const BandedBlockTriangularPreconditioner< MATRIX > & )

delete

Broken assignment operator.

◆ preconditioner_solve()

template<typename MATRIX >

void oomph::BandedBlockTriangularPreconditioner< MATRIX >::preconditioner_solve	(	const DoubleVector &	r,
		DoubleVector &	z
	)

virtual

Apply preconditioner to r.

Preconditioner solve for the block triangular preconditioner.

Implements oomph::Preconditioner.

   {
     // Cache number of block types
     unsigned n_block = this->nblock_types();
  
     // The start index
     int start;
  
     // The end index
     int end;
  
     // The max. bandwidth of the block matrix
     int bandwidth_limit;
  
     // The steps to take (=+1/-1) which is dependent on whether we're using
     // the lower or upper triangular form of the preconditioner
     int step;
  
     // If we're using this as an block upper triangular preconditioner
     if (Upper_triangular)
     {
       start = n_block - 1;
       end = -1;
       step = -1;
     }
     else
     {
       start = 0;
       end = n_block;
       step = 1;
     }
  
     // Storage for the iteration count. The entries will be updated as we loop
     // over the blocks. Here -1 is used to indicate that a block was not solved
     // by GMRES so we ignore it
     Vector<int> iteration_count(n_block, -1);
  
     // Storage for the number of blocks solved with GMRES
     unsigned n_block_solved_with_gmres = 0;
  
     // Vector of vectors for each section of residual vector
     Vector<DoubleVector> block_r;
  
     // Rearrange the vector r into the vector of block vectors block_r
     this->get_block_vectors(r, block_r);
  
     // Vector of vectors for the solution block vectors
     Vector<DoubleVector> block_z(n_block);
  
     // Loop over the block rows
     for (int i = start; i != end; i += step)
     {
       // If the i-th subsidiary preconditioner is a block preconditioner
       if (dynamic_cast<BlockPreconditioner<CRDoubleMatrix>*>(
             this->Subsidiary_preconditioner_pt[i]) != 0)
       {
         // This is pretty inefficient but there is no other way to do this with
         // block sub preconditioners as far as I can tell because they demand
         // to have the full r and z vectors...
         DoubleVector block_z_with_size_of_full_z(r.distribution_pt());
         DoubleVector r_updated(r.distribution_pt());
  
         // Construct the new r vector (with the update given by back subs
         // below).
         this->return_block_vectors(block_r, r_updated);
  
         // Solve (blocking is handled inside the block preconditioner).
         this->Subsidiary_preconditioner_pt[i]->preconditioner_solve(
           r_updated, block_z_with_size_of_full_z);
  
         // Extract this block's z vector because we need it for the next step
         // (and throw away block_z_with_size_of_full_z).
         this->get_block_vector(i, block_z_with_size_of_full_z, block_z[i]);
       }
       // If the subsidiary preconditioner is just a regular preconditioner
       else
       {
         // Solve on the block
         this->Subsidiary_preconditioner_pt[i]->preconditioner_solve(block_r[i],
                                                                     block_z[i]);
       }
  
       // See if the i-th subsidiary preconditioner the GMRES block
       // preconditioner
       if (dynamic_cast<GMRESBlockPreconditioner*>(
             this->Subsidiary_preconditioner_pt[i]) != 0)
       {
         // Update the iteration count
         iteration_count[i] = dynamic_cast<GMRESBlockPreconditioner*>(
                                this->Subsidiary_preconditioner_pt[i])
                                ->iterations();
  
         // Increment the counter
         n_block_solved_with_gmres++;
       }
  
       // If the block bandwidth has been provided
       if (Block_bandwidth >= 0)
       {
         // If we're using this as an block upper triangular preconditioner
         if (Upper_triangular)
         {
           bandwidth_limit = std::max(end - i, step + step * Block_bandwidth);
         }
         else
         {
           bandwidth_limit = std::min(end - i, step + step * Block_bandwidth);
         }
       }
       // Default case; loop over all the block rows
       else
       {
         bandwidth_limit = end - i;
       }
  
       // Substitute (over all the rows)
       for (int j = i + step; j != i + bandwidth_limit; j += step)
       {
         // Allocate space for the matrix-vector product (MVP)
         DoubleVector temp;
  
         // Calculate the MVP
         Off_diagonal_matrix_vector_products(j, i)->multiply(block_z[i], temp);
  
         // Now update the RHS vector
         block_r[j] -= temp;
       }
     } // for (int i=start;i!=end;i+=step)
  
     // Copy the solution from the block vector block_z back into z
     this->return_block_vectors(block_z, z);
  
     // Only compute the iteration count statistics if we have some data
     if (n_block_solved_with_gmres > 0)
     {
       // Storage for the average iteration count
       double n_iter_mean = 0.0;
  
       // Storage for the variance of the iteration count
       double n_iter_var = 0.0;
  
       // Loop over the entries of the iteration count vector
       for (unsigned i = 0; i < n_block; i++)
       {
         // If we used GMRES on this block
         if (dynamic_cast<GMRESBlockPreconditioner*>(
               this->Subsidiary_preconditioner_pt[i]) != 0)
         {
           // Sanity check: make sure there's a non-negative iteration count
           if (iteration_count[i] < 0)
           {
             // Create an output stream
             std::ostringstream error_message_stream;
  
             // Create an error message
             error_message_stream
               << "Iteration count should be non-negative but "
               << "you have an iteration\ncount of " << iteration_count[i] << "!"
               << std::endl;
  
             // Throw an error
             throw OomphLibError(error_message_stream.str(),
                                 OOMPH_CURRENT_FUNCTION,
                                 OOMPH_EXCEPTION_LOCATION);
           }
         } // if (dynamic_cast<GMRESBlockPreconditioner*>...
       } // for (unsigned i=0;i<n_block;i++)
  
       // Loop over the entries of the iteration count vector
       for (unsigned i = 0; i < n_block; i++)
       {
         // If we used GMRES on this block
         if (dynamic_cast<GMRESBlockPreconditioner*>(
               this->Subsidiary_preconditioner_pt[i]) != 0)
         {
           // Update the mean
           n_iter_mean +=
             (double(iteration_count[i]) / double(n_block_solved_with_gmres));
         } // if (dynamic_cast<GMRESBlockPreconditioner*>...
       } // for (unsigned i=0;i<n_block;i++)
  
       // Loop over the entries of the iteration count vector (again)
       // NOTE: We don't need to do the error checks again, we did them on the
       // previous run through
       for (unsigned i = 0; i < n_block; i++)
       {
         // If we used GMRES on this block
         if (dynamic_cast<GMRESBlockPreconditioner*>(
               this->Subsidiary_preconditioner_pt[i]) != 0)
         {
           // Update the variance
           n_iter_var +=
             (std::pow(double(iteration_count[i]) - n_iter_mean, 2.0) /
              double(n_block_solved_with_gmres));
         } // if (dynamic_cast<GMRESBlockPreconditioner*>...
       } // for (unsigned i=0;i<n_block;i++)
  
       // Doc. the statistics
       oomph_info << "\nNumber of subsidiary blocks solved with GMRES: "
                  << n_block_solved_with_gmres
                  << "\nAverage subsidiary preconditioner iteration count: "
                  << n_iter_mean
                  << "\nStandard deviation of subsidiary preconditioner "
                  << "iteration count: " << std::sqrt(n_iter_var) << std::endl;
     } // if (n_block_solved_with_gmres>0)
   } // End of preconditioner_solve

References Eigen::placeholders::end, i, j, max, min, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, Eigen::bfloat16_impl::pow(), UniformPSDSelfTest::r, sqrt(), and oomph::CumulativeTimings::start().

◆ set_block_bandwidth()

template<typename MATRIX >

void oomph::BandedBlockTriangularPreconditioner< MATRIX >::set_block_bandwidth ( const int & block_bandwidth )

inline

Set the block bandwidth of the preconditioner.

     {
       // Store it
       Block_bandwidth = block_bandwidth;
     } // End of set_block_bandwidth

References oomph::BandedBlockTriangularPreconditioner< MATRIX >::block_bandwidth(), and oomph::BandedBlockTriangularPreconditioner< MATRIX >::Block_bandwidth.

Referenced by UnsteadyHeatProblem< ELEMENT >::set_up_spacetime_solver().

◆ setup()

template<typename MATRIX >

void oomph::BandedBlockTriangularPreconditioner< MATRIX >::setup

virtual

Setup the preconditioner.

Set up the block triangular preconditioner.

Implements oomph::Preconditioner.

   {
     // Clean the memory
     this->clean_up_memory();
  
     // Subsidiary preconditioners don't really need the meshes
     if (this->is_master_block_preconditioner())
     {
 #ifdef PARANOID
       if (this->gp_nmesh() == 0)
       {
         std::ostringstream err_msg;
         err_msg << "There are no meshes set.\n"
                 << "Did you remember to call add_mesh(...)?";
         throw OomphLibError(
           err_msg.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       // Set all meshes if this is master block preconditioner
       this->gp_preconditioner_set_all_meshes();
     }
  
     // Initialise the memory usage variable
     Memory_usage_in_bytes = 0.0;
  
     // 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;
     }
  
     // Set up the block look up schemes
     this->gp_preconditioner_block_setup();
  
     // Number of block types
     unsigned n_block_types = this->nblock_types();
  
     // Storage for the off diagonal matrix vector products
     Off_diagonal_matrix_vector_products.resize(n_block_types, n_block_types, 0);
  
     // Fill in any null subsidiary preconditioners
     this->fill_in_subsidiary_preconditioners(n_block_types);
  
     // The total time for extracting all the blocks from the "global" matrix
     double t_extraction_total = 0.0;
  
     // The total time for setting up the subsidiary preconditioners
     double t_subsidiary_setup_total = 0.0;
  
     // The total time for setting up the matrix-vector products
     double t_mvp_setup_total = 0.0;
  
     // Build the preconditioners and matrix vector products
     for (unsigned i = 0; i < n_block_types; i++)
     {
       // See if the i-th subsidiary preconditioner is a block preconditioner
       if (dynamic_cast<BlockPreconditioner<CRDoubleMatrix>*>(
             this->Subsidiary_preconditioner_pt[i]) != 0)
       {
         // If we need to compute the memory statistics
         if (Compute_memory_statistics)
         {
           // If we're dealing with a GMRES block preconditioner
           if (dynamic_cast<GMRESBlockPreconditioner*>(
                 this->Subsidiary_preconditioner_pt[i]))
           {
             // Enable the doc-ing of memory usage in the GMRES block
             // preconditioner
             dynamic_cast<GMRESBlockPreconditioner*>(
               this->Subsidiary_preconditioner_pt[i])
               ->enable_doc_memory_usage();
           }
         } // if (Compute_memory_statistics)
  
         // Get the start time
         double t_subsidiary_setup_start = TimingHelpers::timer();
  
         // It's a block preconditioner so pass it a pointer to the global
         // matrix!
         this->Subsidiary_preconditioner_pt[i]->setup(this->matrix_pt());
  
         // Get the end time
         double t_subsidiary_setup_end = TimingHelpers::timer();
  
         // Update the timing total
         t_subsidiary_setup_total +=
           (t_subsidiary_setup_end - t_subsidiary_setup_start);
       }
       // It's just a preconditioner so pass it a deep copy of the block!
       else
       {
         // Get the start time
         double t_extract_start = TimingHelpers::timer();
  
         // Grab the i-th diagonal block
         CRDoubleMatrix block_matrix = this->get_block(i, i);
  
         // Get the end time
         double t_extract_end = TimingHelpers::timer();
  
         // Update the timing total
         t_extraction_total += (t_extract_end - t_extract_start);
  
         // Get the start time
         double t_subsidiary_setup_start = TimingHelpers::timer();
  
         // Set up the i-th subsidiary preconditioner with this block
         this->Subsidiary_preconditioner_pt[i]->setup(&block_matrix);
  
         // Get the end time
         double t_subsidiary_setup_end = TimingHelpers::timer();
  
         // Update the timing total
         t_subsidiary_setup_total +=
           (t_subsidiary_setup_end - t_subsidiary_setup_start);
       }
  
       // The index of the lower column bound
       unsigned l;
  
       // The index of the upper column bound
       unsigned u;
  
       // If we're using the upper triangular form of the preconditioner
       if (Upper_triangular)
       {
         // The lower bound column bound
         l = i + 1;
  
         // If the block bandwidth has been provided
         if (Block_bandwidth >= 0)
         {
           // The upper bound is the last nonzero block column
           u = std::min(n_block_types, l + Block_bandwidth);
         }
         // Default case; loop over all the block columns
         else
         {
           // The upper bound is the last column
           u = n_block_types;
         }
       }
       // If we're using the lower triangular form of the preconditioner
       else
       {
         // The upper bound column bound
         u = i;
  
         // If the block bandwidth has been provided
         if (Block_bandwidth >= 0)
         {
           // The lower bound is the last nonzero block column. The explicit
           // casting is a bit over the top but it's better to be safe than
           // sorry...
           l = std::max(0, int(int(u) - Block_bandwidth));
         }
         // Default case; loop over all the block columns
         else
         {
           // The lower bound is the first column
           l = 0;
         }
       } // for (unsigned i=0;i<nblock_types;i++)
  
       // Loop over the chosen block columns
       for (unsigned j = l; j < u; j++)
       {
         // Get the start time
         double t_extract_start = TimingHelpers::timer();
  
         // Get the (i,j)-th block matrix
         CRDoubleMatrix block_matrix = this->get_block(i, j);
  
         // Do we need to doc. the memory statistics?
         if (Compute_memory_statistics)
         {
           // How many rows are there in this block?
           unsigned n_row = block_matrix.nrow();
  
           // How many nonzeros are there in this block?
           unsigned n_nnz = block_matrix.nnz();
  
           // Compute the memory usage. The only memory overhead here (for the
           // setup phase) is the storage of the sub-diagonal blocks for the MVPs
           Memory_usage_in_bytes += ((2 * ((n_row + 1) * sizeof(int))) +
                                     (n_nnz * (sizeof(int) + sizeof(double))));
         }
  
         // Get the end time
         double t_extract_end = TimingHelpers::timer();
  
         // Update the timing total
         t_extraction_total += (t_extract_end - t_extract_start);
  
         // Get the start time
         double t_mvp_start = TimingHelpers::timer();
  
         // Copy the block into a "multiplier" class. If trilinos is being
         // used this should also be faster than oomph-lib's multiphys.
         Off_diagonal_matrix_vector_products(i, j) = new MatrixVectorProduct();
  
         // Set the damn thing up
         this->setup_matrix_vector_product(
           Off_diagonal_matrix_vector_products(i, j), &block_matrix, j);
  
         // Get the end time
         double t_mvp_end = TimingHelpers::timer();
  
         // Update the timing total
         t_mvp_setup_total += (t_mvp_end - t_mvp_start);
       }
     } // for (unsigned i=0;i<n_block_types;i++)
  
     // Remember that the preconditioner has been set up
     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;
     }
  
     // Tell the user
     oomph_info << "Total block extraction time [sec]: " << t_extraction_total
                << "\nTotal subsidiary preconditioner setup time [sec]: "
                << t_subsidiary_setup_total
                << "\nTotal matrix-vector product setup time [sec]: "
                << t_mvp_setup_total << std::endl;
  
     // Do we need to doc. the memory statistics?
     // NOTE: We're going to assume that either:
     //    (1) GMRES is used as a subsidiary block preconditioner (preconditioned
     //        by the Navier-Stokes subsidiary block preconditioner), or;
     //    (2) SuperLU is used as the subsidiary preconditioner.
     if (Compute_memory_statistics)
     {
       // Allocate space for the total memory usage
       double total_memory_usage_for_setup_phase = 0.0;
  
       // How many rows are there in the global Jacobian?
       unsigned n_row = this->matrix_pt()->nrow();
  
       // How many nonzeros are there in the global Jacobian?
       unsigned n_nnz = this->matrix_pt()->nnz();
  
       // Storage for the memory usage of the global system matrix.
       // NOTE: This calculation is done by taking into account the storage
       // scheme for a compressed row matrix
       double memory_usage_for_storage_of_global_jacobian_in_bytes =
         ((2 * ((n_row + 1) * sizeof(int))) +
          (n_nnz * (sizeof(int) + sizeof(double))));
  
       // Allocate storage for the memory usage of the subsidiary preconditioner
       double memory_usage_for_subsidiary_preconditioner_in_bytes = 0.0;
  
       // Allocate storage for the memory usage of the Navier-Stokes subsidiary
       // block preconditioner (if it's used, that is)
       double memory_usage_for_nssbp_preconditioner_in_bytes = 0.0;
  
       // Boolean to indicate whether we've issue a warning about not being
       // able to compute memory statistics. If it doesn't work with one
       // block, chances are it won't work with any of them, so don't be a
       // pain in the gluteus maximus and just spit out the warning once
       bool have_issued_warning_about_memory_calculations = false;
  
       // Build the preconditioners and matrix vector products
       for (unsigned i = 0; i < n_block_types; i++)
       {
         // See if the i-th subsidiary preconditioner the GMRES block
         // preconditioner
         if (dynamic_cast<GMRESBlockPreconditioner*>(
               this->Subsidiary_preconditioner_pt[i]) != 0)
         {
           // Upcast the subsidiary preconditioner pointer to a GMRES block
           // preconditioner pointer
           GMRESBlockPreconditioner* gmres_block_prec_pt =
             dynamic_cast<GMRESBlockPreconditioner*>(
               this->Subsidiary_preconditioner_pt[i]);
  
           // Update the subsidiary preconditioner memory usage variable
           memory_usage_for_subsidiary_preconditioner_in_bytes +=
             gmres_block_prec_pt->get_memory_usage_in_bytes();
  
           // Add on the memory usage for the NS subsidiary block preconditioner
           memory_usage_for_nssbp_preconditioner_in_bytes +=
             gmres_block_prec_pt->navier_stokes_subsidiary_preconditioner_pt()
               ->get_memory_usage_in_bytes();
         }
         // This block is preconditioned by the SuperLU preconditioner
         else if (dynamic_cast<SuperLUPreconditioner*>(
                    this->Subsidiary_preconditioner_pt[i]) != 0)
         {
           // Update the subsidiary preconditioner memory usage variable
           memory_usage_for_subsidiary_preconditioner_in_bytes +=
             dynamic_cast<SuperLUPreconditioner*>(
               this->Subsidiary_preconditioner_pt[i])
               ->get_total_memory_needed_for_superlu();
         }
         // Don't know what to do otherwise!
         else
         {
           // Have we already complained once?
           if (!have_issued_warning_about_memory_calculations)
           {
             // Remember that we've issued a warning now
             have_issued_warning_about_memory_calculations = true;
  
             // Allocate storage for an output stream
             std::ostringstream warning_message_stream;
  
             // Create a warning message
             warning_message_stream
               << "Can't compute the memory statistics for the " << i
               << "-th diagonal block in the banded\nblock "
               << "triangular preconditioner so I'm just going "
               << "to skip it." << std::endl;
  
             // Give the user a warning
             OomphLibWarning(warning_message_stream.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
           }
         }
       } // for (unsigned i=0;i<nblock_types;i++)
  
       // Create some space
       oomph_info << std::endl;
  
       // If we've got a nonzero contribution from the NSSBP
       if (memory_usage_for_nssbp_preconditioner_in_bytes > 0.0)
       {
         // Doc. the memory usage for the NSSBP
         oomph_info << "Amount of memory used by Navier-Stokes subsidiary block "
                    << "preconditioner (MB): "
                    << memory_usage_for_nssbp_preconditioner_in_bytes / 1.0e+06
                    << std::endl;
  
         // Add in the NSSBP contribution
         total_memory_usage_for_setup_phase +=
           memory_usage_for_nssbp_preconditioner_in_bytes;
       }
  
       // Add in the subsidiary preconditioners contribution
       total_memory_usage_for_setup_phase +=
         memory_usage_for_subsidiary_preconditioner_in_bytes;
  
       // Add in the banded block triangular preconditioner contribution
       total_memory_usage_for_setup_phase += get_memory_usage_in_bytes();
  
       // Add in the global Jacobian contribution
       total_memory_usage_for_setup_phase +=
         memory_usage_for_storage_of_global_jacobian_in_bytes;
  
       // How much memory have we used in the subsidiary preconditioners?
       oomph_info
         << "Amount of memory used by the subsidiary preconditioners "
         << "(MB): "
         << memory_usage_for_subsidiary_preconditioner_in_bytes / 1.0e+06
         << "\nAmount of memory used by banded block triangular "
         << "preconditioner (MB): " << get_memory_usage_in_bytes() / 1.0e+06
         << "\nAmount of memory used to store (global) Jacobian (MB): "
         << memory_usage_for_storage_of_global_jacobian_in_bytes / 1.0e+06
         << "\nTotal amount of memory being used after setup (MB): "
         << total_memory_usage_for_setup_phase / 1.0e+06 << "\n"
         << std::endl;
     } // if (Compute_memory_statistics)
   } // End of setup

References oomph::TerminateHelper::clean_up_memory(), oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::get_memory_usage_in_bytes(), oomph::GMRESBlockPreconditioner::get_memory_usage_in_bytes(), i, int(), j, max, min, oomph::GMRESBlockPreconditioner::navier_stokes_subsidiary_preconditioner_pt(), oomph::CRDoubleMatrix::nnz(), oomph::CRDoubleMatrix::nrow(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, oomph::oomph_nullstream, GlobalParameters::Stream_pt, oomph::OomphInfo::stream_pt(), and oomph::TimingHelpers::timer().

◆ upper_triangular()

template<typename MATRIX >

void oomph::BandedBlockTriangularPreconditioner< MATRIX >::upper_triangular ( )

inline

Use as an upper triangular preconditioner.

     {
       // Update the Upper_triangular flag
       Upper_triangular = true;
     } // End of upper_triangular

Boolean indicating upper or lower triangular.

Referenced by oomph::BandedBlockTriangularPreconditioner< MATRIX >::BandedBlockTriangularPreconditioner(), oomph::BandedBlockTriangularPreconditioner< MATRIX >::is_upper_triangular(), oomph::BandedBlockTriangularPreconditioner< MATRIX >::lower_triangular(), and oomph::BandedBlockTriangularPreconditioner< MATRIX >::upper_triangular().

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

Public Member Functions

Protected Attributes

Private Attributes

Additional Inherited Members

Detailed Description

template<typename MATRIX> class oomph::BandedBlockTriangularPreconditioner< MATRIX >

Constructor & Destructor Documentation

◆ BandedBlockTriangularPreconditioner() [1/2]

◆ ~BandedBlockTriangularPreconditioner()

◆ BandedBlockTriangularPreconditioner() [2/2]

Member Function Documentation

◆ block_bandwidth()

◆ clean_up_memory()

◆ disable_doc_memory_usage()

◆ enable_doc_memory_usage()

◆ get_memory_usage_in_bytes()

◆ is_upper_triangular()

◆ lower_triangular()

◆ operator=()

◆ preconditioner_solve()

◆ set_block_bandwidth()

◆ setup()

◆ upper_triangular()

Member Data Documentation

◆ Block_bandwidth

◆ Compute_memory_statistics

◆ Memory_usage_in_bytes

◆ Off_diagonal_matrix_vector_products

◆ Preconditioner_has_been_setup

◆ Upper_triangular

template<typename MATRIX>
class oomph::BandedBlockTriangularPreconditioner< MATRIX >