dbpp_RhsPtr2FuncFlux.h

Go to the documentation of this file.

#pragma once
 
// C++ includes
#include <algorithm>
#include <vector>
// VS19 includes
#include "dbpp_SweRhsAlgorithm.h"
#include "dbpp_ListSectionsFlow.h"
#include "dbpp_PhysicalBoundaryCnd.h"
#include "dbpp_HLLegacyFluxAlgorithm.h"
#include "dbpp_SrcNumericalTreatment.h"
// App include
#include "../include/Sfx_SimulationMgr.h"
 
namespace dbpp 
{
  class RhsPtr2FuncFlux final : public SweRhsAlgorithm 
  {
  public:
    ~RhsPtr2FuncFlux();
    // should pass the physical system, retrieve physical boundary condition
    // and list of physical objects under study, section flow (next version) 
    RhsPtr2FuncFlux( std::string aFFname, CalculFF aPtr2Func, const ListSectionsFlow& aSectionList, bool aUsePressure=false);
    RhsPtr2FuncFlux( std::string aFFname, CalculFF aPtr2Func, SrcNumericalTreatment* aSrcTreatment,
    bool aUsePressure);
    void setPhysicalBoundaryCnd( const PhysicalBoundaryCnd& aPhyBnd) override
    {
      m_leftBcNode = aPhyBnd.getLeftEnd();
      m_rightBcNode = aPhyBnd.getRightEnd();
    }

    PhysicalBoundaryCnd getPhysicalBoundaryCnd() const override final
    {
      return PhysicalBoundaryCnd{ m_leftBcNode,m_rightBcNode };
    }

    //void setPtr2FuncAlgo(CalculFF aPtr2Func) override final { m_fluxPtr2Func = aPtr2Func; }

    void setSourceTermDiscr( SrcNumericalTreatment* aSrcDiscr, 
      bool useManningFormula = true) override { m_srcDiscr = aSrcDiscr; }

    std::string getPtr2FuncName() const noexcept { return m_ptr2funcName; }
    SweRhsData<> calculate( const Sfx::StateVectorField& aU) override final; 
    SweRhsData<> calculate( const Sfx::StateVectorField& aU, const ListSectionsFlow& aList);  
    SweRhsData<> calculate(const Sfx::StateVectorField& aU, 
      const std::shared_ptr<FiniteVolumeDiscretization>& aGblDiscr) override final;
    bool useReconstruction() const noexcept override final { return m_ptr2FuncFF.useReconstr(); }
    bool isFrictionLess() const noexcept override final    
    { 
      if( m_srcDiscr!=nullptr)
      {
        return m_srcDiscr->useFriction();
      }
      
      return m_listSections.isFrictionLess(); // depends Manning coeff used in ptr-to-func (need to be adressed)
    }

    bool usePressureTerm() const noexcept override final   { return m_usePressure; }
    bool useSourceTerms() const noexcept override final    { return m_useSourceTerms; }
    bool useIncompleteFlux() const noexcept override final { return m_ptr2FuncFF.usePhysicalInCompleteFlux(); }
    bool usePtr2FuncLegacy() const noexcept override final { return true; }
    bool supportTraitementTermeS2() const { return true; } //???
 
    // list of section flow (return by-value)
    ListSectionsFlow getListSections() const { return m_listSections; }
  private:
    std::string m_ptr2funcName;             
    CalculFF m_calculFF;                   
    ListSectionsFlow m_listSections;       
    PhyBCNdlConstraint m_leftBcNode;       
    PhyBCNdlConstraint m_rightBcNode;      
    Ptr2FLegacyFluxAlgorithm m_ptr2FuncFF; 
    SrcNumericalTreatment* m_srcDiscr;     
  //  bool m_useFriction;                  /**< friction use*/
    bool m_usePressure;                    
    bool m_useSourceTerms;                 
 //   bool m_isFlatEarth;                  /**< section geometry*/
  };
} // End of namespace