CD_LevelTiles.H

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2021-2026 SINTEF Energy Research
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 */
 
#ifndef CD_LEVELTILES_H
#define CD_LEVELTILES_H
 
// Std includes
#include <cmath>
#include <cstddef>
#include <unordered_map>
#include <vector>
 
// Chombo includes
#include <IntVect.H>
#include <RealVect.H>
#include <Vector.H>
#include <RefCountedPtr.H>
#include <SPMD.H>
#include <DisjointBoxLayout.H>
#include <DataIndex.H>
 
// Our includes
#include <CD_NamespaceHeader.H>
 
class LevelTiles
{
public:
  using BoxIDs = std::pair<unsigned int, unsigned int>;
 
  struct TileHasher
  {
    std::size_t
    operator()(const IntVect& a_tile) const noexcept
    {
      std::size_t hash = 14695981039346656037ULL; // FNV-1a 64-bit offset basis
      for (int dir = 0; dir < SpaceDim; dir++) {
        hash ^= static_cast<std::size_t>(static_cast<unsigned int>(a_tile[dir]));
        hash *= 1099511628211ULL;
      }
      return hash;
    }
  };
 
  LevelTiles() noexcept;
 
  LevelTiles(const DisjointBoxLayout& a_dbl, const int a_minBlockSize) noexcept;
 
  virtual ~LevelTiles() noexcept;
 
  virtual void
  define(const DisjointBoxLayout& a_dbl, const int a_minBlockSize) noexcept;
 
  virtual const std::unordered_map<IntVect, unsigned int, TileHasher>&
  getMyTiles() const noexcept;
 
  virtual const std::unordered_map<IntVect, BoxIDs, TileHasher>&
  getOtherTiles() const noexcept;
 
  virtual const std::unordered_map<unsigned int, DataIndex>&
  getMyGrids() const noexcept;
 
  struct LevelAndBox
  {
    int level;
 
    unsigned int gridIndex;
 
    int rank;
 
    bool valid;
  };
 
  static inline LevelAndBox
  findDestination(const RealVect&                          a_pos,
                  const RealVect&                          a_probLo,
                  const Vector<RealVect>&                  a_dx,
                  const int                                a_minBlockSize,
                  const Vector<RefCountedPtr<LevelTiles>>& a_levelTiles,
                  const int                                a_finestLevel) noexcept
  {
    // Finest level whose min-block tile contains the point wins.
    for (int lvl = a_finestLevel; lvl >= 0; lvl--) {
      IntVect tile;
 
      for (int dir = 0; dir < SpaceDim; dir++) {
        tile[dir] = static_cast<int>(std::floor((a_pos[dir] - a_probLo[dir]) / (a_minBlockSize * a_dx[lvl][dir])));
      }
 
      const LevelTiles& tiles = *a_levelTiles[lvl];
 
      const auto& myTiles = tiles.getMyTiles();
      const auto  mit     = myTiles.find(tile);
 
      if (mit != myTiles.end()) {
        return LevelAndBox{lvl, mit->second, procID(), true};
      }
 
#ifdef CH_MPI
      const auto& otherTiles = tiles.getOtherTiles();
      const auto  oit        = otherTiles.find(tile);
 
      if (oit != otherTiles.end()) {
        return LevelAndBox{lvl, oit->second.first, static_cast<int>(oit->second.second), true};
      }
#endif
    }
 
    return LevelAndBox{-1, 0u, -1, false};
  }
 
protected:
  bool m_isDefined;
 
  std::unordered_map<IntVect, unsigned int, TileHasher> m_myTiles;
 
  std::unordered_map<IntVect, BoxIDs, TileHasher> m_otherTiles;
 
  std::unordered_map<unsigned int, DataIndex> m_myGrids;
};
 
#include <CD_NamespaceFooter.H>
 
#endif