LinearSystem.hpp

Go to the documentation of this file.

 
#ifndef __LINEARSYSTEM_HEADER__
#define __LINEARSYSTEM_HEADER__
 
// Standard header files
#include <cmath>
#include <fstream>
#include <iostream>
#include <string>
 
// OpenCAEPoro header files
#include "DenseMat.hpp"
#include "FaspSolver.hpp"
#include "OCPConst.hpp"
 
using namespace std;
 
//  Note: The matrix is stored in the form of row-segmented CSR internally
class LinearSystem
{
 
public:
    void AllocateRowMem(const OCP_USI& dimMax, const USI& nb);
    void AllocateColMem(const vector<USI>&            bulk2bulk,
                        const vector<vector<OCP_USI>> well2bulk);
    void ClearData();
 
    vector<OCP_DBL>& GetSolution() { return u; }
    void CheckEquation() const;
    void CheckSolution() const;
    void OutputLinearSystem(const string& fileA, const string& fileb) const;
    void OutputSolution(const string& filename) const;
 
    // Linear Solver
    void SetupLinearSolver(const USI& i, const string& dir, const string& file);
    void AssembleMatLinearSolver() { LS->AssembleMat(colId, val, dim, blockDim, b, u); }
    OCP_INT Solve() { return LS->Solve(); }
 
    OCP_USI AddDim(const OCP_USI& n)
    {
        dim += n;
        return dim;
    }
 
    // Scalar
    void NewDiag(const OCP_USI& n, const OCP_DBL& v)
    {
        OCP_ASSERT(colId[n].size() == 0, "Wrong Diag");
        colId[n].push_back(n);
        val[n].push_back(v);
    }
    void AddDiag(const OCP_USI& n, const OCP_DBL& v)
    {
        OCP_ASSERT(colId[n].size() > 0, "Wrong Diag");
        val[n][0] += v;
    }
    void NewOffDiag(const OCP_USI& bId, const OCP_USI& eId, const OCP_DBL& v)
    {
        OCP_ASSERT(colId[bId].size() > 0, "Wrong Diag");
        colId[bId].push_back(eId);
        val[bId].push_back(v);
    }
    void AddRhs(const OCP_USI& n, const OCP_DBL& v) { b[n] += v; }
    void AssignGuess(const OCP_USI& n, const OCP_DBL& v) { u[n] = v; }
 
    // Vector
    void NewDiag(const OCP_USI& n, const vector<OCP_DBL>& v)
    {
        OCP_ASSERT(colId[n].size() == 0, "Wrong Diag");
        colId[n].push_back(n);
        val[n].insert(val[n].begin(), v.begin(), v.end());
    }
    void AddDiag(const OCP_USI& n, const vector<OCP_DBL>& v)
    {
        OCP_ASSERT(colId[n].size() > 0, "Wrong Diag");
        for (USI i = 0; i < blockSize; i++) {
            val[n][i] += v[i];
        }
    }
    void NewOffDiag(const OCP_USI& bId, const OCP_USI& eId, const vector<OCP_DBL>& v)
    {
        OCP_ASSERT(colId[bId].size() > 0, "Wrong Diag");
        colId[bId].push_back(eId);
        val[bId].insert(val[bId].end(), v.begin(), v.end());
    }
    void AddRhs(const OCP_USI& n, const vector<OCP_DBL>& v)
    {
        for (USI i = 0; i < blockDim; i++) {
            b[n * blockDim + i] += v[i];
        }
    }
 
    void AssembleRhsAccumulate(const vector<OCP_DBL>& rhs);
    void AssembleRhsCopy(const vector<OCP_DBL>& rhs);
    USI GetNumIters() { return LS->GetNumIters(); }
 
private:
    // Used for internal mat structure.
    USI blockDim;  
    USI blockSize; 
 
    // maxDim: fixed and used to allocate memory at the beginning of simulation;
    // dim:    might change during simulation but always less than maxDim.
    OCP_USI maxDim; 
    OCP_USI dim;    
 
    // The following values are stored for each row. Among them, rowCapacity is the max
    // possible capacity of each row of the matrix. It is just a little bigger than the
    // actual size and is used to allocate memory at the beginning of simulation.
    // diagVal is an auxiliary variable used to help setup entries in diagonal line and
    // it will only be used when matrix is assembled.
    vector<USI>             rowCapacity; 
    vector<vector<OCP_USI>> colId;       
    vector<vector<OCP_DBL>> val;         
    vector<OCP_DBL>         b;           
    vector<OCP_DBL>         u;           
 
    string solveDir; 
 
    LinearSolver* LS;
};
 
#endif /* end if __LINEARSOLVER_HEADER__ */
 
/*----------------------------------------------------------------------------*/
/*  Brief Change History of This File                                         */
/*----------------------------------------------------------------------------*/
/*  Author              Date             Actions                              */
/*----------------------------------------------------------------------------*/
/*  Shizhe Li           Oct/01/2021      Create file                          */
/*  Chensong Zhang      Oct/15/2021      Format file                          */
/*  Chensong Zhang      Nov/09/2021      Remove decoupling methods            */
/*  Chensong Zhang      Nov/22/2021      renamed to LinearSystem              */
/*----------------------------------------------------------------------------*/