Public Member Functions | Protected Member Functions | Protected Attributes | Private Attributes | Static Private Attributes | List of all members
oomph::BlockPreconditioner< MATRIX > Class Template Reference

#include <block_preconditioner.h>

+ Inheritance diagram for oomph::BlockPreconditioner< MATRIX >:

Public Member Functions

 BlockPreconditioner ()
 Constructor. More...
 
virtual ~BlockPreconditioner ()
 Destructor. More...
 
 BlockPreconditioner (const BlockPreconditioner &)
 Broken copy constructor. More...
 
void operator= (const BlockPreconditioner &)
 Broken assignment operator. More...
 
MATRIX * 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< MATRIX > *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 Navier-Stokes 2x2 block preconditioner dealing with the fluid sub-blocks 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< MATRIX > *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 Navier-Stokes 2x2 block preconditioner dealing with the fluid sub-blocks 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 dof-to-block 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 dof-to-block 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, MATRIX &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 dof-level blocks above this preconditioner. More...
 
MATRIX 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 (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)
 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< MATRIX * > &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 sub-block 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 sub-block has not been requested and is therefore not available. More...
 
void get_dof_level_block (const unsigned &i, const unsigned &j, MATRIX &output_block, const bool &ignore_replacement_block=false) const
 Gets dof-level block (i,j). If Replacement_dof_block_pt(i,j) is not null, then the replacement block is returned via a deep copy. More...
 
MATRIX 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 non-const 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 i-th entry in the vector associated with block b. Note: If the preconditioner is a subsidiary preconditioner then only the sub-vectors 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 i-th entry in the vector associated with block b. Note: If the preconditioner is a subsidiary preconditioner then only the sub-vectors 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 n-th 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 n-th 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 Meshmesh_pt (const unsigned &i) const
 Access to i-th 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 LinearAlgebraDistributionblock_distribution_pt (const unsigned &b) const
 Access function to the block distributions (const version). More...
 
LinearAlgebraDistributionblock_distribution_pt (const unsigned b)
 Access function to the block distributions (non-const version). More...
 
LinearAlgebraDistributiondof_block_distribution_pt (const unsigned &b)
 Access function to the dof-level block distributions. More...
 
const LinearAlgebraDistributionmaster_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 upper-most 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< MATRIX > * 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 dof-level 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 dof-level 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/her-self 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 n-th 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 n-th 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 i-th 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 sub-vectors 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 i-th 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 sub-vectors 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, MATRIX &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 dof-block 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 LinearAlgebraDistributioninternal_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 MATRIX *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...
 
template<typename myType >
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...
 
template<>
void internal_get_block (const unsigned &block_i, const unsigned &block_j, CRDoubleMatrix &output_block) const
 
template<>
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 &)
 Broken copy constructor. More...
 
void operator= (const Preconditioner &)
 Broken assignment operator. More...
 
virtual ~Preconditioner ()
 Destructor (empty) More...
 
virtual void preconditioner_solve (const DoubleVector &r, DoubleVector &z)=0
 Apply the preconditioner. Pure virtual generic interface function. This method should apply the preconditioner operator to the vector r and return the vector z. 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 setup ()=0
 Setup the preconditioner. Pure virtual generic interface function. 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 OomphCommunicatorcomm_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)
 Broken copy constructor. More...
 
void operator= (const DistributableLinearAlgebraObject &)
 Broken assignment operator. More...
 
virtual ~DistributableLinearAlgebraObject ()
 Destructor. More...
 
LinearAlgebraDistributiondistribution_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...
 

Protected Member Functions

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 i-th 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 dof-level blocks. Only dof-level 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 stand-alone 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 LinearAlgebraDistributioninternal_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 LinearAlgebraDistributionpreconditioner_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

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
 Mapping for block types to dof types. These are the dof types the writer of the preconditioner expects. For the upper-most 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 top-most 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 stand-alone 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 stand-alone block preconditioner, in the latter case it stores the number of dofs within the subsidiary preconditioner. More...
 

Private Attributes

bool Recursive_debug_flag
 Debugging variable. Set true or false via the access functions turn_on_recursive_debug_flag(...) turn_off_recursive_debug_flag(...) These will turn on/off the debug flag up the hierarchy. More...
 
bool Debug_flag
 Debugging variable. Set true or false via the access functions turn_on_debug_flag(...) turn_off_debug_flag(...) More...
 
std::map< Vector< unsigned >
, LinearAlgebraDistribution * > 
Auxiliary_block_distribution_pt
 Stores any block-level distributions / concatenation of block-level distributions required. The first in the pair (Vector<unsigned>) represents the block numbers of the distributions concatenated to get the second in the pair (LinearAlgebraDistribution*). More...
 
unsigned Nrow
 Number of DOFs (# of rows or columns in the matrix) in this preconditioner. Note that this information is maintained if used as a subsidiary or stand-alone block preconditioner, in the latter case it stores the number of rows within the subsidiary preconditioner. More...
 
BlockPreconditioner< MATRIX > * Master_block_preconditioner_pt
 If the block preconditioner is acting a subsidiary block preconditioner then a pointer to the master preconditioner is stored here. If the preconditioner does not have a master block preconditioner then this pointer remains null. More...
 
Vector< unsigned > Doftype_in_master_preconditioner_fine
 The map between the dof types in this preconditioner and the master preconditioner. If there is no master preconditioner it remains empty. This list contains the mapping for the underlying dof types. More...
 
Vector< unsigned > Doftype_in_master_preconditioner_coarse
 The map between the dof types in this preconditioner and the master preconditioner. If there is no master preconditioner, it remains empty. This is the version for which the master preconditioner expects. The dof types in here may or may not be coarsened in the preconditioner above this one. More...
 
Vector< unsigned > Index_in_dof_block_dense
 This was uncommented Presumably a non-distributed analogue of Index_in_dof_block_sparse. More...
 
Vector< unsigned > Dof_number_dense
 Vector to store the mapping from the global DOF number to its block. Empty if this preconditioner has a master preconditioner, in this case the information is obtained from the master preconditioner. More...
 
Vector< unsigned > Global_index_sparse
 For global indices outside of the range this->first_row() to this->first_row()+this->nrow_local(), the Index_in_dof_block and Dof_number are stored sparsely in the vectors: More...
 
Vector< unsigned > Index_in_dof_block_sparse
 Vector to store the mapping from the global DOF number to the index (row/column number) within its block (empty if this preconditioner has a master preconditioner as this information is obtained from the master preconditioner). Sparse version: for global indices outside of the range this->first_row() to this->first_row()+this->nrow_local(). The global index of an element in this vector is defined in Global_index_sparse. More...
 
Vector< unsigned > Dof_number_sparse
 Vector to store the mapping from the global DOF number to its block (empty if this preconditioner has a master preconditioner as this information is obtained from the master preconditioner). Sparse version: for global indices outside of the range this->first_row() to this->first_row()+this->nrow_local(). The global index of an element in this vector is defined in Global_index_sparse. More...
 
Vector< unsigned > Dof_dimension
 Vector containing the size of each block, i.e. the number of global DOFs associated with it. (Empty if this preconditioner has a master preconditioner as this information is obtain from the master preconditioner.) More...
 
Vector< Vector< unsigned > > Global_index
 Vectors of vectors for the mapping from block number and block row to global row number. Empty if this preconditioner has a master preconditioner as this information is obtain from the master preconditioner. More...
 
Vector< Vector< unsigned > > Block_number_to_dof_number_lookup
 Vector of vectors to store the mapping from block number to the DOF number (each element could be a vector because we allow multiple DOFs types in a single block). More...
 
Vector< unsigned > Dof_number_to_block_number_lookup
 Vector to the mapping from DOF number to block number. More...
 
Vector< unsigned > Ndof_in_block
 Number of types of degree of freedom associated with each block. More...
 
DenseMatrix< int * > Rows_to_send_for_get_block
 The global rows to be sent of block b to processor p (matrix indexed [b][p]). More...
 
DenseMatrix< unsigned > Nrows_to_send_for_get_block
 The number of global rows to be sent of block b to processor p (matrix indexed [b][p]). More...
 
DenseMatrix< int * > Rows_to_recv_for_get_block
 The block rows to be received from processor p for block b (matrix indexed [b][p]). More...
 
DenseMatrix< unsigned > Nrows_to_recv_for_get_block
 The number of block rows to be received from processor p for block b (matrix indexed [b][p]). More...
 
Vector< int * > Rows_to_send_for_get_ordered
 The global rows to be sent to processor p for get_block_ordered_... type methods. More...
 
Vector< unsigned > Nrows_to_send_for_get_ordered
 The number global rows to be sent to processor p for get_block_ordered_... type methods. More...
 
Vector< int * > Rows_to_recv_for_get_ordered
 The preconditioner rows to be received from processor p for get_block_ordered_... type methods. More...
 
Vector< unsigned > Nrows_to_recv_for_get_ordered
 The number of preconditioner rows to be received from processor p for get_block_ordered_... type methods. More...
 
LinearAlgebraDistributionInternal_preconditioner_matrix_distribution_pt
 The distribution of the (internal) preconditioner matrix. This is formed by concatenating the distribution of the internal blocks. This is obsolete code, maintained for backwards compatibility. Below is the old comment: More...
 
LinearAlgebraDistributionPreconditioner_matrix_distribution_pt
 The distribution of the preconditioner matrix. This is the concatenation of the block distribution. More...
 
std::string Output_base_filename
 String giving the base of the files to write block data into. If empty then do not output blocks. Default is empty. More...
 

Static Private Attributes

static bool Run_block_matrix_test =false
 Static boolean to allow block_matrix_test(...) to be run. Defaults to false. More...
 

Detailed Description

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

Block Preconditioner base class. The block structure of the overall problem is determined from the Mesh's constituent elements. Each constituent element must be block-preconditionable - i.e must implement the GeneralisedElements functions ndof_types() and get_dof_numbers_for_unknowns(...). A Problem can have several Meshes, but each Mesh must contain elements with the same DOF types. The association between global degrees of freedom and their unique local dof numbers is therefore based on information provided by the elements. We refer to the local dof numbers provided by the elements as the elemental dof numbers.

By default each type of DOF is assumed to be unique type of block, but DOF types can be grouped together in a single block when block_setup(...) is called.

This class can function in one of two ways. Either it acts as a stand-alone block preconditioner which computes and stores the association between global degrees of freedom and their unique global block numbers itself. Alternatively, the block preconditioner can act as a subsidiary block preconditioner within a (larger) master block preconditioner (pointed to by Master_block_preconditioner_pt). The master block preconditioner must have an equal or greater number of block types. Examples are the FSI preconditioner which is the 3x3 "master block preconditioner" for the Navier-Stokes preconditioners which deals with the 2x2 fluid-blocks within the overall structure. In this case, only the master block preconditioner computes and stores the master lookup schemes. All block preconditioners compute and store their own optimised lookup schemes.

In cases where a Problem contains elements of different element types (e.g. fluid and solid elements in a fluid-structure interaction problem), access to the elements of the same type must be provided via pointers to (possibly auxiliary) Meshes that only contain elements of a single type. The block preconditioner will then create global block numbers by concatenating the block types. Consider, e.g. a fluid-structure interaction problem in which the first Mesh contains (fluid) elements whose degrees of freedom have been subdivided into types "0" (the velocity, say) and "1" (the pressure say), while the second Mesh contains (solid) elements whose degrees of freedom are the nodal displacements, classified as its type "0". The combined block preconditioner then has three "block types": "0": Fluid velocity, "1": Fluid pressure, "2": Solid nodal positions. NOTE: currently this preconditioner uses the same communicator as the underlying problem. We may need to change this in the future.

Definition at line 422 of file block_preconditioner.h.

Constructor & Destructor Documentation

template<typename MATRIX>
oomph::BlockPreconditioner< MATRIX >::BlockPreconditioner ( )
inline

Constructor.

Definition at line 427 of file block_preconditioner.h.

template<typename MATRIX>
virtual oomph::BlockPreconditioner< MATRIX >::~BlockPreconditioner ( )
inlinevirtual

Destructor.

Definition at line 509 of file block_preconditioner.h.

template<typename MATRIX>
oomph::BlockPreconditioner< MATRIX >::BlockPreconditioner ( const BlockPreconditioner< MATRIX > &  )
inline

Broken copy constructor.

Definition at line 515 of file block_preconditioner.h.

Member Function Documentation

template<typename MATRIX>
bool oomph::BlockPreconditioner< MATRIX >::any_mesh_distributed ( ) const
inlineprotected

Check if any of the meshes are distributed. This is equivalent to problem.distributed() and is used as a replacement.

Definition at line 3064 of file block_preconditioner.h.

template<typename MATRIX>
const LinearAlgebraDistribution* oomph::BlockPreconditioner< MATRIX >::block_distribution_pt ( const unsigned &  b) const
inline

Access function to the block distributions (const version).

Definition at line 1922 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::get_concatenated_block().

template<typename MATRIX>
LinearAlgebraDistribution* oomph::BlockPreconditioner< MATRIX >::block_distribution_pt ( const unsigned  b)
inline

Access function to the block distributions (non-const version).

Definition at line 1953 of file block_preconditioner.h.

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::block_matrix_test ( const unsigned &  i,
const unsigned &  j,
const MATRIX *  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.

test function to check that every element in the block matrix (block_i,block_j) matches the corresponding element in the original matrix

Definition at line 5753 of file block_preconditioner.cc.

References i, and oomph::DistributableLinearAlgebraObject::nrow().

template<typename MATRIX>
int oomph::BlockPreconditioner< MATRIX >::block_number ( const unsigned &  i_dof) const
inline

Return the block number corresponding to a global index i_dof.

Definition at line 1841 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::index_in_block().

template<typename MATRIX>
bool oomph::BlockPreconditioner< MATRIX >::block_output_on ( ) const
inline

Test if output of blocks is on or not.

Definition at line 2113 of file block_preconditioner.h.

template<typename MATRIX >
void oomph::BlockPreconditioner< MATRIX >::block_setup ( )
virtual

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 dof-to-block 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...

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 each DOF type corresponds to a unique block type.

Definition at line 2437 of file block_preconditioner.cc.

References i.

Referenced by oomph::GeneralPurposeBlockPreconditioner< MATRIX >::gp_preconditioner_block_setup(), oomph::DummyBlockPreconditioner< MATRIX >::setup(), oomph::HelmholtzGMRESMG< MATRIX >::solve(), and oomph::HelmholtzFGMRESMG< MATRIX >::solve().

template<typename MATRIX >
void oomph::BlockPreconditioner< MATRIX >::block_setup ( const Vector< unsigned > &  dof_to_block_map_in)

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 dof-to-block 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:

dof_to_block_map[dof_number] = block_number.

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 any block contains more than one type of DOF. The argument vector dof_to_block_map should be of length ndof. Each element should contain an integer indicating the block number corresponding to that type of DOF.

Definition at line 56 of file block_preconditioner.cc.

References oomph::LinearAlgebraDistribution::clear(), oomph::CRDoubleMatrix::column_index(), oomph::LinearAlgebraDistributionHelpers::concatenate(), e, oomph::LinearAlgebraDistribution::first_row(), i, oomph::Vector< _Tp >::initialise(), oomph::Data::Is_unclassified, oomph::CRDoubleMatrix::nnz(), oomph::LinearAlgebraDistribution::nrow_local(), and oomph::Global_string_for_annotation::string().

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::clear_block_preconditioner_base ( )
inline

Clears all BlockPreconditioner data. Called by the destructor and the block_setup(...) methods.

Definition at line 2183 of file block_preconditioner.h.

Referenced by oomph::GeneralPurposeBlockPreconditioner< MATRIX >::clean_up_memory(), and oomph::BlockPreconditioner< CRDoubleMatrix >::~BlockPreconditioner().

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::disable_block_output_to_files ( )
inline

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

Definition at line 2107 of file block_preconditioner.h.

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::document ( )
inline

debugging method to document the setup. Should only be called after block_setup(...).

Definition at line 2295 of file block_preconditioner.h.

template<typename MATRIX>
LinearAlgebraDistribution* oomph::BlockPreconditioner< MATRIX >::dof_block_distribution_pt ( const unsigned &  b)
inline

Access function to the dof-level block distributions.

Definition at line 1984 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::set_replacement_dof_block().

template<typename MATRIX>
Vector<Vector<unsigned> > oomph::BlockPreconditioner< MATRIX >::doftype_coarsen_map_fine ( ) const
inline

Access function for the Doftype_coarsen_map_fine variable.

Definition at line 2358 of file block_preconditioner.h.

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::get_block ( const unsigned &  i,
const unsigned &  j,
MATRIX &  output_matrix,
const bool &  ignore_replacement_block = false 
) const
inline
template<typename MATRIX>
MATRIX oomph::BlockPreconditioner< MATRIX >::get_block ( const unsigned &  i,
const unsigned &  j,
const bool &  ignore_replacement_block = false 
) const
inline

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.

Definition at line 998 of file block_preconditioner.h.

template<typename MATRIX >
void oomph::BlockPreconditioner< MATRIX >::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.

This function has been re-written to work with the new dof type coarsening feature. The old function is kept alive in internal_get_block_ordered_preconditioner_vector(...) and is moved to the private section of the code. The differences between the two are:

1) This function extracts all the block vectors (in one go) via the function internal_get_block_vectors(...), and concatenates them.

2) The old function makes use of the variables ending in "get_ordered", thus is slightly more efficient since it does not have to concatenate any block vectors.

3) The old function no longer respect the new indirections if dof types have been coarsened.

4) This function extracts the most fine grain dof-level vectors and concatenates them. These dof-level vectors respect the re-ordering caused by the coarsening of dof types. The overhead associated with concatenating DoubleVectors without communication is very small.

This function should be used.

Definition at line 4736 of file block_preconditioner.cc.

References oomph::DoubleVector::built(), and oomph::DistributableLinearAlgebraObject::distribution_pt().

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::get_block_other_matrix ( const unsigned &  i,
const unsigned &  j,
MATRIX *  in_matrix_pt,
MATRIX &  output_matrix 
)
inline

Get a block from a different matrix using the blocking scheme that has already been set up.

Definition at line 1022 of file block_preconditioner.h.

template<typename MATRIX >
void oomph::BlockPreconditioner< MATRIX >::get_block_vector ( const unsigned &  n,
const DoubleVector v,
DoubleVector b 
) const

Takes the naturally ordered vector, v and returns the n-th block vector, b. Here n is the block number in the current preconditioner.

Definition at line 4136 of file block_preconditioner.cc.

References oomph::DoubleVector::build(), oomph::DoubleVector::built(), oomph::DoubleVectorHelpers::concatenate_without_communication(), and oomph::DistributableLinearAlgebraObject::distribution_pt().

template<typename MATRIX >
void oomph::BlockPreconditioner< MATRIX >::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 i-th entry in the vector associated with block b. Note: If the preconditioner is a subsidiary preconditioner then only the sub-vectors 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.

Definition at line 2917 of file block_preconditioner.cc.

References oomph::DoubleVector::built(), oomph::DoubleVectorHelpers::concatenate_without_communication(), oomph::DistributableLinearAlgebraObject::distribution_pt(), and i.

Referenced by oomph::HelmholtzGMRESMG< MATRIX >::update().

template<typename MATRIX >
void oomph::BlockPreconditioner< MATRIX >::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 i-th entry in the vector associated with block b. Note: If the preconditioner is a subsidiary preconditioner then only the sub-vectors 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].

Definition at line 3085 of file block_preconditioner.cc.

References i.

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::get_blocks ( DenseMatrix< bool > &  required_blocks,
DenseMatrix< MATRIX * > &  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 sub-block 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 sub-block has not been requested and is therefore not available.

WARNING: the matrix pointers are created using new so you must delete them all manually!

WARNING 2: the matrix pointers in block_matrix_pt MUST be null because Richard in all his wisdom decided to call delete on any non-null pointers. Presumably to avoid fixing his memory leaks properly...

Get the block matrices required for the block preconditioner. Takes a pointer to a matrix of bools that indicate if a specified sub-block 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 that sub-block has not been requested and is therefore not available.

Definition at line 2495 of file block_preconditioner.cc.

References i, oomph::DenseMatrix< T >::ncol(), and oomph::DenseMatrix< T >::nrow().

template<typename MATRIX>
MATRIX oomph::BlockPreconditioner< MATRIX >::get_concatenated_block ( const VectorMatrix< BlockSelector > &  selected_block)
inline

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.

For each entry in the VectorMatrix, the following variables must correctly set: BlockSelector::Row_index - Refers to the row index of the block. BlockSelector::Column_index - Refers to the column index of the block. BlockSelector::Wanted - Do we want the block? BlockSelector::Replacement_block_pt - If not null, this block will be used instead of get_block(Row_index,Column_index).

For example, assume that we have a matrix of the following blocking: 0 1 2 3 4 | a | b | c | d | e | –|—|—|—|—|—|

0 a
1 b
2 c
3 d
4 e

If we want a block matrix corresponding to the concatenation of the blocks [(a,d), (a,e) , (b,e)* ] where top left and top right blocks comes from the function get_block(...), the bottom left entry is empty, and the bottom right is a modified block.

Then we create a VectorMatrix of size 2 by 2 VectorMatrix<BlockSelector> selected_block(2,2);

In the [0][0] entry: row index is 0, column index is 3, do we want this block? - yes (true). selected_block[0][0].select_block(0,3,true);

In the [0][1] entry: row index is 0, column index is 4, do we want this block? - yes (true). selected_block[0][0].select_block(0,4,true);

In the [1][0] entry: row index is 1, column index is 3, do we want this block? - no (false). selected_block[0][0].select_block(1,3,false);

In the [1][1] entry: row index is 1, column index is 4, do we want this block? - yes (true). selected_block[0][0].select_block(1,4,true,block_pt);

where block_pt is a pointer to the modified block.

Then we can call:

CRDoubleMatrix my_block = get_concatenated_block(selected_block);

NOTE: It is important to set the row and column indices even if you do not want the block. This is because, if we allow the row and column indices to be "not set", then we can have a whole empty block row without any indices. But concatenation of blocks without communication requires both the row and column distributions, so we know how to permute the rows and columns. So in short, we require that the column and row indices to always be set for every entry in the VectorMatrix<BlockSelector> object for convenience and consistency checks.

Definition at line 1140 of file block_preconditioner.h.

template<typename MATRIX >
void oomph::BlockPreconditioner< MATRIX >::get_concatenated_block_vector ( const Vector< unsigned > &  block_vec_number,
const DoubleVector v,
DoubleVector w 
)

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 non-const function because distributions may be created and stored in Auxiliary_block_distribution_pt for future use.

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 non-const function because distributions may be created and stored in Auxiliary_block_distribution_pt for future use.

Definition at line 2569 of file block_preconditioner.cc.

References oomph::DoubleVector::build(), oomph::DoubleVector::built(), oomph::LinearAlgebraDistributionHelpers::concatenate(), oomph::DoubleVectorHelpers::concatenate_without_communication(), oomph::DistributableLinearAlgebraObject::distribution_pt(), and i.

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::get_dof_level_block ( const unsigned &  i,
const unsigned &  j,
MATRIX &  output_block,
const bool &  ignore_replacement_block = false 
) const

Gets dof-level block (i,j). If Replacement_dof_block_pt(i,j) is not null, then the replacement block is returned via a deep copy.

Otherwise if this is the uppermost block preconditioner then it calls internal_get_block(i,j), else if it is a subsidiary block preconditioner, it will call it's master block preconditioners' get_dof_level_block function.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::get_block().

template<>
void oomph::BlockPreconditioner< CRDoubleMatrix >::get_dof_level_block ( const unsigned &  block_i,
const unsigned &  block_j,
CRDoubleMatrix output_block,
const bool &  ignore_replacement_block 
) const

Otherwise if this is the uppermost block preconditioner then it calls internal_get_block(i,j), else if it is a subsidiary block preconditioner, it will call it's master block preconditioners' get_dof_level_block function.

Definition at line 5593 of file block_preconditioner.cc.

References oomph::DoubleVectorHelpers::concatenate_without_communication(), and oomph::CRDoubleMatrixHelpers::deep_copy().

template<typename MATRIX>
Vector<unsigned> oomph::BlockPreconditioner< MATRIX >::get_fine_grain_dof_types_in ( const unsigned &  i) const
inline

Returns the most fine grain dof types in a (possibly coarsened) dof type.

Definition at line 2365 of file block_preconditioner.h.

template<typename MATRIX>
template<typename myType >
int oomph::BlockPreconditioner< MATRIX >::get_index_of_value ( const Vector< myType > &  vec,
const myType  val,
const bool  sorted = false 
) const
inline

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.

Definition at line 2856 of file block_preconditioner.h.

template<typename MATRIX>
int oomph::BlockPreconditioner< MATRIX >::index_in_block ( const unsigned &  i_dof) const
inline

Given a global dof number, returns the index in the block it belongs to. This is the overall index, not local block (in parallel).

Definition at line 1869 of file block_preconditioner.h.

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::insert_auxiliary_block_distribution ( const Vector< unsigned > &  block_vec_number,
LinearAlgebraDistribution dist_pt 
)
inline

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.

Definition at line 2794 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::get_concatenated_block(), and oomph::BlockPreconditioner< CRDoubleMatrix >::setup_matrix_vector_product().

template<typename MATRIX>
unsigned oomph::BlockPreconditioner< MATRIX >::internal_block_dimension ( const unsigned &  b) const
inlineprotected

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.

Definition at line 3201 of file block_preconditioner.h.

template<typename MATRIX>
const LinearAlgebraDistribution* oomph::BlockPreconditioner< MATRIX >::internal_block_distribution_pt ( const unsigned &  b) const
inline

Access function to the internal block distributions.

Definition at line 2759 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::index_in_block().

template<typename MATRIX>
int oomph::BlockPreconditioner< MATRIX >::internal_block_number ( const unsigned &  i_dof) const
inline

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

Definition at line 2711 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::block_number(), and oomph::BlockPreconditioner< CRDoubleMatrix >::internal_index_in_block().

template<typename MATRIX>
unsigned oomph::BlockPreconditioner< MATRIX >::internal_dof_block_dimension ( const unsigned &  i) const
inlineprotected

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.

Definition at line 3224 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::internal_index_in_block().

template<typename MATRIX>
int oomph::BlockPreconditioner< MATRIX >::internal_dof_number ( const unsigned &  i_dof) const
inlineprotected

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.

Definition at line 3081 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::index_in_block(), oomph::BlockPreconditioner< CRDoubleMatrix >::internal_block_number(), and oomph::BlockPreconditioner< CRDoubleMatrix >::internal_index_in_block().

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::internal_get_block ( const unsigned &  i,
const unsigned &  j,
MATRIX &  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.

template<>
void oomph::BlockPreconditioner< CRDoubleMatrix >::internal_get_block ( const unsigned &  block_i,
const unsigned &  block_j,
CRDoubleMatrix output_block 
) const
template<typename MATRIX >
void oomph::BlockPreconditioner< MATRIX >::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.

This uses the variables ending in "get_ordered". We no longer use this type of method. This function copy values from v and re-order them in "block order" and place them in w. Block order means that the values in w are the same as the concatenated block vectors.

I.e. - v is naturally ordered. v -> s_b, v is ordered into blocks vectors (requires communication) concatenate_without_communication(s_{0,...,nblocks},w) gives w.

But this function skips out the concatenation part and builds w directly from v.

This is nice but the function is implemented in such a way that it always use all the (internal) blocks and concatenated with the identity ordering. I.e. if this preconditioner has 3 block types, then w will always be: concatenate_without_communication([s_0, s_1, s_2], w). There is easy way to change this.

Furthermore, it does not take into account the new dof type coarsening feature. So this function will most likely produce the incorrect vector w from what the user intended. It still works, but w will be the concatenation of the most fine grain dof block vectors with the "natural" dof type ordering.

This has been superseded by the function get_block_ordered_preconditioner_vector(...) which does the correct thing.

Definition at line 4549 of file block_preconditioner.cc.

References oomph::DoubleVector::build(), oomph::DoubleVector::built(), oomph::DistributableLinearAlgebraObject::distribution_pt(), i, and oomph::DoubleVector::values_pt().

template<typename MATRIX >
void oomph::BlockPreconditioner< MATRIX >::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 n-th 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(...).

Definition at line 3966 of file block_preconditioner.cc.

References oomph::DoubleVector::build(), oomph::DoubleVector::built(), oomph::DistributableLinearAlgebraObject::distribution_pt(), i, oomph::DistributableLinearAlgebraObject::nrow(), and oomph::DoubleVector::values_pt().

template<typename MATRIX >
void oomph::BlockPreconditioner< MATRIX >::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 i-th 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 sub-vectors 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.

Takes the naturally ordered vector and rearranges it into a vector of sub vectors corresponding to the blocks, so s[b][i] contains the i-th 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.

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

Definition at line 3113 of file block_preconditioner.cc.

References oomph::DoubleVector::built(), oomph::DistributableLinearAlgebraObject::distribution_pt(), i, and oomph::DoubleVector::values_pt().

template<typename MATRIX >
void oomph::BlockPreconditioner< MATRIX >::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 i-th 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 sub-vectors 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.

Definition at line 3385 of file block_preconditioner.cc.

template<typename MATRIX>
int oomph::BlockPreconditioner< MATRIX >::internal_index_in_block ( const unsigned &  i_dof) const
inline

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.

Definition at line 2727 of file block_preconditioner.h.

template<typename MATRIX>
unsigned oomph::BlockPreconditioner< MATRIX >::internal_index_in_dof ( const unsigned &  i_dof) const
inlineprotected

Return the row/column number of global unknown i_dof within it's block.

Definition at line 3148 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::index_in_block(), and oomph::BlockPreconditioner< CRDoubleMatrix >::internal_index_in_block().

template<typename MATRIX>
unsigned oomph::BlockPreconditioner< MATRIX >::internal_master_dof_number ( const unsigned &  b) const
inlineprotected

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.

Definition at line 3275 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::document(), and oomph::BlockPreconditioner< CRDoubleMatrix >::internal_dof_block_dimension().

template<typename MATRIX>
unsigned oomph::BlockPreconditioner< MATRIX >::internal_nblock_types ( ) const
inline

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

The preconditioner writer should not have to deal with internal dof/block types and thus this function has been moved to private.

This is legacy code from before the coarsening dof type functionality was added. This is kept alive because it is still used in the internal workings of the block preconditioning framework.

The function nblock_types(...) should be used if the number of block types is required.

Definition at line 2548 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::document(), oomph::BlockPreconditioner< CRDoubleMatrix >::internal_block_dimension(), oomph::BlockPreconditioner< CRDoubleMatrix >::internal_block_distribution_pt(), and oomph::BlockPreconditioner< CRDoubleMatrix >::output_blocks_to_files().

template<typename MATRIX>
unsigned oomph::BlockPreconditioner< MATRIX >::internal_ndof_types ( ) const
inline

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/her-self 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.

Definition at line 2590 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::document(), oomph::BlockPreconditioner< CRDoubleMatrix >::internal_dof_block_dimension(), oomph::BlockPreconditioner< CRDoubleMatrix >::internal_dof_number(), oomph::BlockPreconditioner< CRDoubleMatrix >::internal_nblock_types(), and oomph::BlockPreconditioner< CRDoubleMatrix >::ndof_types().

template<typename MATRIX>
const LinearAlgebraDistribution* oomph::BlockPreconditioner< MATRIX >::internal_preconditioner_matrix_distribution_pt ( ) const
inlineprotected

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

Definition at line 3290 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::document().

template<typename MATRIX >
void oomph::BlockPreconditioner< MATRIX >::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().

This is the return function for the function internal_get_block_ordered_preconditioner_vector(...). Both internal_get_block_ordered_preconditioner_vector(...) and internal_return_block_ordered_preconditioner_vector(...) has been superseded by the functions

get_block_ordered_preconditioner_vector(...) and return_block_ordered_preconditioner_vector(...),

Thus this function is moved to the private section of the code.

Definition at line 4794 of file block_preconditioner.cc.

References oomph::DoubleVector::built(), oomph::DistributableLinearAlgebraObject::distribution_pt(), i, and oomph::DoubleVector::values_pt().

template<typename MATRIX >
void oomph::BlockPreconditioner< MATRIX >::internal_return_block_vector ( const unsigned &  b,
const DoubleVector w,
DoubleVector v 
) const

Takes the n-th 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.

This version works with the internal block types. This is legacy code but is kept alive, hence moved to private. Please use the function "return_block_vector(...)".

Definition at line 4245 of file block_preconditioner.cc.

References oomph::DoubleVector::built(), oomph::DistributableLinearAlgebraObject::distribution_pt(), i, and oomph::DoubleVector::values_pt().

template<typename MATRIX >
void oomph::BlockPreconditioner< MATRIX >::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.

Takes the naturally ordered vector and rearranges it into a vector of sub vectors corresponding to the blocks, so s[b][i] contains the i-th 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 sub-vectors 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.

Definition at line 3659 of file block_preconditioner.cc.

References oomph::DoubleVector::built(), oomph::DistributableLinearAlgebraObject::distribution_pt(), i, and oomph::DoubleVector::values_pt().

template<typename MATRIX >
void oomph::BlockPreconditioner< MATRIX >::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.

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 i-th 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 sub-vectors 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.

Definition at line 3944 of file block_preconditioner.cc.

template<typename MATRIX>
bool oomph::BlockPreconditioner< MATRIX >::is_master_block_preconditioner ( ) const
inline
template<typename MATRIX>
bool oomph::BlockPreconditioner< MATRIX >::is_subsidiary_block_preconditioner ( ) const
inline
template<typename MATRIX>
BlockPreconditioner<MATRIX>* oomph::BlockPreconditioner< MATRIX >::master_block_preconditioner_pt ( ) const
inline
template<typename MATRIX>
const LinearAlgebraDistribution* oomph::BlockPreconditioner< MATRIX >::master_distribution_pt ( ) const
inline

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.

Definition at line 2042 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::document().

template<typename MATRIX>
unsigned oomph::BlockPreconditioner< MATRIX >::master_nrow ( ) const
inlineprotected

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 stand-alone block preconditioner but is required to avoid ambiguities. The latter is stored (and maintained) separately for each specific block preconditioner regardless of its role.

Definition at line 3259 of file block_preconditioner.h.

template<typename MATRIX>
MATRIX* oomph::BlockPreconditioner< MATRIX >::matrix_pt ( ) const
inlinevirtual

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.

Reimplemented from oomph::Preconditioner.

Definition at line 529 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::get_block_other_matrix(), oomph::HelmholtzGMRESMG< MATRIX >::resolve(), oomph::HelmholtzGMRESMG< MATRIX >::solve(), and oomph::HelmholtzFGMRESMG< MATRIX >::solve().

template<typename MATRIX>
const Mesh* oomph::BlockPreconditioner< MATRIX >::mesh_pt ( const unsigned &  i) const
inline

Access to i-th mesh (of the various meshes that contain block preconditionable elements of the same number of dof type).

WARNING: This should only be used if the derived class is the upper-most 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)

Definition at line 1799 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::any_mesh_distributed(), oomph::BlockPreconditioner< CRDoubleMatrix >::ndof_types_in_mesh(), oomph::BlockPreconditioner< CRDoubleMatrix >::set_mesh(), oomph::SimpleFSIPreconditioner< MATRIX >::set_navier_stokes_mesh(), and oomph::SimpleFSIPreconditioner< MATRIX >::set_wall_mesh().

template<typename MATRIX>
unsigned oomph::BlockPreconditioner< MATRIX >::nblock_types ( ) const
inline
template<typename MATRIX>
unsigned oomph::BlockPreconditioner< MATRIX >::ndof_types ( ) const
inline
template<typename MATRIX>
unsigned oomph::BlockPreconditioner< MATRIX >::ndof_types_in_mesh ( const unsigned &  i) const
inline

Return the number of DOF types in mesh i. WARNING: This should only be used by the upper-most 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)

Definition at line 2062 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::internal_ndof_types().

template<typename MATRIX>
unsigned oomph::BlockPreconditioner< MATRIX >::nfine_grain_dof_types_in ( const unsigned &  i) const
inline

Access function for the number of most fine grain dof types in a (possibly coarsened) dof type.

Definition at line 2386 of file block_preconditioner.h.

template<typename MATRIX>
unsigned oomph::BlockPreconditioner< MATRIX >::nmesh ( ) const
inline

Return the number of meshes in Mesh_pt.

WARNING: This should only be used if the derived class is the upper-most master block preconditioner. All block preconditioners) should store local copies of "their meshes" (if they're needed for anything)

Definition at line 1835 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::any_mesh_distributed(), oomph::GeneralPurposeBlockPreconditioner< MATRIX >::gp_preconditioner_set_all_meshes(), oomph::BlockPreconditioner< CRDoubleMatrix >::internal_ndof_types(), oomph::BlockPreconditioner< CRDoubleMatrix >::ndof_types(), and oomph::BlockPreconditioner< CRDoubleMatrix >::set_mesh().

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::operator= ( const BlockPreconditioner< MATRIX > &  )
inline

Broken assignment operator.

Definition at line 521 of file block_preconditioner.h.

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::output_blocks_to_files ( const std::string &  basefilename,
const unsigned &  precision = 8 
) const
inline

Output all blocks to numbered files. Called at the end of get blocks if an output filename has been set.

Definition at line 2120 of file block_preconditioner.h.

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::post_block_matrix_assembly_partial_clear ( )
inline

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.

Definition at line 2145 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::clear_block_preconditioner_base().

template<typename MATRIX>
const LinearAlgebraDistribution* oomph::BlockPreconditioner< MATRIX >::preconditioner_matrix_distribution_pt ( ) const
inlineprotected

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

Definition at line 3305 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::document().

template<typename MATRIX>
MapMatrix<unsigned,CRDoubleMatrix*> oomph::BlockPreconditioner< MATRIX >::replacement_dof_block_pt ( ) const
inline

Access function to the replaced dof-level blocks.

Definition at line 2407 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::set_replacement_dof_block().

template<typename MATRIX >
void oomph::BlockPreconditioner< MATRIX >::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().

This is the return function for the function get_block_ordered_preconditioner_vector(...).

It calls the function return_concatenated_block_vector(...) with the identity block number ordering.

Definition at line 4981 of file block_preconditioner.cc.

References oomph::DoubleVector::built(), and oomph::DistributableLinearAlgebraObject::distribution_pt().

template<typename MATRIX >
void oomph::BlockPreconditioner< MATRIX >::return_block_vector ( const unsigned &  n,
const DoubleVector b,
DoubleVector v 
) const

Takes the n-th 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.

Definition at line 4436 of file block_preconditioner.cc.

References oomph::DoubleVector::built(), oomph::DistributableLinearAlgebraObject::distribution_pt(), and oomph::DoubleVectorHelpers::split_without_communication().

template<typename MATRIX >
void oomph::BlockPreconditioner< MATRIX >::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.

Definition at line 3408 of file block_preconditioner.cc.

References oomph::DoubleVector::built(), oomph::DistributableLinearAlgebraObject::distribution_pt(), and oomph::DoubleVectorHelpers::split_without_communication().

Referenced by oomph::HelmholtzGMRESMG< MATRIX >::update().

template<typename MATRIX >
void oomph::BlockPreconditioner< MATRIX >::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].

Definition at line 3631 of file block_preconditioner.cc.

References i.

template<typename MATRIX >
void oomph::BlockPreconditioner< MATRIX >::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.

Takes concatenated block ordered vector, b, and copies its.

Definition at line 2742 of file block_preconditioner.cc.

References oomph::DoubleVector::built(), oomph::LinearAlgebraDistributionHelpers::concatenate(), oomph::DistributableLinearAlgebraObject::distribution_pt(), and oomph::DoubleVectorHelpers::split_without_communication().

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::set_block_output_to_files ( const std::string &  basefilename)
inline

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.

Definition at line 2101 of file block_preconditioner.h.

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::set_master_matrix_pt ( MATRIX *  in_matrix_pt)
inline

Set the matrix_pt in the upper-most master preconditioner.

Definition at line 1007 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::get_block_other_matrix().

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::set_mesh ( const unsigned &  i,
const Mesh *const  mesh_pt,
const bool &  allow_multiple_element_type_in_mesh = false 
)
inlineprotected

Set the i-th 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.

Definition at line 2897 of file block_preconditioner.h.

Referenced by oomph::GeneralPurposeBlockPreconditioner< MATRIX >::gp_preconditioner_set_all_meshes(), oomph::HelmholtzGMRESMG< MATRIX >::solve(), and oomph::HelmholtzFGMRESMG< MATRIX >::solve().

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::set_nmesh ( const unsigned &  n)
inlineprotected

Specify the number of meshes required by this block preconditioner. Note: elements in different meshes correspond to different types of DOF.

Definition at line 2882 of file block_preconditioner.h.

Referenced by oomph::GeneralPurposeBlockPreconditioner< MATRIX >::gp_preconditioner_set_all_meshes(), oomph::SimpleFSIPreconditioner< MATRIX >::SimpleFSIPreconditioner(), oomph::HelmholtzGMRESMG< MATRIX >::solve(), and oomph::HelmholtzFGMRESMG< MATRIX >::solve().

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::set_replacement_dof_block ( const unsigned &  block_i,
const unsigned &  block_j,
CRDoubleMatrix replacement_dof_block_pt 
)
inlineprotected

Set replacement dof-level blocks. Only dof-level blocks can be set. This is important due to how the dof type coarsening feature operates.

IMPORTANT: The block indices (block_i, block_j) is the dof-level ordering, NOT the block-ordering. The block-ordering is determined by the parameters given to block_setup(...). The DOF-ordering is determined by the two-level ordering scheme of first the elements, then the meshes.

Definition at line 2944 of file block_preconditioner.h.

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::setup_matrix_vector_product ( MatrixVectorProduct matvec_prod_pt,
CRDoubleMatrix block_pt,
const Vector< unsigned > &  block_col_indices 
)
inline

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.

The distribution of the block column must be the same as the RHS vector being solved. By default, OOMPH-LIB's uniform row distribution is employed. When block matrices are concatenated without communication, the columns are permuted, as a result, the distribution of the columns may no longer be uniform.

Definition at line 2423 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::setup_matrix_vector_product().

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::setup_matrix_vector_product ( MatrixVectorProduct matvec_prod_pt,
CRDoubleMatrix block_pt,
const unsigned &  block_col_index 
)
inline

Setup matrix vector product. This is simply a wrapper around the other setup_matrix_vector_product function.

Definition at line 2464 of file block_preconditioner.h.

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::turn_into_subsidiary_block_preconditioner ( BlockPreconditioner< MATRIX > *  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 Navier-Stokes 2x2 block preconditioner dealing with the fluid sub-blocks 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.

Function to turn this preconditioner into a subsidiary preconditioner that operates within a bigger "master block preconditioner (e.g. a Navier-Stokes 2x2 block preconditioner dealing with the fluid sub-blocks within a 3x3 FSI preconditioner. Once this is done the master block preconditioner deals with the block setup etc. The vector block_map must specify the dof number in the master preconditioner that corresponds to a block number in this preconditioner. ??ds horribly misleading comment! The length of the vector is used to determine the number of blocks in this preconditioner therefore it must be correctly sized. This calls the other turn_into_subsidiary_block_preconditioner(...) function providing an empty doftype_to_doftype_map vector.

This calls the other turn_into_subsidiary_block_preconditioner function with the identity mapping for doftype_coarsen_map_coarse vector.

Definition at line 2330 of file block_preconditioner.cc.

Referenced by oomph::PseudoElasticFSIPreconditioner::setup(), oomph::PseudoElasticPreconditioner::setup(), oomph::LagrangeEnforcedFlowPreconditioner::setup(), and oomph::PseudoElasticPreconditionerOld::setup().

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::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 
)

Function to turn this preconditioner into a subsidiary preconditioner that operates within a bigger "master block preconditioner (e.g. a Navier-Stokes 2x2 block preconditioner dealing with the fluid sub-blocks 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.

Function to turn this block preconditioner into a subsidiary block preconditioner that operates within a bigger master block preconditioner (e.g. a Navier-Stokes 2x2 block preconditioner dealing with the fluid sub-blocks within a 3x3 FSI preconditioner. Once this is done the master block preconditioner deals with the block setup etc.

The doftype_coarsen_map_coarse is a mapping of the dof numbers in the master preconditioner to the dof numbers REQUIRED by THIS preconditioner. This allows for coarsening of the dof types if the master preconditioner has a more fine grain dof type splitting.

For example, the Lagrangian preconditioner (in 3D with one constraint) has doftypes: 0 1 2 3 4 5 6 7 ub vb wb uc vc wc p Lc

We wish to use an existing Navier-Stokes preconditioner, for example, LSC, to solve the sub-system associated with the dof numbers 0, 1, 2, 3, 4, 5, 6. But the existing LSC preconditioner only works with four dof types (3 velocity dof types and 1 pressure dof types). We need to coarsen the number of dof types in the master preconditioner.

If the LSC preconditioner requires the dof ordering: u, v, w, p. Then the doftype_coarsen_map_coarse will be: [0 3] -> u velocity dof type [1 4] -> v velocity dof type [2 5] -> w velocity dof type [6] -> pressure dof type.

The vector doftype_map must specify the dof type in the master preconditioner that corresponds to a dof type in this block preconditioner.

In general, we want: doftype_map[doftype in subsidiary prec] = doftype in master prec.

It tells this block preconditioner which dof types of the master block preconditioner it is working with.

The length of the vector is used to determine the number of dof types in THIS block preconditioner therefore it must be correctly sized.

For example, let the master block preconditioner have 5 dof types in total and a 1-4 dof type splitting where the block (0,0) corresponds to dof type 0 and the block (1,1) corresponds to dof types 1, 2, 3 and 4 (i.e. it would have given to block_setup the vector [0,1,1,1,1]). Furthermore, it solves (1,1) block with subsidiary block preconditioner. Then the doftype_map passed to this function of the subsidiary block preconditioner would be [1, 2, 3, 4].

Dof type coarsening (following on from the example above): Let the subsidiary block preconditioner (THIS block preconditioner) only works with two DOF types, then the master block preconditioner must "coarsen" the dof types by providing the optional argument doftype_coarsen_map vector.

The doftype_coarsen_map vector (in this case) might be [[0,1], [2,3]] telling the subsidiary block preconditioner that the SUBSIDIARY dof types 0 and 1 should be treated as dof type 0 and the subsidiary dof types 2 and 3 should be treated as subsidiary dof type 1.

If no doftype_coarsen_map vector is provided, then the identity is used automatically (see the turn_into_subsidiary_block_preconditioner(...) function with only two arguments). In the above case, the identity doftype_coarsen_map vector for the subsidiary block preconditioner would be the 2D vector [[0], [1], [2], [3]] which means dof type 0 is treated as dof type 0, dof type 1 is treated as dof type 1, dof type 2 is treated as dof type 2, and dof type 3 is treated as dof type 3.

Definition at line 2408 of file block_preconditioner.cc.

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::turn_off_debug_flag ( )
inline

Toggles off the debug flag.

Definition at line 580 of file block_preconditioner.h.

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::turn_off_recursive_debug_flag ( )
inline

Toggles off the recursive debug flag. The change goes up the block preconditioning hierarchy.

Definition at line 565 of file block_preconditioner.h.

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::turn_on_debug_flag ( )
inline

Toggles on the debug flag.

Definition at line 574 of file block_preconditioner.h.

template<typename MATRIX>
void oomph::BlockPreconditioner< MATRIX >::turn_on_recursive_debug_flag ( )
inline

Toggles on the recursive debug flag. The change goes up the block preconditioning hierarchy.

Definition at line 555 of file block_preconditioner.h.

Member Data Documentation

template<typename MATRIX>
Vector<unsigned> oomph::BlockPreconditioner< MATRIX >::Allow_multiple_element_type_in_mesh
protected

Vector of unsigned to indicate which meshes contain multiple element types.

Definition at line 3382 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::set_mesh(), and oomph::BlockPreconditioner< CRDoubleMatrix >::set_nmesh().

template<typename MATRIX>
std::map<Vector<unsigned>,LinearAlgebraDistribution*> oomph::BlockPreconditioner< MATRIX >::Auxiliary_block_distribution_pt
private

Stores any block-level distributions / concatenation of block-level distributions required. The first in the pair (Vector<unsigned>) represents the block numbers of the distributions concatenated to get the second in the pair (LinearAlgebraDistribution*).

Definition at line 3425 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::clear_block_preconditioner_base(), oomph::BlockPreconditioner< CRDoubleMatrix >::get_concatenated_block(), oomph::BlockPreconditioner< CRDoubleMatrix >::insert_auxiliary_block_distribution(), and oomph::BlockPreconditioner< CRDoubleMatrix >::setup_matrix_vector_product().

template<typename MATRIX>
Vector<LinearAlgebraDistribution*> oomph::BlockPreconditioner< MATRIX >::Block_distribution_pt
protected
template<typename MATRIX>
Vector<Vector<unsigned> > oomph::BlockPreconditioner< MATRIX >::Block_number_to_dof_number_lookup
private

Vector of vectors to store the mapping from block number to the DOF number (each element could be a vector because we allow multiple DOFs types in a single block).

Definition at line 3506 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::document(), oomph::BlockPreconditioner< CRDoubleMatrix >::internal_index_in_block(), and oomph::BlockPreconditioner< CRDoubleMatrix >::post_block_matrix_assembly_partial_clear().

template<typename MATRIX>
Vector<Vector<unsigned> > oomph::BlockPreconditioner< MATRIX >::Block_to_dof_map_coarse
protected

Mapping for block types to dof types. These are the dof types the writer of the preconditioner expects. For the upper-most 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(...).

Definition at line 3322 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::BlockPreconditioner(), oomph::BlockPreconditioner< CRDoubleMatrix >::get_block(), and oomph::BlockPreconditioner< CRDoubleMatrix >::nblock_types().

template<typename MATRIX>
Vector<Vector<unsigned> > oomph::BlockPreconditioner< MATRIX >::Block_to_dof_map_fine
protected
template<typename MATRIX>
bool oomph::BlockPreconditioner< MATRIX >::Debug_flag
private

Debugging variable. Set true or false via the access functions turn_on_debug_flag(...) turn_off_debug_flag(...)

Definition at line 3418 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::BlockPreconditioner(), oomph::BlockPreconditioner< CRDoubleMatrix >::turn_off_debug_flag(), and oomph::BlockPreconditioner< CRDoubleMatrix >::turn_on_debug_flag().

template<typename MATRIX>
Vector<LinearAlgebraDistribution*> oomph::BlockPreconditioner< MATRIX >::Dof_block_distribution_pt
protected
template<typename MATRIX>
Vector<unsigned> oomph::BlockPreconditioner< MATRIX >::Dof_dimension
private

Vector containing the size of each block, i.e. the number of global DOFs associated with it. (Empty if this preconditioner has a master preconditioner as this information is obtain from the master preconditioner.)

Definition at line 3495 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::internal_dof_block_dimension(), and oomph::BlockPreconditioner< CRDoubleMatrix >::post_block_matrix_assembly_partial_clear().

template<typename MATRIX>
Vector<unsigned> oomph::BlockPreconditioner< MATRIX >::Dof_number_dense
private

Vector to store the mapping from the global DOF number to its block. Empty if this preconditioner has a master preconditioner, in this case the information is obtained from the master preconditioner.

Definition at line 3458 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::internal_dof_number(), and oomph::BlockPreconditioner< CRDoubleMatrix >::post_block_matrix_assembly_partial_clear().

template<typename MATRIX>
Vector<unsigned> oomph::BlockPreconditioner< MATRIX >::Dof_number_sparse
private

Vector to store the mapping from the global DOF number to its block (empty if this preconditioner has a master preconditioner as this information is obtained from the master preconditioner). Sparse version: for global indices outside of the range this->first_row() to this->first_row()+this->nrow_local(). The global index of an element in this vector is defined in Global_index_sparse.

Definition at line 3488 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::internal_dof_number(), and oomph::BlockPreconditioner< CRDoubleMatrix >::post_block_matrix_assembly_partial_clear().

template<typename MATRIX>
Vector<unsigned> oomph::BlockPreconditioner< MATRIX >::Dof_number_to_block_number_lookup
private
template<typename MATRIX>
Vector<Vector<unsigned> > oomph::BlockPreconditioner< MATRIX >::Doftype_coarsen_map_coarse
protected

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.

Furthermore, the dof types are that the preconditioner above this one knows; these dof types may or may not be coarsened. For example, say that this preconditioner expects two dof types, 0 and 1. The preconditioner above this one wishes to use this preconditioner to solve the block associated with it's dof types 2, 3 and 4. It passes the Vector [2,3,4] to this preconditioner via the function turn_into_subsidiary_block_preconditioner(...), this list is to be stored in Doftype_in_master_preconditioner_coarse. It also passes in the 2D vector [[0][1,2]] (as described above), this list is to be stored in Doftype_coarsen_map_coarse. BUT, the master's preconditioner dof types may also be coarsened. I.e. the underlying dof types of the master block preconditioner may be [0,1,2,3,4,5,6,7], for which it may have the Doftype_coarsen_map_coarse = [[0,1][2,3][4,5][6,7]].

An additional list has to be kept for the most fine grain dof type mapping. This is stored in Doftype_coarsen_map_fine, in this case it would be:

Doftype_coarsen_map_fine = [[0,1][2,3,4,5]], since the dof types passed to this preconditioner is [2, 3, 4] from the master preconditioner, but it actually refers to the underlying dof types [2,3,4,5,6,7].

In the case of the top most master block preconditioner, the block_setup(...) function fills the vector with the identity mapping.

Definition at line 3363 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::ndof_types().

template<typename MATRIX>
Vector<Vector<unsigned> > oomph::BlockPreconditioner< MATRIX >::Doftype_coarsen_map_fine
protected

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 top-most preconditioner) or the turn_into_subsidiary_block_preconditioner(...) function. Please refer to the comment above Doftype_coarsen_map_coarse for more details.

Definition at line 3371 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::doftype_coarsen_map_fine(), oomph::BlockPreconditioner< CRDoubleMatrix >::get_fine_grain_dof_types_in(), and oomph::BlockPreconditioner< CRDoubleMatrix >::nfine_grain_dof_types_in().

template<typename MATRIX>
Vector<unsigned> oomph::BlockPreconditioner< MATRIX >::Doftype_in_master_preconditioner_coarse
private

The map between the dof types in this preconditioner and the master preconditioner. If there is no master preconditioner, it remains empty. This is the version for which the master preconditioner expects. The dof types in here may or may not be coarsened in the preconditioner above this one.

Definition at line 3449 of file block_preconditioner.h.

template<typename MATRIX>
Vector<unsigned> oomph::BlockPreconditioner< MATRIX >::Doftype_in_master_preconditioner_fine
private

The map between the dof types in this preconditioner and the master preconditioner. If there is no master preconditioner it remains empty. This list contains the mapping for the underlying dof types.

Definition at line 3442 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::internal_dof_number(), and oomph::BlockPreconditioner< CRDoubleMatrix >::internal_master_dof_number().

template<typename MATRIX>
Vector<Vector<unsigned> > oomph::BlockPreconditioner< MATRIX >::Global_index
private

Vectors of vectors for the mapping from block number and block row to global row number. Empty if this preconditioner has a master preconditioner as this information is obtain from the master preconditioner.

Definition at line 3501 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::clear_block_preconditioner_base().

template<typename MATRIX>
Vector<unsigned> oomph::BlockPreconditioner< MATRIX >::Global_index_sparse
private

For global indices outside of the range this->first_row() to this->first_row()+this->nrow_local(), the Index_in_dof_block and Dof_number are stored sparsely in the vectors:

  • Index_in_dof_block_sparse;
  • Dof_number_sparse; The corresponding global indices are stored in this vector.

Definition at line 3471 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::internal_dof_number(), oomph::BlockPreconditioner< CRDoubleMatrix >::internal_index_in_dof(), and oomph::BlockPreconditioner< CRDoubleMatrix >::post_block_matrix_assembly_partial_clear().

template<typename MATRIX>
Vector<unsigned> oomph::BlockPreconditioner< MATRIX >::Index_in_dof_block_dense
private

This was uncommented Presumably a non-distributed analogue of Index_in_dof_block_sparse.

Definition at line 3453 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::internal_index_in_dof(), and oomph::BlockPreconditioner< CRDoubleMatrix >::post_block_matrix_assembly_partial_clear().

template<typename MATRIX>
Vector<unsigned> oomph::BlockPreconditioner< MATRIX >::Index_in_dof_block_sparse
private

Vector to store the mapping from the global DOF number to the index (row/column number) within its block (empty if this preconditioner has a master preconditioner as this information is obtained from the master preconditioner). Sparse version: for global indices outside of the range this->first_row() to this->first_row()+this->nrow_local(). The global index of an element in this vector is defined in Global_index_sparse.

Definition at line 3480 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::internal_index_in_dof(), and oomph::BlockPreconditioner< CRDoubleMatrix >::post_block_matrix_assembly_partial_clear().

template<typename MATRIX>
Vector<LinearAlgebraDistribution*> oomph::BlockPreconditioner< MATRIX >::Internal_block_distribution_pt
protected
template<typename MATRIX>
unsigned oomph::BlockPreconditioner< MATRIX >::Internal_nblock_types
protected

Number of different block types in this preconditioner. Note that this information is maintained if used as a subsidiary or stand-alone block preconditioner, in the latter case it stores the number of blocks within the subsidiary preconditioner.

Definition at line 3399 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::BlockPreconditioner(), oomph::BlockPreconditioner< CRDoubleMatrix >::clear_block_preconditioner_base(), oomph::BlockPreconditioner< CRDoubleMatrix >::document(), and oomph::BlockPreconditioner< CRDoubleMatrix >::internal_nblock_types().

template<typename MATRIX>
unsigned oomph::BlockPreconditioner< MATRIX >::Internal_ndof_types
protected

Number of different DOF types in this preconditioner. Note that this information is maintained if used as a subsidiary or stand-alone block preconditioner, in the latter case it stores the number of dofs within the subsidiary preconditioner.

Definition at line 3405 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::BlockPreconditioner(), oomph::BlockPreconditioner< CRDoubleMatrix >::clear_block_preconditioner_base(), oomph::BlockPreconditioner< CRDoubleMatrix >::document(), and oomph::BlockPreconditioner< CRDoubleMatrix >::internal_ndof_types().

template<typename MATRIX>
LinearAlgebraDistribution* oomph::BlockPreconditioner< MATRIX >::Internal_preconditioner_matrix_distribution_pt
private

The distribution of the (internal) preconditioner matrix. This is formed by concatenating the distribution of the internal blocks. This is obsolete code, maintained for backwards compatibility. Below is the old comment:

Definition at line 3558 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::BlockPreconditioner(), oomph::BlockPreconditioner< CRDoubleMatrix >::clear_block_preconditioner_base(), and oomph::BlockPreconditioner< CRDoubleMatrix >::internal_preconditioner_matrix_distribution_pt().

template<typename MATRIX>
BlockPreconditioner<MATRIX>* oomph::BlockPreconditioner< MATRIX >::Master_block_preconditioner_pt
private
template<typename MATRIX>
Vector<const Mesh*> oomph::BlockPreconditioner< MATRIX >::Mesh_pt
protected

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.

Definition at line 3389 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::mesh_pt(), oomph::BlockPreconditioner< CRDoubleMatrix >::ndof_types(), oomph::BlockPreconditioner< CRDoubleMatrix >::nmesh(), oomph::BlockPreconditioner< CRDoubleMatrix >::set_mesh(), and oomph::BlockPreconditioner< CRDoubleMatrix >::set_nmesh().

template<typename MATRIX>
Vector<unsigned> oomph::BlockPreconditioner< MATRIX >::Ndof_in_block
private

Number of types of degree of freedom associated with each block.

Definition at line 3512 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::post_block_matrix_assembly_partial_clear().

template<typename MATRIX>
Vector<unsigned> oomph::BlockPreconditioner< MATRIX >::Ndof_types_in_mesh
protected

Storage for number of types of degree of freedom of the elements in each mesh.

Definition at line 3393 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::ndof_types_in_mesh().

template<typename MATRIX>
unsigned oomph::BlockPreconditioner< MATRIX >::Nrow
private

Number of DOFs (# of rows or columns in the matrix) in this preconditioner. Note that this information is maintained if used as a subsidiary or stand-alone block preconditioner, in the latter case it stores the number of rows within the subsidiary preconditioner.

Definition at line 3431 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::BlockPreconditioner(), oomph::BlockPreconditioner< CRDoubleMatrix >::clear_block_preconditioner_base(), and oomph::BlockPreconditioner< CRDoubleMatrix >::master_nrow().

template<typename MATRIX>
DenseMatrix<unsigned> oomph::BlockPreconditioner< MATRIX >::Nrows_to_recv_for_get_block
private

The number of block rows to be received from processor p for block b (matrix indexed [b][p]).

Definition at line 3531 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::clear_block_preconditioner_base().

template<typename MATRIX>
Vector<unsigned> oomph::BlockPreconditioner< MATRIX >::Nrows_to_recv_for_get_ordered
private

The number of preconditioner rows to be received from processor p for get_block_ordered_... type methods.

Definition at line 3547 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::clear_block_preconditioner_base().

template<typename MATRIX>
DenseMatrix<unsigned> oomph::BlockPreconditioner< MATRIX >::Nrows_to_send_for_get_block
private

The number of global rows to be sent of block b to processor p (matrix indexed [b][p]).

Definition at line 3523 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::clear_block_preconditioner_base().

template<typename MATRIX>
Vector<unsigned> oomph::BlockPreconditioner< MATRIX >::Nrows_to_send_for_get_ordered
private

The number global rows to be sent to processor p for get_block_ordered_... type methods.

Definition at line 3539 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::clear_block_preconditioner_base().

template<typename MATRIX>
std::string oomph::BlockPreconditioner< MATRIX >::Output_base_filename
private

String giving the base of the files to write block data into. If empty then do not output blocks. Default is empty.

Definition at line 3570 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::block_output_on(), oomph::BlockPreconditioner< CRDoubleMatrix >::disable_block_output_to_files(), and oomph::BlockPreconditioner< CRDoubleMatrix >::set_block_output_to_files().

template<typename MATRIX>
LinearAlgebraDistribution* oomph::BlockPreconditioner< MATRIX >::Preconditioner_matrix_distribution_pt
private
template<typename MATRIX>
bool oomph::BlockPreconditioner< MATRIX >::Recursive_debug_flag
private

Debugging variable. Set true or false via the access functions turn_on_recursive_debug_flag(...) turn_off_recursive_debug_flag(...) These will turn on/off the debug flag up the hierarchy.

Definition at line 3413 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::BlockPreconditioner(), oomph::BlockPreconditioner< CRDoubleMatrix >::turn_off_recursive_debug_flag(), and oomph::BlockPreconditioner< CRDoubleMatrix >::turn_on_recursive_debug_flag().

template<typename MATRIX>
MapMatrix<unsigned,CRDoubleMatrix*> oomph::BlockPreconditioner< MATRIX >::Replacement_dof_block_pt
protected
template<typename MATRIX>
DenseMatrix<int*> oomph::BlockPreconditioner< MATRIX >::Rows_to_recv_for_get_block
private

The block rows to be received from processor p for block b (matrix indexed [b][p]).

Definition at line 3527 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::clear_block_preconditioner_base().

template<typename MATRIX>
Vector<int*> oomph::BlockPreconditioner< MATRIX >::Rows_to_recv_for_get_ordered
private

The preconditioner rows to be received from processor p for get_block_ordered_... type methods.

Definition at line 3543 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::clear_block_preconditioner_base().

template<typename MATRIX>
DenseMatrix<int*> oomph::BlockPreconditioner< MATRIX >::Rows_to_send_for_get_block
private

The global rows to be sent of block b to processor p (matrix indexed [b][p]).

Definition at line 3519 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::clear_block_preconditioner_base().

template<typename MATRIX>
Vector<int*> oomph::BlockPreconditioner< MATRIX >::Rows_to_send_for_get_ordered
private

The global rows to be sent to processor p for get_block_ordered_... type methods.

Definition at line 3535 of file block_preconditioner.h.

Referenced by oomph::BlockPreconditioner< CRDoubleMatrix >::clear_block_preconditioner_base().

template<typename MATRIX>
bool oomph::BlockPreconditioner< MATRIX >::Run_block_matrix_test =false
staticprivate

Static boolean to allow block_matrix_test(...) to be run. Defaults to false.

Definition at line 3566 of file block_preconditioner.h.


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