CD_McPhoto.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_McPhoto_H
#define CD_McPhoto_H
 
// Std includes
#include <random>
 
// Chombo includes
#include <Particle.H>
#include <ParticleData.H>
#include <BinItem.H>
 
// Our includes
#include <CD_RtSolver.H>
#include <CD_EBParticleMesh.H>
#include <CD_ParticleContainer.H>
#include <CD_Photon.H>
#include <CD_PointParticle.H>
#include <CD_NamespaceHeader.H>
 
class McPhoto : public RtSolver
{
public:
  enum class WhichContainer
  {
    Photons,
    Bulk,
    EB,
    Domain,
    Source
  };
 
  McPhoto();
 
  McPhoto(const McPhoto& a_other);
 
  McPhoto(const McPhoto&& a_other);
 
  McPhoto&
  operator=(const McPhoto& a_other);
 
  McPhoto&
  operator=(const McPhoto&& a_other);
 
  virtual ~McPhoto();
 
  virtual bool
  advance(const Real a_dt, EBAMRCellData& a_phi, const EBAMRCellData& a_source, const bool a_zeroPhi = false) override;
 
  virtual bool
  isInstantaneous();
 
  virtual void
  advancePhotonsInstantaneous(ParticleContainer<Photon>& a_bulkPhotons,
                              ParticleContainer<Photon>& a_ebPhotons,
                              ParticleContainer<Photon>& a_domainPhotons,
                              ParticleContainer<Photon>& a_photons);
 
  virtual void
  advancePhotonsTransient(ParticleContainer<Photon>& a_bulkPhotons,
                          ParticleContainer<Photon>& a_ebPhotons,
                          ParticleContainer<Photon>& a_domainPhotons,
                          ParticleContainer<Photon>& a_photons,
                          const Real                 a_dt);
 
  virtual void
  computeNumPhysicalPhotons(EBAMRCellData&       a_numPhysPhotonsTotal,
                            EBAMRCellData&       a_numPhysPhotonsPerPacket,
                            const EBAMRCellData& a_source,
                            const Real           a_dt) const noexcept;
 
  virtual void
  generateComputationalPhotons(ParticleContainer<Photon>& a_photons,
                               const EBAMRCellData&       a_numPhysicalPhotons,
                               const size_t               a_maxPhotonsPerCell) const noexcept;
 
  virtual void
  dirtySamplePhotons(ParticleContainer<PointParticle>& a_photons,
                     EBAMRCellData&                    a_phi,
                     const EBAMRCellData&              a_numPhysicalPhotons,
                     const size_t                      a_maxPhotonsPerCell) const noexcept;
 
  virtual void
  remap();
 
  virtual void
  remap(ParticleContainer<Photon>& a_photons);
 
  virtual void
  depositPhotons();
 
  template <class P, const Real& (P::*particleScalarField)() const>
  void
  depositPhotons(EBAMRCellData&        a_phi,
                 ParticleContainer<P>& a_particles,
                 const DepositionType& a_deposition) const noexcept;
 
  virtual void
  sortPhotonsByCell(const WhichContainer& a_which);
 
  virtual void
  sortPhotonsByPatch(const WhichContainer& a_which);
 
  virtual void
  parseOptions() override;
 
  virtual void
  parseRuntimeOptions() override;
 
  virtual void
  allocate() override;
 
  virtual void
  preRegrid(const int a_base, const int a_oldFinestLevel) override;
 
  virtual void
  deallocate() override;
 
  virtual void
  regrid(const int a_lmin, const int a_oldFinestLevel, const int a_newFinestLevel) override;
 
  virtual void
  registerOperators() override;
 
  virtual void
  computeBoundaryFlux(EBAMRIVData& a_ebFlux, const EBAMRCellData& a_phi) override;
 
  virtual void
  computeDomainFlux(EBAMRIFData& a_domainFlux, const EBAMRCellData& a_phi) override;
 
  virtual void
  computeFlux(EBAMRCellData& a_flux, const EBAMRCellData& a_phi) override;
 
  virtual void
  computeDensity(EBAMRCellData& a_isotropic, const EBAMRCellData& a_phi) override;
 
  virtual void
  clear(const WhichContainer& a_which);
 
  virtual void
  clear();
 
  virtual void
  clear(ParticleContainer<Photon>& a_photons);
 
  virtual void
  clear(AMRParticles<Photon>& a_photons);
 
  virtual void
  writePlotFile() override;
 
  virtual void
  writePlotData(LevelData<EBCellFAB>& a_output,
                int&                  a_icomp,
                const std::string     a_outputRealm,
                const int             a_level) const noexcept override;
 
#ifdef CH_USE_HDF5
  virtual void
  writeCheckpointLevel(HDF5Handle& a_handle, const int a_level) const override;
#endif
 
#ifdef CH_USE_HDF5
  virtual void
  readCheckpointLevel(HDF5Handle& a_handle, const int a_level) override;
#endif
 
  virtual Vector<std::string>
  getPlotVariableNames() const override;
 
  virtual int
  getNumberOfPlotVariables() const override;
 
  virtual int
  countPhotons(const AMRParticles<Photon>& a_photons) const;
 
  virtual ParticleContainer<Photon>&
  getPhotons();
 
  virtual ParticleContainer<Photon>&
  getBulkPhotons();
 
  virtual ParticleContainer<Photon>&
  getEbPhotons();
 
  virtual ParticleContainer<Photon>&
  getDomainPhotons();
 
  virtual ParticleContainer<Photon>&
  getSourcePhotons();
 
  virtual int
  getMaxPhotonsPerCell() const noexcept;
 
  virtual int
  getNumSamplingPackets() const noexcept;
 
  virtual void
  computeLoads(Vector<long long>& a_loads, const DisjointBoxLayout& a_dbl, const int a_level) const noexcept override;
 
protected:
  enum class PhotonGeneration
  {
    Deterministic,
    Stochastic
  };
 
  enum class SourceType
  {
    Number,
    PerVol,
    PerVolSecond,
    PerSecond
  };
 
  enum class IntersectionEB
  {
    Raycast,
    Bisection,
  };
 
  bool m_transparentEB;
 
  bool m_instantaneous;
 
  bool m_blendConservation;
 
  bool m_depositNumber;
 
  bool m_plotNumbers;
 
  bool m_plotPhotons;
 
  bool m_plotBulkPhotons;
 
  bool m_plotSourcePhotons;
 
  bool m_plotEBPhotons;
 
  bool m_plotDomainPhotons;
 
  bool m_dirtySampling;
 
  size_t m_maxPhotonsGeneratedPerCell;
 
  int m_numSamplingPackets;
 
  int m_seed;
 
  int m_haloBuffer;
 
  Real m_bisectStep;
 
  PhotonGeneration m_photoGenerationMethod;
 
  SourceType m_sourceType;
 
  IntersectionEB m_intersectionEB;
 
  DepositionType m_deposition;
 
  CoarseFineDeposition m_coarseFineDeposition;
 
  mutable EBAMRCellData m_scratch;
 
  mutable EBAMRIVData m_depositionNC;
 
  mutable EBAMRIVData m_massDiff;
 
  ParticleContainer<Photon> m_photons;
 
  ParticleContainer<Photon> m_bulkPhotons;
 
  ParticleContainer<Photon> m_ebPhotons;
 
  ParticleContainer<Photon> m_domainPhotons;
 
  ParticleContainer<Photon> m_sourcePhotons;
 
  size_t
  drawPhotons(const Real a_source, const Real a_volume, const Real a_dt) const noexcept;
 
  int
  domainBcMap(const int a_dir, const Side::LoHiSide a_side);
 
  Real
  randomExponential(const Real a_mean) const noexcept;
 
  template <class P, const Real& (P::*particleScalarField)() const>
  void
  depositKappaConservative(EBAMRCellData&             a_phi,
                           ParticleContainer<P>&      a_particles,
                           const DepositionType       a_deposition,
                           const CoarseFineDeposition a_coarseFineDeposition) const noexcept;
 
  void
  depositNonConservative(EBAMRIVData& a_depositionNC, const EBAMRCellData& a_depositionKappaC) const noexcept;
 
  void
  depositHybrid(EBAMRCellData&     a_depositionH,
                EBAMRIVData&       a_massDifference,
                const EBAMRIVData& a_depositionNC) const noexcept;
 
  void
  parseTransparentBoundaries();
 
  void
  parseDirtySampling();
 
  void
  parseDivergenceComputation();
 
  void
  parsePseudoPhotons();
 
  void
  parsePhotoGeneration();
 
  void
  parseInstantaneous();
 
  void
  parseSourceType();
 
  void
  parseIntersectionEB();
 
  void
  parseDeposition();
 
  void
  parsePlotVariables();
 
  virtual void
  depositPhotonsNGP(LevelData<EBCellFAB>&            a_output,
                    const ParticleContainer<Photon>& a_particles,
                    const int                        a_level) const noexcept;
};
 
#include <CD_NamespaceFooter.H>
 
#include <CD_McPhotoImplem.H>
 
#endif