#include <general_purpose_block_preconditioners.h>

Inheritance diagram for oomph::BlockDiagonalPreconditioner< MATRIX >:

Public Member Functions
	BlockDiagonalPreconditioner ()
	constructor - when the preconditioner is used as a master preconditioner More...

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

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

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

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

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

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

void	enable_two_level_parallelisation ()
	Use two level parallelisation. More...

void	disable_two_level_parallelisation ()
	Don't use two-level parallelisation. More...

void	enable_doc_time_during_preconditioner_solve ()
	Enable Doc timings in application of block sub-preconditioners. More...

void	disable_doc_time_during_preconditioner_solve ()
	Disable Doc timings in application of block sub-preconditioners. More...

void	fill_in_subsidiary_preconditioners (const unsigned &nprec_needed)

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 Member Functions
virtual unsigned	get_other_diag_ds (const unsigned &i, const unsigned &nblock) const

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 ()

Private Attributes
PreconditionerArray *	Preconditioner_array_pt
	pointer for the PreconditionerArray More...

bool	Use_two_level_parallelisation
	Use two level parallelism using the PreconditionerArray. More...

bool	Doc_time_during_preconditioner_solve
	Doc timings in application of block sub-preconditioners? More...

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

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

Detailed Description

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

Block diagonal preconditioner. By default SuperLU 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

◆ BlockDiagonalPreconditioner() [1/2]

template<typename MATRIX >

oomph::BlockDiagonalPreconditioner< MATRIX >::BlockDiagonalPreconditioner ( )

inline

constructor - when the preconditioner is used as a master preconditioner

                                   : GeneralPurposeBlockPreconditioner<MATRIX>()
     {
       // by default we do not use two level parallelism
       Use_two_level_parallelisation = false;
  
       // null the Preconditioner array pt
       Preconditioner_array_pt = 0;
  
       // Don't doc by default
       Doc_time_during_preconditioner_solve = false;
     }

◆ ~BlockDiagonalPreconditioner()

template<typename MATRIX >

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

inlinevirtual

Destructor - delete the preconditioner matrices.

     {
       this->clean_up_memory();
     }

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

◆ BlockDiagonalPreconditioner() [2/2]

template<typename MATRIX >

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

delete

Broken copy constructor.

Member Function Documentation

◆ clean_up_memory()

template<typename MATRIX >

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

inlinevirtual

clean up the memory

Reimplemented from oomph::GeneralPurposeBlockPreconditioner< MATRIX >.

     {
       if (Use_two_level_parallelisation)
       {
         delete Preconditioner_array_pt;
         Preconditioner_array_pt = 0;
       }
  
       // Clean up the base class too
       GeneralPurposeBlockPreconditioner<MATRIX>::clean_up_memory();
     }

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

◆ disable_doc_time_during_preconditioner_solve()

template<typename MATRIX >

void oomph::BlockDiagonalPreconditioner< MATRIX >::disable_doc_time_during_preconditioner_solve ( )

inline

Disable Doc timings in application of block sub-preconditioners.

     {
       Doc_time_during_preconditioner_solve = false;
     }

◆ disable_two_level_parallelisation()

template<typename MATRIX >

void oomph::BlockDiagonalPreconditioner< MATRIX >::disable_two_level_parallelisation ( )

inline

Don't use two-level parallelisation.

     {
       Use_two_level_parallelisation = false;
     }

◆ enable_doc_time_during_preconditioner_solve()

template<typename MATRIX >

void oomph::BlockDiagonalPreconditioner< MATRIX >::enable_doc_time_during_preconditioner_solve ( )

inline

Enable Doc timings in application of block sub-preconditioners.

     {
       Doc_time_during_preconditioner_solve = true;
     }

◆ enable_two_level_parallelisation()

template<typename MATRIX >

void oomph::BlockDiagonalPreconditioner< MATRIX >::enable_two_level_parallelisation ( )

inline

Use two level parallelisation.

     {
 #ifndef OOMPH_HAS_MPI
       throw OomphLibError("Cannot do any parallelism since we don't have MPI.",
                           OOMPH_CURRENT_FUNCTION,
                           OOMPH_EXCEPTION_LOCATION);
 #endif
       Use_two_level_parallelisation = true;
     }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ fill_in_subsidiary_preconditioners()

template<typename MATRIX >

void oomph::BlockDiagonalPreconditioner< MATRIX >::fill_in_subsidiary_preconditioners ( const unsigned & nprec_needed )

inline

     {
 #ifdef PARANOID
       if ((Use_two_level_parallelisation) &&
           !this->Subsidiary_preconditioner_pt.empty())
       {
         std::string err_msg =
           "Two level parallelism diagonal block preconditioners cannot have";
         err_msg +=
           " any preset preconditioners (due to weird memory management";
         err_msg += " in the PreconditionerArray, you could try fixing it).";
         throw OomphLibError(
           err_msg, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       // Now call the real function
       GeneralPurposeBlockPreconditioner<
         MATRIX>::fill_in_subsidiary_preconditioners(nprec_needed);
     }

References oomph::GeneralPurposeBlockPreconditioner< MATRIX >::fill_in_subsidiary_preconditioners(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Global_string_for_annotation::string(), and oomph::GeneralPurposeBlockPreconditioner< MATRIX >::Subsidiary_preconditioner_pt.

◆ get_other_diag_ds()

template<typename MATRIX >

virtual unsigned oomph::BlockDiagonalPreconditioner< MATRIX >::get_other_diag_ds	(	const unsigned &	i,
		const unsigned &	nblock
	)		const

inlineprotectedvirtual

This is a helper function to allow us to implement AntiDiagonal preconditioner by only changing this function. Get the second index for block number i. Obviously for a diagonal preconditioner we want the blocks (i,i), (for anti diagonal we will want blocks (i, nblock - i), see that class).

Reimplemented in oomph::BlockAntiDiagonalPreconditioner< MATRIX >.

     {
       return i;
     }

References i.

◆ operator=()

template<typename MATRIX >

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

delete

Broken assignment operator.

◆ preconditioner_solve()

template<typename MATRIX >

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

virtual

Apply preconditioner to r.

Preconditioner solve for the block diagonal preconditioner.

Implements oomph::Preconditioner.

   {
     // Cache umber of block types
     unsigned n_block = this->nblock_types();
  
     // Get the right hand side vector (b in Ax = b) in block form.
     Vector<DoubleVector> block_r;
     this->get_block_vectors(r, block_r);
  
     // Make sure z vector is built
     if (!z.built())
     {
       z.build(this->distribution_pt(), 0.0);
     }
  
     // Vector of vectors for storage of solution in block form.
     Vector<DoubleVector> block_z(n_block);
  
     if (Use_two_level_parallelisation)
     {
       Preconditioner_array_pt->solve_preconditioners(block_r, block_z);
     }
     else
     {
       // solve each diagonal block
       for (unsigned i = 0; i < n_block; i++)
       {
         double t_start = 0.0;
         if (Doc_time_during_preconditioner_solve)
         {
           t_start = TimingHelpers::timer();
         }
  
         // this->Subsidiary_preconditioner_pt[i]->preconditioner_solve(block_r[i],
         //     block_z[i]);
  
  
         // See if the i-th subsidiary preconditioner is a block preconditioner
         if (dynamic_cast<BlockPreconditioner<CRDoubleMatrix>*>(
               this->Subsidiary_preconditioner_pt[i]) == 0)
         {
           this->Subsidiary_preconditioner_pt[i]->preconditioner_solve(
             block_r[i], block_z[i]);
         }
         // If the subsidiary preconditioner is a block preconditioner
         else
         {
           // 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 (Doc_time_during_preconditioner_solve)
         {
           oomph_info << "Time for application of " << i
                      << "-th block preconditioner: "
                      << TimingHelpers::timer() - t_start << std::endl;
         }
       }
     }
  
     // copy solution in block vectors block_z back to z
     this->return_block_vectors(block_z, z);
   }

References oomph::DoubleVector::build(), oomph::DoubleVector::built(), i, oomph::oomph_info, UniformPSDSelfTest::r, and oomph::TimingHelpers::timer().

◆ setup()

template<typename MATRIX >

void oomph::BlockDiagonalPreconditioner< MATRIX >::setup

virtual

Setup the preconditioner.

setup for the block diagonal preconditioner

Implements oomph::Preconditioner.

   {
     // clean the memory
     this->clean_up_memory();
  
     // Note: Subsidiary block preconditioners don't really use their
     // mesh pointers (since the lookup schemes inferred from them are
     // set up by their masters). Generally we insist that (for uniformity)
     // a mesh should be set, but sometimes subsidiary preconditioners are
     // set up on the fly and we can't sensibly set meshes, so we're
     // forgiving...)
     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();
     }
  
     // 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 types of blocks.
     unsigned nblock_types = this->nblock_types();
  
     // Create any subsidiary preconditioners needed
     this->fill_in_subsidiary_preconditioners(nblock_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;
  
     // If using two level parallelisation then we need to use a
     // PrecondtionerArray which requires very different setup. ??ds possibly
     // it should have it's own class?
     if (Use_two_level_parallelisation)
     {
       // Get the blocks. We have to use new because you can't have containers
       // of matrices because the copy constructor is buggy (so we create a
       // container of pointers instead). ??ds
       Vector<CRDoubleMatrix*> block_diagonal_matrix_pt(nblock_types, 0);
       for (unsigned i = 0; i < nblock_types; i++)
       {
         // Allocate space for the new matrix
         block_diagonal_matrix_pt[i] = new CRDoubleMatrix;
  
         // Get the start time
         double t_extract_start = TimingHelpers::timer();
  
         // Extract the i-th block
         this->get_block(
           i, get_other_diag_ds(i, nblock_types), *block_diagonal_matrix_pt[i]);
  
         // Get the end time
         double t_extract_end = TimingHelpers::timer();
  
         // Update the timing total
         t_extraction_total += (t_extract_end - t_extract_start);
       }
  
       // Construct the preconditioner array
       Preconditioner_array_pt = new PreconditionerArray;
  
       // Get the start time
       double t_subsidiary_setup_start = TimingHelpers::timer();
  
       // Set up the preconditioners
       Preconditioner_array_pt->setup_preconditioners(
         block_diagonal_matrix_pt,
         this->Subsidiary_preconditioner_pt,
         this->comm_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);
  
       // and delete the blocks
       for (unsigned i = 0; i < nblock_types; i++)
       {
         delete block_diagonal_matrix_pt[i];
         block_diagonal_matrix_pt[i] = 0;
       }
  
       // Preconditioner array is weird, it calls delete on all the
       // preconditioners you give it and requires new ones each time!
       this->Subsidiary_preconditioner_pt.clear();
     }
     // Otherwise just set up each block's preconditioner in order
     else
     {
       for (unsigned i = 0; i < nblock_types; i++)
       {
         // Get the block
         unsigned j = get_other_diag_ds(i, nblock_types);
  
         // Get the start time
         double t_extract_start = TimingHelpers::timer();
  
         // Get the block
         CRDoubleMatrix block = this->get_block(i, j);
  
         // 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 the (subsidiary) preconditioner up for this block
         this->Subsidiary_preconditioner_pt[i]->setup(&block);
  
         // Get the end time
         double t_subsidiary_setup_end = TimingHelpers::timer();
  
         // Tell the user
         oomph_info << "Took "
                    << t_subsidiary_setup_end - t_subsidiary_setup_start
                    << "s to setup." << std::endl;
  
         // Update the timing total
         t_subsidiary_setup_total +=
           (t_subsidiary_setup_end - t_subsidiary_setup_start);
       }
     }
  
     // 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 << std::endl;
   }

References block(), oomph::TerminateHelper::clean_up_memory(), i, j, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, oomph::oomph_nullstream, GlobalParameters::Stream_pt, oomph::OomphInfo::stream_pt(), and oomph::TimingHelpers::timer().

Member Data Documentation

◆ Doc_time_during_preconditioner_solve

template<typename MATRIX >

bool oomph::BlockDiagonalPreconditioner< MATRIX >::Doc_time_during_preconditioner_solve

private

Doc timings in application of block sub-preconditioners?

◆ Preconditioner_array_pt

template<typename MATRIX >

PreconditionerArray* oomph::BlockDiagonalPreconditioner< MATRIX >::Preconditioner_array_pt

private

pointer for the PreconditionerArray

◆ Use_two_level_parallelisation

template<typename MATRIX >

bool oomph::BlockDiagonalPreconditioner< MATRIX >::Use_two_level_parallelisation

private

Use two level parallelism using the PreconditionerArray.

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

Public Member Functions

Protected Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

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

Constructor & Destructor Documentation

◆ BlockDiagonalPreconditioner() [1/2]

◆ ~BlockDiagonalPreconditioner()

◆ BlockDiagonalPreconditioner() [2/2]

Member Function Documentation

◆ clean_up_memory()

◆ disable_doc_time_during_preconditioner_solve()

◆ disable_two_level_parallelisation()

◆ enable_doc_time_during_preconditioner_solve()

◆ enable_two_level_parallelisation()

◆ fill_in_subsidiary_preconditioners()

◆ get_other_diag_ds()

◆ operator=()

◆ preconditioner_solve()

◆ setup()

Member Data Documentation

◆ Doc_time_during_preconditioner_solve

◆ Preconditioner_array_pt

◆ Use_two_level_parallelisation

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