grid.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2014-2022
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */
 
#ifndef SRC_INCLUDE_SMASH_GRID_H_
#define SRC_INCLUDE_SMASH_GRID_H_
 
#include <array>
#include <cmath>
#include <functional>
#include <utility>
#include <vector>
 
#include "forwarddeclarations.h"
#include "particles.h"
 
namespace smash {
 
enum class GridOptions : char {
  Normal = 0,
  PeriodicBoundaries = 1
};
 
enum class CellSizeStrategy : char {
  Optimal,
 
  Largest
};
 
enum class CellNumberLimitation : char {
  None,
 
  ParticleNumber
};
 
class GridBase {
 public:
  typedef int SizeType;
 
 protected:
  static std::pair<std::array<double, 3>, std::array<double, 3>>
  find_min_and_length(const Particles &particles);
};
 
template <GridOptions Options = GridOptions::Normal>
class Grid : public GridBase {
 public:
  Grid(const Particles &particles, double min_cell_length,
       double timestep_duration, CellNumberLimitation limit,
       const bool include_unformed_particles = false,
       CellSizeStrategy strategy = CellSizeStrategy::Optimal)
      : Grid{find_min_and_length(particles),
             std::move(particles),
             min_cell_length,
             timestep_duration,
             limit,
             include_unformed_particles,
             strategy} {}
 
  Grid(const std::pair<std::array<double, 3>, std::array<double, 3>>
           &min_and_length,
       const Particles &particles, double min_cell_length,
       double timestep_duration, CellNumberLimitation limit,
       const bool include_unformed_particles = false,
       CellSizeStrategy strategy = CellSizeStrategy::Optimal);
 
  void iterate_cells(
      const std::function<void(const ParticleList &)> &search_cell_callback,
      const std::function<void(const ParticleList &, const ParticleList &)>
          &neighbor_cell_callback) const;
 
  double cell_volume() const { return cell_volume_; }
 
 private:
  SizeType make_index(SizeType x, SizeType y, SizeType z) const;
 
  SizeType make_index(std::array<SizeType, 3> idx) const {
    return make_index(idx[0], idx[1], idx[2]);
  }
 
  const std::array<double, 3> length_;
 
  double cell_volume_;
 
  std::array<int, 3> number_of_cells_;
 
  std::vector<ParticleList> cells_;
};
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_GRID_H_