#include <multi_poisson_block_preconditioners.h>

Inheritance diagram for oomph::CoarseTwoPlusTwoPlusOne< MATRIX >:

Public Member Functions
	CoarseTwoPlusTwoPlusOne ()
	Constructor for CoarseTwoPlusTwoPlusOne. More...

	~CoarseTwoPlusTwoPlusOne ()
	Destructor - delete the diagonal solvers (subsidiary preconditioners) More...

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

	CoarseTwoPlusTwoPlusOne (const CoarseTwoPlusTwoPlusOne &)
	Broken copy constructor. More...

void	operator= (const CoarseTwoPlusTwoPlusOne &)
	Broken assignment operator. More...

void	preconditioner_solve (const DoubleVector &r, DoubleVector &z)
	Apply preconditioner to r, i.e. return z such that P z = r. More...

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

void	set_multi_poisson_mesh (Mesh *multi_poisson_mesh_pt)
	Specify the mesh that contains multi-poisson elements. More...

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	clean_up_memory ()
	Clean up memory (empty). Generic interface function. 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 *	First_subsidiary_preconditioner_pt

Preconditioner *	Second_subsidiary_preconditioner_pt

DenseMatrix< CRDoubleMatrix * >	Replacement_matrix_pt

MatrixVectorProduct *	Off_diagonal_matrix_vector_product_pt
	Matrix vector product operator. More...

Mesh *	Multi_poisson_mesh_pt

Additional Inherited Members
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 ()

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::CoarseTwoPlusTwoPlusOne< MATRIX >

///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// Block diagonal preconditioner for system with 5 dof types assembled into a 2x2 block system, with the (0,0) block containing the first two dof types, the (1,1) block containing the three remaining ones.

Constructor & Destructor Documentation

◆ CoarseTwoPlusTwoPlusOne() [1/2]

template<typename MATRIX >

oomph::CoarseTwoPlusTwoPlusOne< MATRIX >::CoarseTwoPlusTwoPlusOne ( )

inline

Constructor for CoarseTwoPlusTwoPlusOne.

                              : 
   BlockPreconditioner<MATRIX>(),
    First_subsidiary_preconditioner_pt(0),
    Second_subsidiary_preconditioner_pt(0),
    Off_diagonal_matrix_vector_product_pt(0)
     {    
      Multi_poisson_mesh_pt=0;
     } // end_of_constructor

References oomph::CoarseTwoPlusTwoPlusOne< MATRIX >::Multi_poisson_mesh_pt.

◆ ~CoarseTwoPlusTwoPlusOne()

template<typename MATRIX >

oomph::CoarseTwoPlusTwoPlusOne< MATRIX >::~CoarseTwoPlusTwoPlusOne ( )

inline

Destructor - delete the diagonal solvers (subsidiary preconditioners)

    {
     this->clean_up_my_memory();
    }    

References oomph::CoarseTwoPlusTwoPlusOne< MATRIX >::clean_up_my_memory().

◆ CoarseTwoPlusTwoPlusOne() [2/2]

template<typename MATRIX >

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

inline

Broken copy constructor.

    { 
     BrokenCopy::broken_copy(
      "CoarseTwoPlusTwoPlusOne");
    } 

References oomph::BrokenCopy::broken_copy().

Member Function Documentation

◆ clean_up_my_memory()

template<typename MATRIX >

void oomph::CoarseTwoPlusTwoPlusOne< MATRIX >::clean_up_my_memory

virtual

clean up the memory

The clean up function.

  {     
   // Delete diagonal preconditioners (approximate solvers)
   if(First_subsidiary_preconditioner_pt!=0)
    {
     delete First_subsidiary_preconditioner_pt;
     First_subsidiary_preconditioner_pt = 0;
    }
   if(Second_subsidiary_preconditioner_pt!=0)
    {
     delete Second_subsidiary_preconditioner_pt;
     Second_subsidiary_preconditioner_pt = 0;
    }
  
   // Clean up the replacement matricies.
   for(unsigned i=0,ni=Replacement_matrix_pt.nrow();i<ni;i++)
    {
     for(unsigned j=0,nj=Replacement_matrix_pt.ncol();j<nj;j++)
      {
       if(Replacement_matrix_pt(i,j)!=0)
        {
         delete Replacement_matrix_pt(i,j);
         Replacement_matrix_pt(i,j)=0;
        }
      } // End loop over j.
    } // End loop over i.
  
   // Kill matrix vector product
   if(Off_diagonal_matrix_vector_product_pt!= 0)
    {
     delete Off_diagonal_matrix_vector_product_pt;
     Off_diagonal_matrix_vector_product_pt = 0;
    }
  
  } // End of clean_up_my_memory function.

References i, and j.

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

◆ operator=()

template<typename MATRIX >

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

inline

Broken assignment operator.

    {
     BrokenCopy::broken_assign(
      "CoarseTwoPlusTwoPlusOne");
    }

References oomph::BrokenCopy::broken_assign().

◆ preconditioner_solve()

template<typename MATRIX >

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

virtual

Apply preconditioner to r, i.e. return z such that P z = r.

Preconditioner solve: Apply preconditioner to r and return z, so that P z = r, where P is the block diagonal matrix constructed from the original linear system.

Implements oomph::Preconditioner.

  {   
    // Now apply the subsidiary block preconditioner that acts on the
    // "bottom right" 3x3 sub-system (only!). The subsidiary preconditioner 
    // will extract the relevant (3x1) "sub-vectors" from the "big" (5x1)
    // vector big_r and treat it as the rhs, r, of P z = r
    // where P is 3x3 block diagonal.
    Second_subsidiary_preconditioner_pt->preconditioner_solve(r,z);
  
    // Get the entries from r corresponding to matrix block 0.
    DoubleVector r_0;
    this->get_block_vector(0,r,r_0);
  
    // Get the entries from z corresponding to matrix block 0.
    DoubleVector z_1;
    this->get_block_vector(1,z,z_1);
  
    // Multiply by off diagonal block and subtract from RHS.
    DoubleVector temp;
    Off_diagonal_matrix_vector_product_pt->multiply(z_1,temp);
    r_0 -= temp;
  
    // Block solve for first diagonal block. Since the associated subsidiary 
    // preconditioner is a block preconditioner itself, it will extract 
    // the required (2x1) block rhs from a "big" (5x1) rhs vector, big_r.
    // Therefore we first put the actual (2x1) rhs vector block_r_0 into the
    // "big" (5x1) vector big_r. 
    DoubleVector big_r(z.distribution_pt());
  
    this->return_block_vector(0,r_0,big_r);
  
    // Now apply the subsidiary block preconditioner that acts on the
    // "top left" 2x2 sub-system (only!). The subsidiary preconditioner 
    // will extract the relevant (2x1) "sub-vectors" from the "big" (5x1)
    // vector big_r and treat it as the rhs, r, of P z = r
    // where P is 2x2 block diagonal. Once the system is solved,
    // the result is automatically put back into the appropriate places 
    // of the "big" (5x1) vector z:
    First_subsidiary_preconditioner_pt->preconditioner_solve(big_r,z);
  }// End of solve

References oomph::DistributableLinearAlgebraObject::distribution_pt(), and UniformPSDSelfTest::r.

◆ set_multi_poisson_mesh()

template<typename MATRIX >

void oomph::CoarseTwoPlusTwoPlusOne< MATRIX >::set_multi_poisson_mesh ( Mesh * multi_poisson_mesh_pt )

inline

Specify the mesh that contains multi-poisson elements.

   {
    Multi_poisson_mesh_pt=multi_poisson_mesh_pt;
   }

References oomph::CoarseTwoPlusTwoPlusOne< MATRIX >::Multi_poisson_mesh_pt.

Referenced by MultiPoissonProblem< ELEMENT >::MultiPoissonProblem().

◆ setup()

template<typename MATRIX >

void oomph::CoarseTwoPlusTwoPlusOne< MATRIX >::setup

virtual

Setup the preconditioner.

The setup function.

Implements oomph::Preconditioner.

  {
   // Clean up memory
   this->clean_up_my_memory();
  
 #ifdef PARANOID
   if (Multi_poisson_mesh_pt == 0)
    {
     std::stringstream err;
     err << "Please set pointer to mesh using set_multi_poisson_mesh(...).\n";
     throw OomphLibError(err.str(),
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
    }
 #endif 
   
   // The preconditioner works with one mesh; set it!
   this->set_nmesh(1);
   this->set_mesh(0,Multi_poisson_mesh_pt);
  
   // This preconditioner only works for 5 dof types
   unsigned n_dof_types = this->ndof_types();
 #ifdef PARANOID
   if (n_dof_types!=5)
    {
     std::stringstream tmp;
     tmp << "This preconditioner only works for problems with 5 dof types\n"
         << "Yours has " << n_dof_types;
     throw OomphLibError(tmp.str(),
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
    }
 #endif
  
  
   // Call block setup with the Vector [0,0,1,1,1] to:
   // Merge DOF types 0 and 1 into block type 0.
   // Merge DOF types 2, 3 and 4 into block type 1.
   Vector<unsigned> dof_to_block_map(n_dof_types,0);
   dof_to_block_map[0] = 0;
   dof_to_block_map[1] = 0;
   dof_to_block_map[2] = 1;
   dof_to_block_map[3] = 1;
   dof_to_block_map[4] = 1;
   this->block_setup(dof_to_block_map);
  
  
   // Replace all the off-diagonal DOF blocks.
   Replacement_matrix_pt.resize(n_dof_types,n_dof_types,0);
   for(unsigned i=0;i<n_dof_types;i++)
    {
     for(unsigned j=0;j<n_dof_types;j++)
      {
       if(i!=j)
        {
         // Get the DOF block's (row!) distribution.
         LinearAlgebraDistribution* dof_block_dist_pt=
          this->dof_block_distribution_pt(i);
          
         // Number of rows in DOF block matrix (i,j).
         const unsigned long dof_block_nrow = dof_block_dist_pt->nrow_local();
  
         // Number of columns in block matrix (i,j) is the same as the number
         // of rows in block matrix (j,i).
         // We use the actual nrow, not the local one here as this block may
         // need to be gotten from another processor.
         const unsigned long dof_block_ncol 
           = this->dof_block_distribution_pt(j)->nrow();
  
         // Storage for replacement matrices:
         // Values
         Vector<double> replacement_value(0);
         // Column index
         Vector<int> replacement_column_index(0);
         // Row start
         Vector<int> replacement_row_start;
  
         // Need one row start per row, and one for the nnz, all of which are 0.
         replacement_row_start.resize(dof_block_nrow+1,0);
  
         Replacement_matrix_pt(i,j)=
          new CRDoubleMatrix(dof_block_dist_pt, dof_block_ncol, 
                             replacement_value,
                             replacement_column_index, replacement_row_start);
  
         // Replace.
         this->set_replacement_dof_block(i,j,Replacement_matrix_pt(i,j));
  
        }// End of if
      }// End of j loop.
    }// End of i loop.
  
   // Create the subsidiary preconditioners
   //--------------------------------------
   {
    // First subsidiary precond is a block diagonal preconditioner itself.
    UpperTriangular<CRDoubleMatrix>* block_prec_pt=
     new UpperTriangular<CRDoubleMatrix>;
    First_subsidiary_preconditioner_pt=block_prec_pt;
  
    // Set mesh
    block_prec_pt->set_multi_poisson_mesh(Multi_poisson_mesh_pt);
    
    // Turn first_sub into a subsidiary preconditioner, declaring which
    // of the five dof types in the present (master) preconditioner
    // correspond to the dof types in the subsidiary block preconditioner
    const unsigned n_sub_dof_types=2;
    Vector<unsigned> dof_map(n_sub_dof_types);
    dof_map[0]=0;
    dof_map[1]=1;
    block_prec_pt->turn_into_subsidiary_block_preconditioner(this,dof_map);    
  
    // Perform setup. Note that because the subsidiary
    // preconditioner is a block preconditioner itself it is given
    // the pointer to the "full" matrix
    block_prec_pt->setup(this->matrix_pt());
   }
  
   // Second subsidiary preconditioner is also a block preconditioner 
   {
    SimpleTwoDofOnly<CRDoubleMatrix>* block_prec_pt=
     new SimpleTwoDofOnly<CRDoubleMatrix>;
    Second_subsidiary_preconditioner_pt=block_prec_pt;
    
    // Set mesh
    block_prec_pt->set_multi_poisson_mesh(Multi_poisson_mesh_pt);
    
    // This is the usual mapping between the subsidiary and master dof types.
    Vector<unsigned> dof_map(3);
    dof_map[0]=2;
    dof_map[1]=3;
    dof_map[2]=4;
    
    // The subsidiary block preconditioner SimpleTwoDofOnly accepts only two
    // dof types. We therefore have to "coarsen" the 3 dof types into two
    // by specifying the vector of vectors doftype_coarsening whose
    // entries are to be interpreted as
    // 
    //    doftype_coarsening[coarsened_dof_type][i]=dof_type
    //
    // where i ranges from 0 to the number of dof types (minus one, because
    // of the zero-based indexing...) that are to be
    // combined/coarsened into dof type dof_type_in_coarsed_block_preconditioner
  
  
    // Number of dof types the subsidiary block preconditioner expects.
    const unsigned n_sub_dof_types=2;
    Vector<Vector<unsigned> > doftype_coarsening(n_sub_dof_types);
    
    // Subsidiary dof type 0 contains 2 dof types.
    doftype_coarsening[0].resize(2);
  
    // Coarsen subsidiary dof types 0 and 1 into subsidiary dof type 0.
    doftype_coarsening[0][0]=0;
    doftype_coarsening[0][1]=1;
    
    // Subsidiary dof type 1 contains 1 dof types. 
    doftype_coarsening[1].resize(1);
    
    // Subsidiary Dof type 1 contains subsidiary dof type 2.
    doftype_coarsening[1][0]=2;
       
    // Turn into subdiary preconditioner
    block_prec_pt->
     turn_into_subsidiary_block_preconditioner(this,dof_map,
                                               doftype_coarsening);
  
    // Perform setup. Note that because the subsidiary
    // preconditioner is a block preconditioner itself it is given
    // the pointer to the "full" matrix
    block_prec_pt->setup(this->matrix_pt());
   }
    
    
   // Set up off diagonal matrix vector product
   {
    // Get the off diagonal block.
    CRDoubleMatrix block_matrix = this->get_block(0,1);
    
    // Create matrix vector product operator
    Off_diagonal_matrix_vector_product_pt = new MatrixVectorProduct;
    
    // Setup: Final argument indicates block column in the present
    // block preconditioner (which views the system matrix as comprising
    // 2x2 blocks).
    unsigned block_column_index=1;
    this->setup_matrix_vector_product(
     Off_diagonal_matrix_vector_product_pt,&block_matrix,block_column_index);
  
    // extracted block can now go out of scope; the matrix vector product
    // retains its own (deep) copy.
   }
  
  }// End of setup

References i, j, oomph::LinearAlgebraDistribution::nrow_local(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::SimpleTwoDofOnly< MATRIX >::set_multi_poisson_mesh(), oomph::UpperTriangular< MATRIX >::set_multi_poisson_mesh(), oomph::SimpleTwoDofOnly< MATRIX >::setup(), oomph::UpperTriangular< MATRIX >::setup(), tmp, and oomph::BlockPreconditioner< MATRIX >::turn_into_subsidiary_block_preconditioner().

Member Data Documentation

◆ First_subsidiary_preconditioner_pt

template<typename MATRIX >

Preconditioner* oomph::CoarseTwoPlusTwoPlusOne< MATRIX >::First_subsidiary_preconditioner_pt

private

Pointer to preconditioners/inexact solver for (0,0) block

◆ Multi_poisson_mesh_pt

template<typename MATRIX >

Mesh* oomph::CoarseTwoPlusTwoPlusOne< MATRIX >::Multi_poisson_mesh_pt

private

Pointer to mesh with preconditionable elements used for classification of dof types.

Referenced by oomph::CoarseTwoPlusTwoPlusOne< MATRIX >::CoarseTwoPlusTwoPlusOne(), and oomph::CoarseTwoPlusTwoPlusOne< MATRIX >::set_multi_poisson_mesh().

◆ Off_diagonal_matrix_vector_product_pt

template<typename MATRIX >

MatrixVectorProduct* oomph::CoarseTwoPlusTwoPlusOne< MATRIX >::Off_diagonal_matrix_vector_product_pt

private

Matrix vector product operator.

◆ Replacement_matrix_pt

template<typename MATRIX >

DenseMatrix<CRDoubleMatrix*> oomph::CoarseTwoPlusTwoPlusOne< MATRIX >::Replacement_matrix_pt

private

◆ Second_subsidiary_preconditioner_pt

template<typename MATRIX >

Preconditioner* oomph::CoarseTwoPlusTwoPlusOne< MATRIX >::Second_subsidiary_preconditioner_pt

private

Pointer to preconditioners/inexact solver for (1,1) block

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

multi_poisson_block_preconditioners.h

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

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

Constructor & Destructor Documentation

◆ CoarseTwoPlusTwoPlusOne() [1/2]

◆ ~CoarseTwoPlusTwoPlusOne()

◆ CoarseTwoPlusTwoPlusOne() [2/2]

Member Function Documentation

◆ clean_up_my_memory()

◆ operator=()

◆ preconditioner_solve()

◆ set_multi_poisson_mesh()

◆ setup()

Member Data Documentation

◆ First_subsidiary_preconditioner_pt

◆ Multi_poisson_mesh_pt

◆ Off_diagonal_matrix_vector_product_pt

◆ Replacement_matrix_pt

◆ Second_subsidiary_preconditioner_pt

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