Sfx_SimulationMgr.h

Go to the documentation of this file.

 
#pragma once
 
// C++ include
#include <string>
// STL associative container 
#include <map>
// SfxBase19 library includes
#include "include/Sfx_Singleton.hpp"    // Singleton implementation
#include "../SfxBase/Sfx_DamBreakData.h"
// Elligno includes
#include "DamBreakSim.h"        // Dam Break Simulator
// VS19 includes
#include "../../Nov_VS2019/PhysicsAlgorithm/Testvs19_ListSectionsFlow.hpp"
#include "../Nov_VS2019/SimulationConfig.h"
#include "../Nov_VS2019/PhysicsAlgorithm/Testvs19_DamBreakSystem.h"
 
namespace Sfx 
{  
    using mapFluxSchemeName = std::map<std::string, CalculFF>;
    
    class SimulationMgr : public SfxSingleton<SimulationMgr> 
    {
    protected:
          SimulationMgr(); 
            ~SimulationMgr() = default;
            SimulationMgr(const SimulationMgr& aOther) = delete;
            SimulationMgr& operator= (const SimulationMgr& aOther) = delete;
    public:
    enum class eInitialWaveProfile { 
            SINE, 
            STEP  
        };

        enum class eRiverBedType
        {
            FLATBED = 0, 
            ONESTEP = 1, 
            HYDJUMP = 2, 
            RANDOM = 3   
        };

    enum class eFrictionType { NoFriction, FrictionValue };
    enum class ePhysicalBCType { EMcNeilBC, EllignoBC };

    template<typename> friend class SfxSingleton;
    void updateTime() {/*not implemented*/ }
    void setStartTime(float64 aStartTime) noexcept { m_startTime = aStartTime; }
        void setStopTime( float64 aStopTime) noexcept { m_stopTime = aStopTime; }
    void setNumTimeStep(uint32 aNumTimeStep) noexcept { m_NumTimeStep = aNumTimeStep; }
        float64 getStartTime() const noexcept { return m_startTime; }
    float64 getStopTime() const noexcept { return m_stopTime; }
    float64 getTime() noexcept { return m_startTime += getTimeStep(); }
    void setTimeStep(const float64 aTimeStep) noexcept { m_TimeStep = aTimeStep; }
    float64 getTimeStep() noexcept { return m_TimeStep; }
    bool useFixedTimeStep() noexcept { return m_UseFixedTimeStep; }
 
        // Pause the simulation
//      void paused();
//      bool isPaused();
          bool onStart();
          void registerSimulator( std::shared_ptr<Sfx::Simulator> aSim) { m_DamSim = aSim;}
          void setTolerance( float32 aTolerance) { m_Tol = aTolerance;}
          float32 getTolerance() { return m_Tol;}
          // Returns the current time of the simulation (temporary fix)
          //float64 getCurrentTime() const { return m_DamSim->getCurrentTime();}
          std::shared_ptr<Sfx::Simulator> getSimulator() const { return m_DamSim;} // temporary fix, will be removed
          void setNujicAlphaCoeff(float64 aAlphaCoeff) { m_alphaCoeff = aAlphaCoeff;}
            float64 getNujicAlphaCoeff() const { return m_alphaCoeff; }
          inline float64 getCFL() const noexcept  { return m_CFL;}
          void setCFL( const float64 aCFL) noexcept  { m_CFL = aCFL;}
            bool useFriction() const noexcept { return m_useFriction; }
            void setUseFriction(bool aUseFriction) noexcept  { m_useFriction = aUseFriction; }
            bool useFlatBed()     const noexcept  { return m_useFlatBed; }
            void setUseFlatBed(bool aUseFlatBed) noexcept { m_useFlatBed = aUseFlatBed; }
            bool isUnitWidth()    const noexcept  { return m_isUnitWidth; }
            void setManningCoeff(float64 aNcoeff) noexcept { m_frictionValue = aNcoeff; }
            float64 getManningCoeff() const noexcept { return m_frictionValue; }
 
            void setUseSourceTerms(bool aUseSrcTerms) noexcept { m_useSourceTerms = aUseSrcTerms; }
            bool getUseSourceTerms() const noexcept { return m_useSourceTerms; }
            bool usePressure() const noexcept { return m_usePressure; }
            void setUsePressure(bool aUsePressure) noexcept { m_usePressure = aUsePressure; }
            void setUseReconstruction(bool aUseReconstr) noexcept { m_useReconstruction = aUseReconstr; }
            bool useReconstruction() const noexcept { return m_useReconstruction; }
            bool isRunning()     const noexcept { return m_simRunning; }
            void setRunning(bool aIsRunning = true) { m_simRunning = aIsRunning; }
            void startSimulation() noexcept { m_simRunning = true; }
            void stopSimulation() noexcept { m_simRunning = false; }
            void  setNbIterationsMax(uint32 aNumOfIterMax) noexcept { m_NbIterMax = aNumOfIterMax; }
            uint32 getNbIterationsMax() const noexcept { return m_NbIterMax; }
            void  incrIteration() noexcept { ++m_NbIterations; }
            uint32 getNbIterations() const noexcept { return m_NbIterations; }
            void setNbIterations(uint32 aNumOfIterations) noexcept { m_NbIterations = aNumOfIterations; }
            void saveScenario() {/*not implemented yet*/ }
            void loadSections( std::string_view aFileName = "SectionIni.txt") {/*not implemented yet*/ }
            void setDBdataType( DamBreakData::eDataTypes aType) noexcept
            {
                // when loading simulation set parameters from reading file
                m_dbDataType = aType;
            }

            float64 getPhi0() const noexcept { return m_phi0; }
            float64 getPhi1() const noexcept { return m_phi1; }
            void setPhi1(float64 aPhi1) noexcept { m_phi1 = aPhi1; }
            void setPhi0(float64 aPhi0) noexcept { m_phi0 = aPhi0; }
 
            // default set to E. McNeil data type
            DamBreakData::eDataTypes getDBdataType() const noexcept { return m_dbDataType; }
 
            // that's what we need in many places (temporary fix, this class will be re-factored)
            // depemnds on array type, need to fix that
            std::string getDBdataTypeStr() const noexcept
            {
                if (DamBreakData::eDataTypes::hudson == m_dbDataType)
                {
                    return std::string{ "d=1 [0,1] [0:99]" };
                }
                else
                {
                    return std::string{ "d=1 [0,1000] [0:99]" };
                }
            }

          std::string getAlgorithmName() const { return m_MethodName;}
          void setMethodName( const std::string& aMethodName) { m_MethodName = aMethodName;}
            std::string getPtrFluxAlgorithmName() const noexcept { return m_methodName; }
            void setPtrFluxAlgorithmName(const std::string& aMethodName) { m_methodName = aMethodName; }
            CalculFF getPtr2FAlgorithm( const std::string& aMethodName);
            CalculFF currentAlgorithm() const { return m_Algorithm; }
            mapFluxSchemeName getMapSchemeName() const { return m_ptr2FuncAlgo; }
            const std::vector<float64>& getBottom()  const { return std::vector<double>(101);/*m_Z*/; }
            //const std::vector<float64>& getManning() const { return std::vector<double>(101); /*m_N*/; }
        //  void readParams();
            void setupEnvironment();
            void printParamOfRun() const;
            void setNbSections(uint32 aNbSections) noexcept { m_NbSections = aNbSections; }
            uint32 getNbSections() const noexcept {return m_NbSections;}
            void setSectionType(dbpp::SectionFlow::eSectionType aSectype) noexcept { m_sectionType = aSectype; }
            dbpp::SectionFlow::eSectionType getSectionType() const noexcept { return m_sectionType; }
            void setDomainExtent(std::pair<float64, float64> aDomainExt) noexcept { m_domainExtent = aDomainExt; }
            std::pair<float64, float64> getDomainExtent() const noexcept { return m_domainExtent; }
            void setBottomType( const eRiverBedType aBottomType) noexcept { m_bottomType = aBottomType; }
            eRiverBedType getBottomType() const noexcept { return m_bottomType; }
            void setFrictionValue(float64 aFrictionType) noexcept { m_frictionValue = aFrictionType; }
            float64 getFrictionValue() const noexcept { return m_frictionValue; }
            void setBCType( const ePhysicalBCType aBCType) noexcept { m_physBCType = aBCType; }
            ePhysicalBCType getBCType() const noexcept { return m_physBCType; }
            void setInitialWaveForm(eInitialWaveProfile aType) noexcept { m_InitialWaveform = aType; }
            eInitialWaveProfile getInitialWaveForm()  const noexcept { return m_InitialWaveform; }
            void registerDamBreakSystem( const Testvs19::DamBreakSystem* aDbSys)
                { m_dbSystem = aDbSys; }

            std::vector<float64> getWaterDepth() const { return m_dbSystem->getH(); }
      private :
          std::shared_ptr<Sfx::Simulator> m_DamSim; 
          CalculFF m_Algorithm;                     
            DamBreakData::eDataTypes m_dbDataType;    
          // Initial profile type 
          //enum eInitialType{SINE, STEP};         initial solution profile 
        //  eInitialWaveProfile m_InitialWaveform;  /**< */        // sine function, step, etc.
          float32  m_Tol;                           
          float64  m_CFL;                           
            float64 m_phi0;                           
            float64 m_phi1;                           
    //    sint32   m_ReadPar;            /**< Flag for reading the parameters from a file*/
          uint32   m_NumTimeStep;                   
        //  uint32   m_NumIterations;
            uint32   m_NbSections;                    
          float64  m_TimeStep;                      
          uint32   m_StateVarCount;                 
          bool     m_useFriction;                    
          bool     m_usePressure;        
            bool     m_useSourceTerms;     
            bool     m_useReconstruction;   
          int32    m_NbIterations;        
          int32    m_NbIterMax;           
          bool     m_UseFixedTimeStep;   
            float64  m_startTime;           
            float64  m_stopTime;             
          float64  m_MaxTimeStep;         
          float64  m_LastTime;            
            float64  m_frictionValue;       
            float64  m_alphaCoeff;          
          std::string m_MethodName;      
          std::string m_StVenantOut;     
          std::map<std::string, CalculFF> m_ptr2FuncAlgo;  
        //  ListofSectionsFlow m_listsectionFlow{ nullptr };
            const Testvs19::DamBreakSystem* m_dbSystem{ nullptr };
            bool     m_useFlatBed;        // flag (default value is true)
            bool     m_isUnitWidth;       // section of unit width (default value is true)
        // default value is trues
    //      bool m_useFinalreport;
            // ...
            bool m_simRunning;
            // measurement on the physical system
        //  bool m_performMeasurement;
 
            // number of physical measurement on the physical system
            //int32 m_numberOfMeasurement;
 
            // Name of the current method
            std::string m_methodName;
            eInitialWaveProfile m_InitialWaveform;
            ePhysicalBCType m_physBCType;
            eRiverBedType m_bottomType;
            dbpp::SectionFlow::eSectionType m_sectionType;;
            std::pair<float64,float64> m_domainExtent;
            std::pair<float64,float64> m_dambreakExtent;
         // void LoadData( std::string_view aFileName);
    };
} //End of namespace