CD_CdrSolver.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_CDRSOLVER_H
#define CD_CDRSOLVER_H
 
// Std includes
#include <random>
#include <time.h>
#include <chrono>
#include <functional>
 
// Our includes
#include <CD_AmrMesh.H>
#include <CD_ComputationalGeometry.H>
#include <CD_CdrSpecies.H>
#include <CD_CdrDomainBC.H>
#include <CD_NamespaceHeader.H>
 
class CdrSolver
{
public:
  CdrSolver();
 
  CdrSolver(const CdrSolver& a_other) = delete;
 
  CdrSolver(const CdrSolver&& a_other) = delete;
 
  CdrSolver&
  operator=(const CdrSolver& a_other) = delete;
 
  CdrSolver&
  operator=(const CdrSolver&& a_other) = delete;
 
  virtual ~CdrSolver();
 
  virtual void
  parseOptions() = 0;
 
  virtual void
  parseRuntimeOptions() = 0;
 
  void
  setDefaultDomainBC();
 
  void
  setDomainBcType(const CdrDomainBC::DomainSide a_domainSide, const CdrDomainBC::BcType a_bcType);
 
  void
  setDomainBcFunction(const CdrDomainBC::DomainSide a_domainSide, const CdrDomainBC::FluxFunction& a_fluxFunction);
 
  virtual void
  advanceEuler(EBAMRCellData& a_newPhi, const EBAMRCellData& a_oldPhi, const Real a_dt);
 
  virtual void
  advanceEuler(EBAMRCellData&       a_newPhi,
               const EBAMRCellData& a_oldPhi,
               const EBAMRCellData& a_source,
               const Real           a_dt) = 0;
 
  virtual void
  advanceCrankNicholson(EBAMRCellData& a_newPhi, const EBAMRCellData& a_oldPhi, const Real a_dt);
 
  virtual void
  advanceCrankNicholson(EBAMRCellData&       a_newPhi,
                        const EBAMRCellData& a_oldPhi,
                        const EBAMRCellData& a_source,
                        const Real           a_dt) = 0;
 
  virtual void
  computeDivJ(EBAMRCellData& a_divJ,
              EBAMRCellData& a_phi,
              const Real     a_extrapDt,
              const bool     a_conservativeOnly,
              const bool     a_ebFlux,
              const bool     a_domainFlux) = 0;
 
  virtual void
  computeDivF(EBAMRCellData& a_divF,
              EBAMRCellData& a_phi,
              const Real     a_extrapDt,
              const bool     a_conservativeOnly,
              const bool     a_ebFlux,
              const bool     a_domainFlux) = 0;
 
  virtual void
  computeDivD(EBAMRCellData& a_divD,
              EBAMRCellData& a_phi,
              const bool     a_conservativeOnly,
              const bool     a_ebFlux,
              const bool     a_domainFlux) = 0;
 
  virtual void
  computeDivG(EBAMRCellData& a_divG, EBAMRFluxData& a_G, const EBAMRIVData& a_ebFlux, const bool a_conservativeOnly);
 
  virtual void
  gwnDiffusionSource(EBAMRCellData& a_noiseSource, const EBAMRCellData& a_cellPhi);
 
  virtual void
  averageVelocityToFaces();
 
  virtual void
  preRegrid(const int a_lbase, const int a_oldFinestLevel);
 
  virtual void
  deallocate();
 
  virtual void
  registerOperators();
 
  virtual void
  setRealm(const std::string& a_realm);
 
  virtual RefCountedPtr<CdrSpecies>&
  getSpecies() noexcept;
 
  virtual const RefCountedPtr<CdrSpecies>&
  getSpecies() const noexcept;
 
  virtual void
  setSpecies(const RefCountedPtr<CdrSpecies>& a_species);
 
  virtual void
  setComputationalGeometry(const RefCountedPtr<ComputationalGeometry>& a_computationalGeometry);
 
  virtual void
  setAmr(const RefCountedPtr<AmrMesh>& a_amr);
 
  virtual void
  setPhase(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);
 
  virtual void
  setVelocity(const EBAMRCellData& a_velocity);
 
  virtual void
  setVelocity(const RealVect& a_velocity);
 
  virtual void
  setVelocity(const std::function<RealVect(const RealVect a_pos)>& a_velocity);
 
  virtual void
  setDiffusionCoefficient(const EBAMRFluxData& a_diffusionCoefficient, const EBAMRIVData& a_ebDiffusionCoefficient);
 
  virtual void
  setDiffusionCoefficient(const Real a_diffusionCoefficient);
 
  virtual void
  setDiffusionCoefficient(const std::function<Real(const RealVect a_position)>& a_diffCo);
 
  virtual void
  setSource(const EBAMRCellData& a_source);
 
  virtual void
  setSource(const Real a_source);
 
  virtual void
  setSource(const std::function<Real(const RealVect a_position)>& a_source);
 
  virtual void
  setEbFlux(const EBAMRIVData& a_ebFlux);
 
  virtual void
  setEbFlux(const Real a_ebFlux);
 
  virtual void
  initialData();
 
  virtual void
  allocate();
 
  virtual void
  writePlotFile();
 
  virtual void
  writePlotData(LevelData<EBCellFAB>& a_output,
                int&                  a_icomp,
                const std::string&    a_outputRealm,
                const int             a_level) const noexcept;
 
#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
  regrid(const int a_lmin, const int a_oldFinestLevel, const int a_newFinestLevel);
 
  virtual std::string
  getRealm() const;
 
  virtual std::string
  getName() const;
 
  virtual Vector<std::string>
  getPlotVariableNames() const;
 
  virtual int
  getNumberOfPlotVariables() const;
 
  virtual Real
  computeAdvectionDt();
 
  virtual Real
  computeDiffusionDt();
 
  virtual Real
  computeAdvectionDiffusionDt();
 
  virtual Real
  computeSourceDt(const Real a_max, const Real a_tolerance);
 
  virtual void
  weightedUpwind(EBAMRCellData& a_weightedUpwindPhi, const int a_pow);
 
  virtual Real
  computeMass();
 
  virtual Real
  computeMass(const EBAMRCellData& a_phi, const bool a_kappaScale = true);
 
  virtual Real
  computeCharge();
 
  virtual bool
  isDiffusive();
 
  virtual bool
  isMobile();
 
  virtual EBAMRCellData&
  getPhi();
 
  virtual EBAMRCellData&
  getSource();
 
  virtual EBAMRCellData&
  getCellCenteredVelocity();
 
  virtual EBAMRFluxData&
  getFaceCenteredVelocity();
 
  virtual EBAMRIVData&
  getEbCenteredVelocity();
 
  virtual EBAMRCellData&
  getCellCenteredDiffusionCoefficient();
 
  virtual EBAMRFluxData&
  getFaceCenteredDiffusionCoefficient();
 
  virtual EBAMRIVData&
  getEbCenteredDiffusionCoefficient();
 
  virtual EBAMRIVData&
  getEbFlux();
 
  virtual EBAMRIFData&
  getDomainFlux();
 
  virtual void
  extrapolateAdvectiveFluxToEB() noexcept;
 
  virtual void
  extrapolateAdvectiveFluxToEB(EBAMRIVData& a_ebFlux) const noexcept;
 
  virtual void
  redistribute(EBAMRCellData& a_phi, const EBAMRIVData& a_delta) const noexcept;
 
protected:
  enum class Redistribution
  {
    VolumeWeighted,
    None
  };
 
  static constexpr int m_comp = 0;
 
  static constexpr int m_nComp = 1;
 
  RefCountedPtr<CdrSpecies> m_species;
 
  RefCountedPtr<ComputationalGeometry> m_computationalGeometry;
 
  RefCountedPtr<AmrMesh> m_amr;
 
  Vector<RefCountedPtr<LayoutData<BaseIFFAB<FaceStencil>>>> m_interpStencils[SpaceDim];
 
  phase::which_phase m_phase;
 
  std::string m_name;
 
  std::string m_className;
 
  std::string m_realm;
 
  CdrDomainBC m_domainBC;
 
  EBAMRCellData m_phi;
 
  EBAMRCellData m_source;
 
  EBAMRCellData m_cellVelocity;
 
  EBAMRFluxData m_faceStates;
 
  EBAMRFluxData m_faceVelocity;
 
  EBAMRIVData m_nonConservativeDivG;
 
  EBAMRIVData m_massDifference;
 
  EBAMRIVData m_ebZero;
 
  EBAMRCellData m_cachePhi;
 
  EBAMRCellData m_cacheSource;
 
  EBAMRIVData m_ebVelocity;
 
  EBAMRIVData m_ebFlux;
 
  EBAMRIFData m_domainFlux;
 
  EBAMRCellData m_cellCenteredDiffusionCoefficient;
 
  EBAMRFluxData m_faceCenteredDiffusionCoefficient;
 
  EBAMRIVData m_ebCenteredDiffusionCoefficient;
 
  std::map<CdrDomainBC::DomainSide, CdrDomainBC::FluxFunction> m_domainFluxFunctions;
 
  int m_verbosity;
 
  int m_timeStep;
 
  Real m_time;
 
  Real m_dt;
 
  Redistribution m_whichRedistribution;
 
  bool m_blendConservation;
 
  bool m_isDiffusive;
 
  bool m_isMobile;
 
  bool m_plotPhi;
 
  bool m_plotVelocity;
 
  bool m_plotDiffusionCoefficient;
 
  bool m_plotEbFlux;
 
  bool m_plotSource;
 
  bool m_plotNumbers;
 
  bool m_regridSlopes;
 
  int m_seed;
 
  virtual void
  averageVelocityToFaces(EBAMRFluxData& a_faceVelocity, const EBAMRCellData& a_cellVelocity);
 
  virtual void
  advectToFaces(EBAMRFluxData& a_facePhi, const EBAMRCellData& a_phi, const Real a_extrapDt) = 0;
 
  virtual void
  computeAdvectionFlux(EBAMRFluxData&       a_flux,
                       const EBAMRFluxData& a_facePhi,
                       const EBAMRFluxData& a_faceVelocity,
                       const bool           a_addDomainFlux = true);
 
  virtual void
  computeAdvectionFlux(LevelData<EBFluxFAB>&       a_flux,
                       const LevelData<EBFluxFAB>& a_facePhi,
                       const LevelData<EBFluxFAB>& a_faceVelocity,
                       const int                   a_lvl);
 
  virtual void
  computeDiffusionFlux(EBAMRFluxData& a_flux, const EBAMRCellData& a_phi, const bool a_addDomainFlux);
 
  virtual void
  computeDiffusionFlux(LevelData<EBFluxFAB>& a_flux, const LevelData<EBCellFAB>& a_phi, const int a_lvl);
 
  virtual void
  computeAdvectionDiffusionFlux(EBAMRFluxData&       a_flux,
                                const EBAMRCellData& a_cellStates,
                                const EBAMRFluxData& a_faceStates,
                                const EBAMRFluxData& a_faceVelocities,
                                const EBAMRFluxData& a_faceDiffCo,
                                const bool           a_addDomainFlux);
 
  virtual void
  resetDomainFlux(EBAMRFluxData& a_flux);
 
  virtual void
  fillDomainFlux(EBAMRFluxData& a_flux);
 
  virtual void
  fillDomainFlux(LevelData<EBFluxFAB>& a_flux, const int a_level);
 
  virtual void
  conservativeDivergenceNoKappaDivision(EBAMRCellData&     a_conservativeDivergence,
                                        EBAMRFluxData&     a_flux,
                                        const EBAMRIVData& a_ebFlux);
 
  virtual void
  nonConservativeDivergence(EBAMRIVData& a_nonConservativeDivergence, const EBAMRCellData& a_divG);
 
  virtual void
  hybridDivergence(EBAMRCellData&     a_hybridDivergence,
                   EBAMRIVData&       a_massDifference,
                   const EBAMRIVData& a_nonConservativeDivergence);
 
  virtual void
  hybridDivergence(LevelData<EBCellFAB>&             a_hybridDivergence,
                   LevelData<BaseIVFAB<Real>>&       a_massDifference,
                   const LevelData<BaseIVFAB<Real>>& a_nonConservativeDivergence,
                   const int                         a_lvl);
 
  virtual void
  conservativeDivergenceRegular(LevelData<EBCellFAB>& a_divJ, const LevelData<EBFluxFAB>& a_flux, const int a_lvl);
 
  virtual void
  interpolateFluxToFaceCentroids(EBAMRFluxData& a_flux);
 
  virtual void
  interpolateFluxToFaceCentroids(LevelData<EBFluxFAB>& a_flux, const int a_lvl);
 
  virtual void
  computeDivergenceIrregular(LevelData<EBCellFAB>&             a_divG,
                             const LevelData<EBFluxFAB>&       a_centroidFluxes,
                             const LevelData<BaseIVFAB<Real>>& a_ebFlux,
                             const int                         a_lvl);
 
  virtual void
  initialDataDistribution();
 
  virtual void
  initialDataParticles();
 
  virtual void
  defineInterpolationStencils();
 
  virtual void
  parseDomainBc();
 
  virtual void
  parsePlotVariables();
 
  virtual void
  parsePlotMode();
 
  virtual void
  parseDivergenceComputation();
 
  virtual void
  parseRegridSlopes();
 
  virtual std::string
  makeBcString(const int a_dir, const Side::LoHiSide a_side) const;
 
  virtual void
  fillGwn(EBAMRFluxData& a_noise, const Real a_sigma);
 
  virtual void
  smoothHeavisideFaces(EBAMRFluxData& a_facePhi, const EBAMRCellData& a_cellPhi);
 
  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>
 
#endif