//////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// More...
#include <complex_smoother.h>
Inheritance diagram for oomph::HelmholtzFGMRESMG< MATRIX >:
Public Member Functions | |
| HelmholtzFGMRESMG () | |
| Constructor (empty) More... | |
| virtual | ~HelmholtzFGMRESMG () |
| Destructor (cleanup storage) More... | |
| HelmholtzFGMRESMG (const HelmholtzFGMRESMG &)=delete | |
| Broken copy constructor. More... | |
| void | operator= (const HelmholtzFGMRESMG &)=delete |
| Broken assignment operator. More... | |
| void | set_preconditioner_LHS () |
| Overloaded function to let the user know that left preconditioning is not possible with FGMRES, only right preconditioning. More... | |
| void | solve (Problem *const &problem_pt, DoubleVector &result) |
| Solver: Takes pointer to problem and returns the results vector which contains the solution of the linear system defined by the problem's fully assembled Jacobian and residual vector. More... | |
| Public Member Functions inherited from oomph::HelmholtzGMRESMG< MATRIX > | |
| HelmholtzGMRESMG () | |
| Constructor. More... | |
| virtual | ~HelmholtzGMRESMG () |
| Destructor (cleanup storage) More... | |
| HelmholtzGMRESMG (const HelmholtzGMRESMG &)=delete | |
| Broken copy constructor. More... | |
| void | operator= (const HelmholtzGMRESMG &)=delete |
| Broken assignment operator. More... | |
| void | disable_resolve () |
| Overload disable resolve so that it cleans up memory too. More... | |
| void | preconditioner_solve (const DoubleVector &r, DoubleVector &z) |
| Implementation of the pure virtual base class function. The function has been broken because this is meant to be used as a linear solver. More... | |
| void | setup () |
| Implementation of the pure virtual base class function. This accompanies the preconditioner_solve function and so is also broken. More... | |
| void | solve (DoubleMatrixBase *const &matrix_pt, const DoubleVector &rhs, DoubleVector &solution) |
| Linear-algebra-type solver: Takes pointer to a matrix and rhs vector and returns the solution of the linear system. More... | |
| void | solve (DoubleMatrixBase *const &matrix_pt, const Vector< double > &rhs, Vector< double > &result) |
| Linear-algebra-type solver: Takes pointer to a matrix and rhs vector and returns the solution of the linear system Call the broken base-class version. If you want this, please implement it. More... | |
| void | resolve (const DoubleVector &rhs, DoubleVector &result) |
| Re-solve the system defined by the last assembled Jacobian and the rhs vector specified here. Solution is returned in the vector result. More... | |
| unsigned | iterations () const |
| Number of iterations taken. More... | |
| void | set_preconditioner_LHS () |
| Set left preconditioning (the default) More... | |
| void | set_preconditioner_RHS () |
| Enable right preconditioning. More... | |
| Public Member Functions inherited from oomph::IterativeLinearSolver | |
| IterativeLinearSolver () | |
| Constructor: Set (default) trivial preconditioner and set defaults for tolerance and max. number of iterations. More... | |
| IterativeLinearSolver (const IterativeLinearSolver &)=delete | |
| Broken copy constructor. More... | |
| void | operator= (const IterativeLinearSolver &)=delete |
| Broken assignment operator. More... | |
| virtual | ~IterativeLinearSolver () |
| Destructor (empty) More... | |
| Preconditioner *& | preconditioner_pt () |
| Access function to preconditioner. More... | |
| Preconditioner *const & | preconditioner_pt () const |
| Access function to preconditioner (const version) More... | |
| double & | tolerance () |
| Access to convergence tolerance. More... | |
| unsigned & | max_iter () |
| Access to max. number of iterations. More... | |
| void | enable_doc_convergence_history () |
| Enable documentation of the convergence history. More... | |
| void | disable_doc_convergence_history () |
| Disable documentation of the convergence history. More... | |
| void | open_convergence_history_file_stream (const std::string &file_name, const std::string &zone_title="") |
| Write convergence history into file with specified filename (automatically switches on doc). Optional second argument is a string that can be used (as a zone title) to identify what case we're running (e.g. what combination of linear solver and preconditioner or parameter values are used). More... | |
| void | close_convergence_history_file_stream () |
| Close convergence history output stream. More... | |
| double | jacobian_setup_time () const |
| returns the time taken to assemble the jacobian matrix and residual vector More... | |
| double | linear_solver_solution_time () const |
| return the time taken to solve the linear system More... | |
| virtual double | preconditioner_setup_time () const |
| returns the the time taken to setup the preconditioner More... | |
| void | enable_setup_preconditioner_before_solve () |
| Setup the preconditioner before the solve. More... | |
| void | disable_setup_preconditioner_before_solve () |
| Don't set up the preconditioner before the solve. More... | |
| void | enable_error_after_max_iter () |
| Throw an error if we don't converge within max_iter. More... | |
| void | disable_error_after_max_iter () |
| Don't throw an error if we don't converge within max_iter (default). More... | |
| void | enable_iterative_solver_as_preconditioner () |
| Enables the iterative solver be used as preconditioner (when calling the solve method it bypass the setup solver method – currently only used by Trilinos solver —) More... | |
| void | disable_iterative_solver_as_preconditioner () |
| Disables the iterative solver be used as preconditioner (when calling the solve method it bypass the setup solver method – currently only used by Trilinos solver —) More... | |
| Public Member Functions inherited from oomph::LinearSolver | |
| LinearSolver () | |
| Empty constructor, initialise the member data. More... | |
| LinearSolver (const LinearSolver &dummy)=delete | |
| Broken copy constructor. More... | |
| void | operator= (const LinearSolver &)=delete |
| Broken assignment operator. More... | |
| virtual | ~LinearSolver () |
| Empty virtual destructor. More... | |
| void | enable_doc_time () |
| Enable documentation of solve times. More... | |
| void | disable_doc_time () |
| Disable documentation of solve times. More... | |
| bool | is_doc_time_enabled () const |
| Is documentation of solve times enabled? More... | |
| bool | is_resolve_enabled () const |
| Boolean flag indicating if resolves are enabled. More... | |
| virtual void | enable_resolve () |
| Enable resolve (i.e. store matrix and/or LU decomposition, say) Virtual so it can be overloaded to perform additional tasks. More... | |
| virtual void | solve_transpose (Problem *const &problem_pt, DoubleVector &result) |
| Solver: Takes pointer to problem and returns the results vector which contains the solution of the linear system defined by the problem's fully assembled Jacobian and residual vector (broken virtual). More... | |
| virtual void | solve_transpose (DoubleMatrixBase *const &matrix_pt, const DoubleVector &rhs, DoubleVector &result) |
| Linear-algebra-type solver: Takes pointer to a matrix and rhs vector and returns the solution of the linear system. More... | |
| virtual void | solve_transpose (DoubleMatrixBase *const &matrix_pt, const Vector< double > &rhs, Vector< double > &result) |
| Linear-algebra-type solver: Takes pointer to a matrix and rhs vector and returns the solution of the linear system. More... | |
| virtual void | resolve_transpose (const DoubleVector &rhs, DoubleVector &result) |
| Solver: Resolve the system defined by the last assembled jacobian and the rhs vector. Solution is returned in the vector result. (broken virtual) More... | |
| virtual void | enable_computation_of_gradient () |
| function to enable the computation of the gradient required for the globally convergent Newton method More... | |
| void | disable_computation_of_gradient () |
| function to disable the computation of the gradient required for the globally convergent Newton method More... | |
| void | reset_gradient () |
| function to reset the size of the gradient before each Newton solve More... | |
| void | get_gradient (DoubleVector &gradient) |
| function to access the gradient, provided it has been computed 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... | |
| LinearAlgebraDistribution * | distribution_pt () const |
| access to the LinearAlgebraDistribution More... | |
| unsigned | nrow () const |
| access function to the number of global rows. More... | |
| unsigned | nrow_local () const |
| access function for the num of local rows on this processor. More... | |
| unsigned | nrow_local (const unsigned &p) const |
| access function for the num of local rows on this processor. More... | |
| unsigned | first_row () const |
| access function for the first row on this processor More... | |
| unsigned | first_row (const unsigned &p) const |
| access function for the first row on this processor More... | |
| bool | distributed () const |
| distribution is serial or distributed More... | |
| bool | distribution_built () const |
| 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... | |
| Public Member Functions inherited from oomph::BlockPreconditioner< MATRIX > | |
| BlockPreconditioner () | |
| Constructor. More... | |
| virtual | ~BlockPreconditioner () |
| Destructor. More... | |
| BlockPreconditioner (const BlockPreconditioner &)=delete | |
| Broken copy constructor. More... | |
| void | operator= (const BlockPreconditioner &)=delete |
| Broken assignment operator. More... | |
| MATRIX * | matrix_pt () const |
| 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 Mesh * | mesh_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 LinearAlgebraDistribution * | block_distribution_pt (const unsigned &b) const |
| Access function to the block distributions (const version). More... | |
| LinearAlgebraDistribution * | block_distribution_pt (const unsigned b) |
| Access function to the block distributions (non-const version). More... | |
| LinearAlgebraDistribution * | dof_block_distribution_pt (const unsigned &b) |
| Access function to the dof-level block distributions. More... | |
| const LinearAlgebraDistribution * | master_distribution_pt () const |
| 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< 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 LinearAlgebraDistribution * | internal_block_distribution_pt (const unsigned &b) const |
| Access function to the internal block distributions. More... | |
| void | insert_auxiliary_block_distribution (const Vector< unsigned > &block_vec_number, LinearAlgebraDistribution *dist_pt) |
| insert a Vector<unsigned> and LinearAlgebraDistribution* pair into Auxiliary_block_distribution_pt. The Auxiliary_block_distribution_pt should only contain pointers to distributions concatenated at this block level. We try to ensure this by checking if the block_vec_number vector is within the range nblock_types(). Of course, this does not guarantee correctness, but this is the least we can do. More... | |
| void | block_matrix_test (const unsigned &i, const unsigned &j, const 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... | |
| 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... | |
| 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... | |
| 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 OomphCommunicator * | comm_pt () const |
| Get function for comm pointer. More... | |
| virtual void | set_comm_pt (const OomphCommunicator *const comm_pt) |
| Set the communicator pointer. More... | |
| double | setup_time () const |
| Returns the time to setup the preconditioner. More... | |
| virtual void | turn_into_subsidiary_block_preconditioner (BlockPreconditioner< CRDoubleMatrix > *master_block_prec_pt, const Vector< unsigned > &doftype_in_master_preconditioner_coarse) |
| Virtual 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... | |
Private Member Functions | |
| void | solve_helper (DoubleMatrixBase *const &matrix_pt, const DoubleVector &rhs, DoubleVector &solution) |
| General interface to solve function. More... | |
| void | update (const unsigned &k, const Vector< Vector< std::complex< double >>> &hessenberg, const Vector< std::complex< double >> &s, const Vector< Vector< DoubleVector >> &z_m, Vector< DoubleVector > &x) |
| Helper function to update the result vector. More... | |
Additional Inherited Members | |
| Protected Member Functions inherited from oomph::HelmholtzGMRESMG< MATRIX > | |
| void | solve_helper (DoubleMatrixBase *const &matrix_pt, const DoubleVector &rhs, DoubleVector &solution) |
| General interface to solve function. More... | |
| void | clean_up_memory () |
| Cleanup data that's stored for resolve (if any has been stored) More... | |
| void | complex_matrix_multiplication (Vector< CRDoubleMatrix * > const matrices_pt, const Vector< DoubleVector > &x, Vector< DoubleVector > &soln) |
| Helper function to calculate a complex matrix-vector product. Assumes the matrix has been provided as a Vector of length two; the first entry containing the real part of the system matrix and the second entry containing the imaginary part. More... | |
| void | update (const unsigned &k, const Vector< Vector< std::complex< double >>> &hessenberg, const Vector< std::complex< double >> &s, const Vector< Vector< DoubleVector >> &v, Vector< DoubleVector > &x) |
| Helper function to update the result vector. More... | |
| void | generate_plane_rotation (std::complex< double > &dx, std::complex< double > &dy, std::complex< double > &cs, std::complex< double > &sn) |
Helper function: Generate a plane rotation. This is done by finding the value of  (i.e. cs) and the value of  (i.e. sn) such that: More... | |
| void | apply_plane_rotation (std::complex< double > &dx, std::complex< double > &dy, std::complex< double > &cs, std::complex< double > &sn) |
| Helper function: Apply plane rotation. This is done using the update: More... | |
| Protected Member Functions inherited from oomph::DistributableLinearAlgebraObject | |
| void | clear_distribution () |
| clear the distribution of this distributable linear algebra object More... | |
| Protected Member Functions inherited from oomph::BlockPreconditioner< MATRIX > | |
| 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 LinearAlgebraDistribution * | internal_preconditioner_matrix_distribution_pt () const |
| access function to the internal preconditioner matrix distribution pt. preconditioner_matrix_distribution_pt always returns the concatenation of the internal block distributions. Since the writer of the preconditioner does not need to concern themselves with the internal dof/block, please use preconditioner_matrix_distribution_pt(). More... | |
| const LinearAlgebraDistribution * | preconditioner_matrix_distribution_pt () const |
| Access function to the preconditioner matrix distribution pointer. This is the concatenation of the block distributions with the identity ordering. I.e. if this preconditioner has three block types, with the three associated block distributions dist_b0, dist_b1 and dist_b2, then this distribution is: LinearAlgebraDistributionHelpers::concatenate(dist_b0, dist_b1, dist_b2). More... | |
| Protected Attributes inherited from oomph::HelmholtzGMRESMG< MATRIX > | |
| unsigned | Iterations |
| Number of iterations taken. More... | |
| Vector< CRDoubleMatrix * > | Matrices_storage_pt |
| Vector of pointers to the real and imaginary part of the system matrix. More... | |
| bool | Resolving |
| Boolean flag to indicate if the solve is done in re-solve mode, bypassing setup of matrix and preconditioner. More... | |
| bool | Matrix_can_be_deleted |
| Boolean flag to indicate if the matrix pointed to be Matrix_pt can be deleted. More... | |
| bool | Preconditioner_LHS |
| boolean indicating use of left hand preconditioning (if true) or right hand preconditioning (if false) More... | |
| Protected Attributes inherited from oomph::IterativeLinearSolver | |
| bool | Doc_convergence_history |
| Flag indicating if the convergence history is to be documented. More... | |
| std::ofstream | Output_file_stream |
| Output file stream for convergence history. More... | |
| double | Tolerance |
| Convergence tolerance. More... | |
| unsigned | Max_iter |
| Maximum number of iterations. More... | |
| Preconditioner * | Preconditioner_pt |
| Pointer to the preconditioner. More... | |
| double | Jacobian_setup_time |
| Jacobian setup time. More... | |
| double | Solution_time |
| linear solver solution time More... | |
| double | Preconditioner_setup_time |
| Preconditioner setup time. More... | |
| bool | Setup_preconditioner_before_solve |
| indicates whether the preconditioner should be setup before solve. Default = true; More... | |
| bool | Throw_error_after_max_iter |
| Should we throw an error instead of just returning when we hit the max iterations? More... | |
| bool | Use_iterative_solver_as_preconditioner |
| Use the iterative solver as preconditioner. More... | |
| bool | First_time_solve_when_used_as_preconditioner |
| When the iterative solver is used a preconditioner then we call the setup of solver method only once (the first time the solve method is called) More... | |
| Protected Attributes inherited from oomph::LinearSolver | |
| bool | Enable_resolve |
| Boolean that indicates whether the matrix (or its factors, in the case of direct solver) should be stored so that the resolve function can be used. More... | |
| bool | Doc_time |
| Boolean flag that indicates whether the time taken. More... | |
| bool | Compute_gradient |
| flag that indicates whether the gradient required for the globally convergent Newton method should be computed or not More... | |
| bool | Gradient_has_been_computed |
| flag that indicates whether the gradient was computed or not More... | |
| DoubleVector | Gradient_for_glob_conv_newton_solve |
| DoubleVector storing the gradient for the globally convergent Newton method. More... | |
| Protected Attributes inherited from oomph::BlockPreconditioner< MATRIX > | |
| MapMatrix< unsigned, CRDoubleMatrix * > | Replacement_dof_block_pt |
| The replacement dof-level blocks. More... | |
| Vector< LinearAlgebraDistribution * > | Block_distribution_pt |
| The distribution for the blocks. More... | |
| Vector< Vector< unsigned > > | Block_to_dof_map_coarse |
| 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... | |
| Static Protected Attributes inherited from oomph::IterativeLinearSolver | |
| static IdentityPreconditioner | Default_preconditioner |
| Default preconditioner: The base class for preconditioners is a fully functional (if trivial!) preconditioner. More... | |
Detailed Description
template<typename MATRIX>
class oomph::HelmholtzFGMRESMG< MATRIX >
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
The FGMRES method, i.e. the flexible variant of the GMRES method which allows for nonconstant preconditioners [see Saad Y, "Iterative methods for sparse linear systems", p.287]. Note, FGMRES can only cater to right preconditioning; if the user tries to switch to left preconditioning they will be notified of this
Definition at line 3240 of file complex_smoother.h.
Constructor & Destructor Documentation
◆ HelmholtzFGMRESMG() [1/2]
template<typename MATRIX >
|
inline |
Constructor (empty)
Definition at line 3244 of file complex_smoother.h.
References oomph::HelmholtzGMRESMG< MATRIX >::Preconditioner_LHS.
◆ ~HelmholtzFGMRESMG()
template<typename MATRIX >
|
inlinevirtual |
Destructor (cleanup storage)
Definition at line 3251 of file complex_smoother.h.
References oomph::HelmholtzGMRESMG< MATRIX >::clean_up_memory().
◆ HelmholtzFGMRESMG() [2/2]
template<typename MATRIX >
|
delete |
Broken copy constructor.
Member Function Documentation
◆ operator=()
template<typename MATRIX >
|
delete |
Broken assignment operator.
◆ set_preconditioner_LHS()
template<typename MATRIX >
|
inline |
Overloaded function to let the user know that left preconditioning is not possible with FGMRES, only right preconditioning.
Definition at line 3265 of file complex_smoother.h.
◆ solve()
template<typename MATRIX >
|
inlinevirtual |
Solver: Takes pointer to problem and returns the results vector which contains the solution of the linear system defined by the problem's fully assembled Jacobian and residual vector.
Reimplemented from oomph::HelmholtzGMRESMG< MATRIX >.
Definition at line 3284 of file complex_smoother.h.
References oomph::BlockPreconditioner< MATRIX >::block_setup(), oomph::DoubleVector::build(), oomph::DistributableLinearAlgebraObject::build_distribution(), oomph::DoubleVector::built(), oomph::HelmholtzGMRESMG< MATRIX >::clean_up_memory(), oomph::MPI_Helpers::communicator_pt(), oomph::Problem::communicator_pt(), oomph::DistributableLinearAlgebraObject::distribution_pt(), oomph::LinearSolver::Doc_time, oomph::LinearSolver::Enable_resolve, oomph::BlockPreconditioner< MATRIX >::get_block(), oomph::Problem::get_jacobian(), i, oomph::IterativeLinearSolver::Jacobian_setup_time, oomph::HelmholtzGMRESMG< MATRIX >::Matrices_storage_pt, oomph::HelmholtzGMRESMG< MATRIX >::Matrix_can_be_deleted, oomph::BlockPreconditioner< MATRIX >::matrix_pt(), oomph::Problem::mesh_pt(), oomph::BlockPreconditioner< MATRIX >::nblock_types(), oomph::Problem::ndof(), oomph::oomph_info, oomph::DoubleVector::redistribute(), oomph::HelmholtzGMRESMG< MATRIX >::Resolving, oomph::Preconditioner::set_comm_pt(), oomph::Preconditioner::set_matrix_pt(), oomph::BlockPreconditioner< MATRIX >::set_mesh(), oomph::BlockPreconditioner< MATRIX >::set_nmesh(), oomph::HelmholtzFGMRESMG< MATRIX >::solve_helper(), and oomph::TimingHelpers::timer().
◆ solve_helper()
template<typename MATRIX >
|
private |
General interface to solve function.
/////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////
Linear-algebra-type solver: Takes pointer to a matrix and rhs vector and returns the solution of the linear system. based on the algorithm presented in Templates for the Solution of Linear Systems: Building Blocks for Iterative Methods, Barrett, Berry et al, SIAM, 2006 and the implementation in the IML++ library : http://math.nist.gov/iml++/
Definition at line 3551 of file complex_smoother.h.
References oomph::DoubleVector::build(), oomph::DoubleVector::built(), oomph::LinearAlgebraDistribution::distributed(), oomph::DistributableLinearAlgebraObject::distribution_pt(), i, oomph::DoubleVector::initialise(), oomph::BlackBoxFDNewtonSolver::Max_iter, oomph::DistributableLinearAlgebraObject::nrow(), oomph::oomph_info, s, oomph::Global_string_for_annotation::string(), and oomph::TimingHelpers::timer().
Referenced by oomph::HelmholtzFGMRESMG< MATRIX >::solve().
◆ update()
template<typename MATRIX >
|
inlineprivate |
Helper function to update the result vector.
Definition at line 3446 of file complex_smoother.h.
References oomph::DistributableLinearAlgebraObject::distribution_pt(), i, and s.
The documentation for this class was generated from the following file: