CD_Driver.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_DRIVER_H
#define CD_DRIVER_H
 
// Chombo includes
#include <RefCountedPtr.H>
 
// Our includes
#include <CD_ComputationalGeometry.H>
#include <CD_TimeStepper.H>
#include <CD_AmrMesh.H>
#include <CD_CellTagger.H>
#include <CD_MultiFluidIndexSpace.H>
#include <CD_Initialize.H>
#include <CD_NamespaceHeader.H>
 
class Driver
{
public:
  Driver() = delete;
 
  Driver(const RefCountedPtr<ComputationalGeometry>& a_computationalGeometry,
         const RefCountedPtr<TimeStepper>&           a_timeStepper,
         const RefCountedPtr<AmrMesh>&               a_amrMesh,
         const RefCountedPtr<CellTagger>&            a_cellTagger = RefCountedPtr<CellTagger>(nullptr));
 
  virtual ~Driver();
 
  void
  setupAndRun();
 
protected:
  RefCountedPtr<MultiFluidIndexSpace> m_multifluidIndexSpace;
 
  RefCountedPtr<AmrMesh> m_amr;
 
  RefCountedPtr<ComputationalGeometry> m_computationalGeometry;
 
  RefCountedPtr<TimeStepper> m_timeStepper;
 
  RefCountedPtr<CellTagger> m_cellTagger;
 
  std::string m_inputFile;
 
  std::string m_realm;
 
  std::string m_geometryGeneration;
 
  std::string m_outputDirectory;
 
  std::string m_outputFileNames;
 
  int m_verbosity;
 
  int m_irregTagGrowth;
 
  int m_geoScanLevel;
 
  int m_timeStep;
 
  int m_regridInterval;
 
  int m_checkpointInterval;
 
  int m_plotInterval;
 
  int m_geometricTagsDepth;
 
  int m_conductorTagsDepth;
 
  int m_dielectricTagsDepth;
 
  int m_maxSteps;
 
  int m_maxPlotLevel;
 
  int m_maxCheckpointDepth;
 
  int m_initialRegrids;
 
  int m_numPlotGhost;
 
  int m_restartStep;
 
  int m_growTags;
 
  Vector<IntVectSet> m_geomTags;
 
  EBAMRTags m_tags;
 
  EBAMRBool m_cachedTags;
 
  Real m_outputDt;
 
  Real m_startTime;
 
  Real m_stopTime;
 
  Real m_dt;
 
  Real m_time;
 
  Real m_capacitance;
 
  Real m_wallClockStart;
 
  Real m_wallClockOne;
 
  Real m_wallClockTwo;
 
  Real m_refineAngle;
 
  bool m_profile;
 
  bool m_doCoarsening;
 
  bool m_needsNewGeometricTags;
 
  bool m_writeRegridFiles;
 
  bool m_writeRestartFiles;
 
  bool m_allowCoarsening;
 
  bool m_doInitLoadBalancing;
 
  bool m_writeMemory;
 
  bool m_writeLoads;
 
  bool m_restart;
 
  bool m_geometryOnly;
 
  bool m_ebisMemoryLoadBalance;
 
  bool m_plotTags;
 
  bool m_plotRanks;
 
  bool m_plotLoads;
 
  bool m_plotLevelset;
 
  void
  run(const Real a_startTime, const Real a_endTime, const int a_maxSteps);
 
  void
  setup(const std::string& a_inputFile,
        const int          a_initialRegrids,
        const bool         a_restart,
        const std::string& a_restartFile);
 
  void
  setAmr(const RefCountedPtr<AmrMesh>& a_amrMesh);
 
  void
  sanityCheck();
 
  void
  parseOptions();
 
  void
  parseRuntimeOptions();
 
  void
  parseGeometryRefinement();
 
  void
  parsePlotVariables();
 
  void
  parseGeometryGeneration();
 
  void
  parseIrregTagGrowth();
 
  void
  createOutputDirectories();
 
  void
  allocateInternals();
 
  void
  cacheTags(const EBAMRTags& a_tags);
 
  void
  writeEBIS();
 
  void
  getGeometryTags();
 
  void
  getCellsAndBoxes(long long&                       a_numLocalCells,
                   long long&                       a_numLocalCellsGhosts,
                   long long&                       a_numLocalBoxes,
                   long long&                       a_numTotalCells,
                   long long&                       a_numTotalCellsGhosts,
                   long long&                       a_numTotalBoxes,
                   Vector<long long>&               a_numLocalLevelBoxes,
                   Vector<long long>&               a_numTotalLevelBoxes,
                   Vector<long long>&               a_numLocalLevelCells,
                   Vector<long long>&               a_numTotalLevelCells,
                   const int&                       a_finestLevel,
                   const Vector<DisjointBoxLayout>& a_grids);
 
  void
  gridReport();
 
#ifdef CH_USE_HDF5
  void
  readCheckpointFile(const std::string& a_restartFile);
#endif
 
  void
  regrid(const int a_lmin, const int a_lmax, const bool a_useInitialData);
 
  void
  regridInternals(const int a_oldFinestLevel, const int a_newFinestLevel);
 
  void
  setComputationalGeometry(const RefCountedPtr<ComputationalGeometry>& a_computationalGeometry);
 
  void
  setTimeStepper(const RefCountedPtr<TimeStepper>& a_timeStepper);
 
  void
  setCellTagger(const RefCountedPtr<CellTagger>& a_cellTagger);
 
  void
  setupFresh(const int a_initialRegrids);
 
#ifdef CH_USE_HDF5
  void
  setupForRestart(const int a_initialRegrids, const std::string& a_restartFile);
#endif
 
  void
  setupGeometryOnly();
 
  void
  checkRestartFile(const std::string& a_restartFile) const;
 
  void
  stepReport(const Real a_startTime, const Real a_endTime, const int a_maxSteps);
 
  void
  writePlotFile(const std::string& a_filename);
 
  void
  writePlotFile();
 
  void
  writePreRegridFile();
 
  void
  writePostRegridFile();
 
  void
  writeRestartFile();
 
  void
  writeCrashFile();
 
  void
  writeMemoryUsage();
 
  void
  writeComputationalLoads();
 
  void
  writeCheckpointFile();
 
#ifdef CH_USE_HDF5
  void
  writeCheckpointLevel(HDF5Handle& a_handle, const int a_level);
#endif
 
#ifdef CH_USE_HDF5
  void
  writeCheckpointTags(HDF5Handle& a_handle, const int a_level);
#endif
 
#ifdef CH_USE_HDF5
  void
  writeCheckpointRealmLoads(HDF5Handle& a_handle, const int a_level);
#endif
 
#ifdef CH_USE_HDF5
  void
  readCheckpointLevel(HDF5Handle& a_handle, const int a_level);
#endif
 
#ifdef CH_USE_HDF5
  void
  readCheckpointRealmLoads(Vector<long int>&  a_loads,
                           HDF5Handle&        a_handle,
                           const std::string& a_realm,
                           const int          a_level);
#endif
 
  void
  writeGeometry();
 
  bool
  tagCells(Vector<IntVectSet>& a_allTags, EBAMRTags& a_cellTags);
 
  int
  getNumberOfPlotVariables() const;
 
  Vector<std::string>
  getPlotVariableNames() const;
 
  virtual void
  writePlotData(LevelData<EBCellFAB>& a_output, int& a_comp, const int a_level) const noexcept;
 
  virtual void
  writeTags(LevelData<EBCellFAB>& a_output, int& a_comp, const int a_level) const noexcept;
 
  virtual void
  writeRanks(LevelData<EBCellFAB>& a_output, int& a_comp, const int a_level) const noexcept;
 
  virtual void
  writeLevelset(LevelData<EBCellFAB>& a_output, int& a_comp, const int a_level) const noexcept;
 
  virtual void
  writeLoads(LevelData<EBCellFAB>& a_output, int& a_comp, const int a_level) const noexcept;
 
  int
  getFinestTagLevel(const EBAMRTags& a_cellTags) const;
 
  void
  rebuildParmParse() const;
};
 
#include <CD_NamespaceFooter.H>
 
#endif