CMS 3D CMS Logo

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Public Member Functions | Protected Member Functions | Private Attributes
RunManager Class Reference

#include <RunManager.h>

Inheritance diagram for RunManager:
RunManagerMT

Public Member Functions

void abortEvent ()
 
void abortRun (bool softAbort=false)
 
void Connect (RunAction *)
 
void Connect (EventAction *)
 
void Connect (TrackingAction *)
 
void Connect (SteppingAction *)
 
const G4Event * currentEvent () const
 
const G4Run * currentRun () const
 
const Generatorgenerator () const
 
SimTrackManagerGetSimTrackManager ()
 
void initG4 (const edm::EventSetup &es)
 
void initializeRun ()
 
void initializeUserActions ()
 
void produce (edm::Event &inpevt, const edm::EventSetup &es)
 
std::vector< boost::shared_ptr
< SimProducer > > 
producers () const
 
 RunManager (edm::ParameterSet const &p)
 
std::vector
< SensitiveCaloDetector * > & 
sensCaloDetectors ()
 
std::vector
< SensitiveTkDetector * > & 
sensTkDetectors ()
 
G4SimEventsimEvent ()
 
void stopG4 ()
 
void terminateRun ()
 
 ~RunManager ()
 

Protected Member Functions

void DumpMagneticField (const G4Field *) const
 
G4Event * generateEvent (edm::Event &inpevt)
 
void resetGenParticleId (edm::Event &inpevt)
 

Private Attributes

bool firstRun
 
edm::ESWatcher
< IdealGeometryRecord
idealGeomRcdWatcher_
 
edm::ESWatcher
< IdealMagneticFieldRecord
idealMagRcdWatcher_
 
AttachSDm_attach
 
bool m_check
 
G4Event * m_currentEvent
 
G4Run * m_currentRun
 
ExceptionHandlerm_CustomExceptionHandler
 
int m_EvtMgrVerbosity
 
sim::FieldBuilderm_fieldBuilder
 
std::string m_FieldFile
 
std::vector< std::string > m_G4Commands
 
Generatorm_generator
 
std::string m_InTag
 
G4RunManagerKernel * m_kernel
 
bool m_managerInitialized
 
bool m_nonBeam
 
edm::ParameterSet m_p
 
edm::ParameterSet m_pEventAction
 
edm::ParameterSet m_pField
 
edm::ParameterSet m_pGenerator
 
edm::ParameterSet m_pGeometry
 
std::auto_ptr< PhysicsListm_physicsList
 
std::string m_PhysicsTablesDir
 
edm::ParameterSet m_pPhysics
 
PrimaryTransformerm_primaryTransformer
 
std::vector< boost::shared_ptr
< SimProducer > > 
m_producers
 
edm::ParameterSet m_pRunAction
 
edm::ParameterSet m_pStackingAction
 
edm::ParameterSet m_pSteppingAction
 
edm::ParameterSet m_pTrackingAction
 
bool m_pUseMagneticField
 
edm::ParameterSet m_pVertexGenerator
 
SimActivityRegistry m_registry
 
bool m_RestorePhysicsTables
 
bool m_runAborted
 
bool m_runInitialized
 
SimRunInterfacem_runInterface
 
bool m_runTerminated
 
std::vector
< SensitiveCaloDetector * > 
m_sensCaloDets
 
std::vector
< SensitiveTkDetector * > 
m_sensTkDets
 
G4SimEventm_simEvent
 
bool m_StorePhysicsTables
 
edm::InputTag m_theLHCTlinkTag
 
std::auto_ptr< SimTrackManagerm_trackManager
 
RunActionm_userRunAction
 
std::vector< boost::shared_ptr
< SimWatcher > > 
m_watchers
 
std::string m_WriteFile
 

Detailed Description

Definition at line 60 of file RunManager.h.

Constructor & Destructor Documentation

RunManager::RunManager ( edm::ParameterSet const &  p)

Definition at line 110 of file RunManager.cc.

References SimActivityRegistry::connect(), createWatchers(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), m_check, m_CustomExceptionHandler, m_FieldFile, m_generator, m_InTag, m_kernel, m_p, m_pGenerator, m_producers, m_registry, m_runInterface, m_userRunAction, m_watchers, m_WriteFile, and AlCaHLTBitMon_QueryRunRegistry::string.

111  : m_generator(0), m_nonBeam(p.getParameter<bool>("NonBeamEvent")),
113  m_managerInitialized(false),
114  m_runInitialized(false), m_runTerminated(false), m_runAborted(false),
115  firstRun(true),
116  m_pUseMagneticField(p.getParameter<bool>("UseMagneticField")),
118  m_PhysicsTablesDir(p.getParameter<std::string>("PhysicsTablesDirectory")),
119  m_StorePhysicsTables(p.getParameter<bool>("StorePhysicsTables")),
120  m_RestorePhysicsTables(p.getParameter<bool>("RestorePhysicsTables")),
121  m_EvtMgrVerbosity(p.getUntrackedParameter<int>("G4EventManagerVerbosity",0)),
122  m_pField(p.getParameter<edm::ParameterSet>("MagneticField")),
123  m_pGenerator(p.getParameter<edm::ParameterSet>("Generator")),
124  m_pPhysics(p.getParameter<edm::ParameterSet>("Physics")),
125  m_pRunAction(p.getParameter<edm::ParameterSet>("RunAction")),
126  m_pEventAction(p.getParameter<edm::ParameterSet>("EventAction")),
127  m_pStackingAction(p.getParameter<edm::ParameterSet>("StackingAction")),
128  m_pTrackingAction(p.getParameter<edm::ParameterSet>("TrackingAction")),
129  m_pSteppingAction(p.getParameter<edm::ParameterSet>("SteppingAction")),
130  m_G4Commands(p.getParameter<std::vector<std::string> >("G4Commands")),
131  m_p(p), m_fieldBuilder(0),
132  m_theLHCTlinkTag(p.getParameter<edm::InputTag>("theLHCTlinkTag"))
133 {
134  //m_HepMC = iC.consumes<edm::HepMCProduct>(p.getParameter<edm::InputTag>("HepMCProduct"));
135 
136  m_kernel = G4RunManagerKernel::GetRunManagerKernel();
137  if (m_kernel==0) m_kernel = new G4RunManagerKernel();
138 
140 
141  m_check = p.getUntrackedParameter<bool>("CheckOverlap",false);
142  m_WriteFile = p.getUntrackedParameter<std::string>("FileNameGDML","");
143  m_FieldFile = p.getUntrackedParameter<std::string>("FileNameField","");
144  if("" != m_FieldFile) { m_FieldFile += ".txt"; }
145 
146  m_userRunAction = 0;
147  m_runInterface = 0;
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 
159  m_InTag = m_pGenerator.getParameter<std::string>("HepMCProductLabel") ;
160 
161 }
T getParameter(std::string const &) const
bool m_check
Definition: RunManager.h:131
edm::ParameterSet m_pGenerator
Definition: RunManager.h:134
G4Event * m_currentEvent
Definition: RunManager.h:120
SimActivityRegistry m_registry
Definition: RunManager.h:150
edm::ParameterSet m_p
Definition: RunManager.h:143
Generator * m_generator
Definition: RunManager.h:107
bool m_pUseMagneticField
Definition: RunManager.h:118
ExceptionHandler * m_CustomExceptionHandler
Definition: RunManager.h:144
bool m_nonBeam
Definition: RunManager.h:110
int m_EvtMgrVerbosity
Definition: RunManager.h:130
std::string m_WriteFile
Definition: RunManager.h:163
bool firstRun
Definition: RunManager.h:117
SimRunInterface * m_runInterface
Definition: RunManager.h:123
bool m_RestorePhysicsTables
Definition: RunManager.h:129
G4Run * m_currentRun
Definition: RunManager.h:119
edm::ParameterSet m_pStackingAction
Definition: RunManager.h:139
edm::ParameterSet m_pEventAction
Definition: RunManager.h:138
bool m_runTerminated
Definition: RunManager.h:115
edm::ParameterSet m_pField
Definition: RunManager.h:133
edm::ParameterSet m_pPhysics
Definition: RunManager.h:136
edm::ParameterSet m_pSteppingAction
Definition: RunManager.h:141
RunAction * m_userRunAction
Definition: RunManager.h:122
std::string m_InTag
Definition: RunManager.h:108
bool m_runInitialized
Definition: RunManager.h:114
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:75
PrimaryTransformer * m_primaryTransformer
Definition: RunManager.h:112
sim::FieldBuilder * m_fieldBuilder
Definition: RunManager.h:155
std::string m_PhysicsTablesDir
Definition: RunManager.h:127
bool m_StorePhysicsTables
Definition: RunManager.h:128
void connect(SimActivityRegistry &iOther)
forwards our signals to slots connected to iOther
std::vector< boost::shared_ptr< SimProducer > > m_producers
Definition: RunManager.h:152
std::vector< boost::shared_ptr< SimWatcher > > m_watchers
Definition: RunManager.h:151
edm::ParameterSet m_pRunAction
Definition: RunManager.h:137
edm::ParameterSet m_pTrackingAction
Definition: RunManager.h:140
std::vector< std::string > m_G4Commands
Definition: RunManager.h:142
std::string m_FieldFile
Definition: RunManager.h:162
G4SimEvent * m_simEvent
Definition: RunManager.h:121
bool m_managerInitialized
Definition: RunManager.h:113
edm::InputTag m_theLHCTlinkTag
Definition: RunManager.h:160
G4RunManagerKernel * m_kernel
Definition: RunManager.h:105
bool m_runAborted
Definition: RunManager.h:116
RunManager::~RunManager ( )

Definition at line 163 of file RunManager.cc.

References m_runInterface, m_runTerminated, and terminateRun().

164 {
165  if (!m_runTerminated) { terminateRun(); }
166  G4StateManager::GetStateManager()->SetNewState(G4State_Quit);
167  G4GeometryManager::GetInstance()->OpenGeometry();
168  // if (m_kernel!=0) delete m_kernel;
169  delete m_runInterface;
170 }
SimRunInterface * m_runInterface
Definition: RunManager.h:123
void terminateRun()
Definition: RunManager.cc:460
bool m_runTerminated
Definition: RunManager.h:115

Member Function Documentation

void RunManager::abortEvent ( )

Definition at line 382 of file RunManager.cc.

References m_currentEvent, m_kernel, m_runTerminated, TrackingAction::PostUserTrackingAction(), and edmStreamStallGrapher::t.

Referenced by SimRunInterface::abortEvent(), and abortRun().

383 {
384  if (m_runTerminated) { return; }
385  G4Track* t =
386  m_kernel->GetEventManager()->GetTrackingManager()->GetTrack();
387  t->SetTrackStatus(fStopAndKill) ;
388 
389  // CMS-specific act
390  //
391  TrackingAction* uta =
392  (TrackingAction*)m_kernel->GetEventManager()->GetUserTrackingAction() ;
393  uta->PostUserTrackingAction(t) ;
394 
395  m_currentEvent->SetEventAborted();
396 
397  // do NOT call this method for now
398  // because it'll set abortRequested=true (withing G4EventManager)
399  // this will make Geant4, in the event *next* after the aborted one
400  // NOT to get the primary, thus there's NOTHING to trace, and it goes
401  // to the end of G4Event::DoProcessing(G4Event*), where abortRequested
402  // will be reset to true again
403  //
404  //m_kernel->GetEventManager()->AbortCurrentEvent();
405  //
406  // instead, mimic what it does, except (re)setting abortRequested
407  //
408  m_kernel->GetEventManager()->GetStackManager()->clear() ;
409  m_kernel->GetEventManager()->GetTrackingManager()->EventAborted() ;
410 
411  G4StateManager* stateManager = G4StateManager::GetStateManager();
412  stateManager->SetNewState(G4State_GeomClosed);
413 }
G4Event * m_currentEvent
Definition: RunManager.h:120
bool m_runTerminated
Definition: RunManager.h:115
virtual void PostUserTrackingAction(const G4Track *aTrack)
G4RunManagerKernel * m_kernel
Definition: RunManager.h:105
void RunManager::abortRun ( bool  softAbort = false)

Definition at line 484 of file RunManager.cc.

References abortEvent(), m_currentRun, m_runAborted, m_runInitialized, and terminateRun().

Referenced by SimRunInterface::abortRun(), ExceptionHandler::Notify(), and produce().

485 {
486  m_runAborted = false;
487  if (!softAbort) { abortEvent(); }
488  if (m_currentRun!=0) { delete m_currentRun; m_currentRun = 0; }
489  m_runInitialized = false;
490  m_runAborted = true;
491  terminateRun();
492 }
void abortEvent()
Definition: RunManager.cc:382
void terminateRun()
Definition: RunManager.cc:460
G4Run * m_currentRun
Definition: RunManager.h:119
bool m_runInitialized
Definition: RunManager.h:114
bool m_runAborted
Definition: RunManager.h:116
void RunManager::Connect ( RunAction runAction)

Definition at line 508 of file RunManager.cc.

References SimActivityRegistry::beginOfRunSignal_, sim_act::Signaler< T >::connect(), SimActivityRegistry::endOfRunSignal_, RunAction::m_beginOfRunSignal, RunAction::m_endOfRunSignal, and m_registry.

Referenced by SimRunInterface::Connect(), and initializeUserActions().

509 {
512 }
SimActivityRegistry m_registry
Definition: RunManager.h:150
SimActivityRegistry::EndOfRunSignal m_endOfRunSignal
Definition: RunAction.h:23
BeginOfRunSignal beginOfRunSignal_
EndOfRunSignal endOfRunSignal_
void connect(Observer< const T * > *iObs)
does not take ownership of memory
Definition: Signaler.h:59
SimActivityRegistry::BeginOfRunSignal m_beginOfRunSignal
Definition: RunAction.h:22
void RunManager::Connect ( EventAction eventAction)

Definition at line 514 of file RunManager.cc.

References SimActivityRegistry::beginOfEventSignal_, sim_act::Signaler< T >::connect(), SimActivityRegistry::endOfEventSignal_, EventAction::m_beginOfEventSignal, EventAction::m_endOfEventSignal, and m_registry.

515 {
518 }
SimActivityRegistry m_registry
Definition: RunManager.h:150
EndOfEventSignal endOfEventSignal_
SimActivityRegistry::EndOfEventSignal m_endOfEventSignal
Definition: EventAction.h:46
BeginOfEventSignal beginOfEventSignal_
void connect(Observer< const T * > *iObs)
does not take ownership of memory
Definition: Signaler.h:59
SimActivityRegistry::BeginOfEventSignal m_beginOfEventSignal
Definition: EventAction.h:45
void RunManager::Connect ( TrackingAction trackingAction)

Definition at line 520 of file RunManager.cc.

References SimActivityRegistry::beginOfTrackSignal_, sim_act::Signaler< T >::connect(), SimActivityRegistry::endOfTrackSignal_, TrackingAction::m_beginOfTrackSignal, TrackingAction::m_endOfTrackSignal, and m_registry.

521 {
524 }
SimActivityRegistry m_registry
Definition: RunManager.h:150
SimActivityRegistry::EndOfTrackSignal m_endOfTrackSignal
void connect(Observer< const T * > *iObs)
does not take ownership of memory
Definition: Signaler.h:59
EndOfTrackSignal endOfTrackSignal_
BeginOfTrackSignal beginOfTrackSignal_
SimActivityRegistry::BeginOfTrackSignal m_beginOfTrackSignal
void RunManager::Connect ( SteppingAction steppingAction)

Definition at line 526 of file RunManager.cc.

References sim_act::Signaler< T >::connect(), SimActivityRegistry::g4StepSignal_, SteppingAction::m_g4StepSignal, and m_registry.

527 {
529 }
SimActivityRegistry m_registry
Definition: RunManager.h:150
SimActivityRegistry::G4StepSignal m_g4StepSignal
void connect(Observer< const T * > *iObs)
does not take ownership of memory
Definition: Signaler.h:59
const G4Event* RunManager::currentEvent ( ) const
inline

Definition at line 79 of file RunManager.h.

References m_currentEvent.

79 { return m_currentEvent; }
G4Event * m_currentEvent
Definition: RunManager.h:120
const G4Run* RunManager::currentRun ( ) const
inline

Definition at line 75 of file RunManager.h.

References m_currentRun.

75 { return m_currentRun; }
G4Run * m_currentRun
Definition: RunManager.h:119
void RunManager::DumpMagneticField ( const G4Field *  field) const
protected

Definition at line 531 of file RunManager.cc.

References funct::cos(), groupFilesInBlocks::fout, i, j, m_FieldFile, dbtoconf::out, phi, point, alignCSCRings::r, funct::sin(), detailsBasic3DVector::z, and SiStripMonitorClusterAlca_cfi::zmax.

Referenced by initG4().

532 {
533  std::ofstream fout(m_FieldFile.c_str(), std::ios::out);
534  if(fout.fail()){
535  edm::LogWarning("SimG4CoreApplication")
536  << " RunManager WARNING : "
537  << "error opening file <" << m_FieldFile << "> for magnetic field";
538  } else {
539  double rmax = 9000*mm;
540  double zmax = 16000*mm;
541 
542  double dr = 5*cm;
543  double dz = 20*cm;
544 
545  int nr = (int)(rmax/dr);
546  int nz = 2*(int)(zmax/dz);
547 
548  double r = 0.0;
549  double z0 = -zmax;
550  double z;
551 
552  double phi = 0.0;
553  double cosf = cos(phi);
554  double sinf = sin(phi);
555 
556  double point[4] = {0.0,0.0,0.0,0.0};
557  double bfield[3] = {0.0,0.0,0.0};
558 
559  fout << std::setprecision(6);
560  for(int i=0; i<=nr; ++i) {
561  z = z0;
562  for(int j=0; j<=nz; ++j) {
563  point[0] = r*cosf;
564  point[1] = r*sinf;
565  point[2] = z;
566  field->GetFieldValue(point, bfield);
567  fout << "R(mm)= " << r/mm << " phi(deg)= " << phi/degree
568  << " Z(mm)= " << z/mm << " Bz(tesla)= " << bfield[2]/tesla
569  << " Br(tesla)= " << (bfield[0]*cosf + bfield[1]*sinf)/tesla
570  << " Bphi(tesla)= " << (bfield[0]*sinf - bfield[1]*cosf)/tesla
571  << G4endl;
572  z += dz;
573  }
574  r += dr;
575  }
576 
577  fout.close();
578  }
579 }
int i
Definition: DBlmapReader.cc:9
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
float float float z
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
int j
Definition: DBlmapReader.cc:9
tuple out
Definition: dbtoconf.py:99
std::string m_FieldFile
Definition: RunManager.h:162
*vegas h *****************************************************used in the default bin number in original ***version of VEGAS is ***a higher bin number might help to derive a more precise ***grade subtle point
Definition: invegas.h:5
Definition: DDAxes.h:10
G4Event * RunManager::generateEvent ( edm::Event inpevt)
protected

Definition at line 351 of file RunManager.cc.

References edm::EventID::event(), edm::Event::getByLabel(), Generator::HepMC2G4(), edm::EventBase::id(), m_currentEvent, m_generator, m_InTag, m_nonBeam, m_simEvent, Generator::nonBeamEvent2G4(), resetGenParticleId(), and Generator::setGenEvent().

Referenced by produce().

352 {
353  if (m_currentEvent!=0) { delete m_currentEvent; }
354  m_currentEvent = 0;
355  if (m_simEvent!=0) { delete m_simEvent; }
356  m_simEvent = 0;
357  G4Event * evt = new G4Event(inpevt.id().event());
358 
360 
361  inpevt.getByLabel( m_InTag, HepMCEvt ) ;
362 
363  m_generator->setGenEvent(HepMCEvt->GetEvent());
364 
365  // required to reset the GenParticle Id for particles transported
366  // along the beam pipe
367  // to their original value for SimTrack creation
368  resetGenParticleId( inpevt );
369 
370  if (!m_nonBeam)
371  {
372  m_generator->HepMC2G4(HepMCEvt->GetEvent(),evt);
373  }
374  else
375  {
376  m_generator->nonBeamEvent2G4(HepMCEvt->GetEvent(),evt);
377  }
378 
379  return evt;
380 }
EventNumber_t event() const
Definition: EventID.h:44
G4Event * m_currentEvent
Definition: RunManager.h:120
void HepMC2G4(const HepMC::GenEvent *g, G4Event *e)
Definition: Generator.cc:91
Generator * m_generator
Definition: RunManager.h:107
bool m_nonBeam
Definition: RunManager.h:110
void setGenEvent(const HepMC::GenEvent *inpevt)
Definition: Generator.h:24
void resetGenParticleId(edm::Event &inpevt)
Definition: RunManager.cc:494
bool getByLabel(InputTag const &tag, Handle< PROD > &result) const
Definition: Event.h:390
void nonBeamEvent2G4(const HepMC::GenEvent *g, G4Event *e)
Definition: Generator.cc:481
std::string m_InTag
Definition: RunManager.h:108
edm::EventID id() const
Definition: EventBase.h:56
G4SimEvent * m_simEvent
Definition: RunManager.h:121
const Generator* RunManager::generator ( ) const
inline

Definition at line 78 of file RunManager.h.

References m_generator.

78 { return m_generator; }
Generator * m_generator
Definition: RunManager.h:107
SimTrackManager * RunManager::GetSimTrackManager ( )

Definition at line 503 of file RunManager.cc.

References m_trackManager.

Referenced by SimRunInterface::SimRunInterface().

504 {
505  return m_trackManager.get();
506 }
std::auto_ptr< SimTrackManager > m_trackManager
Definition: RunManager.h:154
void RunManager::initG4 ( const edm::EventSetup es)

Definition at line 172 of file RunManager.cc.

References SimActivityRegistry::beginOfJobSignal_, sim::FieldBuilder::build(), edm::ESWatcher< T >::check(), asciidump::cmd, AttachSD::create(), SurfaceDeformationFactory::create(), SimActivityRegistry::dddWorldSignal_, dir, DumpMagneticField(), edm::hlt::Exception, firstRun, g, edm::EventSetup::get(), reco::get(), edm::ParameterSet::getParameter(), DDDWorld::GetWorldVolume(), idealGeomRcdWatcher_, idealMagRcdWatcher_, recoMuon::in, initializeRun(), initializeUserActions(), m_attach, m_check, m_fieldBuilder, m_FieldFile, m_G4Commands, m_kernel, m_managerInitialized, m_p, m_pField, m_physicsList, m_PhysicsTablesDir, m_pPhysics, m_primaryTransformer, m_pUseMagneticField, m_registry, m_RestorePhysicsTables, m_sensCaloDets, m_sensTkDets, m_StorePhysicsTables, m_trackManager, m_WriteFile, and AlCaHLTBitMon_QueryRunRegistry::string.

173 {
174  bool geomChanged = idealGeomRcdWatcher_.check(es);
175  if (geomChanged && (!firstRun)) {
176  throw cms::Exception("BadConfig")
177  << "[SimG4Core RunManager]\n"
178  << "The Geometry configuration is changed during the job execution\n"
179  << "this is not allowed, the geometry must stay unchanged\n";
180  }
181  if (m_pUseMagneticField) {
182  bool magChanged = idealMagRcdWatcher_.check(es);
183  if (magChanged && (!firstRun)) {
184  throw cms::Exception("BadConfig")
185  << "[SimG4Core RunManager]\n"
186  << "The MagneticField configuration is changed during the job execution\n"
187  << "this is not allowed, the MagneticField must stay unchanged\n";
188  }
189  }
190 
191  if (m_managerInitialized) return;
192 
193  // DDDWorld: get the DDCV from the ES and use it to build the World
195  es.get<IdealGeometryRecord>().get(pDD);
196 
198  SensitiveDetectorCatalog catalog_;
199  const DDDWorld * world = new DDDWorld(&(*pDD), map_, catalog_, m_check);
201 
202  if("" != m_WriteFile) {
203  G4GDMLParser gdml;
204  gdml.Write(m_WriteFile, world->GetWorldVolume());
205  }
206 
208  {
209  // setup the magnetic field
211  es.get<IdealMagneticFieldRecord>().get(pMF);
212  const GlobalPoint g(0.,0.,0.);
213 
214  m_fieldBuilder = new sim::FieldBuilder(&(*pMF), m_pField);
215  G4TransportationManager * tM =
216  G4TransportationManager::GetTransportationManager();
217  m_fieldBuilder->build( tM->GetFieldManager(),
218  tM->GetPropagatorInField());
219  if("" != m_FieldFile) {
220  DumpMagneticField(tM->GetFieldManager()->GetDetectorField());
221  }
222  }
223 
224  // we need the track manager now
225  m_trackManager = std::auto_ptr<SimTrackManager>(new SimTrackManager);
226 
227  // attach sensitive detector
228  m_attach = new AttachSD;
229 
230  std::pair< std::vector<SensitiveTkDetector*>,
231  std::vector<SensitiveCaloDetector*> > sensDets =
232  m_attach->create(*world,(*pDD),catalog_,m_p,m_trackManager.get(),
233  m_registry);
234 
235  m_sensTkDets.swap(sensDets.first);
236  m_sensCaloDets.swap(sensDets.second);
237 
238  edm::LogInfo("SimG4CoreApplication")
239  << " RunManager: Sensitive Detector "
240  << "building finished; found "
241  << m_sensTkDets.size()
242  << " Tk type Producers, and "
243  << m_sensCaloDets.size()
244  << " Calo type producers ";
245 
247  es.get<PDTRecord>().get(fTable);
248  const HepPDT::ParticleDataTable *fPDGTable = &(*fTable);
249 
251 
252  std::auto_ptr<PhysicsListMakerBase>
253  physicsMaker(PhysicsListFactory::get()->create(
254  m_pPhysics.getParameter<std::string> ("type")));
255  if (physicsMaker.get()==0) {
256  throw SimG4Exception("Unable to find the Physics list requested");
257  }
258  m_physicsList =
259  physicsMaker->make(map_,fPDGTable,m_fieldBuilder,m_pPhysics,m_registry);
260 
261  PhysicsList* phys = m_physicsList.get();
262  if (phys==0) {
263  throw SimG4Exception("Physics list construction failed!");
264  }
265 
266  // adding GFlash, Russian Roulette for eletrons and gamma,
267  // step limiters on top of any Physics Lists
268  phys->RegisterPhysics(new ParametrisedEMPhysics("EMoptions",m_pPhysics));
269 
270  m_kernel->SetPhysics(phys);
271  m_kernel->InitializePhysics();
272 
273  m_physicsList->ResetStoredInAscii();
274  std::string tableDir = m_PhysicsTablesDir;
276  m_physicsList->SetPhysicsTableRetrieved(tableDir);
277  }
278  if (m_kernel->RunInitialization()) { m_managerInitialized = true; }
279  else {
280  throw SimG4Exception("G4RunManagerKernel initialization failed!");
281  }
282 
284  {
285  std::ostringstream dir;
286  dir << tableDir << '\0';
287  std::string cmd = std::string("/control/shell mkdir -p ")+tableDir;
288  if (!std::ifstream(dir.str().c_str(), std::ios::in))
289  G4UImanager::GetUIpointer()->ApplyCommand(cmd);
290  m_physicsList->StorePhysicsTable(tableDir);
291  }
292 
293  //tell all interesting parties that we are beginning the job
294  BeginOfJob aBeginOfJob(&es);
295  m_registry.beginOfJobSignal_(&aBeginOfJob);
296 
298 
299  for (unsigned it=0; it<m_G4Commands.size(); it++) {
300  edm::LogInfo("SimG4CoreApplication") << "RunManager:: Requests UI: "
301  << m_G4Commands[it];
302  G4UImanager::GetUIpointer()->ApplyCommand(m_G4Commands[it]);
303  }
304 
305  // If the Geant4 particle table is needed, decomment the lines below
306  //
307  // G4cout << "Output of G4ParticleTable DumpTable:" << G4endl;
308  // G4ParticleTable::GetParticleTable()->DumpTable("ALL");
309 
310  initializeRun();
311  firstRun= false;
312 }
T getParameter(std::string const &) const
bool m_check
Definition: RunManager.h:131
std::auto_ptr< SimTrackManager > m_trackManager
Definition: RunManager.h:154
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
edm::ESWatcher< IdealMagneticFieldRecord > idealMagRcdWatcher_
Definition: RunManager.h:158
const G4VPhysicalVolume * GetWorldVolume() const
Definition: DDDWorld.h:17
SimActivityRegistry m_registry
Definition: RunManager.h:150
edm::ParameterSet m_p
Definition: RunManager.h:143
HepPDT::ParticleDataTable ParticleDataTable
void initializeRun()
Definition: RunManager.cc:450
void initializeUserActions()
Definition: RunManager.cc:415
void build(G4FieldManager *fM=0, G4PropagatorInField *fP=0)
Definition: FieldBuilder.cc:47
bool m_pUseMagneticField
Definition: RunManager.h:118
edm::ESWatcher< IdealGeometryRecord > idealGeomRcdWatcher_
Definition: RunManager.h:157
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
std::vector< SensitiveCaloDetector * > m_sensCaloDets
Definition: RunManager.h:148
std::vector< SensitiveTkDetector * > m_sensTkDets
Definition: RunManager.h:147
BeginOfJobSignal beginOfJobSignal_
std::auto_ptr< PhysicsList > m_physicsList
Definition: RunManager.h:111
std::string m_WriteFile
Definition: RunManager.h:163
bool firstRun
Definition: RunManager.h:117
string cmd
Definition: asciidump.py:19
bool m_RestorePhysicsTables
Definition: RunManager.h:129
edm::ParameterSet m_pField
Definition: RunManager.h:133
edm::ParameterSet m_pPhysics
Definition: RunManager.h:136
DDDWorldSignal dddWorldSignal_
const T & get() const
Definition: EventSetup.h:55
bool check(const edm::EventSetup &iSetup)
Definition: ESWatcher.h:58
void DumpMagneticField(const G4Field *) const
Definition: RunManager.cc:531
AttachSD * m_attach
Definition: RunManager.h:146
PrimaryTransformer * m_primaryTransformer
Definition: RunManager.h:112
sim::FieldBuilder * m_fieldBuilder
Definition: RunManager.h:155
std::string m_PhysicsTablesDir
Definition: RunManager.h:127
bool m_StorePhysicsTables
Definition: RunManager.h:128
dbl *** dir
Definition: mlp_gen.cc:35
std::vector< std::string > m_G4Commands
Definition: RunManager.h:142
SurfaceDeformation * create(int type, const std::vector< double > &params)
std::string m_FieldFile
Definition: RunManager.h:162
bool m_managerInitialized
Definition: RunManager.h:113
T get(const Candidate &c)
Definition: component.h:55
G4RunManagerKernel * m_kernel
Definition: RunManager.h:105
void RunManager::initializeRun ( )

Definition at line 450 of file RunManager.cc.

References RunAction::BeginOfRunAction(), m_currentRun, m_runAborted, m_runInitialized, and m_userRunAction.

Referenced by initG4().

451 {
452  m_runInitialized = false;
453  if (m_currentRun==0) { m_currentRun = new G4Run(); }
454  G4StateManager::GetStateManager()->SetNewState(G4State_GeomClosed);
456  m_runAborted = false;
457  m_runInitialized = true;
458 }
G4Run * m_currentRun
Definition: RunManager.h:119
RunAction * m_userRunAction
Definition: RunManager.h:122
void BeginOfRunAction(const G4Run *aRun)
Definition: RunAction.cc:16
bool m_runInitialized
Definition: RunManager.h:114
bool m_runAborted
Definition: RunManager.h:116
void RunManager::initializeUserActions ( )

Definition at line 415 of file RunManager.cc.

References Connect(), m_EvtMgrVerbosity, m_generator, m_kernel, m_pEventAction, m_pRunAction, m_pStackingAction, m_pSteppingAction, m_pTrackingAction, m_runInterface, m_trackManager, and m_userRunAction.

Referenced by initG4().

416 {
417  m_runInterface = new SimRunInterface(this, false);
418 
421 
422  G4EventManager * eventManager = m_kernel->GetEventManager();
423  eventManager->SetVerboseLevel(m_EvtMgrVerbosity);
424 
425  if (m_generator!=0) {
426  EventAction * userEventAction =
428  Connect(userEventAction);
429  eventManager->SetUserAction(userEventAction);
430 
431  TrackingAction* userTrackingAction =
432  new TrackingAction(userEventAction,m_pTrackingAction);
433  Connect(userTrackingAction);
434  eventManager->SetUserAction(userTrackingAction);
435 
436  SteppingAction* userSteppingAction =
437  new SteppingAction(userEventAction,m_pSteppingAction);
438  Connect(userSteppingAction);
439  eventManager->SetUserAction(userSteppingAction);
440 
441  eventManager->SetUserAction(new StackingAction(m_pStackingAction));
442 
443  } else {
444  edm::LogWarning("SimG4CoreApplication") << " RunManager: WARNING : "
445  << "No generator; initialized "
446  << "only RunAction!";
447  }
448 }
std::auto_ptr< SimTrackManager > m_trackManager
Definition: RunManager.h:154
Generator * m_generator
Definition: RunManager.h:107
int m_EvtMgrVerbosity
Definition: RunManager.h:130
SimRunInterface * m_runInterface
Definition: RunManager.h:123
edm::ParameterSet m_pStackingAction
Definition: RunManager.h:139
edm::ParameterSet m_pEventAction
Definition: RunManager.h:138
edm::ParameterSet m_pSteppingAction
Definition: RunManager.h:141
RunAction * m_userRunAction
Definition: RunManager.h:122
void Connect(RunAction *)
Definition: RunManager.cc:508
edm::ParameterSet m_pRunAction
Definition: RunManager.h:137
edm::ParameterSet m_pTrackingAction
Definition: RunManager.h:140
G4RunManagerKernel * m_kernel
Definition: RunManager.h:105
void RunManager::produce ( edm::Event inpevt,
const edm::EventSetup es 
)

Definition at line 320 of file RunManager.cc.

References abortRun(), G4SimEvent::collisionPoint(), edm::EventID::event(), Generator::eventWeight(), generateEvent(), Generator::genEvent(), Generator::genVertex(), G4SimEvent::hepEvent(), edm::EventBase::id(), m_currentEvent, m_generator, m_kernel, m_simEvent, G4SimEvent::nGenParts(), G4SimEvent::nTracks(), G4SimEvent::nVertices(), edm::second(), and G4SimEvent::weight().

321 {
322  m_currentEvent = generateEvent(inpevt);
323  m_simEvent = new G4SimEvent;
326  if (m_generator->genVertex() !=0 ) {
329  m_generator->genVertex()->y()/centimeter,
330  m_generator->genVertex()->z()/centimeter,
331  m_generator->genVertex()->t()/second));
332  }
333  if (m_currentEvent->GetNumberOfPrimaryVertex()==0) {
334  edm::LogError("SimG4CoreApplication")
335  << " RunManager::produce event " << inpevt.id().event()
336  << " with no G4PrimaryVertices \n Aborting Run" ;
337 
338  abortRun(false);
339  } else {
340  m_kernel->GetEventManager()->ProcessOneEvent(m_currentEvent);
341  }
342 
343  edm::LogInfo("SimG4CoreApplication")
344  << " RunManager: saved : Event " << inpevt.id().event()
345  << " of weight " << m_simEvent->weight()
346  << " with " << m_simEvent->nTracks() << " tracks and "
347  << m_simEvent->nVertices()
348  << " vertices, generated by " << m_simEvent->nGenParts() << " particles ";
349 }
EventNumber_t event() const
Definition: EventID.h:44
virtual const math::XYZTLorentzVector * genVertex() const
Definition: Generator.h:29
virtual const double eventWeight() const
Definition: Generator.h:30
ROOT::Math::LorentzVector< ROOT::Math::PxPyPzE4D< double > > XYZTLorentzVectorD
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:14
G4Event * m_currentEvent
Definition: RunManager.h:120
void abortRun(bool softAbort=false)
Definition: RunManager.cc:484
virtual const HepMC::GenEvent * genEvent() const
Definition: Generator.h:28
Generator * m_generator
Definition: RunManager.h:107
U second(std::pair< T, U > const &p)
void weight(float w)
Definition: G4SimEvent.h:27
void hepEvent(const HepMC::GenEvent *r)
Definition: G4SimEvent.h:25
unsigned int nTracks() const
Definition: G4SimEvent.h:22
unsigned int nVertices() const
Definition: G4SimEvent.h:23
unsigned int nGenParts() const
Definition: G4SimEvent.h:24
G4Event * generateEvent(edm::Event &inpevt)
Definition: RunManager.cc:351
edm::EventID id() const
Definition: EventBase.h:56
void collisionPoint(const math::XYZTLorentzVectorD &v)
Definition: G4SimEvent.h:29
G4SimEvent * m_simEvent
Definition: RunManager.h:121
G4RunManagerKernel * m_kernel
Definition: RunManager.h:105
std::vector<boost::shared_ptr<SimProducer> > RunManager::producers ( ) const
inline

Definition at line 87 of file RunManager.h.

References m_producers.

87  {
88  return m_producers;
89  }
std::vector< boost::shared_ptr< SimProducer > > m_producers
Definition: RunManager.h:152
void RunManager::resetGenParticleId ( edm::Event inpevt)
protected

Definition at line 494 of file RunManager.cc.

References edm::Event::getByLabel(), edm::HandleBase::isValid(), m_theLHCTlinkTag, m_trackManager, and edm::Handle< T >::product().

Referenced by generateEvent().

495 {
497  inpevt.getByLabel( m_theLHCTlinkTag, theLHCTlink );
498  if ( theLHCTlink.isValid() ) {
499  m_trackManager->setLHCTransportLink( theLHCTlink.product() );
500  }
501 }
std::auto_ptr< SimTrackManager > m_trackManager
Definition: RunManager.h:154
bool isValid() const
Definition: HandleBase.h:76
bool getByLabel(InputTag const &tag, Handle< PROD > &result) const
Definition: Event.h:390
T const * product() const
Definition: Handle.h:81
edm::InputTag m_theLHCTlinkTag
Definition: RunManager.h:160
std::vector<SensitiveCaloDetector*>& RunManager::sensCaloDetectors ( )
inline

Definition at line 84 of file RunManager.h.

References m_sensCaloDets.

84  {
85  return m_sensCaloDets;
86  }
std::vector< SensitiveCaloDetector * > m_sensCaloDets
Definition: RunManager.h:148
std::vector<SensitiveTkDetector*>& RunManager::sensTkDetectors ( )
inline

Definition at line 81 of file RunManager.h.

References m_sensTkDets.

81  {
82  return m_sensTkDets;
83  }
std::vector< SensitiveTkDetector * > m_sensTkDets
Definition: RunManager.h:147
G4SimEvent* RunManager::simEvent ( )
inline

Definition at line 80 of file RunManager.h.

References m_simEvent.

Referenced by SimRunInterface::simEvent().

80 { return m_simEvent; }
G4SimEvent * m_simEvent
Definition: RunManager.h:121
void RunManager::stopG4 ( )

Definition at line 314 of file RunManager.cc.

References m_runTerminated, and terminateRun().

315 {
316  G4StateManager::GetStateManager()->SetNewState(G4State_Quit);
317  if (!m_runTerminated) { terminateRun(); }
318 }
void terminateRun()
Definition: RunManager.cc:460
bool m_runTerminated
Definition: RunManager.h:115
void RunManager::terminateRun ( )

Definition at line 460 of file RunManager.cc.

References RunAction::EndOfRunAction(), m_currentEvent, m_currentRun, m_kernel, m_runInitialized, m_runTerminated, m_simEvent, and m_userRunAction.

Referenced by abortRun(), stopG4(), and ~RunManager().

461 {
462  if (m_userRunAction!=0) {
464  delete m_userRunAction;
465  m_userRunAction = 0;
466  }
467  /*
468  if (m_currentRun!=0) {
469  delete m_currentRun;
470  m_currentRun = 0;
471  }
472  */
473  if (m_kernel!=0 && !m_runTerminated) {
474  delete m_currentEvent;
475  m_currentEvent = 0;
476  delete m_simEvent;
477  m_simEvent = 0;
478  m_kernel->RunTermination();
479  m_runInitialized = false;
480  m_runTerminated = true;
481  }
482 }
G4Event * m_currentEvent
Definition: RunManager.h:120
void EndOfRunAction(const G4Run *aRun)
Definition: RunAction.cc:28
G4Run * m_currentRun
Definition: RunManager.h:119
bool m_runTerminated
Definition: RunManager.h:115
RunAction * m_userRunAction
Definition: RunManager.h:122
bool m_runInitialized
Definition: RunManager.h:114
G4SimEvent * m_simEvent
Definition: RunManager.h:121
G4RunManagerKernel * m_kernel
Definition: RunManager.h:105

Member Data Documentation

bool RunManager::firstRun
private

Definition at line 117 of file RunManager.h.

Referenced by initG4().

edm::ESWatcher<IdealGeometryRecord> RunManager::idealGeomRcdWatcher_
private

Definition at line 157 of file RunManager.h.

Referenced by initG4().

edm::ESWatcher<IdealMagneticFieldRecord> RunManager::idealMagRcdWatcher_
private

Definition at line 158 of file RunManager.h.

Referenced by initG4().

AttachSD* RunManager::m_attach
private

Definition at line 146 of file RunManager.h.

Referenced by initG4().

bool RunManager::m_check
private

Definition at line 131 of file RunManager.h.

Referenced by initG4(), and RunManager().

G4Event* RunManager::m_currentEvent
private

Definition at line 120 of file RunManager.h.

Referenced by abortEvent(), currentEvent(), generateEvent(), produce(), and terminateRun().

G4Run* RunManager::m_currentRun
private

Definition at line 119 of file RunManager.h.

Referenced by abortRun(), currentRun(), initializeRun(), and terminateRun().

ExceptionHandler* RunManager::m_CustomExceptionHandler
private

Definition at line 144 of file RunManager.h.

Referenced by RunManager().

int RunManager::m_EvtMgrVerbosity
private

Definition at line 130 of file RunManager.h.

Referenced by initializeUserActions().

sim::FieldBuilder* RunManager::m_fieldBuilder
private

Definition at line 155 of file RunManager.h.

Referenced by initG4().

std::string RunManager::m_FieldFile
private

Definition at line 162 of file RunManager.h.

Referenced by DumpMagneticField(), initG4(), and RunManager().

std::vector<std::string> RunManager::m_G4Commands
private

Definition at line 142 of file RunManager.h.

Referenced by initG4().

Generator* RunManager::m_generator
private

Definition at line 107 of file RunManager.h.

Referenced by generateEvent(), generator(), initializeUserActions(), produce(), and RunManager().

std::string RunManager::m_InTag
private

Definition at line 108 of file RunManager.h.

Referenced by generateEvent(), and RunManager().

G4RunManagerKernel* RunManager::m_kernel
private
bool RunManager::m_managerInitialized
private

Definition at line 113 of file RunManager.h.

Referenced by initG4().

bool RunManager::m_nonBeam
private

Definition at line 110 of file RunManager.h.

Referenced by generateEvent().

edm::ParameterSet RunManager::m_p
private

Definition at line 143 of file RunManager.h.

Referenced by initG4(), and RunManager().

edm::ParameterSet RunManager::m_pEventAction
private

Definition at line 138 of file RunManager.h.

Referenced by initializeUserActions().

edm::ParameterSet RunManager::m_pField
private

Definition at line 133 of file RunManager.h.

Referenced by initG4().

edm::ParameterSet RunManager::m_pGenerator
private

Definition at line 134 of file RunManager.h.

Referenced by RunManager().

edm::ParameterSet RunManager::m_pGeometry
private

Definition at line 132 of file RunManager.h.

std::auto_ptr<PhysicsList> RunManager::m_physicsList
private

Definition at line 111 of file RunManager.h.

Referenced by initG4().

std::string RunManager::m_PhysicsTablesDir
private

Definition at line 127 of file RunManager.h.

Referenced by initG4().

edm::ParameterSet RunManager::m_pPhysics
private

Definition at line 136 of file RunManager.h.

Referenced by initG4().

PrimaryTransformer* RunManager::m_primaryTransformer
private

Definition at line 112 of file RunManager.h.

Referenced by initG4().

std::vector<boost::shared_ptr<SimProducer> > RunManager::m_producers
private

Definition at line 152 of file RunManager.h.

Referenced by producers(), and RunManager().

edm::ParameterSet RunManager::m_pRunAction
private

Definition at line 137 of file RunManager.h.

Referenced by initializeUserActions().

edm::ParameterSet RunManager::m_pStackingAction
private

Definition at line 139 of file RunManager.h.

Referenced by initializeUserActions().

edm::ParameterSet RunManager::m_pSteppingAction
private

Definition at line 141 of file RunManager.h.

Referenced by initializeUserActions().

edm::ParameterSet RunManager::m_pTrackingAction
private

Definition at line 140 of file RunManager.h.

Referenced by initializeUserActions().

bool RunManager::m_pUseMagneticField
private

Definition at line 118 of file RunManager.h.

Referenced by initG4().

edm::ParameterSet RunManager::m_pVertexGenerator
private

Definition at line 135 of file RunManager.h.

SimActivityRegistry RunManager::m_registry
private

Definition at line 150 of file RunManager.h.

Referenced by Connect(), initG4(), and RunManager().

bool RunManager::m_RestorePhysicsTables
private

Definition at line 129 of file RunManager.h.

Referenced by initG4().

bool RunManager::m_runAborted
private

Definition at line 116 of file RunManager.h.

Referenced by abortRun(), and initializeRun().

bool RunManager::m_runInitialized
private

Definition at line 114 of file RunManager.h.

Referenced by abortRun(), initializeRun(), and terminateRun().

SimRunInterface* RunManager::m_runInterface
private

Definition at line 123 of file RunManager.h.

Referenced by initializeUserActions(), RunManager(), and ~RunManager().

bool RunManager::m_runTerminated
private

Definition at line 115 of file RunManager.h.

Referenced by abortEvent(), stopG4(), terminateRun(), and ~RunManager().

std::vector<SensitiveCaloDetector*> RunManager::m_sensCaloDets
private

Definition at line 148 of file RunManager.h.

Referenced by initG4(), and sensCaloDetectors().

std::vector<SensitiveTkDetector*> RunManager::m_sensTkDets
private

Definition at line 147 of file RunManager.h.

Referenced by initG4(), and sensTkDetectors().

G4SimEvent* RunManager::m_simEvent
private

Definition at line 121 of file RunManager.h.

Referenced by generateEvent(), produce(), simEvent(), and terminateRun().

bool RunManager::m_StorePhysicsTables
private

Definition at line 128 of file RunManager.h.

Referenced by initG4().

edm::InputTag RunManager::m_theLHCTlinkTag
private

Definition at line 160 of file RunManager.h.

Referenced by resetGenParticleId().

std::auto_ptr<SimTrackManager> RunManager::m_trackManager
private
RunAction* RunManager::m_userRunAction
private

Definition at line 122 of file RunManager.h.

Referenced by initializeRun(), initializeUserActions(), RunManager(), and terminateRun().

std::vector<boost::shared_ptr<SimWatcher> > RunManager::m_watchers
private

Definition at line 151 of file RunManager.h.

Referenced by RunManager().

std::string RunManager::m_WriteFile
private

Definition at line 163 of file RunManager.h.

Referenced by initG4(), and RunManager().