dbpp_PhysicalSystem.h

Go to the documentation of this file.

#pragma once
 
// STL includes
#include <map>
#include <vector>
// SfxBase19 includes
#include "include/Sfx_UniversalConstants.h"
#include "include/Sfx_StateVariables.h"
#include "include/Sfx_Observable.h"
// SfxBase package DamBreak++
#include "../SfxBase/Sfx_DamBreakInitialCnd.h"
#include "dbpp_ListSectionsFlow.h"
#include "dbpp_EMcNeilPhysBC.h"
// BaseNumTypes library include
#include "Sfx/Sfx_StateVectorField.h"
 
namespace dbpp 
{
  class PhysicalSystem : public virtual Sfx::Observable
  {
    enum class ePhysicalSystemType
    {
      halfOpen=0,  
      close=1      
    };
 
  public:
    using pairStateVar = std::pair<Sfx::StateVariables/*A*/, Sfx::StateVariables/*Q*/>;//temporary fix
    
    using SectionStateVar = std::map<unsigned int/*section id*/, pairStateVar /*section state var*/>;

    using StateVectorPair = Sfx::StateVectorField::StateVector; // U=(A,Q)
    
    template<typename... Params>
    struct BCNodeConstraint
    {
      std::tuple<unsigned, Params.../*node values*/> values;
    };
  public:
    PhysicalSystem();   
    virtual void add( const SectionFlow& aSectFlow2Add);
    virtual void add( SectionFlow&& aSectFlow2Add);
    // No don't do that, disable move semantic!! return by copy 
    // C++17 "copy elision is mandatory" no more temporary since 
    // the prvalue "materialize" to xvalue (eXpiring value)
    SectionStateVar getStateVariables() const noexcept { return m_stateVarMap; }
    SectionStateVar& getStateVariables()      noexcept { return m_stateVarMap; }
    Sfx::StateVectorField getStateVector() const;
    // what about an iterator instead of returning the list of section flow
    const ListSectionsFlow& getSectionList() const noexcept { return *m_listSections; }
          ListSectionsFlow& getSectionList()       noexcept { return *m_listSections; }
    std::shared_ptr<ListSectionsFlow>& getListSectionsPtr()
    {
      return m_listSections;
    }

    std::shared_ptr<ListSectionsFlow> getListSectionsPtr() const
    {
      return m_listSections;
    }

    [[nodiscard]] bool empty() const noexcept { return m_listSections->isEmpty(); }
    ListSectionsFlow::vec_sizetype size() const noexcept { return m_listSections->size(); }
 
     // Design Note
     //  Shall implement this method as template for container
     //  different signature or niversal reference??
     //void update(CONT&& aCont) {...}

    void update( const Sfx::StateVectorField& aStateVector);
    void update( const std::valarray<float64>& aVarr1,
       const std::valarray<float64>& aVarr2);
    void update( std::valarray<float64>&& aVarr1,
       std::valarray<float64>&& aVarr2);
    void setRightPhysicalBnd( std::tuple<uint32, float64, float64, float64> aRightPhyBnd)
    {
      m_bcNodeDownstream = std::make_from_tuple<PhyBCNdlConstraint>(aRightPhyBnd);
    }

    PhyBCNdlConstraint getRightPhysicalBnd() const noexcept
    {
      return m_bcNodeDownstream;
    }

    void setLeftPhysicalBnd( std::tuple<uint32, float64, float64, float64> aLeftPhyBnd)
    {
      m_bcNodeUpstream = std::make_from_tuple<PhyBCNdlConstraint>(aLeftPhyBnd);
    }

    PhyBCNdlConstraint getLeftPhysicalBnd() const noexcept
    {
      return m_bcNodeUpstream;
    }

    bool isSystemFictionLess() const noexcept { return true; }
    bool useUnitWidthGeom() const noexcept { return true; }
    bool useFlatEarth() const noexcept { return true; }
    void PhysicalSystemBndType() const noexcept{/*half-open*/ } // left tied, right open 
    static ListSectionsFlow createSectionFlow( const Sfx::DamBreakData& aDbdata)
    {
      // list of unit section (nbSections is propbaly equal to 101)
      ListSectionsFlow w_listSectF; //{ static_cast<ListSectionsFlow::vec_sizetype>(aDbdata.nbSections()) };
      w_listSectF.reserve(aDbdata.nbSections());
 
      // create the list of sections flow for the current simulation
      auto sectId = 0u;
      Sfx::DamBreakInitialCnd w_ic{ aDbdata };
      // give return value a name to use it as an 'lvalue' (keep non-constness of return value)
      auto&& w_xcoordBeg = w_ic.Xcoord().begin(); // return a temporary (prvalue: pure reading value) 
 
      // reference to temporay objects always extends their lifetime
      static_assert(!std::is_same_v<decltype(w_xcoordBeg),std::ranges::dangling>); // check for dangling iterator
      static_assert(std::is_same_v<decltype(w_xcoordBeg),std::vector<float64>::iterator&&>);  // type (rvalue ref)
      static_assert(std::is_same_v<decltype((w_xcoordBeg)), std::vector<float64>::iterator&>); // value category (lvalue ref)
      for( auto w_sectH : w_ic.Hvalues()) 
      {
        // unit width as default and Manning coefficient is zero (default value)
        w_listSectF.push_back(SectionFlow{ sectId,*w_xcoordBeg++,w_sectH }); // yield no dangling iterator
      }
 
      return w_listSectF;
    }
 
    //  Observable interface
    
    void attach(Sfx::Observer* aObserver) override final;
    void detach(Sfx::Observer* aObserver) override final;
    void notify() override final;
  private:
    int32 m_nbSectionsFlow = Sfx::DIM::value;         
    std::shared_ptr<ListSectionsFlow> m_listSections; 
    SectionStateVar m_stateVarMap;                    
    // Design Note
    // not too sure yet if it should be part of the physical system (for now leave it like that) 
    // Usage: node_id,A,Q,H (values)
    //  auto w_bndLeftEnd = std::make_from_tuple<Nodal_Value>(std::make_tuple(1,2.,3.2,.4));
    PhyBCNdlConstraint m_bcNodeUpstream;        
    PhyBCNdlConstraint m_bcNodeDownstream;      
    std::list<Sfx::Observer*> m_listOfObserver; 
  };
} // End of namespace