Public Types | Public Member Functions | Private Attributes | List of all members
oomph::LagrangeEnforcedFlowPreconditioner Class Reference

The preconditioner for the Lagrange multiplier constrained Navier-Stokes equations. The velocity components are constrained by Lagrange multiplier, which are applied via OOMPH-LIB's FACE elements. More...

#include <lagrange_enforced_flow_preconditioner.h>

+ Inheritance diagram for oomph::LagrangeEnforcedFlowPreconditioner:

Public Types

typedef Preconditioner *(* SubsidiaryPreconditionerFctPt) ()
 This preconditioner includes the option to use subsidiary operators other than SuperLUPreconditioner for this problem. This is the typedef of a function that should return an instance of a subsidiary preconditioning operator. This preconditioner is responsible for the destruction of the subsidiary preconditioners. More...
 

Public Member Functions

 LagrangeEnforcedFlowPreconditioner ()
 Constructor - initialise variables. More...
 
virtual ~LagrangeEnforcedFlowPreconditioner ()
 Destructor. More...
 
 LagrangeEnforcedFlowPreconditioner (const LagrangeEnforcedFlowPreconditioner &)=delete
 Broken copy constructor. More...
 
void operator= (const LagrangeEnforcedFlowPreconditioner &)=delete
 Broken assignment operator. More...
 
void setup ()
 Setup method for the LagrangeEnforcedFlowPreconditioner. More...
 
void preconditioner_solve (const DoubleVector &r, DoubleVector &z)
 Apply the preconditioner. r is the residual (rhs), z will contain the solution. More...
 
void set_meshes (const Vector< Mesh * > &mesh_pt)
 Set the meshes, the first mesh in the vector must be the bulk mesh. More...
 
void use_norm_f_for_scaling_sigma ()
 Set flag to use the infinite norm of the Navier-Stokes F matrix as the scaling sigma. This is the default behaviour. Note: the norm of the NS F matrix positive, however, we actually use the negative of the norm. This is because the underlying Navier-Stokes Jacobian is multiplied by -1. Ask Andrew/Matthias for more detail. More...
 
void set_scaling_sigma (const double &scaling_sigma)
 Access function to set the scaling sigma. Note: this also sets the flag to use the infinite norm of the Navier-Stokes F matrix as the scaling sigma to false. Warning is given if trying to set scaling sigma to be equal to or greater than zero. More...
 
double scaling_sigma () const
 Read (const) function to get the scaling sigma. More...
 
void set_navier_stokes_preconditioner (Preconditioner *new_ns_preconditioner_pt=0)
 Set a new Navier-Stokes matrix preconditioner (inexact solver) More...
 
void set_superlu_for_navier_stokes_preconditioner ()
 Set Navier-Stokes matrix preconditioner (inexact solver) to SuperLU. More...
 
void clean_up_memory ()
 Clears the memory. More...
 
- Public Member Functions inherited from oomph::BlockPreconditioner< CRDoubleMatrix >
 BlockPreconditioner ()
 Constructor. More...
 
 BlockPreconditioner (const BlockPreconditioner &)=delete
 Broken copy constructor. More...
 
virtual ~BlockPreconditioner ()
 Destructor. More...
 
void operator= (const BlockPreconditioner &)=delete
 Broken assignment operator. More...
 
CRDoubleMatrixmatrix_pt () const
 Access function to matrix_pt. If this is the master then cast the matrix pointer to MATRIX*, error check and return. Otherwise ask the master for its matrix pointer. More...
 
void turn_on_recursive_debug_flag ()
 Toggles on the recursive debug flag. The change goes up the block preconditioning hierarchy. More...
 
void turn_off_recursive_debug_flag ()
 Toggles off the recursive debug flag. The change goes up the block preconditioning hierarchy. More...
 
void turn_on_debug_flag ()
 Toggles on the debug flag. More...
 
void turn_off_debug_flag ()
 Toggles off the debug flag. More...
 
void turn_into_subsidiary_block_preconditioner (BlockPreconditioner< CRDoubleMatrix > *master_block_prec_pt, const Vector< unsigned > &doftype_in_master_preconditioner_coarse)
 Function to turn this preconditioner into a subsidiary preconditioner that operates within a bigger "master block preconditioner (e.g. a 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< CRDoubleMatrix > *master_block_prec_pt, const Vector< unsigned > &doftype_in_master_preconditioner_coarse, const Vector< Vector< unsigned >> &doftype_coarsen_map_coarse)
 Function to turn this preconditioner into a subsidiary preconditioner that operates within a bigger "master block preconditioner (e.g. a 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, CRDoubleMatrix &output_matrix, const bool &ignore_replacement_block=false) const
 Put block (i,j) into output_matrix. This block accounts for any coarsening of dof types and any replaced dof-level blocks above this preconditioner. More...
 
CRDoubleMatrix get_block (const unsigned &i, const unsigned &j, const bool &ignore_replacement_block=false) const
 Return block (i,j). If the optional argument ignore_replacement_block is true, then any blocks in Replacement_dof_block_pt will be ignored throughout the preconditioning hierarchy. More...
 
void set_master_matrix_pt (CRDoubleMatrix *in_matrix_pt)
 Set the matrix_pt in the upper-most master preconditioner. More...
 
void get_block_other_matrix (const unsigned &i, const unsigned &j, CRDoubleMatrix *in_matrix_pt, CRDoubleMatrix &output_matrix)
 Get a block from a different matrix using the blocking scheme that has already been set up. More...
 
void get_blocks (DenseMatrix< bool > &required_blocks, DenseMatrix< CRDoubleMatrix * > &block_matrix_pt) const
 Get all the block matrices required by the block preconditioner. Takes a pointer to a matrix of bools that indicate if a specified 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, CRDoubleMatrix &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...
 
void get_dof_level_block (const unsigned &block_i, const unsigned &block_j, CRDoubleMatrix &output_block, const bool &ignore_replacement_block) 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...
 
CRDoubleMatrix get_concatenated_block (const VectorMatrix< BlockSelector > &selected_block)
 Returns a concatenation of the block matrices specified by the argument selected_block. The VectorMatrix selected_block must be correctly sized as it is used to determine the number of sub block matrices to concatenate. More...
 
void get_concatenated_block_vector (const Vector< unsigned > &block_vec_number, const DoubleVector &v, DoubleVector &b)
 Takes the naturally ordered vector and extracts the blocks indicated by the block number (the values) in the Vector block_vec_number all at once, then concatenates them without communication. Here, the values in block_vec_number is the block number in the current preconditioner. This is a 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
 Output all blocks to numbered files. Called at the end of get blocks if an output filename has been set. More...
 
void post_block_matrix_assembly_partial_clear ()
 A helper method to reduce the memory requirements of block preconditioners. Once the methods get_block(...), get_blocks(...) and build_preconditioner_matrix(...) have been called in this and all subsidiary block preconditioners this method can be called to clean up. More...
 
BlockPreconditioner< CRDoubleMatrix > * master_block_preconditioner_pt () const
 Access function to the master block preconditioner pt. More...
 
void clear_block_preconditioner_base ()
 Clears all BlockPreconditioner data. Called by the destructor and the block_setup(...) methods. More...
 
void document ()
 debugging method to document the setup. Should only be called after block_setup(...). More...
 
Vector< Vector< unsigned > > doftype_coarsen_map_fine () const
 Access function for the Doftype_coarsen_map_fine variable. More...
 
Vector< unsigned > get_fine_grain_dof_types_in (const unsigned &i) const
 Returns the most fine grain dof types in a (possibly coarsened) dof type. More...
 
unsigned nfine_grain_dof_types_in (const unsigned &i) const
 Access function for the number of most fine grain dof types in a (possibly coarsened) dof type. More...
 
MapMatrix< unsigned, CRDoubleMatrix * > replacement_dof_block_pt () const
 Access function to the replaced 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, CRDoubleMatrix &output_block) const
 Gets block (i,j) from the matrix pointed to by Matrix_pt and returns it in output_block. This is associated with the internal blocks. Please use the other get_block(...) function. More...
 
void internal_get_block (const unsigned &block_i, const unsigned &block_j, CRDoubleMatrix &output_block) const
 Gets block (i,j) from the matrix pointed to by Matrix_pt and returns it in output_block. This is associated with the internal blocks. Please use the other get_block(...) function. More...
 
int internal_block_number (const unsigned &i_dof) const
 Return the block number corresponding to a global index i_dof. This returns the block number corresponding to the internal blocks. What this means is that this returns the most fine grain 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 CRDoubleMatrix *block_matrix_pt) const
 Private helper function to check that every element in the block matrix (i,j) matches the corresponding element in the original matrix. More...
 
int get_index_of_value (const Vector< myType > &vec, const myType val, const bool sorted=false) const
 Get the index of first occurrence of value in a vector. If the element does not exist, -1 is returned. The optional parameter indicates of the Vector is sorted or not. Complexity: if the Vector is sorted, then on average, logarithmic in the distance between first and last: Performs approximately log2(N)+2 element comparisons. Otherwise, up to linear in the distance between first and last: Compares elements until a match is found. More...
 
- Public Member Functions inherited from oomph::Preconditioner
 Preconditioner ()
 Constructor. More...
 
 Preconditioner (const Preconditioner &)=delete
 Broken copy constructor. More...
 
void operator= (const Preconditioner &)=delete
 Broken assignment operator. More...
 
virtual ~Preconditioner ()
 Destructor (empty) More...
 
virtual void preconditioner_solve_transpose (const DoubleVector &r, DoubleVector &z)
 Apply the preconditioner. Pure virtual generic interface function. This method should apply the preconditioner operator to the vector r and return the vector z. (broken virtual) 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...
 
void enable_silent_preconditioner_setup ()
 Set up the block preconditioner quietly! More...
 
void disable_silent_preconditioner_setup ()
 Be verbose in the block preconditioner setup. More...
 
virtual void set_matrix_pt (DoubleMatrixBase *matrix_pt)
 Set the matrix pointer. More...
 
virtual const 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 interface function for making a preconditioner a subsidiary of a block preconditioner. By default nothing is needed, but if this preconditioner is also a block preconditioner then things need to happen. There's an assumption here that the block preconditioner will be in CR form but since that assumption is hard coded all over BlockPreconditioner we're safe. More...
 
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)
 Virtual interface function for making a preconditioner a subsidiary of a block preconditioner. By default nothing is needed, but if this preconditioner is also a block preconditioner then things need to happen. Version for coarsening dof-types. More...
 
- Public Member Functions inherited from oomph::DistributableLinearAlgebraObject
 DistributableLinearAlgebraObject ()
 Default constructor - create a distribution. More...
 
 DistributableLinearAlgebraObject (const DistributableLinearAlgebraObject &matrix)=delete
 Broken copy constructor. More...
 
void operator= (const DistributableLinearAlgebraObject &)=delete
 Broken assignment operator. More...
 
virtual ~DistributableLinearAlgebraObject ()
 Destructor. More...
 
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
 if the communicator_pt is null then the distribution is not setup then false is returned, otherwise return true More...
 
void build_distribution (const LinearAlgebraDistribution *const dist_pt)
 setup the distribution of this distributable linear algebra object More...
 
void build_distribution (const LinearAlgebraDistribution &dist)
 setup the distribution of this distributable linear algebra object More...
 

Private Attributes

bool Preconditioner_has_been_setup
 Control flag is true if the preconditioner has been setup (used so we can wipe the data when the preconditioner is called again) More...
 
double Scaling_sigma
 Scaling for the augmentation: Scaling_sigma*(LL^T) More...
 
bool Use_norm_f_for_scaling_sigma
 Flag to indicate if we want to use the infinite norm of the Navier-Stokes momentum block for the scaling sigma. More...
 
Vector< Vector< double > > Inv_w_diag_values
 Inverse W values. More...
 
PreconditionerNavier_stokes_preconditioner_pt
 Pointer to the 'preconditioner' for the Navier-Stokes block. More...
 
bool Navier_stokes_preconditioner_is_block_preconditioner
 Flag to indicate if the preconditioner for the Navier-Stokes block is a block preconditioner or not. More...
 
bool Using_superlu_ns_preconditioner
 Flag to indicate whether the default NS preconditioner is used. More...
 
Vector< Mesh * > My_mesh_pt
 Storage for the meshes. In our implementation, the first mesh must always be the Navier-Stokes (bulk) mesh, followed by surface meshes. More...
 
Vector< unsigned > My_ndof_types_in_mesh
 The number of DOF types in each mesh. This is used create various lookup lists. More...
 
unsigned My_nmesh
 The number of meshes. This is used to create various lookup lists. More...
 
unsigned N_lagrange_doftypes
 The number of Lagrange multiplier DOF types. More...
 
unsigned N_fluid_doftypes
 The number of fluid DOF types (including pressure). More...
 
unsigned N_velocity_doftypes
 The number of velocity DOF types. More...
 

Additional Inherited Members

- Protected Member Functions inherited from oomph::BlockPreconditioner< CRDoubleMatrix >
void set_nmesh (const unsigned &n)
 Specify the number of meshes required by this block preconditioner. Note: elements in different meshes correspond to different types of DOF. More...
 
void set_mesh (const unsigned &i, const Mesh *const mesh_pt, const bool &allow_multiple_element_type_in_mesh=false)
 Set the 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 inherited from oomph::BlockPreconditioner< CRDoubleMatrix >
MapMatrix< unsigned, CRDoubleMatrix * > Replacement_dof_block_pt
 The replacement dof-level blocks. More...
 
Vector< LinearAlgebraDistribution * > Block_distribution_pt
 The distribution for the blocks. More...
 
Vector< Vector< unsigned > > Block_to_dof_map_coarse
 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...
 
- Protected Attributes inherited from oomph::Preconditioner
bool Silent_preconditioner_setup
 Boolean to indicate whether or not the build should be done silently. More...
 
std::ostream * Stream_pt
 Pointer to the output stream – defaults to std::cout. More...
 

Detailed Description

The preconditioner for the Lagrange multiplier constrained Navier-Stokes equations. The velocity components are constrained by Lagrange multiplier, which are applied via OOMPH-LIB's FACE elements.

The linearised Jacobian takes the block form:

| F_ns | L^T | |---------—| | L | 0 |

where L correspond to the constrained block, F_ns is the Navier-Stokes block with the following block structure

| F | G^T | |-------—| | D | 0 |

Here F is the momentum block, G the discrete gradient operator, and D the discrete divergence operator. For unstabilised elements, we have D = G^T and in much of the literature the divergence matrix is denoted by B.

The Lagrange enforced flow preconditioner takes the form:

F_aug
Wd

where F_aug = F_ns + L^T*inv(Wd)*L is an augmented Navier-Stokes block and Wd=(1/Scaling_sigma)*diag(LL^T).

In our implementation of the preconditioner, the linear systems associated with the (1,1) block can either be solved "exactly", using SuperLU (in its incarnation as an exact preconditioner; this is the default) or by any other Preconditioner (inexact solver) specified via the access functions

LagrangeEnforcedFlowPreconditioner::set_navier_stokes_preconditioner(...)

Access to the elements is provided via meshes. However, a Vector of meshes is taken, each mesh contains a different type of block preconditionable element. This allows the (re-)classification of the constrained velocity DOF types.

The first mesh in the Vector Mesh_pt must be the 'bulk' mesh. The rest are assumed to contain FACEELMENTS.

Thus, the most general block structure (in 3D) is:

0 1 2 3 4 5 6 7 8 ..x x+0 x+1 x+2 x+3 x+4 [u v w p] [u v w l1 l2 ...] [u v w l1 l2 ...] ... Bulk Surface 1 Surface 2 ...

where the DOF types in [] are the DOF types associated with each mesh.

For example, consider a unit cube domain [0,1]^3 with parallel outflow imposed (in mesh 0) and tangential flow imposed (in mesh 1), then there are 13 DOF types and our implementation respects the following (natural) DOF type order:

bulk mesh 0 mesh 1 [0 1 2 3] [4 5 6 7 8 ] [9 10 11 12 ] [u v w p] [up vp wp Lp1 Lp2] [ut vt wt Lt1]

Via the appropriate mapping, the block_setup(...) function will re-order the DOF types into the following block types:

0 1 2 3 4 5 6 7 8 9 10 11 12 <- Block type 0 4 9 1 5 10 2 6 11 3 7 8 12 <- DOF type [u up ut v vp vt w wp wt ] [p] [Lp1 Lp2 Lt1]

Definition at line 166 of file lagrange_enforced_flow_preconditioner.h.

Member Typedef Documentation

◆ SubsidiaryPreconditionerFctPt

typedef Preconditioner*(* oomph::LagrangeEnforcedFlowPreconditioner::SubsidiaryPreconditionerFctPt) ()

This preconditioner includes the option to use subsidiary operators other than SuperLUPreconditioner for this problem. This is the typedef of a function that should return an instance of a subsidiary preconditioning operator. This preconditioner is responsible for the destruction of the subsidiary preconditioners.

Definition at line 175 of file lagrange_enforced_flow_preconditioner.h.

Constructor & Destructor Documentation

◆ LagrangeEnforcedFlowPreconditioner() [1/2]

oomph::LagrangeEnforcedFlowPreconditioner::LagrangeEnforcedFlowPreconditioner ( )
inline

◆ ~LagrangeEnforcedFlowPreconditioner()

virtual oomph::LagrangeEnforcedFlowPreconditioner::~LagrangeEnforcedFlowPreconditioner ( )
inlinevirtual

Destructor.

Definition at line 208 of file lagrange_enforced_flow_preconditioner.h.

References clean_up_memory().

◆ LagrangeEnforcedFlowPreconditioner() [2/2]

oomph::LagrangeEnforcedFlowPreconditioner::LagrangeEnforcedFlowPreconditioner ( const LagrangeEnforcedFlowPreconditioner )
delete

Broken copy constructor.

Member Function Documentation

◆ clean_up_memory()

void oomph::LagrangeEnforcedFlowPreconditioner::clean_up_memory ( )
virtual

◆ operator=()

void oomph::LagrangeEnforcedFlowPreconditioner::operator= ( const LagrangeEnforcedFlowPreconditioner )
delete

Broken assignment operator.

◆ preconditioner_solve()

void oomph::LagrangeEnforcedFlowPreconditioner::preconditioner_solve ( const DoubleVector r,
DoubleVector z 
)
virtual

◆ scaling_sigma()

double oomph::LagrangeEnforcedFlowPreconditioner::scaling_sigma ( ) const
inline

Read (const) function to get the scaling sigma.

Definition at line 277 of file lagrange_enforced_flow_preconditioner.h.

References Scaling_sigma.

Referenced by set_scaling_sigma().

◆ set_meshes()

void oomph::LagrangeEnforcedFlowPreconditioner::set_meshes ( const Vector< Mesh * > &  mesh_pt)

◆ set_navier_stokes_preconditioner()

void oomph::LagrangeEnforcedFlowPreconditioner::set_navier_stokes_preconditioner ( Preconditioner new_ns_preconditioner_pt = 0)

Set a new Navier-Stokes matrix preconditioner (inexact solver)

Function to set a new momentum matrix preconditioner (inexact solver)

Definition at line 1214 of file lagrange_enforced_flow_preconditioner.cc.

References Navier_stokes_preconditioner_pt, and Using_superlu_ns_preconditioner.

◆ set_scaling_sigma()

void oomph::LagrangeEnforcedFlowPreconditioner::set_scaling_sigma ( const double &  scaling_sigma)
inline

Access function to set the scaling sigma. Note: this also sets the flag to use the infinite norm of the Navier-Stokes F matrix as the scaling sigma to false. Warning is given if trying to set scaling sigma to be equal to or greater than zero.

Definition at line 246 of file lagrange_enforced_flow_preconditioner.h.

References scaling_sigma(), Scaling_sigma, and Use_norm_f_for_scaling_sigma.

◆ set_superlu_for_navier_stokes_preconditioner()

void oomph::LagrangeEnforcedFlowPreconditioner::set_superlu_for_navier_stokes_preconditioner ( )
inline

Set Navier-Stokes matrix preconditioner (inexact solver) to SuperLU.

Definition at line 289 of file lagrange_enforced_flow_preconditioner.h.

References Navier_stokes_preconditioner_pt, and Using_superlu_ns_preconditioner.

◆ setup()

void oomph::LagrangeEnforcedFlowPreconditioner::setup ( )
virtual

Setup method for the LagrangeEnforcedFlowPreconditioner.

Setup the Lagrange enforced flow preconditioner. This extracts blocks corresponding to the velocity and Lagrange multiplier unknowns, creates the matrices actually needed in the application of the preconditioner and deletes what can be deleted... Note that this preconditioner needs a CRDoubleMatrix.

Implements oomph::Preconditioner.

Definition at line 507 of file lagrange_enforced_flow_preconditioner.cc.

References oomph::BlockPreconditioner< CRDoubleMatrix >::Block_distribution_pt, oomph::BlockPreconditioner< CRDoubleMatrix >::block_setup(), oomph::CRDoubleMatrix::build(), clean_up_memory(), oomph::CRDoubleMatrix::diagonal_entries(), oomph::DistributableLinearAlgebraObject::distribution_pt(), oomph::BlockPreconditioner< CRDoubleMatrix >::get_block(), oomph::BlockPreconditioner< CRDoubleMatrix >::get_concatenated_block(), oomph::CRDoubleMatrixHelpers::inf_norm(), Inv_w_diag_values, oomph::BlockPreconditioner< CRDoubleMatrix >::is_subsidiary_block_preconditioner(), oomph::BlockPreconditioner< CRDoubleMatrix >::matrix_pt(), oomph::CRDoubleMatrix::multiply(), My_mesh_pt, My_ndof_types_in_mesh, My_nmesh, N_fluid_doftypes, N_lagrange_doftypes, N_velocity_doftypes, Navier_stokes_preconditioner_is_block_preconditioner, Navier_stokes_preconditioner_pt, oomph::DenseMatrix< T >::ncol(), oomph::BlockPreconditioner< CRDoubleMatrix >::ndof_types(), oomph::CRDoubleMatrix::nnz(), oomph::DenseMatrix< T >::nrow(), Preconditioner_has_been_setup, Scaling_sigma, oomph::BlockPreconditioner< CRDoubleMatrix >::set_replacement_dof_block(), oomph::Preconditioner::setup(), oomph::BlockPreconditioner< MATRIX >::turn_into_subsidiary_block_preconditioner(), Use_norm_f_for_scaling_sigma, and Using_superlu_ns_preconditioner.

◆ use_norm_f_for_scaling_sigma()

void oomph::LagrangeEnforcedFlowPreconditioner::use_norm_f_for_scaling_sigma ( )
inline

Set flag to use the infinite norm of the Navier-Stokes F matrix as the scaling sigma. This is the default behaviour. Note: the norm of the NS F matrix positive, however, we actually use the negative of the norm. This is because the underlying Navier-Stokes Jacobian is multiplied by -1. Ask Andrew/Matthias for more detail.

Definition at line 236 of file lagrange_enforced_flow_preconditioner.h.

References Use_norm_f_for_scaling_sigma.

Member Data Documentation

◆ Inv_w_diag_values

Vector<Vector<double> > oomph::LagrangeEnforcedFlowPreconditioner::Inv_w_diag_values
private

Inverse W values.

Definition at line 316 of file lagrange_enforced_flow_preconditioner.h.

Referenced by preconditioner_solve(), and setup().

◆ My_mesh_pt

Vector<Mesh*> oomph::LagrangeEnforcedFlowPreconditioner::My_mesh_pt
private

Storage for the meshes. In our implementation, the first mesh must always be the Navier-Stokes (bulk) mesh, followed by surface meshes.

Definition at line 331 of file lagrange_enforced_flow_preconditioner.h.

Referenced by LagrangeEnforcedFlowPreconditioner(), set_meshes(), and setup().

◆ My_ndof_types_in_mesh

Vector<unsigned> oomph::LagrangeEnforcedFlowPreconditioner::My_ndof_types_in_mesh
private

The number of DOF types in each mesh. This is used create various lookup lists.

Definition at line 335 of file lagrange_enforced_flow_preconditioner.h.

Referenced by LagrangeEnforcedFlowPreconditioner(), and setup().

◆ My_nmesh

unsigned oomph::LagrangeEnforcedFlowPreconditioner::My_nmesh
private

The number of meshes. This is used to create various lookup lists.

Definition at line 339 of file lagrange_enforced_flow_preconditioner.h.

Referenced by LagrangeEnforcedFlowPreconditioner(), set_meshes(), and setup().

◆ N_fluid_doftypes

unsigned oomph::LagrangeEnforcedFlowPreconditioner::N_fluid_doftypes
private

The number of fluid DOF types (including pressure).

Definition at line 345 of file lagrange_enforced_flow_preconditioner.h.

Referenced by LagrangeEnforcedFlowPreconditioner(), preconditioner_solve(), and setup().

◆ N_lagrange_doftypes

unsigned oomph::LagrangeEnforcedFlowPreconditioner::N_lagrange_doftypes
private

The number of Lagrange multiplier DOF types.

Definition at line 342 of file lagrange_enforced_flow_preconditioner.h.

Referenced by LagrangeEnforcedFlowPreconditioner(), preconditioner_solve(), and setup().

◆ N_velocity_doftypes

unsigned oomph::LagrangeEnforcedFlowPreconditioner::N_velocity_doftypes
private

The number of velocity DOF types.

Definition at line 348 of file lagrange_enforced_flow_preconditioner.h.

Referenced by LagrangeEnforcedFlowPreconditioner(), and setup().

◆ Navier_stokes_preconditioner_is_block_preconditioner

bool oomph::LagrangeEnforcedFlowPreconditioner::Navier_stokes_preconditioner_is_block_preconditioner
private

Flag to indicate if the preconditioner for the Navier-Stokes block is a block preconditioner or not.

Definition at line 323 of file lagrange_enforced_flow_preconditioner.h.

Referenced by LagrangeEnforcedFlowPreconditioner(), and setup().

◆ Navier_stokes_preconditioner_pt

Preconditioner* oomph::LagrangeEnforcedFlowPreconditioner::Navier_stokes_preconditioner_pt
private

◆ Preconditioner_has_been_setup

bool oomph::LagrangeEnforcedFlowPreconditioner::Preconditioner_has_been_setup
private

Control flag is true if the preconditioner has been setup (used so we can wipe the data when the preconditioner is called again)

Definition at line 306 of file lagrange_enforced_flow_preconditioner.h.

Referenced by clean_up_memory(), LagrangeEnforcedFlowPreconditioner(), preconditioner_solve(), and setup().

◆ Scaling_sigma

double oomph::LagrangeEnforcedFlowPreconditioner::Scaling_sigma
private

Scaling for the augmentation: Scaling_sigma*(LL^T)

Definition at line 309 of file lagrange_enforced_flow_preconditioner.h.

Referenced by LagrangeEnforcedFlowPreconditioner(), scaling_sigma(), set_scaling_sigma(), and setup().

◆ Use_norm_f_for_scaling_sigma

bool oomph::LagrangeEnforcedFlowPreconditioner::Use_norm_f_for_scaling_sigma
private

Flag to indicate if we want to use the infinite norm of the Navier-Stokes momentum block for the scaling sigma.

Definition at line 313 of file lagrange_enforced_flow_preconditioner.h.

Referenced by LagrangeEnforcedFlowPreconditioner(), set_scaling_sigma(), setup(), and use_norm_f_for_scaling_sigma().

◆ Using_superlu_ns_preconditioner

bool oomph::LagrangeEnforcedFlowPreconditioner::Using_superlu_ns_preconditioner
private

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