OscarMTProducer Class Reference

Inheritance diagram for OscarMTProducer:

Public Types
typedef std::vector< std::shared_ptr< SimProducer > >	Producers
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< OscarMTMasterThread >, edm::RunCache< int > >
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Public Member Functions
void	beginRun (const edm::Run &r, const edm::EventSetup &c) override
void	endRun (const edm::Run &r, const edm::EventSetup &c) override
	OscarMTProducer (edm::ParameterSet const &p, const OscarMTMasterThread *)
void	produce (edm::Event &e, const edm::EventSetup &c) override
	~OscarMTProducer () override
Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< OscarMTMasterThread >, edm::RunCache< int > >
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static std::shared_ptr< int >	globalBeginRun (const edm::Run &iRun, const edm::EventSetup &iSetup, const OscarMTMasterThread *masterThread)
static void	globalEndJob (OscarMTMasterThread *masterThread)
static void	globalEndRun (const edm::Run &iRun, const edm::EventSetup &iSetup, const RunContext *iContext)
static std::unique_ptr< OscarMTMasterThread >	initializeGlobalCache (const edm::ParameterSet &iConfig)

Private Attributes
omt::ThreadHandoff	m_handoff
const OscarMTMasterThread *	m_masterThread
const edm::ParameterSetID	m_psetID
std::unique_ptr< RunManagerMTWorker >	m_runManagerWorker
int	m_verbose

Static Private Attributes
static const OscarMTMasterThread *	s_masterThread = nullptr
static edm::ParameterSetID	s_psetID {}

Detailed Description

Definition at line 43 of file OscarMTProducer.cc.

Member Typedef Documentation

Producers

typedef std::vector<std::shared_ptr<SimProducer> > OscarMTProducer::Producers

Definition at line 45 of file OscarMTProducer.cc.

Constructor & Destructor Documentation

OscarMTProducer()

OscarMTProducer::OscarMTProducer ( edm::ParameterSet const &  p, const OscarMTMasterThread *  ms  )

explicit

Definition at line 109 of file OscarMTProducer.cc.

References AlCaHLTBitMon_ParallelJobs::p.

    : m_handoff{p.getUntrackedParameter<int>("workerThreadStackSize", 10 * 1024 * 1024)}, m_psetID{p.id()} {
  m_verbose = p.getParameter<int>("EventVerbose");
  // Random number generation not allowed here
  StaticRandomEngineSetUnset random(nullptr);

  auto token = edm::ServiceRegistry::instance().presentToken();
  m_handoff.runAndWait([this, &p, token]() {
    edm::ServiceRegistry::Operate guard{token};
    StaticRandomEngineSetUnset random(nullptr);
    m_runManagerWorker = std::make_unique<RunManagerMTWorker>(p, consumesCollector());
  });
  m_masterThread = ms ? ms : s_masterThread;
  assert(m_masterThread);
  m_masterThread->callConsumes(consumesCollector());

  // List of produced containers
  produces<edm::SimTrackContainer>().setBranchAlias("SimTracks");
  produces<edm::SimVertexContainer>().setBranchAlias("SimVertices");
  produces<edm::PSimHitContainer>("TrackerHitsPixelBarrelLowTof");
  produces<edm::PSimHitContainer>("TrackerHitsPixelBarrelHighTof");
  produces<edm::PSimHitContainer>("TrackerHitsTIBLowTof");
  produces<edm::PSimHitContainer>("TrackerHitsTIBHighTof");
  produces<edm::PSimHitContainer>("TrackerHitsTIDLowTof");
  produces<edm::PSimHitContainer>("TrackerHitsTIDHighTof");
  produces<edm::PSimHitContainer>("TrackerHitsPixelEndcapLowTof");
  produces<edm::PSimHitContainer>("TrackerHitsPixelEndcapHighTof");
  produces<edm::PSimHitContainer>("TrackerHitsTOBLowTof");
  produces<edm::PSimHitContainer>("TrackerHitsTOBHighTof");
  produces<edm::PSimHitContainer>("TrackerHitsTECLowTof");
  produces<edm::PSimHitContainer>("TrackerHitsTECHighTof");

  produces<edm::PSimHitContainer>("TotemHitsT1");
  produces<edm::PSimHitContainer>("TotemHitsT2Gem");
  produces<edm::PSimHitContainer>("TotemHitsRP");
  produces<edm::PSimHitContainer>("CTPPSPixelHits");
  produces<edm::PSimHitContainer>("CTPPSTimingHits");
  produces<edm::PSimHitContainer>("FP420SI");
  produces<edm::PSimHitContainer>("BSCHits");
  produces<edm::PSimHitContainer>("PLTHits");
  produces<edm::PSimHitContainer>("BCM1FHits");
  produces<edm::PSimHitContainer>("BHMHits");
  produces<edm::PSimHitContainer>("FastTimerHitsBarrel");
  produces<edm::PSimHitContainer>("FastTimerHitsEndcap");

  produces<edm::PCaloHitContainer>("EcalHitsEB");
  produces<edm::PCaloHitContainer>("EcalHitsEE");
  produces<edm::PCaloHitContainer>("EcalHitsES");
  produces<edm::PCaloHitContainer>("HcalHits");
  produces<edm::PCaloHitContainer>("CaloHitsTk");
  produces<edm::PCaloHitContainer>("HGCHitsEE");
  produces<edm::PCaloHitContainer>("HGCHitsHEfront");
  produces<edm::PCaloHitContainer>("HGCHitsHEback");

  produces<edm::PSimHitContainer>("MuonDTHits");
  produces<edm::PSimHitContainer>("MuonCSCHits");
  produces<edm::PSimHitContainer>("MuonRPCHits");
  produces<edm::PSimHitContainer>("MuonGEMHits");
  produces<edm::PSimHitContainer>("MuonME0Hits");
  produces<edm::PCaloHitContainer>("CastorPL");
  produces<edm::PCaloHitContainer>("CastorFI");
  produces<edm::PCaloHitContainer>("CastorBU");
  produces<edm::PCaloHitContainer>("CastorTU");
  produces<edm::PCaloHitContainer>("EcalTBH4BeamHits");
  produces<edm::PCaloHitContainer>("HcalTB06BeamHits");
  produces<edm::PCaloHitContainer>("ZDCHITS");
  produces<edm::PCaloHitContainer>("ChamberHits");
  produces<edm::PCaloHitContainer>("FibreHits");
  produces<edm::PCaloHitContainer>("WedgeHits");
  produces<edm::PCaloHitContainer>("HFNoseHits");
  produces<edm::PCaloHitContainer>("TotemHitsT2Scint");

  //register any products
  auto& producers = m_runManagerWorker->producers();
  for (auto& ptr : producers) {
    ptr->registerProducts(producesCollector());
  }
  edm::LogVerbatim("SimG4CoreApplication") << "OscarMTProducer is constructed";
}

~OscarMTProducer()

OscarMTProducer::~OscarMTProducer ( )

override

Definition at line 189 of file OscarMTProducer.cc.

References edm::ServiceRegistry::instance(), m_handoff, m_runManagerWorker, edm::ServiceRegistry::presentToken(), omt::ThreadHandoff::runAndWait(), and unpackBuffers-CaloStage2::token.

                                  {
  auto token = edm::ServiceRegistry::instance().presentToken();
  m_handoff.runAndWait([this, token]() {
    edm::ServiceRegistry::Operate guard{token};
    m_runManagerWorker.reset();
  });
}

Member Function Documentation

beginRun()

void OscarMTProducer::beginRun ( const edm::Run &  r, const edm::EventSetup &  c  )

override

Definition at line 237 of file OscarMTProducer.cc.

References Exception, l1ctLayer2EG_cff::id, edm::ServiceRegistry::instance(), m_handoff, m_masterThread, m_psetID, m_runManagerWorker, edm::ServiceRegistry::presentToken(), omt::ThreadHandoff::runAndWait(), OscarMTMasterThread::runManagerMasterPtr(), s_psetID, and unpackBuffers-CaloStage2::token.

                                                                     {
  if (s_psetID != m_psetID) {
    throw cms::Exception("DiffOscarMTProducers")
        << "At least two different OscarMTProducer instances have been"
           "loaded into the job and they have different configurations.\n"
           " All OscarMTProducers in a job must have exactly the same configuration.";
  }
  int id = m_runManagerWorker->getThreadIndex();
  edm::LogVerbatim("SimG4CoreApplication") << "OscarMTProducer::beginRun threadID=" << id;
  auto token = edm::ServiceRegistry::instance().presentToken();
  m_handoff.runAndWait([this, &es, token]() {
    edm::ServiceRegistry::Operate guard{token};
    m_runManagerWorker->beginRun(es);
    m_runManagerWorker->initializeG4(m_masterThread->runManagerMasterPtr(), es);
  });
  edm::LogVerbatim("SimG4CoreApplication") << "OscarMTProducer::beginRun done threadID=" << id;
}

endRun()

void OscarMTProducer::endRun ( const edm::Run &  r, const edm::EventSetup &  c  )

override

Definition at line 255 of file OscarMTProducer.cc.

References l1ctLayer2EG_cff::id, edm::ServiceRegistry::instance(), m_handoff, m_runManagerWorker, edm::ServiceRegistry::presentToken(), omt::ThreadHandoff::runAndWait(), and unpackBuffers-CaloStage2::token.

                                                                {
  StaticRandomEngineSetUnset random(nullptr);
  int id = m_runManagerWorker->getThreadIndex();
  edm::LogVerbatim("SimG4CoreApplication") << "OscarMTProducer::endRun threadID=" << id;
  auto token = edm::ServiceRegistry::instance().presentToken();
  m_handoff.runAndWait([this, token]() {
    edm::ServiceRegistry::Operate guard{token};
    m_runManagerWorker->endRun();
  });
  edm::LogVerbatim("SimG4CoreApplication") << "OscarMTProducer::endRun done threadID=" << id;
}

globalBeginRun()

std::shared_ptr< int > OscarMTProducer::globalBeginRun ( const edm::Run &  iRun, const edm::EventSetup &  iSetup, const OscarMTMasterThread *  masterThread  )

static

Definition at line 210 of file OscarMTProducer.cc.

References OscarMTMasterThread::beginRun().

                                                                                              {
  // Random number generation not allowed here
  StaticRandomEngineSetUnset random(nullptr);
  edm::LogVerbatim("SimG4CoreApplication") << "OscarMTProducer::globalBeginRun";
  if (masterThread) {
    masterThread->beginRun(iSetup);
  }
  edm::LogVerbatim("SimG4CoreApplication") << "OscarMTProducer::globalBeginRun done";
  return std::shared_ptr<int>();
}

globalEndJob()

void OscarMTProducer::globalEndJob ( OscarMTMasterThread *  masterThread )

static

Definition at line 230 of file OscarMTProducer.cc.

References OscarMTMasterThread::stopThread().

                                                                    {
  edm::LogVerbatim("SimG4CoreApplication") << "OscarMTProducer::globalEndJob";
  if (masterThread) {
    masterThread->stopThread();
  }
}

globalEndRun()

void OscarMTProducer::globalEndRun ( const edm::Run &  iRun, const edm::EventSetup &  iSetup, const RunContext *  iContext  )

static

Definition at line 223 of file OscarMTProducer.cc.

References edm::stream::RunContextT< R, G >::global().

                                                                                                  {
  edm::LogVerbatim("SimG4CoreApplication") << "OscarMTProducer::globalEndRun";
  if (nullptr != iContext->global()) {
    iContext->global()->endRun();
  }
}

initializeGlobalCache()

std::unique_ptr< OscarMTMasterThread > OscarMTProducer::initializeGlobalCache ( const edm::ParameterSet &  iConfig )

static

Definition at line 197 of file OscarMTProducer.cc.

References edm::ParameterSet::id(), runTheMatrix::ret, s_masterThread, and s_psetID.

                                                                                                        {
  // Random number generation not allowed here
  StaticRandomEngineSetUnset random(nullptr);
  edm::LogVerbatim("SimG4CoreApplication") << "OscarMTProducer::initializeGlobalCache";
  if (nullptr == s_masterThread) {
    auto ret = std::make_unique<OscarMTMasterThread>(iConfig);
    s_masterThread = ret.get();
    s_psetID = iConfig.id();
    return ret;
  }
  return {};
}

produce()

void OscarMTProducer::produce ( edm::Event &  e, const edm::EventSetup &  c  )

override

Definition at line 267 of file OscarMTProducer.cc.

References MillePedeFileConverter_cfg::e, mps_fire::i, l1ctLayer2EG_cff::id, edm::ServiceRegistry::instance(), G4SimEvent::load(), m_handoff, m_masterThread, m_runManagerWorker, m_verbose, eostools::move(), Skims_PA_cff::name, groupFilesInBlocks::nn, LaserDQM_cfg::p1, SiStripOfflineCRack_cfg::p2, edm::ServiceRegistry::presentToken(), dumpMFGeometry_cfg::prod, HLT_2022v15_cff::producers, omt::ThreadHandoff::runAndWait(), OscarMTMasterThread::runManagerMaster(), unpackBuffers-CaloStage2::token, PbPb_ZMuSkimMuonDPG_cff::tracker, and findQualityFiles::v.

                                                                  {
  StaticRandomEngineSetUnset random(e.streamID());
  auto engine = random.currentEngine();
  int id = m_runManagerWorker->getThreadIndex();
  if (0 < m_verbose) {
    edm::LogVerbatim("SimG4CoreApplication")
        << "Produce event " << e.id() << " stream " << e.streamID() << " threadID=" << id;
    //edm::LogVerbatim("SimG4CoreApplication") << " rand= " << G4UniformRand();
  }

  auto& sTk = m_runManagerWorker->sensTkDetectors();
  auto& sCalo = m_runManagerWorker->sensCaloDetectors();

  G4SimEvent* evt = nullptr;
  auto token = edm::ServiceRegistry::instance().presentToken();
  m_handoff.runAndWait([this, &e, &es, &evt, token, engine]() {
    edm::ServiceRegistry::Operate guard{token};
    StaticRandomEngineSetUnset random(engine);
    evt = m_runManagerWorker->produce(e, es, m_masterThread->runManagerMaster());
  });

  std::unique_ptr<edm::SimTrackContainer> p1(new edm::SimTrackContainer);
  std::unique_ptr<edm::SimVertexContainer> p2(new edm::SimVertexContainer);
  evt->load(*p1);
  evt->load(*p2);

  if (0 < m_verbose) {
    edm::LogVerbatim("SimG4CoreApplication") << "Produced " << p2->size() << " SimVertex objects";
    if (1 < m_verbose) {
      int nn = p2->size();
      for (int i = 0; i < nn; ++i) {
        edm::LogVerbatim("Vertex") << " " << (*p2)[i] << " " << (*p2)[i].processType();
      }
    }
    edm::LogVerbatim("SimG4CoreApplication") << "Produced " << p1->size() << " SimTrack objects";
    if (1 < m_verbose) {
      int nn = p1->size();
      for (int i = 0; i < nn; ++i) {
        edm::LogVerbatim("Track") << " " << i << ". " << (*p1)[i] << " " << (*p1)[i].crossedBoundary() << " "
                                  << (*p1)[i].getIDAtBoundary();
      }
    }
  }
  e.put(std::move(p1));
  e.put(std::move(p2));

  for (auto& tracker : sTk) {
    const std::vector<std::string>& v = tracker->getNames();
    for (auto& name : v) {
      std::unique_ptr<edm::PSimHitContainer> product(new edm::PSimHitContainer);
      tracker->fillHits(*product, name);
      if (0 < m_verbose && product != nullptr && !product->empty())
        edm::LogVerbatim("SimG4CoreApplication") << "Produced " << product->size() << " tracker hits <" << name << ">";
      e.put(std::move(product), name);
    }
  }
  for (auto& calo : sCalo) {
    const std::vector<std::string>& v = calo->getNames();
    for (auto& name : v) {
      std::unique_ptr<edm::PCaloHitContainer> product(new edm::PCaloHitContainer);
      calo->fillHits(*product, name);
      if (0 < m_verbose && product != nullptr && !product->empty())
        edm::LogVerbatim("SimG4CoreApplication") << "Produced " << product->size() << " calo hits <" << name << ">";
      e.put(std::move(product), name);
    }
  }

  auto& producers = m_runManagerWorker->producers();
  for (auto& prod : producers) {
    prod.get()->produce(e, es);
  }
  if (0 < m_verbose) {
    edm::LogVerbatim("SimG4CoreApplication")
        << "Event is produced event " << e.id() << " streamID=" << e.streamID() << " threadID=" << id;
    //edm::LogVerbatim("SimG4CoreApplication") << " rand= " << G4UniformRand();
  }
}

Member Data Documentation

m_handoff

omt::ThreadHandoff OscarMTProducer::m_handoff

private

Definition at line 62 of file OscarMTProducer.cc.

Referenced by beginRun(), endRun(), produce(), and ~OscarMTProducer().

m_masterThread

const OscarMTMasterThread* OscarMTProducer::m_masterThread

private

Definition at line 64 of file OscarMTProducer.cc.

Referenced by beginRun(), and produce().

m_psetID

const edm::ParameterSetID OscarMTProducer::m_psetID

private

Definition at line 65 of file OscarMTProducer.cc.

Referenced by beginRun().

m_runManagerWorker

std::unique_ptr<RunManagerMTWorker> OscarMTProducer::m_runManagerWorker

private

Definition at line 63 of file OscarMTProducer.cc.

Referenced by beginRun(), endRun(), produce(), and ~OscarMTProducer().

m_verbose

int OscarMTProducer::m_verbose

private

Definition at line 66 of file OscarMTProducer.cc.

Referenced by produce().

s_masterThread

const OscarMTMasterThread * OscarMTProducer::s_masterThread = nullptr

staticprivate

Definition at line 67 of file OscarMTProducer.cc.

Referenced by initializeGlobalCache().

s_psetID

edm::ParameterSetID OscarMTProducer::s_psetID {}

staticprivate

Definition at line 68 of file OscarMTProducer.cc.

Referenced by beginRun(), and initializeGlobalCache().