Testvs19_DamBreakSystem.h

Go to the documentation of this file.

 
#pragma once
 
#include <list>
// boost include
#include <boost/ptr_container/ptr_vector.hpp>
// SfxBase19 lib includes
#include "include/Sfx_PhysicalSystem.h"
#include "include/Sfx_StateVector.h"
#include "include/Sfx_Observable.h"
// Nov19 package includes
#include "../../Nov_VS2019/dbpp_SectionFlow.h"
#include "../../Nov_VS2019/dbpp_SimulationUtilities.hpp"
#include "../../Nov_VS2019/PhysicsAlgorithm/Testvs19_ListSectionsFlow.hpp"
// BaseNumericlaTypes include 
#include "Sfx/Sfx_NodalValues.h"
 
// forward declaration
namespace Sfx { 
  class Observer;
  class PhysicalObject; 
}
 
namespace Testvs19
{
    class DamBreakSystem final : public Sfx::PhysicalSystem,
      virtual public Sfx::Observable  
    {
        public:
      using ListSectionFlowPtr = std::shared_ptr<ListSectionsFlow<dbpp::SectionFlow>>;
      using vecidx = std::vector<float64>::size_type;
      using pair_vecarr = std::pair<std::vector<float64>, std::vector<float64>>;
      using phystate = pair_vecarr; // state variables (A,Q)
      using value_type = boost::ptr_vector<Sfx::Nodal_Value>::value_type;
      using size_type = boost::ptr_vector<Sfx::Nodal_Value>::size_type;
      using iterator = boost::ptr_vector<Sfx::Nodal_Value>::iterator;
      using const_iterator = boost::ptr_vector<Sfx::Nodal_Value>::const_iterator;
     // using riterator = std::reverse_iterator<iterator>;
    //  using criterator = std::reverse_iterator<const_iterator>;

      iterator begin() { return m_Objs.begin(); }
      iterator end()   { return m_Objs.end(); }
      const_iterator cbegin() const { return m_Objs.begin(); }
      const_iterator cend()   const { return m_Objs.end(); }
      auto rbegin() { return m_Objs.rbegin(); }
      auto rend()   { return m_Objs.rend(); }
      auto crbegin() const { return m_Objs.crbegin(); }
      auto crend()   const { return m_Objs.crend(); }
 
    public:
    explicit DamBreakSystem( std::string aName = "DamBreakSystem");
    void add( Sfx::Object* aNval) override final;
    bool contains( const Sfx::Object* aN2find) override final;
    bool remove( const Sfx::Object* aN2find) override final;
    [[nodiscard]] bool empty() const noexcept override final  { return m_Objs.empty(); }
    size_t size() const override final { return m_Objs.size(); } 
    // Design Note
    // The reason for this, it's becausein the time stepping of 
    // the physical algorithm, predictor step we do not update
    // H(water level), only state variables(A,Q). Then, corrector
    // step we update final state of state variables, but also
    // H (water level). We do it separetly, because the state 
    // variables are updated calling setState(state var).
    void setH() // update list of sections H value
    {
      // consider (unit width and flat bottom)
      std::for_each(m_listOfSections->begin(), m_listOfSections->end(), 
        [*this](dbpp::SectionFlow& aSectionFlow)
      {
        aSectionFlow.setH(std::get<2>(m_Objs[aSectionFlow.getId()].Values()));
      });
 
      // H-Variable 
      // consider (unit width and flat bottom)
      //std::for_each(begin(), end(), [*this](Sfx::Nodal_Value& aPhyObj) 
      //  {
      //     // NOTE considering flat bed Z=0, this is temp fix and must 
      //     // be fix by computing the water depth using utility
      //     // Evaluation_H_fonction_A(A,Z,B=1) unit width 
      //     aPhyObj.Values( std::make_tuple( m_phyState.first[aPhyObj.getIdX().first],
      //       m_phyState.second[aPhyObj.getIdX().first], 
      //       m_phyState.first[aPhyObj.getIdX().first])); // assume Z=0 flat bed
      /*  }
     //     try
      //    {
            // throw an exception
           Sfx::Nodal_Value& w_Nvar =
              dynamic_cast<Sfx::Nodal_Value&>(aPhyObj);
 
            // FIX no choice to do that, since operator[] of Nodal_Value was
            // removed, we have to use this method to modify (A,Q variables)
            // we have already called setState() but we just overwrite it. 
            // modify at this stage state variables (A,Q), H: at final state
            /*w_Nvar.Values(std::make_tuple(m_phyState.first[w_Nvar.getIdX().first],
              m_phyState.second[w_Nvar.getIdX().first], m_phyState.first[w_Nvar.getIdX().first]));
 
          catch( std::bad_cast& bc)
          {
            std::cerr << "Bad cast caught :" << bc.what() << "\n";
          }*/
//        }/*Swe::Eval_H_InTerm_A(1., 0.)*/);
    }

    std::vector<float64> getH() const 
    {
      std::vector<float64> w_vecH;
      w_vecH.reserve(m_listOfSections->size());
      for( const auto& w_sect : *m_listOfSections)
      {
        w_vecH.push_back(w_sect.H());
      }
      return w_vecH;
    }

    phystate getPhysicalState() const { return m_phyState; }
    void setPhysicalState( phystate aState)
    {
      // set the physical state variables
      m_phyState = aState;
    }

    Sfx::StateVector getSectionStateVector( vecidx aSectionIdx) const
    {
      return Sfx::StateVector{ m_phyState.first[aSectionIdx],
        m_phyState.second[aSectionIdx] };
    }

    void update() // update nodal values
    {
       // consider (unit width and flat bottom)
      std::for_each(begin(), end(), [*this](Sfx::Nodal_Value& aPhyObj)
      {
        // NOTE considering flat bed Z=0, unit width 
        aPhyObj.Values( std::make_tuple(m_phyState.first[aPhyObj.getIdX().first],
          m_phyState.second[aPhyObj.getIdX().first], //assume Z=0 flat bed
          dbpp::Evaluation_H_fonction_A(m_phyState.first[aPhyObj.getIdX().first],0.,1.))); 
      });
    }

    ListSectionFlowPtr getListSectionFlow() const { return m_listOfSections; }
 
    //
    // Observeable Interface
    //  

    void attach(Sfx::Observer* aObs2Attach) override final;
    void detach(Sfx::Observer* aObs2Detach) override final;
    void notify() override final; 
 
    private:
    std::string m_name;                             
    phystate m_phyState;                             
    ListSectionFlowPtr m_listOfSections{ nullptr }; 
    // pointer container for reference semantic (Nodal_Value)
    //boost::ptr_vector<Sfx::Object> m_Objs;
    boost::ptr_vector<Sfx::Nodal_Value> m_Objs;     
    std::list<Sfx::Observer*> m_listObs;            
    };
}// End of namespace