dbpp_HLLFluxAlgorithm.h

Go to the documentation of this file.

#pragma once
 
//C++ includes
#include <vector>
// numeric include
#include <valarray>
// SfxBase19 includes
#include "include/Sfx_DefineTypes.h"
//VS19 includes
#include "dbpp_MUSCLReconstr.hpp"
//#include "dbpp_Enumerations.h"
#include "dbpp_FluxTensor.h"
#include "dbpp_FluxAlgorithm.h"
 
// forward declarations
namespace Sfx {
  class scalarField1D;
  class cellFaceVariables;
}
// forward declarations
namespace dbpp {
  class Omega;
  class HLLSolver1D;
  class PhysicalBoundaryCnd;
}
 
namespace dbpp 
{ 
  class HLLFluxAlgorithm : public FluxAlgorithm
  {
  public:
    using mapcellfaceVar = std::map<short/*face idx*/, std::pair<Sfx::StateVector/*UL*/, Sfx::StateVector/*UR*/>>;
  public:
    HLLFluxAlgorithm( const ePhysicalFluxType aPhyFluxType = ePhysicalFluxType::incomplete) // don't make sense!!!
    : m_varOrder{2},
      m_fluxType{ aPhyFluxType },
      m_reconstrType{eReconstrType::None},
      m_musclReconstr{}
    {}

    void setFluxType(ePhysicalFluxType aFluxType) noexcept { m_fluxType = aFluxType; }
    ePhysicalFluxType getFluxType() const noexcept { return m_fluxType; }
    bool useReconstr() const noexcept override final { return true; }
    bool usePhysicalCompleteFlux() const noexcept override final { return false; }
    void setReconstrType(eReconstrType aRecnstrType) noexcept { m_reconstrType = aRecnstrType; } // ON/OFF??
    eReconstrType getReconstrType() const noexcept { return m_reconstrType; }
    void setPhysicalBndCnd( const PhysicalBoundaryCnd& aPhysbc) noexcept {}
    void setReconstrVarOrder(int32 aOrder) noexcept override { m_varOrder = aOrder; }
    int32 getReconstrVarOrder() const noexcept override {return m_varOrder;}
    void setReconstrMethod( /*const MUSCLReconstr& aReconst*/) noexcept {}
 
    //HLL algorithm parameters (mu_s,CS,CR) + shock speed
    void setFluxAlgoPrms(/*Sfx:StateVector&,Sfx:StateVector&*/) override {/*not implmenetd yet*/ }
 
    void setApprRiemanSolver( const HLLSolver1D* aRsolver) {/*not implmenetd yet*/ }
    FluxTensor calculFF( const Sfx::cellFaceVariables& aFaceVariables) override final;
    FluxTensorMap
      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
    {
      return calculFF(aU1.asStdVector(),aU2.asStdVector(), aPhysbc);
    }
  protected:
    FluxTensorMap // 'rvalue' version
      calculFF( std::vector<float64>&& U1, std::vector<float64>&& U2, //computational dommain (DIM)
        const PhysicalBoundaryCnd& aPhysbc);
    FluxTensorMap
      calculFF( const std::valarray<float64>& aU1, std::valarray<float64>& aU2,
                const std::list<cellFace>& aListClFace, const PhysicalBoundaryCnd& aPhysbc);
    virtual void computeCellFacePhysicalFlux( const Sfx::cellFaceVariables& aFaceVar);
    virtual void computeCellFacePhysicalFlux( const Sfx::StateVector& aUL, const Sfx::StateVector& aUR);
  private:
    int32 m_varOrder;              
    ePhysicalFluxType m_fluxType;  
    eReconstrType m_reconstrType;  
    MUSCLReconstr m_musclReconstr; 
    virtual mapcellfaceVar reconstr( const std::list<cellFace>& aListCellFace,
      std::vector<float64>&& aA, std::vector<float64>&& aQ); // phys b.c. applied
  };
} // End of namespace