FaspSolver.hpp

Go to the documentation of this file.

 
#ifndef __FASPSOLVER_HEADER__
#define __FASPSOLVER_HEADER__
 
// Standard header files
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
 
// faspsolver header files
extern "C" {
#include "fasp.h"
#include "fasp_block.h"
#include "fasp_functs.h"
}
 
// fasp4blkoil header files
#if WITH_FASP4BLKOIL
extern "C" {
#include "fasp4blkoil.h"
#include "fasp4blkoil_functs.h"
}
#endif
 
// fasp4cuda header files
// Note: It should not inside extern "C" {} !
#if WITH_FASP4CUDA
#include "fasp4cuda.h"
#include "fasp4cuda_functs.h"
#endif
 
// OpenCAEPoro header files
#include "LinearSolver.hpp"
 
using namespace std;
 
// Standard preconditioner types
#define PC_NULL  60 
#define PC_FASP1 61 
#define PC_FASP2 62 
#define PC_FASP3 63 
#define PC_FASP4 64 
#define PC_FASP5 65 
#define PC_DIAG  68 
#define PC_BILU  69 
 
// Sharing-setup preconditioner types
#define PC_FASP1_SHARE 71 
#define PC_FASP4_SHARE 74 
#define RESET_CONST    35 
 
class FaspSolver : public LinearSolver
{
public:
    void SetupParam(const string& dir, const string& file) override;
 
    USI GetNumIters() const override { return itParam.maxit; }
 
public:
    string      solveDir;  
    string      solveFile; 
    input_param inParam;   
    ITS_param   itParam;   
    AMG_param   amgParam;  
    ILU_param   iluParam;  
    SWZ_param   swzParam;  
};
 
class ScalarFaspSolver : public FaspSolver
{
    friend class LinearSystem;
 
private:
    void Allocate(const vector<USI>& rowCapacity,
                  const OCP_USI&     maxDim,
                  const USI&         blockDim) override;
 
    void InitParam() override;
 
    void AssembleMat(const vector<vector<USI>>&     colId,
                     const vector<vector<OCP_DBL>>& val,
                     const OCP_USI&                 dim,
                     const USI&                     blockDim,
                     vector<OCP_DBL>&               rhs,
                     vector<OCP_DBL>&               u) override;
 
    OCP_INT Solve() override;
 
private:
    dCSRmat A; 
    dvector b; 
    dvector x; 
};
 
class VectorFaspSolver : public FaspSolver
{
    friend class LinearSystem;
 
private:
    void Allocate(const vector<USI>& rowCapacity,
                  const OCP_USI&     maxDim,
                  const USI&         blockDim) override;
 
    void InitParam() override;
 
    void AssembleMat(const vector<vector<USI>>&     colId,
                     const vector<vector<OCP_DBL>>& val,
                     const OCP_USI&                 dim,
                     const USI&                     blockDim,
                     vector<OCP_DBL>&               rhs,
                     vector<OCP_DBL>&               u) override;
 
    OCP_INT Solve() override;
 
    void Decoupling(dBSRmat* Absr,
                    dvector* b,
                    dBSRmat* Asc,
                    dvector* fsc,
                    ivector* order,
                    double*  Dmatvec,
                    int      decouple_type);
 
private:
    dBSRmat A; 
    dvector b; 
    dvector x; 
 
    dBSRmat Asc;   
    dvector fsc;   
    ivector order; 
 
    vector<OCP_DBL> Dmat; 
};
 
#endif // __FASPSOLVER_HEADER__
 
/*----------------------------------------------------------------------------*/
/*  Brief Change History of This File                                         */
/*----------------------------------------------------------------------------*/
/*  Author              Date             Actions                              */
/*----------------------------------------------------------------------------*/
/*  Shizhe Li           Nov/22/2021      Create file                          */
/*  Chensong Zhang      Jan/08/2022      Update Doxygen                       */
/*  Chensong Zhang      Jan/19/2022      Set FASP4BLKOIL as optional          */
/*  Li Zhao             Apr/04/2022      Set FASP4CUDA   as optional          */
/*----------------------------------------------------------------------------*/