dbpp_HLLSolver1D.h

Go to the documentation of this file.

#pragma once
 
// SfxBase19 include 
#include "include/Sfx_DefineTypes.h"
// DamBreak app include
#include "dbpp_FluxTensor.h"
 
namespace dbpp { class RiemannProblem; }
namespace Sfx { class cellFaceVariables; }
namespace dbpp
{
  class HLLSolver1D
  {
  public:
    HLLSolver1D() = default;
    //HLLSolver1D( const CellFaceVariables& aCellFvar); //  not sure
    HLLSolver1D( const HLLSolver1D& aOther) = delete;
    HLLSolver1D& operator= (const HLLSolver1D& aOther) = delete;
    FluxTensor solve(const RiemannProblem& aRprob); //override
    std::pair<double/*SL*/, double/*SR*/> getShockSpeed() const
    {
      return {0.,0./* m_shockSpeed.m_SL, m_shockSpeed.m_SR*/ };
    }
#if 0 // another interesting implementation (will be back later)
    virtual fluxcomp solve(const RiemannProblem& aRprob)
    {
      // retrieve conservative system    
      const auto w_stVen1D = aRprob.getMthEquations();
 
      // compute state variables physical flux at cell face
      const auto FL1 = aRprob.getUL().Q();
      const auto FR1 = aRprob.getUR().Q();
 
      // physical flux (math model in use)
      const auto FL2 = w_stVen1D->flux(Sfx::StateVector{ aRprob.getUL().A(), aRprob.getUL().Q() }); //FL2
      const auto FR2 = w_stVen1D->flux(Sfx::StateVector{ aRprob.getUR().A(), aRprob.getUR().Q() }); //FR2
 
      // compute flux parameters according to HLL  HLL algorithm
      emcil::HLLParameters w_hllprms;
      // structured binding C++17 (tuple-like API)
      const auto& [CR, CL, CS, uL, uR, uS] =
        w_hllprms.setParameters(aRprob.getUL(), aRprob.getUR());
 
      // shock speed on both side of the shock
      const auto SL = std::min(uL - CL, uS - CS);
      const auto SR = std::max(uR + CR, uS + CS);
      // ...
      HLLFlux1D w_hllFlux; // call shock speed 
      w_hllFlux.setShockSpeed(std::make_pair(SL, SR));
      w_hllFlux.setphysicalFlux(std::make_tuple(FL1, FR1, FL2, FR2));
 
      // [U1L,U2L] and [U1R,U2R] 
      Sfx::cellFaceVariables w_cellFaceVar{ static_cast<unsigned>(aRprob.getFaceIdx()), Sfx::StateVector{aRprob.getUL()},
                                            Sfx::StateVector{aRprob.getUR()} };
 
      // calculate numerical cell face flux
      auto [FF1, FF2] = w_hllFlux.calculFF(w_cellFaceVar);
 
      // Design note
      //  maybe return a struct??
      return { FF1,FF2 }; // numeric face flux 
    }
#endif // 0
 
  private:
    struct hllParams 
    {
      float64 uL; 
      float64 uR; 
      float64 CL; 
      float64 CR; 
    };
 
  protected:
    virtual std::pair<double, double> computeShockSpeed( const Sfx::cellFaceVariables& aFace); // override
    virtual hllParams computeParams( const Sfx::cellFaceVariables& aFace);  // override
  };
}//End of namespace