JetEnergyLoss.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file JetEnergyLoss.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 JETENERGYLOSS_H
#define JETENERGYLOSS_H

#include "JetScapeModuleBase.h"
#include "FluidDynamics.h"
#include "FluidCellInfo.h"
#include "JetClass.h"
#include "JetScapeWriter.h"
#include "PartonShower.h"
#include "PartonPrinter.h"
#include "MakeUniqueHelper.h"
#include "LiquefierBase.h"
#include <vector>
#include <random>

namespace Jetscape {

class JetEnergyLoss : public JetScapeModuleBase,
                      public std::enable_shared_from_this<JetEnergyLoss> {

public:
  JetEnergyLoss();

  JetEnergyLoss(const JetEnergyLoss &j);

  virtual ~JetEnergyLoss();

  virtual shared_ptr<JetEnergyLoss> Clone() const { return nullptr; }

  virtual void Init();

  virtual void
  Exec() final; // prevents eloss modules from overwrting and missusing

  virtual void WriteTask(weak_ptr<JetScapeWriter> w);

  virtual void Clear();

  virtual void DoEnergyLoss(double deltaT, double time, double Q2,
                            vector<Parton> &pIn, vector<Parton> &pOut){};

  sigslot::signal5<double, double, double, double,
                   std::unique_ptr<FluidCellInfo> &, multi_threaded_local>
      GetHydroCellSignal;
  
  sigslot::signal1<double &, multi_threaded_local> GetHydroTau0Signal;

  sigslot::signal2<int, double, multi_threaded_local> jetSignal;

  sigslot::signal2<int, double &, multi_threaded_local> edensitySignal;

  sigslot::signal5<double, double, double, vector<Parton> &, vector<Parton> &,
                   multi_threaded_local>
      SentInPartons;
  
  void SetQhat(double m_qhat) { qhat = m_qhat; }

  const double GetQhat() const { return qhat; }

  void AddShowerInitiatingParton(shared_ptr<Parton> p) { inP = p; }

  shared_ptr<Parton> GetShowerInitiatingParton() { return inP; }

  void PrintShowerInitiatingParton();

  double GetDeltaT() { return deltaT; }

  double GetMaxT() { return maxT; }

  shared_ptr<PartonShower> GetShower() { return pShower; }

  // old test signals ======================

  void SetJetSignalConnected(bool m_jetSignalConnected) {
    jetSignalConnected = m_jetSignalConnected;
  }

  const bool GetJetSignalConnected() const { return jetSignalConnected; }

  void SetEdensitySignalConnected(bool m_edensitySignalConnected) {
    edensitySignalConnected = m_edensitySignalConnected;
  }

  const bool GetEdensitySignalConnected() const {
    return edensitySignalConnected;
  }

  void SetGetHydroCellSignalConnected(bool m_GetHydroCellSignalConnected) {
    GetHydroCellSignalConnected = m_GetHydroCellSignalConnected;
  }

  const bool GetGetHydroCellSignalConnected() {
    return GetHydroCellSignalConnected;
  }

  void SetGetHydroTau0SignalConnected(bool m_GetHydroTau0SignalConnected) {
    GetHydroTau0SignalConnected = m_GetHydroTau0SignalConnected;
  }

  const bool GetGetHydroTau0SignalConnected() {
    return GetHydroTau0SignalConnected;
  }

  void SetSentInPartonsConnected(bool m_SentInPartonsConnected) {
    SentInPartonsConnected = m_SentInPartonsConnected;
  }

  const bool GetSentInPartonsConnected() { return SentInPartonsConnected; }

  void add_a_liquefier(std::shared_ptr<LiquefierBase> new_liquefier) {
    liquefier_ptr = new_liquefier;
  }

  std::weak_ptr<LiquefierBase> get_liquefier() { return (liquefier_ptr); }

  // The Slot method to send the vector of Hadronization module
  void SendFinalStatePartons(vector<vector<shared_ptr<Parton>>> &fPartons) {
    fPartons = final_Partons;
  }

  void GetFinalPartonsForEachShower(shared_ptr<PartonShower> shower);

protected:
  std::weak_ptr<LiquefierBase> liquefier_ptr;

private:
  double deltaT;
  double maxT;

  double qhat;
  shared_ptr<Parton> inP;
  shared_ptr<PartonShower> pShower;

  bool GetHydroCellSignalConnected;
  bool GetHydroTau0SignalConnected;
  bool SentInPartonsConnected;

  void DoShower();

  node vStart;
  node vEnd;

  //old test signals
  bool jetSignalConnected;
  bool edensitySignalConnected;

  // Vector of final state partons for each shower as a vector

  vector<vector<shared_ptr<Parton>>> final_Partons;
};

} // end namespace Jetscape

#endif