collidermodus.h

Go to the documentation of this file.

/*
 *    Copyright (c) 2012-2020,2022-2024
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 */
#ifndef SRC_INCLUDE_SMASH_COLLIDERMODUS_H_
#define SRC_INCLUDE_SMASH_COLLIDERMODUS_H_
 
#include <cstring>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
#include "alphaclusterednucleus.h"
#include "deformednucleus.h"
#include "forwarddeclarations.h"
#include "fourvector.h"
#include "icparameters.h"
#include "interpolation.h"
#include "modusdefault.h"
#include "nucleus.h"
#include "pdgcode.h"
 
namespace smash {
 
struct ExperimentParameters;
 
class ColliderModus : public ModusDefault {
 public:
  explicit ColliderModus(Configuration modus_config,
                         const ExperimentParameters &parameters);
  std::string custom_file_path(const std::string &file_directory,
                               const std::string &file_name);
  double initial_conditions(Particles *particles,
                            const ExperimentParameters &parameters);
 
  void sample_impact();
 
  double nuclei_passing_time() const {
    const double passing_distance =
        projectile_->get_nuclear_radius() + target_->get_nuclear_radius();
    const double passing_time =
        passing_distance /
        std::sqrt(sqrt_s_NN_ * sqrt_s_NN_ /
                      ((2 * nucleon_mass) * (2 * nucleon_mass)) -
                  1);
    return passing_time;
  }
  double velocity_projectile() const { return velocity_projectile_; }
  double velocity_target() const { return velocity_target_; }
  FermiMotion fermi_motion() { return fermi_motion_; }
  bool is_collider() const { return true; }
  double sqrt_s_NN() const { return sqrt_s_NN_; }
  double impact_parameter() const { return impact_; }
  bool calculation_frame_is_fixed_target() const {
    return frame_ == CalculationFrame::FixedTarget ? true : false;
  }
  bool is_IC_for_hybrid() const { return IC_for_hybrid_; }
  const InitialConditionParameters &IC_parameters() const {
    return *IC_parameters_;
  }
  const std::map<int32_t, double> &fluid_background() const {
    return *fluid_background_;
  }
  const RectangularLattice<EnergyMomentumTensor> &fluid_lattice() const {
    return *fluid_lattice_;
  }
  void build_fluidization_lattice(double t,
                                  const std::vector<Particles> &ensembles,
                                  const DensityParameters &dens_par);
 
  void update_fluidization_background(std::map<int32_t, double> &&background) {
    *fluid_background_ = std::move(background);
  }
 
  struct ColliderEmpty : public ModusDefault::BadInput {
    using ModusDefault::BadInput::BadInput;
  };
 
 private:
  std::unique_ptr<Nucleus> projectile_;
  std::unique_ptr<Nucleus> target_;
  double total_s_;
  double sqrt_s_NN_;
  static std::unique_ptr<DeformedNucleus> create_deformed_nucleus(
      Configuration &nucleus_cfg, const int ntest,
      const std::string &nucleus_type);
  static std::unique_ptr<AlphaClusteredNucleus> create_alphaclustered_nucleus(
      Configuration &nucleus_cfg, const int ntest,
      const std::string &nucleus_type);
  bool same_inputfile(Configuration &proj_config, Configuration &targ_config);
  double impact_ = 0.;
  bool random_reaction_plane_;
  bool IC_for_hybrid_ = false;
  Sampling sampling_ = InputKeys::modi_collider_impact_sample.default_value();
  double imp_min_ = InputKeys::modi_collider_impact_value.default_value();
  double imp_max_ = InputKeys::modi_collider_impact_value.default_value();
  double yield_max_ = 0.0;
  std::unique_ptr<InterpolateDataLinear<double>> impact_interpolation_ =
      nullptr;
 
  void rotate_reaction_plane(double phi, Particles *particles);
 
  double initial_z_displacement_;
  CalculationFrame frame_;
  FermiMotion fermi_motion_;
  double velocity_projectile_ = 0.0;
  double velocity_target_ = 0.0;
  std::unique_ptr<InitialConditionParameters> IC_parameters_;
  std::unique_ptr<RectangularLattice<EnergyMomentumTensor>> fluid_lattice_ =
      nullptr;
  std::unique_ptr<std::map<int32_t, double>> fluid_background_ = nullptr;
 
  std::pair<double, double> get_velocities(double mandelstam_s, double m_a,
                                           double m_b);
 
  friend std::ostream &operator<<(std::ostream &, const ColliderModus &);
};
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_COLLIDERMODUS_H_