dbpp_Uh.h

Go to the documentation of this file.

#pragma once
 
// STL includes
#include <vector>
#include <functional>
// Boost include
#include <boost/iterator/transform_iterator.hpp>
// SfxBase19 include
#include "include/Sfx_DefineTypes.h"
// VS19 includes
#include  "dbpp_Enumerations.h"
#include "dbpp_NodalTpl.hpp"
#include "dbpp_Omega.h"
 
namespace dbpp 
{
    class Uh
    {
  public:
    using NodalValue = NodalTpl<unsigned/*Id*/, float64/*A*/, float64/*Q*/, float64/*H*/>;
    public:
    using vec_nval = std::vector<NodalValue>;
    using value_type = vec_nval::value_type;
    using pointer = value_type*;
    using iterator = pointer;
    using const_pointer = const value_type*;
    using const_iterator = const_pointer;
    using reference = value_type&;
    using const_reference = const value_type&;
    using range_diff_type = ptrdiff_t;
    using reverse_iterator = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
    auto cbegin()  const { return m_vecNodalVarArray.cbegin(); }
    auto begin()         { return m_vecNodalVarArray.begin();  }
    auto cend()    const { return m_vecNodalVarArray.cend();   }
    auto end()           { return m_vecNodalVarArray.end();    }
    auto crbegin() const { return m_vecNodalVarArray.crbegin();}
    auto rbegin()        { return m_vecNodalVarArray.rbegin(); }
    auto rend()    const { return m_vecNodalVarArray.crend();  }
    auto crend()   const { return m_vecNodalVarArray.crend();  }
    public:
    Uh();
    Uh(int32 df, Omega& oh); 
    std::vector<double> to_stdVector( eNodalField aNvalComp = eNodalField::A) const
    {
      using namespace boost;
 
      std::function<double(const NodalValue&)> w_getA = [](const NodalValue& aVal) -> double { return std::get<1>(aVal.m_tpl); };
      std::function<double(const NodalValue&)> w_getQ = [](const NodalValue& aVal) -> double { return std::get<2>(aVal.m_tpl); };
      std::function<double(const NodalValue&)> w_getH = [](const NodalValue& aVal) -> double { return std::get<3>(aVal.m_tpl); };
      
      using enum  eNodalVarComp;
      
      switch (aNvalComp)
      {
      case eNodalField::A:
      {
        return std::vector<double>(make_transform_iterator(m_vecNodalVarArray.begin(), w_getA),
          make_transform_iterator(m_vecNodalVarArray.end(), w_getA));
        break;
      }
      case eNodalField::Q:
      {
        return std::vector<double>(make_transform_iterator(m_vecNodalVarArray.begin(), w_getQ),
          make_transform_iterator(m_vecNodalVarArray.end(), w_getQ));
        break;
      }
      case eNodalField::H:
      {
        return std::vector<double>(make_transform_iterator(m_vecNodalVarArray.begin(), w_getH),
          make_transform_iterator(m_vecNodalVarArray.end(), w_getH));
        break;
      }
      default:
        // log something in the log file!!!
        std::cerr << "Cannot return an invalid type in GlobalDiscretization\n";
        return std::vector<float64>(); // empty vector
        break;
      }
    }

     vec_nval& vecNodalVarArray()       { return m_vecNodalVarArray; }
    const vec_nval& vecNodalVarArray() const { return m_vecNodalVarArray; }
          NodalValue& operator[] (int32 nn)       { return m_vecNodalVarArray[nn]; }
    const NodalValue& operator[] (int32 nn) const { return m_vecNodalVarArray[nn]; }
    std::size_t total_node_no() const { return m_totalNodeNo; }
 
    //  U_h& operator= ( Gamma_h& gh);
    
    friend std::ostream& operator<< (std::ostream&, Uh&);
  private:
        int32 ndf;                   
        std::size_t m_totalNodeNo;   
        vec_nval m_vecNodalVarArray; 
    };
} // End of namespace