CD_ParticleContainer.H

Go to the documentation of this file.

/* chombo-discharge
 * Copyright © 2021 SINTEF Energy Research.
 * Please refer to Copyright.txt and LICENSE in the chombo-discharge root directory.
 */
 
#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_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,
                    const int                                a_blockingFactor,
                    const int                                a_finestLevel,
                    const std::string                        a_realm);
 
  virtual ~ParticleContainer();
 
  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,
         const int                                a_blockingFactor,
         const 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,
         const int                                a_base,
         const int                                a_newFinestLevel);
 
  void
  preRegrid(const int a_base);
 
  void
  copyMaskParticles(const Vector<RefCountedPtr<LevelData<BaseFab<bool>>>>& a_mask) const;
 
  void
  copyMaskParticles(const int a_level, const LevelData<BaseFab<bool>>& a_mask) const;
 
  void
  transferMaskParticles(const Vector<RefCountedPtr<LevelData<BaseFab<bool>>>>& a_mask);
 
  void
  transferMaskParticles(const 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;
 
  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;
 
  const RealVect
  getProbLo() const noexcept;
 
  const Vector<RealVect>
  getDx() const noexcept;
 
  ParticleData<P>&
  operator[](const int a_level);
 
  const ParticleData<P>&
  operator[](const int a_level) const;
 
  AMRCellParticles<P>&
  getCellParticles();
 
  const AMRCellParticles<P>&
  getCellParticles() const;
 
  LayoutData<BinFab<P>>&
  getCellParticles(const int a_level);
 
  const LayoutData<BinFab<P>>&
  getCellParticles(const int a_level) const;
 
  BinFab<P>&
  getCellParticles(const int a_level, const DataIndex a_dit);
 
  const BinFab<P>&
  getCellParticles(const int a_level, const DataIndex a_dit) const;
 
  void
  getCellParticles(BinFab<P>& a_cellParticles, const int a_lvl, const DataIndex a_dit) const;
 
  void
  getCellParticlesDestructive(BinFab<P>& a_cellParticles, const 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, const int a_lvl, const DataIndex a_dit);
 
  void
  addParticlesDestructive(BinFab<P>& a_particles, const 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, const int a_coarseLevel);
 
  template <Real& (P::*particleScalarField)()>
  inline void
  setValue(const 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;
 
  bool m_isOrganizedByCell;
 
  bool m_profile;
 
  bool m_debug;
 
  bool m_verbose;
 
  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(const int a_base, const int a_finestLevel);
 
  void
  setupParticleData(const int a_base, const 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<std::map<std::pair<unsigned int, unsigned int>, List<P>>>& a_mappedParticles,
                        List<P>& a_unmappedParticles) const noexcept;
 
  inline void
  catenateParticleMaps(
    std::vector<std::map<std::pair<unsigned int, unsigned int>, List<P>>>& a_globalParticles,
    std::vector<std::map<std::pair<unsigned int, unsigned int>, List<P>>>& a_localParticles) const noexcept;
 
  inline void
  assignLocalParticles(std::map<std::pair<unsigned int, unsigned int>, List<P>>& a_mappedParticles,
                       AMRParticles<P>&                                          a_particleData) const noexcept;
};
 
#include <CD_NamespaceFooter.H>
 
#include <CD_ParticleContainerImplem.H>
 
#endif