#include <fsi_preconditioners.h>

Inheritance diagram for oomph::SimpleFSIPreconditioner< MATRIX >:

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

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

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

void	set_navier_stokes_mesh (Mesh *mesh_pt, const bool &allow_multiple_element_type_in_navier_stokes_mesh=false)
	Broken assignment operator. More...

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

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 ()

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

virtual	~BlockPreconditioner ()
	Destructor. More...

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

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

MATRIX *	matrix_pt () const

void	turn_on_recursive_debug_flag ()

void	turn_off_recursive_debug_flag ()

void	turn_on_debug_flag ()
	Toggles on the debug flag. More...

void	turn_off_debug_flag ()
	Toggles off the debug flag. More...

void	turn_into_subsidiary_block_preconditioner (BlockPreconditioner< MATRIX > *master_block_prec_pt, const Vector< unsigned > &doftype_in_master_preconditioner_coarse)

void	turn_into_subsidiary_block_preconditioner (BlockPreconditioner< MATRIX > *master_block_prec_pt, const Vector< unsigned > &doftype_in_master_preconditioner_coarse, const Vector< Vector< unsigned >> &doftype_coarsen_map_coarse)

virtual void	block_setup ()

void	block_setup (const Vector< unsigned > &dof_to_block_map)

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

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

void	set_master_matrix_pt (MATRIX *in_matrix_pt)
	Set the matrix_pt in the upper-most master preconditioner. More...

void	get_block_other_matrix (const unsigned &i, const unsigned &j, MATRIX *in_matrix_pt, MATRIX &output_matrix)

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

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

MATRIX	get_concatenated_block (const VectorMatrix< BlockSelector > &selected_block)

void	get_concatenated_block_vector (const Vector< unsigned > &block_vec_number, const DoubleVector &v, DoubleVector &b)

void	return_concatenated_block_vector (const Vector< unsigned > &block_vec_number, const DoubleVector &b, DoubleVector &v) const
	Takes concatenated block ordered vector, b, and copies its. More...

void	get_block_vectors (const Vector< unsigned > &block_vec_number, const DoubleVector &v, Vector< DoubleVector > &s) const

void	get_block_vectors (const DoubleVector &v, Vector< DoubleVector > &s) const

void	return_block_vectors (const Vector< unsigned > &block_vec_number, const Vector< DoubleVector > &s, DoubleVector &v) const

void	return_block_vectors (const Vector< DoubleVector > &s, DoubleVector &v) const

void	get_block_vector (const unsigned &n, const DoubleVector &v, DoubleVector &b) const

void	return_block_vector (const unsigned &n, const DoubleVector &b, DoubleVector &v) const

void	get_block_ordered_preconditioner_vector (const DoubleVector &v, DoubleVector &w)

void	return_block_ordered_preconditioner_vector (const DoubleVector &w, DoubleVector &v) const

unsigned	nblock_types () const
	Return the number of block types. More...

unsigned	ndof_types () const
	Return the total number of DOF types. More...

const Mesh *	mesh_pt (const unsigned &i) const

unsigned	nmesh () const

int	block_number (const unsigned &i_dof) const
	Return the block number corresponding to a global index i_dof. More...

int	index_in_block (const unsigned &i_dof) const

const LinearAlgebraDistribution *	block_distribution_pt (const unsigned &b) const
	Access function to the block distributions (const version). More...

LinearAlgebraDistribution *	block_distribution_pt (const unsigned b)
	Access function to the block distributions (non-const version). More...

LinearAlgebraDistribution *	dof_block_distribution_pt (const unsigned &b)
	Access function to the dof-level block distributions. More...

const LinearAlgebraDistribution *	master_distribution_pt () const

unsigned	ndof_types_in_mesh (const unsigned &i) const

bool	is_subsidiary_block_preconditioner () const

bool	is_master_block_preconditioner () const

void	set_block_output_to_files (const std::string &basefilename)

void	disable_block_output_to_files ()
	Turn off output of blocks (by clearing the basefilename string). More...

bool	block_output_on () const
	Test if output of blocks is on or not. More...

void	output_blocks_to_files (const std::string &basefilename, const unsigned &precision=8) const

void	post_block_matrix_assembly_partial_clear ()

BlockPreconditioner< MATRIX > *	master_block_preconditioner_pt () const
	Access function to the master block preconditioner pt. More...

void	clear_block_preconditioner_base ()

void	document ()

Vector< Vector< unsigned > >	doftype_coarsen_map_fine () const

Vector< unsigned >	get_fine_grain_dof_types_in (const unsigned &i) const

unsigned	nfine_grain_dof_types_in (const unsigned &i) const

MapMatrix< unsigned, CRDoubleMatrix * >	replacement_dof_block_pt () const
	Access function to the replaced dof-level blocks. More...

void	setup_matrix_vector_product (MatrixVectorProduct matvec_prod_pt, CRDoubleMatrix block_pt, const Vector< unsigned > &block_col_indices)

void	setup_matrix_vector_product (MatrixVectorProduct matvec_prod_pt, CRDoubleMatrix block_pt, const unsigned &block_col_index)

void	internal_get_block_ordered_preconditioner_vector (const DoubleVector &v, DoubleVector &w) const

void	internal_return_block_ordered_preconditioner_vector (const DoubleVector &w, DoubleVector &v) const

unsigned	internal_nblock_types () const

unsigned	internal_ndof_types () const

void	internal_return_block_vector (const unsigned &n, const DoubleVector &b, DoubleVector &v) const

void	internal_get_block_vector (const unsigned &n, const DoubleVector &v, DoubleVector &b) const

void	internal_get_block_vectors (const Vector< unsigned > &block_vec_number, const DoubleVector &v, Vector< DoubleVector > &s) const

void	internal_get_block_vectors (const DoubleVector &v, Vector< DoubleVector > &s) const

void	internal_return_block_vectors (const Vector< unsigned > &block_vec_number, const Vector< DoubleVector > &s, DoubleVector &v) const

void	internal_return_block_vectors (const Vector< DoubleVector > &s, DoubleVector &v) const

void	internal_get_block (const unsigned &i, const unsigned &j, MATRIX &output_block) const

int	internal_block_number (const unsigned &i_dof) const

int	internal_index_in_block (const unsigned &i_dof) const

const LinearAlgebraDistribution *	internal_block_distribution_pt (const unsigned &b) const
	Access function to the internal block distributions. More...

void	insert_auxiliary_block_distribution (const Vector< unsigned > &block_vec_number, LinearAlgebraDistribution *dist_pt)

void	block_matrix_test (const unsigned &i, const unsigned &j, const MATRIX *block_matrix_pt) const

template<typename myType >
int	get_index_of_value (const Vector< myType > &vec, const myType val, const bool sorted=false) const

void	internal_get_block (const unsigned &block_i, const unsigned &block_j, CRDoubleMatrix &output_block) const

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

Public Member Functions inherited from oomph::Preconditioner
	Preconditioner ()
	Constructor. More...

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

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

virtual	~Preconditioner ()
	Destructor (empty) More...

virtual void	preconditioner_solve_transpose (const DoubleVector &r, DoubleVector &z)

void	setup (DoubleMatrixBase *matrix_pt)

void	setup (const Problem problem_pt, DoubleMatrixBase matrix_pt)

void	enable_silent_preconditioner_setup ()
	Set up the block preconditioner quietly! More...

void	disable_silent_preconditioner_setup ()
	Be verbose in the block preconditioner setup. More...

virtual void	clean_up_memory ()
	Clean up memory (empty). Generic interface function. More...

virtual void	set_matrix_pt (DoubleMatrixBase *matrix_pt)
	Set the matrix pointer. More...

virtual const OomphCommunicator *	comm_pt () const
	Get function for comm pointer. More...

virtual void	set_comm_pt (const OomphCommunicator *const comm_pt)
	Set the communicator pointer. More...

double	setup_time () const
	Returns the time to setup the preconditioner. More...

virtual void	turn_into_subsidiary_block_preconditioner (BlockPreconditioner< CRDoubleMatrix > *master_block_prec_pt, const Vector< unsigned > &doftype_in_master_preconditioner_coarse)

virtual void	turn_into_subsidiary_block_preconditioner (BlockPreconditioner< CRDoubleMatrix > *master_block_prec_pt, const Vector< unsigned > &doftype_in_master_preconditioner_coarse, const Vector< Vector< unsigned >> &doftype_coarsen_map_coarse)

Public Member Functions inherited from oomph::DistributableLinearAlgebraObject
	DistributableLinearAlgebraObject ()
	Default constructor - create a distribution. More...

	DistributableLinearAlgebraObject (const DistributableLinearAlgebraObject &matrix)=delete
	Broken copy constructor. More...

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

virtual	~DistributableLinearAlgebraObject ()
	Destructor. More...

LinearAlgebraDistribution *	distribution_pt () const
	access to the LinearAlgebraDistribution More...

unsigned	nrow () const
	access function to the number of global rows. More...

unsigned	nrow_local () const
	access function for the num of local rows on this processor. More...

unsigned	nrow_local (const unsigned &p) const
	access function for the num of local rows on this processor. More...

unsigned	first_row () const
	access function for the first row on this processor More...

unsigned	first_row (const unsigned &p) const
	access function for the first row on this processor More...

bool	distributed () const
	distribution is serial or distributed More...

bool	distribution_built () const

void	build_distribution (const LinearAlgebraDistribution *const dist_pt)

void	build_distribution (const LinearAlgebraDistribution &dist)

Private Member Functions
virtual void	identify_required_blocks (DenseMatrix< bool > &required_blocks)

Private Attributes
Preconditioner *	Preconditioner_pt
	Preconditioner (inexact solver) More...

bool	Retain_solid_onto_fluid_terms

bool	Retain_fluid_onto_solid_terms

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
	Flag for multiple element types in the Navier-Stokes mesh. More...

bool	Allow_multiple_element_type_in_wall_mesh
	Flag for multiple element types in the Wall mesh. More...

Additional Inherited Members
Protected Member Functions inherited from oomph::BlockPreconditioner< MATRIX >
void	set_nmesh (const unsigned &n)

void	set_mesh (const unsigned &i, const Mesh *const mesh_pt, const bool &allow_multiple_element_type_in_mesh=false)

void	set_replacement_dof_block (const unsigned &block_i, const unsigned &block_j, CRDoubleMatrix *replacement_dof_block_pt)

bool	any_mesh_distributed () const

int	internal_dof_number (const unsigned &i_dof) const

unsigned	internal_index_in_dof (const unsigned &i_dof) const

unsigned	internal_block_dimension (const unsigned &b) const

unsigned	internal_dof_block_dimension (const unsigned &i) const

unsigned	master_nrow () const

unsigned	internal_master_dof_number (const unsigned &b) const

const LinearAlgebraDistribution *	internal_preconditioner_matrix_distribution_pt () const

const LinearAlgebraDistribution *	preconditioner_matrix_distribution_pt () const

Protected Member Functions inherited from oomph::DistributableLinearAlgebraObject
void	clear_distribution ()

Protected Attributes inherited from oomph::BlockPreconditioner< MATRIX >
MapMatrix< unsigned, CRDoubleMatrix * >	Replacement_dof_block_pt
	The replacement dof-level blocks. More...

Vector< LinearAlgebraDistribution * >	Block_distribution_pt
	The distribution for the blocks. More...

Vector< Vector< unsigned > >	Block_to_dof_map_coarse

Vector< Vector< unsigned > >	Block_to_dof_map_fine
	Mapping for the block types to the most fine grain dof types. More...

Vector< Vector< unsigned > >	Doftype_coarsen_map_coarse

Vector< Vector< unsigned > >	Doftype_coarsen_map_fine

Vector< LinearAlgebraDistribution * >	Internal_block_distribution_pt
	Storage for the default distribution for each internal block. More...

Vector< LinearAlgebraDistribution * >	Dof_block_distribution_pt

Vector< unsigned >	Allow_multiple_element_type_in_mesh

Vector< const Mesh * >	Mesh_pt

Vector< unsigned >	Ndof_types_in_mesh

unsigned	Internal_nblock_types

unsigned	Internal_ndof_types

Protected Attributes inherited from oomph::Preconditioner
bool	Silent_preconditioner_setup
	Boolean to indicate whether or not the build should be done silently. More...

std::ostream *	Stream_pt
	Pointer to the output stream – defaults to std::cout. More...

Detailed Description

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

//////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// 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. Blocks are then re-assembled into one global matrix and solved with a direct solver (SuperLU in its incarnation as an exact preconditioner). By default we retain the fluid on solid off diagonal blocks.

Constructor & Destructor Documentation

◆ SimpleFSIPreconditioner() [1/2]

template<typename MATRIX >

oomph::SimpleFSIPreconditioner< MATRIX >::SimpleFSIPreconditioner ( )

inline

Constructor.

                               : BlockPreconditioner<MATRIX>()
     {
       // set the mesh pointers
       Navier_stokes_mesh_pt = 0;
       Wall_mesh_pt = 0;
       this->set_nmesh(2);
  
       // Default setting: Retain fluid on solid
       Retain_solid_onto_fluid_terms = false;
       Retain_fluid_onto_solid_terms = true;
  
       // Null the preconditioner pointer (inexact solver)
       Preconditioner_pt = 0;
  
       // Initially assume that there are no multiple element types in
       // the same mesh.
       Allow_multiple_element_type_in_navier_stokes_mesh = false;
       Allow_multiple_element_type_in_wall_mesh = false;
     }

References oomph::SimpleFSIPreconditioner< MATRIX >::Allow_multiple_element_type_in_navier_stokes_mesh, oomph::SimpleFSIPreconditioner< MATRIX >::Allow_multiple_element_type_in_wall_mesh, oomph::SimpleFSIPreconditioner< MATRIX >::Navier_stokes_mesh_pt, oomph::SimpleFSIPreconditioner< MATRIX >::Preconditioner_pt, oomph::SimpleFSIPreconditioner< MATRIX >::Retain_fluid_onto_solid_terms, oomph::SimpleFSIPreconditioner< MATRIX >::Retain_solid_onto_fluid_terms, oomph::BlockPreconditioner< MATRIX >::set_nmesh(), and oomph::SimpleFSIPreconditioner< MATRIX >::Wall_mesh_pt.

◆ ~SimpleFSIPreconditioner()

template<typename MATRIX >

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

inline

Destructor: Clean up.

     {
       // Wiping preconditioner (inexact solver) wipes the stored
       // LU decompositon
       if (Preconditioner_pt != 0)
       {
         delete Preconditioner_pt;
         Preconditioner_pt = 0;
       }
     }

References oomph::SimpleFSIPreconditioner< MATRIX >::Preconditioner_pt.

◆ SimpleFSIPreconditioner() [2/2]

template<typename MATRIX >

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

delete

Broken copy constructor.

Member Function Documentation

◆ identify_required_blocks()

template<typename MATRIX >

void SimpleFSIPreconditioner< MATRIX >::identify_required_blocks ( DenseMatrix< bool > & required_blocks )

privatevirtual

Identify the required blocks: Here we only need the momentum, gradient and divergence blocks of the 2x2 block-structured fluid matrix, the 1x1 solid block and the selected FSI-off diagonals.

///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// Identify the required blocks: Here we only need the momentum, gradient and divergence blocks of the 2x2 block-structured fluid matrix, the 1x1 solid block and the selected FSI-off diagonals.

   {
     // find number of block types
     unsigned n_dof = this->nblock_types();
  
     // Initialise all blocks to false
     for (unsigned i = 0; i < n_dof; i++)
     {
       for (unsigned j = 0; j < n_dof; j++)
       {
         required_blocks(i, j) = false;
       }
     }
  
     // Fluid: Only need momentum, gradient and divergence blocks
     required_blocks(0, 0) = true;
     required_blocks(1, 0) = true;
     required_blocks(0, 1) = true;
  
     // Always retain the solid block
     required_blocks(2, 2) = true;
  
     // Switch on the required off-diagonals
     if (Retain_solid_onto_fluid_terms)
     {
       required_blocks(0, 2) = true;
       required_blocks(1, 2) = true;
     }
     if (Retain_fluid_onto_solid_terms)
     {
       required_blocks(2, 0) = true;
       required_blocks(2, 1) = true;
       if (Retain_solid_onto_fluid_terms)
       {
         std::ostringstream error_message;
         error_message << "Can't retain all off-diagonal blocks!\n";
         throw OomphLibError(error_message.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
     }
   }

References i, j, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ preconditioner_solve()

template<typename MATRIX >

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

virtual

Apply preconditioner to r.

Apply preconditioner to Vector r.

Apply preconditioner.

Implements oomph::Preconditioner.

 {
  // Fluid Subsidiary Preconditioner
  //=================================
  
  // Start by applying the Fluid subsidiary preconditioner
  // The fluid subsidiary preconditioner is a block preconditioner and
  // hence we pass it the global residual and solution vectors (y and z)
  Navier_stokes_preconditioner_pt->preconditioner_solve(y,z);
  
  // Fluid Onto Solid Matrix Vector Product Operator
  //================================================
  
  // The vector z_f contains the result of the action of the 
  // NavierStokesPreconditioner on a subset of  the elements of z.
  // Remember the fluid block index is 0 and the solid block index is 1.
  DoubleVector z_f;
  this->get_block_vector(0,z,z_f);
  
  // Apply the matrix vector product to z_f and store the results in w
  DoubleVector w;
  Fluid_solid_coupling_matvec_pt->multiply(z_f,w);
  
  // The vector y_s contains the solid residuals
  DoubleVector y_s;
  this->get_block_vector(1,y,y_s);
  
  // Subtract the action of the fluid onto solid matrix vector product from y_s
  y_s -= w;
  w = y_s; 
  
  // Solid Subsidiary Preconditioner
  //================================
  
  // Apply the solid preconditioner to s and return the result to the 
  // global solution vector z
  DoubleVector z_s;
  Solid_preconditioner_pt->preconditioner_solve(w,z_s);
  this->return_block_vector(1,z_s,z);
 }

References w, and y.

◆ set_navier_stokes_mesh()

template<typename MATRIX >

void oomph::SimpleFSIPreconditioner< MATRIX >::set_navier_stokes_mesh	(	Mesh *	mesh_pt,
		const bool &	allow_multiple_element_type_in_navier_stokes_mesh = `false`
	)

inline

Broken assignment operator.

Setter function for the mesh containing the block-preconditionable Navier-Stokes elements.

     {
       // Store the mesh pointer.
       Navier_stokes_mesh_pt = mesh_pt;
  
       // Are there multiple elements in this mesh?
       Allow_multiple_element_type_in_navier_stokes_mesh =
         allow_multiple_element_type_in_navier_stokes_mesh;
     }

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

Referenced by main(), and PreconditionedFSICollapsibleChannelProblem< ELEMENT >::PreconditionedFSICollapsibleChannelProblem().

◆ set_wall_mesh()

template<typename MATRIX >

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

     {
       // Store the mesh pointer
       Wall_mesh_pt = mesh_pt;
  
       // Are the multiple elements in this mesh?
       Allow_multiple_element_type_in_wall_mesh =
         allow_multiple_element_type_in_wall_mesh;
     }

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

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

◆ setup()

template<typename MATRIX >

void SimpleFSIPreconditioner< MATRIX >::setup

virtual

Setup the preconditioner.

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

Setup the preconditioner: Copy the upper/lower triangular block matrices back into a big matrix (with the entries re-ordered relative to the original Jacobian matrix).

Implements oomph::Preconditioner.

 {
  // setup the meshes for BlockPreconditioner and get the number of types of
  // DOF assoicated with each Mesh.
  // Mesh 0 is the fluid mesh, and hence DOFs 0 to n_fluid_dof_type-1 
  // are the fluid DOFs. Mesh 1 is the solid mesh and therefore DOFs 
  // n_fluid_dof_type to n_total_dof_type-1 are solid DOFs
  // set the mesh pointers
  this->set_nmesh(2);
  this->set_mesh(0,Navier_stokes_mesh_pt);
  this->set_mesh(1,Solid_mesh_pt);
  
  unsigned n_fluid_dof_type = this->ndof_types_in_mesh(0);
  unsigned n_total_dof_type = n_fluid_dof_type + this->ndof_types_in_mesh(1);
  
  // This fsi preconditioner has two types of block -- fluid and solid.
  // Create a map from DOF number to block type. The fluid block is labelled
  // 0 and the solid block 1.
  Vector<unsigned> dof_to_block_map(n_total_dof_type,0);
  for (unsigned i = n_fluid_dof_type; i < n_total_dof_type; i++)
   {
    dof_to_block_map[i] = 1;
   }
  
  // Call the BlockPreconditioner method block_setup(...) to assemble the data
  // structures required for block preconditioning.
  this->block_setup(dof_to_block_map);
  
  // First the solid preconditioner
  //===============================
  
  // get the solid block matrix (1,1)
  CRDoubleMatrix* solid_matrix_pt = new CRDoubleMatrix;
  this->get_block(1,1,*solid_matrix_pt);
  
  // setup the solid preconditioner
  // (perform the LU decomposition)
  Solid_preconditioner_pt->setup(solid_matrix_pt);
  delete solid_matrix_pt; solid_matrix_pt = 0;
  
  // Next the fluid preconditioner
  //==============================
  
  // Specify the relationship between the enumeration of DOF types in the 
  // master preconditioner and the Schur complement subsidiary preconditioner 
  // so that ns_dof_type[i_nst] contains i_master
  Vector<unsigned> ns_dof_list(n_fluid_dof_type);
  for (unsigned i = 0; i < n_fluid_dof_type; i++)
   {
    ns_dof_list[i] = i;
   }
  
  // Turn the NavierStokesSchurComplement preconditioner into a subsidiary 
  // preconditioner of this (FSI) preconditioner
  Navier_stokes_preconditioner_pt->
   turn_into_subsidiary_block_preconditioner(this,ns_dof_list);
  
  // Set up the NavierStokesSchurComplement preconditioner. 
  // (Pass it a pointer to the Navier Stokes mesh)
  Navier_stokes_preconditioner_pt->
   set_navier_stokes_mesh(Navier_stokes_mesh_pt);
  
  // Navier Stokes preconditioner is a subsidiary block preconditioner.
  // It therefore needs a pointer to the full matrix.
  Navier_stokes_preconditioner_pt->setup(this->matrix_pt());
  
  // Finally the fluid onto solid matrix vector product operator
  //============================================================
  
  // Similar to the solid preconditioner get the matrix
  CRDoubleMatrix* fluid_onto_solid_matrix_pt = new CRDoubleMatrix;
  this->get_block(1,0,*fluid_onto_solid_matrix_pt);
  
  // And setup the matrix vector product operator
  this->setup_matrix_vector_product(Fluid_solid_coupling_matvec_pt,
                                    fluid_onto_solid_matrix_pt,
                                    0);
  // Clean up
  delete fluid_onto_solid_matrix_pt; fluid_onto_solid_matrix_pt = 0;
 }

References i.

◆ use_block_diagonal_version()

template<typename MATRIX >

void oomph::SimpleFSIPreconditioner< MATRIX >::use_block_diagonal_version ( )

inline

Switch to block-diagonal preconditioner.

     {
       Retain_solid_onto_fluid_terms = false;
       Retain_fluid_onto_solid_terms = false;
     }

References oomph::SimpleFSIPreconditioner< MATRIX >::Retain_fluid_onto_solid_terms, and oomph::SimpleFSIPreconditioner< MATRIX >::Retain_solid_onto_fluid_terms.

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

◆ use_block_triangular_version_with_fluid_on_solid()

template<typename MATRIX >

void oomph::SimpleFSIPreconditioner< MATRIX >::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 oomph::SimpleFSIPreconditioner< MATRIX >::Retain_fluid_onto_solid_terms, and oomph::SimpleFSIPreconditioner< MATRIX >::Retain_solid_onto_fluid_terms.

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

◆ use_block_triangular_version_with_solid_on_fluid()

template<typename MATRIX >

void oomph::SimpleFSIPreconditioner< MATRIX >::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;
     }

private

pointer to the solid mesh

Referenced by oomph::SimpleFSIPreconditioner< MATRIX >::set_wall_mesh(), and oomph::SimpleFSIPreconditioner< MATRIX >::SimpleFSIPreconditioner().

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

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

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

Constructor & Destructor Documentation

◆ SimpleFSIPreconditioner() [1/2]

◆ ~SimpleFSIPreconditioner()

◆ SimpleFSIPreconditioner() [2/2]

Member Function Documentation

◆ identify_required_blocks()

◆ preconditioner_solve()

◆ set_navier_stokes_mesh()

◆ set_wall_mesh()

◆ setup()

◆ 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

◆ Navier_stokes_mesh_pt

◆ Preconditioner_pt

◆ Retain_fluid_onto_solid_terms

◆ Retain_solid_onto_fluid_terms

◆ Wall_mesh_pt

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