The leastsquares commutator (LSC; formerly BFBT) preconditioner. It uses blocks corresponding to the displacement/position and pressure unknowns, i.e. there are a total of 2x2 blocks, and all displacement/position components are treated as a single block of unknowns. More...
#include <solid_preconditioners.h>
Public Member Functions  
PressureBasedSolidLSCPreconditioner ()  
Constructor  sets defaults for control flags. More...  
~PressureBasedSolidLSCPreconditioner ()  
Destructor. More...  
PressureBasedSolidLSCPreconditioner (const PressureBasedSolidLSCPreconditioner &)  
Broken copy constructor. More...  
void  setup () 
Broken assignment operator. More...  
void  preconditioner_solve (const DoubleVector &r, DoubleVector &z) 
Apply preconditioner to Vector r. More...  
void  set_solid_mesh (Mesh *mesh_pt) 
void  enable_p_matrix_scaling () 
Enable mass matrix diagonal scaling in the Schur complement approximation. More...  
void  disable_p_matrix_scaling () 
Enable mass matrix diagonal scaling in the. More...  
bool  is_p_matrix_using_scaling () const 
Return whether the mass matrix is using diagonal scaling or not. More...  
void  set_p_preconditioner (Preconditioner *new_p_preconditioner_pt) 
Function to set a new pressure matrix preconditioner (inexact solver) More...  
void  set_p_superlu_preconditioner () 
Function to (re)set pressure matrix preconditioner (inexact solver) to SuperLU. More...  
void  set_f_preconditioner (Preconditioner *new_f_preconditioner_pt) 
Function to set a new momentum matrix preconditioner (inexact solver) More...  
void  set_f_superlu_preconditioner () 
Function to (re)set momentum matrix preconditioner (inexact solver) to SuperLU. More...  
void  enable_doc_time () 
Enable documentation of time. More...  
void  disable_doc_time () 
Disable documentation of time. More...  
void  enable_form_BFBt_product () 
If this function is called then: in setup(...) : BFBt is computed. in preconditioner_solve(...) : a single matrix vector product with BFBt is performed. More...  
void  disable_form_BFBt_product () 
if this function is called then: in setup(...) : the matrices B, F are assembled and stored (the default behaviour) . in preconditioner_solve(...) : a sequence of matrix vector products with B, F, and Bt is performed. (Note: in this discussion no scaling was considered but B and Bt are replaced with BQ and QBt with scaling) More...  
void  clean_up_memory () 
Helper function to delete preconditioner data. More...  
Public Member Functions inherited from oomph::BlockPreconditioner< CRDoubleMatrix >  
BlockPreconditioner ()  
Constructor. More...  
BlockPreconditioner (const BlockPreconditioner &)  
Broken copy constructor. More...  
virtual  ~BlockPreconditioner () 
Destructor. More...  
void  operator= (const BlockPreconditioner &) 
Broken assignment operator. More...  
CRDoubleMatrix *  matrix_pt () const 
Access function to matrix_pt. If this is the master then cast the matrix pointer to MATRIX*, error check and return. Otherwise ask the master for its matrix pointer. More...  
void  turn_on_recursive_debug_flag () 
Toggles on the recursive debug flag. The change goes up the block preconditioning hierarchy. More...  
void  turn_off_recursive_debug_flag () 
Toggles off the recursive debug flag. The change goes up the block preconditioning hierarchy. More...  
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) 
Function to turn this preconditioner into a subsidiary preconditioner that operates within a bigger "master block preconditioner (e.g. a NavierStokes 2x2 block preconditioner dealing with the fluid subblocks within a 3x3 FSI preconditioner. Once this is done the master block preconditioner deals with the block setup etc. The vector doftype_in_master_preconditioner_coarse must specify the dof number in the master preconditioner that corresponds to a dof number in this preconditioner. 1. The length of the vector is used to determine the number of blocks in this preconditioner therefore it must be correctly sized. 2. block_setup(...) should be called in the master preconditioner before this method is called. 3. block_setup(...) should be called in the corresponding subsidiary preconditioner after this method is called. More...  
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) 
Function to turn this preconditioner into a subsidiary preconditioner that operates within a bigger "master block preconditioner (e.g. a NavierStokes 2x2 block preconditioner dealing with the fluid subblocks within a 3x3 FSI preconditioner. Once this is done the master block preconditioner deals with the block setup etc. The vector doftype_in_master_preconditioner_coarse must specify the dof number in the master preconditioner that corresponds to a dof number in this preconditioner. 1. The length of the vector is used to determine the number of blocks in this preconditioner therefore it must be correctly sized. 2. block_setup(...) should be called in the master preconditioner before this method is called. 3. block_setup(...) should be called in the corresponding subsidiary preconditioner after this method is called. More...  
virtual void  block_setup () 
Determine the size of the matrix blocks and setup the lookup schemes relating the global degrees of freedom with their "blocks" and their indices (row/column numbers) in those blocks. The distributions of the preconditioner and the internal blocks are automatically specified (and assumed to be uniform) at this stage. This method should be used if the identity doftoblock mapping is okay, i.e. dof number 0 corresponds to block number 0 dof number 1 corresponds to block number 1 dof number 2 corresponds to block number 2 etc... More...  
void  block_setup (const Vector< unsigned > &dof_to_block_map) 
Determine the size of the matrix blocks and setup the lookup schemes relating the global degrees of freedom with their "blocks" and their indices (row/column numbers) in those blocks. The distributions of the preconditioner and the blocks are automatically specified (and assumed to be uniform) at this stage. This method should be used if anything other than the identity doftoblock mapping is required. The argument vector dof_to_block_map should be of length ndof. The indices represents the dof types whilst the value represents the block types. In general we want: More...  
void  get_block (const unsigned &i, const unsigned &j, CRDoubleMatrix &output_matrix, const bool &ignore_replacement_block=false) const 
Put block (i,j) into output_matrix. This block accounts for any coarsening of dof types and any replaced doflevel blocks above this preconditioner. More...  
CRDoubleMatrix  get_block (const unsigned &i, const unsigned &j, const bool &ignore_replacement_block=false) const 
Return block (i,j). If the optional argument ignore_replacement_block is true, then any blocks in Replacement_dof_block_pt will be ignored throughout the preconditioning hierarchy. More...  
void  set_master_matrix_pt (CRDoubleMatrix *in_matrix_pt) 
Set the matrix_pt in the uppermost master preconditioner. More...  
void  get_block_other_matrix (const unsigned &i, const unsigned &j, CRDoubleMatrix *in_matrix_pt, CRDoubleMatrix &output_matrix) 
Get a block from a different matrix using the blocking scheme that has already been set up. More...  
void  get_blocks (DenseMatrix< bool > &required_blocks, DenseMatrix< CRDoubleMatrix * > &block_matrix_pt) const 
Get all the block matrices required by the block preconditioner. Takes a pointer to a matrix of bools that indicate if a specified subblock is required for the preconditioning operation. Computes the required block matrices, and stores pointers to them in the matrix block_matrix_pt. If an entry in block_matrix_pt is equal to NULL on return, that subblock has not been requested and is therefore not available. More...  
void  get_dof_level_block (const unsigned &i, const unsigned &j, CRDoubleMatrix &output_block, const bool &ignore_replacement_block=false) const 
Gets doflevel block (i,j). If Replacement_dof_block_pt(i,j) is not null, then the replacement block is returned via a deep copy. More...  
CRDoubleMatrix  get_concatenated_block (const VectorMatrix< BlockSelector > &selected_block) 
Returns a concatenation of the block matrices specified by the argument selected_block. The VectorMatrix selected_block must be correctly sized as it is used to determine the number of sub block matrices to concatenate. More...  
void  get_concatenated_block_vector (const Vector< unsigned > &block_vec_number, const DoubleVector &v, DoubleVector &b) 
Takes the naturally ordered vector and extracts the blocks indicated by the block number (the values) in the Vector block_vec_number all at once, then concatenates them without communication. Here, the values in block_vec_number is the block number in the current preconditioner. This is a nonconst function because distributions may be created and stored in Auxiliary_block_distribution_pt for future use. More...  
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 entries to the appropriate entries in the naturally ordered vector, v. Here the values in block_vec_number indicates which blocks the vector b is a concatenation of. The block number are those in the current preconditioner. If the preconditioner is a subsidiary block preconditioner the other entries in v that are not associated with it are left alone. More...  
void  get_block_vectors (const Vector< unsigned > &block_vec_number, const DoubleVector &v, Vector< DoubleVector > &s) const 
Takes the naturally ordered vector and rearranges it into a vector of sub vectors corresponding to the blocks, so s[b][i] contains the ith entry in the vector associated with block b. Note: If the preconditioner is a subsidiary preconditioner then only the subvectors associated with the blocks of the subsidiary preconditioner will be included. Hence the length of v is master_nrow() whereas the total length of the s vectors is the sum of the lengths of the individual block vectors defined in block_vec_number. More...  
void  get_block_vectors (const DoubleVector &v, Vector< DoubleVector > &s) const 
Takes the naturally ordered vector and rearranges it into a vector of sub vectors corresponding to the blocks, so s[b][i] contains the ith entry in the vector associated with block b. Note: If the preconditioner is a subsidiary preconditioner then only the subvectors associated with the blocks of the subsidiary preconditioner will be included. Hence the length of v is master_nrow() whereas the total length of the s vectors is Nrow. This is simply a wrapper around the other get_block_vectors(...) function where the block_vec_number Vector is the identity, i.e. block_vec_number is [0, 1, ..., nblock_types  1]. More...  
void  return_block_vectors (const Vector< unsigned > &block_vec_number, const Vector< DoubleVector > &s, DoubleVector &v) const 
Takes the vector of block vectors, s, and copies its entries into the naturally ordered vector, v. If this is a subsidiary block preconditioner only those entries in v that are associated with its blocks are affected. The block_vec_number indicates which block the vectors in s came from. The block number corresponds to the block numbers in this preconditioner. More...  
void  return_block_vectors (const Vector< DoubleVector > &s, DoubleVector &v) const 
Takes the vector of block vectors, s, and copies its entries into the naturally ordered vector, v. If this is a subsidiary block preconditioner only those entries in v that are associated with its blocks are affected. The block_vec_number indicates which block the vectors in s came from. The block number corresponds to the block numbers in this preconditioner. This is simply a wrapper around the other return_block_vectors(...) function where the block_vec_number Vector is the identity, i.e. block_vec_number is [0, 1, ..., nblock_types  1]. More...  
void  get_block_vector (const unsigned &n, const DoubleVector &v, DoubleVector &b) const 
Takes the naturally ordered vector, v and returns the nth block vector, b. Here n is the block number in the current preconditioner. More...  
void  return_block_vector (const unsigned &n, const DoubleVector &b, DoubleVector &v) const 
Takes the nth block ordered vector, b, and copies its entries to the appropriate entries in the naturally ordered vector, v. Here n is the block number in the current block preconditioner. If the preconditioner is a subsidiary block preconditioner the other entries in v that are not associated with it are left alone. More...  
void  get_block_ordered_preconditioner_vector (const DoubleVector &v, DoubleVector &w) 
Given the naturally ordered vector, v, return the vector rearranged in block order in w. This function calls get_concatenated_block_vector(...) with the identity block mapping. More...  
void  return_block_ordered_preconditioner_vector (const DoubleVector &w, DoubleVector &v) const 
Takes the block ordered vector, w, and reorders it in natural order. Reordered vector is returned in v. Note: If the preconditioner is a subsidiary preconditioner then only the components of the vector associated with the blocks of the subsidiary preconditioner will be included. Hence the length of v is master_nrow() whereas that of the vector w is of length this>nrow(). More...  
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 
Access to ith mesh (of the various meshes that contain block preconditionable elements of the same number of dof type). More...  
unsigned  nmesh () const 
Return the number of meshes in Mesh_pt. More...  
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 
Given a global dof number, returns the index in the block it belongs to. This is the overall index, not local block (in parallel). More...  
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 (nonconst version). More...  
LinearAlgebraDistribution *  dof_block_distribution_pt (const unsigned &b) 
Access function to the doflevel block distributions. More...  
const LinearAlgebraDistribution *  master_distribution_pt () const 
Access function to the distribution of the master preconditioner. If this preconditioner does not have a master preconditioner then the distribution of this preconditioner is returned. More...  
unsigned  ndof_types_in_mesh (const unsigned &i) const 
Return the number of DOF types in mesh i. WARNING: This should only be used by the uppermost master block preconditioner. An error is thrown is this function is called from a subsidiary preconditioner. They (and since every block preconditioner can in principle be used as s subsidiary preconditioner: all block preconditioners) should store local copies of "their meshes" (if they're needed for anything) More...  
bool  is_subsidiary_block_preconditioner () const 
Return true if this preconditioner is a subsidiary preconditioner. More...  
bool  is_master_block_preconditioner () const 
Return true if this preconditioner is the master block preconditioner. More...  
void  set_block_output_to_files (const std::string &basefilename) 
Set the base part of the filename to output blocks to. If it is set then all blocks will be output at the end of block_setup. If it is left empty nothing will be output. More...  
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 () 
A helper method to reduce the memory requirements of block preconditioners. Once the methods get_block(...), get_blocks(...) and build_preconditioner_matrix(...) have been called in this and all subsidiary block preconditioners this method can be called to clean up. More...  
BlockPreconditioner < CRDoubleMatrix > *  master_block_preconditioner_pt () const 
Access function to the master block preconditioner pt. More...  
void  clear_block_preconditioner_base () 
Clears all BlockPreconditioner data. Called by the destructor and the block_setup(...) methods. More...  
void  document () 
debugging method to document the setup. Should only be called after block_setup(...). More...  
Vector< Vector< unsigned > >  doftype_coarsen_map_fine () const 
Access function for the Doftype_coarsen_map_fine variable. More...  
Vector< unsigned >  get_fine_grain_dof_types_in (const unsigned &i) const 
Returns the most fine grain dof types in a (possibly coarsened) dof type. More...  
unsigned  nfine_grain_dof_types_in (const unsigned &i) const 
Access function for the number of most fine grain dof types in a (possibly coarsened) dof type. More...  
MapMatrix< unsigned, CRDoubleMatrix * >  replacement_dof_block_pt () const 
Access function to the replaced doflevel blocks. More...  
void  setup_matrix_vector_product (MatrixVectorProduct *matvec_prod_pt, CRDoubleMatrix *block_pt, const Vector< unsigned > &block_col_indices) 
Setup a matrix vector product. matvec_prod_pt is a pointer to the MatrixVectorProduct, block_pt is a pointer to the block matrix, block_col_indices is a vector indicating which block indices does the RHS vector we want to multiply the matrix by. More...  
void  setup_matrix_vector_product (MatrixVectorProduct *matvec_prod_pt, CRDoubleMatrix *block_pt, const unsigned &block_col_index) 
Setup matrix vector product. This is simply a wrapper around the other setup_matrix_vector_product function. More...  
void  internal_get_block_ordered_preconditioner_vector (const DoubleVector &v, DoubleVector &w) const 
Given the naturally ordered vector, v, return the vector rearranged in block order in w. This is a legacy function from the old block preconditioning framework. Kept alive in case it may be needed again. More...  
void  internal_return_block_ordered_preconditioner_vector (const DoubleVector &w, DoubleVector &v) const 
Takes the block ordered vector, w, and reorders it in the natural order. Reordered vector is returned in v. Note: If the preconditioner is a subsidiary preconditioner then only the components of the vector associated with the blocks of the subsidiary preconditioner will be included. Hence the length of v is master_nrow() whereas that of the vector w is of length this>nrow(). More...  
unsigned  internal_nblock_types () const 
Return the number internal blocks. This should be the same as the number of internal dof types. Internally, the block preconditioning framework always work with the most fine grain blocks. I.e. it always deal with the most fine grain doflevel blocks. This allows for coarsening of dof types. When we extract a block, we look at the Block_to_dof_map_fine vector to find out which most fine grain dof types belongs to this block. More...  
unsigned  internal_ndof_types () const 
Return the number of internal dof types. This is the number of most fine grain dof types. The preconditioner writer should not have to concern him/herself with the internal dof/block types. Thus this fuction is moved to private. We have kept this function alive since it it still used deep within the inner workings of the block preconditioning framework. More...  
void  internal_return_block_vector (const unsigned &n, const DoubleVector &b, DoubleVector &v) const 
Takes the nth block ordered vector, b, and copies its entries to the appropriate entries in the naturally ordered vector, v. Here n is the block number in the current block preconditioner. If the preconditioner is a subsidiary block preconditioner the other entries in v that are not associated with it are left alone. More...  
void  internal_get_block_vector (const unsigned &n, const DoubleVector &v, DoubleVector &b) const 
A helper function, takes the naturally ordered vector, v, and extracts the nth block vector, b. Here n is the block number in the current preconditioner. NOTE: The ordering of the vector b is the same as the ordering of the block matrix from internal_get_block(...). More...  
void  internal_get_block_vectors (const Vector< unsigned > &block_vec_number, const DoubleVector &v, Vector< DoubleVector > &s) const 
Takes the naturally ordered vector and rearranges it into a vector of sub vectors corresponding to the blocks, so s[b][i] contains the ith entry in the vector associated with block b. The block_vec_number indicates which blocks we want. These blocks and vectors are those corresponding to the internal blocks. Note: If the preconditioner is a subsidiary preconditioner then only the subvectors associated with the blocks of the subsidiary preconditioner will be included. Hence the length of v is master_nrow() whereas the total length of the s vectors is the sum of the Nrow of the sub vectors. More...  
void  internal_get_block_vectors (const DoubleVector &v, Vector< DoubleVector > &s) const 
A helper function, takes the naturally ordered vector and rearranges it into a vector of sub vectors corresponding to the blocks, so s[b][i] contains the ith entry in the vector associated with block b. The block_vec_number indicates which blocks we want. These blocks and vectors are those corresponding to the internal blocks. Note: If the preconditioner is a subsidiary preconditioner then only the subvectors associated with the blocks of the subsidiary preconditioner will be included. Hence the length of v is master_nrow() whereas the total length of the s vectors is the sum of the Nrow of the sub vectors. This is simply a wrapper around the other internal_get_block_vectors(...) function with the identity block_vec_number vector. More...  
void  internal_return_block_vectors (const Vector< unsigned > &block_vec_number, const Vector< DoubleVector > &s, DoubleVector &v) const 
A helper function, takes the vector of block vectors, s, and copies its entries into the naturally ordered vector, v. If this is a subsidiary block preconditioner only those entries in v that are associated with its blocks are affected. More...  
void  internal_return_block_vectors (const Vector< DoubleVector > &s, DoubleVector &v) const 
A helper function, takes the vector of block vectors, s, and copies its entries into the naturally ordered vector, v. If this is a subsidiary block preconditioner only those entries in v that are associated with its blocks are affected. This is simple a wrapper around the other internal_return_block_vectors(...) function with the identity block_vec_number vector. More...  
void  internal_get_block (const unsigned &i, const unsigned &j, CRDoubleMatrix &output_block) const 
Gets block (i,j) from the matrix pointed to by Matrix_pt and returns it in output_block. This is associated with the internal blocks. Please use the other get_block(...) function. More...  
int  internal_block_number (const unsigned &i_dof) const 
Return the block number corresponding to a global index i_dof. This returns the block number corresponding to the internal blocks. What this means is that this returns the most fine grain dofblock number which this global index i_dof corresponds to. Since the writer of the preconditioner does not need to care about the internal block types, this function should not be used and thus moved to private. This function should not be removed since it is still used deep within the inner workings of the block preconditioning framework. More...  
int  internal_index_in_block (const unsigned &i_dof) const 
Return the index in the block corresponding to a global block number i_dof. The index returned corresponds to the internal blocks, which is the most fine grain dof blocks. More...  
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) 
insert a Vector<unsigned> and LinearAlgebraDistribution* pair into Auxiliary_block_distribution_pt. The Auxiliary_block_distribution_pt should only contain pointers to distributions concatenated at this block level. We try to ensure this by checking if the block_vec_number vector is within the range nblock_types(). Of course, this does not guarantee correctness, but this is the least we can do. More...  
void  block_matrix_test (const unsigned &i, const unsigned &j, const CRDoubleMatrix *block_matrix_pt) const 
Private helper function to check that every element in the block matrix (i,j) matches the corresponding element in the original matrix. More...  
int  get_index_of_value (const Vector< myType > &vec, const myType val, const bool sorted=false) const 
Get the index of first occurrence of value in a vector. If the element does not exist, 1 is returned. The optional parameter indicates of the Vector is sorted or not. Complexity: if the Vector is sorted, then on average, logarithmic in the distance between first and last: Performs approximately log2(N)+2 element comparisons. Otherwise, up to linear in the distance between first and last: Compares elements until a match is found. More...  
Public Member Functions inherited from oomph::Preconditioner  
Preconditioner ()  
Constructor. More...  
Preconditioner (const Preconditioner &)  
Broken copy constructor. More...  
void  operator= (const Preconditioner &) 
Broken assignment operator. More...  
virtual  ~Preconditioner () 
Destructor (empty) More...  
void  setup (DoubleMatrixBase *matrix_pt) 
Setup the preconditioner: store the matrix pointer and the communicator pointer then call preconditioner specific setup() function. More...  
void  setup (const Problem *problem_pt, DoubleMatrixBase *matrix_pt) 
Compatability layer for old preconditioners where problem pointers were needed. The problem pointer is only used to get a communicator pointer. 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...  
Public Member Functions inherited from oomph::DistributableLinearAlgebraObject  
DistributableLinearAlgebraObject ()  
Default constructor  create a distribution. More...  
DistributableLinearAlgebraObject (const DistributableLinearAlgebraObject &matrix)  
Broken copy constructor. More...  
void  operator= (const DistributableLinearAlgebraObject &) 
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) 
setup the distribution of this distributable linear algebra object More...  
void  build_distribution (const LinearAlgebraDistribution &dist) 
setup the distribution of this distributable linear algebra object More...  
Private Member Functions  
CRDoubleMatrix *  assemble_mass_matrix_diagonal () 
Private Attributes  
Preconditioner *  P_preconditioner_pt 
Pointer to the 'preconditioner' for the pressure matrix. More...  
Preconditioner *  F_preconditioner_pt 
Pointer to the 'preconditioner' for the F matrix. More...  
bool  Using_default_f_preconditioner 
flag indicating whether the default F preconditioner is used More...  
bool  Using_default_p_preconditioner 
flag indicating whether the default P preconditioner is used More...  
bool  Preconditioner_has_been_setup 
Control flag is true if the preconditioner has been setup (used so we can wipe the data when the preconditioner is called again) More...  
bool  P_matrix_using_scaling 
Control flag is true if mass matrix diagonal scaling is used in the Schur complement approximation. More...  
bool  F_preconditioner_is_block_preconditioner 
Boolean indicating whether the momentum system preconditioner is a block preconditioner. More...  
bool  Doc_time 
Set Doc_time to true for outputting results of timings. More...  
MatrixVectorProduct *  F_mat_vec_pt 
MatrixVectorProduct operator for F if BFBt is not to be formed. More...  
MatrixVectorProduct *  QBt_mat_vec_pt 
MatrixVectorProduct operator for QBt if BFBt is not to be formed. More...  
MatrixVectorProduct *  Bt_mat_vec_pt 
MatrixVectorProduct operator for Bt;. More...  
MatrixVectorProduct *  E_mat_vec_pt 
MatrixVectorProduct operator for E (BFBt) if BFBt is to be formed. More...  
bool  Form_BFBt_product 
indicates whether BFBt should be formed or the component matrices should be retained. If true then: in setup(...) : BFBt is computed. in preconditioner_solve(...) : a single matrix vector product with BFBt is performed. if false then: in setup(...) : the matrices B, F are assembled and stored. in preconditioner_solve(...) : a sequence of matrix vector products with B, F, and Bt is performed. (Note: in this discussion no scaling was considered but B and Bt are replaced with BQ and QBt with scaling) More...  
Mesh *  Solid_mesh_pt 
the pointer to the mesh of block preconditionable solid elements. More...  
Additional Inherited Members  
Protected Member Functions inherited from oomph::BlockPreconditioner< CRDoubleMatrix >  
void  set_nmesh (const unsigned &n) 
Specify the number of meshes required by this block preconditioner. Note: elements in different meshes correspond to different types of DOF. More...  
void  set_mesh (const unsigned &i, const Mesh *const mesh_pt, const bool &allow_multiple_element_type_in_mesh=false) 
Set the ith mesh for this block preconditioner. Note: The method set_nmesh(...) must be called before this method to specify the number of meshes. By default, it is assumed that each mesh only contains elements of the same type. This condition may be relaxed by setting the boolean allow_multiple_element_type_in_mesh to true, however, each mesh must only contain elements with the same number of dof types. More...  
void  set_replacement_dof_block (const unsigned &block_i, const unsigned &block_j, CRDoubleMatrix *replacement_dof_block_pt) 
Set replacement doflevel blocks. Only doflevel blocks can be set. This is important due to how the dof type coarsening feature operates. More...  
bool  any_mesh_distributed () const 
Check if any of the meshes are distributed. This is equivalent to problem.distributed() and is used as a replacement. More...  
int  internal_dof_number (const unsigned &i_dof) const 
Return the number of the block associated with global unknown i_dof. If this preconditioner is a subsidiary block preconditioner then the block number in the subsidiary block preconditioner is returned. If a particular global DOF is not associated with this preconditioner then 1 is returned. More...  
unsigned  internal_index_in_dof (const unsigned &i_dof) const 
Return the row/column number of global unknown i_dof within it's block. More...  
unsigned  internal_block_dimension (const unsigned &b) const 
Return the number of degrees of freedom in block b. Note that if this preconditioner acts as a subsidiary preconditioner then b refers to the block number in the subsidiary preconditioner not the master block preconditioner. More...  
unsigned  internal_dof_block_dimension (const unsigned &i) const 
Return the size of the dof "block" i, i.e. how many degrees of freedom are associated with it. Note that if this preconditioner acts as a subsidiary preconditioner, then i refers to the block number in the subsidiary preconditioner not the master block preconditioner. More...  
unsigned  master_nrow () const 
Return the number of dofs (number of rows or columns) in the overall problem. The prefix "master_" is sort of redundant when used as a standalone block preconditioner but is required to avoid ambiguities. The latter is stored (and maintained) separately for each specific block preconditioner regardless of its role. More...  
unsigned  internal_master_dof_number (const unsigned &b) const 
Takes the block number within this preconditioner and returns the corresponding block number in the master preconditioner. If this preconditioner does not have a master block preconditioner then the block number passed is returned. More...  
const LinearAlgebraDistribution *  internal_preconditioner_matrix_distribution_pt () const 
access function to the internal preconditioner matrix distribution pt. preconditioner_matrix_distribution_pt always returns the concatenation of the internal block distributions. Since the writer of the preconditioner does not need to concern themselves with the internal dof/block, please use preconditioner_matrix_distribution_pt(). More...  
const LinearAlgebraDistribution *  preconditioner_matrix_distribution_pt () const 
Access function to the preconditioner matrix distribution pointer. This is the concatenation of the block distributions with the identity ordering. I.e. if this preconditioner has three block types, with the three associated block distributions dist_b0, dist_b1 and dist_b2, then this distribution is: LinearAlgebraDistributionHelpers::concatenate(dist_b0, dist_b1, dist_b2). More...  
Protected Member Functions inherited from oomph::DistributableLinearAlgebraObject  
void  clear_distribution () 
clear the distribution of this distributable linear algebra object More...  
Protected Attributes inherited from oomph::BlockPreconditioner< CRDoubleMatrix >  
MapMatrix< unsigned, CRDoubleMatrix * >  Replacement_dof_block_pt 
The replacement doflevel blocks. More...  
Vector < LinearAlgebraDistribution * >  Block_distribution_pt 
The distribution for the blocks. More...  
Vector< Vector< unsigned > >  Block_to_dof_map_coarse 
Mapping for block types to dof types. These are the dof types the writer of the preconditioner expects. For the uppermost master block preconditioner, this would be the sum of the dof types in the meshes. For subsidiary block preconditioners, this is determined by the parent preconditioner when passing in the doftype_coarsen_map_coarse vector in turn_into_subsidiary_block_preconditioner(...). More...  
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 
Mapping for dof types within THIS precondition. This is usually passed down from the parent preconditioner. This list is used to tell which does types should be considered as a single dof type within this preconditioner. I.e. we "coarsen" the dof types. The values are local to this preconditioner, for example, even if the Doftype_in_master_preconditioner_coarse = [2,3,4], the vector Doftype_coarsen_map_coarse = [[0],[1,2]], saying your local dof types 0 should be considered as dof type 0 and dof types 1 and 2 are considered as dof type 1. More...  
Vector< Vector< unsigned > >  Doftype_coarsen_map_fine 
Mapping the dof types within this preconditioner. The values in here refers to the most grain dof types. This list is automatically generated either in block_setup(...) (for the topmost preconditioner) or the turn_into_subsidiary_block_preconditioner(...) function. Please refer to the comment above Doftype_coarsen_map_coarse for more details. More...  
Vector < LinearAlgebraDistribution * >  Internal_block_distribution_pt 
Storage for the default distribution for each internal block. More...  
Vector < LinearAlgebraDistribution * >  Dof_block_distribution_pt 
Storage for the default distribution for each dof block at this level. More...  
Vector< unsigned >  Allow_multiple_element_type_in_mesh 
Vector of unsigned to indicate which meshes contain multiple element types. More...  
Vector< const Mesh * >  Mesh_pt 
Vector of pointers to the meshes containing the elements used in the block preconditioner. Const pointers to prevent modification of the mesh by the preconditioner (this could be relaxed if needed). If this is a subsidiary preconditioner, then the information is looked up in the master preconditioner. More...  
Vector< unsigned >  Ndof_types_in_mesh 
Storage for number of types of degree of freedom of the elements in each mesh. More...  
unsigned  Internal_nblock_types 
Number of different block types in this preconditioner. Note that this information is maintained if used as a subsidiary or standalone block preconditioner, in the latter case it stores the number of blocks within the subsidiary preconditioner. More...  
unsigned  Internal_ndof_types 
Number of different DOF types in this preconditioner. Note that this information is maintained if used as a subsidiary or standalone block preconditioner, in the latter case it stores the number of dofs within the subsidiary preconditioner. More...  
The leastsquares commutator (LSC; formerly BFBT) preconditioner. It uses blocks corresponding to the displacement/position and pressure unknowns, i.e. there are a total of 2x2 blocks, and all displacement/position components are treated as a single block of unknowns.
Here are the details: An "ideal" preconditioner would solve the saddle point system
where , , and are the blocks that arise in the Jacobian of the pressurebased equations of linear and nonlinear elasticity (with dofs in order of displacement/position and pressure). The use of this preconditioner would ensure the convergence of any iterative linear solver in a single iteration but its application is, of course, exactly as expensive as a direct solve. The LSC/BFBT preconditioner replaces the exact Jacobian by a blocktriangular approximation
where is an approximation to the pressure Schurcomplement This system can be solved in two steps:
In the LSC/BFBT preconditioner, the action of the inverse pressure Schur complement
is approximated by
where is the diagonal of the displacement/position mass matrix. The evaluation of this expression involves two linear solves involving the matrix
which has the character of a matrix arising from the discretisation of a Poisson problem on the pressure space. We also have to evaluate matrixvector products with the matrix
Details of the theory can be found in "Finite Elements and Fast Iterative Solvers with Applications in Incompressible Fluid Dynamics" by Howard C. Elman, David J. Silvester, and Andrew J. Wathen, published by Oxford University Press, 2006.
In our implementation of the preconditioner, the linear systems can either be solved "exactly", using SuperLU (in its incarnation as an exact preconditioner; this is the default) or by any other Preconditioner (inexact solver) specified via the access functions
or
Definition at line 161 of file solid_preconditioners.h.

inline 
Constructor  sets defaults for control flags.
Definition at line 168 of file solid_preconditioners.h.
References Bt_mat_vec_pt, Doc_time, E_mat_vec_pt, F_mat_vec_pt, F_preconditioner_pt, Form_BFBt_product, P_matrix_using_scaling, P_preconditioner_pt, Preconditioner_has_been_setup, QBt_mat_vec_pt, oomph::BlockPreconditioner< CRDoubleMatrix >::set_nmesh(), Solid_mesh_pt, Using_default_f_preconditioner, and Using_default_p_preconditioner.

inline 

inline 
Broken copy constructor.
Definition at line 219 of file solid_preconditioners.h.
References oomph::BrokenCopy::broken_copy().

private 
Helper function to assemble the diagonal of the mass matrix from the elemental contributions defined in PressureBasedSolidEquations<DIM>::get_mass_matrix_diagonal(...).
Helper function to assemble the diagonal of the mass matrix from the elemental contributions defined in SolidElementWithDiagonalMassMatrix::get_mass_matrix_diagonal(...).
Definition at line 730 of file solid_preconditioners.cc.
References oomph::BlockPreconditioner< CRDoubleMatrix >::any_mesh_distributed(), oomph::BlockPreconditioner< CRDoubleMatrix >::block_distribution_pt(), oomph::BlockPreconditioner< CRDoubleMatrix >::block_number(), oomph::CRDoubleMatrix::build_without_copy(), oomph::Preconditioner::comm_pt(), oomph::DistributableLinearAlgebraObject::distributed(), e, oomph::Mesh::element_pt(), oomph::GeneralisedElement::eqn_number(), oomph::LinearAlgebraDistribution::first_row(), oomph::DistributableLinearAlgebraObject::first_row(), oomph::SolidElementWithDiagonalMassMatrix::get_mass_matrix_diagonal(), i, oomph::BlockPreconditioner< CRDoubleMatrix >::index_in_block(), oomph::GeneralisedElement::is_halo(), oomph::BlockPreconditioner< CRDoubleMatrix >::master_distribution_pt(), oomph::GeneralisedElement::ndof(), oomph::Mesh::nelement(), oomph::LinearAlgebraDistribution::nrow(), oomph::DistributableLinearAlgebraObject::nrow(), oomph::LinearAlgebraDistribution::nrow_local(), oomph::DistributableLinearAlgebraObject::nrow_local(), and Solid_mesh_pt.
Referenced by setup().

virtual 
Helper function to delete preconditioner data.
Reimplemented from oomph::Preconditioner.
Definition at line 1397 of file solid_preconditioners.cc.
References Bt_mat_vec_pt, E_mat_vec_pt, F_mat_vec_pt, F_preconditioner_pt, Form_BFBt_product, P_preconditioner_pt, Preconditioner_has_been_setup, QBt_mat_vec_pt, Using_default_f_preconditioner, and Using_default_p_preconditioner.
Referenced by setup(), and ~PressureBasedSolidLSCPreconditioner().

inline 
Disable documentation of time.
Definition at line 313 of file solid_preconditioners.h.
References Doc_time.

inline 
if this function is called then: in setup(...) : the matrices B, F are assembled and stored (the default behaviour) . in preconditioner_solve(...) : a sequence of matrix vector products with B, F, and Bt is performed. (Note: in this discussion no scaling was considered but B and Bt are replaced with BQ and QBt with scaling)
Definition at line 328 of file solid_preconditioners.h.
References Form_BFBt_product.

inline 
Enable mass matrix diagonal scaling in the.
Schur complement approximation
Definition at line 254 of file solid_preconditioners.h.
References P_matrix_using_scaling.

inline 
Enable documentation of time.
Definition at line 310 of file solid_preconditioners.h.
References Doc_time.

inline 
If this function is called then: in setup(...) : BFBt is computed. in preconditioner_solve(...) : a single matrix vector product with BFBt is performed.
Definition at line 319 of file solid_preconditioners.h.
References Form_BFBt_product.

inline 
Enable mass matrix diagonal scaling in the Schur complement approximation.
Definition at line 250 of file solid_preconditioners.h.
References P_matrix_using_scaling.

inline 
Return whether the mass matrix is using diagonal scaling or not.
Definition at line 258 of file solid_preconditioners.h.
References P_matrix_using_scaling.

virtual 
Apply preconditioner to Vector r.
Apply preconditioner to r.
Implements oomph::Preconditioner.
Definition at line 510 of file solid_preconditioners.cc.
References Bt_mat_vec_pt, oomph::DoubleVector::build(), oomph::DoubleVector::built(), oomph::DoubleVector::clear(), oomph::DistributableLinearAlgebraObject::distribution_pt(), Doc_time, E_mat_vec_pt, F_mat_vec_pt, F_preconditioner_is_block_preconditioner, F_preconditioner_pt, Form_BFBt_product, oomph::BlockPreconditioner< CRDoubleMatrix >::get_block_vector(), oomph::MatrixVectorProduct::multiply(), oomph::MatrixVectorProduct::multiply_transpose(), oomph::DistributableLinearAlgebraObject::nrow(), oomph::oomph_info, P_preconditioner_pt, Preconditioner_has_been_setup, oomph::Preconditioner::preconditioner_solve(), QBt_mat_vec_pt, oomph::BlockPreconditioner< CRDoubleMatrix >::return_block_vector(), and oomph::TimingHelpers::timer().

inline 
Function to set a new momentum matrix preconditioner (inexact solver)
Definition at line 285 of file solid_preconditioners.h.
References F_preconditioner_pt, and Using_default_f_preconditioner.

inline 
Function to (re)set momentum matrix preconditioner (inexact solver) to SuperLU.
Definition at line 299 of file solid_preconditioners.h.
References F_preconditioner_pt, and Using_default_f_preconditioner.

inline 
Function to set a new pressure matrix preconditioner (inexact solver)
Definition at line 261 of file solid_preconditioners.h.
References P_preconditioner_pt, and Using_default_p_preconditioner.

inline 
Function to (re)set pressure matrix preconditioner (inexact solver) to SuperLU.
Definition at line 275 of file solid_preconditioners.h.
References P_preconditioner_pt, and Using_default_p_preconditioner.

inline 
specify the mesh containing the mesh containing the blockpreconditionable solid elements. The dimension of the problem must also be specified.
Definition at line 243 of file solid_preconditioners.h.
References oomph::BlockPreconditioner< CRDoubleMatrix >::mesh_pt(), and Solid_mesh_pt.

virtual 
Broken assignment operator.
Setup the preconditioner
Setup the leastsquares commutator solid preconditioner. This extracts blocks corresponding to the position/displacement and pressure unknowns, creates the matrices actually needed in the application of the preconditioner and deletes what can be deleted... Note that this preconditioner needs a CRDoubleMatrix.
Implements oomph::Preconditioner.
Definition at line 47 of file solid_preconditioners.cc.
References assemble_mass_matrix_diagonal(), oomph::BlockPreconditioner< CRDoubleMatrix >::block_setup(), Bt_mat_vec_pt, clean_up_memory(), Doc_time, E_mat_vec_pt, F_mat_vec_pt, F_preconditioner_is_block_preconditioner, F_preconditioner_pt, Form_BFBt_product, oomph::BlockPreconditioner< CRDoubleMatrix >::get_block(), i, oomph::BlockPreconditioner< CRDoubleMatrix >::is_subsidiary_block_preconditioner(), oomph::BlockPreconditioner< CRDoubleMatrix >::matrix_pt(), oomph::CRDoubleMatrix::multiply(), oomph::BlockPreconditioner< CRDoubleMatrix >::ndof_types(), oomph::BlockPreconditioner< CRDoubleMatrix >::ndof_types_in_mesh(), oomph::oomph_info, P_matrix_using_scaling, P_preconditioner_pt, Preconditioner_has_been_setup, QBt_mat_vec_pt, oomph::BlockPreconditioner< CRDoubleMatrix >::set_mesh(), oomph::Preconditioner::setup(), oomph::BlockPreconditioner< CRDoubleMatrix >::setup_matrix_vector_product(), Solid_mesh_pt, oomph::TimingHelpers::timer(), oomph::BlockPreconditioner< CRDoubleMatrix >::turn_into_subsidiary_block_preconditioner(), Using_default_f_preconditioner, and Using_default_p_preconditioner.

private 
MatrixVectorProduct operator for Bt;.
Definition at line 380 of file solid_preconditioners.h.
Referenced by clean_up_memory(), preconditioner_solve(), PressureBasedSolidLSCPreconditioner(), and setup().

private 
Set Doc_time to true for outputting results of timings.
Definition at line 371 of file solid_preconditioners.h.
Referenced by disable_doc_time(), enable_doc_time(), preconditioner_solve(), PressureBasedSolidLSCPreconditioner(), and setup().

private 
MatrixVectorProduct operator for E (BFBt) if BFBt is to be formed.
Definition at line 383 of file solid_preconditioners.h.
Referenced by clean_up_memory(), preconditioner_solve(), PressureBasedSolidLSCPreconditioner(), and setup().

private 
MatrixVectorProduct operator for F if BFBt is not to be formed.
Definition at line 374 of file solid_preconditioners.h.
Referenced by clean_up_memory(), preconditioner_solve(), PressureBasedSolidLSCPreconditioner(), and setup().

private 
Boolean indicating whether the momentum system preconditioner is a block preconditioner.
Definition at line 368 of file solid_preconditioners.h.
Referenced by preconditioner_solve(), and setup().

private 
Pointer to the 'preconditioner' for the F matrix.
Definition at line 344 of file solid_preconditioners.h.
Referenced by clean_up_memory(), preconditioner_solve(), PressureBasedSolidLSCPreconditioner(), set_f_preconditioner(), set_f_superlu_preconditioner(), and setup().

private 
indicates whether BFBt should be formed or the component matrices should be retained. If true then: in setup(...) : BFBt is computed. in preconditioner_solve(...) : a single matrix vector product with BFBt is performed. if false then: in setup(...) : the matrices B, F are assembled and stored. in preconditioner_solve(...) : a sequence of matrix vector products with B, F, and Bt is performed. (Note: in this discussion no scaling was considered but B and Bt are replaced with BQ and QBt with scaling)
Definition at line 397 of file solid_preconditioners.h.
Referenced by clean_up_memory(), disable_form_BFBt_product(), enable_form_BFBt_product(), preconditioner_solve(), PressureBasedSolidLSCPreconditioner(), and setup().

private 
Control flag is true if mass matrix diagonal scaling is used in the Schur complement approximation.
Definition at line 359 of file solid_preconditioners.h.
Referenced by disable_p_matrix_scaling(), enable_p_matrix_scaling(), is_p_matrix_using_scaling(), PressureBasedSolidLSCPreconditioner(), and setup().

private 
Pointer to the 'preconditioner' for the pressure matrix.
Definition at line 341 of file solid_preconditioners.h.
Referenced by clean_up_memory(), preconditioner_solve(), PressureBasedSolidLSCPreconditioner(), set_p_preconditioner(), set_p_superlu_preconditioner(), and setup().

private 
Control flag is true if the preconditioner has been setup (used so we can wipe the data when the preconditioner is called again)
Definition at line 355 of file solid_preconditioners.h.
Referenced by clean_up_memory(), preconditioner_solve(), PressureBasedSolidLSCPreconditioner(), and setup().

private 
MatrixVectorProduct operator for QBt if BFBt is not to be formed.
Definition at line 377 of file solid_preconditioners.h.
Referenced by clean_up_memory(), preconditioner_solve(), PressureBasedSolidLSCPreconditioner(), and setup().

private 
the pointer to the mesh of block preconditionable solid elements.
Definition at line 401 of file solid_preconditioners.h.
Referenced by assemble_mass_matrix_diagonal(), PressureBasedSolidLSCPreconditioner(), set_solid_mesh(), and setup().

private 
flag indicating whether the default F preconditioner is used
Definition at line 347 of file solid_preconditioners.h.
Referenced by clean_up_memory(), PressureBasedSolidLSCPreconditioner(), set_f_preconditioner(), set_f_superlu_preconditioner(), and setup().

private 
flag indicating whether the default P preconditioner is used
Definition at line 350 of file solid_preconditioners.h.
Referenced by clean_up_memory(), PressureBasedSolidLSCPreconditioner(), set_p_preconditioner(), set_p_superlu_preconditioner(), and setup().