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 dSlim; 
    OCP_DBL dNlim; 
    OCP_DBL dVlim; 
};
 
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:
    bool    activity{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 DetailInfo;
    friend class Reservoir;
 
    friend class OCP_FIM;
    friend class OCP_FIMn;
    friend class OCP_IMPEC;
    friend class OCP_AIMc;
    friend class OCP_AIMs;
    friend class OCP_AIMt;
    friend class OCP_FIM_IMPEC;
    // temp
    friend class Solver; 
 
public:
    void InputParam(const ParamControl& CtrlParam);
 
    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() { 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 UpdateTimeLS(const OCP_DBL& t) { totalLStime += t; }
 
    void RecordTotalTime(const OCP_DBL& t) { totalSimTime += t; }
 
    void CalNextTstepIMPEC(const Reservoir& reservoir);
    void CalNextTstepFIM(const Reservoir& reservoir);
 
    bool IsCriticalTime(const USI& d)
    {
        return ((criticalTime[d] - current_time) < TINY);
    }
 
    string GetWorkDir() const { return workDir; }
 
    string GetLsFile() const { return linearsolveFile; }
 
    // Set wellChange
    void SetWellChange(const bool& flag) { wellChange = flag; }
 
private:
    USI    method;  
    string workDir; 
    string linearsolveFile;  
 
    vector<OCP_DBL> criticalTime; 
 
    // Record time information
    OCP_DBL current_dt;      
    OCP_DBL last_dt;         
    OCP_DBL current_time{0}; 
    OCP_DBL end_time;        
    OCP_DBL totalSimTime{0}; 
    OCP_DBL totalLStime{0};  
    OCP_DBL init_dt;         
 
    // 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 };
 
    // Includes time controler, error controler, and iteration controler, all of which
    // could change at different critical time step.
    ControlTime            ctrlTime;
    vector<ControlTime>    ctrlTimeSet;
    ControlPreTime         ctrlPreTime;
    vector<ControlPreTime> ctrlPreTimeSet;
    ControlNR              ctrlNR;
    vector<ControlNR>      ctrlNRSet;
    FastControl            ctrlFast; 
 
    // Well 
    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                       */
/*----------------------------------------------------------------------------*/