Testvs19_Wave1DSimulator.h

Go to the documentation of this file.

 
#pragma once
 
// C/C++ includes
#include <stdio.h>
//#include <string.h>
#include <string>
#include <tuple>
#include <utility>
#include <filesystem>
// stl include
#include <list>
// numeric include
#include <valarray>
// SfxBase19 library includes
#include "include/Sfx_DefineTypes.h"
#include "include/Sfx_Simulator.h"
#include "include/Sfx_Observer.h"
 
// forward declarations
namespace Sfx { class WaveFunc; }
namespace dbpp { 
    class DamBreakProblem; 
    class ListSectionsFlow;
} 
 
namespace Testvs19
{
    //  Reference
  //    "How To Export C++ Classes From a DLL", Alex Blekhman, 13 nov 2012
  //     Code Project web site
    //
    //  Very important to read and understand this article, because it's breath and butter 
    //   of COM approach (create a factory that return pointer to base abstract type).
    //   Wave1DSimulator is nothing else than a POM/COM which is not exported. Actually it 
    //   implements an interface (pure abstract class) like jb_ClassDll 
    
    
    class Wave1DSimulator : public Sfx::Simulator, 
        public virtual Sfx::Observer,
        public std::enable_shared_from_this<Wave1DSimulator>
    {
        using WaveFuncPtr = std::shared_ptr<Sfx::WaveFunc>;
        using ListSectPtr = std::shared_ptr<dbpp::ListSectionsFlow>;
    public:
        enum class eIC 
        {
            EMcNeil=0, 
            Hudson = 1 
        };

        enum class eSimulationState 
        {
            running=0, 
            pause=1,   
            stop=2     
        };
    public:
        Wave1DSimulator( int aNbIterationsMax=50, double aCFL=0.6);
        Wave1DSimulator( const Wave1DSimulator& aOther) = delete;
        Wave1DSimulator&operator= (const Wave1DSimulator& aOther) = delete; 
        void run() override final;
        bool init() override final;
        void unInitialize() override final {/*nothing to do*/ }
        virtual void timeLoop(); 
        void setActiveAlgortihm( std::string aAlgoName) noexcept { m_activeAlgo = aAlgoName;}
    std::string getactiveAlgorithm() const noexcept { return m_activeAlgo;}
        void setValidationDir( const std::filesystem::path& aValidationDir) noexcept  
        {m_validationDir = aValidationDir;}

        std::filesystem::path getValidationDir() const noexcept { return m_validationDir;}
        void setSaveResult2File( bool saveResult) noexcept { m_saveResult2File=saveResult;}
        bool isSaveResult2File() const noexcept { return m_saveResult2File;}
        void setIterationNumberMax( unsigned aNumMaxIter) noexcept {m_NumberIterationsMax=aNumMaxIter;}
        uint32 getNumberIterationsMax() const noexcept { return m_NumberIterationsMax;}
        void setCFL( float64 aCFl)  noexcept {m_CFL=aCFl;}
        float64 getCFL() const noexcept {return m_CFL;}
        void setPhi1(float64 aPhi1) noexcept {m_Phi1=aPhi1;}
        float64 getPhi1() const noexcept {return m_Phi1;}
        void setPhi0( float64 aPhi0) noexcept {m_Phi0=aPhi0;}
        float64 getPhi0() const noexcept{return m_Phi0;}
    // not usre about this one
        float64 getFinalTime() const { return m_finalTime;}
    // not sure still needed (???)
        void update() override final;
        void solveProblem( const dbpp::DamBreakProblem& aDBprob);
        std::valarray<float64> getH() const noexcept 
        { 
            return std::valarray<float64>(m_waveDepthProfile.data(), m_waveDepthProfile.size()); 
        }

        std::shared_ptr<Wave1DSimulator> sharedPtrTo() { return shared_from_this(); }
    private:
        WaveFuncPtr m_H{nullptr};            
        WaveFuncPtr m_I{ nullptr };          
        ListSectPtr m_ListSectFlow{nullptr}; 
        std::vector<float64> m_waveDepthProfile; 
        float64 m_CFL;    //  deprecated 
        std::string m_activeAlgo;  
        std::filesystem::path m_validationDir;  
        bool m_saveResult2File;   
        unsigned int m_NumberIterationsMax; 
        float64 m_Phi1;     // deprecated
        float64 m_Phi0;     // deprecated
        float64 m_finalTime; 
        eIC m_IC; 
    };
} // End of namespace