#include <multi_poisson_block_preconditioners.h>

Inheritance diagram for oomph::TwoPlusOneUpperTriangularPreconditioner< MATRIX >:

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

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

virtual void	clean_up_my_memory ()
	Cleanup function. More...

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

void	operator= (const TwoPlusOneUpperTriangularPreconditioner &)
	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...

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

void	setup (DoubleMatrixBase *matrix_pt)

void	setup (const Problem problem_pt, DoubleMatrixBase matrix_pt)

virtual void	setup ()=0

Public Member Functions inherited from oomph::BlockPreconditioner< 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

MatrixVectorProduct *	Off_diagonal_matrix_vector_product_pt
	Matrix vector product operators for the off diagonals. 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::TwoPlusOneUpperTriangularPreconditioner< MATRIX >

///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// Block diagonal preconditioner for system with 3 dof types assembled into a 2x2 block system, with (0,0) block containing the first two dof types, the (1,1) block containing the last one. Both blocks are solved by subsidiary diagonal block preconditioners, so the overall behaviour is equivalent to a solve with a 3x3 upper triangular preconditioner.

Constructor & Destructor Documentation

◆ TwoPlusOneUpperTriangularPreconditioner() [1/2]

template<typename MATRIX >

oomph::TwoPlusOneUpperTriangularPreconditioner< MATRIX >::TwoPlusOneUpperTriangularPreconditioner ( )

inline

Constructor for TwoPlusOneUpperTriangularPreconditioner.

                                              : 
   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::TwoPlusOneUpperTriangularPreconditioner< MATRIX >::Multi_poisson_mesh_pt.

◆ ~TwoPlusOneUpperTriangularPreconditioner()

template<typename MATRIX >

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

inline

Destructor - delete the diagonal solvers (subsidiary preconditioners)

    {
     this->clean_up_my_memory();
    }

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

◆ TwoPlusOneUpperTriangularPreconditioner() [2/2]

template<typename MATRIX >

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

inline

Broken copy constructor.

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

References oomph::BrokenCopy::broken_copy().

Member Function Documentation

◆ clean_up_my_memory()

template<typename MATRIX >

void oomph::TwoPlusOneUpperTriangularPreconditioner< MATRIX >::clean_up_my_memory

virtual

Cleanup function.

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

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

◆ operator=()

template<typename MATRIX >

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

inline

Broken assignment operator.

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

References oomph::BrokenCopy::broken_assign().

◆ preconditioner_solve()

template<typename MATRIX >

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

virtual

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

Preconditioner solve for the two plus one diagonal preconditioner: Apply preconditioner to r and return z, so that P z = r

Implements oomph::Preconditioner.

  {   
   // Solve (1,1) diagonal block system:
   // Apply the subsidiary block preconditioner that acts on the
   // "bottom right" 1x1 sub-system (only!). The subsidiary preconditioner 
   // will extract the relevant (1x1) "sub-vectors" from the "big" (3x1)
   // vector big_r and treat it as the rhs, r, of P z = r
   // where P is 1x1 block diagonal. Once the system is solved,
   // the result is automatically put back into the appropriate places 
   // of the "big" (3x1) vector z:
   Second_subsidiary_preconditioner_pt->preconditioner_solve(r,z);
  
   // Perform matrix vector product with (0,1) off diagonal.
   DoubleVector temp;
   DoubleVector z_1;
   this->get_block_vector(1,z,z_1);
   Off_diagonal_matrix_vector_product_pt->multiply(z_1,temp);
   
   // Get r_0 from the RHS and modify it accordingly.
   DoubleVector r_0;
   this->get_block_vector(0,r,r_0);
   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" (3x1) rhs vector, big_r.
   // Therefore we first put the actual (2x1) rhs vector r_0 into the
   // "big" (3x1) 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" (3x1)
   // 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" (3x1) vector z:
   First_subsidiary_preconditioner_pt->preconditioner_solve(big_r,z);
  }

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

◆ set_multi_poisson_mesh()

template<typename MATRIX >

void oomph::TwoPlusOneUpperTriangularPreconditioner< 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::TwoPlusOneUpperTriangularPreconditioner< MATRIX >::Multi_poisson_mesh_pt.

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

◆ setup() [1/4]

template<typename MATRIX >

void oomph::TwoPlusOneUpperTriangularPreconditioner< 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);
  
  
 #ifdef PARANOID
   // This preconditioner only works for 3 dof types
   unsigned n_dof_types = this->ndof_types();
   if (n_dof_types!=3)
    {
     std::stringstream tmp;
     tmp << "This preconditioner only works for problems with 3 dof types\n"
         << "Yours has " << n_dof_types;
     throw OomphLibError(tmp.str(),
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
    }
 #endif
   
   // Combine into two major blocks, one containing dofs 0 and 1, the
   // final one dof, 2.
   
   Vector<unsigned> dof_to_block_map(3);
   dof_to_block_map[0]=0;
   dof_to_block_map[1]=0;
   dof_to_block_map[2]=1;
   this->block_setup(dof_to_block_map);
   
   // Create the subsidiary preconditioners
   //--------------------------------------
   
   // First one:
   {
    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 it into a subsidiary preconditioner, declaring which
    // of the three dof types in the present (master) preconditioner
    // correspond to the dof types in the subsidiary block preconditioner,
    // i.e. arguments: dof_map[doc_in_subsidiary]=dof_in_present
    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 one:
   {
    UpperTriangular<CRDoubleMatrix>* block_prec_pt=
     new UpperTriangular<CRDoubleMatrix>;
    Second_subsidiary_preconditioner_pt=block_prec_pt;
    
    // Set mesh
    block_prec_pt->set_multi_poisson_mesh(Multi_poisson_mesh_pt);
    
    // Turn it into a subsidiary preconditioner, declaring which
    // of the three dof types in the present (master) preconditioner
    // correspond to the dof types in the subsidiary block preconditioner i.e.
    // arguments: dof_map[doc_in_subsidiary]=dof_in_present
    unsigned n_sub_dof_types=1;
    Vector<unsigned> dof_map(n_sub_dof_types);
    dof_map[0] = 2;
    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()); 
   }
  
  
   // Set up off diagonal matrix vector product operator.
   {
    // Get the 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 since the 
    // matrix vector product operators stores what it needs
   }
  
  }

References OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::UpperTriangular< MATRIX >::set_multi_poisson_mesh(), oomph::UpperTriangular< MATRIX >::setup(), tmp, and oomph::BlockPreconditioner< MATRIX >::turn_into_subsidiary_block_preconditioner().

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

◆ setup() [2/4]

template<typename MATRIX >

virtual void oomph::Preconditioner::setup

virtual

Setup the preconditioner. Pure virtual generic interface function.

Implements oomph::Preconditioner.

◆ setup() [3/4]

template<typename MATRIX >

void oomph::Preconditioner::setup

inlinevirtual

Compatability layer for old preconditioners where problem pointers were needed. The problem pointer is only used to get a communicator pointer.

Implements oomph::Preconditioner.

     {
       ObsoleteCode::obsolete();
       setup(matrix_pt);
     }

◆ setup() [4/4]

template<typename MATRIX >

void oomph::Preconditioner::setup

inlinevirtual

Setup the preconditioner: store the matrix pointer and the communicator pointer then call preconditioner specific setup() function.

Implements oomph::Preconditioner.

     {
       // Store matrix pointer
       set_matrix_pt(matrix_pt);
  
       // Extract and store communicator pointer
       DistributableLinearAlgebraObject* dist_obj_pt =
         dynamic_cast<DistributableLinearAlgebraObject*>(matrix_pt);
       if (dist_obj_pt != 0)
       {
         set_comm_pt(dist_obj_pt->distribution_pt()->communicator_pt());
       }
       else
       {
         set_comm_pt(0);
       }
  
       double setup_time_start = TimingHelpers::timer();
       setup();
       double setup_time_finish = TimingHelpers::timer();
       Setup_time = setup_time_finish - setup_time_start;
     }

Member Data Documentation

◆ First_subsidiary_preconditioner_pt

template<typename MATRIX >

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

private

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

◆ Multi_poisson_mesh_pt

template<typename MATRIX >

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

private

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

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

◆ Off_diagonal_matrix_vector_product_pt

template<typename MATRIX >

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

private

Matrix vector product operators for the off diagonals.

◆ Second_subsidiary_preconditioner_pt

template<typename MATRIX >

Preconditioner* oomph::TwoPlusOneUpperTriangularPreconditioner< 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::TwoPlusOneUpperTriangularPreconditioner< MATRIX >

Constructor & Destructor Documentation

◆ TwoPlusOneUpperTriangularPreconditioner() [1/2]

◆ ~TwoPlusOneUpperTriangularPreconditioner()

◆ TwoPlusOneUpperTriangularPreconditioner() [2/2]

Member Function Documentation

◆ clean_up_my_memory()

◆ operator=()

◆ preconditioner_solve()

◆ set_multi_poisson_mesh()

◆ setup() [1/4]

◆ setup() [2/4]

◆ setup() [3/4]

◆ setup() [4/4]

Member Data Documentation

◆ First_subsidiary_preconditioner_pt

◆ Multi_poisson_mesh_pt

◆ Off_diagonal_matrix_vector_product_pt

◆ Second_subsidiary_preconditioner_pt

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