#include <fsi_preconditioners.h>

Inheritance diagram for oomph::FSIPreconditioner:

Public Member Functions
	FSIPreconditioner (Problem *problem_pt)

	~FSIPreconditioner ()
	Destructor: Clean up. More...

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

void	set_solid_preconditioner_pt (Preconditioner *solid_preconditioner_pt)
	Broken assignment operator. More...

Preconditioner *	solid_preconditioner_pt () const
	Read-only access to solid preconditoner (use set_... to set it) More...

void	use_block_diagonal_version ()
	Switch to block-diagonal preconditioner. More...

void	use_block_triangular_version_with_fluid_on_solid ()

void	use_block_triangular_version_with_solid_on_fluid ()

void	set_navier_stokes_mesh (Mesh *mesh_pt, const bool &allow_multiple_element_type_in_navier_stokes_mesh=false)

void	set_wall_mesh (Mesh *mesh_pt, const bool &allow_multiple_element_type_in_wall_mesh=false)

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

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

NavierStokesSchurComplementPreconditioner *	navier_stokes_preconditioner_pt () const
	Access function to the Navier Stokes preconditioner (inexact solver) More...

void	enable_doc_time ()
	Enable documentation of time. More...

void	disable_doc_time ()
	Disable documentation of time. 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	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
NavierStokesSchurComplementPreconditioner *	Navier_stokes_preconditioner_pt
	Pointer the Navier Stokes preconditioner (inexact solver) More...

Preconditioner *	Solid_preconditioner_pt
	Pointer to the solid preconditioner (inexact solver) More...

MatrixVectorProduct *	Matrix_vector_product_0_1_pt
	Pointer to fluid/solid interaction matrix. More...

MatrixVectorProduct *	Matrix_vector_product_1_0_pt
	Pointer to solid/fluid solid interaction matrix. More...

bool	Preconditioner_has_been_setup
	Boolean indicating the preconditioner has been set up. More...

bool	Retain_solid_onto_fluid_terms

bool	Retain_fluid_onto_solid_terms

bool	Doc_time
	Set Doc_time to true for outputting results of timings. More...

Mesh *	Navier_stokes_mesh_pt
	Pointer to the navier stokes mesh. More...

Mesh *	Wall_mesh_pt
	pointer to the solid mesh More...

bool	Allow_multiple_element_type_in_navier_stokes_mesh

bool	Allow_multiple_element_type_in_wall_mesh

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

//////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// FSI preconditioner. This extracts upper/lower triangular blocks in the 3x3 overall block matrix structure arising from the monolithic discretisation of FSI problems with algebraic node updates. Dofs are decomposed into fluid velocity, pressure and solid unknowns. NavierStokesSchurComplementPreconditioner is used as the inexact solver for the fluid block; SuperLU (in its incarnation as an "exact" preconditioner) is used for the solid block. By default we retain the fluid on solid off diagonal blocks.

Constructor & Destructor Documentation

◆ FSIPreconditioner() [1/2]

oomph::FSIPreconditioner::FSIPreconditioner ( Problem * problem_pt )

inline

Constructor: By default use block triangular form with retained fluid on solid terms. A problem pointer is required for the underlying NavierStokesSchurComplementPreconditioner.

     {
       // set the mesh pointers
       this->set_nmesh(2);
       Navier_stokes_mesh_pt = 0;
       Wall_mesh_pt = 0;
  
       // Initially assume that there are no multiple element types in the
       // meshes.
       Allow_multiple_element_type_in_navier_stokes_mesh = false;
       Allow_multiple_element_type_in_wall_mesh = false;
  
       // Default setting: Fluid onto solid as it this was shown to be
       // marginally faster than solid onto fluid; see Heil CMAME 193 (2004)
       Retain_solid_onto_fluid_terms = false;
       Retain_fluid_onto_solid_terms = true;
  
       // Create the Navier Stokes Schur complement preconditioner
       Navier_stokes_preconditioner_pt =
         new NavierStokesSchurComplementPreconditioner(problem_pt);
  
       // Create the Solid preconditioner
       Solid_preconditioner_pt = new SuperLUPreconditioner;
  
       // Preconditioner hasn't been set up yet.
       Preconditioner_has_been_setup = false;
  
       // Create the matrix vector product operators
       Matrix_vector_product_0_1_pt = new MatrixVectorProduct;
       Matrix_vector_product_1_0_pt = new MatrixVectorProduct;
  
       // set Doc_time to false
       Doc_time = false;
     }

References Allow_multiple_element_type_in_navier_stokes_mesh, Allow_multiple_element_type_in_wall_mesh, Doc_time, Matrix_vector_product_0_1_pt, Matrix_vector_product_1_0_pt, Navier_stokes_mesh_pt, Navier_stokes_preconditioner_pt, Preconditioner_has_been_setup, Retain_fluid_onto_solid_terms, Retain_solid_onto_fluid_terms, oomph::BlockPreconditioner< CRDoubleMatrix >::set_nmesh(), Solid_preconditioner_pt, and Wall_mesh_pt.

◆ ~FSIPreconditioner()

oomph::FSIPreconditioner::~FSIPreconditioner ( )

inline

Destructor: Clean up.

     {
       // Delete the Navier-Stokes preconditioner (inexact solver)
       delete Navier_stokes_preconditioner_pt;
  
       // Delete the solid preconditioner (inexact solver)
       delete Solid_preconditioner_pt;
  
       // delete the matrix vector product operators
       delete Matrix_vector_product_0_1_pt;
       delete Matrix_vector_product_1_0_pt;
     }

References Matrix_vector_product_0_1_pt, Matrix_vector_product_1_0_pt, Navier_stokes_preconditioner_pt, and Solid_preconditioner_pt.

◆ FSIPreconditioner() [2/2]

oomph::FSIPreconditioner::FSIPreconditioner ( const FSIPreconditioner & )

delete

Broken copy constructor.

Member Function Documentation

◆ disable_doc_time()

void oomph::FSIPreconditioner::disable_doc_time ( )

inline

Disable documentation of time.

     {
       Doc_time = false;
     }

References Doc_time.

◆ enable_doc_time()

void oomph::FSIPreconditioner::enable_doc_time ( )

inline

Enable documentation of time.

     {
       Doc_time = true;
     }

References Doc_time.

Referenced by main().

◆ navier_stokes_preconditioner_pt()

NavierStokesSchurComplementPreconditioner* oomph::FSIPreconditioner::navier_stokes_preconditioner_pt ( ) const

inline

Access function to the Navier Stokes preconditioner (inexact solver)

     {
       return Navier_stokes_preconditioner_pt;
     }

References Navier_stokes_preconditioner_pt.

Referenced by main(), PreconditionedFSICollapsibleChannelProblem< ELEMENT >::PreconditionedFSICollapsibleChannelProblem(), RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::switch_to_iterative_linear_solver(), and TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::TurekProblem().

◆ preconditioner_solve()

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

virtual

Apply preconditioner to r.

Apply preconditioner to Vector r.

Implements oomph::Preconditioner.

   {
     // if z is not setup then give it the same distribution
     if (!z.built())
     {
       z.build(r.distribution_pt(), 0.0);
     }
  
     // Make copy of residual vector (to overcome const-ness
     DoubleVector res(r);
  
  
     // Retain off-diagonals that represent effect of solid on fluid
     //-------------------------------------------------------------
     if (Retain_solid_onto_fluid_terms)
     {
       // Working vectors
       DoubleVector temp_solid_vec;
       DoubleVector temp_fluid_vec;
  
       // Copy solid values from residual to temp_vec:
       // Loop over all entries in the global vector (this one
       // includes solid, velocity and pressure dofs in some random fashion)
       get_block_vector(1, res, temp_solid_vec);
  
       // Solve solid system by back-substitution
       // with LU-decomposed stiffness matrix
       DoubleVector temp_solid_vec2;
       Solid_preconditioner_pt->preconditioner_solve(temp_solid_vec,
                                                     temp_solid_vec2);
       this->return_block_vector(1, temp_solid_vec2, z);
  
       // NOTE: temp_solid_vec now contains z_s = S^{-1} r_s
  
       // Multiply C_{us} by z_s
       Matrix_vector_product_0_1_pt->multiply(temp_solid_vec2, temp_fluid_vec);
       temp_solid_vec.clear();
  
       // Subtract from fluid residual vector for fluid solve
       DoubleVector another_temp_vec;
       this->get_block_vector(0, res, another_temp_vec);
       another_temp_vec -= temp_fluid_vec;
       this->return_block_vector(0, another_temp_vec, res);
  
       // now apply the navier stokes lsc preconditioner
       Navier_stokes_preconditioner_pt->preconditioner_solve(res, z);
     }
  
  
     // Retain off-diagonals that represent effect of fluid on solid
     //-------------------------------------------------------------
     // (or diagonal preconditioner)
     //-----------------------------
     else
     {
       // Call fluid preconditioner for fluid block
       Navier_stokes_preconditioner_pt->preconditioner_solve(res, z);
  
       // Working vectors
       DoubleVector temp_solid_vec;
  
       // get the solid vector
       get_block_vector(1, res, temp_solid_vec);
  
       // Do matrix vector products with fluid onto solid coupling matrices:
       if (Retain_fluid_onto_solid_terms)
       {
         DoubleVector temp_fluid_vec;
         get_block_vector(0, z, temp_fluid_vec);
  
         // Auxiliary vector to hold the matrix vector product of the
         // fluid-onto-solid coupling matrices with the fluid solutions:
         DoubleVector aux_vec;
  
         // Multiply C_{su} by z_u
         Matrix_vector_product_1_0_pt->multiply(temp_fluid_vec, aux_vec);
  
         // ...and subtract from r_s:
         temp_solid_vec -= aux_vec;
       }
  
       // Solve solid system by back-substitution
       // with LU-decomposed stiffness matrix
       DoubleVector temp_solid_vec2;
       Solid_preconditioner_pt->preconditioner_solve(temp_solid_vec,
                                                     temp_solid_vec2);
  
       // Now copy result_vec (i.e. z_s) back into the global vector z.
       // Loop over all entries in the global results vector z:
       return_block_vector(1, temp_solid_vec2, z);
     }
   }

References oomph::DoubleVector::build(), oomph::DoubleVector::built(), oomph::DoubleVector::clear(), oomph::BlockPreconditioner< CRDoubleMatrix >::get_block_vector(), Matrix_vector_product_0_1_pt, Matrix_vector_product_1_0_pt, oomph::MatrixVectorProduct::multiply(), Navier_stokes_preconditioner_pt, oomph::NavierStokesSchurComplementPreconditioner::preconditioner_solve(), oomph::Preconditioner::preconditioner_solve(), UniformPSDSelfTest::r, res, Retain_fluid_onto_solid_terms, Retain_solid_onto_fluid_terms, oomph::BlockPreconditioner< CRDoubleMatrix >::return_block_vector(), and Solid_preconditioner_pt.

◆ set_navier_stokes_mesh()

void oomph::FSIPreconditioner::set_navier_stokes_mesh	(	Mesh *	mesh_pt,
		const bool &	allow_multiple_element_type_in_navier_stokes_mesh = `false`
	)

inline

Setter function for the mesh containing the block-preconditionable Navier-Stokes elements. The optional argument indicates if there are more than one type of elements in same mesh.

     {
       // Store the mesh pointer.
       Navier_stokes_mesh_pt = mesh_pt;
  
       // Are there multiple element types in the Navier-Stokes mesh?
       Allow_multiple_element_type_in_navier_stokes_mesh =
         allow_multiple_element_type_in_navier_stokes_mesh;
     }

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

Referenced by FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem(), main(), PreconditionedFSICollapsibleChannelProblem< ELEMENT >::PreconditionedFSICollapsibleChannelProblem(), RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::switch_to_iterative_linear_solver(), and TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::TurekProblem().

◆ set_solid_preconditioner_pt()

void oomph::FSIPreconditioner::set_solid_preconditioner_pt ( Preconditioner * solid_preconditioner_pt )

inline

Broken assignment operator.

Set solid preconditioner (deletes existing one)

     {
       // Kill existing one
       if (Solid_preconditioner_pt != 0)
       {
         delete Solid_preconditioner_pt;
       }
       Solid_preconditioner_pt = solid_preconditioner_pt;
     }

References solid_preconditioner_pt(), and Solid_preconditioner_pt.

Referenced by RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::switch_to_iterative_linear_solver().

◆ set_wall_mesh()

void oomph::FSIPreconditioner::set_wall_mesh	(	Mesh *	mesh_pt,
		const bool &	allow_multiple_element_type_in_wall_mesh = `false`
	)

inline

Setter function for the mesh containing the block-preconditionable FSI solid elements. The optional argument indicates if there are more than one type of elements in the same mesh.

     {
       // Store the mesh pointer
       Wall_mesh_pt = mesh_pt;
  
       // Are there multiple element types in the wall mesh?
       Allow_multiple_element_type_in_wall_mesh =
         allow_multiple_element_type_in_wall_mesh;
     }

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

Referenced by FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem(), main(), PreconditionedFSICollapsibleChannelProblem< ELEMENT >::PreconditionedFSICollapsibleChannelProblem(), RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::switch_to_iterative_linear_solver(), and TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::TurekProblem().

◆ setup()

void oomph::FSIPreconditioner::setup ( )

virtual

Setup the preconditioner.

Setup the preconditioner. Note: Matrix must be a CRDoubleMatrix.

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

Implements oomph::Preconditioner.

   {
     // check the meshes have been set
 #ifdef PARANOID
     if (Navier_stokes_mesh_pt == 0)
     {
       std::ostringstream error_message;
       error_message << "Pointer to fluid mesh hasn't been set!\n";
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
     if (Wall_mesh_pt == 0)
     {
       std::ostringstream error_message;
       error_message << "Pointer to solid mesh hasn't been set!\n";
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // setup the meshes
     this->set_mesh(0,
                    Navier_stokes_mesh_pt,
                    Allow_multiple_element_type_in_navier_stokes_mesh);
     this->set_mesh(1, Wall_mesh_pt, Allow_multiple_element_type_in_wall_mesh);
  
     // get the number of fluid dofs from teh first element in the mesh
     unsigned n_fluid_dof = this->ndof_types_in_mesh(0);
     unsigned n_dof = n_fluid_dof + this->ndof_types_in_mesh(1);
  
     // this fsi preconditioner has two types of DOF fluid dofs and solid dofs
     Vector<unsigned> dof_to_block_map(n_dof, 0);
     for (unsigned i = n_fluid_dof; i < n_dof; i++)
     {
       dof_to_block_map[i] = 1;
     }
  
     // Call block setup for this preconditioner
     this->block_setup(dof_to_block_map);
  
     // Block mapping for the subsidiary Navier Stokes preconditioner:
     // blocks 0 and 1 in the FSI preconditioner are also blocks 0 and 1
     // in the subsidiary Navier Stokes one.
     Vector<unsigned> ns_dof_lookup(n_fluid_dof);
     for (unsigned i = 0; i < n_fluid_dof; i++)
     {
       ns_dof_lookup[i] = i;
     }
  
     // Turn the Navier Stokes Schur complement preconditioner into a
     // subsidiary preconditioner of this preconditioner
     Navier_stokes_preconditioner_pt->turn_into_subsidiary_block_preconditioner(
       this, ns_dof_lookup);
  
     // Setup the navier stokes preconditioner: Tell it about the
     // Navier Stokes mesh and set it up.
     Navier_stokes_preconditioner_pt->set_navier_stokes_mesh(
       Navier_stokes_mesh_pt);
     Navier_stokes_preconditioner_pt->setup(matrix_pt());
  
     // Extract the additional blocks we need for FSI:
  
     // Solid tangent stiffness matrix
     CRDoubleMatrix block_matrix_1_1;
     this->get_block(1, 1, block_matrix_1_1);
  
     // Setup the solid preconditioner (inexact solver)
     double t_start = TimingHelpers::timer();
     Solid_preconditioner_pt->setup(&block_matrix_1_1);
     double t_end = TimingHelpers::timer();
     block_matrix_1_1.clear();
     double setup_time = t_end - t_start;
  
     // Solid on fluid terms (if needed)
     if (Retain_solid_onto_fluid_terms)
     {
       CRDoubleMatrix block_matrix_0_1 = get_block(0, 1);
       this->setup_matrix_vector_product(
         Matrix_vector_product_0_1_pt, &block_matrix_0_1, 1);
     }
  
     // Fluid on solid terms (if needed)
     if (Retain_fluid_onto_solid_terms)
     {
       CRDoubleMatrix block_matrix_1_0 = get_block(1, 0);
       this->setup_matrix_vector_product(
         Matrix_vector_product_1_0_pt, &block_matrix_1_0, 0);
     }
  
     // Output times
     if (Doc_time)
     {
       oomph_info << "Solid sub-preconditioner setup time [sec]: " << setup_time
                  << "\n";
     }
  
     // We're done (and we stored some data)
     Preconditioner_has_been_setup = true;
   }

References Allow_multiple_element_type_in_navier_stokes_mesh, Allow_multiple_element_type_in_wall_mesh, oomph::BlockPreconditioner< CRDoubleMatrix >::block_setup(), oomph::CRDoubleMatrix::clear(), Doc_time, oomph::BlockPreconditioner< CRDoubleMatrix >::get_block(), i, oomph::BlockPreconditioner< CRDoubleMatrix >::matrix_pt(), Matrix_vector_product_0_1_pt, Matrix_vector_product_1_0_pt, Navier_stokes_mesh_pt, Navier_stokes_preconditioner_pt, oomph::BlockPreconditioner< CRDoubleMatrix >::ndof_types_in_mesh(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, Preconditioner_has_been_setup, Retain_fluid_onto_solid_terms, Retain_solid_onto_fluid_terms, oomph::BlockPreconditioner< CRDoubleMatrix >::set_mesh(), oomph::NavierStokesSchurComplementPreconditioner::set_navier_stokes_mesh(), oomph::NavierStokesSchurComplementPreconditioner::setup(), oomph::Preconditioner::setup(), oomph::BlockPreconditioner< CRDoubleMatrix >::setup_matrix_vector_product(), oomph::Preconditioner::setup_time(), Solid_preconditioner_pt, oomph::TimingHelpers::timer(), oomph::BlockPreconditioner< MATRIX >::turn_into_subsidiary_block_preconditioner(), and Wall_mesh_pt.

◆ solid_preconditioner_pt()

Preconditioner* oomph::FSIPreconditioner::solid_preconditioner_pt ( ) const

inline

Read-only access to solid preconditoner (use set_... to set it)

     {
       return Solid_preconditioner_pt;
     }

References Solid_preconditioner_pt.

Referenced by set_solid_preconditioner_pt().

◆ use_block_diagonal_version()

void oomph::FSIPreconditioner::use_block_diagonal_version ( )

inline

Switch to block-diagonal preconditioner.

     {
       Retain_solid_onto_fluid_terms = false;
       Retain_fluid_onto_solid_terms = false;
     }

References Retain_fluid_onto_solid_terms, and Retain_solid_onto_fluid_terms.

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

◆ use_block_triangular_version_with_fluid_on_solid()

void oomph::FSIPreconditioner::use_block_triangular_version_with_fluid_on_solid ( )

inline

Switch to block-triangular preconditioner in which action of fluid dofs onto solid equations is retained

     {
       Retain_solid_onto_fluid_terms = false;
       Retain_fluid_onto_solid_terms = true;
     }

References Retain_fluid_onto_solid_terms, and Retain_solid_onto_fluid_terms.

Referenced by FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem(), PreconditionedFSICollapsibleChannelProblem< ELEMENT >::PreconditionedFSICollapsibleChannelProblem(), and TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::TurekProblem().

◆ use_block_triangular_version_with_solid_on_fluid()

void oomph::FSIPreconditioner::use_block_triangular_version_with_solid_on_fluid ( )

inline

Switch to block-triangular preconditioner in which action of solid dofs onto fluid equations is retained

     {
       Retain_solid_onto_fluid_terms = true;
       Retain_fluid_onto_solid_terms = false;
     }

References Retain_fluid_onto_solid_terms, and Retain_solid_onto_fluid_terms.

Referenced by PreconditionedFSICollapsibleChannelProblem< ELEMENT >::PreconditionedFSICollapsibleChannelProblem(), and RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::switch_to_iterative_linear_solver().

Member Data Documentation

◆ Allow_multiple_element_type_in_navier_stokes_mesh

bool oomph::FSIPreconditioner::Allow_multiple_element_type_in_navier_stokes_mesh

private

Flag to indicate if there are multiple element types in the Navier-Stokes mesh.

Referenced by FSIPreconditioner(), set_navier_stokes_mesh(), and setup().

◆ Allow_multiple_element_type_in_wall_mesh

bool oomph::FSIPreconditioner::Allow_multiple_element_type_in_wall_mesh

private

Referenced by FSIPreconditioner(), set_wall_mesh(), and setup().

◆ Doc_time

bool oomph::FSIPreconditioner::Doc_time

private

Set Doc_time to true for outputting results of timings.

Referenced by disable_doc_time(), enable_doc_time(), FSIPreconditioner(), and setup().

◆ Matrix_vector_product_0_1_pt

MatrixVectorProduct* oomph::FSIPreconditioner::Matrix_vector_product_0_1_pt

private

Pointer to fluid/solid interaction matrix.

Referenced by FSIPreconditioner(), preconditioner_solve(), setup(), and ~FSIPreconditioner().

◆ Matrix_vector_product_1_0_pt

MatrixVectorProduct* oomph::FSIPreconditioner::Matrix_vector_product_1_0_pt

private

Pointer to solid/fluid solid interaction matrix.

Referenced by FSIPreconditioner(), preconditioner_solve(), setup(), and ~FSIPreconditioner().

◆ Navier_stokes_mesh_pt

Mesh* oomph::FSIPreconditioner::Navier_stokes_mesh_pt

private

Pointer to the navier stokes mesh.

Referenced by FSIPreconditioner(), set_navier_stokes_mesh(), and setup().

◆ Navier_stokes_preconditioner_pt

NavierStokesSchurComplementPreconditioner* oomph::FSIPreconditioner::Navier_stokes_preconditioner_pt

private

Pointer the Navier Stokes preconditioner (inexact solver)

Referenced by FSIPreconditioner(), navier_stokes_preconditioner_pt(), preconditioner_solve(), setup(), and ~FSIPreconditioner().

◆ Preconditioner_has_been_setup

bool oomph::FSIPreconditioner::Preconditioner_has_been_setup

private

Boolean indicating the preconditioner has been set up.

Referenced by FSIPreconditioner(), and setup().

◆ Retain_fluid_onto_solid_terms

bool oomph::FSIPreconditioner::Retain_fluid_onto_solid_terms

private

Boolean flag used to indicate that the fluid onto solid interaction terms are to be retained

Referenced by FSIPreconditioner(), preconditioner_solve(), setup(), use_block_diagonal_version(), use_block_triangular_version_with_fluid_on_solid(), and use_block_triangular_version_with_solid_on_fluid().

◆ Retain_solid_onto_fluid_terms

bool oomph::FSIPreconditioner::Retain_solid_onto_fluid_terms

private

Boolean flag used to indicate that the solid onto fluid interaction terms are to be retained

Referenced by FSIPreconditioner(), preconditioner_solve(), setup(), use_block_diagonal_version(), use_block_triangular_version_with_fluid_on_solid(), and use_block_triangular_version_with_solid_on_fluid().

◆ Solid_preconditioner_pt

Preconditioner* oomph::FSIPreconditioner::Solid_preconditioner_pt

private

Pointer to the solid preconditioner (inexact solver)

Referenced by FSIPreconditioner(), preconditioner_solve(), set_solid_preconditioner_pt(), setup(), solid_preconditioner_pt(), and ~FSIPreconditioner().

◆ Wall_mesh_pt

Mesh* oomph::FSIPreconditioner::Wall_mesh_pt

private

pointer to the solid mesh

Referenced by FSIPreconditioner(), set_wall_mesh(), and setup().

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

fsi_preconditioners.h

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ FSIPreconditioner() [1/2]

◆ ~FSIPreconditioner()

◆ FSIPreconditioner() [2/2]

Member Function Documentation

◆ disable_doc_time()

◆ enable_doc_time()

◆ navier_stokes_preconditioner_pt()

◆ preconditioner_solve()

◆ set_navier_stokes_mesh()

◆ set_solid_preconditioner_pt()

◆ set_wall_mesh()

◆ setup()

◆ solid_preconditioner_pt()

◆ use_block_diagonal_version()

◆ use_block_triangular_version_with_fluid_on_solid()

◆ use_block_triangular_version_with_solid_on_fluid()

Member Data Documentation

◆ Allow_multiple_element_type_in_navier_stokes_mesh

◆ Allow_multiple_element_type_in_wall_mesh

◆ Doc_time

◆ Matrix_vector_product_0_1_pt

◆ Matrix_vector_product_1_0_pt

◆ Navier_stokes_mesh_pt

◆ Navier_stokes_preconditioner_pt

◆ Preconditioner_has_been_setup

◆ Retain_fluid_onto_solid_terms

◆ Retain_solid_onto_fluid_terms

◆ Solid_preconditioner_pt

◆ Wall_mesh_pt