src/framework/JetScapeSignalManager.h

0001 /*******************************************************************************
0002  * Copyright (c) The JETSCAPE Collaboration, 2018
0003  *
0004  * Modular, task-based framework for simulating all aspects of heavy-ion collisions
0005  *
0006  * For the list of contributors see AUTHORS.
0007  *
0008  * Report issues at https://github.com/JETSCAPE/JETSCAPE/issues
0009  *
0010  * or via email to bugs.jetscape@gmail.com
0011  *
0012  * Distributed under the GNU General Public License 3.0 (GPLv3 or later).
0013  * See COPYING for details.
0014  ******************************************************************************/
0015
0016 //  SignalManager instance class (meant as singelton)
0017
0018 #ifndef JETSCAPESIGNALMANAGER_H
0019 #define JETSCAPESIGNALMANAGER_H
0020
0021 #include "Afterburner.h"
0022 #include "InitialState.h"
0023 #include "JetEnergyLoss.h"
0024 #include "JetEnergyLossManager.h"
0025 #include "HadronizationManager.h"
0026 #include "Hadronization.h"
0027 #include "FluidDynamics.h"
0028 #include "HardProcess.h"
0029 #include "JetScapeWriter.h"
0030 #include "PreequilibriumDynamics.h"
0031 #include "PartonPrinter.h"
0032 #include "HadronPrinter.h"
0033
0034 #include <iostream>
0035 #include <string>
0036 #include <map>
0037 #include "sigslot.h"
0038
0039 using namespace sigslot;
0040
0041 namespace Jetscape {
0042
0043 class
0044     JetScapeSignalManager //: public sigslot::has_slots<sigslot::multi_threaded_local>
0045 {
0046
0047 public:
0048   static JetScapeSignalManager *Instance();
0049
0050   void SetInitialStatePointer(shared_ptr<InitialState> m_initial) {
0051     initial_state = m_initial;
0052   }
0053   weak_ptr<InitialState> GetInitialStatePointer() { return initial_state; }
0054
0055   void SetPreEquilibriumPointer(shared_ptr<PreequilibriumDynamics> m_pre_eq) {
0056     pre_equilibrium = m_pre_eq;
0057   }
0058   weak_ptr<PreequilibriumDynamics> GetPreEquilibriumPointer() {
0059     return pre_equilibrium;
0060   }
0061
0062   void SetHydroPointer(shared_ptr<FluidDynamics> m_hydro) { hydro = m_hydro; }
0063   weak_ptr<FluidDynamics> GetHydroPointer() { return hydro; }
0064
0065   void SetSoftParticlizationPointer(shared_ptr<SoftParticlization> m_soft) {
0066     softparticlization = m_soft;
0067   }
0068   weak_ptr<SoftParticlization> GetSoftParticlizationPointer() {
0069     return softparticlization;
0070   }
0071
0072   void
0073   SetJetEnergyLossManagerPointer(shared_ptr<JetEnergyLossManager> m_jloss) {
0074     jloss = m_jloss;
0075   }
0076   weak_ptr<JetEnergyLossManager> GetJetEnergyLossManagerPointer() {
0077     return jloss;
0078   }
0079
0080   void SetHardProcessPointer(shared_ptr<HardProcess> m_hardp) {
0081     hardp = m_hardp;
0082   }
0083   weak_ptr<HardProcess> GetHardProcessPointer() { return hardp; }
0084
0085   void SetWriterPointer(shared_ptr<JetScapeWriter> m_writer) {
0086     writer = m_writer;
0087   }
0088   weak_ptr<JetScapeWriter> GetWriterPointer() { return writer; }
0089
0090   void
0091   SetHadronizationManagerPointer(shared_ptr<HadronizationManager> m_hadro) {
0092     hadro = m_hadro;
0093   }
0094   weak_ptr<HadronizationManager> GetHadronizationManagerPointer() {
0095     return hadro;
0096   }
0097
0098   void SetPartonPrinterPointer(shared_ptr<PartonPrinter> m_pprinter) {
0099     pprinter = m_pprinter;
0100   }
0101   weak_ptr<PartonPrinter> GetPartonPrinterPointer() { return pprinter; }
0102
0103   void SetHadronPrinterPointer(shared_ptr<HadronPrinter> m_hprinter) {
0104     hprinter = m_hprinter;
0105   }
0106   weak_ptr<HadronPrinter> GetHadronPrinterPointer() { return hprinter; }
0107
0108
0109   void SetEnergyLossPointer(shared_ptr<JetEnergyLoss> m_eloss) {
0110     eloss = m_eloss;
0111   }
0112
0113   weak_ptr<JetEnergyLoss> GetEnergyLossPointer() { return eloss; }
0114
0115   void ConnectJetSignal(shared_ptr<JetEnergyLoss> j);
0116   void ConnectEdensitySignal(shared_ptr<JetEnergyLoss> j);
0117   void ConnectGetHydroTau0Signal(shared_ptr<JetEnergyLoss> j);
0118   void ConnectGetHydroCellSignal(shared_ptr<JetEnergyLoss> j);
0119   void ConnectGetHydroCellSignal(shared_ptr<LiquefierBase> l);
0120   void ConnectGetHydroCellSignal(shared_ptr<Hadronization> h);
0121   void ConnectGetHardPartonListSignal(shared_ptr<JetEnergyLossManager> jm);
0122   void ConnectSentInPartonsSignal(shared_ptr<JetEnergyLoss> j,
0123                                   shared_ptr<JetEnergyLoss> j2);
0124   void ConnectGetFinalPartonListSignal(shared_ptr<HadronizationManager> hm);
0125   void ConnectTransformPartonsSignal(shared_ptr<Hadronization> h,
0126                                      shared_ptr<Hadronization> h2);
0127         void ConnectGetFinalHadronListSignal(shared_ptr<HadronPrinter> h);
0128
0129   void ConnectGetHydroHyperSurfaceSignal(shared_ptr<Hadronization> h);
0130
0131   void
0132   DisconnectSignal(){}; // to be implememted if needed maybe for Eloss ...!???
0133
0134   void CleanUp();
0135
0136   int GetNumberOfJetSignals() { return num_jet_signals; }
0137   int GetNumberOfEdensitySignals() { return num_edensity_signals; }
0138   int GetNumberOfGetHydroCellSignals() { return num_GetHydroCellSignals; }
0139
0140   void PrintJetSignalMap();
0141   void PrintEdensitySignalMap();
0142   void PrintGetHydroCellSignalMap();
0143   void PrintSentInPartonsSignalMap();
0144   void PrintTransformPartonsSignalMap();
0145
0146 private:
0147   JetScapeSignalManager(){};
0148   JetScapeSignalManager(JetScapeSignalManager const &){};
0149   static JetScapeSignalManager *m_pInstance;
0150
0151   weak_ptr<InitialState> initial_state;
0152   weak_ptr<PreequilibriumDynamics> pre_equilibrium;
0153   weak_ptr<FluidDynamics> hydro;
0154   weak_ptr<JetEnergyLossManager> jloss;
0155   weak_ptr<HardProcess> hardp;
0156   weak_ptr<JetScapeWriter> writer;
0157   weak_ptr<HadronizationManager> hadro;
0158   weak_ptr<Afterburner> afterburner;
0159   weak_ptr<PartonPrinter> pprinter;
0160   weak_ptr<HadronPrinter> hprinter;
0161   weak_ptr<JetEnergyLoss> eloss;
0162   weak_ptr<SoftParticlization> softparticlization;
0163
0164   int num_jet_signals = 0;
0165   int num_edensity_signals = 0;
0166   int num_GetHydroCellSignals = 0;
0167   int num_SentInPartons = 0;
0168   int num_TransformPartons = 0;
0169
0170   map<int, weak_ptr<JetEnergyLoss>> jet_signal_map;
0171   map<int, weak_ptr<JetEnergyLoss>> edensity_signal_map;
0172   map<int, weak_ptr<JetEnergyLoss>> GetHydroCellSignal_map;
0173
0174   map<int, weak_ptr<JetEnergyLoss>> SentInPartons_map;
0175   map<int, weak_ptr<Hadronization>> TransformPartons_map;
0176 };
0177
0178 } // end namespace Jetscape
0179
0180 #endif