FluidEvolutionHistory.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file FluidEvolutionHistory.h

/*******************************************************************************
 * Copyright (c) The JETSCAPE Collaboration, 2018
 *
 * Modular, task-based framework for simulating all aspects of heavy-ion collisions
 *
 * For the list of contributors see AUTHORS.
 *
 * Report issues at https://github.com/JETSCAPE/JETSCAPE/issues
 *
 * or via email to bugs.jetscape@gmail.com
 *
 * Distributed under the GNU General Public License 3.0 (GPLv3 or later).
 * See COPYING for details.
 ******************************************************************************/
// This is a general basic class for hydrodynamics

#ifndef EVOLUTIONHISTORY_H
#define EVOLUTIONHISTORY_H

#include <vector>
#include <stdexcept>
#include "FluidCellInfo.h"
#include "RealType.h"

namespace Jetscape {

// The simplest way for 3rd party hydro to provide evolution history is to
// send 2 vectors to the framework. One is a 1D float vector stores all
// the evolution history to data_vector.
// The other is the description of the content of the data to data_info.
// E.g., data_info should store a vector of 3 strings ['energy_density', 'vx, 'vy']
// if data_vector = [ed0, vx0, vy0, ed1, vx1, vy1, ..., edN, vxN, vyN, vzN],
// where N = ntau * nx * ny * netas is the number of total cells.
// One can pass these 3 data or more data to the framework, by storing them in any order,
// as long as the description matches the data content.
// The following is a list possible valid data names.
// ValidNames = [ "energy_density", "entropy_density", "temperature",
//                "pressure", "qgp_fraction", "mu_b", "mu_c", "mu_s",
//                "vx", "vy", "vz", "pi00", "pi01", "pi02", "pi03",
//                "pi11", "pi12", "pi13", "pi22", "pi23", "pi33", "bulk_pi"];
//

enum EntryName {
  ENTRY_ENERGY_DENSITY,
  ENTRY_ENTROPY_DENSITY,
  ENTRY_TEMPERATURE,
  ENTRY_PRESSURE,
  ENTRY_QGP_FRACTION,
  ENTRY_MU_B,
  ENTRY_MU_C,
  ENTRY_MU_S,
  ENTRY_VX,
  ENTRY_VY,
  ENTRY_VZ,
  ENTRY_PI00,
  ENTRY_PI01,
  ENTRY_PI02,
  ENTRY_PI03,
  ENTRY_PI11,
  ENTRY_PI12,
  ENTRY_PI13,
  ENTRY_PI22,
  ENTRY_PI23,
  ENTRY_PI33,
  ENTRY_BULK_PI,
  ENTRY_INVALID
};

EntryName ResolveEntryName(std::string input);

class InvalidSpaceTimeRange : public std::invalid_argument {
  using std::invalid_argument::invalid_argument;
};

class EvolutionHistory {
public:
  Jetscape::real tau_min, dtau; 

  Jetscape::real x_min, dx; 

  Jetscape::real y_min, dy; 

  Jetscape::real eta_min, deta; 
  int ntau; 
  int nx;   
  int ny;   
  int neta; 

  bool tau_eta_is_tz;

  bool boost_invariant;

  std::vector<FluidCellInfo> data;

  std::vector<float> data_vector;

  std::vector<std::string> data_info;

  EvolutionHistory() = default;

  void FromVector(const std::vector<float> &data_,
                  const std::vector<std::string> &data_info_, float tau_min,
                  float dtau, float x_min, float dx, int nx, float y_min,
                  float dy, int ny, float eta_min, float deta, int neta,
                  bool tau_eta_is_tz);

  ~EvolutionHistory() {
    data.clear();
    data_vector.clear();
    data_info.clear();
  }

  void clear_up_evolution_data() { data.clear(); }

  int get_data_size() const { return (data.size()); }
  bool is_boost_invariant() const { return (boost_invariant); }
  bool is_Cartesian() const { return (tau_eta_is_tz); }

  Jetscape::real Tau0() const { return (tau_min); }
  Jetscape::real XMin() const { return (x_min); }
  Jetscape::real YMin() const { return (y_min); }
  Jetscape::real EtaMin() const { return (eta_min); }

  inline Jetscape::real TauMax() const { return (tau_min + (ntau - 1) * dtau); }

  inline Jetscape::real XMax() const { return (x_min + (nx - 1) * dx); }

  inline Jetscape::real YMax() const { return (y_min + (ny - 1) * dy); }

  inline Jetscape::real EtaMax() const { return (eta_min + (neta - 1) * deta); }

  int CheckInRange(Jetscape::real tau, Jetscape::real x, Jetscape::real y,
                   Jetscape::real eta) const;

  // get the lower bound of the fluid cell along tau
  inline int GetIdTau(Jetscape::real tau) const {
    return (static_cast<int>((tau - tau_min) / dtau));
  }

  // get the lower bound of the fluid cell along x
  inline int GetIdX(Jetscape::real x) const {
    return (static_cast<int>((x - x_min) / dx));
  }

  // get the lower bound of the fluid cell along y
  inline int GetIdY(Jetscape::real y) const {
    return (static_cast<int>((y - y_min) / dy));
  }

  // get the lower bound of the fluid cell along eta
  inline int GetIdEta(Jetscape::real eta) const {
    return (static_cast<int>((eta - eta_min) / deta));
  }

  // get the coordinate of tau, x, y, eta on grid
  inline Jetscape::real TauCoord(int id_tau) const {
    return (tau_min + id_tau * dtau);
  }

  inline Jetscape::real XCoord(int id_x) const { return (x_min + id_x * dx); }

  inline Jetscape::real YCoord(int id_y) const { return (y_min + id_y * dy); }

  inline Jetscape::real EtaCoord(int id_eta) const {
    return (eta_min + id_eta * deta);
  }

  // get the FluidCellInfo index in data
  inline int CellIndex(int id_tau, int id_x, int id_y, int id_eta) const {
    id_tau = std::min(ntau - 1, std::max(0, id_tau));
    id_x = std::min(nx - 1, std::max(0, id_x));
    id_y = std::min(ny - 1, std::max(0, id_y));
    id_eta = std::min(neta - 1, std::max(0, id_eta));
    return (id_tau * nx * ny * neta + id_x * ny * neta + id_y * neta + id_eta);
  }

  /* Read fluid cell info for a given lattice cell*/
  FluidCellInfo GetFluidCell(int id_tau, int id_x, int id_y, int id_eta) const;

  // get the FluidCellInfo at space point given time step
  FluidCellInfo GetAtTimeStep(int id_tau, Jetscape::real x, Jetscape::real y,
                              Jetscape::real etas) const;

  // get the FluidCellInfo at given space time point
  FluidCellInfo get(Jetscape::real tau, Jetscape::real x, Jetscape::real y,
                    Jetscape::real etas) const;
  FluidCellInfo get_tz(Jetscape::real t, Jetscape::real x, Jetscape::real y,
                       Jetscape::real z) const;
};

} // namespace Jetscape

#endif // EVOLUTIONHISTORY_H