#include <RunManagerMT.h>

Inheritance diagram for 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 Generator *	generator () const

SimTrackManager *	GetSimTrackManager ()

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

	RunManagerMT (edm::ParameterSet const &p)

std::vector < SensitiveCaloDetector * > &	sensCaloDetectors ()

std::vector < SensitiveTkDetector * > &	sensTkDetectors ()

G4SimEvent *	simEvent ()

void	stopG4 ()

void	terminateRun ()

	~RunManagerMT ()

Public Member Functions inherited from RunManager
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 Generator *	generator () const

SimTrackManager *	GetSimTrackManager ()

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 ()

G4SimEvent *	simEvent ()

void	stopG4 ()

void	terminateRun ()

	~RunManager ()

Protected Member Functions
void	DumpMagneticField (const G4Field *) const

G4Event *	generateEvent (edm::Event &inpevt)

void	resetGenParticleId (edm::Event &inpevt)

Protected Member Functions inherited from RunManager
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_

AttachSD *	m_attach

bool	m_check

G4Event *	m_currentEvent

G4Run *	m_currentRun

ExceptionHandler *	m_CustomExceptionHandler

int	m_EvtMgrVerbosity

sim::FieldBuilder *	m_fieldBuilder

std::string	m_FieldFile

std::vector< std::string >	m_G4Commands

Generator *	m_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< PhysicsList >	m_physicsList

std::string	m_PhysicsTablesDir

edm::ParameterSet	m_pPhysics

PrimaryTransformer *	m_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

SimRunInterface *	m_runInterface

bool	m_runTerminated

std::vector < SensitiveCaloDetector * >	m_sensCaloDets

std::vector < SensitiveTkDetector * >	m_sensTkDets

G4SimEvent *	m_simEvent

bool	m_StorePhysicsTables

edm::InputTag	m_theLHCTlinkTag

std::auto_ptr< SimTrackManager >	m_trackManager

RunAction *	m_userRunAction

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

std::string	m_WriteFile

Detailed Description

Definition at line 62 of file RunManagerMT.h.

Constructor & Destructor Documentation

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

Definition at line 110 of file RunManagerMT.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.

   : RunManager(p),
       m_generator(0), m_nonBeam(p.getParameter<bool>("NonBeamEvent")), 
       m_primaryTransformer(0), 
       m_managerInitialized(false), 
       m_runInitialized(false), m_runTerminated(false), m_runAborted(false),
       firstRun(true),
       m_pUseMagneticField(p.getParameter<bool>("UseMagneticField")),
       m_currentRun(0), m_currentEvent(0), m_simEvent(0), 
       m_PhysicsTablesDir(p.getParameter<std::string>("PhysicsTablesDirectory")),
       m_StorePhysicsTables(p.getParameter<bool>("StorePhysicsTables")),
       m_RestorePhysicsTables(p.getParameter<bool>("RestorePhysicsTables")),
       m_EvtMgrVerbosity(p.getUntrackedParameter<int>("G4EventManagerVerbosity",0)),
       m_pField(p.getParameter<edm::ParameterSet>("MagneticField")),
       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")),
       m_G4Commands(p.getParameter<std::vector<std::string> >("G4Commands")),
       m_p(p), m_fieldBuilder(0),
       m_theLHCTlinkTag(p.getParameter<edm::InputTag>("theLHCTlinkTag"))
 {    
   //m_HepMC = iC.consumes<edm::HepMCProduct>(p.getParameter<edm::InputTag>("HepMCProduct"));
 
   m_kernel = G4RunManagerKernel::GetRunManagerKernel();
   if (m_kernel==0) m_kernel = new G4RunManagerKernel();
 
   m_CustomExceptionHandler = new ExceptionHandler(this) ;
     
   m_check = p.getUntrackedParameter<bool>("CheckOverlap",false);
   m_WriteFile = p.getUntrackedParameter<std::string>("FileNameGDML","");
   m_FieldFile = p.getUntrackedParameter<std::string>("FileNameField","");
   if("" != m_FieldFile) { m_FieldFile += ".txt"; } 
 
   m_userRunAction = 0;
   m_runInterface = 0;
 
   //Look for an outside SimActivityRegistry
   // this is used by the visualization code
   edm::Service<SimActivityRegistry> otherRegistry;
   if(otherRegistry){
     m_registry.connect(*otherRegistry);
   }
 
   createWatchers(m_p, m_registry, m_watchers, m_producers);
 
   m_generator = new Generator(m_pGenerator);
   m_InTag = m_pGenerator.getParameter<std::string>("HepMCProductLabel") ;
 
 }

RunManagerMT::~RunManagerMT ( )

Definition at line 164 of file RunManagerMT.cc.

References m_runInterface, m_runTerminated, and terminateRun().

 { 
   if (!m_runTerminated) { terminateRun(); }
   G4StateManager::GetStateManager()->SetNewState(G4State_Quit);
   G4GeometryManager::GetInstance()->OpenGeometry();
   //   if (m_kernel!=0) delete m_kernel; 
   delete m_runInterface;
 }

Member Function Documentation

void RunManagerMT::abortEvent ( )

Definition at line 384 of file RunManagerMT.cc.

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

Referenced by abortRun().

 {
   if (m_runTerminated) { return; }
   G4Track* t =
     m_kernel->GetEventManager()->GetTrackingManager()->GetTrack();
   t->SetTrackStatus(fStopAndKill) ;
      
   // CMS-specific act
   //
   TrackingAction* uta =
     (TrackingAction*)m_kernel->GetEventManager()->GetUserTrackingAction() ;
   uta->PostUserTrackingAction(t) ;
 
   m_currentEvent->SetEventAborted();
     
   // do NOT call this method for now
   // because it'll set abortRequested=true (withing G4EventManager)
   // this will make Geant4, in the event *next* after the aborted one
   // NOT to get the primamry, thus there's NOTHING to trace, and it goes
   // to the end of G4Event::DoProcessing(G4Event*), where abortRequested
   // will be reset to true again
   //    
   //m_kernel->GetEventManager()->AbortCurrentEvent();
   //
   // instead, mimic what it does, except (re)setting abortRequested
   //
   m_kernel->GetEventManager()->GetStackManager()->clear() ;
   m_kernel->GetEventManager()->GetTrackingManager()->EventAborted() ;
      
   G4StateManager* stateManager = G4StateManager::GetStateManager();
   stateManager->SetNewState(G4State_GeomClosed);
 }

void RunManagerMT::abortRun ( bool softAbort = false )

Definition at line 486 of file RunManagerMT.cc.

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

Referenced by produce().

 {
   m_runAborted = false;
   if (!softAbort) { abortEvent(); }
   if (m_currentRun!=0) { delete m_currentRun; m_currentRun = 0; }
   m_runInitialized = false;
   m_runAborted = true;
   terminateRun();
 }

void RunManagerMT::Connect ( RunAction * runAction )

Definition at line 510 of file RunManagerMT.cc.

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

Referenced by initializeUserActions().

 {
   runAction->m_beginOfRunSignal.connect(m_registry.beginOfRunSignal_);
   runAction->m_endOfRunSignal.connect(m_registry.endOfRunSignal_);
 }

void RunManagerMT::Connect ( EventAction * eventAction )

Definition at line 516 of file RunManagerMT.cc.

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

 {
   eventAction->m_beginOfEventSignal.connect(m_registry.beginOfEventSignal_);
   eventAction->m_endOfEventSignal.connect(m_registry.endOfEventSignal_);
 }

void RunManagerMT::Connect ( TrackingAction * trackingAction )

Definition at line 522 of file RunManagerMT.cc.

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

 {
   trackingAction->m_beginOfTrackSignal.connect(m_registry.beginOfTrackSignal_);
   trackingAction->m_endOfTrackSignal.connect(m_registry.endOfTrackSignal_);
 }

void RunManagerMT::Connect ( SteppingAction * steppingAction )

Definition at line 528 of file RunManagerMT.cc.

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

 {
   steppingAction->m_g4StepSignal.connect(m_registry.g4StepSignal_);
 }

const G4Event* RunManagerMT::currentEvent ( ) const

inline

Definition at line 80 of file RunManagerMT.h.

References m_currentEvent.

80 { return m_currentEvent; }

RunManagerMT::m_currentEvent

G4Event * m_currentEvent

Definition: RunManagerMT.h:121

const G4Run* RunManagerMT::currentRun ( ) const

inline

Definition at line 76 of file RunManagerMT.h.

References m_currentRun.

76 { return m_currentRun; }

RunManagerMT::m_currentRun

G4Run * m_currentRun

Definition: RunManagerMT.h:120

void RunManagerMT::DumpMagneticField ( const G4Field * field ) const

protected

Definition at line 533 of file RunManagerMT.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().

 {
   std::ofstream fout(m_FieldFile.c_str(), std::ios::out);
   if(fout.fail()){
     edm::LogWarning("SimG4CoreApplication") 
       << " RunManagerMT WARNING : "
       << "error opening file <" << m_FieldFile << "> for magnetic field";
   } else {
     double rmax = 9000*mm;
     double zmax = 16000*mm;
 
     double dr = 5*cm;
     double dz = 20*cm;
 
     int nr = (int)(rmax/dr);
     int nz = 2*(int)(zmax/dz);
 
     double r = 0.0;
     double z0 = -zmax;
     double z;
 
     double phi = 0.0;
     double cosf = cos(phi);
     double sinf = sin(phi);
 
     double point[4] = {0.0,0.0,0.0,0.0};
     double bfield[3] = {0.0,0.0,0.0};
 
     fout << std::setprecision(6); 
     for(int i=0; i<=nr; ++i) {
       z = z0;
       for(int j=0; j<=nz; ++j) {
         point[0] = r*cosf;
     point[1] = r*sinf;
     point[2] = z;
         field->GetFieldValue(point, bfield); 
         fout << "R(mm)= " << r/mm << " phi(deg)= " << phi/degree 
          << " Z(mm)= " << z/mm << "   Bz(tesla)= " << bfield[2]/tesla 
          << " Br(tesla)= " << (bfield[0]*cosf + bfield[1]*sinf)/tesla
          << " Bphi(tesla)= " << (bfield[0]*sinf - bfield[1]*cosf)/tesla
          << G4endl;
     z += dz;
       }
       r += dr;
     }
     
     fout.close();
   }
 }

G4Event * RunManagerMT::generateEvent ( edm::Event & inpevt )

protected

Definition at line 353 of file RunManagerMT.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().

 {                       
   if (m_currentEvent!=0) { delete m_currentEvent; }
   m_currentEvent = 0;
   if (m_simEvent!=0) { delete m_simEvent; }
   m_simEvent = 0;
   G4Event * evt = new G4Event(inpevt.id().event());
   
   edm::Handle<edm::HepMCProduct> HepMCEvt;
   
   inpevt.getByLabel( m_InTag, HepMCEvt ) ;
   
   m_generator->setGenEvent(HepMCEvt->GetEvent());
 
   // required to reset the GenParticle Id for particles transported 
   // along the beam pipe
   // to their original value for SimTrack creation
   resetGenParticleId( inpevt );
 
   if (!m_nonBeam) 
     {
       m_generator->HepMC2G4(HepMCEvt->GetEvent(),evt);
     }
   else 
     {
       m_generator->nonBeamEvent2G4(HepMCEvt->GetEvent(),evt);
     }
  
   return evt;
 }

const Generator* RunManagerMT::generator ( ) const

inline

Definition at line 79 of file RunManagerMT.h.

References m_generator.

79 { return m_generator; }

RunManagerMT::m_generator

Generator * m_generator

Definition: RunManagerMT.h:108

SimTrackManager * RunManagerMT::GetSimTrackManager ( )

Definition at line 505 of file RunManagerMT.cc.

References m_trackManager.

 {
   return m_trackManager.get();
 }

void RunManagerMT::initG4 ( const edm::EventSetup & es )

Definition at line 173 of file RunManagerMT.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.

 {
   bool geomChanged = idealGeomRcdWatcher_.check(es);
   if (geomChanged && (!firstRun)) {
     throw cms::Exception("BadConfig") 
       << "[SimG4Core RunManagerMT]\n"
       << "The Geometry configuration is changed during the job execution\n"
       << "this is not allowed, the geometry must stay unchanged\n";
   }
   if (m_pUseMagneticField) {
     bool magChanged = idealMagRcdWatcher_.check(es);
     if (magChanged && (!firstRun)) {
       throw cms::Exception("BadConfig") 
     << "[SimG4Core RunManagerMT]\n"
     << "The MagneticField configuration is changed during the job execution\n"
     << "this is not allowed, the MagneticField must stay unchanged\n";
     }
   }
 
   if (m_managerInitialized) return;
   
   // DDDWorld: get the DDCV from the ES and use it to build the World
   edm::ESTransientHandle<DDCompactView> pDD;
   es.get<IdealGeometryRecord>().get(pDD);
    
   G4LogicalVolumeToDDLogicalPartMap map_;
   SensitiveDetectorCatalog catalog_;
   const DDDWorld * world = new DDDWorld(&(*pDD), map_, catalog_, m_check);
   m_registry.dddWorldSignal_(world);
 
   if("" != m_WriteFile) {
     G4GDMLParser gdml;
     gdml.Write(m_WriteFile, world->GetWorldVolume());
   }
 
   if (m_pUseMagneticField)
     {
       // setup the magnetic field
       edm::ESHandle<MagneticField> pMF;
       es.get<IdealMagneticFieldRecord>().get(pMF);
       const GlobalPoint g(0.,0.,0.);
 
       m_fieldBuilder = new sim::FieldBuilder(&(*pMF), m_pField);
       G4TransportationManager * tM = 
     G4TransportationManager::GetTransportationManager();
       m_fieldBuilder->build( tM->GetFieldManager(),
                  tM->GetPropagatorInField());
       if("" != m_FieldFile) { 
     DumpMagneticField(tM->GetFieldManager()->GetDetectorField()); 
       }
     }
 
   // we need the track manager now
   m_trackManager = std::auto_ptr<SimTrackManager>(new SimTrackManager);
 
   // attach sensitive detector
   m_attach = new AttachSD;
   
   std::pair< std::vector<SensitiveTkDetector*>,
     std::vector<SensitiveCaloDetector*> > sensDets = 
     m_attach->create(*world,(*pDD),catalog_,m_p,m_trackManager.get(),
              m_registry);
       
   m_sensTkDets.swap(sensDets.first);
   m_sensCaloDets.swap(sensDets.second);
      
   edm::LogInfo("SimG4CoreApplication") 
     << " RunManagerMT: Sensitive Detector "
     << "building finished; found " 
     << m_sensTkDets.size()
     << " Tk type Producers, and " 
     << m_sensCaloDets.size() 
     << " Calo type producers ";
 
   edm::ESHandle<HepPDT::ParticleDataTable> fTable;
   es.get<PDTRecord>().get(fTable);
   const HepPDT::ParticleDataTable *fPDGTable = &(*fTable);
 
   m_primaryTransformer = new PrimaryTransformer();
 
   std::auto_ptr<PhysicsListMakerBase> 
     physicsMaker(PhysicsListFactory::get()->create(
       m_pPhysics.getParameter<std::string> ("type")));
   if (physicsMaker.get()==0) {
     throw SimG4Exception("Unable to find the Physics list requested");
   }
   m_physicsList = 
     physicsMaker->make(map_,fPDGTable,m_fieldBuilder,m_pPhysics,m_registry);
 
   PhysicsList* phys = m_physicsList.get(); 
   if (phys==0) { 
     throw SimG4Exception("Physics list construction failed!"); 
   }
 
   // adding GFlash, Russian Roulette for eletrons and gamma, 
   // step limiters on top of any Physics Lists
   phys->RegisterPhysics(new ParametrisedEMPhysics("EMoptions",m_pPhysics));
   
   m_kernel->SetPhysics(phys);
   m_kernel->InitializePhysics();
 
   m_physicsList->ResetStoredInAscii();
   std::string tableDir = m_PhysicsTablesDir;
   if (m_RestorePhysicsTables) {
     m_physicsList->SetPhysicsTableRetrieved(tableDir);
   } 
   if (m_kernel->RunInitialization()) { m_managerInitialized = true; }
   else { 
     throw SimG4Exception("G4RunManagerKernel initialization failed!"); 
   }
   
   if (m_StorePhysicsTables)
     {
       std::ostringstream dir;
       dir << tableDir << '\0';
       std::string cmd = std::string("/control/shell mkdir -p ")+tableDir;
       if (!std::ifstream(dir.str().c_str(), std::ios::in))
         G4UImanager::GetUIpointer()->ApplyCommand(cmd);
       m_physicsList->StorePhysicsTable(tableDir);
     }
   
   //tell all interesting parties that we are beginning the job
   BeginOfJob aBeginOfJob(&es);
   m_registry.beginOfJobSignal_(&aBeginOfJob);
   
   initializeUserActions();
   
   for (unsigned it=0; it<m_G4Commands.size(); it++) {
     edm::LogInfo("SimG4CoreApplication") << "RunManagerMT:: Requests UI: "
                                          << m_G4Commands[it];
     G4UImanager::GetUIpointer()->ApplyCommand(m_G4Commands[it]);
   }
 
   // If the Geant4 particle table is needed, decomment the lines below
   //
   //  G4cout << "Output of G4ParticleTable DumpTable:" << G4endl;
   //  G4ParticleTable::GetParticleTable()->DumpTable("ALL");
   
   initializeRun();
   firstRun= false;
 }

void RunManagerMT::initializeRun ( )

Definition at line 452 of file RunManagerMT.cc.

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

Referenced by initG4().

 {
   m_runInitialized = false;
   if (m_currentRun==0) { m_currentRun = new G4Run(); }
   G4StateManager::GetStateManager()->SetNewState(G4State_GeomClosed);
   if (m_userRunAction!=0) { m_userRunAction->BeginOfRunAction(m_currentRun); }
   m_runAborted = false;
   m_runInitialized = true;
 }

void RunManagerMT::initializeUserActions ( )

Definition at line 417 of file RunManagerMT.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().

 {
   m_runInterface = new SimRunInterface(this, false);
 
   m_userRunAction = new RunAction(m_pRunAction, m_runInterface);
   Connect(m_userRunAction);
 
   G4EventManager * eventManager = m_kernel->GetEventManager();
   eventManager->SetVerboseLevel(m_EvtMgrVerbosity);
 
   if (m_generator!=0) {
     EventAction * userEventAction = 
       new EventAction(m_pEventAction, m_runInterface, m_trackManager.get());
     Connect(userEventAction);
     eventManager->SetUserAction(userEventAction);
 
     TrackingAction* userTrackingAction = 
       new TrackingAction(userEventAction,m_pTrackingAction);
     Connect(userTrackingAction);
     eventManager->SetUserAction(userTrackingAction);
     
     SteppingAction* userSteppingAction = 
       new SteppingAction(userEventAction,m_pSteppingAction); 
     Connect(userSteppingAction);
     eventManager->SetUserAction(userSteppingAction);
 
     eventManager->SetUserAction(new StackingAction(m_pStackingAction));
 
   } else {
     edm::LogWarning("SimG4CoreApplication") << " RunManagerMT: WARNING : "
                         << "No generator; initialized "
                         << "only RunAction!";
   }
 }

void RunManagerMT::produce	(	edm::Event &	inpevt,
		const edm::EventSetup &	es
	)

Definition at line 322 of file RunManagerMT.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().

 {
   m_currentEvent = generateEvent(inpevt);
   m_simEvent = new G4SimEvent;
   m_simEvent->hepEvent(m_generator->genEvent());
   m_simEvent->weight(m_generator->eventWeight());
   if (m_generator->genVertex() !=0 ) {
     m_simEvent->collisionPoint(
       math::XYZTLorentzVectorD(m_generator->genVertex()->x()/centimeter,
                    m_generator->genVertex()->y()/centimeter,
                    m_generator->genVertex()->z()/centimeter,
                    m_generator->genVertex()->t()/second));
   }
   if (m_currentEvent->GetNumberOfPrimaryVertex()==0) {
     edm::LogError("SimG4CoreApplication") 
       << " RunManagerMT::produce event " << inpevt.id().event()
       << " with no G4PrimaryVertices \n  Aborting Run" ;
        
     abortRun(false);
   } else {
     m_kernel->GetEventManager()->ProcessOneEvent(m_currentEvent);
   }
     
   edm::LogInfo("SimG4CoreApplication") 
     << " RunManagerMT: saved : Event  " << inpevt.id().event() 
     << " of weight " << m_simEvent->weight()
     << " with " << m_simEvent->nTracks() << " tracks and " 
     << m_simEvent->nVertices()
     << " vertices, generated by " << m_simEvent->nGenParts() << " particles ";
 }

std::vector<boost::shared_ptr<SimProducer> > RunManagerMT::producers ( ) const

inline

Definition at line 88 of file RunManagerMT.h.

References m_producers.

                                                              {
     return m_producers;
   }

void RunManagerMT::resetGenParticleId ( edm::Event & inpevt )

protected

Definition at line 496 of file RunManagerMT.cc.

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

Referenced by generateEvent().

 {
   edm::Handle<edm::LHCTransportLinkContainer> theLHCTlink;
   inpevt.getByLabel( m_theLHCTlinkTag, theLHCTlink );
   if ( theLHCTlink.isValid() ) {
     m_trackManager->setLHCTransportLink( theLHCTlink.product() );
   }
 }

std::vector<SensitiveCaloDetector*>& RunManagerMT::sensCaloDetectors ( )

inline

Definition at line 85 of file RunManagerMT.h.

References m_sensCaloDets.

                                                          { 
     return m_sensCaloDets; 
   }

std::vector<SensitiveTkDetector*>& RunManagerMT::sensTkDetectors ( )

inline

Definition at line 82 of file RunManagerMT.h.

References m_sensTkDets.

                                                      { 
     return m_sensTkDets; 
   }

G4SimEvent* RunManagerMT::simEvent ( )

inline

Definition at line 81 of file RunManagerMT.h.

References m_simEvent.

81 { return m_simEvent; }

RunManagerMT::m_simEvent

G4SimEvent * m_simEvent

Definition: RunManagerMT.h:122

void RunManagerMT::stopG4 ( )

Definition at line 315 of file RunManagerMT.cc.

References m_runTerminated, and terminateRun().

 {
   //std::cout << "RunManagerMT::stopG4" << std::endl;
   G4StateManager::GetStateManager()->SetNewState(G4State_Quit);
   if (!m_runTerminated) { terminateRun(); }
 }

void RunManagerMT::terminateRun ( )

Definition at line 462 of file RunManagerMT.cc.

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

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

 {
   if (m_userRunAction!=0) {
     m_userRunAction->EndOfRunAction(m_currentRun);
     delete m_userRunAction; 
     m_userRunAction = 0;
   }
   /*
   if (m_currentRun!=0) { 
     delete m_currentRun; 
     m_currentRun = 0; 
   }
   */
   if (m_kernel!=0 && !m_runTerminated) {
     delete m_currentEvent;
     m_currentEvent = 0;
     delete m_simEvent;
     m_simEvent = 0;
     m_kernel->RunTermination();
     m_runInitialized = false;
     m_runTerminated = true;
   }  
 }