OCPControl.hpp

Go to the documentation of this file.

 
#ifndef __OCP_CONTROL_HEADER__
#define __OCP_CONTROL_HEADER__
 
// Standard header files
#include <vector>
 
// OpenCAEPoro header files
#include "OCPConst.hpp"
#include "ParamControl.hpp"
#include "Reservoir.hpp"
 
using namespace std;
 
class ControlTime
{
public:
    ControlTime() = default;
    ControlTime(const vector<OCP_DBL>& src);
 
public:
    // Note: Most commonly used params are the first three
    OCP_DBL timeInit;    
    OCP_DBL timeMax;     
    OCP_DBL timeMin;     
    OCP_DBL maxIncreFac; 
    OCP_DBL minChopFac;  
    OCP_DBL cutFacNR;    
};
 
class ControlPreTime
{
public:
    ControlPreTime() = default;
    ControlPreTime(const vector<OCP_DBL>& src);
 
public:
    // Limits for changes at next time step
    OCP_DBL dPlim; 
    OCP_DBL dTlim; 
    OCP_DBL dSlim; 
    OCP_DBL dNlim; 
    OCP_DBL eVlim; 
};
 
class ControlNR
{
public:
    ControlNR() = default;
    ControlNR(const vector<OCP_DBL>& src);
 
public:
    // Note: Important for convergence of solution methods
    USI     maxNRiter; 
    OCP_DBL NRtol;     
    OCP_DBL NRdPmax;   
    OCP_DBL NRdSmax;   
    OCP_DBL NRdPmin;   
    OCP_DBL NRdSmin;   
    OCP_DBL Verrmax;   
};
 
class FastControl
{
public:
    void ReadParam(const USI& argc, const char* optset[]);
 
public:
    OCP_BOOL activity{OCP_FALSE};
    USI      method;        
    OCP_DBL  timeInit;      
    OCP_DBL  timeMax;       
    OCP_DBL  timeMin;       
    USI      printLevel{0}; 
};
 
//  Note: Which solution method will be used is determined here!
class OCPControl
{
    friend class OpenCAEPoro;
    friend class OCPOutput;
    friend class Out4RPT;
 
    friend class IsoT_FIM;
    friend class IsoT_FIMn;
    friend class IsoT_IMPEC;
    friend class IsoT_AIMc;
    friend class T_FIM;
    // temp
    friend class Solver;
 
public:
    void InputParam(const ParamControl& CtrlParam);
 
    USI GetModel() const { return model; }
 
    void ApplyControl(const USI& i, const Reservoir& rs);
 
    void InitTime(const USI& i);
 
    void SetupFastControl(const USI& argc, const char* optset[]);
 
    USI GetMethod() const { return method; }
 
    USI GetNumTSteps() const { return criticalTime.size(); }
 
    OCP_DBL GetCurTime() const { return current_time; }
 
    OCP_DBL GetCurDt() const { return current_dt; }
 
    OCP_DBL GetLastDt() const { return last_dt; }
 
    USI GetLSiter() const { return iterLS; }
 
    USI GetLSiterT() const { return iterLS_total; }
 
    USI GetNRiter() const { return iterNR; }
 
    USI GetNRiterT() const { return iterNR_total; }
 
    void UpdateIters();
 
    void UpdateIterLS(const USI& num) { iterLS += num; }
 
    void UpdateIterNR() { iterNR++; }
 
    void ResetIterNRLS();
 
    void RecordTimeLS(const OCP_DBL& t) { totalLStime += t; }
 
    void RecordTimeAssembleMat(const OCP_DBL& t) { totalAssembleMatTime += t; }
 
    void RecordTimeUpdateProperty(const OCP_DBL& t) { totalUpdatePropertyTime += t; }
 
    void RecordTotalTime(const OCP_DBL& t) { totalSimTime += t; }
 
    OCP_BOOL IsCriticalTime(const USI& d)
    {
        return ((criticalTime[d] - current_time) < TINY);
    }
 
    string GetWorkDir() const { return workDir; }
 
    string GetLsFile() const { return linearSolverFile; }
 
    // Check order is important
    OCP_BOOL Check(Reservoir& rs, initializer_list<string> il);
 
    // Calculate next time step
    void CalNextTimeStep(Reservoir& rs, initializer_list<string> il);
 
private:
    USI    model;            
    USI    method;           
    string workDir;          
    string linearSolverFile; 
 
    vector<OCP_DBL> criticalTime; 
 
    // Record time information
    OCP_DBL init_dt;         
    OCP_DBL current_dt;      
    OCP_DBL last_dt;         
    OCP_DBL current_time{0}; 
    OCP_DBL end_time;        
 
    OCP_DBL totalSimTime{0};            
    OCP_DBL initTime{0};                
    OCP_DBL totalUpdatePropertyTime{0}; 
    OCP_DBL totalAssembleMatTime{0};    
    OCP_DBL totalLStime{0};             
 
    // Record iteration information
    USI numTstep{0};     
    USI iterLS{0};       
    USI iterLS_total{0}; 
    USI iterNR{0};       
    USI iterNR_total{0}; 
    USI wastedIterNR{0}; 
    USI wastedIterLS{0}; 
 
    // Print level
    USI printLevel{0};
 
    // Time, error, and iteration dynamic controllers, all of which could change at
    // any critical time steps
    ControlTime            ctrlTime;
    vector<ControlTime>    ctrlTimeSet;
    ControlPreTime         ctrlPreTime;
    vector<ControlPreTime> ctrlPreTimeSet;
    ControlNR              ctrlNR;
    vector<ControlNR>      ctrlNRSet;
 
    // Receive directly from command lines, which will overwrite others
    FastControl ctrlFast;
 
    // Well
    OCP_BOOL wellChange; 
};
 
#endif /* end if __OCP_Control_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      Jan/08/2022      Update Doxygen                       */
/*----------------------------------------------------------------------------*/