gsTrilinosSolvers.h

Go to the documentation of this file.

#pragma once

#include <gsTrilinos/Vector.h>
#include <gsIO/gsOptionList.h>



namespace gismo
{

namespace trilinos
{

namespace solver
{

class AmesosSolver;
class AztecSolver;
class BelosSolver;
class MLSolver;

struct AmesosSolvers
{
    enum {
        Lapack                   = 1,                
        KLU                      = 2,                
        Umfpack                  = 3,                
        Pardiso                  = 4,                
        Taucs                    = 5,                
        SuperLU                  = 6,                
        SuperLUDist              = 7,                
        Mumps                    = 8,                
        Dscpack                  = 9                 
    };
};

//constants for solver types - from az_aztec_defs.h
#define AZ_cg               0 /* preconditioned conjugate gradient method     */
#define AZ_gmres            1 /* preconditioned gmres method                  */
#define AZ_cgs              2 /* preconditioned cg squared method             */
#define AZ_tfqmr            3 /* preconditioned transpose-free qmr method     */
#define AZ_bicgstab         4 /* preconditioned stabilized bi-cg method       */
#define AZ_slu              5 /* super LU direct method.                      */
#define AZ_symmlq           6 /* indefinite symmetric like symmlq             */
#define AZ_GMRESR           7 /* recursive GMRES (not supported)              */
#define AZ_fixed_pt         8 /* fixed point iteration                        */
#define AZ_analyze          9 /* fixed point iteration                        */
#define AZ_lu              10 /* sparse LU direct method. Also used for a     */
#define AZ_cg_condnum      11
#define AZ_gmres_condnum   12

//constants for preconditioners - from az_aztec_defs.h
#define AZ_none             0 /* no preconditioning. Note: also used for      */
/* scaling, output, overlap options options     */
#define AZ_Jacobi           1 /* Jacobi preconditioning. Note: also used for  */
/* scaling options                              */
#define AZ_sym_GS           2 /* symmetric Gauss-Siedel preconditioning       */
#define AZ_Neumann          3 /* Neumann series polynomial preconditioning    */
#define AZ_ls               4 /* least-squares polynomial preconditioning     */
#define AZ_ilu              6 /* domain decomp with  ilu in subdomains        */
#define AZ_bilu             7 /* domain decomp with block ilu in subdomains   */
/* #define AZ_lu           10    domain decomp with   lu in subdomains        */
#define AZ_icc              8 /* domain decomp with incomp Choleski in domains*/
#define AZ_ilut             9 /* domain decomp with ilut in subdomains        */
#define AZ_rilu            11 /* domain decomp with rilu in subdomains        */
#define AZ_recursive       12 /* Recursive call to AZ_iterate()               */
#define AZ_smoother        13 /* Recursive call to AZ_iterate()               */
#define AZ_dom_decomp      14 /* Domain decomposition using subdomain solver  */
/* given by options[AZ_subdomain_solve]         */
#define AZ_multilevel      15 /* Do multiplicative domain decomp with coarse  */
/* grid (not supported).                        */
#define AZ_user_precond    16 /*  user's preconditioning */
/* Begin Aztec 2.1 mheroux mod */
#define AZ_bilu_ifp        17 /* dom decomp with bilu using ifpack in subdom  */
/* End Aztec 2.1 mheroux mod */

struct AztecSolvers
{
    enum {
        CG                       = AZ_cg,            
        CGCondNum                = AZ_cg_condnum,    
        Gmres                    = AZ_gmres,         
        GmresCondNum             = AZ_gmres_condnum, 
        GmresR                   = AZ_GMRESR,        
        CGS                      = AZ_cgs,           
        TFQMR                    = AZ_tfqmr,         
        BiCGStab                 = AZ_bicgstab,      
        LU                       = AZ_lu,            
        SLU                      = AZ_slu,           
        SymmLQ                   = AZ_symmlq,        
        FixedPoint               = AZ_fixed_pt,      
        Analyze                  = AZ_analyze        
    };
};

struct AztecPreconds
{
    enum {
        None                     = AZ_none,          
        Jacobi                   = AZ_Jacobi,        
        Neumann                  = AZ_Neumann,       
        LS                       = AZ_ls,            
        GS                       = AZ_sym_GS,        
        DD                       = AZ_dom_decomp,    
        ILU                      = AZ_ilu,           
        BILU                     = AZ_bilu,          
        ICC                      = AZ_icc,           
        ILUT                     = AZ_ilut,          
        RILU                     = AZ_rilu,          
        Recursive                = AZ_recursive,     
        Smoother                 = AZ_smoother,      
        Multilevel               = AZ_multilevel,    
        UserDefined              = AZ_user_precond,  
        IfpackBILU               = AZ_bilu_ifp       
    };
};

struct AztecSubdomainSolvers
{
    enum {
        LU                       = AZ_lu,            
        ILUT                     = AZ_ilut,          
        ILU                      = AZ_ilu,           
        RILU                     = AZ_rilu,          
        BILU                     = AZ_bilu,          
        ICC                      = AZ_icc            
    };
};

#undef AZ_cg
#undef AZ_gmres
#undef AZ_cgs
#undef AZ_tfqmr
#undef AZ_bicgstab
#undef AZ_slu
#undef AZ_symmlq
#undef AZ_GMRESR
#undef AZ_fixed_pt
#undef AZ_analyze
#undef AZ_lu
#undef AZ_cg_condnum
#undef AZ_gmres_condnum
//
#undef AZ_none
#undef AZ_Jacobi
#undef AZ_sym_GS
#undef AZ_Neumann
#undef AZ_ls
#undef AZ_ilu
#undef AZ_bilu
#undef AZ_icc
#undef AZ_ilut
#undef AZ_rilu
#undef AZ_recursive
#undef AZ_smoother
#undef AZ_dom_decomp
#undef AZ_multilevel
#undef AZ_user_precond
#undef AZ_bilu_ifp


struct BelosSolvers
{
    enum {
        BiCGStab                =  1, 
        BlockCG                 =  2, 
#ifdef Belos_ENABLE_Experimental
        BlockGCRODR             =  3, 
#endif
        BlockGmres              =  4, 
        FixedPoint              =  5, 
        GCRODR                  =  6, 
        GmresPoly               =  7, 
        LSQR                    =  8, 
        Minres                  =  9, 
        PCPG                    = 10, 
        PseudoBlockCG           = 11, 
        PseudoBlockGmres        = 12, 
        PseudoBlockStochasticCG = 13, 
        PseudoBlockTFQMR        = 14, 
        RCG                     = 15, 
        TFQMR                   = 16  
    };
};

struct MLSolvers
{
    enum {
        SA                      =  1, 
        NSSA                    =  2, 
        DD                      =  3, 
        DDLU                    =  4, 
        DDML                    =  5, 
        DDMLLU                  =  6  
    };
};

struct AbstractSolverPrivate;

class GISMO_EXPORT AbstractSolver
{
 public:

    AbstractSolver();
    explicit AbstractSolver(const SparseMatrix & A);

    ~AbstractSolver();

    const Vector & solve(const Vector & b);

    void getSolution(gsVector<real_t> & sol, const int rank = 0) const;

    virtual std::string validParams() const = 0;

    virtual std::string currentParams() const = 0;

    virtual std::string status() const = 0;

    virtual std::string timing() const = 0;

    virtual void set(const std::string & name, const int & value) = 0;
    virtual void set(const std::string & name, const bool & value) = 0;
    virtual void set(const std::string & name, const double & value) = 0;
    virtual void set(const std::string & name, const std::string & value) = 0;

    void setOptions(const gsOptionList & opt);


 protected:
    virtual void solveProblem() = 0;

 protected:
    AbstractSolverPrivate * my;
};

class GISMO_EXPORT AbstractDirectSolver : public AbstractSolver
{
 public:

    AbstractDirectSolver() { }
    explicit AbstractDirectSolver(const SparseMatrix & A)
        : AbstractSolver(A) { }

};

class GISMO_EXPORT AbstractIterativeSolver : public AbstractSolver
{
 public:

    AbstractIterativeSolver();
    explicit AbstractIterativeSolver(const SparseMatrix & A);

 protected:

    virtual int numIterations() const = 0;

protected:

    double tolerance;

    int    maxIter;
};

/*    --- Amesos solver ---    */

struct AmesosSolverPrivate;

class GISMO_EXPORT AmesosSolver : public AbstractDirectSolver
{
 public:
    typedef AbstractDirectSolver Base;

 public:

    explicit AmesosSolver(const SparseMatrix & A,
                          const int solver = AmesosSolvers::KLU);

    ~AmesosSolver();

    std::string validParams() const;
    std::string currentParams() const;

    std::string status() const;
    std::string timing() const;

    void set(const std::string & name, const int & value);
    void set(const std::string & name, const bool & value);
    void set(const std::string & name, const double & value);
    void set(const std::string & name, const std::string & value);

 private:

    void solveProblem();
    void solveProblem(const bool noSymbolicFactorization,
                      const bool noNumericFactorization);

private:

    AmesosSolverPrivate * myAmesos;
};

/*    --- Aztec solver ---    */

struct AztecSolverPrivate;

class GISMO_EXPORT AztecSolver : public AbstractIterativeSolver
{
 public:
    typedef AbstractIterativeSolver Base;

 public:

    explicit AztecSolver(const SparseMatrix & A,
                         const int solver   = AztecSolvers::Gmres,
                         const int precond  = AztecPreconds::None,
                         const int subdomain_solver = AztecSubdomainSolvers::ILUT);

    ~AztecSolver();

    void setPreconditioner(const BelosSolver & Belos);

    void setPreconditioner(const MLSolver & ML);

    std::string validParams() const;
    std::string currentParams() const;

    std::string status() const;
    std::string timing() const;

    void set(const std::string & name, const int & value);
    void set(const std::string & name, const bool & value);
    void set(const std::string & name, const double & value);
    void set(const std::string & name, const std::string & value);

    void set(const int & option, const int & value);
    void set(const int & param,  const double & value);

    int numIterations() const;

 private:

    void solveProblem();

 private:

    AztecSolverPrivate * myAztec;
};

/*   --- Belos solver ---    */

struct BelosSolverPrivate;

class GISMO_EXPORT BelosSolver : public AbstractIterativeSolver
{
 public:
    typedef AbstractIterativeSolver Base;

    explicit BelosSolver(const SparseMatrix & A,
                         const int solver   = BelosSolvers::BiCGStab);

    ~BelosSolver();

    std::string validParams() const;
    std::string currentParams() const;

    std::string status() const;
    std::string timing() const;

    void set(const std::string & name, const int & value);
    void set(const std::string & name, const bool & value);
    void set(const std::string & name, const double & value);
    void set(const std::string & name, const std::string & value);

    void setHermitian();

    int setPreconditioner(const std::string & precType, const SparseMatrix &A,
                          const bool & leftprec, const int & OverlapLevel=0);

    //    void setMLPreconditioner(const SparseMatrix &A);

    int numIterations() const;

 private:

    void solveProblem();

 private:

    BelosSolverPrivate * myBelos;

public:

    Epetra_Operator * getPrecOperator() const;
};

/*    --- Multi Level (ML) ---    */

struct MLSolverPrivate;

class GISMO_EXPORT MLSolver : public AbstractIterativeSolver
{

 public:
    typedef AbstractIterativeSolver Base;

 public:

    explicit MLSolver(const SparseMatrix &A,
                      const int solver = MLSolvers::SA);

    ~MLSolver();

    std::string validParams() const;
    std::string currentParams() const;

    std::string status() const;
    std::string timing() const;

    void set(const std::string & name, const int & value);
    void set(const std::string & name, const bool & value);
    void set(const std::string & name, const double & value);
    void set(const std::string & name, const std::string & value);

    void set(const int & option, const int & value);

    int numIterations() const;

 private:

    void solveProblem();

 private:

    MLSolverPrivate * myML;

 public:

    Epetra_Operator * getPrecOperator() const;
};

}// namespace solver
}// namespace trilinos
}// namespace gismo