Sfx_ENOD1X.h

Go to the documentation of this file.

 
#pragma once
 
//#define DIM 100 // debugging purpose (grid dimension)
 
#include <array>
#include <valarray>
//#include "vectorField.h"
#include "Sfx/Sfx_ScalarField1D.h"
//#include "../EMcneilGamma.h"
#include "../../Nov_VS2019/dbpp_PhysicalBoundaryCnd.h"
#include "../../Nov_VS2019/dbpp_Gamma.h"
 
namespace Sfx 
{ 
    class FiniteDifferenceDerivative 
  {
        // typedef struct { double r[DIM+1]; } scalar;
        // typedef struct { scalar x; } vector;
 
        //typedef struct { double r[DIM+1];} vector;
        //typedef struct { short  x[DIM+1]; } stencil;
 
    // C++11 way of declaring those struct above
    static constexpr int DIM = 100;
//     using vector  = struct { std::array<double, DIM + 1> r; };
//     using stencil = struct { std::array<short,  DIM + 1> x; };
 
    // EMcNeilDamBreakData<float>::DIM() constexpr can be use in compile time context
    struct vector 
    {
      std::array<float64, DIM + 1> r;
      std::array<float64, DIM + 1>::iterator begin() { return r.begin(); }
      std::array<float64, DIM + 1>::iterator end() { return r.end(); }
      std::array<float64, DIM + 1>::const_iterator cbegin() { return r.cbegin(); }
      std::array<float64, DIM + 1>::const_iterator cend() { return r.cend(); }
 
      // default ctor
      vector() 
      {
        r.fill(0.);
      }
 
      vector( const vector& aOther) = default;
      vector& operator= ( const vector& aOther) = default;
 
      // ... 
      std::size_t size() const { return r.size();  }
      bool isEmpty() const     { return r.empty(); }
      double front() const     { return r.front(); }
      double back() const      { return r.back();  }
    };
 
    struct stencil 
    { 
      std::array<short, DIM + 1> x; 
    };

    enum class eStenType 
    {
      None=0,
      periodic=1,
      nonperiodic=2
    };
 
    public:
    FiniteDifferenceDerivative( std::string aName, const dbpp::Gamma& aBC, bool aUseENOSten)
    : m_name( std::move(aName)),
      m_derivOrder(2),
      m_stenType( eStenType::None),
      m_useSten(aUseENOSten),
      m_dx{}
    {}
    // not sure about these ones!!
    FiniteDifferenceDerivative( const FiniteDifferenceDerivative& aOther) = delete;
    FiniteDifferenceDerivative& operator= ( const FiniteDifferenceDerivative& aOther) = delete;
    ~FiniteDifferenceDerivative() = default; // disable move semantic!!! what we want??
        std::valarray<float64> d1x( const Sfx::scalarField1D* aScalrField, const dbpp::PhysicalBoundaryCnd& aBC);
//      stencil* eno_stencil( const vectorField& aVecf);
 

    bool useENOStencil() const { return m_useSten; }
    void setDerivativeOrder(int aOrder) { m_derivOrder = aOrder; }
    void setStencilType( eStenType aStenType) { m_stenType = aStenType; }
    eStenType getStencil() const { return m_stenType; }
    size_t getDerivativeOrder() const { return m_derivOrder; } // default
        size_t getGlobalDimension() const { return DIM + 1; }
 
    private:
    vector* new_vector(void);
        void free_vector( vector*);
 
//      void test_reconstr(Deriv1X::vector*, int);
//      void test_derivative(void);
//      void test_stencil(int );
 

    stencil* eno_stencil( vector* aStencil);
    vector* d1x( vector* aVec, stencil* aSten=nullptr);
    void setdx(double dx) { m_dx = dx; }
 
    std::string m_name; 
    int m_derivOrder;  
    eStenType m_stenType; 
    bool m_useSten;  
    double m_dx;  
  };
} // End of namespace