Line data    Source code

       1              : // Implementation of coupling::indexing::CellIndex
       2              : 
       3              : namespace coupling {
       4              : namespace indexing {
       5              : 
       6              : template <unsigned int dim, IndexTrait... traits>
       7              : template <IndexTrait... converted_traits>
       8      9615200 : CellIndex<dim, traits...>::operator CellIndex<dim, converted_traits...>() const {
       9              : 
      10              :   // conversion: identical IndexType -> "copy constructor"
      11              :   if constexpr (std::is_same_v<CellIndex, CellIndex<dim, converted_traits...>>) {
      12              :     return CellIndex{_index};
      13              :   }
      14              : 
      15              : #if (COUPLING_MD_ERROR == COUPLING_MD_YES)
      16      9615200 :   if (!IndexingService<dim>::getInstance().isInitialized()) {
      17           16 :     throw std::runtime_error(std::string("coupling::indexing::CellIndex::operator CellIndex(): IndexingService not initialized! (I.e. you attempted to convert "
      18              :                                          "indices before defining their domains)"));
      19              :   }
      20              : #endif
      21              : 
      22              :   // conversion: non-BaseIndex -> BaseIndex
      23              :   if constexpr (std::is_same_v<CellIndex<dim, converted_traits...>, BaseIndex<dim>>) {
      24              :     // convert to vector if neccessary, then add offset, then construct a
      25              :     // BaseIndex from that tarch::la::Vector
      26     10832288 :     return BaseIndex<dim>{convertToVector<dim, traits...>(*this) + CellIndex<dim, traits...>::lowerBoundary.get()};
      27              :   }
      28              : 
      29              :   // conversion: BaseIndex -> non-BaseIndex
      30              :   if constexpr (std::is_same_v<CellIndex, BaseIndex<dim>>) {
      31              :     // convert to scalar if neccessary + construct CellIndex<dim,
      32              :     // converted_traits...>
      33              :     if constexpr ((TraitOperations::is_same<IndexTrait::vector>(converted_traits) or ...)) {
      34      4901160 :       return CellIndex<dim, converted_traits...>{(*this - CellIndex<dim, converted_traits...>::lowerBoundary).get()};
      35              :     } else /* result index is not a vector */ {
      36              :       // get scalar version of i_vec by first constructing a BaseIndex and then
      37              :       // converting it
      38      1293264 :       const unsigned int i_sca{// Get BaseIndex (i.e. traits=vector) and convert that to scalar
      39      1293264 :                                convertToScalar<dim, IndexTrait::vector, converted_traits...>(CellIndex<dim, IndexTrait::vector, converted_traits...>(
      40      3879792 :                                    (*this - CellIndex<dim, converted_traits...>::lowerBoundary).get()))};
      41              : 
      42      1293264 :       return CellIndex<dim, converted_traits...>{i_sca};
      43              :     }
      44              :   }
      45              : 
      46              :   // conversion: non-BaseIndex -> different non-BaseIndex
      47              :   // call this -> BaseIndex conversion
      48      1925552 :   BaseIndex<dim> b{*this};
      49              :   // call BaseIndex -> target index type conversion
      50      1925552 :   return CellIndex<dim, converted_traits...>{b};
      51              : }
      52              : 
      53              : // Overloading operator<< for CellIndex
      54           64 : template <unsigned int dim, IndexTrait... traits> std::ostream& operator<<(std::ostream& os, const CellIndex<dim, traits...>& i) {
      55           64 :   os << i.get();
      56           64 :   return os;
      57              : }
      58              : 
      59              : // Overloading arithmetic operators for CellIndex
      60              : template <unsigned int dim, IndexTrait... traits>
      61              : CellIndex<dim, traits...> operator+(const CellIndex<dim, traits...>& i1, const CellIndex<dim, traits...>& i2) {
      62              :   if constexpr (std::is_same_v<CellIndex<dim, traits...>, BaseIndex<dim>>)
      63              :     return BaseIndex<dim>{i1.get() + i2.get()};
      64              :   else
      65              :     return BaseIndex<dim>{i1} + BaseIndex<dim>{i2};
      66              : }
      67              : 
      68              : template <unsigned int dim, IndexTrait... traits>
      69      2274260 : coupling::indexing::CellIndex<dim, traits...> operator-(const CellIndex<dim, traits...>& i1, const CellIndex<dim, traits...>& i2) {
      70              :   if constexpr (std::is_same_v<CellIndex<dim, traits...>, BaseIndex<dim>>)
      71      9097040 :     return BaseIndex<dim>{i1.get() - i2.get()};
      72              :   else
      73              :     return BaseIndex<dim>{i1} - BaseIndex<dim>{i2};
      74              : }
      75              : 
      76              : template <unsigned int dim, IndexTrait... traits>
      77              : CellIndex<dim, traits...> operator+(const CellIndex<dim, traits...>& i1, const typename CellIndex<dim, traits...>::value_T& raw_i) {
      78              :   return CellIndex<dim, traits...>{i1.get() + raw_i};
      79              : }
      80              : 
      81              : template <unsigned int dim, IndexTrait... traits>
      82              : coupling::indexing::CellIndex<dim, traits...> operator-(const CellIndex<dim, traits...>& i1, const typename CellIndex<dim, traits...>::value_T& raw_i) {
      83              :   return CellIndex<dim, traits...>{i1.get() - raw_i};
      84              : }
      85              : 
      86              : } // namespace indexing
      87              : } // namespace coupling