hdsim2d.hpp

Go to the documentation of this file.

#ifndef HDSIM_HPP
#define HDSIM_HPP 1

#include "computational_cell_2d.hpp"
#include "../common/equation_of_state.hpp"
#include "spatial_distribution2d.hpp"
#include "../common/riemann_solver.hpp"
#include "point_motion.hpp"
#include "spatial_reconstruction.hpp"
#include "../../tessellation/tessellation.hpp"
#include "../common/hydrodynamics.hpp"
#include "SourceTerm.hpp"
#include "../../tessellation/HilbertOrder.hpp"
#include "OuterBoundary.hpp"
#include "../../misc/utils.hpp"
#include "../../misc/cached_lazy_list.hpp"
#include "../../misc/lazy_list.hpp"
#include "../../misc/universal_error.hpp"
#include "extensive.hpp"
#include "RefineStrategy.hpp"
#include "RemovalStrategy.hpp"
#include "../../misc/utils.hpp"
#include "ResetDump.hpp"
#include "physical_geometry.hpp"
#include "simple_cfl.hpp"
#include "flux_calculator_2d.hpp"
#include "cell_updater_2d.hpp"
#include "extensive_updater.hpp"
#include "cache_data.hpp"
#include "edge_velocity_calculator.hpp"
#include <boost/container/small_vector.hpp>
#include "computational_cell_2d.hpp"
#ifdef RICH_MPI
#include "../../mpi/ProcessorUpdate.hpp"
#endif

class hdsim
{
private:
#ifdef RICH_MPI
        Tessellation& proctess_;
#endif

  Tessellation& tess_;

  const OuterBoundary& obc_;

  const EquationOfState& eos_;

  vector<ComputationalCell> cells_;

  vector<Extensive> extensives_;

  const PointMotion& point_motion_;

  const EdgeVelocityCalculator& edge_velocity_calculator_;

  const SourceTerm& source_;

  double time_;

  int cycle_;

  const PhysicalGeometry& pg_;

  const TimeStepFunction& tsf_;

  const FluxCalculator& fc_;

  const ExtensiveUpdater& eu_;

  const CellUpdater& cu_;

  TracerStickerNames tracer_sticker_names_;

  const CacheData cache_data_;

#ifdef RICH_MPI
  const ProcessorUpdate* proc_update_;
#endif

  // The purpose of these declarations is to disable copying
  hdsim(const hdsim& origin);

  hdsim& operator=(const hdsim& origin);

public:

  const vector<ComputationalCell>& getAllCells(void) const;

  vector<ComputationalCell>& getAllCells(void);

  void recalculatePrimitives(void);

  void recalculateExtensives(void);

  const PhysicalGeometry& getPhysicalGeometry(void) const;

  const Tessellation& getTessellation(void) const;

  Tessellation& getTessellation(void);

#ifdef RICH_MPI

  const Tessellation & GetProcTessellation(void)const;
#endif

#ifdef RICH_MPI
#endif // RICH_MPI
  hdsim
          (
#ifdef RICH_MPI
          Tessellation& proctess,
#endif
          Tessellation& tess,
   const OuterBoundary& obc,
   const PhysicalGeometry& pg,
   const vector<ComputationalCell>& init_cond,
   const EquationOfState& eos,
   const PointMotion& pointmotion,
   const EdgeVelocityCalculator& evc,
   const SourceTerm& external_force,
   const TimeStepFunction& tsf,
   const FluxCalculator& fc,
   const ExtensiveUpdater& eu,
   const CellUpdater& cu,
   TracerStickerNames tracer_sticker_names = TracerStickerNames(),
        bool relativistic = false
#ifdef RICH_MPI
                  ,const ProcessorUpdate* proc_update=0
#endif
                  );

  void load(const ResetDump& checkpoint);

  void makeCheckpoint(ResetDump& checkpoint) const;

  ~hdsim(void);

  void TimeAdvance(void);

  void TimeAdvanceClip(void);

  void TimeAdvance2Heun(void);

  void TimeAdvance2MidPointClip(void);
  void TimeAdvance2MidPoint(void);

  void changePhysicalGeometry(const PhysicalGeometry* pg);

  void setStartTime(double t_start);

  void setCycle(int cycle);

  // Diagnostics

  double getTime(void) const;

  double getCellVolume(size_t index) const;

  int getCycle(void) const;

  void setTimeStepFunction(TimeStepFunction& tsf);

  const EquationOfState& getEos(void) const;

  const OuterBoundary& getOuterBoundary(void) const;

  const vector<Extensive>& getAllExtensives(void) const;

  vector<Extensive>& getAllExtensives(void);

  const CacheData& getCacheData(void) const;

  TracerStickerNames const& GetTracerStickerNames(void)const;
};

#endif