CD_ItoSolver.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_ItoSolver_H
#define CD_ItoSolver_H
 
// Our includes
#include <CD_AmrMesh.H>
#include <CD_ComputationalGeometry.H>
#include <CD_ItoSpecies.H>
#include <CD_ItoParticle.H>
#include <CD_EBParticleMesh.H>
#include <CD_ParticleContainer.H>
#include <CD_EBRepresentation.H>
#include <CD_EBIntersection.H>
#include <CD_CellInfo.H>
#include <CD_ParticleManagement.H>
#include <CD_NamespaceHeader.H>
 
class ItoSolver
{
public:
  enum class WhichContainer
  {
    Bulk,
    EB,
    Domain,
    Source,
    Covered,
    Scratch
  };
 
  ItoSolver();
 
  virtual ~ItoSolver();
 
  virtual void
  setParticleMerger(const ParticleManagement::ParticleMerger<ItoParticle>& a_particleMerger) noexcept;
 
  virtual std::string
  getName() const;
 
  virtual const std::string
  getRealm() const;
 
  virtual void
  setRealm(const std::string a_realm);
 
  virtual void
  parseOptions();
 
  virtual void
  parseRuntimeOptions();
 
  virtual EBIntersection
  getIntersectionAlgorithm() const noexcept;
 
  virtual void
  initialData();
 
  virtual void
  generateParticlesFromDensity(ParticleContainer<ItoParticle>&              a_particles,
                               const std::function<Real(const RealVect x)>& a_densityFunc,
                               const int                                    a_maxParticlesPerCell) const noexcept;
 
  virtual void
  regrid(const int a_lmin, const int a_oldFinestLevel, const int a_newFinestLevel);
 
  virtual void
  allocate();
 
  virtual void
  clear(const WhichContainer a_container);
 
  virtual void
  clear(ParticleContainer<ItoParticle>& a_particles) const;
 
  virtual void
  clear(AMRParticles<ItoParticle>& a_particles) const;
 
  virtual void
  depositConductivity(EBAMRCellData& a_phi, ParticleContainer<ItoParticle>& a_particles) const;
 
  virtual void
  depositConductivity(EBAMRCellData&                  a_phi,
                      ParticleContainer<ItoParticle>& a_particles,
                      const DepositionType            a_deposition,
                      const CoarseFineDeposition      a_coarseFineDeposition) const;
 
  virtual void
  depositDiffusivity(EBAMRCellData& a_phi, ParticleContainer<ItoParticle>& a_particles) const;
 
  virtual void
  depositDiffusivity(EBAMRCellData&                  a_phi,
                     ParticleContainer<ItoParticle>& a_particles,
                     const DepositionType            a_deposition,
                     const CoarseFineDeposition      a_coarseFineDeposition) const;
 
  virtual void
  depositEnergyDensity(EBAMRCellData& a_phi, ParticleContainer<ItoParticle>& a_particles) const;
 
  virtual void
  depositEnergyDensity(EBAMRCellData&                  a_phi,
                       ParticleContainer<ItoParticle>& a_particles,
                       const DepositionType            a_deposition,
                       const CoarseFineDeposition      a_coarseFineDeposition) const;
 
  virtual void
  computeAverageMobility(EBAMRCellData& a_phi, ParticleContainer<ItoParticle>& a_particles) const;
 
  virtual void
  computeAverageDiffusion(EBAMRCellData& a_phi, ParticleContainer<ItoParticle>& a_particles) const;
 
  virtual void
  computeAverageEnergy(EBAMRCellData& a_phi, ParticleContainer<ItoParticle>& a_particles) const;
 
  virtual void
  depositParticles();
 
  virtual void
  depositParticles(const WhichContainer a_container);
 
  template <class P, class Ret, Ret (P ::*MemberFunc)() const>
  void
  depositParticlesNGP(LevelData<EBCellFAB>&       a_output,
                      const ParticleContainer<P>& a_particles,
                      const int                   a_level) const noexcept;
 
  template <class P, class Ret, Ret (P ::*MemberFunc)() const>
  void
  depositParticles(EBAMRCellData& a_phi, ParticleContainer<P>& a_particles) const;
 
  template <class P, class Ret, Ret (P ::*MemberFunc)() const>
  void
  depositParticles(EBAMRCellData&             a_phi,
                   ParticleContainer<P>&      a_particles,
                   const DepositionType       a_deposition,
                   const CoarseFineDeposition a_coarseFineDeposition) const;
 
  virtual void
  removeCoveredParticles(const EBRepresentation a_representation, const Real a_tol);
 
  virtual void
  removeCoveredParticles(const WhichContainer a_container, const EBRepresentation a_representation, const Real a_tol);
 
  virtual void
  removeCoveredParticles(ParticleContainer<ItoParticle>& a_particles,
                         const EBRepresentation          a_representation,
                         const Real                      a_tol) const;
 
  virtual void
  transferCoveredParticles(const EBRepresentation a_representation, const Real a_tol);
 
  virtual void
  transferCoveredParticles(const WhichContainer   a_containerFrom,
                           const WhichContainer   a_containerTo,
                           const EBRepresentation a_representation,
                           const Real             a_tol);
 
  virtual void
  transferCoveredParticles(ParticleContainer<ItoParticle>& a_particlesFrom,
                           ParticleContainer<ItoParticle>& a_particlesTo,
                           const EBRepresentation          a_representation,
                           const Real                      a_tol) const;
 
  virtual void
  intersectParticles(
    const EBIntersection                    a_ebIntersection,
    const bool                              a_deleteParticles,
    const std::function<void(ItoParticle&)> a_nonDeletionModifier = [](ItoParticle&) -> void {
      return;
    });
 
  virtual void
  intersectParticles(
    const WhichContainer                    a_particles,
    const WhichContainer                    a_ebParticles,
    const WhichContainer                    a_domainParticles,
    const EBIntersection                    a_ebIntersection,
    const bool                              a_deleteParticles,
    const std::function<void(ItoParticle&)> a_nonDeletionModifier = [](ItoParticle&) -> void {
      return;
    });
 
  virtual void
  intersectParticles(
    ParticleContainer<ItoParticle>&         a_particles,
    ParticleContainer<ItoParticle>&         a_ebParticles,
    ParticleContainer<ItoParticle>&         a_domainParticles,
    const EBIntersection                    a_ebIntersection,
    const bool                              a_deleteParticles,
    const std::function<void(ItoParticle&)> a_nonDeletionModifier = [](ItoParticle&) -> void {
      return;
    });
 
  virtual void
  computeLoads(Vector<long int>& a_loads, const DisjointBoxLayout& a_dbl, const int a_level);
 
  virtual int
  getNumberOfPlotVariables() const;
 
  virtual Vector<std::string>
  getPlotVariableNames() const;
 
  virtual void
  writePlotData(LevelData<EBCellFAB>& a_output,
                int&                  a_comp,
                const std::string     a_outputRealm,
                const int             a_level) const noexcept;
 
  virtual unsigned long long
  getNumParticles(const WhichContainer a_container, const bool a_localOnly) const;
 
  virtual void
  registerOperators() const;
 
  virtual void
  setComputationalGeometry(const RefCountedPtr<ComputationalGeometry>& a_computationalGeometry);
 
  virtual void
  setAmr(const RefCountedPtr<AmrMesh>& a_amr);
 
  virtual void
  setPhase(const phase::which_phase a_phase);
 
  virtual void
  setVerbosity(const int a_verbosity);
 
  virtual void
  setTime(const int a_step, const Real a_time, const Real a_dt);
 
#ifdef CH_USE_HDF5
  virtual void
  writeCheckpointLevel(HDF5Handle& a_handle, const int a_level) const;
#endif
 
#ifdef CH_USE_HDF5
  virtual void
  readCheckpointLevel(HDF5Handle& a_handle, const int a_level);
#endif
 
  virtual void
  setSpecies(const RefCountedPtr<ItoSpecies>& a_species);
 
  virtual void
  preRegrid(const int a_lbase, const int a_oldFinestLevel);
 
  template <ItoSolver::WhichContainer C = WhichContainer::Bulk>
  void
  addParticles(ListBox<ItoParticle>& a_inputParticles,
               const int             a_lvl,
               const DataIndex       a_dit,
               const bool            a_destructive);
 
  virtual bool
  isMobile() const;
 
  virtual bool
  isDiffusive() const;
 
  virtual ParticleContainer<ItoParticle>&
  getParticles(const WhichContainer a_container);
 
  virtual const ParticleContainer<ItoParticle>&
  getParticles(const WhichContainer a_container) const;
 
  virtual const RefCountedPtr<ItoSpecies>&
  getSpecies() const;
 
  virtual EBAMRCellData&
  getPhi();
 
  virtual EBAMRCellData&
  getVelocityFunction();
 
  virtual const EBAMRCellData&
  getVelocityFunction() const;
 
  virtual EBAMRCellData&
  getDiffusionFunction();
 
  virtual const EBAMRCellData&
  getDiffusionFunction() const;
 
  virtual EBAMRCellData&
  getMobilityFunction();
 
  virtual const EBAMRCellData&
  getMobilityFunction() const;
 
  virtual void
  setDiffusionFunction(const Real a_diffusionCoefficient);
 
  virtual void
  setVelocityFunction(const RealVect a_velocity);
 
  virtual void
  setParticleMobility(const Real a_mobility);
 
  virtual void
  setParticleDiffusion(const Real a_diffusion);
 
  virtual void
  interpolateVelocities();
 
  virtual void
  interpolateVelocities(const int a_level, const DataIndex& a_dit);
 
  virtual void
  interpolateMobilities();
 
  virtual void
  updateMobilities();
 
  virtual void
  interpolateDiffusion();
 
  virtual void
  updateDiffusion();
 
  virtual void
  organizeParticlesByCell(const WhichContainer a_container);
 
  virtual void
  organizeParticlesByPatch(const WhichContainer a_container);
 
  virtual void
  makeSuperparticles(const WhichContainer a_container, const int a_particlesPerCell);
 
  virtual void
  makeSuperparticles(const WhichContainer a_container, const Vector<int> a_particlesPerCell);
 
  virtual void
  makeSuperparticles(const WhichContainer a_container, const int a_particlesPerCell, const int a_level);
 
  virtual void
  makeSuperparticles(const WhichContainer a_container,
                     const int            a_particlesPerCell,
                     const int            a_level,
                     const DataIndex      a_dit);
 
  virtual void
  mergeParticles(List<ItoParticle>& a_particles,
                 const CellInfo&    a_cellInfo,
                 const int          a_particlesPerCell) const noexcept;
 
  virtual void
  makeSuperparticlesEqualWeightKD(List<ItoParticle>& a_particles,
                                  const CellInfo&    a_cellInfo,
                                  const int          a_particlesPerCell) const noexcept;
 
  virtual void
  makeSuperparticlesBVHReinitialize(List<ItoParticle>& a_particles,
                                    const CellInfo&    a_cellInfo,
                                    const int          a_particlesPerCell) const noexcept;
 
  virtual void
  reinitializeParticles(List<ItoParticle>& a_particles,
                        const CellInfo&    a_cellInfo,
                        const int          a_particlesPerCell) const noexcept;
 
  virtual void
  remap();
 
  virtual void
  remap(const WhichContainer a_container);
 
  virtual void
  remapAll();
 
  inline RealVect
  randomGaussian() const;
 
  inline RealVect
  randomDirection() const;
 
  virtual Real
  computeDt() const;
 
  virtual Real
  computeDt(const int a_lvl) const;
 
  virtual Real
  computeDt(const int a_lvl, const DataIndex& a_dit) const;
 
  virtual Real
  computeHopDt(const Real a_maxCellsToMove) const;
 
  virtual Real
  computeHopDt(const Real a_maxCellsToMove, const int a_lvl) const;
 
  virtual Real
  computeHopDt(const Real a_maxCellsToMove, const int a_lvl, const DataIndex& a_dit) const;
 
  virtual Real
  computeAdvectiveDt() const;
 
  virtual Real
  computeAdvectiveDt(const int a_lvl) const;
 
  virtual Real
  computeAdvectiveDt(const int a_lvl, const DataIndex& a_dit) const;
 
  virtual Real
  computeDiffusiveDt() const;
 
  virtual Real
  computeDiffusiveDt(const int a_lvl) const;
 
  virtual Real
  computeDiffusiveDt(const int a_lvl, const DataIndex& a_dit) const;
 
  DepositionType
  getDeposition() const;
 
  CoarseFineDeposition
  getCoarseFineDeposition() const;
 
  phase::which_phase
  getPhase() const;
 
protected:
  static constexpr int m_comp = 0;
 
  static constexpr int m_nComp = 1;
 
  enum class WhichCheckpoint
  {
    Particles,
    Numbers
  };
 
  enum class WhichMobilityInterpolation
  {
    Direct,
    Velocity
  };
 
  WhichCheckpoint m_checkpointing;
 
  WhichMobilityInterpolation m_mobilityInterp;
 
  ParticleManagement::ParticleMerger<ItoParticle> m_particleMerger;
 
  int m_restartPPC;
 
  std::string m_realm;
 
  RefCountedPtr<ComputationalGeometry> m_computationalGeometry;
 
  RefCountedPtr<AmrMesh> m_amr;
 
  RefCountedPtr<ItoSpecies> m_species;
 
  phase::which_phase m_phase;
 
  std::string m_name;
 
  std::string m_className;
 
  Real m_normalDistributionTruncation;
 
  Real m_bisectionStep;
 
  int m_verbosity;
 
  int m_timeStep;
 
  Real m_time;
 
  Real m_dt;
 
  bool m_forceIrregDepositionNGP;
 
  bool m_forceIrregInterpolationNGP;
 
  bool m_forceHaloNGP;
 
  bool m_useRedistribution;
 
  bool m_blendConservation;
 
  bool m_isDiffusive;
 
  bool m_isMobile;
 
  bool m_plotPhi;
 
  bool m_plotVelocity;
 
  bool m_plotDiffCo;
 
  bool m_plotParticles;
 
  bool m_plotParticlesEB;
 
  bool m_plotParticlesDomain;
 
  bool m_plotParticlesSource;
 
  bool m_plotParticlesCovered;
 
  bool m_plotEnergyDensity;
 
  bool m_plotAverageEnergy;
 
  DepositionType m_deposition;
 
  CoarseFineDeposition m_coarseFineDeposition;
 
  DepositionType m_plotDeposition;
 
  EBAMRCellData m_phi;
 
  EBAMRCellData m_mobilityFunction;
 
  EBAMRCellData m_velocityFunction;
 
  EBAMRCellData m_diffusionFunction;
 
  mutable EBAMRIVData m_depositionNC;
 
  mutable EBAMRIVData m_massDiff;
 
  std::map<WhichContainer, ParticleContainer<ItoParticle>> m_particleContainers;
 
  EBIntersection m_intersectionAlg;
 
  void
  parseRNG();
 
  void
  parseTruncation();
 
  void
  parseDeposition();
 
  void
  parseParticleMerger();
 
  void
  parseIntersectionEB();
 
  void
  parseVerbosity();
 
  void
  parsePlotVariables();
 
  void
  parseDiffusionHop();
 
  void
  parseRedistribution();
 
  void
  parseDivergenceComputation();
 
  void
  parseCheckpointing();
 
#ifdef CH_USE_HDF5
  virtual void
  writeCheckPointLevelParticles(HDF5Handle& a_handle, const int a_level) const;
#endif
 
#ifdef CH_USE_HDF5
  virtual void
  writeCheckPointLevelFluid(HDF5Handle& a_handle, const int a_level) const;
#endif
 
#ifdef CH_USE_HDF5
  virtual void
  readCheckpointLevelParticles(HDF5Handle& a_handle, const int a_level);
#endif
 
#ifdef CH_USE_HDF5
  virtual void
  readCheckpointLevelFluid(HDF5Handle& a_handle, const int a_level);
#endif
 
  void
  drawNewParticles(const LevelData<EBCellFAB>& a_particlesPerCell, const int a_level, const int a_newPPC);
 
  template <class P, class Ret, Ret (P ::*MemberFunc)() const>
  void
  depositKappaConservative(EBAMRCellData&             a_phi,
                           ParticleContainer<P>&      a_particles,
                           const DepositionType       a_deposition,
                           const CoarseFineDeposition a_coarseFineDeposition) const;
 
  virtual void
  redistributeAMR(EBAMRCellData& a_phi) const;
 
  virtual void
  depositNonConservative(EBAMRIVData& a_depositionNC, const EBAMRCellData& a_depositionKappaC) const;
 
  virtual void
  depositHybrid(EBAMRCellData& a_depositionH, EBAMRIVData& a_massDifference, const EBAMRIVData& a_depositionNC) const;
 
  virtual void
  interpolateMobilities(const int a_level, const DataIndex& a_dit, const EBCellFAB& a_velocityMagnitude) noexcept;
 
  virtual void
  interpolateMobilitiesDirect(const int a_level, const DataIndex& a_dit) noexcept;
 
  virtual void
  interpolateMobilitiesVelocity(const int        a_level,
                                const DataIndex& a_dit,
                                const EBCellFAB& a_velocityMagnitude) noexcept;
 
  virtual void
  updateMobilities(const int a_level, const DataIndex a_dit);
 
  virtual void
  interpolateDiffusion(const int a_level, const DataIndex& a_dit);
 
  virtual void
  updateDiffusion(const int a_level, const DataIndex a_dit);
 
  virtual void
  writeData(LevelData<EBCellFAB>& a_output,
            int&                  a_comp,
            const EBAMRCellData&  a_data,
            const std::string     a_outputRealm,
            const int             a_level,
            const bool            a_interpToCentroids,
            const bool            a_interpGhost) const noexcept;
};
 
#include <CD_NamespaceFooter.H>
 
#include <CD_ItoSolverImplem.H>
 
#endif