RunManagerMT Class Reference

#include <RunManagerMT.h>

Public Member Functions
void	abortRun (bool softAbort=false)
const SensitiveDetectorCatalog &	catalog () const
sim::ChordFinderSetter *	chordFinderSetterForWorker () const
void	Connect (RunAction *)
const std::vector< std::string > &	G4Commands () const
void	initG4 (const DDCompactView *pDD, const MagneticField *pMF, const HepPDT::ParticleDataTable *fPDGTable)
void	initializeUserActions ()
PhysicsList *	physicsListForWorker () const
	RunManagerMT (edm::ParameterSet const &p)
void	stopG4 ()
const DDDWorld &	world () const
	~RunManagerMT ()

Private Member Functions
void	DumpMagneticField (const G4Field *) const
void	terminateRun ()

Private Attributes
SensitiveDetectorCatalog	m_catalog
bool	m_check
std::unique_ptr < sim::ChordFinderSetter >	m_chordFinderSetter
G4Run *	m_currentRun
sim::FieldBuilder *	m_fieldBuilder
std::string	m_FieldFile
std::vector< std::string >	m_G4Commands
edm::ParameterSet	m_g4overlap
G4MTRunManagerKernel *	m_kernel
bool	m_managerInitialized
edm::ParameterSet	m_p
edm::ParameterSet	m_pField
std::unique_ptr< PhysicsList >	m_physicsList
const std::string	m_PhysicsTablesDir
edm::ParameterSet	m_pPhysics
std::unique_ptr < DDG4ProductionCuts >	m_prodCuts
edm::ParameterSet	m_pRunAction
bool	m_pUseMagneticField
std::string	m_RegionFile
SimActivityRegistry	m_registry
bool	m_RestorePhysicsTables
std::unique_ptr< SimRunInterface >	m_runInterface
bool	m_runTerminated
bool	m_StorePhysicsTables
std::unique_ptr< CustomUIsession >	m_UIsession
RunAction *	m_userRunAction
std::unique_ptr< DDDWorld >	m_world
std::string	m_WriteFile

Friends
class	RunManagerMTWorker

Detailed Description

Definition at line 60 of file RunManagerMT.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 61 of file RunManagerMT.cc.

References edm::ParameterSet::getUntrackedParameter(), m_check, m_currentRun, m_FieldFile, m_kernel, m_RegionFile, m_UIsession, m_WriteFile, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                   :
      m_managerInitialized(false), 
      m_runTerminated(false),
      m_pUseMagneticField(p.getParameter<bool>("UseMagneticField")),
      m_PhysicsTablesDir(p.getParameter<std::string>("PhysicsTablesDirectory")),
      m_StorePhysicsTables(p.getParameter<bool>("StorePhysicsTables")),
      m_RestorePhysicsTables(p.getParameter<bool>("RestorePhysicsTables")),
      m_pField(p.getParameter<edm::ParameterSet>("MagneticField")),
      m_pPhysics(p.getParameter<edm::ParameterSet>("Physics")),
      m_pRunAction(p.getParameter<edm::ParameterSet>("RunAction")),
      m_g4overlap(p.getParameter<edm::ParameterSet>("G4CheckOverlap")),
      m_G4Commands(p.getParameter<std::vector<std::string> >("G4Commands")),
      m_p(p),m_fieldBuilder(nullptr)
{    
  m_currentRun = nullptr;
  m_UIsession.reset(new CustomUIsession());
  m_kernel = new G4MTRunManagerKernel();

  m_check = p.getUntrackedParameter<bool>("CheckOverlap",false);
  m_WriteFile = p.getUntrackedParameter<std::string>("FileNameGDML","");
  m_FieldFile = p.getUntrackedParameter<std::string>("FileNameField","");
  m_RegionFile = p.getUntrackedParameter<std::string>("FileNameRegions","");
}

RunManagerMT::~RunManagerMT

(

)

Definition at line 85 of file RunManagerMT.cc.

References m_runTerminated, and terminateRun().

{
  if(!m_runTerminated) { terminateRun(); }
  G4StateManager::GetStateManager()->SetNewState(G4State_Quit);
  G4GeometryManager::GetInstance()->OpenGeometry();
}

Member Function Documentation

void RunManagerMT::abortRun ( bool  softAbort = false )

inline

Definition at line 78 of file RunManagerMT.h.

Referenced by ExceptionHandler::Notify().

{}

const SensitiveDetectorCatalog& RunManagerMT::catalog ( ) const

inline

Definition at line 84 of file RunManagerMT.h.

References m_catalog.

Referenced by RunManagerMTWorker::initializeThread().

                                                         {
    return m_catalog;
  }

sim::ChordFinderSetter* RunManagerMT::chordFinderSetterForWorker ( ) const

inline

Definition at line 103 of file RunManagerMT.h.

References m_chordFinderSetter.

Referenced by RunManagerMTWorker::initializeThread().

                                                                  {
    return m_chordFinderSetter.get();
  }

void RunManagerMT::Connect

(

RunAction *

runAction

)

Definition at line 231 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 SimRunInterface::Connect(), and initializeUserActions().

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

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

private

Definition at line 255 of file RunManagerMT.cc.

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

Referenced by initG4().

{
  std::ofstream fout(m_FieldFile.c_str(), std::ios::out);
  if(fout.fail()){
    edm::LogWarning("SimG4CoreApplication") 
      << " RunManager 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();
  }
}

const std::vector<std::string>& RunManagerMT::G4Commands ( ) const

inline

Definition at line 88 of file RunManagerMT.h.

References m_G4Commands.

                                                        {
    return m_G4Commands;
  }

void RunManagerMT::initG4	(	const DDCompactView *	pDD,
		const MagneticField *	pMF,
		const HepPDT::ParticleDataTable *	fPDGTable
	)

Definition at line 92 of file RunManagerMT.cc.

References RunAction::BeginOfRunAction(), sim::FieldBuilder::build(), trackerTree::check(), cmsHarvester::cmd, edm::errors::Configuration, beamerCreator::create(), SimActivityRegistry::dddWorldSignal_, dir, DumpMagneticField(), Exception, g, reco::get(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), recoMuon::in, initializeUserActions(), edm::errors::LogicError, m_catalog, m_check, m_chordFinderSetter, m_currentRun, m_fieldBuilder, m_FieldFile, m_G4Commands, m_g4overlap, m_kernel, m_managerInitialized, m_pField, m_physicsList, m_PhysicsTablesDir, m_pPhysics, m_prodCuts, m_pUseMagneticField, m_RegionFile, m_registry, m_RestorePhysicsTables, m_StorePhysicsTables, m_userRunAction, m_world, m_WriteFile, map_, G4RegionReporter::ReportRegions(), and AlCaHLTBitMon_QueryRunRegistry::string.

{
  if (m_managerInitialized) return;

  edm::LogInfo("SimG4CoreApplication") 
    << "RunManagerMT: start initialisation of geometry";
  
  // DDDWorld: get the DDCV from the ES and use it to build the World
  G4LogicalVolumeToDDLogicalPartMap map_;
  m_world.reset(new DDDWorld(pDD, map_, m_catalog, false));
  m_registry.dddWorldSignal_(m_world.get());

  // setup the magnetic field
  edm::LogInfo("SimG4CoreApplication") 
    << "RunManagerMT: start initialisation of magnetic field";

  if (m_pUseMagneticField)
    {
      const GlobalPoint g(0.,0.,0.);

      m_chordFinderSetter.reset(new sim::ChordFinderSetter());
      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());
      }
    }

  // Create physics list
  edm::LogInfo("SimG4CoreApplication") 
    << "RunManagerMT: create PhysicsList";

  std::unique_ptr<PhysicsListMakerBase>
    physicsMaker(PhysicsListFactory::get()->create(
      m_pPhysics.getParameter<std::string> ("type")));
  if (physicsMaker.get()==nullptr) {
    throw edm::Exception( edm::errors::Configuration ) 
      << "Unable to find the Physics list requested";
  }
  m_physicsList = 
    physicsMaker->make(map_,fPDGTable,m_chordFinderSetter.get(),m_pPhysics,m_registry);

  PhysicsList* phys = m_physicsList.get(); 
  if (phys==nullptr) { 
    throw edm::Exception( edm::errors::Configuration,
              "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_physicsList->ResetStoredInAscii();
  if (m_RestorePhysicsTables) {
    m_physicsList->SetPhysicsTableRetrieved(m_PhysicsTablesDir);
  }
  edm::LogInfo("SimG4CoreApplication") 
    << "RunManagerMT: start initialisation of PhysicsList for master";

  int verb = m_pPhysics.getUntrackedParameter<int>("Verbosity",0);

  m_physicsList->SetDefaultCutValue(m_pPhysics.getParameter<double>("DefaultCutValue")*CLHEP::cm);
  m_physicsList->SetCutsWithDefault();
  m_prodCuts.reset(new DDG4ProductionCuts(map_, verb, m_pPhysics)); 
  m_prodCuts->update();
  
  m_kernel->SetPhysics(phys);
  m_kernel->InitializePhysics();
  m_kernel->SetUpDecayChannels();

  // The following line was with the following comment in
  // G4MTRunManager::InitializePhysics() in 10.00.p01; in practice
  // needed to initialize certain singletons during the master thread
  // initialization in order to avoid races later...
  //
  //BERTINI, this is needed to create pseudo-particles, to be removed
  G4CascadeInterface::Initialize();

  if (m_kernel->RunInitialization()) { m_managerInitialized = true; }
  else { 
    throw edm::Exception( edm::errors::LogicError, 
              "G4RunManagerKernel initialization failed!"); 
  }

  if (m_StorePhysicsTables) {
    std::ostringstream dir;
    dir << m_PhysicsTablesDir << '\0';
    std::string cmd = std::string("/control/shell mkdir -p ")+m_PhysicsTablesDir;
    if (!std::ifstream(dir.str().c_str(), std::ios::in))
      G4UImanager::GetUIpointer()->ApplyCommand(cmd);
    m_physicsList->StorePhysicsTable(m_PhysicsTablesDir);
  }

  initializeUserActions();

  if(0 < m_G4Commands.size()) {
    G4cout << "RunManagerMT: Requested UI commands: " << G4endl;
    for (unsigned it=0; it<m_G4Commands.size(); ++it) {
      G4cout << "    " << m_G4Commands[it] << G4endl;
      G4UImanager::GetUIpointer()->ApplyCommand(m_G4Commands[it]);
    }
  }

  if(verb > 1) { m_physicsList->DumpCutValuesTable(); }

  // geometry dump
  if("" != m_WriteFile) {
    G4GDMLParser gdml(new G4GDMLReadStructure(), new CMSGDMLWriteStructure());
    gdml.Write(m_WriteFile, m_world->GetWorldVolume(), true);
  }

  // G4Region dump
  if("" != m_RegionFile) {
    G4RegionReporter rrep;
    rrep.ReportRegions(m_RegionFile);
  }

  // Intersection check
  if(m_check) { G4CheckOverlap check(m_g4overlap); }

  // If the Geant4 particle table is needed, decomment the lines below
  //
  //G4ParticleTable::GetParticleTable()->DumpTable("ALL");
  //
  G4StateManager::GetStateManager()->SetNewState(G4State_GeomClosed);
  m_currentRun = new G4Run(); 
  m_userRunAction->BeginOfRunAction(m_currentRun); 
}

void RunManagerMT::initializeUserActions

(

)

Definition at line 225 of file RunManagerMT.cc.

References Connect(), m_pRunAction, m_runInterface, and m_userRunAction.

Referenced by initG4().

                                         {
  m_runInterface.reset(new SimRunInterface(this, true));
  m_userRunAction = new RunAction(m_pRunAction, m_runInterface.get());
  Connect(m_userRunAction);
}

PhysicsList* RunManagerMT::physicsListForWorker ( ) const

inline

Definition at line 95 of file RunManagerMT.h.

References m_physicsList.

Referenced by RunManagerMTWorker::initializeThread().

                                                   {
    return m_physicsList.get();
  }

void RunManagerMT::stopG4

(

)

Definition at line 237 of file RunManagerMT.cc.

References m_runTerminated, and terminateRun().

{
  G4StateManager::GetStateManager()->SetNewState(G4State_Quit);
  if(!m_runTerminated) { terminateRun(); }
}

void RunManagerMT::terminateRun ( )

private

Definition at line 243 of file RunManagerMT.cc.

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

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

                                {
  if(m_userRunAction) {
    m_userRunAction->EndOfRunAction(m_currentRun);
    delete m_userRunAction;
    m_userRunAction = nullptr;
  }
  if(m_kernel && !m_runTerminated) {
    m_kernel->RunTermination();
  }
  m_runTerminated = true;
}

const DDDWorld& RunManagerMT::world ( ) const

inline

Definition at line 80 of file RunManagerMT.h.

References m_world.

Referenced by RunManagerMTWorker::initializeThread().

                                       {
    return *m_world;
  }

Friends And Related Function Documentation

friend class RunManagerMTWorker

friend

Definition at line 62 of file RunManagerMT.h.

Member Data Documentation

SensitiveDetectorCatalog RunManagerMT::m_catalog

private

Definition at line 136 of file RunManagerMT.h.

Referenced by catalog(), and initG4().

bool RunManagerMT::m_check

private

Definition at line 125 of file RunManagerMT.h.

Referenced by initG4(), and RunManagerMT().

std::unique_ptr<sim::ChordFinderSetter> RunManagerMT::m_chordFinderSetter

private

Definition at line 139 of file RunManagerMT.h.

Referenced by chordFinderSetterForWorker(), and initG4().

G4Run* RunManagerMT::m_currentRun

private

Definition at line 119 of file RunManagerMT.h.

Referenced by initG4(), RunManagerMT(), and terminateRun().

sim::FieldBuilder* RunManagerMT::m_fieldBuilder

private

Definition at line 138 of file RunManagerMT.h.

Referenced by initG4().

std::string RunManagerMT::m_FieldFile

private

Definition at line 141 of file RunManagerMT.h.

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

std::vector<std::string> RunManagerMT::m_G4Commands

private

Definition at line 130 of file RunManagerMT.h.

Referenced by G4Commands(), and initG4().

edm::ParameterSet RunManagerMT::m_g4overlap

private

Definition at line 129 of file RunManagerMT.h.

Referenced by initG4().

G4MTRunManagerKernel* RunManagerMT::m_kernel

private

Definition at line 111 of file RunManagerMT.h.

Referenced by initG4(), RunManagerMT(), and terminateRun().

bool RunManagerMT::m_managerInitialized

private

Definition at line 115 of file RunManagerMT.h.

Referenced by initG4().

edm::ParameterSet RunManagerMT::m_p

private

Definition at line 131 of file RunManagerMT.h.

edm::ParameterSet RunManagerMT::m_pField

private

Definition at line 126 of file RunManagerMT.h.

Referenced by initG4().

std::unique_ptr<PhysicsList> RunManagerMT::m_physicsList

private

Definition at line 114 of file RunManagerMT.h.

Referenced by initG4(), and physicsListForWorker().

const std::string RunManagerMT::m_PhysicsTablesDir

private

Definition at line 122 of file RunManagerMT.h.

Referenced by initG4().

edm::ParameterSet RunManagerMT::m_pPhysics

private

Definition at line 127 of file RunManagerMT.h.

Referenced by initG4().

std::unique_ptr<DDG4ProductionCuts> RunManagerMT::m_prodCuts

private

Definition at line 134 of file RunManagerMT.h.

Referenced by initG4().

edm::ParameterSet RunManagerMT::m_pRunAction

private

Definition at line 128 of file RunManagerMT.h.

Referenced by initializeUserActions().

bool RunManagerMT::m_pUseMagneticField

private

Definition at line 117 of file RunManagerMT.h.

Referenced by initG4().

std::string RunManagerMT::m_RegionFile

private

Definition at line 143 of file RunManagerMT.h.

Referenced by initG4(), and RunManagerMT().

SimActivityRegistry RunManagerMT::m_registry

private

Definition at line 135 of file RunManagerMT.h.

Referenced by Connect(), and initG4().

bool RunManagerMT::m_RestorePhysicsTables

private

Definition at line 124 of file RunManagerMT.h.

Referenced by initG4().

std::unique_ptr<SimRunInterface> RunManagerMT::m_runInterface

private

Definition at line 120 of file RunManagerMT.h.

Referenced by initializeUserActions().

bool RunManagerMT::m_runTerminated

private

Definition at line 116 of file RunManagerMT.h.

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

bool RunManagerMT::m_StorePhysicsTables

private

Definition at line 123 of file RunManagerMT.h.

Referenced by initG4().

std::unique_ptr<CustomUIsession> RunManagerMT::m_UIsession

private

Definition at line 113 of file RunManagerMT.h.

Referenced by RunManagerMT().

RunAction* RunManagerMT::m_userRunAction

private

Definition at line 118 of file RunManagerMT.h.

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

std::unique_ptr<DDDWorld> RunManagerMT::m_world

private

Definition at line 133 of file RunManagerMT.h.

Referenced by initG4(), and world().

std::string RunManagerMT::m_WriteFile

private

Definition at line 142 of file RunManagerMT.h.

Referenced by initG4(), and RunManagerMT().