split run2,3 and Run4

Author: civanch

SimG4Core/Application/interface/CMSSimEventManager.h

@@ -18,9 +18,9 @@ namespace edm {
 }
 
 class G4Event;
-class EventAction;
-class StackingAction;
-class TrackingAction;
+class G4UserEventAction;
+class G4UserStackingAction;
+class G4UserTrackingAction;
 class G4UserSteppingAction;
 class G4SDManager;
 class G4StateManager;
@@ -41,9 +41,9 @@ class CMSSimEventManager {
   // This method aborts the processing of the current event.
   void AbortCurrentEvent();
 
-  void SetUserAction(EventAction* ptr);
-  void SetUserAction(StackingAction* ptr);
-  void SetUserAction(TrackingAction* ptr);
+  void SetUserAction(G4UserEventAction* ptr);
+  void SetUserAction(G4UserStackingAction* ptr);
+  void SetUserAction(G4UserTrackingAction* ptr);
   void SetUserAction(G4UserSteppingAction* ptr);
 
   CMSSimEventManager(const CMSSimEventManager& right) = delete;
@@ -58,9 +58,9 @@ class CMSSimEventManager {
   G4PrimaryTransformer* m_primaryTransformer;
   G4Navigator* m_navigator;
 
-  EventAction* m_eventAction;
-  StackingAction* m_stackingAction;
-  TrackingAction* m_trackingAction;
+  G4UserEventAction* m_eventAction;
+  G4UserTrackingAction* m_trackingAction;
+  G4UserStackingAction* m_stackingAction;
 
   G4int trackID_{0};
   G4int verbose_;

SimG4Core/Application/interface/Phase2EventAction.h

@@ -0,0 +1,57 @@
+#ifndef SimG4Core_Phase2EventAction_H
+#define SimG4Core_Phase2EventAction_H
+//
+// Package:     Application
+// Class  :     Phase2EventAction
+//
+// Description: Manage MC truth 
+// Created:     08.04.2025 V.Ivantchenko
+//
+
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+
+#include "SimG4Core/Notification/interface/SimTrackManager.h"
+#include "SimG4Core/Notification/interface/TrackWithHistory.h"
+#include "SimG4Core/Notification/interface/TrackContainer.h"
+#include "SimG4Core/Notification/interface/SimActivityRegistry.h"
+
+#include "G4UserEventAction.hh"
+
+#include <vector>
+#include <string>
+
+class SimRunInterface;
+class BeginOfEvent;
+class EndOfEvent;
+class CMSSteppingVerbose;
+
+class Phase2EventAction : public G4UserEventAction {
+public:
+  explicit Phase2EventAction(const edm::ParameterSet& ps, SimRunInterface*, SimTrackManager*, CMSSteppingVerbose*);
+  ~Phase2EventAction() override = default;
+
+  void BeginOfEventAction(const G4Event* evt) override;
+  void EndOfEventAction(const G4Event* evt) override;
+
+  void abortEvent();
+
+  const TrackContainer* trackContainer() const { return m_trackManager->trackContainer(); }
+
+  TrackWithHistory* getTrackByID(int id) const { return m_trackManager->getTrackByID(id); }
+
+  SimActivityRegistry::BeginOfEventSignal m_beginOfEventSignal;
+  SimActivityRegistry::EndOfEventSignal m_endOfEventSignal;
+
+  Phase2EventAction(const Phase2EventAction&) = delete;
+  const Phase2EventAction& operator=(const Phase2EventAction&) = delete;
+  
+private:
+  SimRunInterface* m_runInterface;
+  SimTrackManager* m_trackManager;
+  CMSSteppingVerbose* m_SteppingVerbose;
+  std::string m_stopFile;
+  bool m_printRandom;
+  bool m_debug;
+};
+
+#endif

SimG4Core/Application/interface/Phase2TrackingAction.h

@@ -0,0 +1,61 @@
+#ifndef SimG4Core_Phase2TrackingAction_H
+#define SimG4Core_Phase2TrackingAction_H
+//
+// Package:     Application
+// Class  :     Phase2TrackingAction
+//
+// Description: Manage tracks 
+// Created:     08.04.2025 V.Ivantchenko
+//
+
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "SimG4Core/Notification/interface/SimActivityRegistry.h"
+
+#include "G4UserTrackingAction.hh"
+#include "G4Region.hh"
+
+#include <vector>
+
+class SimTrackManager;
+class CMSG4TrackInterface;
+class TrackWithHistory;
+class BeginOfTrack;
+class EndOfTrack;
+class CMSSteppingVerbose;
+class TrackInformation;
+
+class Phase2TrackingAction : public G4UserTrackingAction {
+public:
+  explicit Phase2TrackingAction(SimTrackManager*, CMSSteppingVerbose*, const edm::ParameterSet& ps);
+  ~Phase2TrackingAction() override = default;
+
+  void PreUserTrackingAction(const G4Track* aTrack) override;
+  void PostUserTrackingAction(const G4Track* aTrack) override;
+
+  inline TrackWithHistory* currentTrackWithHistory() { return currentTrack_; }
+  inline const G4Track* geant4Track() const { return g4Track_; }
+  inline G4TrackingManager* getTrackManager() { return fpTrackingManager; }
+
+  SimActivityRegistry::BeginOfTrackSignal m_beginOfTrackSignal;
+  SimActivityRegistry::EndOfTrackSignal m_endOfTrackSignal;
+
+  Phase2TrackingAction(Phase2TrackingAction&) = delete;
+  Phase2TrackingAction& operator=(const Phase2TrackingAction& right) = delete;
+
+private:
+  SimTrackManager* trackManager_;
+  CMSG4TrackInterface* trackInterface_;
+  CMSSteppingVerbose* steppingVerbose_;
+  const G4Track* g4Track_ = nullptr;
+  TrackInformation* trkInfo_ = nullptr;
+  TrackWithHistory* currentTrack_ = nullptr;
+  int endPrintTrackID_;
+  bool checkTrack_;
+  bool doFineCalo_;
+  bool saveCaloBoundaryInformation_;
+  double ekinMin_;
+  std::vector<double> ekinMinRegion_;
+  std::vector<G4Region*> ptrRegion_;
+};
+
+#endif

SimG4Core/Application/interface/RunManagerMTWorker.h

@@ -36,7 +36,9 @@ class CustomUIsession;
 
 class RunAction;
 class EventAction;
+class Phase2EventAction;
 class TrackingAction;
+class Phase2TrackingAction;
 class SteppingAction;
 class Phase2SteppingAction;
 class CMSSteppingVerbose;
@@ -65,7 +67,9 @@ class RunManagerMTWorker {
 
   void Connect(RunAction*);
   void Connect(EventAction*);
+  void Connect(Phase2EventAction*);
   void Connect(TrackingAction*);
+  void Connect(Phase2TrackingAction*);
   void Connect(SteppingAction*);
   void Connect(Phase2SteppingAction*);
 

SimG4Core/Application/interface/StackingAction.h

@@ -14,10 +14,11 @@
 class TrackingAction;
 class CMSSteppingVerbose;
 class G4VProcess;
+class CMSG4TrackInterface;
 
 class StackingAction : public G4UserStackingAction {
 public:
-  explicit StackingAction(const TrackingAction*, const edm::ParameterSet& ps, const CMSSteppingVerbose*);
+  explicit StackingAction(const edm::ParameterSet& ps, const CMSSteppingVerbose*);
 
   ~StackingAction() override = default;
 
@@ -69,7 +70,7 @@ class StackingAction : public G4UserStackingAction {
   std::vector<const G4Region*> deadRegions;
 
   G4VSolid* worldSolid;
-  const TrackingAction* trackAction;
+  CMSG4TrackInterface* m_trackInterface;
   const CMSSteppingVerbose* steppingVerbose;
   const G4VProcess* m_Compton{nullptr};
 

SimG4Core/Application/src/CMSSimEventManager.cc

@@ -1,8 +1,5 @@
 #include "SimG4Core/Application/interface/CMSSimEventManager.h"
 #include "SimG4Core/Application/interface/RunAction.h"
-#include "SimG4Core/Application/interface/EventAction.h"
-#include "SimG4Core/Application/interface/StackingAction.h"
-#include "SimG4Core/Application/interface/TrackingAction.h"
 
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
 #include "FWCore/MessageLogger/interface/MessageLogger.h"
@@ -13,7 +10,10 @@
 #include "G4PrimaryTransformer.hh"
 #include "G4TrackingManager.hh"
 #include "G4TrackStatus.hh"
+#include "G4UserEventAction.hh"
+#include "G4UserTrackingAction.hh"
 #include "G4UserSteppingAction.hh"
+#include "G4UserStackingAction.hh"
 
 #include "G4SDManager.hh"
 #include "G4StateManager.hh"
@@ -98,13 +98,13 @@ void CMSSimEventManager::StackTracks(G4TrackVector* trackVector, bool IDisSet) {
   trackVector->clear();
 }
 
-void CMSSimEventManager::SetUserAction(EventAction* ptr) { m_eventAction = ptr; }
+void CMSSimEventManager::SetUserAction(G4UserEventAction* ptr) { m_eventAction = ptr; }
 
-void CMSSimEventManager::SetUserAction(StackingAction* ptr) { m_stackingAction = ptr; }
+void CMSSimEventManager::SetUserAction(G4UserStackingAction* ptr) { m_stackingAction = ptr; }
 
-void CMSSimEventManager::SetUserAction(TrackingAction* ptr) {
+void CMSSimEventManager::SetUserAction(G4UserTrackingAction* ptr) {
   m_trackingAction = ptr;
-  m_defTrackManager->SetUserAction((G4UserTrackingAction*)ptr);
+  m_defTrackManager->SetUserAction(ptr);
 }
 
 void CMSSimEventManager::SetUserAction(G4UserSteppingAction* ptr) { m_defTrackManager->SetUserAction(ptr); }

SimG4Core/Application/src/Phase2EventAction.cc

@@ -0,0 +1,65 @@
+#include "SimG4Core/Application/interface/Phase2EventAction.h"
+#include "SimG4Core/Application/interface/SimRunInterface.h"
+#include "SimG4Core/Notification/interface/TmpSimEvent.h"
+#include "SimG4Core/Notification/interface/TmpSimVertex.h"
+#include "SimG4Core/Notification/interface/BeginOfEvent.h"
+#include "SimG4Core/Notification/interface/EndOfEvent.h"
+#include "SimG4Core/Notification/interface/CMSSteppingVerbose.h"
+
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+
+#include "Randomize.hh"
+
+Phase2EventAction::Phase2EventAction(const edm::ParameterSet& p,
+                                     SimRunInterface* rm,
+                                     SimTrackManager* iManager,
+                                     CMSSteppingVerbose* sv)
+    : m_runInterface(rm),
+      m_trackManager(iManager),
+      m_SteppingVerbose(sv),
+      m_stopFile(p.getParameter<std::string>("StopFile")),
+      m_printRandom(p.getParameter<bool>("PrintRandomSeed")),
+      m_debug(p.getUntrackedParameter<bool>("debug", false)) {}
+
+void Phase2EventAction::BeginOfEventAction(const G4Event* anEvent) {
+  BeginOfEvent e(anEvent);
+  m_beginOfEventSignal(&e);
+
+  if (m_printRandom) {
+    edm::LogVerbatim("SimG4CoreApplication")
+        << "BeginOfEvent " << anEvent->GetEventID() << " Random number: " << G4UniformRand();
+  }
+
+  if (nullptr != m_SteppingVerbose) {
+    m_SteppingVerbose->beginOfEvent(anEvent);
+  }
+}
+
+void Phase2EventAction::EndOfEventAction(const G4Event* anEvent) {
+  if (m_printRandom) {
+    edm::LogVerbatim("SimG4CoreApplication")
+        << "Phase2EventAction::EndOfEventAction: " << anEvent->GetEventID() << " Random number: " << G4UniformRand();
+  }
+  if (!m_stopFile.empty() && std::ifstream(m_stopFile.c_str())) {
+    edm::LogWarning("SimG4CoreApplication")
+        << "Phase2EventAction::EndOfEventAction: termination signal received at event " << anEvent->GetEventID();
+    // soft abort run
+    m_runInterface->abortRun(true);
+  }
+  if (anEvent->GetNumberOfPrimaryVertex() == 0) {
+    edm::LogWarning("SimG4CoreApplication") << "Phase2EventACtion::EndOfEventAction: event " << anEvent->GetEventID()
+                                            << " must have failed (no G4PrimaryVertices found) and will be skipped";
+    return;
+  }
+
+  m_trackManager->storeTracks();
+
+  // dispatch now end of event
+  EndOfEvent e(anEvent);
+  m_endOfEventSignal(&e);
+
+  // delete transient objects
+  m_trackManager->reset();
+}
+
+void Phase2EventAction::abortEvent() { m_runInterface->abortEvent(); }