Sfx_LDeltaOperator.h

Go to the documentation of this file.

#pragma once
 
// C++ include 
#include <cmath>
#include <vector>
#include <valarray>
// boost includes
#include <boost/numeric/ublas/vector.hpp>
// BaseNumTypes lib
#include "Sfx/Sfx_FieldLattice.h"
// SfxBase15 package include
#include "include/Sfx_HOperator.h"
// Physics algo includes
#include "../Nov_VS2019/SimulationConfig.h"
#include "../Nov_VS2019/PhysicsAlgorithm/Testvs19_NujicSourceTreatment.h"
 
// forward declarations
namespace Sfx { 
    class PhysicalSystem;
  class EMcNeilBndCnd;
}
namespace dbpp { class SweRhsAlgorithm; }
 
namespace Sfx
{
    class LDeltaOperator : public Sfx::HOperator
    {
    public:
        using ListSectFlowPtr = std::shared_ptr<Testvs19::ListSectionsFlow<dbpp::SectionFlow>>;
        static constexpr int32 DIM = 100; 
        // just testing new implementation
    //  template<typename NumContType = std::valarray<double>>
//      using NumArrayTypetest = NumContType;
        using uvec64 = boost::numeric::ublas::vector<float64>;
        using CalculFF = void(*)( NumArrayType& aFF1, NumArrayType& aFF2,
            const NumArrayType& aU1, const NumArrayType& aU2);  
    public:
        struct SWE_RHS           
        {
            NumArrayType   m_FF1;   
            NumArrayType   m_FF2;    
            NumArrayType   m_P2;     
            NumArrayType   m_PF2;   
            NumArrayType   m_S;     
        };
    public:
        enum class eNumArrayType   
        {                          
            std_valarray=0,           
            std_vector=1,             
            swe_NumArray=2,           
            ublas_vector=3            
        };

        enum class eSourceTermType
        {
            Hderivative=0, 
            Zderivative=1  
        };

        enum class eSourceDxType 
        {
            central_2ndorder=0, 
            central_4thorder=1  
        };

    enum class eDxSchemeType
    {
      central_2ndorder = 0, 
      central_4thorder = 1  
    };

    enum class eDerivBCType
    {
      noncentered_2ndorder = 0, 
      emcil_2nd_order   = 1     
    };
//      enum class eENOStencil 
//      {
//          central=0,
//          ENO=1
//      };
        enum class eFluxType       
        {                     
            convective=0,      
            pressure=1,        
            conv_pressure=2    
        };

        enum class eFluxDxType  
        {
            upwind_1st = 0, 
            upwind_2nd = 1 
        };
        using sourcediscr = eSourceDxType;
        using sourceTerm = eSourceTermType;
        using dx_f = eFluxDxType;
//      typedef eBcType bounddiscr;
    public:
        LDeltaOperator(); 
        LDeltaOperator( dbpp::SweRhsAlgorithm* aRhsDiscr);
        LDeltaOperator( const LDeltaOperator& aOther)=delete;
        LDeltaOperator& operator= ( const LDeltaOperator& aOther)=delete;
        // what about move semantic?
        LDeltaOperator( CalculFF aFluxDiscr);
        ~LDeltaOperator();
        void* applyTo( std::shared_ptr<Sfx::FieldLattice>& aU1,
            std::shared_ptr<Sfx::FieldLattice>& aU2) override;
    void* applyTo( const Sfx::FieldLattice& aU1, const Sfx::FieldLattice& aU2);
    void solveFor() override {/*no implementation*/ }
        eNumArrayType arrayType() const noexcept { return m_arrType;}
        void setArrayType( const eNumArrayType aType) noexcept {m_arrType=aType;}
        bool haspressureTerm() const noexcept { return false;}
        bool useFriction()     const noexcept { return false;}
        void setTraitementS2( const eSourceTermType aSdx) noexcept
        {
            m_sourceType=aSdx;
        }

        void setDxSourceTerm( const sourcediscr aSdx) noexcept
        {
            m_sourceDxType=aSdx;
        }

        void setTraitementF( const dx_f aDxF) noexcept
        {
            m_dxfType=aDxF;
        }

    void setDerivativType( eDxSchemeType aDerivType) noexcept { m_derivativeType = aDerivType; }
    eDxSchemeType getderivativeType() const noexcept { return m_derivativeType;}
    void setD1xBCAtBothEnd(eDerivBCType aBCtype) noexcept { m_bcBothEnd = aBCtype; }
    eDerivBCType getD1xBCtype() const  noexcept { return m_bcBothEnd; }
        void setSrcTermRhsData( const ListSectFlowPtr& aSrcData) noexcept
        {
            m_srcTreatmentData=aSrcData;
        }   

        void setFluxAlgorithm( CalculFF aConvF) noexcept { m_calculFF = aConvF; }
        CalculFF getFluxAlgorithm()             noexcept { return m_calculFF; }
    private:
        eNumArrayType   m_arrType;          
        eSourceDxType   m_sourceDxType;     
    eDxSchemeType   m_derivativeType;    
    eDerivBCType    m_bcBothEnd;        
        eSourceTermType m_sourceType;         
        eFluxDxType     m_dxfType;           
        eFluxType       m_fluxSchme;         
        //ArrayType      m_H;               /**< water level    (H)*/  //???? what for
        CalculFF m_calculFF = nullptr;       
        dbpp::SweRhsAlgorithm* m_rhsDiscr;  
        ListSectFlowPtr m_srcTreatmentData; 
        SWE_RHS* theRhs;                     
    };
} // End of namespace