dbpp_FluxTensor.h

Go to the documentation of this file.

#pragma once
 
// C++ 17 includes
#include <optional>
#include <ranges>   //C++20
#include <algorithm>
// STL include
#include <map>
#include <valarray>
// SfxBase19 include
#include "include/Sfx_DefineTypes.h"
// logger
#include "../SfxBase/Sfx_Logger.h"
 
namespace dbpp 
{
  struct FluxTensor
  {
    short  m_cellIdx; 
    float64 FF1;      
    float64 FF2;      
    std::pair<float64/*FF1*/, float64/*FF2*/> asFFPair() const
    {
      return std::make_pair(FF1, FF2);
    }

    bool isZeroValue() const { return (FF1 == 0. && FF2 == 0.); }
    std::tuple<short, float64, float64> asFFTuple() const
    {
      return std::make_tuple(m_cellIdx, FF1, FF2);
    }
  };
#if 1
  struct FluxTensorMap 
  {
    using sizeMapType = std::map<short, FluxTensor>::size_type;

    enum class eFFcomp {FF1,FF2};
 
    std::map<short, FluxTensor> m_fluxTensorMap;
    bool insert( FluxTensor&& aFlux2Insert) 
    {
      if( auto [pos,succeed] =  // need a refctoring
        m_fluxTensorMap.try_emplace(aFlux2Insert.m_cellIdx, aFlux2Insert.m_cellIdx, aFlux2Insert.FF1, aFlux2Insert.FF2); !succeed)
      {
        Sfx::Logger::instance()->OutputError(std::string{ "Couldn't insert flux tensor at index {} already in" }.data());
        return false;
      }
      return true;
    }

    std::vector<float64> asStdVector(const eFFcomp& aFFcomp) const
    {
      std::vector<float64> w_stdVec;
      w_stdVec.reserve(m_fluxTensorMap.size());
      for(const auto& mapElem : m_fluxTensorMap | std::views::values)
      {
        if (aFFcomp==eFFcomp::FF1)
        {
           w_stdVec.push_back(mapElem.FF1);
        }
        else
        {
          w_stdVec.push_back(mapElem.FF2);
        }
      }
      return w_stdVec;
    }

    std::valarray<float64> asStdValArray(const eFFcomp& aFFcomp) const 
    {
      std::valarray<float64> w_stdValAray(m_fluxTensorMap.size());
      auto i = 0;
      for (const auto& mapElem : m_fluxTensorMap | std::views::values)
      {
        if (aFFcomp == eFFcomp::FF1)
        {
          w_stdValAray[i++] = mapElem.FF1;
        }
        else
        {
          w_stdValAray[i++] = mapElem.FF2;
        }
      }
      return w_stdValAray;
    }

    bool isNullValues(const eFFcomp& aFFcomp) const
    { 
      // give return value a name to use it as an 'lvalue'
      auto&& w_FF12 = asStdVector(aFFcomp);
      // Calling 'find_if_not' for a temporary, you have to pass it as an 'lvalue'
      auto pos = std::ranges::find_if_not(w_FF12, [](float64 aVal) { return aVal != 0.; });
      static_assert(!std::is_same_v<std::ranges::dangling, decltype(pos)>); // sanity check
      if( pos!=w_FF12.end())
      {
        return false;
      }
      return true;
    }

    bool hasNAN(const eFFcomp& aFFcomp) const
    {
      // give return value a name to use it as an 'lvalue'
      auto&& w_FF12 = asStdVector(aFFcomp);
      // 
      return std::ranges::any_of( w_FF12, [](float64 aNumber) { return std::isnan(aNumber); });
    }

    std::optional<FluxTensor> operator[] (short aIdx) const 
    { 
      if( auto pos = m_fluxTensorMap.find(aIdx); pos!=m_fluxTensorMap.end()) 
      {
        return std::optional<FluxTensor>{pos->second};
      }
      return std::nullopt; 
    }

    sizeMapType size() const noexcept { return m_fluxTensorMap.size(); }
    [[nodiscard]] bool isEmpty() const noexcept { return m_fluxTensorMap.empty(); }
    void clear() noexcept
    {
      if (!m_fluxTensorMap.empty()) m_fluxTensorMap.clear();
    }
  };
#endif
} // End of namespace