mainapp.h

Go to the documentation of this file.

#ifndef  _MY_MainApp_
#define _MY_MainApp_
#include <string>
#include "dealbase.h"
#include "configfile.h"
#include "transportbase.h"
#include "dynamicbase.h"
#include "orthomesh.h"
#include "sequencer.h"
#include "facefluxfunction.h"
#include "co2gridgenerator.h"
#include "constvelocitymodule.h"
#include "facefluxfunction.h"
#include "flashbase.h"
#include "opointer.h"
#include "linearsolver.h"
#include "fixedvaluecondition.h"
#include "diffusivestep.h" 
#include "stringhashfun.h"
#include "doubleporositydiff.h"
#include "blockmatrixmodule.h"
#include "monitorwells.h"

using std::string;

class UnitTests;
class MainApp
{
  std::ostream *pOut;
  friend class UnitTests;
  std::string m_suffix;
 protected:
  Dictionary log;
  
  ConfigFile configFile;
  VecWellInfo m_wells;
  OPointer<MonitorWells> m_pMonitorWells;
  bool m_bPrint;
  OPointer<OrthoMesh> m_pMesh;
  OPointer<OrthoMesh> m_pMB_Mesh;
  VecDouble m_cPor;
  VecDouble m_cK;
  VecDouble m_mbcPor;
  VecDouble m_mbcK;
  //We use these pointers as classes attributes just to track the 
  //allocated objects so that they can be deallocated when the mainapp exit.
  OPointer<GeneralFunctionInterface>  m_fMob,m_fMobT,m_fMobGrav,m_fFracFlux;
  OPointer<GeneralFunctionInterface> m_mb_fMob,m_mb_fMobT,m_mb_fMobGrav,m_mb_fFracFlux; //used for matrix block mobilities
  OPointer<GeneralFunctionInterface>    m_fKr1, m_fKr2, m_fDKr1,m_fDKr2; //To store the relative permeabilities;
  

  
  OPointer<GeneralFunctionInterface>  m_DfMobGrav,m_DfFracFlux,m_fKr,m_fDKr;
  OPointer<GeneralFunctionInterface> m_mb_DfMobGrav, m_mb_DfFracFlux;
  OPointer<GeneralFunctionInterface>  m_fPc,m_dfPc,m_fPcInv;
  OPointer<GeneralFunctionInterface> m_mb_fPc, m_mb_dfPc, m_mb_fPcInv;
  OPointer<Function3D> m_fSource;

  FaceFluxFunction  *m_flux;
  Function3D *m_fTransBC;
  Function3D *m_fInit;
  Function3D *m_fPor;
  Function3D *m_mbfPor;
  Function3D *m_pVelFunction;
  Function3D *m_fK;
  Function3D *m_mbfK;
  OPointer<Function3D> m_fFluxBC,m_fDP;
  OPointer<Function3D> m_fDU,m_fTensionBC;
  OPointer<Function3D> m_fInitPressure;
  OPointer<LinearSolver> m_pSolver;
  OPointer<DiffusiveStep> m_pDiff;
  OPointer<DynamicBase> m_pDynamicModule;
  OPointer<TransportBase> m_pTransportModule;
  Sequencer *m_pSequencer;
  FlashBase *m_pFlash;
  OPointer<Function1D> m_pRelMob;


  FixedValueCondition m_fixedC;
  FixedValueCondition m_fixedP;

  BlockMatrixModule *m_blockMatrix;
  
  BlockMatrixModule& getBlockMatrix();
  
  

  
  void adjustInitialConditionForCompressibleModel(DynamicBase &dyn,ConservativeMethodForSystem &trans, FlashCompositional &flash);
  
  void setOutput(std::ostream &out){pOut = &out;}

  void printTriangulation();
  void printBeginSection(std::string str,std::ostream &out=std::cout);
  void textcolor(int attr, int fg, int bg);
  void printMeshInfo(); 

  void setTriangulation(Triangulation<3>& tria);
  void appendSuffixToFileNames(std::string suffix){m_suffix=suffix;}
  std::string getHDF5FileName();
  std::string getMonitorWellsOutputFileName();
  unsigned hasSystemOfTransportEquations();

 protected:

  Point3D getP0();
  Point3D getP1();
  Point3D getDX(); 
  std::vector<unsigned> getNElements();
  OrthoMesh& getMesh();

  OrthoMesh& getMB_Mesh(); 

  //Functions related to wells
  VecWellInfo getWells();
  VecWellInfo getSourceWells();
  MonitorWells& getMonitorWells(); 
  void getWellsPressureBC(Function3D *&fP,Function3D *&fFlux) ;
  Function3D& getWellsSourceTerm();
  Function3D* getWellTransportBC(std::string varName);

  //Function3D* getK(); /*!<Get permeability*/
  double  getYoung(); 
  double  getPoisson(); 
  double  getDynamicTimeStep();
  //Function3D* getPorosity();

  void getMobilities(GeneralFunctionInterface* &fMob,GeneralFunctionInterface* &fMobT,GeneralFunctionInterface* &fFracFlux,GeneralFunctionInterface* &DfFracFlux,GeneralFunctionInterface* &fMobGrav,GeneralFunctionInterface* &DfMobGrav); 

  void getKr(GeneralFunctionInterface* &fKr,GeneralFunctionInterface* &DfKr);
  
  //get mobilities for matrix block: dynamic module
  void mb_getMobilities(GeneralFunctionInterface* &fMob,GeneralFunctionInterface* &fMobT,GeneralFunctionInterface* &fFracFlux,GeneralFunctionInterface* &DfFracFlux,GeneralFunctionInterface* &fMobGrav,GeneralFunctionInterface* &DfMobGrav);
  
  void getPcFunction(GeneralFunctionInterface **fpc,GeneralFunctionInterface **dfpc,GeneralFunctionInterface **fpcInv);

  void mb_getPcFunction(GeneralFunctionInterface **mb_fpc, GeneralFunctionInterface **mb_dfpc, GeneralFunctionInterface **mb_fpcInv);
  
  void        getPBoundaryCondition(Function3D * &fDP, Function3D * &fFlux);
  void        getUBoundaryCondition(Function3D * &fDU, Function3D * &fTensionBC);
  FixedValueCondition& getTransportFixedConditions();
  FixedValueCondition& getPressureFixedConditions();
  
  ConstVelocityModule* getConstVelocityDynamicModule();
  LinearSolver*        getLinearSolver();
  DynamicBase*   getDynamicModule(); 
  Function3D* getPressureIC();

  Function3D* getTransportBC(std::string compName);
  Function3D* getTransportIC(std::string compName);

  //These functions are specific to cases where we have just a scalar equation for the transport
  FaceFluxFunction* getFluxFunction();
  TransportBase* getTransportModule(); 
  //get Flash Module
  FlashBase* getFlash(); 
  FlashCompositional* getFlashCompositional();
  bool isCompositionalFlash();

  //These functions are specific to cases where we have system for hyperbolic equations
  DiffusiveStep* getDiffusiveStep();
  Function3D* getTransportForSystemBC(unsigned nCmps);
  Function3D* getTransportForSystemIC(unsigned nCmps);

  Sequencer*  getSequencer(); 
  void enablePrint(bool b){m_bPrint = b;}
  Point3D getSpatialDiscretizationSteps(); 
  Point3D getDomainDimensions(); 

  Function3D* getPorousMediaProperty(std::string key); 

  VecDouble& getPorosityAtCells();
  VecDouble& getPermeabilityAtCells();
  
  VecDouble& mb_getPorosityAtCells();
  VecDouble& mb_getPermeabilityAtCells();
  void print(std::string section,const char *format,...);
  void printLog(std::ostream &out);
  void print_log_entry(std::string section,std::ostream &out);
 public:

  MainApp();
  void execute(std::string fileName,bool unitests=false); 
  void coarseMesh(unsigned nX,unsigned nY,unsigned nZ,string fileIn,string fileOut);
  void abortEvent();

  ~MainApp();

};

#endif

---