CD_ParticleContainer.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_PARTICLECONTAINER_H
#define CD_PARTICLECONTAINER_H
 
// Chombo includes
#include <Particle.H>
#include <ParticleData.H>
#include <ParticleValidRegion.H>
#include <BinItem.H>
#include <BinFab.H>
#include <ProblemDomain.H>
#include <DisjointBoxLayout.H>
#include <BaseEBCellFAB.H>
 
// Our includes
#include <CD_OpenMP.H>
#include <CD_LevelTiles.H>
#include <CD_ParticleMap.H>
#include <CD_NamespaceHeader.H>
 
template <class P>
using AMRParticles = Vector<RefCountedPtr<ParticleData<P>>>;
 
template <class P>
using AMRCellParticles = Vector<RefCountedPtr<LayoutData<BinFab<P>>>>;
 
template <class P>
class ParticleContainer
{
public:
  using ValidMask = RefCountedPtr<LevelData<BaseFab<bool>>>;
 
  ParticleContainer();
 
  ParticleContainer(const Vector<DisjointBoxLayout>&         a_grids,
                    const Vector<ProblemDomain>&             a_domains,
                    const Vector<Real>&                      a_dx,
                    const Vector<int>&                       a_refRat,
                    const Vector<ValidMask>&                 a_validMask,
                    const Vector<RefCountedPtr<LevelTiles>>& a_levelTiles,
                    const RealVect&                          a_probLo,
                    int                                      a_blockingFactor,
                    int                                      a_finestLevel,
                    std::string                              a_realm);
 
  virtual ~ParticleContainer();
 
  ParticleContainer(const ParticleContainer&) = delete;
  ParticleContainer&
  operator=(const ParticleContainer&) = delete;
 
  ParticleContainer(ParticleContainer&&) = default;
 
  ParticleContainer&
  operator=(ParticleContainer&&) = default;
 
  void
  define(const Vector<DisjointBoxLayout>&         a_grids,
         const Vector<ProblemDomain>&             a_domains,
         const Vector<Real>&                      a_dx,
         const Vector<int>&                       a_refRat,
         const Vector<ValidMask>&                 a_validMask,
         const Vector<RefCountedPtr<LevelTiles>>& a_levelTiles,
         const RealVect&                          a_probLo,
         int                                      a_blockingFactor,
         int                                      a_finestLevel,
         const std::string&                       a_realm);
 
  void
  regrid(const Vector<DisjointBoxLayout>&         a_grids,
         const Vector<ProblemDomain>&             a_domains,
         const Vector<Real>&                      a_dx,
         const Vector<int>&                       a_refRat,
         const Vector<ValidMask>&                 a_validMask,
         const Vector<RefCountedPtr<LevelTiles>>& a_levelTiles,
         int                                      a_base,
         int                                      a_newFinestLevel);
 
  void
  preRegrid(int a_lmin);
 
  void
  resetParticleIDs() noexcept;
 
  void
  copyMaskParticles(const Vector<RefCountedPtr<LevelData<BaseFab<bool>>>>& a_mask) const;
 
  void
  copyMaskParticles(int a_level, const LevelData<BaseFab<bool>>& a_mask) const;
 
  void
  transferMaskParticles(const Vector<RefCountedPtr<LevelData<BaseFab<bool>>>>& a_mask);
 
  void
  transferMaskParticles(int a_level, const LevelData<BaseFab<bool>>& a_mask);
 
  void
  sortParticles() noexcept;
 
  void
  clearParticles();
 
  void
  clearBufferParticles() const;
 
  void
  clearMaskParticles() const;
 
  void
  clearOutcast() noexcept;
 
  void
  clear(AMRParticles<P>& a_particles) const;
 
  bool
  isOrganizedByCell() const;
 
  int
  getFinestLevel() const;
 
  std::string
  getRealm() const;
 
  AMRParticles<P>&
  getParticles();
 
  const AMRParticles<P>&
  getParticles() const;
 
  AMRParticles<P>&
  getBufferParticles();
 
  const AMRParticles<P>&
  getBufferParticles() const;
 
  AMRParticles<P>&
  getMaskParticles();
 
  const AMRParticles<P>&
  getMaskParticles() const;
 
  const Vector<DisjointBoxLayout>&
  getGrids() const;
 
  RealVect
  getProbLo() const noexcept;
 
  Vector<RealVect>
  getDx() const noexcept;
 
  ParticleData<P>&
  operator[](int a_lvl);
 
  const ParticleData<P>&
  operator[](int a_level) const;
 
  AMRCellParticles<P>&
  getCellParticles();
 
  const AMRCellParticles<P>&
  getCellParticles() const;
 
  LayoutData<BinFab<P>>&
  getCellParticles(int a_level);
 
  const LayoutData<BinFab<P>>&
  getCellParticles(int a_level) const;
 
  BinFab<P>&
  getCellParticles(int a_level, const DataIndex& a_dit);
 
  const BinFab<P>&
  getCellParticles(int a_level, const DataIndex& a_dit) const;
 
  void
  getCellParticles(BinFab<P>& a_cellParticles, int a_lvl, const DataIndex& a_dit) const;
 
  void
  getCellParticlesDestructive(BinFab<P>& a_cellParticles, int a_lvl, const DataIndex& a_dit);
 
  void
  organizeParticlesByCell();
 
  void
  organizeParticlesByPatch();
 
  void
  addParticles(const List<P>& a_particles);
 
  void
  addParticlesDestructive(List<P>& a_particles);
 
  void
  addParticles(const BinFab<P>& a_particles, int a_lvl, const DataIndex& a_dit);
 
  void
  addParticlesDestructive(BinFab<P>& a_particles, int a_lvl, const DataIndex& a_dit);
 
  void
  addParticles(const ParticleContainer<P>& a_otherContainer);
 
  void
  addParticlesDestructive(ParticleContainer<P>& a_otherContainer);
 
  void
  sanityCheck() const noexcept;
 
  void
  remap();
 
  void
  transferParticles(ParticleContainer<P>& a_otherContainer);
 
  void
  transferParticles(AMRParticles<P>& a_otherContainer);
 
  void
  admitValidParticles(List<P>& a_evictedParticles, ParticleData<P>& a_particles, int a_coarseLevel);
 
  template <Real& (P::*particleScalarField)()>
  inline void
  setValue(Real a_value);
 
  template <RealVect& (P::*particleVectorField)()>
  inline void
  setValue(const RealVect& a_value);
 
  unsigned long long
  getNumberOfValidParticlesLocal() const;
 
  unsigned long long
  getNumberOfValidParticlesGlobal() const;
 
  unsigned long long
  getNumberOfOutcastParticlesLocal() const;
 
  unsigned long long
  getNumberOfOutcastParticlesGlobal() const;
 
  unsigned long long
  getNumberOfMaskParticlesLocal() const;
 
  unsigned long long
  getNumberOfMaskParticlesGlobal() const;
 
protected:
  // Reductions for performing catenation and join operations in a thread-safe manner.
#pragma omp declare reduction(catenate : List<P> : ThreadSafeCatenation<P>(omp_out, omp_in))
#pragma omp declare reduction(join : List<P> : ThreadSafeJoin<P>(omp_out, omp_in))
 
  std::string m_realm;
 
  int m_blockingFactor;
 
  int m_finestLevel;
 
  RealVect m_probLo;
 
  bool m_isDefined = false;
 
  bool m_isOrganizedByCell = false;
 
  bool m_profile = false;
 
  bool m_debug = false;
 
  bool m_verbose = false;
 
  Vector<RefCountedPtr<LevelTiles>> m_levelTiles;
 
  Vector<DisjointBoxLayout> m_grids;
 
  Vector<DisjointBoxLayout> m_oldGrids;
 
  Vector<ProblemDomain> m_domains;
 
  Vector<RefCountedPtr<LevelData<BaseFab<bool>>>> m_validRegion;
 
  Vector<BoxLayout> m_grownGrids;
 
  Vector<RealVect> m_dx;
 
  Vector<int> m_refRat;
 
  mutable AMRParticles<P> m_particles;
 
  mutable AMRParticles<P> m_bufferParticles;
 
  mutable AMRParticles<P> m_maskParticles;
 
  AMRParticles<P> m_cacheParticles;
 
  AMRCellParticles<P> m_cellSortedParticles;
 
  void
  setupGrownGrids(int a_base, int a_finestLevel);
 
  void
  setupParticleData(int a_base, int a_finestLevel);
 
  inline void
  transferParticlesToSingleList(List<P>& a_list, AMRParticles<P>& a_particles) const noexcept;
 
  inline void
  copyParticlesToSingleList(List<P>& a_list, const AMRParticles<P>& a_particles) const noexcept;
 
  inline void
  mapParticlesToAMRGrid(std::vector<ParticleMap<List<P>>>& a_mappedParticles,
                        List<P>&                           a_unmappedParticles) const noexcept;
 
  inline void
  catenateParticleMaps(std::vector<ParticleMap<List<P>>>& a_globalParticles,
                       std::vector<ParticleMap<List<P>>>& a_localParticles) const noexcept;
 
  inline void
  assignLocalParticles(ParticleMap<List<P>>& a_mappedParticles, AMRParticles<P>& a_particleData) const noexcept;
};
 
#include <CD_NamespaceFooter.H>
 
#include <CD_ParticleContainerImplem.H>
 
#endif