#include <multi_poisson_block_preconditioners.h>

Inheritance diagram for oomph::UpperTriangular< MATRIX >:

Public Member Functions
	UpperTriangular ()
	Constructor. More...

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

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

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

void	operator= (const UpperTriangular &)
	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_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
DenseMatrix< MatrixVectorProduct * >	Off_diagonal_matrix_vector_product_pt
	Pointers to matrix vector product operators for the off diagonals. More...

Vector< Preconditioner * >	Block_preconditioner_pt

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

//////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// Upper triangular preconditioner for a system with any number of dof types.

Constructor & Destructor Documentation

◆ UpperTriangular() [1/2]

template<typename MATRIX >

oomph::UpperTriangular< MATRIX >::UpperTriangular ( )

inline

Constructor.

                     : BlockPreconditioner<MATRIX>()
    {
     Multi_poisson_mesh_pt=0;
    }

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

◆ ~UpperTriangular()

template<typename MATRIX >

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

inlinevirtual

Destructor - delete the preconditioner matrices.

    {
     this->clean_up_my_memory();
    }

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

◆ UpperTriangular() [2/2]

template<typename MATRIX >

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

inline

Broken copy constructor.

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

References oomph::BrokenCopy::broken_copy().

Member Function Documentation

◆ clean_up_my_memory()

template<typename MATRIX >

void oomph::UpperTriangular< MATRIX >::clean_up_my_memory

virtual

clean up the memory

The clean up function.

  {     
   // Delete anything in Off_diagonal_matrix_vector_products
   for(unsigned i=0,ni=Off_diagonal_matrix_vector_product_pt.nrow();i<ni;i++)
    {
     for(unsigned j=0,nj=Off_diagonal_matrix_vector_product_pt.ncol();j<nj;j++)
      {
       if(Off_diagonal_matrix_vector_product_pt(i,j) != 0)
        {    
         delete Off_diagonal_matrix_vector_product_pt(i,j);
         Off_diagonal_matrix_vector_product_pt(i,j) = 0;
        }
      }
    }
  
   // Delete preconditioners (approximate solvers)
   unsigned n_block = Block_preconditioner_pt.size();
   for (unsigned i=0;i<n_block;i++)
    {
     if(Block_preconditioner_pt[i]!=0)
      {
       delete Block_preconditioner_pt[i];
       Block_preconditioner_pt[i]=0;
      }
    }
  } // End of clean_up_my_memory function.

References i, and j.

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

◆ operator=()

template<typename MATRIX >

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

inline

Broken assignment operator.

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

References oomph::BrokenCopy::broken_assign().

◆ preconditioner_solve()

template<typename MATRIX >

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

virtual

Apply preconditioner to r.

Preconditioner solve for the upper triangular preconditioner: 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.

  {
   // Get number of blocks
   unsigned n_block = this->nblock_types();
  
   // vector of vectors for each section of rhs 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);
  
   // Required to be an int due to an unsigned being unable to be compared to a
   // negative number (because it would roll over).
   for (int i=n_block-1;i>-1;i--)
    {
     // Back substitute
     for (unsigned j=i+1;j<n_block;j++)
      {
       DoubleVector temp;
       Off_diagonal_matrix_vector_product_pt(i,j)->multiply(block_z[j],temp);
       block_r[i] -= temp;
      } // End for over j
  
     // Solve on the block
     this->Block_preconditioner_pt[i]->
      preconditioner_solve(block_r[i], block_z[i]);
    } // End for over i
  
   // Copy solution in block vectors block_r back to z
   this->return_block_vectors(block_z,z);
  }

References i, j, and UniformPSDSelfTest::r.

◆ set_multi_poisson_mesh()

template<typename MATRIX >

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

Referenced by MultiPoissonProblem< ELEMENT >::MultiPoissonProblem(), oomph::TwoPlusThreeUpperTriangularWithOneLevelSubsidiary< MATRIX >::setup(), oomph::TwoPlusOneUpperTriangularPreconditioner< MATRIX >::setup(), oomph::TwoPlusThreeUpperTriangularWithTwoLevelSubsidiary< MATRIX >::setup(), oomph::TwoPlusThreeUpperTriangularWithReplace< MATRIX >::setup(), oomph::CoarseTwoPlusTwoPlusOne< MATRIX >::setup(), and oomph::OnePlusFourWithTwoCoarse< MATRIX >::setup().

◆ setup() [1/4]

template<typename MATRIX >

void oomph::UpperTriangular< MATRIX >::setup

virtual

Setup the preconditioner.

The setup function.

Implements oomph::Preconditioner.

  {
   // clean the 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);
  
   // Set up the block look up schemes
   this->block_setup();
  
   // Number of block types  
   unsigned nblock_types = this->nblock_types();
  
   // Storage for the pointers to the off diagonal matrix vector products
   // and the the subsidiary preconditioners (inexact solvers) for the diagonal 
   // blocks
   Off_diagonal_matrix_vector_product_pt.resize(nblock_types,nblock_types,0);
   Block_preconditioner_pt.resize(nblock_types);
  
   // Build the preconditioners and matrix vector products
   for(unsigned i = 0; i < nblock_types; i++)
    {
     // Create the subsidiary preconditioners
     Block_preconditioner_pt[i] = new SuperLUPreconditioner;
     
     // Put in braces so block matrix goes out of scope when done...
     {
      // Get block -- this makes a deep copy of the relevant entries in the
      // full Jacobian (i.e. the matrix of the linear system we're
      // actually trying to solve); we can do with this copy whatever
      // we want...
      CRDoubleMatrix block;
      this->get_block(i,i,block);
      
      // Set up preconditioner (i.e. lu-decompose the block)
      Block_preconditioner_pt[i]->setup(&block);
      
      // Done with this block now, so the diagonal block that we extracted
      // above can go out of scope. Its LU decomposition (which is the only 
      // thing we need to apply the preconditioner in the 
      // preconditioner_solve(...) function) is retained in the associated 
      // sub-preconditioner/(in)exact solver(SuperLU).
  
     } // end of brace to make block go out of scope
      
     // Next set up the off diagonal mat vec operators
     for(unsigned j=i+1;j<nblock_types;j++)
      {
       // Get the off diagonal block
       CRDoubleMatrix block_matrix = this->get_block(i,j);
  
       // Create a matrix vector product operator
       Off_diagonal_matrix_vector_product_pt(i,j) = new MatrixVectorProduct;
  
       // Setup the matrix vector product for the currrent block matrix
       // and specify the column in the "big matrix" as final argument.
       // This is needed for things to work properly in parallel -- don't ask!
       this->setup_matrix_vector_product(
        Off_diagonal_matrix_vector_product_pt(i,j),&block_matrix,j);
  
       // Done with this block now, so the diagonal block that we extracted
       // above can go out of scope. The MatrixVectorProduct operator retains
       // its own copy of whatever data it needs.
  
      } // End for loop over j
    } // End for loop over i
  } // End setup(...)

References block(), i, j, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by oomph::TwoPlusThreeUpperTriangularWithOneLevelSubsidiary< MATRIX >::setup(), oomph::TwoPlusOneUpperTriangularPreconditioner< MATRIX >::setup(), oomph::TwoPlusThreeUpperTriangularWithTwoLevelSubsidiary< MATRIX >::setup(), oomph::TwoPlusThreeUpperTriangularWithReplace< MATRIX >::setup(), oomph::CoarseTwoPlusTwoPlusOne< MATRIX >::setup(), and oomph::OnePlusFourWithTwoCoarse< 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

◆ Block_preconditioner_pt

template<typename MATRIX >

Vector<Preconditioner*> oomph::UpperTriangular< MATRIX >::Block_preconditioner_pt

private

Vector of pointers to preconditioners/inexact solvers for each diagonal block

◆ Multi_poisson_mesh_pt

template<typename MATRIX >

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

private

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

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

◆ Off_diagonal_matrix_vector_product_pt

template<typename MATRIX >

DenseMatrix<MatrixVectorProduct*> oomph::UpperTriangular< MATRIX >::Off_diagonal_matrix_vector_product_pt

private

Pointers to matrix vector product operators for the off diagonals.

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

Constructor & Destructor Documentation

◆ UpperTriangular() [1/2]

◆ ~UpperTriangular()

◆ UpperTriangular() [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

◆ Block_preconditioner_pt

◆ Multi_poisson_mesh_pt

◆ Off_diagonal_matrix_vector_product_pt

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