dbpp_SimulationUtilities.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cmath>
// C++ include
#include <iostream>
#include <concepts>
#include <type_traits>
#include <ranges> // C++20 feature
// STL numeric 
#include <numeric>
// SfxBase19 include
#include "include/Sfx_UniversalConstants.h"
// App include
#include "../SfxBase/Sfx_Logger.h" // emcil::Logger
#include "../include/HydUtils.h"   // Hydraulic utility
// vs19 includes
#include "dbpp_CellFace.h"
#include "dbpp_ListSectionsFlow.h"
// Dsn package incude
//#include "HydUtils/Dsn_HydroUtils.h"
 
  //template<typename T1, typename... TN>
  //constexpr bool isHomogeneous(T1, TN ...)
  //{
  //  // return fold expression
  //  return (std::is_same_v<T1, TN> && ...);
  //}
 
namespace dbpp 
{
  template<typename T, typename... TN>
  struct isHomogeneous {
    // using fold expression (C++17 new features)
    static constexpr bool value = (std::is_same_v<T, TN> && ...);
  };
 
  // just trying to implement a print function with C++17 feature
  // variadic template and fold expression 
#if 0
  template<auto Sep = ' ', typename First, typename... Args>
  void print17(const First& aFirst2Print, const Args&... aArgs)
  {
    std::cout << aFirst2Print;
 
    // use auto keyword in lambda expression
    auto outWithSep = [](const auto& arg)
    {
      std::cout << Sep << "arg";
    }
 
    // use folder expression to return
    // IMPORTANT the expansion '...' must have no white space
    //  with comma and lambda, stick all together, otherwise
    // it doesn't compile!!!
    (... , outWithSep(aArgs)) << '\n';
 
    //std::cout << '\n';
  }
#endif
 
  template<typename T>
  concept dbl_arg_type = std::is_floating_point_v<T>;

  template<typename T>
  requires dbl_arg_type<T>
    class MinMod19
  {
  public:
    // return type ...
    // something has to do with decay!!
    constexpr auto operator() (T aVal1, T aVal2)
    {
      using namespace std::string_literals;
 
      if (aVal1 * aVal2 <= 0.)
        return 0.;
 
      else if ((std::abs(aVal1) < std::abs(aVal2)) && (aVal1 * aVal2 > 0.))
        return aVal1;
 
      else if ((std::abs(aVal2) < std::abs(aVal1)) && (aVal1 * aVal2 > 0.))
        return aVal2;
 
      else if (std::abs(aVal2) == std::abs(aVal1))      //  ATTENTION, mis pour v�rification !!!! sanity check!!
        return aVal1;
      else
      {
        // NO!!! hard to debug
        std::cerr << "Fonction MINMOD: situation ne correspondant pas a celle attendue\n";
        Sfx::Logger::instance()->OutputError("Fonction MINMOD: situation ne correspondant pas a celle attendue"s.data());
        exit(EXIT_FAILURE); // what else to do? throw an exception
      }
    }
  };

  class ManningFormula
  {
  public:
    using argument_type = std::pair<float64,float64>;
    using result_type = float64;
    ManningFormula(float64 aRoughnessCoeff) : m_N{ aRoughnessCoeff } {}
    result_type operator() ( const argument_type& aNval) const
    {
      // structured binding C++17
      auto [A, Q] = aNval;
 
      // Hydraulic radius (unit width).
      //HydroUtils::R w_R;
      //const auto Rh = Dsn::R(A, 1.); // A
      const auto Rh = Sfx::HydRadius(A, 1.); // A
 
      // define some for clarity (check doc for Manning relation ())
      const auto gNN = Sfx::cGravity<float64>*m_N * m_N;
      const auto V = Q / A; // velocity (Q/A)
      const auto Vsquaredivh = V * std::fabs(V) / ((A * A) * std::pow(Rh, 4. / 3.));
 
      return gNN * Vsquaredivh;
    }
  private:
    float64 m_N; 
  };

  constexpr float64 Evaluation_H_fonction_A(float64 A, float64 Z, float64 B = 1.)
  {
    return (A / B + Z);
  }

  constexpr float64 Evaluation_A_fonction_H(float64 H, float64 Z, float64 B = 1.)
  {
    return (H - Z) * B;
  }
 
  // Usage
  // auto w_funcAfromH = []( const SectFlow* aSectFlow) 
  //     {
  //       return HydroUtils::Evaluation_A_fonction_H(aSectFlow->H(),aSectFlow->Z(),aSectFlow->B());
  //     }
  //  just experimenting 
  template<typename UnaryFunctor>  //could be a lambda or callable
  decltype(auto) Evaluation_A_fonction_H14( const ListSectionsFlow& aSectF, UnaryFunctor aFunctor)
  {
    // Not sure if it is working, ListSectFlow has member begin/end
    return std::for_each(std::begin(aSectF), std::end(aSectF), aFunctor);
  }

  template<typename Range>
  std::ranges::range_value_t<Range> maxValue(Range&& aRng)
  {
    // NOTE
    // pass range as universal reference because cannot iterate
    // on some lightweight range (views) when they are constant 
    if constexpr (std::ranges::empty(aRng))
    {
      return std::ranges::range_value_t<Range>{};
    }
    // init max value
    auto maxValue = *std::ranges::begin(aRng);
    // search for max value
    for(auto pos = std::ranges::begin(aRng);
        pos!=std::ranges::end(aRng);++pos)
    {
      if (*pos>maxValue)
      {
        maxValue = *pos;
      }
    }
    return maxValue;
  }

  template<typename CB>
  class callCounter 
  {
  public:
    callCounter(CB aCallBack) : m_callBack{ aCallBack } {}
    template<typename ...Args>
    decltype(auto) operator() (Args&& ...args)
    {
      ++m_count;
      return m_callBack(std::forward<Args>(args)...);
    }

    long count() const { return m_count; }
  private:
    CB m_callBack;                   
    long m_count{};                  
    std::atomic_long m_parCounter{}; 
  };
} // End of namespace