DamBreakSim.h

Go to the documentation of this file.

 
#pragma once
 
// File stream 
#include <fstream>
#include <filesystem> //C++17 new feature
// STL container
#include <valarray>
#include <vector>
// VS19 include
#include "../Nov_VS2019/SimulationConfig.h"
// SfxBase19 includes
#include "include/Sfx_TimePrm.h"
#include "include/Sfx_Utility.h"
#include "include/Sfx_Simulator.h"
// May 2015 include
//#include "../May_VS2015/DamBreakData.h"
#include "../SfxBase/Sfx_DamBreakData.h"
// VS2019 includes
#include "../Nov_VS2019/dbpp_ListSectionsFlow.h"
 
#define SFX_DEBUG 0 // deprecated, set in the visual studio preprocessor
 
// IMPORTANT (Nov 24)
// this cause an error "error C2872: 'byte': ambiguous symbol" see comment below 
// The issue is that, since using namespace std imports the entire std namespace into the top-level one, 
// it is like defining stuff there, including the new byte type from C++17, then Windows headers also define byte so 
// byte is ambiguous because of the name collision. In general, you should not define anythng before including headers as it may cause such issues.
//using namespace std; don't do that in a header file like thsi, included by other files it mess everything

class DamBreakSim : public Sfx::Simulator,
    public std::enable_shared_from_this<DamBreakSim>
{ 
  public:
        enum class eInitialWaveProfile
        {
            SINE = 0, 
            STEP = 1  
        };
  public:
      DamBreakSim();

    ~DamBreakSim() = default;

    DamBreakSim(const DamBreakSim & aOther) = delete;

    DamBreakSim& operator= (const DamBreakSim & aOther) = delete;
 
      //
      // Simulator interface (base class)
      //

      void run() override final;
 
        bool init() override final; 

        void unInitialize() override final {/*nothing to do*/ }

      void dump( const std::filesystem::path& aFilePath /*const char* aFilename*/);

     // void setH( float64 aValue);
      const DBSArrayType getH() const noexcept { return mH;}

      void setPhi1( float64 aValue) { mPhi1 = aValue;}
      void setPhi0( float64 aValue) { mPhi0 = aValue;}

      const float64 getPhi1() const { return mPhi1;  }
      const float64 getPhi0() const { return mPhi0;  }
 
      // ---------------REFACTORING--------------------------------
      //   All these methods shall be managed by the Simulation Manager
     //     

      inline float64 getCFL() const          { return mCFL;}
             void    setCFL( float64 aOther) { mCFL = aOther;}  
        float64 getCurrentTime() const { return mTime;} 
      float64 getTimeStep() { return m_Tip.Delta();}
      uint32 currentIteration() { return m_Tip.getTimeStepNo();}
        std::string getMethodName() { return mMethodName;}
      void setMethodName( const std::string& aMethodName)
        { 
            if( !mMethodName.empty())
            {
                mMethodName.clear();
                mMethodName = aMethodName;
            }
        }

        void setWorkingDir( std::filesystem::path aProjectPath) { m_currWrkDir = aProjectPath; }
        bool isFlatBedTopography() const { return true; }
 
        //eInitialWaveProfile getWaveInitialProfile() { return m_initialWaveProfile; }
        void setInitialCnd( eInitialWaveProfile aType) { m_initialWaveProfile = aType; }
        eInitialWaveProfile getInitialType()  const { return m_initialWaveProfile; }
        std::shared_ptr<DamBreakSim> getDamBreakSim() { return shared_from_this(); }
    private:
 
        DBSArrayType mU1;  
        DBSArrayType mU2;  
        DBSArrayType mH;   
        DBSArrayType mX;   
        DBSArrayType mZ;   
        DBSArrayType mN;   
    float64      mDx;  
 
    //  StateVariables m_CurrentState;   /**< state variables*/
      int32          mNbSections;      
      int32          mReadpar;         
     // int32     mConditionArret;                          
     // uint32    mNbIterations;            //
      int32     mNbIterMax;             
     // bool       mUseFixedTimeStep;  //
     // float32 mMaxTimeStep;       //
     // float32 mLastTime;          //
    Sfx::SfxTimePrm m_Tip;                
 
      // flag for ??? 
      bool   mSimRunning;         
      bool   mUseFriction;       
    //  bool   mUseGravity;        /**<   */
      bool   mUseCompare;        
  
    float64 mCFL;               
 
        // Time parameters
      float64 mTime;              
 
        // Section width set to unity
      float64 B;
 
    float64 mL;                   
 //   int32 N;                   /**< number of grid points  */ 
//    float64 uMax;                /**<  maximum wave amplitude */ 
    float64 mDt;                  
    //float64 CFLRatio;            /**<  Courant-Friedrichs-Lewy ratio tau/h */ 
      float64 mS0am;                
      float64 mS0av;                
      float64 mPhi1;                
      float64 mPhi0;                 
 
//    enum {SINE, STEP};        /**< initial solution profile */
 //   int32 initialWaveform;    /**< sine function, step, etc. */
        eInitialWaveProfile m_initialWaveProfile; 
        std::ofstream mFileRes;         
        //const char* mStVenantOut;
        std::string mStVenantOut;      
    //const char* mMethodName; 
        std::string mMethodName;       
        std::filesystem::path m_currWrkDir;   
      // Compute the time step for numerical stability
     // float64 calculateDt();
      // Physical boundary condition
      void ImposePhysCnd();
      // Save intermediate result in a file
      void saveResult();
        Sfx::DamBreakData m_dbData; 
        // list of cross-section 
        dbpp::ListSectionsFlow m_listDamBreak;
    public:
      void profilecmp( float64 aTime);
 
    private:
//    void plotCurve( char* aOutFileName, const char* aInFileName = nullptr) const;

      //void (*CalculFF)(       ArrayType & aFF1,      ArrayType & aFF2, 
         //                 const ArrayType & aU1, const ArrayType & aU2);
 
        //using CalculFF = void (*)(       DBSArrayType& aFF1, DBSArrayType& aFF2,
        //                           const DBSArrayType& aU1, const DBSArrayType& aU2);
 
        // Pointer 2 function
        CalculFF m_calculFF;
};