CD_FieldSolver.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_FieldSolver_H
#define CD_FieldSolver_H
 
// Std includes
#include <functional>
 
// Our includes
#include <CD_Location.H>
#include <CD_ComputationalGeometry.H>
#include <CD_AmrMesh.H>
#include <CD_ElectrostaticDomainBc.H>
#include <CD_ElectrostaticEbBc.H>
#include <CD_DataParser.H>
#include <CD_LookupTable1D.H>
#include <CD_LookupTable.H>
#include <CD_TriangleCollection.H>
#include <CD_NamespaceHeader.H>
 
class FieldSolver
{
public:
  FieldSolver();
 
  FieldSolver(const FieldSolver& a_other) = delete;
 
  FieldSolver(const FieldSolver&& a_other) = delete;
 
  FieldSolver&
  operator=(const FieldSolver& a_other) = delete;
 
  FieldSolver&
  operator=(const FieldSolver&& a_other) = delete;
 
  virtual ~FieldSolver();
 
  virtual void
  setupSolver() = 0;
 
  virtual void
  setSolverPermittivities(const MFAMRCellData& a_permittivityCell,
                          const MFAMRFluxData& a_permittivityFace,
                          const MFAMRIVData&   a_permittivityEB);
 
  virtual bool
  solve(const bool a_zeroPhi = false);
 
  virtual bool
  solve(MFAMRCellData& a_potential, const bool a_zerophi = false);
 
  virtual bool
  solve(MFAMRCellData& a_phi, const MFAMRCellData& a_rho, const EBAMRIVData& a_sigma, const bool a_zerophi = false) = 0;
 
  virtual void
  computeElectricField();
 
  virtual void
  computeElectricField(MFAMRCellData& a_E, const MFAMRCellData& a_potential) const = 0;
 
  virtual void
  computeElectricField(MFAMRFluxData& a_E, const MFAMRCellData& a_potential) const = 0;
 
  virtual void
  computeElectricField(EBAMRCellData&           a_E,
                       const phase::which_phase a_phase,
                       const MFAMRCellData&     a_potential) const = 0;
 
  virtual void
  computeElectricField(EBAMRFluxData&           a_E,
                       const phase::which_phase a_phase,
                       const MFAMRCellData&     a_potential) const = 0;
 
  virtual void
  parseOptions() = 0;
 
  virtual void
  parseRuntimeOptions() = 0;
 
  virtual void
  allocate();
 
  virtual void
  preRegrid(const int a_lbase, const int a_oldFinestLevel);
 
  virtual void
  computeDisplacementField(MFAMRCellData& a_displacementField, const MFAMRCellData& a_electricField);
 
  virtual void
  deallocate();
 
  virtual void
  regrid(const int a_lmin, const int a_oldFinestLevel, const int a_newFinestLevel);
 
  virtual void
  registerOperators() = 0;
 
  void
  setRho(const Real a_rho);
 
  void
  setRho(const std::function<Real(const RealVect)>& a_rho);
 
  void
  setSigma(const Real a_sigma);
 
  void
  setSigma(const std::function<Real(const RealVect)>& a_sigma);
 
  void
  setComputationalGeometry(const RefCountedPtr<ComputationalGeometry>& a_computationalGeometry);
 
  void
  setAmr(const RefCountedPtr<AmrMesh>& a_amr);
 
  virtual void
  setPermittivities();
 
  virtual void
  writePlotFile();
 
#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
  postCheckpoint();
 
  virtual void
  writePlotData(LevelData<EBCellFAB>& a_output,
                int&                  a_comp,
                const std::string     a_outputRealm,
                const int             a_level,
                const bool            a_forceNoInterp = false) const noexcept;
 
  virtual void
  writeMultifluidData(LevelData<EBCellFAB>&    a_output,
                      int&                     a_comp,
                      const MFAMRCellData&     a_data,
                      const phase::which_phase a_phase,
                      const std::string        a_outputRealm,
                      const int                a_level,
                      const bool               a_interp) const noexcept;
 
  virtual void
  writeSurfaceData(LevelData<EBCellFAB>&             a_output,
                   int&                              a_comp,
                   const LevelData<BaseIVFAB<Real>>& a_data,
                   const std::string                 a_outputRealm,
                   const int                         a_level) const noexcept;
 
  void
  setRealm(const std::string a_realm);
 
  void
  setTime(const int a_timeStep, const Real a_time, const Real a_dt);
 
  void
  setVerbosity(const int a_verbosity);
 
  virtual void
  setVoltage(std::function<Real(const Real a_time)> a_voltage);
 
  virtual void
  setDomainSideBcFunction(const int                                a_dir,
                          const Side::LoHiSide                     a_side,
                          const ElectrostaticDomainBc::BcFunction& a_function);
 
  virtual void
  setElectrodeDirichletFunction(const int a_electrode, const ElectrostaticEbBc::BcFunction& a_function);
 
  virtual int
  getNumberOfPlotVariables() const;
 
  const std::function<Real(const Real a_time)>&
  getVoltage() const;
 
  Real
  getCurrentVoltage() const;
 
  Real
  getTime() const;
 
  Real
  computeCapacitance();
 
  Real
  computeEnergy(const MFAMRCellData& a_electricField);
 
  virtual Vector<std::string>
  getPlotVariableNames() const;
 
  virtual Vector<long long>
  computeLoads(const DisjointBoxLayout& a_dbl, const int a_level);
 
  void
  setDataLocation(const Location::Cell a_dataLocation);
 
  std::string
  getRealm() const;
 
  MFAMRCellData&
  getPotential();
 
  MFAMRCellData&
  getElectricField();
 
  MFAMRCellData&
  getRho();
 
  MFAMRCellData&
  getResidue();
 
  MFAMRCellData&
  getPermittivityCell();
 
  MFAMRFluxData&
  getPermittivityFace();
 
  MFAMRIVData&
  getPermittivityEB();
 
  EBAMRIVData&
  getSigma();
 
  Location::Cell
  getDataLocation() const;
 
protected:
  constexpr static int m_comp = 0;
 
  constexpr static int m_nComp = 1;
 
  Location::Cell m_dataLocation;
 
  Location::Face m_faceLocation;
 
  std::string m_realm;
 
  std::string m_className;
 
  RefCountedPtr<MultiFluidIndexSpace> m_multifluidIndexSpace;
 
  RefCountedPtr<ComputationalGeometry> m_computationalGeometry;
 
  RefCountedPtr<AmrMesh> m_amr;
 
  MFAMRCellData m_cache;
 
  MFAMRCellData m_potential;
 
  MFAMRCellData m_electricField;
 
  MFAMRCellData m_rho;
 
  EBAMRIVData m_sigma;
 
  MFAMRCellData m_residue;
 
  MFAMRCellData m_permittivityCell;
 
  MFAMRFluxData m_permittivityFace;
 
  MFAMRIVData m_permittivityEB;
 
  bool m_isVoltageSet;
 
  bool m_plotPotential;
 
  bool m_plotRho;
 
  bool m_plotElectricField;
 
  bool m_plotElectricFieldSolid;
 
  bool m_plotResidue;
 
  bool m_plotPermittivity;
 
  bool m_plotSigma;
 
  bool m_regridSlopes;
 
  int m_verbosity;
 
  int m_timeStep;
 
  Real m_dt;
 
  Real m_time;
 
  ElectrostaticDomainBc m_domainBc;
 
  ElectrostaticEbBc m_ebBc;
 
  std::map<ElectrostaticDomainBc::DomainSide, ElectrostaticDomainBc::BcFunction> m_domainBcFunctions;
 
  std::vector<std::pair<Electrode, ElectrostaticEbBc::BcFunction>> m_electrodeBcFunctions;
 
  std::function<Real(const Real a_time)> m_voltage;
 
  virtual void
  parseVerbosity();
 
  virtual void
  parsePlotVariables();
 
  virtual void
  parseDomainBc();
 
  virtual void
  parseRegridSlopes();
 
  virtual void
  setDefaultDomainBcFunctions();
 
  virtual void
  setDefaultEbBcFunctions();
 
  inline Real
  getDielectricPermittivity(const RealVect& a_pos) const;
 
  virtual void
  setCellPermittivities(EBCellFAB&      a_perm,
                        const Box&      a_cellBox,
                        const EBISBox&  a_ebisbox,
                        const RealVect& a_probLo,
                        const Real&     a_dx);
 
  virtual void
  setFacePermittivities(EBFluxFAB&      a_perm,
                        const Box&      a_cellBox,
                        const EBISBox&  a_ebisbox,
                        const RealVect& a_probLo,
                        const Real&     a_dx);
 
  virtual void
  setEbPermittivities(BaseIVFAB<Real>& a_perm,
                      const Box&       a_cellBox,
                      const EBISBox&   a_ebisbox,
                      const RealVect&  a_origin,
                      const Real&      a_dx);
 
  virtual ElectrostaticDomainBc::BcType
  parseBcString(const std::string a_str) const;
 
  virtual std::string
  makeBcString(const int a_dir, const Side::LoHiSide a_side) const;
 
  virtual void
  fillCoveredPotential(MFAMRCellData& a_phi) const noexcept;
};
 
#include <CD_NamespaceFooter.H>
 
#include <CD_FieldSolverImplem.H>
 
#endif