RunManager Class Reference

#include <RunManager.h>

Public Member Functions
void	abortEvent ()
void	abortRun (bool softAbort=false)
const G4Event *	currentEvent () const
const G4Run *	currentRun () const
const Generator *	generator () const
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	terminateRun ()
virtual	~RunManager ()

Protected Member Functions
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::vector< std::string >	m_G4Commands
Generator *	m_generator
std::string	m_InTag
G4RunManagerKernel *	m_kernel
bool	m_managerInitialized
bool	m_nonBeam
bool	m_Override
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
bool	m_runTerminated
std::vector < SensitiveCaloDetector * >	m_sensCaloDets
std::vector < SensitiveTkDetector * >	m_sensTkDets
G4SimEvent *	m_simEvent
bool	m_StorePhysicsTables
std::auto_ptr< SimTrackManager >	m_trackManager
G4UserRunAction *	m_userRunAction
std::vector< boost::shared_ptr < SimWatcher > >	m_watchers

Detailed Description

Definition at line 52 of file RunManager.h.

Constructor & Destructor Documentation

RunManager::RunManager

(

edm::ParameterSet const &

p

)

Definition at line 116 of file RunManager.cc.

References SimActivityRegistry::connect(), createWatchers(), edm::ParameterSet::getUntrackedParameter(), m_check, m_CustomExceptionHandler, m_kernel, m_p, m_producers, m_registry, and m_watchers.

  :   m_generator(0), m_nonBeam(p.getParameter<bool>("NonBeamEvent")), 
      m_primaryTransformer(0), 
      m_managerInitialized(false), 
      //m_geometryInitialized(true), m_physicsInitialized(true),
      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_Override(p.getParameter<bool>("OverrideUserStackingAction")),
      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_kernel = G4RunManagerKernel::GetRunManagerKernel();
    if (m_kernel==0) m_kernel = new G4RunManagerKernel();
    
    m_CustomExceptionHandler = new ExceptionHandler(this) ;
    
    m_check = p.getUntrackedParameter<bool>("CheckOverlap",false);

    //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);
}

RunManager::~RunManager ( )

virtual

Definition at line 159 of file RunManager.cc.

References m_kernel.

{ 
    if (m_kernel!=0) delete m_kernel; 
}

Member Function Documentation

void RunManager::abortEvent

(

)

Definition at line 361 of file RunManager.cc.

References m_currentEvent, m_kernel, TrackingAction::PostUserTrackingAction(), hitfit::return, and lumiQTWidget::t.

Referenced by abortRun(), and OscarProducer::produce().

{

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

    return ;

}

void RunManager::abortRun

(

bool

softAbort = false

)

Definition at line 470 of file RunManager.cc.

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

Referenced by EventAction::BeginOfEventAction(), RunAction::BeginOfRunAction(), EventAction::EndOfEventAction(), RunAction::EndOfRunAction(), ExceptionHandler::Notify(), and produce().

{

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

const G4Event* RunManager::currentEvent ( ) const

inline

Definition at line 68 of file RunManager.h.

References m_currentEvent.

{ return m_currentEvent; }

const G4Run* RunManager::currentRun ( ) const

inline

Definition at line 64 of file RunManager.h.

References m_currentRun.

{ return m_currentRun; }

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

protected

Definition at line 317 of file RunManager.cc.

References alignCSCRings::e, 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 * e = new G4Event(inpevt.id().event());
  
  // std::vector< edm::Handle<edm::HepMCProduct> > AllHepMCEvt;
  edm::Handle<edm::HepMCProduct> HepMCEvt;
  
  // inpevt.getByType(HepMCEvt);       
  // inpevt.getManyByType(AllHepMCEvt);
  inpevt.getByLabel( m_InTag, HepMCEvt ) ;
  
  // actually, it's a double protection - it's not even necessary 
  // because getByLabel will throw if the correct product isn't there         
  if (!HepMCEvt.isValid())
    {
      throw SimG4Exception("Unable to find HepMCProduct(HepMC::GenEvent) in edm::Event  ");
    }
  else
    {
      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(),e);
        }
      else 
        {
          m_generator->nonBeamEvent2G4(HepMCEvt->GetEvent(),e);
        }
    }
  
  return e;
  
}

const Generator* RunManager::generator ( ) const

inline

Definition at line 67 of file RunManager.h.

References m_generator.

{ return m_generator; }

void RunManager::initG4

(

const edm::EventSetup &

es

)

Definition at line 167 of file RunManager.cc.

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

Referenced by OscarProducer::beginRun().

{

  bool geomChanged = idealGeomRcdWatcher_.check(es);
  if (geomChanged && (!firstRun)) {
    throw cms::Exception("BadConfig") 
      << "[SimG4Core RunManager]\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 RunManager]\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_pUseMagneticField)
    {
      // setup the magnetic field
      edm::ESHandle<MagneticField> pMF;
      es.get<IdealMagneticFieldRecord>().get(pMF);
      const GlobalPoint g(0.,0.,0.);

      // m_fieldBuilder = std::auto_ptr<sim::FieldBuilder>(new sim::FieldBuilder(&(*pMF), map_, m_pField));
      m_fieldBuilder = (new sim::FieldBuilder(&(*pMF), m_pField));
      G4TransportationManager * tM = G4TransportationManager::GetTransportationManager();
      m_fieldBuilder->build( tM->GetFieldManager(),tM->GetPropagatorInField() ) ;
      // m_fieldBuilder->configure("MagneticFieldType",tM->GetFieldManager(),tM->GetPropagatorInField());
    }

  // we need the track manager now
  m_trackManager = std::auto_ptr<SimTrackManager>(new SimTrackManager);

  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") << " RunManager: 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_generator = new Generator(m_pGenerator);
  // m_InTag = m_pGenerator.getParameter<edm::InputTag>("HepMCProductLabel") ;
  m_InTag = m_pGenerator.getParameter<std::string>("HepMCProductLabel") ;
  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);
  if (m_physicsList.get()==0) throw SimG4Exception("Physics list construction failed!");
  m_kernel->SetPhysics(m_physicsList.get());
  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") << "RunManager:: 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 RunManager::initializeRun

(

)

Definition at line 437 of file RunManager.cc.

References m_currentRun, m_runAborted, m_runInitialized, m_userRunAction, and hitfit::return.

Referenced by initG4().

{

    m_runInitialized = false;
    if (m_currentRun==0) m_currentRun = new G4Run();
    // m_currentRun->SetRunID(m_RunNumber);   // run on default runID=0; doesn't matter...
    G4StateManager::GetStateManager()->SetNewState(G4State_GeomClosed);
    if (m_userRunAction!=0) m_userRunAction->BeginOfRunAction(m_currentRun);
    m_runAborted = false;
    m_runInitialized = true;
    
    return ;
    
}

void RunManager::initializeUserActions

(

)

Definition at line 397 of file RunManager.cc.

References SimActivityRegistry::beginOfEventSignal_, SimActivityRegistry::beginOfRunSignal_, SimActivityRegistry::beginOfTrackSignal_, sim_act::Signaler< T >::connect(), SimActivityRegistry::endOfEventSignal_, SimActivityRegistry::endOfRunSignal_, SimActivityRegistry::endOfTrackSignal_, SimActivityRegistry::g4StepSignal_, EventAction::m_beginOfEventSignal, RunAction::m_beginOfRunSignal, TrackingAction::m_beginOfTrackSignal, EventAction::m_endOfEventSignal, RunAction::m_endOfRunSignal, TrackingAction::m_endOfTrackSignal, m_EvtMgrVerbosity, SteppingAction::m_g4StepSignal, m_generator, m_kernel, m_Override, m_pEventAction, m_pRunAction, m_pStackingAction, m_pSteppingAction, m_pTrackingAction, m_registry, m_trackManager, and m_userRunAction.

Referenced by initG4().

{

    RunAction* userRunAction = new RunAction(m_pRunAction,this);
    m_userRunAction = userRunAction;
    userRunAction->m_beginOfRunSignal.connect(m_registry.beginOfRunSignal_);
    userRunAction->m_endOfRunSignal.connect(m_registry.endOfRunSignal_);

    G4EventManager * eventManager = m_kernel->GetEventManager();
    eventManager->SetVerboseLevel(m_EvtMgrVerbosity);
    if (m_generator!=0)
    {
        EventAction * userEventAction = new EventAction(m_pEventAction,this,m_trackManager.get());
    //userEventAction->SetRunManager(this) ;
    userEventAction->m_beginOfEventSignal.connect(m_registry.beginOfEventSignal_);
    userEventAction->m_endOfEventSignal.connect(m_registry.endOfEventSignal_);
        eventManager->SetUserAction(userEventAction);
        TrackingAction* userTrackingAction = new TrackingAction(userEventAction,m_pTrackingAction);
    userTrackingAction->m_beginOfTrackSignal.connect(m_registry.beginOfTrackSignal_);
    userTrackingAction->m_endOfTrackSignal.connect(m_registry.endOfTrackSignal_);
    eventManager->SetUserAction(userTrackingAction);
    
    SteppingAction* userSteppingAction = new SteppingAction(userEventAction,m_pSteppingAction); 
    userSteppingAction->m_g4StepSignal.connect(m_registry.g4StepSignal_);
        eventManager->SetUserAction(userSteppingAction);
        if (m_Override)
        {
       edm::LogInfo("SimG4CoreApplication") << " RunManager: user StackingAction overridden " ;
            eventManager->SetUserAction(new StackingAction(m_pStackingAction));
        }
    }
    else 
    {
       edm::LogWarning("SimG4CoreApplication") << " RunManager: WARNING :  No generator; initialized only RunAction!";
    }
    
    return;

}

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

Definition at line 285 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().

Referenced by OscarProducer::produce().

{
    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") 
            << " RunManager::produce event " << inpevt.id().event()
            << " with no G4PrimaryVertices \n  Aborting Run" ;
       
       abortRun(false);
    }
    else
        m_kernel->GetEventManager()->ProcessOneEvent(m_currentEvent);

    
    edm::LogInfo("SimG4CoreApplication") 
         << " RunManager: 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> > RunManager::producers ( ) const

inline

Definition at line 73 of file RunManager.h.

References m_producers.

                                                               {
       return m_producers;
    }

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

protected

Definition at line 483 of file RunManager.cc.

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

Referenced by generateEvent().

                                                      {

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

}

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

inline

Definition at line 71 of file RunManager.h.

References m_sensCaloDets.

Referenced by OscarProducer::produce().

{ return m_sensCaloDets; }

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

inline

Definition at line 70 of file RunManager.h.

References m_sensTkDets.

Referenced by OscarProducer::produce().

{ return m_sensTkDets; }

G4SimEvent* RunManager::simEvent ( )

inline

Definition at line 69 of file RunManager.h.

References m_simEvent.

Referenced by EventAction::EndOfEventAction(), and OscarProducer::produce().

{ return m_simEvent; }

void RunManager::terminateRun

(

)

Definition at line 452 of file RunManager.cc.

References m_currentRun, m_kernel, m_runInitialized, m_runTerminated, and m_userRunAction.

{

    m_runTerminated = false;
    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_kernel->RunTermination();
    m_runInitialized = false;
    m_runTerminated = true;
    
    return;
    
}

Member Data Documentation

bool RunManager::firstRun

private

Definition at line 100 of file RunManager.h.

Referenced by initG4().

edm::ESWatcher<IdealGeometryRecord> RunManager::idealGeomRcdWatcher_

private

Definition at line 137 of file RunManager.h.

Referenced by initG4().

edm::ESWatcher<IdealMagneticFieldRecord> RunManager::idealMagRcdWatcher_

private

Definition at line 138 of file RunManager.h.

Referenced by initG4().

AttachSD* RunManager::m_attach

private

Definition at line 126 of file RunManager.h.

Referenced by initG4().

bool RunManager::m_check

private

Definition at line 111 of file RunManager.h.

Referenced by initG4(), and RunManager().

G4Event* RunManager::m_currentEvent

private

Definition at line 103 of file RunManager.h.

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

G4Run* RunManager::m_currentRun

private

Definition at line 102 of file RunManager.h.

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

ExceptionHandler* RunManager::m_CustomExceptionHandler

private

Definition at line 124 of file RunManager.h.

Referenced by RunManager().

int RunManager::m_EvtMgrVerbosity

private

Definition at line 109 of file RunManager.h.

Referenced by initializeUserActions().

sim::FieldBuilder* RunManager::m_fieldBuilder

private

Definition at line 135 of file RunManager.h.

Referenced by initG4().

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

private

Definition at line 122 of file RunManager.h.

Referenced by initG4().

Generator* RunManager::m_generator

private

Definition at line 87 of file RunManager.h.

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

std::string RunManager::m_InTag

private

Definition at line 89 of file RunManager.h.

Referenced by generateEvent(), and initG4().

G4RunManagerKernel* RunManager::m_kernel

private

Definition at line 85 of file RunManager.h.

Referenced by abortEvent(), initG4(), initializeUserActions(), produce(), RunManager(), terminateRun(), and ~RunManager().

bool RunManager::m_managerInitialized

private

Definition at line 94 of file RunManager.h.

Referenced by initG4().

bool RunManager::m_nonBeam

private

Definition at line 91 of file RunManager.h.

Referenced by generateEvent().

bool RunManager::m_Override

private

Definition at line 110 of file RunManager.h.

Referenced by initializeUserActions().

edm::ParameterSet RunManager::m_p

private

Definition at line 123 of file RunManager.h.

Referenced by initG4(), and RunManager().

edm::ParameterSet RunManager::m_pEventAction

private

Definition at line 118 of file RunManager.h.

Referenced by initializeUserActions().

edm::ParameterSet RunManager::m_pField

private

Definition at line 113 of file RunManager.h.

Referenced by initG4().

edm::ParameterSet RunManager::m_pGenerator

private

Definition at line 114 of file RunManager.h.

Referenced by initG4().

edm::ParameterSet RunManager::m_pGeometry

private

Definition at line 112 of file RunManager.h.

std::auto_ptr<PhysicsList> RunManager::m_physicsList

private

Definition at line 92 of file RunManager.h.

Referenced by initG4().

std::string RunManager::m_PhysicsTablesDir

private

Definition at line 106 of file RunManager.h.

Referenced by initG4().

edm::ParameterSet RunManager::m_pPhysics

private

Definition at line 116 of file RunManager.h.

Referenced by initG4().

PrimaryTransformer* RunManager::m_primaryTransformer

private

Definition at line 93 of file RunManager.h.

Referenced by initG4().

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

private

Definition at line 132 of file RunManager.h.

Referenced by producers(), and RunManager().

edm::ParameterSet RunManager::m_pRunAction

private

Definition at line 117 of file RunManager.h.

Referenced by initializeUserActions().

edm::ParameterSet RunManager::m_pStackingAction

private

Definition at line 119 of file RunManager.h.

Referenced by initializeUserActions().

edm::ParameterSet RunManager::m_pSteppingAction

private

Definition at line 121 of file RunManager.h.

Referenced by initializeUserActions().

edm::ParameterSet RunManager::m_pTrackingAction

private

Definition at line 120 of file RunManager.h.

Referenced by initializeUserActions().

bool RunManager::m_pUseMagneticField

private

Definition at line 101 of file RunManager.h.

Referenced by initG4().

edm::ParameterSet RunManager::m_pVertexGenerator

private

Definition at line 115 of file RunManager.h.

SimActivityRegistry RunManager::m_registry

private

Definition at line 130 of file RunManager.h.

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

bool RunManager::m_RestorePhysicsTables

private

Definition at line 108 of file RunManager.h.

Referenced by initG4().

bool RunManager::m_runAborted

private

Definition at line 99 of file RunManager.h.

Referenced by abortRun(), and initializeRun().

bool RunManager::m_runInitialized

private

Definition at line 97 of file RunManager.h.

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

bool RunManager::m_runTerminated

private

Definition at line 98 of file RunManager.h.

Referenced by terminateRun().

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

private

Definition at line 128 of file RunManager.h.

Referenced by initG4(), and sensCaloDetectors().

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

private

Definition at line 127 of file RunManager.h.

Referenced by initG4(), and sensTkDetectors().

G4SimEvent* RunManager::m_simEvent

private

Definition at line 104 of file RunManager.h.

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

bool RunManager::m_StorePhysicsTables

private

Definition at line 107 of file RunManager.h.

Referenced by initG4().

std::auto_ptr<SimTrackManager> RunManager::m_trackManager

private

Definition at line 134 of file RunManager.h.

Referenced by initG4(), initializeUserActions(), and resetGenParticleId().

G4UserRunAction* RunManager::m_userRunAction

private

Definition at line 105 of file RunManager.h.

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

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

private

Definition at line 131 of file RunManager.h.

Referenced by RunManager().