dbpp_NujicFluxAlgorithm.h

Go to the documentation of this file.

#pragma once
 
//C++ includes
#include <map>
#include <list>
#include <valarray>
// STL include
#include <algorithm>
// SfxBase19 includes
#include "include/Sfx_StateVector.h"
#include "include/Sfx_DefineTypes.h"
#include "include/Sfx_UniversalConstants.h"
// Numerical Types
#include "Sfx/Sfx_scalarField1D.h"
// Nov19 include
//#include "dbpp_Reconstruction.hpp" // MUSCL
#include "dbpp_FluxTensor.h"
#include "dbpp_Enumerations.h"
#include "dbpp_FluxAlgorithm.h"
#include "dbpp_PhysicalBoundaryCnd.h"
// App include
//#include "../SfxBase/Sfx_StVenant1DTerms.h"
 
// forward declarations
namespace Sfx {
  class StVenant1D;
  class scalarField1D;
  class cellFaceVariables;
}
 
namespace dbpp 
{
  class NujicFluxAlgorithm : public FluxAlgorithm
  {
  public:
    //enum class eFluxType {
    //  complete = 0,  /**< */
    //  incomplete = 1 /**< */
    //};
    using valr64 = std::valarray<float64>;
    using pairf12 = std::pair<std::valarray<float64>, std::valarray<float64>>;
  public:
    NujicFluxAlgorithm( const dbpp::ePhysicalFluxType aFluxType, float64 aAlgoNujicPrm) 
    : m_fluxType{ aFluxType },
      m_algoPrm{aAlgoNujicPrm}
    {}

    FluxTensor calculFF( const Sfx::cellFaceVariables& aFaceVariables) override final;
    FluxTensorMap // FF1,FF2 flux tensor?? why virtual?
      calculFF( const Sfx::scalarField1D& U1, const Sfx::scalarField1D& U2, //computational dommain 
        const Omega& aDomain, const PhysicalBoundaryCnd& aPhysbc) override final;
    FluxTensor calculFF( const Sfx::StateVector& aUL, const Sfx::StateVector& aUR,
      const cellFace& aCellFace) override final
    {
      return FluxTensor{};
    }

    FluxTensorMap
      calculFF( const Sfx::scalarField1D& aU1, const Sfx::scalarField1D& aU2, //computational dommain 
        const PhysicalBoundaryCnd& aPhysbc) override final
    {
#if 0
      auto w_phySys = aPhysbc.getPhysicalSystem();
      std::valarray<float64> w_H(aPhysbc.getPhysicalSystem()->size());
      auto i = 0;
      // retrieve section water level
      for( const auto& w_sectFlowH : 
        w_phySys->getSectionList().getSectionsWaterLevel() | std::views::values)
      {
        w_H[i++] = w_sectFlowH;
      }
      // retrieve physical boundary condition (C++17 structured binding)
      auto [Aleftbc, Qleftbc, Hleftbc] = aPhysbc.getLeftEnd();
      auto [Arightbc, Qrightbc, Hrightbc] = aPhysbc.getRightEnd();
      
      // allow space for global domain (computation domain + ghost node)
      std::valarray<float64> w_Arrp1(aU1.asStdVector().data(),aU1.values().size() + 1);
      std::valarray<float64> w_Qrrp1(aU2.asStdVector().data(),aU1.values().size() + 1);
 
      // set b.c. upstream
      w_Arrp1[aU1.grid().getBaseI()] = Aleftbc;
      w_Qrrp1[aU1.grid().getBaseI()] = Qleftbc;
      // set b.c. downstream
      w_Arrp1[aU1.grid().getMaxI()] = Arightbc; // ghost node
      w_Qrrp1[aU1.grid().getMaxI()] = Qrightbc; // ditto
      
      // cell face numerical flux 
      return calculFF( std::move(w_Arrp1),std::move(w_Qrrp1),std::move(w_H));
#endif
      return FluxTensorMap{};
    }

    bool useReconstr() const noexcept override final { return false; }
    bool usePhysicalCompleteFlux() const noexcept override final { return false; }
    void setReconstrType(eReconstrType aRecnstrType) noexcept override final { m_reconstype = aRecnstrType; }
    eReconstrType getReconstrType() const noexcept override final { return m_reconstype; }
  protected:
    std::tuple<valr64/*f1p*/, valr64/*f1m*/, valr64/*f2p*/, valr64/*f2p*/>
      computePhysicalFlux(std::valarray<float64>&& aU1, std::valarray<float64>&& aU2,
        std::valarray<float64>&& aH);
    void setNujicAlgoPrm(float64 aNujicAlgoPrm) { m_algoPrm = aNujicAlgoPrm; }
    std::tuple<valr64/*f1p*/, valr64/*f1m*/, valr64/*f2p*/, valr64/*f2p*/>
      computePhysicalFlux( Sfx::StVenant1D* aSclEquation, const Uh& aUh);
    valr64 computef12p( std::span<float64, Sfx::DIM::value>&& aRng, //f1p
      std::span<float64, Sfx::DIM::value>&& adRng); //df1p
    valr64 computef12m( std::span<float64, Sfx::DIM::value>&& aRng, //f1p
      std::span<float64, Sfx::DIM::value>&& adRng); //df1p
  private:
    ePhysicalFluxType m_fluxType; 
    eReconstrType m_reconstype;   
    float64 m_Alpha{};            
    float64 m_algoPrm{ 0.4 };     
    std::vector<float64> m_Hvec;  
  };
} // End of namespace