InitialState.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file InitialState.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.
 ******************************************************************************/

#ifndef INITIALSTATE_H
#define INITIALSTATE_H

#include <tuple>
#include <memory>
#include "JetScapeModuleBase.h"
#include "JetClass.h"

namespace Jetscape {
class InitialState : public JetScapeModuleBase {
public:
  InitialState() { SetId("InitialState"); }

  ~InitialState();

  virtual void Init();

  virtual void Exec();

  virtual void Clear();

  virtual void Write(weak_ptr<JetScapeWriter> w);

  virtual void CollectHeader(weak_ptr<JetScapeWriter> w);

  virtual double GetNpart() { return -1; };

  virtual double GetNcoll() { return -1; };

  virtual double GetTotalEntropy() { return -1; };

  // one can set range by hand if not read from xml file
  inline void SetRanges(double xmax, double ymax, double zmax) {
    grid_max_x_ = xmax;
    grid_max_y_ = ymax;
    grid_max_z_ = zmax;
  }

  // one can set grid steps by hand if not read from xml file
  inline void SetSteps(double dx, double dy, double dz) {
    grid_step_x_ = dx;
    grid_step_y_ = dy;
    grid_step_z_ = dz;
  }

  inline std::vector<double> GetEntropyDensityDistribution() {
    return entropy_density_distribution_;
  };

  inline std::vector<double> GetNumOfBinaryCollisions() {
    return num_of_binary_collisions_;
  };

  int GetEventId() const { return (event_id_); }

  void SetEventId(int event_id_in) { event_id_ = event_id_in; }

  std::tuple<double, double, double> CoordFromIdx(int idx);
  virtual void SampleABinaryCollisionPoint(double &x, double &y);

  inline double GetXMax() { return grid_max_x_; }
  inline double GetXStep() { return grid_step_x_; }
  inline double GetYMax() { return grid_max_y_; }
  inline double GetYStep() { return grid_step_y_; }
  inline double GetZMax() { return grid_max_z_; }
  inline double GetZStep() { return grid_step_z_; }

  // get number of grids along x, follow trento convention
  inline int GetXSize() {
    return int(std::ceil(2 * grid_max_x_ / grid_step_x_));
  }

  // get number of grids along y
  inline int GetYSize() {
    return int(std::ceil(2 * grid_max_y_ / grid_step_y_));
  }

  // get number of grids along z
  inline int GetZSize() {
    int nz = 1;
    if (grid_step_z_ != 0) {
      nz = int(std::ceil(2 * grid_max_z_ / grid_step_z_));
      // for 2d case, user may set grid_max_z_ = 0,
      if (nz == 0)
        nz = 1;
    }
    return nz;
  }

protected:
  // initial state entropy density distribution for the given grids
  // stored order: for z { for y {for x } }
  std::vector<double> entropy_density_distribution_;

  // one can sample jet production position from Ta * Tb
  // where Ta * Tb is the distribution of num_of_binary_collisions
  // stored order: for z { for y {for x } }
  std::vector<double> num_of_binary_collisions_;
  // the above should be private. Only Adding getters for now to not break other people's code

  //inline std::vector<double> GetEntropyDensityDistribution() {return entropy_density_distribution_;};

  // one can sample jet production position from Ta * Tb
  // where Ta * Tb is the distribution of num_of_binary_collisions
  //inline std::vector<double> GetNumOfBinaryCollisions() {return num_of_binary_collisions_;};

  // compute 3d coordinates (x, y, z) given the 1D index in vector
  //std::tuple<double, double, double> CoordFromIdx(int idx);

  int event_id_;
  //int GetEventId() const {return(event_id_);}
  //void SetEventId(int event_id_in) {event_id_ = event_id_in;}

  // default assumption: x range = [-grid_max_x_, grid_max_x_]
  // default assumption: y range = [-grid_max_y_, grid_max_y_]
  // default assumption: z range = [-grid_max_z_, grid_max_z_]
  double grid_max_x_;
  double grid_max_y_;
  double grid_max_z_; // z can represent spatial rapidity

  // one problem: different hydro codes require different dx_i / dtau
  // matches between (dx_i/dtau, hydro_code) should be checked
  double grid_step_x_;
  double grid_step_y_;
  double grid_step_z_;
};

} // end namespace Jetscape

#endif