#include <pseudo_elastic_preconditioner.h>

Inheritance diagram for oomph::PseudoElasticPreconditioner:

Public Types
enum	Elastic_preconditioner_type { Exact_block_preconditioner , Block_diagonal_preconditioner , Block_lower_triangular_preconditioner , Block_upper_triangular_preconditioner }

typedef Preconditioner (	SubsidiaryPreconditionerFctPt) ()

Public Member Functions
	PseudoElasticPreconditioner ()
	Default (and only) constructor. More...

virtual	~PseudoElasticPreconditioner ()
	destructor More...

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

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

void	preconditioner_solve (const DoubleVector &r, DoubleVector &z)

void	set_elastic_mesh (Mesh *mesh_pt)

void	set_lagrange_multiplier_mesh (Mesh *mesh_pt)

void	enable_inf_norm_of_s_scaling ()
	Call to use the inf norm of S as scaling. More...

void	disable_inf_norm_of_s_scaling ()
	Call to use no scaling. More...

void	set_lagrange_multiplier_subsidiary_preconditioner (SubsidiaryPreconditionerFctPt prec_fn)

void	set_elastic_subsidiary_preconditioner (SubsidiaryPreconditionerFctPt prec_fn)

Elastic_preconditioner_type &	elastic_preconditioner_type ()

void	clean_up_memory ()
	Clears the memory. More...

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 Member Functions
void	elastic_preconditioner_solve (const DoubleVector &r, DoubleVector &z)
	Apply the elastic subsidiary preconditioner. More...

void	lagrange_multiplier_preconditioner_solve (const DoubleVector &r, DoubleVector &z)
	Apply the lagrange multiplier subsidiary preconditioner. More...

Private Attributes
double	Scaling
	The scaling. Defaults to infinity norm of S. More...

bool	Use_inf_norm_of_s_scaling

Elastic_preconditioner_type	E_preconditioner_type

unsigned	Dim
	the dimension of the problem More...

Preconditioner *	Elastic_preconditioner_pt
	storage for the preconditioner for the solid system More...

Vector< Preconditioner * >	Lagrange_multiplier_preconditioner_pt
	lagrange multiplier preconditioner pt More...

SubsidiaryPreconditionerFctPt	Lagrange_multiplier_subsidiary_preconditioner_function_pt
	The Lagrange multiplier subsidiary preconditioner function pointer. More...

SubsidiaryPreconditionerFctPt	Elastic_subsidiary_preconditioner_function_pt
	The solid subsidiary preconditioner function pointer. More...

Mesh *	Elastic_mesh_pt
	Pointer to the mesh containing the solid elements. More...

Mesh *	Lagrange_multiplier_mesh_pt
	Pointer to the mesh containing the Lagrange multiplier elements. More...

Friends
class	PseudoElasticFSIPreconditioner

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

//////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// A subsidiary preconditioner for the pseudo-elastic FSI preconditioner. Also a stand-alone preconditioner for the problem of non-linear elasticity subject to prescribed displacement by Lagrange multiplier. Enumeration of Elastic DOF types in the Pseudo-Elastic Elements The method get_dof_types_for_unknowns() must be implemented such that DOFs subject be Lagrange multiplier and DOFs NOT subject to Lagrange multiplier have different labels. For example in a 3D problem there are 6 DOF types and the following labelling must be implemented: 0 - x displacement (without lagr mult traction) 1 - y displacement (without lagr mult traction) 2 - z displacement (without lagr mult traction) 4 - x displacement (with lagr mult traction) 5 - y displacement (with lagr mult traction) 6 - z displacement (with lagr mult traction)

Member Typedef Documentation

◆ SubsidiaryPreconditionerFctPt

typedef Preconditioner*(* oomph::PseudoElasticPreconditioner::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.

Member Enumeration Documentation

◆ Elastic_preconditioner_type

enum oomph::PseudoElasticPreconditioner::Elastic_preconditioner_type

The augmented elasticity system can be preconditioned in one of four ways. 0 - Exact preconditioner 1 - Block diagonal preconditioning 2 - Block upper triangular preconditioner 3 - Block lower triangular preconditioner We group together the different components of the displacement vector field for the block decomposition.

Enumerator
Exact_block_preconditioner
Block_diagonal_preconditioner
Block_lower_triangular_preconditioner
Block_upper_triangular_preconditioner

     {
       Exact_block_preconditioner,
       Block_diagonal_preconditioner,
       Block_lower_triangular_preconditioner,
       Block_upper_triangular_preconditioner
     };

Constructor & Destructor Documentation

◆ PseudoElasticPreconditioner() [1/2]

oomph::PseudoElasticPreconditioner::PseudoElasticPreconditioner ( )

inline

Default (and only) constructor.

     {
       // null pointers
       Lagrange_multiplier_subsidiary_preconditioner_function_pt = 0;
       Elastic_subsidiary_preconditioner_function_pt = 0;
       Elastic_preconditioner_pt = 0;
  
       // set defaults
       Use_inf_norm_of_s_scaling = true;
       E_preconditioner_type = Exact_block_preconditioner;
  
       // resize the Mesh_pt
       Lagrange_multiplier_mesh_pt = 0;
       Elastic_mesh_pt = 0;
     }

References E_preconditioner_type, Elastic_mesh_pt, Elastic_preconditioner_pt, Elastic_subsidiary_preconditioner_function_pt, Exact_block_preconditioner, Lagrange_multiplier_mesh_pt, Lagrange_multiplier_subsidiary_preconditioner_function_pt, and Use_inf_norm_of_s_scaling.

◆ ~PseudoElasticPreconditioner()

virtual oomph::PseudoElasticPreconditioner::~PseudoElasticPreconditioner ( )

inlinevirtual

destructor

     {
       this->clean_up_memory();
     }

References clean_up_memory().

◆ PseudoElasticPreconditioner() [2/2]

oomph::PseudoElasticPreconditioner::PseudoElasticPreconditioner ( const PseudoElasticPreconditioner & )

delete

Broken copy constructor.

Member Function Documentation

◆ clean_up_memory()

void oomph::PseudoElasticPreconditioner::clean_up_memory ( )

virtual

Clears the memory.

Reimplemented from oomph::Preconditioner.

   {
     // clean the block preconditioner base class memory
     this->clear_block_preconditioner_base();
  
     // delete the solid preconditioner
     delete Elastic_preconditioner_pt;
     Elastic_preconditioner_pt = 0;
  
     // delete the lagrange multiplier preconditioner pt
     unsigned sz = Lagrange_multiplier_preconditioner_pt.size();
     for (unsigned i = 0; i < sz; i++)
     {
       delete Lagrange_multiplier_preconditioner_pt[i];
       Lagrange_multiplier_preconditioner_pt[i] = 0;
     }
   }

References oomph::BlockPreconditioner< CRDoubleMatrix >::clear_block_preconditioner_base(), Elastic_preconditioner_pt, i, and Lagrange_multiplier_preconditioner_pt.

Referenced by oomph::PseudoElasticFSIPreconditioner::clean_up_memory(), setup(), and ~PseudoElasticPreconditioner().

◆ disable_inf_norm_of_s_scaling()

void oomph::PseudoElasticPreconditioner::disable_inf_norm_of_s_scaling ( )

inline

Call to use no scaling.

     {
       Use_inf_norm_of_s_scaling = false;
     }

References Use_inf_norm_of_s_scaling.

◆ elastic_preconditioner_solve()

void oomph::PseudoElasticPreconditioner::elastic_preconditioner_solve	(	const DoubleVector &	r,
		DoubleVector &	z
	)

private

Apply the elastic subsidiary preconditioner.

   {
     // apply the solid preconditioner
     Elastic_preconditioner_pt->preconditioner_solve(r, z);
   }

References Elastic_preconditioner_pt, oomph::Preconditioner::preconditioner_solve(), and UniformPSDSelfTest::r.

Referenced by oomph::PseudoElasticFSIPreconditioner::preconditioner_solve(), and preconditioner_solve().

◆ elastic_preconditioner_type()

Elastic_preconditioner_type& oomph::PseudoElasticPreconditioner::elastic_preconditioner_type ( )

inline

Set the type of preconditioner applied to the elastic: 0 - Exact preconditioner 1 - Block diagonal preconditioning 2 - Block upper triangular preconditioner 3 - Block lower triangular preconditioner We group together the different components of the displacement vector field for the block decomposition.

     {
       return E_preconditioner_type;
     }

References E_preconditioner_type.

Referenced by PrescribedBoundaryDisplacementProblem< ELEMENT >::PrescribedBoundaryDisplacementProblem(), FSIChannelWithLeafletProblem< ELEMENT >::set_iterative_solver(), PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::set_pseudo_elastic_fsi_solver(), and set_pseudo_elastic_fsi_solver().

◆ enable_inf_norm_of_s_scaling()

void oomph::PseudoElasticPreconditioner::enable_inf_norm_of_s_scaling ( )

inline

Call to use the inf norm of S as scaling.

     {
       Use_inf_norm_of_s_scaling = true;
     }

References Use_inf_norm_of_s_scaling.

◆ lagrange_multiplier_preconditioner_solve()

void oomph::PseudoElasticPreconditioner::lagrange_multiplier_preconditioner_solve	(	const DoubleVector &	r,
		DoubleVector &	z
	)

private

Apply the lagrange multiplier subsidiary preconditioner.

   {
     // apply the lagrange multiplier preconditioner
     for (unsigned d = 0; d < Dim; d++)
     {
       DoubleVector x;
       this->get_block_vector(Dim * 2 + d, r, x);
       DoubleVector y;
       Lagrange_multiplier_preconditioner_pt[d]->preconditioner_solve(x, y);
       Lagrange_multiplier_preconditioner_pt[d]->preconditioner_solve(y, x);
       unsigned nrow_local = x.nrow_local();
       double* x_pt = x.values_pt();
       for (unsigned i = 0; i < nrow_local; i++)
       {
         x_pt[i] = x_pt[i] * Scaling;
       }
       this->return_block_vector(Dim * 2 + d, x, z);
     }
   }

References Dim, oomph::BlockPreconditioner< CRDoubleMatrix >::get_block_vector(), i, Lagrange_multiplier_preconditioner_pt, oomph::DistributableLinearAlgebraObject::nrow_local(), UniformPSDSelfTest::r, oomph::BlockPreconditioner< CRDoubleMatrix >::return_block_vector(), Scaling, plotDoE::x, and y.

Referenced by oomph::PseudoElasticFSIPreconditioner::preconditioner_solve(), and preconditioner_solve().

◆ preconditioner_solve()

void oomph::PseudoElasticPreconditioner::preconditioner_solve	(	const DoubleVector &	r,
		DoubleVector &	z
	)

inlinevirtual

Apply the preconditioner. Method implemented in two other methods (elastic and lagrange multiplier subsidiary preocnditioner) for the PseudoElasticFSIPreconditioner

Implements oomph::Preconditioner.

     {
       this->elastic_preconditioner_solve(r, z);
       this->lagrange_multiplier_preconditioner_solve(r, z);
     }

References elastic_preconditioner_solve(), and lagrange_multiplier_preconditioner_solve().

◆ set_elastic_mesh()

void oomph::PseudoElasticPreconditioner::set_elastic_mesh ( Mesh * mesh_pt )

inline

Access function to mesh containing the block-preconditionable elastic elements

     {
       Elastic_mesh_pt = mesh_pt;
     }

References Elastic_mesh_pt, and oomph::BlockPreconditioner< CRDoubleMatrix >::mesh_pt().

Referenced by PrescribedBoundaryDisplacementProblem< ELEMENT >::PrescribedBoundaryDisplacementProblem(), and oomph::PseudoElasticFSIPreconditioner::setup().

◆ set_elastic_subsidiary_preconditioner()

void oomph::PseudoElasticPreconditioner::set_elastic_subsidiary_preconditioner ( SubsidiaryPreconditionerFctPt prec_fn )

inline

By default the elastic subsidiary systems are preconditioner with SuperLUPreconditioner. For a different preconditioner, pass a function to this method returning a different subsidiary operator.

     {
       Elastic_subsidiary_preconditioner_function_pt = prec_fn;
     }

References Elastic_subsidiary_preconditioner_function_pt.

Referenced by PrescribedBoundaryDisplacementProblem< ELEMENT >::PrescribedBoundaryDisplacementProblem(), PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::set_pseudo_elastic_fsi_solver(), and set_pseudo_elastic_fsi_solver().

◆ set_lagrange_multiplier_mesh()

void oomph::PseudoElasticPreconditioner::set_lagrange_multiplier_mesh ( Mesh * mesh_pt )

inline

Access function to mesh containing the block-preconditionable lagrange multiplier elements

     {
       Lagrange_multiplier_mesh_pt = mesh_pt;
     }

References Lagrange_multiplier_mesh_pt, and oomph::BlockPreconditioner< CRDoubleMatrix >::mesh_pt().

Referenced by PrescribedBoundaryDisplacementProblem< ELEMENT >::PrescribedBoundaryDisplacementProblem(), and oomph::PseudoElasticFSIPreconditioner::setup().

◆ set_lagrange_multiplier_subsidiary_preconditioner()

void oomph::PseudoElasticPreconditioner::set_lagrange_multiplier_subsidiary_preconditioner ( SubsidiaryPreconditionerFctPt prec_fn )

inline

By default the Lagrange multiplier subsidiary systems are preconditioner with SuperLUPreconditioner. For a different preconditioner, pass a function to this method returning a different subsidiary operator.

     {
       Lagrange_multiplier_subsidiary_preconditioner_function_pt = prec_fn;
     }

References Lagrange_multiplier_subsidiary_preconditioner_function_pt.

Referenced by PrescribedBoundaryDisplacementProblem< ELEMENT >::PrescribedBoundaryDisplacementProblem(), PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::set_pseudo_elastic_fsi_solver(), and set_pseudo_elastic_fsi_solver().

◆ setup()

void oomph::PseudoElasticPreconditioner::setup ( )

virtual

Broken assignment operator.

Setup method for the PseudoElasticPreconditioner.

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

Implements oomph::Preconditioner.

   {
     // clean
     this->clean_up_memory();
  
 #ifdef PARANOID
     // paranoid check that meshes have been set
     if (Elastic_mesh_pt == 0)
     {
       std::ostringstream error_message;
       error_message << "The elastic mesh must be set.";
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
     if (Lagrange_multiplier_mesh_pt == 0)
     {
       std::ostringstream error_message;
       error_message << "The Lagrange multiplier mesh must be set.";
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // set the meshes
     this->set_nmesh(2);
     this->set_mesh(0, Elastic_mesh_pt);
     this->set_mesh(1, Lagrange_multiplier_mesh_pt);
  
     // Figure out number of dof types
     unsigned n_solid_dof_types = 0;
     unsigned n_dof_types = 0;
  
     if (this->is_master_block_preconditioner())
     {
       // get the number of solid dof types from the first element
       n_solid_dof_types = this->ndof_types_in_mesh(0);
  
       // get the total number of dof types
       n_dof_types = n_solid_dof_types + this->ndof_types_in_mesh(1);
     }
     else
     {
       n_dof_types = this->ndof_types();
       n_solid_dof_types = n_dof_types - (n_dof_types / 3);
     }
 #ifdef PARANOID
     if (n_dof_types % 3 != 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
  
     // determine the dimension
     Dim = n_dof_types / 3;
  
 #ifdef PARANOID
     // Recast Jacobian matrix to CRDoubleMatrix
     CRDoubleMatrix* cr_matrix_pt = dynamic_cast<CRDoubleMatrix*>(matrix_pt());
  
     if (cr_matrix_pt == 0)
     {
       std::ostringstream error_message;
       error_message << "FSIPreconditioner only works with"
                     << " CRDoubleMatrix matrices" << std::endl;
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // Setup the dof_list scheme for block_setup.
     // The natural DOF types order is (in 3D):
     // 0 1 2 3  4  5  6  7  8  <- natural DOF type index
     // x y z xc yc zc lx ly lz <- DOf type
     //
     // We need to group the directional displacements together:
     // 0 1  2 3  4  5  6  7  8  <- block index
     // x xc y yc xz zc lx ly lz <- DOF type
     //
     // The mapping required is:
     // 0 2 4 1 3 5 6 7 8
     //
     // In general we want:
     //
     //   dof_to_block_map[DOF type] = block type
     Vector<unsigned> dof_list_for_block_setup(n_dof_types);
     for (unsigned dim_i = 0; dim_i < Dim; dim_i++)
     {
       // bulk solid dof types
       dof_list_for_block_setup[dim_i] = 2 * dim_i;
  
       // constrained solid dof types
       dof_list_for_block_setup[dim_i + Dim] = 2 * dim_i + 1;
  
       // lagr dof types
       dof_list_for_block_setup[dim_i + 2 * Dim] = 2 * Dim + dim_i;
     }
  
     // Setup the block ordering. We have the following:
     // Block types [0, 2*Dim) are the solid blocks.
     // Block types [2*Dim, 3*Dim) are the Lagrange multiplier blocks.
     //
     // For d = 0, 1, 2,
     // Bulk solid doftypes: 2*d
     // Constrained solid doftypes: 2*d+1
     // Lgr doftyoes: 2*Dim + d
     this->block_setup(dof_list_for_block_setup);
  
     // Create dof_list for subsidiary preconditioner. This will be used later
     // in turn_into_subsidiary_block_preconditioner(...)
     Vector<unsigned> dof_list_for_subsidiary_prec(n_solid_dof_types);
  
     // The dof types are currently in the order (in 3D):
     // 0 1 2 3  4  5  6  7  8  <- DOF index
     // x y z xc yc zc lx ly lz <- DOF type
     //
     // We need to group the directional displacements together:
     // x xc y yc xz zc
     //
     // The mapping required is:
     // 0 3 1 4 2 5
     //
     // In general we want:
     //    dof_list[subsidiary DOF type] = master DOF type
     for (unsigned dim_i = 0; dim_i < Dim; dim_i++)
     {
       // bulk solid dof
       dof_list_for_subsidiary_prec[2 * dim_i] = dim_i;
  
       // constrained solid dof
       dof_list_for_subsidiary_prec[2 * dim_i + 1] = dim_i + Dim;
     }
  
     // Get the solid blocks
     DenseMatrix<CRDoubleMatrix*> solid_matrix_pt(
       n_solid_dof_types, n_solid_dof_types, 0);
  
     for (unsigned row_i = 0; row_i < n_solid_dof_types; row_i++)
     {
       for (unsigned col_i = 0; col_i < n_solid_dof_types; col_i++)
       {
         solid_matrix_pt(row_i, col_i) = new CRDoubleMatrix;
         this->get_block(row_i, col_i, *solid_matrix_pt(row_i, col_i));
       }
     }
  
     // compute the scaling (if required)
     if (Use_inf_norm_of_s_scaling)
     {
       Scaling = CRDoubleMatrixHelpers::inf_norm(solid_matrix_pt);
     }
     else
     {
       Scaling = 1.0;
     }
  
     // Add the scaled identify matrix to the constrained solid blocks.
     for (unsigned d = 0; d < Dim; d++)
     {
       // Where is the constrained block located?
       unsigned block_i = 2 * d + 1;
  
       // Data from the constrained block.
       double* s_values = solid_matrix_pt(block_i, block_i)->value();
       int* s_column_index = solid_matrix_pt(block_i, block_i)->column_index();
       int* s_row_start = solid_matrix_pt(block_i, block_i)->row_start();
       int s_nrow_local = solid_matrix_pt(block_i, block_i)->nrow_local();
       int s_first_row = solid_matrix_pt(block_i, block_i)->first_row();
  
       // Loop through the diagonal entries and add the scaling.
       for (int i = 0; i < s_nrow_local; i++)
       {
         bool found = false;
         for (int j = s_row_start[i]; j < s_row_start[i + 1] && !found; j++)
         {
           if (s_column_index[j] == i + s_first_row)
           {
             s_values[j] += Scaling;
             found = true;
           } // if
         } // for row start
  
         // Check if the diagonal entry is found.
         if (!found)
         {
           std::ostringstream error_message;
           error_message << "The diagonal entry for the constained block("
                         << block_i << "," << block_i << ")\n"
                         << "on local row " << i << " does not exist."
                         << std::endl;
           throw OomphLibError(error_message.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
       } // for nrow_local
     } // for Dim
  
  
     // setup the solid subsidiary preconditioner
     // //////////////////////////////// this preconditioner uses the full S
     // matrix
     if (E_preconditioner_type == Exact_block_preconditioner)
     {
       ExactBlockPreconditioner<CRDoubleMatrix>* s_prec_pt =
         new ExactBlockPreconditioner<CRDoubleMatrix>;
  
       // Add mesh (not actually used since this only acts as a subsidiary
       // preconditioner...
       // s_prec_pt->add_mesh(Elastic_mesh_pt);
  
       Vector<Vector<unsigned>> doftype_to_doftype_map(n_solid_dof_types,
                                                       Vector<unsigned>(1, 0));
  
       for (unsigned i = 0; i < n_solid_dof_types; i++)
       {
         doftype_to_doftype_map[i][0] = i;
       }
  
       s_prec_pt->turn_into_subsidiary_block_preconditioner(
         this, dof_list_for_subsidiary_prec, doftype_to_doftype_map);
  
       if (Elastic_subsidiary_preconditioner_function_pt != 0)
       {
         s_prec_pt->set_subsidiary_preconditioner_function(
           Elastic_subsidiary_preconditioner_function_pt);
       }
  
       // Set the replacement blocks.
       for (unsigned d = 0; d < Dim; d++)
       {
         // The dof-block located in the block-ordering.
         unsigned block_i = 2 * d + 1;
  
         // The dof-block located in the dof-ordering.
         unsigned dof_block_i = Dim + d;
         this->set_replacement_dof_block(
           dof_block_i, dof_block_i, solid_matrix_pt(block_i, block_i));
       }
  
       s_prec_pt->Preconditioner::setup(matrix_pt());
       Elastic_preconditioner_pt = s_prec_pt;
     }
     // otherwise it is a block based preconditioner
     else
     {
       GeneralPurposeBlockPreconditioner<CRDoubleMatrix>* s_prec_pt = 0;
  
       // set the block preconditioning method
       switch (E_preconditioner_type)
       {
         case Block_diagonal_preconditioner:
         {
           s_prec_pt = new BlockDiagonalPreconditioner<CRDoubleMatrix>;
         }
         break;
         case Block_upper_triangular_preconditioner:
         {
           BlockTriangularPreconditioner<CRDoubleMatrix>*
             block_triangular_prec_pt =
               new BlockTriangularPreconditioner<CRDoubleMatrix>;
           block_triangular_prec_pt->upper_triangular();
  
           s_prec_pt = block_triangular_prec_pt;
         }
         break;
         case Block_lower_triangular_preconditioner:
         {
           BlockTriangularPreconditioner<CRDoubleMatrix>*
             block_triangular_prec_pt =
               new BlockTriangularPreconditioner<CRDoubleMatrix>;
           block_triangular_prec_pt->lower_triangular();
  
           s_prec_pt = block_triangular_prec_pt;
         }
         break;
         default:
         {
           std::ostringstream error_msg;
           error_msg
             << "There is no such block based preconditioner.\n"
             << "Candidates are:\n"
             << "PseudoElasticPreconditioner::Block_diagonal_preconditioner\n"
             << "PseudoElasticPreconditioner::Block_upper_triangular_"
                "preconditioner\n"
             << "PseudoElasticPreconditioner::Block_lower_triangular_"
                "preconditioner\n";
           throw OomphLibError(
             error_msg.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
         }
         break;
       }
  
  
       // Add mesh (not actually used since this only acts as a subsidiary
       // preconditioner...
       // s_prec_pt->add_mesh(Elastic_mesh_pt);
  
       // The block to block map
       Vector<Vector<unsigned>> doftype_to_doftype_map(Dim,
                                                       Vector<unsigned>(2, 0));
       Vector<unsigned> s_prec_dof_to_block_map(Dim, 0);
  
       unsigned tmp_index = 0;
       for (unsigned d = 0; d < Dim; d++)
       {
         s_prec_dof_to_block_map[d] = d;
         doftype_to_doftype_map[d][0] = tmp_index++;
         doftype_to_doftype_map[d][1] = tmp_index++;
       }
  
       s_prec_pt->turn_into_subsidiary_block_preconditioner(
         this, dof_list_for_subsidiary_prec, doftype_to_doftype_map);
  
       if (Elastic_subsidiary_preconditioner_function_pt != 0)
       {
         s_prec_pt->set_subsidiary_preconditioner_function(
           Elastic_subsidiary_preconditioner_function_pt);
       }
  
       // Set the replacement blocks.
       for (unsigned d = 0; d < Dim; d++)
       {
         // The dof-block located in the block-ordering.
         unsigned block_i = 2 * d + 1;
  
         // Then dof-block located in the dof-ordering.
         unsigned dof_block_i = Dim + d;
         this->set_replacement_dof_block(
           dof_block_i, dof_block_i, solid_matrix_pt(block_i, block_i));
       }
  
       s_prec_pt->set_dof_to_block_map(s_prec_dof_to_block_map);
       s_prec_pt->Preconditioner::setup(matrix_pt());
  
       Elastic_preconditioner_pt = s_prec_pt;
     }
  
     // No longer require the solid blocks
     for (unsigned row_i = 0; row_i < n_solid_dof_types; row_i++)
     {
       for (unsigned col_i = 0; col_i < n_solid_dof_types; col_i++)
       {
         delete solid_matrix_pt(row_i, col_i);
         solid_matrix_pt(row_i, col_i) = 0;
       }
     }
  
     // next setup the lagrange multiplier preconditioners
     Lagrange_multiplier_preconditioner_pt.resize(Dim);
     for (unsigned d = 0; d < Dim; d++)
     {
       CRDoubleMatrix* b_pt = new CRDoubleMatrix;
       this->get_block(2 * Dim + d, 2 * d + 1, *b_pt);
  
       // if a non default preconditioner is specified create
       // the preconditioners
       if (Lagrange_multiplier_subsidiary_preconditioner_function_pt != 0)
       {
         Lagrange_multiplier_preconditioner_pt[d] =
           (*Lagrange_multiplier_subsidiary_preconditioner_function_pt)();
       }
       // else use default superlu preconditioner
       else
       {
         Lagrange_multiplier_preconditioner_pt[d] = new SuperLUPreconditioner;
       }
  
       // and setup
       Lagrange_multiplier_preconditioner_pt[d]->setup(b_pt);
       delete b_pt;
       b_pt = 0;
     }
   }

Friends And Related Function Documentation

◆ PseudoElasticFSIPreconditioner

friend class PseudoElasticFSIPreconditioner

friend

PseudoElasticFSIPreconditioner is a friend to access the private *_preconditioner_solve(...) method

Member Data Documentation

◆ Dim

unsigned oomph::PseudoElasticPreconditioner::Dim

private

the dimension of the problem

Referenced by lagrange_multiplier_preconditioner_solve(), and setup().

◆ E_preconditioner_type

Elastic_preconditioner_type oomph::PseudoElasticPreconditioner::E_preconditioner_type

private

An unsigned indicating which method should be used for preconditioning the solid component.

Referenced by elastic_preconditioner_type(), PseudoElasticPreconditioner(), and setup().

◆ Elastic_mesh_pt

Mesh* oomph::PseudoElasticPreconditioner::Elastic_mesh_pt

private

Pointer to the mesh containing the solid elements.

Referenced by PseudoElasticPreconditioner(), set_elastic_mesh(), and setup().

◆ Elastic_preconditioner_pt

Preconditioner* oomph::PseudoElasticPreconditioner::Elastic_preconditioner_pt

private

storage for the preconditioner for the solid system

Referenced by clean_up_memory(), elastic_preconditioner_solve(), PseudoElasticPreconditioner(), and setup().

◆ Elastic_subsidiary_preconditioner_function_pt

SubsidiaryPreconditionerFctPt oomph::PseudoElasticPreconditioner::Elastic_subsidiary_preconditioner_function_pt

private

The solid subsidiary preconditioner function pointer.

Referenced by PseudoElasticPreconditioner(), set_elastic_subsidiary_preconditioner(), and setup().

◆ Lagrange_multiplier_mesh_pt

Mesh* oomph::PseudoElasticPreconditioner::Lagrange_multiplier_mesh_pt

private

Pointer to the mesh containing the Lagrange multiplier elements.

Referenced by PseudoElasticPreconditioner(), set_lagrange_multiplier_mesh(), and setup().

◆ Lagrange_multiplier_preconditioner_pt

Vector<Preconditioner*> oomph::PseudoElasticPreconditioner::Lagrange_multiplier_preconditioner_pt

private

lagrange multiplier preconditioner pt

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

◆ Lagrange_multiplier_subsidiary_preconditioner_function_pt

SubsidiaryPreconditionerFctPt oomph::PseudoElasticPreconditioner::Lagrange_multiplier_subsidiary_preconditioner_function_pt

private

The Lagrange multiplier subsidiary preconditioner function pointer.

Referenced by PseudoElasticPreconditioner(), set_lagrange_multiplier_subsidiary_preconditioner(), and setup().

◆ Scaling

double oomph::PseudoElasticPreconditioner::Scaling

private

The scaling. Defaults to infinity norm of S.

Referenced by lagrange_multiplier_preconditioner_solve(), and setup().

◆ Use_inf_norm_of_s_scaling

bool oomph::PseudoElasticPreconditioner::Use_inf_norm_of_s_scaling

private

boolean indicating whether the inf-norm of S should be used as scaling. Default = true;

Referenced by disable_inf_norm_of_s_scaling(), enable_inf_norm_of_s_scaling(), PseudoElasticPreconditioner(), and setup().

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

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ SubsidiaryPreconditionerFctPt

Member Enumeration Documentation

◆ Elastic_preconditioner_type

Constructor & Destructor Documentation

◆ PseudoElasticPreconditioner() [1/2]

◆ ~PseudoElasticPreconditioner()

◆ PseudoElasticPreconditioner() [2/2]

Member Function Documentation

◆ clean_up_memory()

◆ disable_inf_norm_of_s_scaling()

◆ elastic_preconditioner_solve()

◆ elastic_preconditioner_type()

◆ enable_inf_norm_of_s_scaling()

◆ lagrange_multiplier_preconditioner_solve()

◆ preconditioner_solve()

◆ set_elastic_mesh()

◆ set_elastic_subsidiary_preconditioner()

◆ set_lagrange_multiplier_mesh()

◆ set_lagrange_multiplier_subsidiary_preconditioner()

◆ setup()

Friends And Related Function Documentation

◆ PseudoElasticFSIPreconditioner

Member Data Documentation

◆ Dim

◆ E_preconditioner_type

◆ Elastic_mesh_pt

◆ Elastic_preconditioner_pt

◆ Elastic_subsidiary_preconditioner_function_pt

◆ Lagrange_multiplier_mesh_pt

◆ Lagrange_multiplier_preconditioner_pt

◆ Lagrange_multiplier_subsidiary_preconditioner_function_pt

◆ Scaling

◆ Use_inf_norm_of_s_scaling