CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
RunManager.cc
Go to the documentation of this file.
9 
19 
22 
26 
31 
33 
35 
38 
39 #include "HepPDT/defs.h"
40 #include "HepPDT/TableBuilder.hh"
41 #include "HepPDT/ParticleDataTable.hh"
43 
44 #include "G4StateManager.hh"
45 #include "G4ApplicationState.hh"
46 #include "G4RunManagerKernel.hh"
47 #include "G4UImanager.hh"
48 
49 #include "G4EventManager.hh"
50 #include "G4Run.hh"
51 #include "G4Event.hh"
52 #include "G4TransportationManager.hh"
53 #include "G4ParticleTable.hh"
54 
55 
56 #include <iostream>
57 #include <sstream>
58 #include <fstream>
59 #include <memory>
60 
62 
64 
65 static
67  SimActivityRegistry& iReg,
68  std::vector<boost::shared_ptr<SimWatcher> >& oWatchers,
69  std::vector<boost::shared_ptr<SimProducer> >& oProds
70  )
71 {
72  using namespace std;
73  using namespace edm;
74  vector<ParameterSet> watchers;
75  try {
76  watchers = iP.getParameter<vector<ParameterSet> >("Watchers");
77  } catch( edm::Exception) {
78  }
79 
80  for(vector<ParameterSet>::iterator itWatcher = watchers.begin();
81  itWatcher != watchers.end();
82  ++itWatcher) {
83  std::auto_ptr<SimWatcherMakerBase> maker(
85  (itWatcher->getParameter<std::string> ("type")) );
86  if(maker.get()==0) {
87  throw SimG4Exception("Unable to find the requested Watcher");
88  }
89 
90  boost::shared_ptr<SimWatcher> watcherTemp;
91  boost::shared_ptr<SimProducer> producerTemp;
92  maker->make(*itWatcher,iReg,watcherTemp,producerTemp);
93  oWatchers.push_back(watcherTemp);
94  if(producerTemp) {
95  oProds.push_back(producerTemp);
96  }
97  }
98 }
99 
100 // RunManager * RunManager::me = 0;
101 /*
102 RunManager * RunManager::init(edm::ParameterSet const & p)
103 {
104  if (me != 0) abort();
105  me = new RunManager(p);
106  return me;
107 }
108 
109 RunManager * RunManager::instance()
110 {
111  if (me==0) abort();
112  return me;
113 }
114 */
115 
117  : m_generator(0), m_nonBeam(p.getParameter<bool>("NonBeamEvent")),
118  m_primaryTransformer(0),
119  m_managerInitialized(false),
120  //m_geometryInitialized(true), m_physicsInitialized(true),
121  m_runInitialized(false), m_runTerminated(false), m_runAborted(false),
122  firstRun(true),
123  m_pUseMagneticField(p.getParameter<bool>("UseMagneticField")),
124  m_currentRun(0), m_currentEvent(0), m_simEvent(0),
125  m_PhysicsTablesDir(p.getParameter<std::string>("PhysicsTablesDirectory")),
126  m_StorePhysicsTables(p.getParameter<bool>("StorePhysicsTables")),
127  m_RestorePhysicsTables(p.getParameter<bool>("RestorePhysicsTables")),
128  m_EvtMgrVerbosity(p.getUntrackedParameter<int>("G4EventManagerVerbosity",0)),
129  m_Override(p.getParameter<bool>("OverrideUserStackingAction")),
130  m_pField(p.getParameter<edm::ParameterSet>("MagneticField")),
131  m_pGenerator(p.getParameter<edm::ParameterSet>("Generator")),
132  m_pPhysics(p.getParameter<edm::ParameterSet>("Physics")),
133  m_pRunAction(p.getParameter<edm::ParameterSet>("RunAction")),
134  m_pEventAction(p.getParameter<edm::ParameterSet>("EventAction")),
135  m_pStackingAction(p.getParameter<edm::ParameterSet>("StackingAction")),
136  m_pTrackingAction(p.getParameter<edm::ParameterSet>("TrackingAction")),
137  m_pSteppingAction(p.getParameter<edm::ParameterSet>("SteppingAction")),
138  m_G4Commands(p.getParameter<std::vector<std::string> >("G4Commands")),
139  m_p(p), m_fieldBuilder(0)
140 
141 {
142  m_kernel = G4RunManagerKernel::GetRunManagerKernel();
143  if (m_kernel==0) m_kernel = new G4RunManagerKernel();
144 
146 
147  m_check = p.getUntrackedParameter<bool>("CheckOverlap",false);
148 
149  //Look for an outside SimActivityRegistry
150  // this is used by the visualization code
151  edm::Service<SimActivityRegistry> otherRegistry;
152  if(otherRegistry){
153  m_registry.connect(*otherRegistry);
154  }
155 
157 }
158 
160 {
161  if (m_kernel!=0) delete m_kernel;
162 }
163 
164 
165 
166 
168 {
169 
170  bool geomChanged = idealGeomRcdWatcher_.check(es);
171  if (geomChanged && (!firstRun)) {
172  throw cms::Exception("BadConfig")
173  << "[SimG4Core RunManager]\n"
174  << "The Geometry configuration is changed during the job execution\n"
175  << "this is not allowed, the geometry must stay unchanged\n";
176  }
177  if (m_pUseMagneticField) {
178  bool magChanged = idealMagRcdWatcher_.check(es);
179  if (magChanged && (!firstRun)) {
180  throw cms::Exception("BadConfig")
181  << "[SimG4Core RunManager]\n"
182  << "The MagneticField configuration is changed during the job execution\n"
183  << "this is not allowed, the MagneticField must stay unchanged\n";
184  }
185  }
186 
187  if (m_managerInitialized) return;
188 
189  // DDDWorld: get the DDCV from the ES and use it to build the World
191  es.get<IdealGeometryRecord>().get(pDD);
192 
194  SensitiveDetectorCatalog catalog_;
195  const DDDWorld * world = new DDDWorld(&(*pDD), map_, catalog_, m_check);
197 
199  {
200  // setup the magnetic field
202  es.get<IdealMagneticFieldRecord>().get(pMF);
203  const GlobalPoint g(0.,0.,0.);
204 
205  // m_fieldBuilder = std::auto_ptr<sim::FieldBuilder>(new sim::FieldBuilder(&(*pMF), map_, m_pField));
206  m_fieldBuilder = (new sim::FieldBuilder(&(*pMF), m_pField));
207  G4TransportationManager * tM = G4TransportationManager::GetTransportationManager();
208  m_fieldBuilder->build( tM->GetFieldManager(),tM->GetPropagatorInField() ) ;
209  // m_fieldBuilder->configure("MagneticFieldType",tM->GetFieldManager(),tM->GetPropagatorInField());
210  }
211 
212  // we need the track manager now
213  m_trackManager = std::auto_ptr<SimTrackManager>(new SimTrackManager);
214 
215  m_attach = new AttachSD;
216  {
217  std::pair< std::vector<SensitiveTkDetector*>,
218  std::vector<SensitiveCaloDetector*> > sensDets = m_attach->create(*world,(*pDD),catalog_,m_p,m_trackManager.get(),m_registry);
219 
220  m_sensTkDets.swap(sensDets.first);
221  m_sensCaloDets.swap(sensDets.second);
222  }
223 
224 
225  edm::LogInfo("SimG4CoreApplication") << " RunManager: Sensitive Detector building finished; found " << m_sensTkDets.size()
226  << " Tk type Producers, and " << m_sensCaloDets.size() << " Calo type producers ";
227 
229  es.get<PDTRecord>().get(fTable);
230  const HepPDT::ParticleDataTable *fPDGTable = &(*fTable);
231 
233  // m_InTag = m_pGenerator.getParameter<edm::InputTag>("HepMCProductLabel") ;
234  m_InTag = m_pGenerator.getParameter<std::string>("HepMCProductLabel") ;
236 
237  std::auto_ptr<PhysicsListMakerBase> physicsMaker(
239  (m_pPhysics.getParameter<std::string> ("type")));
240  if (physicsMaker.get()==0) throw SimG4Exception("Unable to find the Physics list requested");
241  m_physicsList = physicsMaker->make(map_,fPDGTable,m_fieldBuilder,m_pPhysics,m_registry);
242  if (m_physicsList.get()==0) throw SimG4Exception("Physics list construction failed!");
243  m_kernel->SetPhysics(m_physicsList.get());
244  m_kernel->InitializePhysics();
245 
246  m_physicsList->ResetStoredInAscii();
247  std::string tableDir = m_PhysicsTablesDir;
248  if (m_RestorePhysicsTables) m_physicsList->SetPhysicsTableRetrieved(tableDir);
249 
250  if (m_kernel->RunInitialization()) m_managerInitialized = true;
251  else throw SimG4Exception("G4RunManagerKernel initialization failed!");
252 
254  {
255  std::ostringstream dir;
256  dir << tableDir << '\0';
257  std::string cmd = std::string("/control/shell mkdir -p ")+tableDir;
258  if (!std::ifstream(dir.str().c_str(), std::ios::in))
259  G4UImanager::GetUIpointer()->ApplyCommand(cmd);
260  m_physicsList->StorePhysicsTable(tableDir);
261  }
262 
263  //tell all interesting parties that we are beginning the job
264  BeginOfJob aBeginOfJob(&es);
265  m_registry.beginOfJobSignal_(&aBeginOfJob);
266 
268 
269  for (unsigned it=0; it<m_G4Commands.size(); it++) {
270  edm::LogInfo("SimG4CoreApplication") << "RunManager:: Requests UI: "
271  << m_G4Commands[it];
272  G4UImanager::GetUIpointer()->ApplyCommand(m_G4Commands[it]);
273  }
274 
275  // If the Geant4 particle table is needed, decomment the lines below
276  //
277  // G4cout << "Output of G4ParticleTable DumpTable:" << G4endl;
278  // G4ParticleTable::GetParticleTable()->DumpTable("ALL");
279 
280  initializeRun();
281  firstRun= false;
282 
283 }
284 
286 {
287  m_currentEvent = generateEvent(inpevt);
288  m_simEvent = new G4SimEvent;
291  if (m_generator->genVertex()!=0)
293  m_generator->genVertex()->y()/centimeter,
294  m_generator->genVertex()->z()/centimeter,
295  m_generator->genVertex()->t()/second));
296 
297  if (m_currentEvent->GetNumberOfPrimaryVertex()==0)
298  {
299 
300  edm::LogError("SimG4CoreApplication")
301  << " RunManager::produce event " << inpevt.id().event()
302  << " with no G4PrimaryVertices \n Aborting Run" ;
303 
304  abortRun(false);
305  }
306  else
307  m_kernel->GetEventManager()->ProcessOneEvent(m_currentEvent);
308 
309 
310  edm::LogInfo("SimG4CoreApplication")
311  << " RunManager: saved : Event " << inpevt.id().event() << " of weight " << m_simEvent->weight()
312  << " with " << m_simEvent->nTracks() << " tracks and " << m_simEvent->nVertices()
313  << " vertices, generated by " << m_simEvent->nGenParts() << " particles " ;
314 
315 }
316 
318 {
319 
320  if (m_currentEvent!=0) delete m_currentEvent;
321  m_currentEvent = 0;
322  if (m_simEvent!=0) delete m_simEvent;
323  m_simEvent = 0;
324  G4Event * e = new G4Event(inpevt.id().event());
325 
326  // std::vector< edm::Handle<edm::HepMCProduct> > AllHepMCEvt;
328 
329  // inpevt.getByType(HepMCEvt);
330  // inpevt.getManyByType(AllHepMCEvt);
331  inpevt.getByLabel( m_InTag, HepMCEvt ) ;
332 
333  // actually, it's a double protection - it's not even necessary
334  // because getByLabel will throw if the correct product isn't there
335  if (!HepMCEvt.isValid())
336  {
337  throw SimG4Exception("Unable to find HepMCProduct(HepMC::GenEvent) in edm::Event ");
338  }
339  else
340  {
341  m_generator->setGenEvent(HepMCEvt->GetEvent());
342 
343  // required to reset the GenParticle Id for particles transported along the beam pipe
344  // to their original value for SimTrack creation
345  resetGenParticleId( inpevt );
346 
347  if (!m_nonBeam)
348  {
349  m_generator->HepMC2G4(HepMCEvt->GetEvent(),e);
350  }
351  else
352  {
353  m_generator->nonBeamEvent2G4(HepMCEvt->GetEvent(),e);
354  }
355  }
356 
357  return e;
358 
359 }
360 
362 {
363 
364  G4Track* t =
365  m_kernel->GetEventManager()->GetTrackingManager()->GetTrack();
366  t->SetTrackStatus(fStopAndKill) ;
367 
368  // CMS-specific act
369  //
370  TrackingAction* uta =
371  (TrackingAction*)m_kernel->GetEventManager()->GetUserTrackingAction() ;
372  uta->PostUserTrackingAction(t) ;
373 
374  m_currentEvent->SetEventAborted();
375 
376  // do NOT call this method for now
377  // because it'll set abortRequested=true (withing G4EventManager)
378  // this will make Geant4, in the event *next* after the aborted one
379  // NOT to get the primamry, thus there's NOTHING to trace, and it goes
380  // to the end of G4Event::DoProcessing(G4Event*), where abortRequested
381  // will be reset to true again
382  //
383  //m_kernel->GetEventManager()->AbortCurrentEvent();
384  //
385  // instead, mimic what it does, except (re)setting abortRequested
386  //
387  m_kernel->GetEventManager()->GetStackManager()->clear() ;
388  m_kernel->GetEventManager()->GetTrackingManager()->EventAborted() ;
389 
390  G4StateManager* stateManager = G4StateManager::GetStateManager();
391  stateManager->SetNewState(G4State_GeomClosed);
392 
393  return ;
394 
395 }
396 
398 {
399 
400  RunAction* userRunAction = new RunAction(m_pRunAction,this);
401  m_userRunAction = userRunAction;
404 
405  G4EventManager * eventManager = m_kernel->GetEventManager();
406  eventManager->SetVerboseLevel(m_EvtMgrVerbosity);
407  if (m_generator!=0)
408  {
409  EventAction * userEventAction = new EventAction(m_pEventAction,this,m_trackManager.get());
410  //userEventAction->SetRunManager(this) ;
413  eventManager->SetUserAction(userEventAction);
414  TrackingAction* userTrackingAction = new TrackingAction(userEventAction,m_pTrackingAction);
417  eventManager->SetUserAction(userTrackingAction);
418 
419  SteppingAction* userSteppingAction = new SteppingAction(userEventAction,m_pSteppingAction);
420  userSteppingAction->m_g4StepSignal.connect(m_registry.g4StepSignal_);
421  eventManager->SetUserAction(userSteppingAction);
422  if (m_Override)
423  {
424  edm::LogInfo("SimG4CoreApplication") << " RunManager: user StackingAction overridden " ;
425  eventManager->SetUserAction(new StackingAction(m_pStackingAction));
426  }
427  }
428  else
429  {
430  edm::LogWarning("SimG4CoreApplication") << " RunManager: WARNING : No generator; initialized only RunAction!";
431  }
432 
433  return;
434 
435 }
436 
438 {
439 
440  m_runInitialized = false;
441  if (m_currentRun==0) m_currentRun = new G4Run();
442  // m_currentRun->SetRunID(m_RunNumber); // run on default runID=0; doesn't matter...
443  G4StateManager::GetStateManager()->SetNewState(G4State_GeomClosed);
444  if (m_userRunAction!=0) m_userRunAction->BeginOfRunAction(m_currentRun);
445  m_runAborted = false;
446  m_runInitialized = true;
447 
448  return ;
449 
450 }
451 
453 {
454 
455  m_runTerminated = false;
456  if (m_userRunAction!=0)
457  {
458  m_userRunAction->EndOfRunAction(m_currentRun);
459  delete m_userRunAction; m_userRunAction = 0;
460  }
461  if (m_currentRun!=0) { delete m_currentRun; m_currentRun = 0; }
462  if (m_kernel!=0) m_kernel->RunTermination();
463  m_runInitialized = false;
464  m_runTerminated = true;
465 
466  return;
467 
468 }
469 
470 void RunManager::abortRun(bool softAbort)
471 {
472 
473  m_runAborted = false;
474  if (!softAbort) abortEvent();
475  if (m_currentRun!=0) { delete m_currentRun; m_currentRun = 0; }
476  m_runInitialized = false;
477  m_runAborted = true;
478 
479  return;
480 
481 }
482 
484 
486  inpevt.getByType( theLHCTlink );
487  if ( theLHCTlink.isValid() ) {
488  m_trackManager->setLHCTransportLink( theLHCTlink.product() );
489  }
490 
491 }
T getParameter(std::string const &) const
bool m_check
Definition: RunManager.h:111
EventNumber_t event() const
Definition: EventID.h:44
edm::ParameterSet m_pGenerator
Definition: RunManager.h:114
T getUntrackedParameter(std::string const &, T const &) const
std::auto_ptr< SimTrackManager > m_trackManager
Definition: RunManager.h:134
std::pair< std::vector< SensitiveTkDetector * >, std::vector< SensitiveCaloDetector * > > create(const DDDWorld &w, const DDCompactView &cpv, SensitiveDetectorCatalog &clg, edm::ParameterSet const &p, const SimTrackManager *m, SimActivityRegistry &reg) const
Definition: AttachSD.cc:23
virtual const math::XYZTLorentzVector * genVertex() const
Definition: Generator.h:31
edm::ESWatcher< IdealMagneticFieldRecord > idealMagRcdWatcher_
Definition: RunManager.h:138
G4UserRunAction * m_userRunAction
Definition: RunManager.h:105
virtual const double eventWeight() const
Definition: Generator.h:32
ROOT::Math::LorentzVector< ROOT::Math::PxPyPzE4D< double > > XYZTLorentzVectorD
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:15
G4Event * m_currentEvent
Definition: RunManager.h:103
void abortRun(bool softAbort=false)
Definition: RunManager.cc:470
SimActivityRegistry m_registry
Definition: RunManager.h:130
virtual const HepMC::GenEvent * genEvent() const
Definition: Generator.h:30
edm::ParameterSet m_p
Definition: RunManager.h:123
SimActivityRegistry::G4StepSignal m_g4StepSignal
HepPDT::ParticleDataTable ParticleDataTable
void initializeRun()
Definition: RunManager.cc:437
void HepMC2G4(const HepMC::GenEvent *g, G4Event *e)
Definition: Generator.cc:58
EndOfEventSignal endOfEventSignal_
void initializeUserActions()
Definition: RunManager.cc:397
SimActivityRegistry::EndOfRunSignal m_endOfRunSignal
Definition: RunAction.h:23
Generator * m_generator
Definition: RunManager.h:87
void build(G4FieldManager *fM=0, G4PropagatorInField *fP=0)
Definition: FieldBuilder.cc:49
BeginOfRunSignal beginOfRunSignal_
string firstRun
Definition: dataset.py:395
bool getByType(Handle< PROD > &result) const
Definition: Event.h:398
SimActivityRegistry::EndOfEventSignal m_endOfEventSignal
Definition: EventAction.h:44
bool m_pUseMagneticField
Definition: RunManager.h:101
edm::ESWatcher< IdealGeometryRecord > idealGeomRcdWatcher_
Definition: RunManager.h:137
ExceptionHandler * m_CustomExceptionHandler
Definition: RunManager.h:124
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e g
Definition: Activities.doc:4
void abortEvent()
Definition: RunManager.cc:361
std::vector< SensitiveCaloDetector * > m_sensCaloDets
Definition: RunManager.h:128
std::vector< SensitiveTkDetector * > m_sensTkDets
Definition: RunManager.h:127
BeginOfJobSignal beginOfJobSignal_
bool m_nonBeam
Definition: RunManager.h:91
U second(std::pair< T, U > const &p)
void weight(float w)
Definition: G4SimEvent.h:27
bool m_Override
Definition: RunManager.h:110
int m_EvtMgrVerbosity
Definition: RunManager.h:109
std::auto_ptr< PhysicsList > m_physicsList
Definition: RunManager.h:92
bool firstRun
Definition: RunManager.h:100
void terminateRun()
Definition: RunManager.cc:452
edm::serviceregistry::AllArgsMaker< DTDataMonitorInterface, DTDataIntegrityTask > maker
Definition: plugins.cc:73
void collisionPoint(math::XYZTLorentzVectorD v)
Definition: G4SimEvent.h:29
string cmd
Definition: asciidump.py:19
virtual ~RunManager()
Definition: RunManager.cc:159
bool m_RestorePhysicsTables
Definition: RunManager.h:108
void hepEvent(const HepMC::GenEvent *r)
Definition: G4SimEvent.h:25
void setGenEvent(const HepMC::GenEvent *inpevt)
Definition: Generator.h:27
BeginOfEventSignal beginOfEventSignal_
SimActivityRegistry::EndOfTrackSignal m_endOfTrackSignal
bool isValid() const
Definition: HandleBase.h:76
G4Run * m_currentRun
Definition: RunManager.h:102
void resetGenParticleId(edm::Event &inpevt)
Definition: RunManager.cc:483
EndOfRunSignal endOfRunSignal_
bool getByLabel(InputTag const &tag, Handle< PROD > &result) const
Definition: Event.h:356
edm::ParameterSet m_pStackingAction
Definition: RunManager.h:119
unsigned int nTracks() const
Definition: G4SimEvent.h:22
void connect(Observer< const T * > *iObs)
does not take ownership of memory
Definition: Signaler.h:60
edm::ParameterSet m_pEventAction
Definition: RunManager.h:118
bool m_runTerminated
Definition: RunManager.h:98
unsigned int nVertices() const
Definition: G4SimEvent.h:23
edm::ParameterSet m_pField
Definition: RunManager.h:113
edm::ParameterSet m_pPhysics
Definition: RunManager.h:116
edm::ParameterSet m_pSteppingAction
Definition: RunManager.h:121
virtual void PostUserTrackingAction(const G4Track *aTrack)
unsigned int nGenParts() const
Definition: G4SimEvent.h:24
DDDWorldSignal dddWorldSignal_
const T & get() const
Definition: EventSetup.h:55
T const * product() const
Definition: Handle.h:74
void nonBeamEvent2G4(const HepMC::GenEvent *g, G4Event *e)
Definition: Generator.cc:368
bool check(const edm::EventSetup &iSetup)
Definition: ESWatcher.h:59
std::string m_InTag
Definition: RunManager.h:89
G4Event * generateEvent(edm::Event &inpevt)
Definition: RunManager.cc:317
bool m_runInitialized
Definition: RunManager.h:97
SimActivityRegistry::BeginOfRunSignal m_beginOfRunSignal
Definition: RunAction.h:22
edm::EventID id() const
Definition: EventBase.h:56
static void createWatchers(const edm::ParameterSet &iP, SimActivityRegistry &iReg, std::vector< boost::shared_ptr< SimWatcher > > &oWatchers, std::vector< boost::shared_ptr< SimProducer > > &oProds)
Definition: RunManager.cc:66
AttachSD * m_attach
Definition: RunManager.h:126
PrimaryTransformer * m_primaryTransformer
Definition: RunManager.h:93
sim::FieldBuilder * m_fieldBuilder
Definition: RunManager.h:135
std::string m_PhysicsTablesDir
Definition: RunManager.h:106
bool m_StorePhysicsTables
Definition: RunManager.h:107
void connect(SimActivityRegistry &iOther)
forwards our signals to slots connected to iOther
dbl *** dir
Definition: mlp_gen.cc:35
EndOfTrackSignal endOfTrackSignal_
std::vector< boost::shared_ptr< SimProducer > > m_producers
Definition: RunManager.h:132
std::vector< boost::shared_ptr< SimWatcher > > m_watchers
Definition: RunManager.h:131
edm::ParameterSet m_pRunAction
Definition: RunManager.h:117
RunManager(edm::ParameterSet const &p)
Definition: RunManager.cc:116
edm::ParameterSet m_pTrackingAction
Definition: RunManager.h:120
std::vector< std::string > m_G4Commands
Definition: RunManager.h:122
SurfaceDeformation * create(int type, const std::vector< double > &params)
SimActivityRegistry::BeginOfEventSignal m_beginOfEventSignal
Definition: EventAction.h:43
G4SimEvent * m_simEvent
Definition: RunManager.h:104
bool m_managerInitialized
Definition: RunManager.h:94
void initG4(const edm::EventSetup &es)
Definition: RunManager.cc:167
T get(const Candidate &c)
Definition: component.h:56
BeginOfTrackSignal beginOfTrackSignal_
G4RunManagerKernel * m_kernel
Definition: RunManager.h:85
bool m_runAborted
Definition: RunManager.h:99
void produce(edm::Event &inpevt, const edm::EventSetup &es)
Definition: RunManager.cc:285
SimActivityRegistry::BeginOfTrackSignal m_beginOfTrackSignal