Sfx_DamBreakData.h

Go to the documentation of this file.

#pragma once
 
#include <cassert>
// // C++ includes
#include <iostream>
#include <utility>
#include <string>
// // STL include
#include <vector>
// SfxBase19 include 
#include "include/Sfx_DefineTypes.h"
 
namespace Sfx 
{
  class DamBreakData final
  {
  public:
    using pairofloat64 = std::pair<float64, float64>; 
    enum class eDataTypes
    {
      emcneil = 0, 
      hudson = 1   
    };

    explicit DamBreakData( eDataTypes aDiscrType = eDataTypes::emcneil) : m_discrType{ aDiscrType }
    {
      if( m_discrType == eDataTypes::emcneil)
      {
        setEMcNeilParams();
      }
      else
      {
        setHudsonParams();
      }
    }

    DamBreakData( std::string aDataType) // pass by copy?? move?
    {
      // only 2 supported for now
      if (std::string{"emcneildata"} == aDataType)
      {
        setEMcNeilParams();
      }
      else
      {
        setHudsonParams();
      }
    }

    float64 x_min()    const noexcept { return m_Xmin; }
    float64 x_max()    const noexcept { return m_Xmax; }
    //  std::vector<float64> Xcoord() const { return m_X; }
    // does it use move semantic for this return?
    //std::vector<float64> Xcoord() const { return std::vector<float64>(&X[0], &X[0] + m_NbSects); }
    float64 getS0am()    const noexcept { return m_S0am; }
    float64 getS0av()    const noexcept { return m_S0av; }
    float64 getCFL()     const noexcept { return m_cfl; }
    float64 dX()         const noexcept { return m_dX; }
    int32   nbSections() const noexcept { return m_NbSects; }
    float64 getPhi0()    const noexcept { return m_Phi0; }
    float64 getPhi1()    const noexcept { return m_Phi1; }
    float64 getWidth()   const noexcept { return m_sectWidth; }
    float64 getShockLocation() const noexcept { return m_shockLocation; }
    pairofloat64 domainExtent() const noexcept { return m_domainExtent; }
    pairofloat64 dambreakExtent() const noexcept { return m_dambreakExtent; }
    eDataTypes getDiscrType() const noexcept { return m_discrType; }
    bool isUnitSectionWidth() const noexcept { return m_unitSectWidth; }
    bool isFrictionLess() const noexcept { return m_frictionLess; }
    bool isFlatBed() const noexcept { return m_flatBed; }
    std::string toString(eDataTypes aDisc) noexcept
    {
      if (aDisc == eDataTypes::emcneil)
      {
        return std::string("d=1 [0,1000] [1:100]");
      }
      else if (aDisc == eDataTypes::hudson)
      {
        return std::string("d=1 [0,1] [1:10]");
      }
      else
      {
       // Sfx::Logger::instance()->OutputError("Discretization not supported");
        return std::string{};
      }
    }

    std::string toString(eDataTypes aDisc) const noexcept
    {
      if (aDisc == eDataTypes::emcneil)
      {
        return std::string("d=1 [0,1000] [1:100]");
      }
      else if (aDisc == eDataTypes::hudson)
      {
        return std::string("d=1 [0,1] [1:10]");
      }
      else
      {
        //Sfx::Logger::instance()->OutputError("Discretization not supported");
        return std::string{};
      }
    }
 
  private:
    eDataTypes m_discrType;         
    pairofloat64 m_domainExtent;    
    pairofloat64 m_dambreakExtent;  
    float64 m_S0am;                 
    float64 m_S0av;                 
    float64 m_dX;                   
    float64 m_Phi0;                 
    float64 m_Phi1;                 
    float64 m_cfl;                  
    int32   m_NbSects;              
    float64 m_Xmin;                 
    float64 m_Xmax;                 
    float64 m_sectWidth;            
    float64 m_shockLocation;        
    bool    m_unitSectWidth;        
    bool    m_frictionLess;         
    bool    m_flatBed;              

    void setEMcNeilParams() noexcept
    {
      // configure the simulation property. 
      m_S0am = 0.;                      // ...
      m_S0av = 0.;                      // ...
      m_Phi1 = 10.;                   // water level at upstream
      m_Phi0 = 1.;                    // water level at downstream
      //m_cfl = 0.6;                     this is a simulation parameter and handle by SimulationMgr class
      m_sectWidth = 1.;                 //
      m_NbSects = 101;               // number of sections
      m_Xmin = 0.;                    // x-coordinate of the left bound. node
      m_Xmax = 1000.;                 // x-coordinate of the right bound. node
      m_domainExtent.first = m_Xmin;    // ...
      m_domainExtent.second = m_Xmax;   // ...
      m_dambreakExtent.first = m_Phi0;  // dam-break water level at downstream
      m_dambreakExtent.second = m_Phi1; // dam-break water level at upstream
      m_shockLocation = 500.;
      m_unitSectWidth = true;           //
      m_frictionLess = true;
      m_flatBed = true;
      assert(m_Xmin < m_Xmax);
      // spatial step
      m_dX = 10.; // no point to calculate that,  
                  //        (m_Xmax - m_Xmin) / boost::numeric_cast<float64>(m_NbSects - 1);
      assert(m_Phi0 < m_Phi1);
      assert(m_dX != 0.);
    }

    void setHudsonParams() noexcept
    { 
      m_S0am = 0.;                      // ...
      m_S0av = 0.;                      // ...
      m_Phi1 = 1.;                   // water level at upstream
      m_Phi0 = 0.5;                    // water level at downstream
                                      //m_cfl = 0.6;                     this is a simulation parameter and handle by SimulationMgr class
      m_sectWidth = 1.;                 //
      m_NbSects = 101;               // number of sections
      m_Xmin = 0.;                    // x-coordinate of the left bound. node
      m_Xmax = 1.;                 // x-coordinate of the right bound. node
      m_domainExtent.first = m_Xmin;    // ...
      m_domainExtent.second = m_Xmax;   // ...
      m_dambreakExtent.first = m_Phi0;  // dam-break water level at downstream
      m_dambreakExtent.second = m_Phi1; // dam-break water level at upstream
      m_shockLocation = 0.5;
      m_unitSectWidth = true;           //
      m_frictionLess = true;
      m_flatBed = true;
      assert(m_Xmin < m_Xmax);
      // spatial step
      m_dX = 0.01; // no point to calculate that,  
                  //        (m_Xmax - m_Xmin) / boost::numeric_cast<float64>(m_NbSects - 1);
      assert(m_Phi0 < m_Phi1);
      assert(m_dX != 0.);
    }

    void setDiscrType()
    {
      switch (m_discrType)
      {
      case eDataTypes::emcneil:
      {
        setEMcNeilParams();
        break;
      }
      case eDataTypes::hudson:
      {
        setHudsonParams();
        break;
      }
      default:
        std::cerr << "Discretization not supported yet\n";
        break;
      }
    }
  };
} // End of namespace