src/stream/EDAnalyzerAdaptorBase.cc

0001 // -*- C++ -*-
0002 //
0003 // Package:     FWCore/Framework
0004 // Class  :     edm::stream::EDAnalyzerAdaptorBase
0005 //
0006 // Implementation:
0007 //     [Notes on implementation]
0008 //
0009 // Original Author:  Chris Jones
0010 //         Created:  Fri, 02 Aug 2013 21:43:44 GMT
0011 //
0012
0013 // system include files
0014 #include <cassert>
0015
0016 // user include files
0017 #include "FWCore/Framework/interface/stream/EDAnalyzerAdaptorBase.h"
0018 #include "FWCore/Framework/interface/stream/EDAnalyzerBase.h"
0019 #include "FWCore/Framework/interface/Event.h"
0020 #include "FWCore/Framework/interface/LuminosityBlock.h"
0021 #include "FWCore/Framework/interface/Run.h"
0022 #include "FWCore/Framework/interface/EventSetup.h"
0023 #include "FWCore/Framework/interface/EventPrincipal.h"
0024 #include "FWCore/Framework/interface/LuminosityBlockPrincipal.h"
0025 #include "FWCore/Framework/interface/RunPrincipal.h"
0026 #include "FWCore/ServiceRegistry/interface/ESParentContext.h"
0027 #include "FWCore/ServiceRegistry/interface/ModuleConsumesInfo.h"
0028
0029 #include "FWCore/Framework/interface/PreallocationConfiguration.h"
0030 #include "FWCore/Framework/src/EventSignalsSentry.h"
0031 #include "FWCore/Framework/interface/TransitionInfoTypes.h"
0032
0033 using namespace edm::stream;
0034 //
0035 // constants, enums and typedefs
0036 //
0037
0038 //
0039 // static data member definitions
0040 //
0041
0042 //
0043 // constructors and destructor
0044 //
0045 EDAnalyzerAdaptorBase::EDAnalyzerAdaptorBase() {}
0046
0047 // EDAnalyzerAdaptorBase::EDAnalyzerAdaptorBase(const EDAnalyzerAdaptorBase& rhs)
0048 // {
0049 //    // do actual copying here;
0050 // }
0051
0052 EDAnalyzerAdaptorBase::~EDAnalyzerAdaptorBase() {
0053   for (auto m : m_streamModules) {
0054     delete m;
0055   }
0056 }
0057
0058 void EDAnalyzerAdaptorBase::deleteModulesEarly() {
0059   for (auto m : m_streamModules) {
0060     delete m;
0061   }
0062   m_streamModules.clear();
0063 }
0064
0065 //
0066 // assignment operators
0067 //
0068 // const EDAnalyzerAdaptorBase& EDAnalyzerAdaptorBase::operator=(const EDAnalyzerAdaptorBase& rhs)
0069 // {
0070 //   //An exception safe implementation is
0071 //   EDAnalyzerAdaptorBase temp(rhs);
0072 //   swap(rhs);
0073 //
0074 //   return *this;
0075 // }
0076
0077 //
0078 // member functions
0079 //
0080 void EDAnalyzerAdaptorBase::doPreallocate(PreallocationConfiguration const& iPrealloc) {
0081   m_streamModules.resize(iPrealloc.numberOfStreams(), static_cast<stream::EDAnalyzerBase*>(nullptr));
0082   setupStreamModules();
0083   preallocRuns(iPrealloc.numberOfRuns());
0084   preallocLumis(iPrealloc.numberOfLuminosityBlocks());
0085 }
0086
0087 void EDAnalyzerAdaptorBase::registerProductsAndCallbacks(EDAnalyzerAdaptorBase const*,
0088                                                          SignallingProductRegistryFiller* reg) {
0089   for (auto mod : m_streamModules) {
0090     mod->registerProductsAndCallbacks(mod, reg);
0091   }
0092 }
0093
0094 void EDAnalyzerAdaptorBase::itemsToGet(BranchType iType, std::vector<ProductResolverIndexAndSkipBit>& iIndices) const {
0095   assert(not m_streamModules.empty());
0096   m_streamModules[0]->itemsToGet(iType, iIndices);
0097 }
0098 void EDAnalyzerAdaptorBase::itemsMayGet(BranchType iType, std::vector<ProductResolverIndexAndSkipBit>& iIndices) const {
0099   assert(not m_streamModules.empty());
0100   m_streamModules[0]->itemsMayGet(iType, iIndices);
0101 }
0102
0103 std::vector<edm::ProductResolverIndexAndSkipBit> const& EDAnalyzerAdaptorBase::itemsToGetFrom(BranchType iType) const {
0104   assert(not m_streamModules.empty());
0105   return m_streamModules[0]->itemsToGetFrom(iType);
0106 }
0107
0108 std::vector<edm::ESResolverIndex> const& EDAnalyzerAdaptorBase::esGetTokenIndicesVector(edm::Transition iTrans) const {
0109   assert(not m_streamModules.empty());
0110   return m_streamModules[0]->esGetTokenIndicesVector(iTrans);
0111 }
0112
0113 std::vector<edm::ESRecordIndex> const& EDAnalyzerAdaptorBase::esGetTokenRecordIndicesVector(
0114     edm::Transition iTrans) const {
0115   assert(not m_streamModules.empty());
0116   return m_streamModules[0]->esGetTokenRecordIndicesVector(iTrans);
0117 }
0118
0119 void EDAnalyzerAdaptorBase::updateLookup(BranchType iType,
0120                                          ProductResolverIndexHelper const& iHelper,
0121                                          bool iPrefetchMayGet) {
0122   for (auto mod : m_streamModules) {
0123     mod->updateLookup(iType, iHelper, iPrefetchMayGet);
0124   }
0125 }
0126
0127 void EDAnalyzerAdaptorBase::updateLookup(eventsetup::ESRecordsToProductResolverIndices const& iPI) {
0128   for (auto mod : m_streamModules) {
0129     mod->updateLookup(iPI);
0130   }
0131 }
0132
0133 void EDAnalyzerAdaptorBase::releaseMemoryPostLookupSignal() {
0134   for (auto mod : m_streamModules) {
0135     mod->releaseMemoryPostLookupSignal();
0136   }
0137 }
0138
0139 const edm::EDConsumerBase* EDAnalyzerAdaptorBase::consumer() const { return m_streamModules[0]; }
0140
0141 void EDAnalyzerAdaptorBase::convertCurrentProcessAlias(std::string const& processName) {
0142   for (auto mod : m_streamModules) {
0143     mod->convertCurrentProcessAlias(processName);
0144   }
0145 }
0146
0147 std::vector<edm::ModuleConsumesInfo> EDAnalyzerAdaptorBase::moduleConsumesInfos() const {
0148   assert(not m_streamModules.empty());
0149   return m_streamModules[0]->moduleConsumesInfos();
0150 }
0151
0152 std::vector<edm::ModuleConsumesMinimalESInfo> EDAnalyzerAdaptorBase::moduleConsumesMinimalESInfos() const {
0153   assert(not m_streamModules.empty());
0154   return m_streamModules[0]->moduleConsumesMinimalESInfos();
0155 }
0156
0157 bool EDAnalyzerAdaptorBase::doEvent(EventTransitionInfo const& info,
0158                                     ActivityRegistry* act,
0159                                     ModuleCallingContext const* mcc) {
0160   EventPrincipal const& ep = info.principal();
0161   assert(ep.streamID() < m_streamModules.size());
0162   auto mod = m_streamModules[ep.streamID()];
0163   EventSignalsSentry sentry(act, mcc);
0164   Event e(ep, moduleDescription_, mcc);
0165   e.setConsumer(mod);
0166   ESParentContext parentC(mcc);
0167   const EventSetup c{
0168       info, static_cast<unsigned int>(Transition::Event), mod->esGetTokenIndices(Transition::Event), parentC};
0169   mod->analyze(e, c);
0170   return true;
0171 }
0172
0173 void EDAnalyzerAdaptorBase::doBeginStream(StreamID id) { m_streamModules[id]->beginStream(id); }
0174 void EDAnalyzerAdaptorBase::doEndStream(StreamID id) { m_streamModules[id]->endStream(); }
0175
0176 void EDAnalyzerAdaptorBase::doStreamBeginRun(StreamID id,
0177                                              RunTransitionInfo const& info,
0178                                              ModuleCallingContext const* mcc) {
0179   RunPrincipal const& rp = info.principal();
0180   auto mod = m_streamModules[id];
0181   setupRun(mod, rp.index());
0182
0183   Run r(rp, moduleDescription_, mcc, false);
0184   ESParentContext parentC(mcc);
0185   const EventSetup c{
0186       info, static_cast<unsigned int>(Transition::BeginRun), mod->esGetTokenIndices(Transition::BeginRun), parentC};
0187   r.setConsumer(mod);
0188   mod->beginRun(r, c);
0189 }
0190
0191 void EDAnalyzerAdaptorBase::doStreamEndRun(StreamID id,
0192                                            RunTransitionInfo const& info,
0193                                            ModuleCallingContext const* mcc) {
0194   auto mod = m_streamModules[id];
0195   Run r(info, moduleDescription_, mcc, true);
0196   r.setConsumer(mod);
0197   ESParentContext parentC(mcc);
0198   const EventSetup c{
0199       info, static_cast<unsigned int>(Transition::EndRun), mod->esGetTokenIndices(Transition::EndRun), parentC};
0200   mod->endRun(r, c);
0201   streamEndRunSummary(mod, r, c);
0202 }
0203
0204 void EDAnalyzerAdaptorBase::doStreamBeginLuminosityBlock(StreamID id,
0205                                                          LumiTransitionInfo const& info,
0206                                                          ModuleCallingContext const* mcc) {
0207   LuminosityBlockPrincipal const& lbp = info.principal();
0208   auto mod = m_streamModules[id];
0209   setupLuminosityBlock(mod, lbp.index());
0210
0211   LuminosityBlock lb(lbp, moduleDescription_, mcc, false);
0212   lb.setConsumer(mod);
0213   ESParentContext parentC(mcc);
0214   const EventSetup c{info,
0215                      static_cast<unsigned int>(Transition::BeginLuminosityBlock),
0216                      mod->esGetTokenIndices(Transition::BeginLuminosityBlock),
0217                      parentC};
0218   mod->beginLuminosityBlock(lb, c);
0219 }
0220 void EDAnalyzerAdaptorBase::doStreamEndLuminosityBlock(StreamID id,
0221                                                        LumiTransitionInfo const& info,
0222                                                        ModuleCallingContext const* mcc) {
0223   auto mod = m_streamModules[id];
0224   LuminosityBlock lb(info, moduleDescription_, mcc, true);
0225   lb.setConsumer(mod);
0226   ESParentContext parentC(mcc);
0227   const EventSetup c{info,
0228                      static_cast<unsigned int>(Transition::EndLuminosityBlock),
0229                      mod->esGetTokenIndices(Transition::EndLuminosityBlock),
0230                      parentC};
0231   mod->endLuminosityBlock(lb, c);
0232   streamEndLuminosityBlockSummary(mod, lb, c);
0233 }
0234
0235 void EDAnalyzerAdaptorBase::setModuleDescriptionPtr(EDAnalyzerBase* m) {
0236   m->setModuleDescriptionPtr(&moduleDescription_);
0237 }