Testvs19_Numethod_f.h

Go to the documentation of this file.

#pragma once
 
// SxBase19 includes
#include "include/Sfx_Directory.h"
// DamBreak include
#include "../dbpp_NumericalMethod.h"
#include "../../SfxBase/Sfx_DbgLogger.h"
#include "../../SfxBase/Sfx_PhysicalAlgorithm.h"
#include "../../SfxBase/Sfx_PhysicalConfigure.h"
#include "../../SfxBase/Sfx_PhysicalMeasurement.h"
#include "../../include/Sfx_Simulation.h"
#include "../../include/Sfx_SimulationMgr.h"
 
namespace Testvs19 
{
  class Numethod_f : public dbpp::NumericalMethod
  {
  public:
    Numethod_f( dbpp::SweRhsAlgorithm* aRhsAlgo)
    :  m_rhsAlgo{ aRhsAlgo },
     //  m_phySystem{ nullptr },
      m_U12{ nullptr,nullptr },
      //   m_U12p{ nullptr,nullptr },
      m_dbgFile{ true }
    {}

    void initialize( const std::shared_ptr<dbpp::FiniteVolumeDiscretization>& aGblDiscr) override final
    {
      // PhysicalAlgorithm w_phyAlgo;
      if (nullptr == w_phySystem)
      {
        // use of factory to create these simulation types
      //  IPhysicalConfigure = new PhysicalConfigure
       // IPhysicalMeasurement = new PhysicalMeasure
       // 
        // physical system (made of physical objects)
        w_phySystem = new dbpp::PhysicalSystem;
        w_phyConfig->configure( w_phySystem/*, aGblDiscr*/);
      }
    }

    void mainLoop( const std::shared_ptr<dbpp::FiniteVolumeDiscretization>& aGblDiscr,
      Sfx::SfxTimePrm& aTimePrm) override final
    {
 
      w_fileDatStore.open();
      if (!w_fileDatStore.isOpen())
      {
        std::cerr << "Couldn't open data store -- Stop simulation\n"; // debugging purpose
      }
 
      // TODO 
      //  Time stepping (cfl criteria) 
      //  Physical boundary condition
      //  Set time parameters (start,stop) ok its done since we retrieve from arg
      //  Simulaton setimestep
      //  
 
      std::cout << "Simulation initial time is: " << aTimePrm.getStartTime() << "\n";
      std::cout << "Simulation final time is: " << aTimePrm.getFinalTime() << "\n";
      std::cout << "Simulation delta (time step) is: " << aTimePrm.Delta() << "\n";
 
      // ================================================
      //         logical time loop SfxTimePrm
      // ================================================
 
      while (!aTimePrm.finished()) // base on stop time value
      {
#if _DEBUG
        // Writing some debug results to file for visualization (DamBreak++ visual debugger)
        Sfx::DbgLogger* w_dbgLog = Sfx::DbgLogger::instance();
        //    auto chk = Sfx::Directory::getWrkDbgFile();
        w_dbgLog->open(Sfx::Directory::getWrkDbgFile());
        if (!w_dbgLog->isOpen())
        {
          std::cout << "Couldn't open file for writing debug info\n";
        }
        // shall use the time prm method "numberStepNo()" something like that!!
        // Simulation is model of a bean ()
        w_dbgLog->write2file(std::string(""), Sfx::SimulationMgr::getSingleton().getNbIterations() + 1);
        w_dbgLog->close();
#endif
        // calculate(physical system, simulation)
        // Design Note
        //  Physical algorithm contains data and information to simulate at each time
        //  step the St-Venant equations system (wave profile) wawe propagation.
        // See advance method below for what it should be
        //
        //  Physical algorithm contains information or components to compute RHS
        //  actually it contains the numerical representation of the math equations??
        //  is that make sense?? neded to think about that!!!
        w_phyAlgo->calculate(w_phySystem, /*SweRhsAlgorithm* aRhsAlgo,*/Sfx::Simulation::getSingleton()); // does one time step??
        m_rhsAlgo->calculate(w_phySystem->getStateVector(), aGblDiscr); //???
 
        // take measure on physical system such as energy, velocity, ...
        // we measure wet area and discharge of the cross-section 
        w_phyMeasure->take(w_phySystem);
 
        // save measure to data store to eventually do some manip 
        // try-catch file open exception (take a look at Swe proto version)
        // create a final report (simulation result)
        w_fileDatStore.save( &w_phyMeasure, Sfx::Simulation::getSingleton());
 
        std::vector<double> w_A; w_A.reserve(w_phySystem->getStateVariables().size());
        std::vector<double> w_Q; w_Q.reserve(w_phySystem->getStateVariables().size());
 
        namespace vws = std::views; // ranges library
        for( const auto& w_pairVar : w_phySystem->getStateVariables() | vws::values)
        {
          // should I use std::move? or std::forward?
          w_A.push_back(w_pairVar.first.value());
          w_Q.push_back(w_pairVar.second.value());
        }
 
        auto w_CFL = Sfx::SimulationMgr::getSingleton().getCFL();
        
        auto w_dt = w_CFL * TimeStepCriteria::timeStep(w_A, w_Q);
 
        // set simulation time step
        Sfx::Simulation::getSingleton().setSimulationTimeStep(w_dt);
        aTimePrm.increaseTime(w_dt); // t1=t0+dt;
 
        std::cout << "Finished time step at iteration " <<
          Sfx::SimulationMgr::getSingleton().getNbIterations() + 1 << "\n";
 
        // increase iteration by 1 (should be done in the Simulato::run())
        Sfx::SimulationMgr::getSingleton().incrIteration();
 
        // create a report for end result (yes)
        //Final report (create the final report)
        std::cout << "End of an iteration\n";
      }//while-loop
 
      // close data store  
      w_fileDatStore.close();
 
      if (w_phySystem)
      {
        delete w_phySystem;
        w_phySystem = nullptr;
      }
    }
 
    //  void setCalculFFAlgo(CalculFFAlgo aOldAlgo) { m_oldAlgo = aOldAlgo; }
      // returns a string representation of the class
   //   std::string toString() override final { return std::string{ "EMcNeil1d_f" }; }

    void setDebugFileON(bool aFileOn) { m_dbgFile = aFileOn; }
    bool isDebugFileON() const { return m_dbgFile; }
  protected:
    // Want to re-implement 
    void advance( const dbpp::PhysicalSystem* aPhysys, 
      const dbpp::FiniteVolumeDiscretization* aGblDiscr, double aDt) //override final;
    {
#if _DEBUG
        // Writing some debug results to file 
        Sfx::DbgLogger* w_dbgLog = Sfx::DbgLogger::instance();
        auto chk = Sfx::Directory::getWrkDbgFile();
        w_dbgLog->open(Sfx::Directory::getWrkDbgFile());
        if (!w_dbgLog->isOpen())
        {
          std::cout << "Couldn't open file for writing debug info\n";
        }
#endif
 
        // create an time stepper
        dbpp::NujicIntegrator w_twoStepsIntegrator;
        // NOTE use vectorField ctor to convert from StateVector
      //  auto statVec = aPhysys->getStateVector().first->values().to_stdVector();
 
        w_twoStepsIntegrator.setInitialState(w_phySystem->getStateVector());
 
        // just a check (2 impl of the SweRhsAlgorithm)
        //auto w_sweRhsAlgo = aGblDiscr->numericalMethod()->getSweRhsAlgorithm();
        //assert(nullptr != w_sweRhsAlgo);
        //w_sweRhsAlgo->calculate(aPhysys->getStateVector(), aGblDiscr);
 
        // call physical algorithm??? compute rhs?? 
        w_phyAlgo->calculate(w_phySystem, Sfx::Simulation::getSingleton());
 
        if (auto w_rhs = dynamic_cast<dbpp::TestRhsImpl*>(m_rhsAlgo); w_rhs != nullptr)
        {
          m_rhsAlgo->calculate(w_phySystem->getStateVector(), aGblDiscr);
        }
        else { // RhsPtr2FuncFlux (original algorithm wrapped (DamBreakSim::run()) 
               // in the ... to be completed)
          assert(nullptr != dynamic_cast<dbpp::RhsPtr2FuncFlux*>(m_rhsAlgo)); //sanity check
          m_rhsAlgo->setBC(aGblDiscr->gamma());
          m_rhsAlgo->calculate(aPhysys->getStateVector());
        }
        //m_rhsAlgo->calculate( aPhysys->getStateVector(), aGblDiscr);   new algorithm using BaseRhsAlgorithm and 
        using namespace dbpp::NujicIntegrator::eIntegratorStep;
        w_twoStepsIntegrator.setIntegratorStep(dbpp::NujicIntegrator::eIntegratorStep::predictor);
        w_twoStepsIntegrator.step(m_rhsAlgo, aDt); // time-step algo
        const auto w_halfStep = w_twoStepsIntegrator.getMidState(); // deprecated (debugging)
 
#if _DEBUG // writing to debug for visualization
    // write to log file for debugging purpose
        w_dbgLog->write2file_p({ static_cast<unsigned>(w_halfStep.first->values().size()),
          std::vector(std::begin(w_halfStep.first->values()), std::end(w_halfStep.first->values())),
          std::vector(std::begin(w_halfStep.second->values()),std::end(w_halfStep.second->values())) });
#endif
 
        if (auto w_rhs = dynamic_cast<TestRhsImpl*>(m_rhsAlgo); w_rhs != nullptr)
        {
          m_rhsAlgo->calculate(w_twoStepsIntegrator.getMidState(), aGblDiscr);
        }
        else { // RhsPtr2FuncFlux (original algorithm wrapped (DamBreakSim::run()) 
               // in the ... to be completed)
          assert(nullptr != dynamic_cast<dbpp::RhsPtr2FuncFlux*>(m_rhsAlgo)); //sanity check
          m_rhsAlgo->calculate(w_twoStepsIntegrator.getMidState());
        }
        //m_rhsAlgo->calculate( w_halfStep, aGblDiscr);   new algorithm using BaseRhsAlgorithm and 
 
        w_twoStepsIntegrator.setIntegratorStep(NujicIntegrator::eIntegratorStep::corrector);
        w_twoStepsIntegrator.step(m_rhsAlgo, aDt);
        // i am not sure if a numerical method shall return a state
        // for now will do but i have to think about that
        m_U12 = w_twoStepsIntegrator.getCurrentState(); // update values
 
#if _DEBUG
    // write to log file for debugging purpose
        w_dbgLog->write2file({ static_cast<unsigned>(m_U12.first->values().size()),
          std::vector(std::begin(m_U12.first->values()),std::end(m_U12.first->values())),
          std::vector(std::begin(m_U12.second->values()),std::end(m_U12.second->values())) });
        // closing file debug info
        if (w_dbgLog->isOpen())
        {
          w_dbgLog->close();
        }
#endif
 
    }
  private:
    dbpp::SweRhsAlgorithm* m_rhsAlgo;
   // PhysicalSystem* m_phySystem;  /**< Physics System */
    StateVector m_U12;            
  //    StateVector m_U12p;           /**< state vector for mid time step*/
    bool m_dbgFile;               
    // prototyping ne wimplementation of numrical method
    dbpp::PhysicalSystem* w_phySystem{ nullptr }; // = new PhysicalSystem;                                                  
    Sfx::PhysicalConfigure* w_phyConfig{ nullptr };          //physics configuration (set initial condition)
    Sfx::PhysicalMeasurement* w_phyMeasure{ nullptr };       // physical quantities measured on the system
    Sfx::PhysicalAlgorithm* w_phyAlgo{ nullptr };            // ...
    Sfx::FileDataStore w_fileDatStore;           // save measure to the data store
  };
}// End of namespace