#include <pseudo_elastic_preconditioner.h>

Inheritance diagram for oomph::PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld:

Public Types
typedef Preconditioner (	SubsidiaryPreconditionerFctPt) ()

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

	~PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld ()
	Destructor. More...

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

void	clean_up_memory ()
	Broken assignment operator. More...

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

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

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

void	use_block_diagonal_approximation ()
	use as a block diagonal preconditioner More...

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

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

double &	scaling ()

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

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

virtual	~BlockPreconditioner ()
	Destructor. More...

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

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

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)

virtual void	block_setup ()

void	block_setup (const Vector< unsigned > &dof_to_block_map)

void	get_block (const unsigned &i, const unsigned &j, CRDoubleMatrix &output_matrix, const bool &ignore_replacement_block=false) const

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

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

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

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

void	get_dof_level_block (const unsigned &block_i, const unsigned &block_j, CRDoubleMatrix &output_block, const bool &ignore_replacement_block) const

CRDoubleMatrix	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< CRDoubleMatrix > *	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, CRDoubleMatrix &output_block) const

void	internal_get_block (const unsigned &block_i, const unsigned &block_j, CRDoubleMatrix &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 CRDoubleMatrix *block_matrix_pt) const

int	get_index_of_value (const Vector< myType > &vec, const myType val, const bool sorted=false) 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)

Private Attributes
Vector< PseudoElasticPreconditionerSubsidiaryPreconditionerOld * >	Diagonal_block_preconditioner_pt

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

unsigned	Method

SubsidiaryPreconditionerFctPt	Subsidiary_preconditioner_function_pt
	The SubisidaryPreconditionerFctPt. More...

double	Scaling
	The scaling. default 1.0. More...

Additional Inherited Members
Protected Member Functions inherited from oomph::BlockPreconditioner< CRDoubleMatrix >
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< CRDoubleMatrix >
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

///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// Subsidiary helper preconditioner for the PseudoElasticPreconditioner. Required for block preconditioner of the augmented elastic subsidiary problem. NOTE:

This is only intended to be used as a subsidiary preconditioner within the PseudoElasticPreconditioner.
If this preconditioner has N DOF types then the first N/2 are assumed to be ordinary solid DOF types, and the second N/2 are the solid DOF types with lagrange multiplier tractions applied.
By default this preconditioner uses a superlu preconditioner.

Member Typedef Documentation

◆ SubsidiaryPreconditionerFctPt

typedef Preconditioner*(* oomph::PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld::SubsidiaryPreconditionerFctPt) ()

This preconditioner includes the option to use subsidiary operators other than SuperLUPreconditioner for this problem. This is the typedef of a function that should return an instance of a subsidiary preconditioning operator. This preconditioner is responsible for the destruction of the subsidiary preconditioners.

Constructor & Destructor Documentation

◆ PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld() [1/2]

oomph::PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld::PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld ( )

inline

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

       : BlockPreconditioner<CRDoubleMatrix>()
     {
       // null the subsidiary preconditioner function pointer
       Subsidiary_preconditioner_function_pt = 0;
  
       // default to block diagonal
       Method = 0;
  
       // default scaling = 1.0
       Scaling = 1.0;
     };

References Method, Scaling, and Subsidiary_preconditioner_function_pt.

◆ ~PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld()

oomph::PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld::~PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld ( )

inline

Destructor.

     {
       this->clean_up_memory();
     }

References clean_up_memory().

◆ PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld() [2/2]

oomph::PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld::PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld ( const PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld & )

delete

Broken copy constructor.

Member Function Documentation

◆ clean_up_memory()

void oomph::PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld::clean_up_memory ( )

virtual

Broken assignment operator.

clean up the memory

//////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////

Reimplemented from oomph::Preconditioner.

   {
     // number of block types
     unsigned n_block = Diagonal_block_preconditioner_pt.size();
  
     // delete diagonal blocks
     for (unsigned i = 0; i < n_block; i++)
     {
       delete Diagonal_block_preconditioner_pt[i];
       Diagonal_block_preconditioner_pt[i] = 0;
       if (Method == 1)
       {
         for (unsigned j = i + 1; j < n_block; j++)
         {
           delete Off_diagonal_matrix_vector_products(i, j);
           Off_diagonal_matrix_vector_products(i, j) = 0;
         }
       }
       else if (Method == 2)
       {
         for (unsigned j = 0; j < i; j++)
         {
           delete Off_diagonal_matrix_vector_products(i, j);
           Off_diagonal_matrix_vector_products(i, j) = 0;
         }
       }
     }
  
     // clean up the block preconditioner
     this->clear_block_preconditioner_base();
   }

References oomph::BlockPreconditioner< CRDoubleMatrix >::clear_block_preconditioner_base(), Diagonal_block_preconditioner_pt, i, j, Method, and Off_diagonal_matrix_vector_products.

Referenced by setup(), and ~PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld().

◆ preconditioner_solve()

void oomph::PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld::preconditioner_solve	(	const DoubleVector &	res,
		DoubleVector &	z
	)

virtual

Apply preconditioner to r.

Implements oomph::Preconditioner.

   {
     // copy r
     DoubleVector r(res);
  
     unsigned n_block;
  
     // Cache umber of block types (also the spatial DIM)
     n_block = this->nblock_types();
  
     // loop parameters
     int start = n_block - 1;
     int end = -1;
     int step = -1;
     if (Method != 1)
     {
       start = 0;
       end = n_block;
       step = 1;
     }
  
     // the preconditioning method.
     // 0 - block diagonal
     // 1 - upper triangular
     // 2 - lower triangular
     //
     // loop over the DIM
     //
     // For Method = 0 or 2 (diagonal, lower)
     // start = 2, end = -1, step = -1
     // i = 2,1,0
     //
     // For Method = 1 (upper)
     // start = 0, end = 3 step = 1
     // i = 0, 1, 2
     for (int i = start; i != end; i += step)
     {
       // solve
       Diagonal_block_preconditioner_pt[i]->preconditioner_solve(r, z);
  
       // if upper or lower triangular
       if (Method != 0)
       {
         // substitute
         //
         for (int j = i + step; j != end; j += step)
         {
           DoubleVector x;
           this->get_block_vector(i, z, x);
           DoubleVector y;
           Off_diagonal_matrix_vector_products(j, i)->multiply(x, y);
           x.clear();
           this->get_block_vector(j, r, x);
           x -= y;
           this->return_block_vector(j, x, r);
         } // substitute
       } // if upper or lower
     } // for loop over DIM
   } // Block preconditioner solve

References Diagonal_block_preconditioner_pt, Eigen::placeholders::end, oomph::BlockPreconditioner< CRDoubleMatrix >::get_block_vector(), i, j, Method, oomph::BlockPreconditioner< CRDoubleMatrix >::nblock_types(), Off_diagonal_matrix_vector_products, UniformPSDSelfTest::r, res, oomph::BlockPreconditioner< CRDoubleMatrix >::return_block_vector(), oomph::CumulativeTimings::start(), plotDoE::x, and y.

◆ scaling()

double& oomph::PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld::scaling ( )

inline

Specify the scaling. Default is 1.0 Must be set before setup(...).

     {
       return Scaling;
     }

References Scaling.

Referenced by oomph::PseudoElasticPreconditionerOld::setup().

◆ set_subsidiary_preconditioner_function()

void oomph::PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld::set_subsidiary_preconditioner_function ( SubsidiaryPreconditionerFctPt sub_prec_fn )

inline

access function to set the subsidiary preconditioner function.

     {
       Subsidiary_preconditioner_function_pt = sub_prec_fn;
     };

References Subsidiary_preconditioner_function_pt.

Referenced by oomph::PseudoElasticPreconditionerOld::setup().

◆ setup()

void oomph::PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld::setup ( )

virtual

Setup the preconditioner.

Implements oomph::Preconditioner.

   {
     // clean the memory
     this->clean_up_memory();
  
     // determine the number of DOF types
     unsigned n_dof_types = this->ndof_types();
  
 #ifdef PARANOID
     // must be Dim*2 dof types
     if (n_dof_types % 2 != 0)
     {
       std::ostringstream error_message;
       error_message << "This preconditioner requires DIM*3 types of DOF";
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // store the dimension of the problem
     unsigned dim = n_dof_types / 2;
  
     // assemble the dof to block lookup scheme
     Vector<unsigned> dof_to_block_map(n_dof_types, 0);
     for (unsigned d = 0; d < dim; d++)
     {
       dof_to_block_map[d] = d;
       dof_to_block_map[d + dim] = d;
     }
  
     // setup the blocks look up schemes
     this->block_setup(dof_to_block_map);
  
     // Storage for the diagonal block preconditioners
     Diagonal_block_preconditioner_pt.resize(dim);
  
     // storage for the off diagonal matrix vector products
     Off_diagonal_matrix_vector_products.resize(dim, dim, 0);
  
     // setup the subsidiary preconditioners
     for (unsigned d = 0; d < dim; d++)
     {
       Vector<unsigned> dof_list(2);
       dof_list[0] = d;
       dof_list[1] = d + dim;
  
       Diagonal_block_preconditioner_pt[d] =
         new PseudoElasticPreconditionerSubsidiaryPreconditionerOld;
       Diagonal_block_preconditioner_pt[d]
         ->turn_into_subsidiary_block_preconditioner(this, dof_list);
       if (Subsidiary_preconditioner_function_pt != 0)
       {
         Diagonal_block_preconditioner_pt[d]
           ->set_subsidiary_preconditioner_function(
             Subsidiary_preconditioner_function_pt);
       }
       Diagonal_block_preconditioner_pt[d]->scaling() = Scaling;
  
       Diagonal_block_preconditioner_pt[d]->Preconditioner::setup(matrix_pt());
  
       // the preconditioning method.\n
       // 0 - block diagonal\n
       // 1 - upper triangular\n
       // 2 - lower triangular\n
       // next setup the off diagonal mat vec operators if required
       if (Method == 1 || Method == 2)
       {
         unsigned l = d + 1;
         unsigned u = dim;
         if (Method == 2)
         {
           l = 0;
           u = d;
         }
         for (unsigned j = l; j < u; j++)
         {
           CRDoubleMatrix* block_matrix_pt = new CRDoubleMatrix;
           this->get_block(d, j, *block_matrix_pt);
           Off_diagonal_matrix_vector_products(d, j) = new MatrixVectorProduct();
           //        Off_diagonal_matrix_vector_products(d,j)->setup(block_matrix_pt);
           this->setup_matrix_vector_product(
             Off_diagonal_matrix_vector_products(d, j), block_matrix_pt, j);
  
           delete block_matrix_pt;
           block_matrix_pt = 0;
         }
       }
     } // setup the subsidiary preconditioner.
   } // preconditioner setup

References oomph::BlockPreconditioner< CRDoubleMatrix >::block_setup(), clean_up_memory(), Diagonal_block_preconditioner_pt, oomph::BlockPreconditioner< CRDoubleMatrix >::get_block(), j, oomph::BlockPreconditioner< CRDoubleMatrix >::matrix_pt(), Method, oomph::BlockPreconditioner< CRDoubleMatrix >::ndof_types(), Off_diagonal_matrix_vector_products, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Scaling, oomph::BlockPreconditioner< CRDoubleMatrix >::setup_matrix_vector_product(), and Subsidiary_preconditioner_function_pt.

◆ use_block_diagonal_approximation()

void oomph::PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld::use_block_diagonal_approximation ( )

inline

use as a block diagonal preconditioner

     {
       Method = 0;
     }

References Method.

Referenced by oomph::PseudoElasticPreconditionerOld::setup().

◆ use_lower_triangular_approximation()

void oomph::PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld::use_lower_triangular_approximation ( )

inline

Use as a lower triangular preconditioner.

     {
       Method = 2;
     }

References Method.

Referenced by oomph::PseudoElasticPreconditionerOld::setup().

◆ use_upper_triangular_approximation()

void oomph::PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld::use_upper_triangular_approximation ( )

inline

Use as an upper triangular preconditioner.

     {
       Method = 1;
     }

References Method.

Referenced by oomph::PseudoElasticPreconditionerOld::setup().

Member Data Documentation

◆ Diagonal_block_preconditioner_pt

Vector<PseudoElasticPreconditionerSubsidiaryPreconditionerOld*> oomph::PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld::Diagonal_block_preconditioner_pt

private

Vector of SuperLU preconditioner pointers for storing the preconditioners for each diagonal block

Referenced by clean_up_memory(), preconditioner_solve(), and setup().

◆ Method

unsigned oomph::PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld::Method

private

the preconditioning method. 0 - block diagonal 1 - upper triangular 2 - lower triangular

Referenced by clean_up_memory(), preconditioner_solve(), PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld(), setup(), use_block_diagonal_approximation(), use_lower_triangular_approximation(), and use_upper_triangular_approximation().

◆ Off_diagonal_matrix_vector_products

DenseMatrix<MatrixVectorProduct*> oomph::PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld::Off_diagonal_matrix_vector_products

private

Matrix of matrix vector product operators for the off diagonals.

Referenced by clean_up_memory(), preconditioner_solve(), and setup().

◆ Scaling

double oomph::PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld::Scaling

private

The scaling. default 1.0.

Referenced by PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld(), scaling(), and setup().

◆ Subsidiary_preconditioner_function_pt

SubsidiaryPreconditionerFctPt oomph::PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld::Subsidiary_preconditioner_function_pt

private

The SubisidaryPreconditionerFctPt.

Referenced by PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld(), set_subsidiary_preconditioner_function(), and setup().

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

Public Types

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ SubsidiaryPreconditionerFctPt

Constructor & Destructor Documentation

◆ PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld() [1/2]

◆ ~PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld()

◆ PseudoElasticPreconditionerSubsidiaryBlockPreconditionerOld() [2/2]

Member Function Documentation

◆ clean_up_memory()

◆ preconditioner_solve()

◆ scaling()

◆ set_subsidiary_preconditioner_function()

◆ setup()

◆ use_block_diagonal_approximation()

◆ use_lower_triangular_approximation()

◆ use_upper_triangular_approximation()

Member Data Documentation

◆ Diagonal_block_preconditioner_pt

◆ Method

◆ Off_diagonal_matrix_vector_products

◆ Scaling

◆ Subsidiary_preconditioner_function_pt