dbpp_SemiDiscreteScheme.h

Go to the documentation of this file.

#pragma once
 
// numeric include
#include <valarray>
 
// forward declarations
namespace Sfx {
  class ExplicitOperator;
  class LDeltaOperator;
}
namespace dbpp {
  class SweRhsAlgorithm; }
 
namespace dbpp 
{
  class SemiDiscreteScheme // UNDER CONSTRUCTION!!!
  {
    using float64 = double;
 
    // see note below
    friend class FiniteDifferenceModel;
    
    // all declared protected we don't want client to use it!!
    // to be used only by the FiniteDifferenceModel!!!
  protected:
    SemiDiscreteScheme(/*RhsDiscretization*/Sfx::LDeltaOperator* aDeltaOp)
    : m_deltaOp{aDeltaOp},
      m_explOp{nullptr}
 /*     m_IdentityU1(),
      m_IdentityU2() {}*/
    {}
    // similar to setStep()
    void setRhs(float64 aDt)
    {
      // set LDeltaOperator step (RK2 time step)
      // similar what is done in the NujicIntegrator
 
      SweRhsAlgorithm* m_rhsDiscr = dbpp::factory::create() //? ?
      auto w_activeALgo = Sfx::Simulation.activeSweRhsAlgorithm();
 
      SweRhsAlgorithm* w_rhsAlgo = nullptr;
      w_rhsAlgo->setFluxAlgorithm(w_rhsAlgo->getFluxAlgorithm());
      w_rhsAlgo->setSourceTermDiscr(w_rhsAlgo->getSrcTermDiscr());
 
      if(m_rhsDiscr->usePressure())
        w_rhsAlgo->setPressureTermDiscr(m_rhsDiscr->getPressureTermDiscr());
 
      if (m_rhsDiscr->hasFrictionCoeff())
        w_rhsAlgo->setManningFormula();
 
      m_deltaOp->setRhsAlgorithm(w_rhsAlgo);
      m_explOp->setOperator(m_deltaOp, ...);
 
//      auto [dFF1, dFF2] = m_deltaOp->calculFF();
//      auto S = m_deltaOp->TraitementSource2();
 
      // --------------------------PREDICTOR
      // mass equation
//      auto m_U1np12 = m_IdentityU1 - dFF1;
 
      // Momentum equation (without pressure term)
//      auto m_U2np12 = m_IdentityU2 - dFF2 + aDt*S;
 
      //return { w_U1p,w_U2p };
 
      // --------------------------COORECTOR
      // Mass equation
//      w_U1 = 0.5 * (w_U1 + w_U1np12 - w_dFF1);
 
      // Momentum equation (without pressure term) 
 //     w_U2 = 0.5 * (w_U2 + w_U2np12 - w_dFF2 +
  //      w_timeStep * w_Rhs->m_S[j - 1]);
    }
 
    bool usePressure() const { return false; }
    bool useFriction() const { return false; }
 
    void step( std::valarray<float64>& aU1, std::valarray<float64>& aU2)
    {
      // switch to select predictor/corrector step
      // call operator: 
      // setStep(...)
      //m_explOp->applyTo(aU1,aU2)
    }
 
    Sfx::LDeltaOperator*   m_deltaOp{ nullptr };
    Sfx::ExplicitOperator* m_explOp;  // U - lambda*m_deltaOp.apply(aU).massEq();
 
    // previous state vaariables
    std::valarray<float64> m_U1np12; //set to 1
    std::valarray<float64> m_U2np12;    
    std::valarray<float64> m_U1np1; //set to 1
    std::valarray<float64> m_U2np1;
    // 
    //std::valarray<float64> m_IdentityU1(); //set to 1
    //std::valarray<float64> m_IdentityU2;
  };
} //End of namespace