Merge pull request #2354 from civanch/ForGeant4_10.0

Geant4.10 -- For geant4 10.0 UserActions
cms-sw · Feb 7, 2014 · 4b9defe · 4b9defe
2 parents 2ff20b4 + ea7ca0c
commit 4b9defe
Show file tree

Hide file tree

Showing 18 changed files with 562 additions and 158 deletions.
diff --git a/Alignment/LaserAlignmentSimulation/plugins/LaserOpticalPhysics.cc b/Alignment/LaserAlignmentSimulation/plugins/LaserOpticalPhysics.cc
@@ -34,7 +34,7 @@ LaserOpticalPhysics::LaserOpticalPhysics(G4LogicalVolumeToDDLogicalPartMap& map,
 	    << std::endl;
 
   // EM Physics
-  RegisterPhysics( new CMSEmStandardPhysics("standard EM", ver));
+  RegisterPhysics(new CMSEmStandardPhysics(ver));
   // Synchroton Radiation & GN Physics
   RegisterPhysics(new G4EmExtraPhysics(ver));
   // Decays

diff --git a/SimG4Core/Application/interface/ActionInitialization.h b/SimG4Core/Application/interface/ActionInitialization.h
@@ -0,0 +1,44 @@
+#ifndef SimG4Core_ActionInitialization_h
+#define SimG4Core_ActionInitialization_h 1
+
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "SimG4Core/Generators/interface/Generator.h"
+
+#include "G4VUserActionInitialization.hh"
+
+// Action initialization class.
+//
+
+class RunManager;
+class CMSRunInterface;
+
+class ActionInitialization : public G4VUserActionInitialization
+{
+public:
+
+  ActionInitialization(const edm::ParameterSet & ps, 
+		       RunManager* runm);
+
+  virtual ~ActionInitialization();
+
+  virtual void BuildForMaster() const;
+  virtual void Build() const;
+
+private:
+
+  RunManager*       m_runManager;
+
+  edm::ParameterSet m_pGenerator;   
+  edm::ParameterSet m_pVertexGenerator;
+  edm::ParameterSet m_pPhysics; 
+  edm::ParameterSet m_pRunAction;      
+  edm::ParameterSet m_pEventAction;
+  edm::ParameterSet m_pStackingAction;
+  edm::ParameterSet m_pTrackingAction;
+  edm::ParameterSet m_pSteppingAction;
+
+};
+
+#endif
+
+
diff --git a/SimG4Core/Application/interface/EventAction.h b/SimG4Core/Application/interface/EventAction.h
@@ -17,7 +17,7 @@
 #include <vector>
 #include <map>
 
-class RunManager;
+class SimRunInterface;
 class BeginOfEvent;
 class EndOfEvent;
 
@@ -26,7 +26,7 @@ class EventAction: public G4UserEventAction
 public:
 
     EventAction(const edm::ParameterSet& ps,
-                RunManager*,
+                SimRunInterface*,
 		SimTrackManager*);
     ~EventAction();
 
@@ -47,7 +47,7 @@ class EventAction: public G4UserEventAction
 
 private:
     //does not own the manager
-    RunManager*      m_runManager;
+    SimRunInterface* m_runInterface;
     SimTrackManager* m_trackManager;
     std::string m_stopFile;
     bool m_debug;

diff --git a/SimG4Core/Application/interface/RunAction.h b/SimG4Core/Application/interface/RunAction.h
@@ -8,21 +8,21 @@
 
 #include <string>
 
-class RunManager;
+class SimRunInterface;
 class BeginOfRun;
 class EndOfRun;
 
 class RunAction: public G4UserRunAction
 {
 public:
-    RunAction(const edm::ParameterSet & ps, RunManager*);
+    RunAction(const edm::ParameterSet & ps, SimRunInterface*);
     void BeginOfRunAction(const G4Run * aRun);
     void EndOfRunAction(const G4Run * aRun);
 
     SimActivityRegistry::BeginOfRunSignal m_beginOfRunSignal;
     SimActivityRegistry::EndOfRunSignal m_endOfRunSignal; 
 private:
-    RunManager* m_runManager;
+    SimRunInterface* m_runInterface;
     std::string m_stopFile;
 };
 

diff --git a/SimG4Core/Application/interface/RunManager.h b/SimG4Core/Application/interface/RunManager.h
@@ -3,7 +3,6 @@
 
 #include <memory>
 #include "FWCore/Framework/interface/Event.h"
-// #include "DataFormats/Common/interface/Handle.h"
 #include "DataFormats/Common/interface/Handle.h"
 #include "FWCore/Framework/interface/EventSetup.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
@@ -41,12 +40,19 @@ class SimProducer;
 class G4SimEvent;
 class SimTrackManager;
 
+class RunAction;
+class EventAction;
+class TrackingAction;
+class SteppingAction;
+
 class DDDWorld;
 
 class G4RunManagerKernel;
 class G4Run;
 class G4Event;
-class G4UserRunAction;
+class RunAction;
+
+class SimRunInterface;
 
 class ExceptionHandler ;
 
@@ -73,6 +79,13 @@ class RunManager
     std::vector<boost::shared_ptr<SimProducer> > producers() const {
        return m_producers;
     }
+
+    SimTrackManager* GetSimTrackManager();
+    void             Connect(RunAction*);
+    void             Connect(EventAction*);
+    void             Connect(TrackingAction*);
+    void             Connect(SteppingAction*);
+
 protected:
     G4Event * generateEvent( edm::Event& inpevt );
 
@@ -88,8 +101,6 @@ class RunManager
     std::auto_ptr<PhysicsList> m_physicsList;
     PrimaryTransformer * m_primaryTransformer;
     bool m_managerInitialized;
-    //    bool m_geometryInitialized;
-    //    bool m_physicsInitialized;
     bool m_runInitialized;
     bool m_runTerminated;
     bool m_runAborted;
@@ -98,12 +109,13 @@ class RunManager
     G4Run * m_currentRun;
     G4Event * m_currentEvent;
     G4SimEvent * m_simEvent;
-    G4UserRunAction * m_userRunAction;
+    RunAction * m_userRunAction;
+    SimRunInterface * m_runInterface;
+
     std::string m_PhysicsTablesDir;
     bool m_StorePhysicsTables;
     bool m_RestorePhysicsTables;
     int m_EvtMgrVerbosity;
-    //bool m_Override;
     bool m_check;
     edm::ParameterSet m_pGeometry;
     edm::ParameterSet m_pField;

diff --git a/SimG4Core/Application/interface/SimRunInterface.h b/SimG4Core/Application/interface/SimRunInterface.h
@@ -0,0 +1,52 @@
+#ifndef SimG4Core_SimRunInterface_h
+#define SimG4Core_SimRunInterface_h 1
+
+// This class is needed to provide an interface
+// between Geant4 user actions and CMS SIM
+// infrastructure both for sequentional and MT runs
+
+
+class RunManager;
+class SimTrackManager;
+class RunAction;
+class EventAction;
+class TrackingAction;
+class SteppingAction;
+class G4SimEvent;
+
+class SimRunInterface
+{
+public:
+
+  SimRunInterface(RunManager* run, bool master);
+
+  ~SimRunInterface();
+
+  void Connect(RunAction*);
+
+  void Connect(EventAction*);
+
+  void Connect(TrackingAction*);
+
+  void Connect(SteppingAction*);
+
+  SimTrackManager* GetSimTrackManager();
+
+  void abortEvent();
+
+  void abortRun(bool softAbort);
+
+  G4SimEvent* simEvent();
+
+private:
+
+  RunManager* m_runManager;
+
+  SimTrackManager* m_SimTrackManager;
+
+  bool  m_isMaster;             
+};
+
+#endif
+
+
diff --git a/SimG4Core/Application/interface/StackingAction.h b/SimG4Core/Application/interface/StackingAction.h
@@ -11,13 +11,12 @@
 #include <string>
 #include <vector>
 
-class EventAction;
 class NewTrackAction;
 
 class StackingAction : public G4UserStackingAction {
 
 public:
-  StackingAction(EventAction* e, const edm::ParameterSet & ps);
+  StackingAction(const edm::ParameterSet & ps);
   virtual ~StackingAction();
 
   virtual G4ClassificationOfNewTrack ClassifyNewTrack(const G4Track * aTrack);
@@ -33,7 +32,7 @@ class StackingAction : public G4UserStackingAction {
   bool   isItLongLived(const G4Track*) const;
 
 private:
-  EventAction                   *eventAction_;
+
   bool                          savePDandCinTracker, savePDandCinCalo;
   bool                          savePDandCinMuon, saveFirstSecondary;
   bool                          killInCalo, killInCaloEfH;

diff --git a/SimG4Core/Application/python/g4SimHits_cfi.py b/SimG4Core/Application/python/g4SimHits_cfi.py
@@ -76,6 +76,7 @@
         delta = cms.double(1.0)
     ),
     Physics = cms.PSet(
+        common_maximum_time,
         # NOTE : if you want EM Physics only,
         #        please select "SimG4Core/Physics/DummyPhysics" for type
         #        and turn ON DummyEMPhysics

diff --git a/SimG4Core/Application/src/ActionInitialization.cc b/SimG4Core/Application/src/ActionInitialization.cc
@@ -0,0 +1,79 @@
+#include "SimG4Core/Generators/interface/Generator.h"
+#include "SimG4Core/Application/interface/RunManager.h"
+#include "SimG4Core/Application/interface/SimRunInterface.h"
+#include "SimG4Core/Application/interface/ActionInitialization.h"
+#include "SimG4Core/Application/interface/RunAction.h"
+#include "SimG4Core/Application/interface/EventAction.h"
+#include "SimG4Core/Application/interface/TrackingAction.h"
+#include "SimG4Core/Application/interface/SteppingAction.h"
+#include "SimG4Core/Application/interface/StackingAction.h"
+#include "SimG4Core/Application/interface/SimTrackManager.h"
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+ActionInitialization::ActionInitialization(const edm::ParameterSet & p, 
+					   RunManager* runm)
+  : G4VUserActionInitialization(),
+    m_runManager(runm),
+    m_pGenerator(p.getParameter<edm::ParameterSet>("Generator")),
+    m_pPhysics(p.getParameter<edm::ParameterSet>("Physics")),
+    m_pRunAction(p.getParameter<edm::ParameterSet>("RunAction")),      
+    m_pEventAction(p.getParameter<edm::ParameterSet>("EventAction")),
+    m_pStackingAction(p.getParameter<edm::ParameterSet>("StackingAction")),
+    m_pTrackingAction(p.getParameter<edm::ParameterSet>("TrackingAction")),
+    m_pSteppingAction(p.getParameter<edm::ParameterSet>("SteppingAction"))
+{}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+ActionInitialization::~ActionInitialization()
+{}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+void ActionInitialization::BuildForMaster() const
+{
+  SimRunInterface* interface = new SimRunInterface(m_runManager, true);
+
+  RunAction* runAction = new RunAction(m_pRunAction, interface);
+  SetUserAction(runAction);
+  interface->Connect(runAction);
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+#include "G4AutoLock.hh"
+namespace { G4Mutex ActionInitializationMutex = G4MUTEX_INITIALIZER; }
+
+void ActionInitialization::Build() const
+{
+  G4AutoLock l(&ActionInitializationMutex);
+
+  SimRunInterface* interface = new SimRunInterface(m_runManager, false);
+
+  //Generator* gen = new Generator(m_pGenerator);
+  //SetUserAction(gen);
+
+  RunAction* runAction = new RunAction(m_pRunAction, interface);
+  SetUserAction(runAction);
+  interface->Connect(runAction);
+
+  EventAction* eventAction = new EventAction(m_pEventAction, interface, 
+					     interface->GetSimTrackManager());
+  SetUserAction(eventAction);
+  interface->Connect(eventAction);
+
+  TrackingAction* trackAction = 
+    new TrackingAction(eventAction, m_pTrackingAction);
+  SetUserAction(trackAction);
+  interface->Connect(trackAction);
+
+  SteppingAction* stepAction = 
+    new SteppingAction(eventAction, m_pSteppingAction);
+  SetUserAction(stepAction);
+  interface->Connect(stepAction);
+
+  SetUserAction(new StackingAction(m_pStackingAction));
+}  
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......