Sfx_Simulation.h

Go to the documentation of this file.

#pragma once
 
// C++ include
#include <string>
#include <filesystem>
// SfxBase19 lib include
#include "include/Sfx_DefineTypes.h"
// Framework Library include
#include "include/Sfx_Singleton.hpp"
 
namespace Sfx 
{
  class Simulation : public Sfx::SfxSingleton<Simulation>
  {
    using ArrayType = std::vector<float64>; // Warning: also define in Sfx_defineTypes.h
 
  public:
    std::string getCalculFFSchemeName() const noexcept
    {
      return m_simProp.m_CalculFFSchemeName;
    }

    void setCalculFFSchemeName(const std::string& aCalculFFSchemeName) noexcept
    {
      m_simProp.m_CalculFFSchemeName = aCalculFFSchemeName;
    }

    void setPerformMeasurement(bool measurement) noexcept
    {
      m_simProp.m_performMeasurement = measurement;
    }

    void setNumberMeasurements(uint32 aNumofMeasurements) noexcept
    {
      m_simProp.m_numberMeasuremenst = aNumofMeasurements;
    }

    void setDataStore(const std::string& dataStore) noexcept
    {
      m_simProp.m_dataStoreName = dataStore;
    }

    void setDataStoreFile(std::string aDataStoreFile) noexcept {/*to be completed*/ }

    void setDoFinalReport(bool doFinalReport) noexcept  { m_simProp.m_doFinalRep = doFinalReport; }

    bool doFinalReport() const noexcept { return m_simProp.m_doFinalRep; }
    void setFinalReportClass(const std::string& finalReportClass) noexcept {/*not implemented yet*/ }
    void setPhysicalConfigureClass(const std::string& aConfClass) noexcept
    {
      m_simProp.m_physConfigClass = aConfClass;
    }

    void setPhysicalAlgoClass(const std::string& aAlgoClass) noexcept
    {
      m_simProp.m_physAlgoClass = aAlgoClass;
    }

    bool getPerformMeasurement() const noexcept { return m_simProp.m_performMeasurement; }
    uint32 getNumberMeasurements() const noexcept { return m_simProp.m_numberMeasuremenst; }
    std::string getDataStore() const noexcept { return m_simProp.m_dataStoreName; }
    const std::string getDataStoreFile() const noexcept { return m_simProp.m_dataStoreFile; }
    void setPhysicalMeasurementClass( std::string aPhysicalMeasureClass) { m_simProp.m_physMeasurementClass = aPhysicalMeasureClass; }
    std::string getPhysicalMeasurementClass() const noexcept
    {
      return m_simProp.m_physMeasurementClass;
    }

    std::string getPhysicalConfigurationClass() const noexcept
    {
      return m_simProp.m_physConfigClass;
    }

    void setPhysicalConfigurationClass(std::string aPhysicalConfig) noexcept
    { m_simProp.m_physConfigClass = aPhysicalConfig; }

    std::string getPhysicalAlgorithmClass() const noexcept
    {
      return m_simProp.m_physAlgoClass;
    }

    void setPhysicalAlgorithmClass(std::string aPhysicalAlgo) noexcept { m_simProp.m_physAlgoClass = aPhysicalAlgo; }
    std::string getFinalReportClass() const noexcept { return std::string{ "" }; }
    void setPhysicalSystemClass( std::string aPhysicalSystemClass) noexcept {}
    std::string getInitialCnd() const noexcept { return std::string{ "" }; }
    void setBoundaryCnd(std::string aBoundaryCnd) noexcept {}
    std::string getBoundaryCnd() noexcept { return std::string{ "" }; }
    void setNumericalMethod(std::string aNumethod) noexcept 
    {
      m_simProp.m_numericalMethod = aNumethod;
    }

    std::string getNumericalMethod() const noexcept { return m_simProp.m_numericalMethod; }
    float64 getSimulationStartTime() const noexcept  { return m_simProp.m_startTime; }
    void setSimulationStartTime(float64 aStartTime) noexcept
    {
      m_simProp.m_startTime = aStartTime;
      m_simProp.m_simTime = aStartTime;
    }

    void setSimulationTime(float64 aTime) noexcept { m_simProp.m_simTime = aTime; }
    float64 getSimulationTime() const noexcept { return m_simProp.m_simTime; /*+= getSimulationTimeStep();*/ }
    void setNumTimeStep(uint32 aNumTimeStep) noexcept { m_simProp.m_numTimeStep = aNumTimeStep; }
    uint32 getNumTimeStep() noexcept { return m_simProp.m_numTimeStep; }
    void setSimulationTimeStep(const float64 aTimeStep) noexcept
    {
      m_simProp.m_timeStep = aTimeStep;
      updateTime();
    }

    const float64 getSimulationTimeStep() const noexcept { return m_simProp.m_timeStep; }
    void updateTime() noexcept
    {
      m_simProp.m_simTime += getSimulationTimeStep();
    }

    std::string toString() const noexcept { return std::string{ "" }; }
    struct SimProp;
    Simulation::SimProp loadPropertyFile( const std::filesystem::path& aFilePropPath/*std::string aPropFile*/);
    void setParamsFileName(std::string aPropFileName) { m_simProp.m_propFileName = aPropFileName; }
    std::string getParamsFileName() const { return m_simProp.m_propFileName; }
    friend class Sfx::SfxSingleton<Simulation>;
  public:
    struct SimProp
    {
      SimProp()
      {
        m_performMeasurement = true; 
        m_doFinalRep = true;         
        m_numberMeasuremenst = 3;
        m_CalculFFSchemeName = std::string{ "HLL_Scheme" }; // flux function
        m_propFileName = std::string{ "DbppSimulationProp.txt" };
        m_dataStoreFile = std::string{ "HLL_Scheme_FullResult.txt" };
        m_dataStoreName = std::string{ "FileDataStore" };
        m_physMeasurementClass = std::string{ "DamBreakMeasure" };
        m_physConfigClass = std::string{ "DamBreakSetup" };
        m_physAlgoClass = std::string{ "PhysicalAlgo" };
        m_phySystemClass = std::string{ "DamBreakSystem" };
        m_numericalMethod = std::string{ "Rk2HllScheme" };
        m_boundaryCnd = std::string{ "EMcNeilBnd" };
        m_NbIterations = 1;      
        m_startTime = 0.;
        m_stopTime = 0.;
        m_simTime = 0.;           
        m_maxTimeStep = 0.1;       
        m_lastTime = 0.;          
        m_timeStep = 0.1;
        m_numTimeStep = 1;
   //     m_lastTime = 0.;          /**< */ 
      }
      bool m_doFinalRep;                  
      bool m_performMeasurement;          
      uint32 m_numberMeasuremenst;        
      std::string m_CalculFFSchemeName;   
      std::string m_propFileName;         
      std::string m_dataStoreName;        
      std::string m_dataStoreFile;         
      std::string m_physMeasurementClass;  
      std::string m_physConfigClass;       
      std::string m_physAlgoClass;         
      std::string m_phySystemClass;        
      std::string m_numericalMethod;       
      std::string m_boundaryCnd;           
      int32   m_NbIterations;              
      float64 m_startTime;                 
      float64 m_stopTime;                  
      float64 m_simTime;                    
      float32 m_lastTime;                  
      float64 m_timeStep;                  
      uint32 m_numTimeStep;                
      float64 m_maxTimeStep;              
  //        std::string m_equationName;
 //   private:
  //    std::string m_fileDataStore;
    } m_simProp;
 
  protected:
    Simulation() = default;
    ~Simulation() = default;
    Simulation( const Simulation& aOther) = delete;
    Simulation& operator= (const Simulation& aOther) = delete;
  private:
    //
    // Simulation properties
    //
 //   int32   m_NbIterations;      // ...
    //bool    m_isRunning;             simulation state
 //   float64 m_simTime;
 //   float32 m_MaxTimeStep;       // step size (dt)
    //float32 m_LastTime;          // ...
    //float64 m_timeStep;
  //  std::string m_algoName;      //
  //  std::list<std::string> m_listOfAlgorithm;
  //private:
  //  bool m_doFinalrep;
  };
}// End of namespace