Merge pull request #48682 from Dr15Jones/modifyInputTag

cmsbuild · web-flow · commit 64ec91280d34 · 2025-08-13T18:00:38.000+02:00
Cache EDGetToken in InputTag
diff --git a/CalibTracker/SiStripCommon/plugins/ShallowDigisProducer.cc b/CalibTracker/SiStripCommon/plugins/ShallowDigisProducer.cc
@@ -4,17 +4,18 @@
 #include "FWCore/Framework/interface/EventSetup.h"
 #include "FWCore/MessageLogger/interface/MessageLogger.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
-#include "DataFormats/Common/interface/DetSetVector.h"
-#include "DataFormats/Common/interface/DetSetVectorNew.h"
-#include "DataFormats/SiStripDigi/interface/SiStripDigi.h"
+#include "FWCore/Utilities/interface/InputTag.h"
 
-ShallowDigisProducer::ShallowDigisProducer(const edm::ParameterSet& conf)
-    : inputTags(conf.getParameter<std::vector<edm::InputTag> >("DigiProducersList")), noisesToken_(esConsumes()) {
-  produces<std::vector<unsigned> >("id");
-  produces<std::vector<unsigned> >("subdet");
-  produces<std::vector<unsigned> >("strip");
-  produces<std::vector<unsigned> >("adc");
-  produces<std::vector<float> >("noise");
+ShallowDigisProducer::ShallowDigisProducer(const edm::ParameterSet& conf) : noisesToken_(esConsumes()) {
+  for (auto const& tag : conf.getParameter<std::vector<edm::InputTag>>("DigiProducersList")) {
+    oldTokens_.emplace_back(consumes<edm::DetSetVector<SiStripDigi>>(tag));
+    newTokens_.emplace_back(consumes<edmNew::DetSetVector<SiStripDigi>>(tag));
+  }
+  produces<std::vector<unsigned>>("id");
+  produces<std::vector<unsigned>>("subdet");
+  produces<std::vector<unsigned>>("strip");
+  produces<std::vector<unsigned>>("adc");
+  produces<std::vector<float>>("noise");
 }
 
 void ShallowDigisProducer::insert(products& p, edm::Event& e) {
@@ -41,24 +42,25 @@ inline void ShallowDigisProducer::recordDigis(const T& digiCollection, products&
 
 void ShallowDigisProducer::produce(edm::Event& e, const edm::EventSetup& es) {
   products p;
-  edm::Handle<edm::DetSetVector<SiStripDigi> > inputOld;
-  edm::Handle<edmNew::DetSetVector<SiStripDigi> > inputNew;
+  edm::Handle<edm::DetSetVector<SiStripDigi>> inputOld;
+  edm::Handle<edmNew::DetSetVector<SiStripDigi>> inputNew;
   const auto& noises = es.getData(noisesToken_);
-  if (findInput(inputOld, e))
+  if (findInput(inputOld, oldTokens_, e))
     recordDigis(*inputOld, p, noises);
-  else if (findInput(inputNew, e))
+  else if (findInput(inputNew, newTokens_, e))
     recordDigis(*inputNew, p, noises);
   else
     edm::LogWarning("Input Not Found");
   insert(p, e);
 }
 
 template <class T>
-inline bool ShallowDigisProducer::findInput(edm::Handle<T>& handle, const edm::Event& e) {
-  for (auto const& inputTag : inputTags) {
-    e.getByLabel(inputTag, handle);
+inline bool ShallowDigisProducer::findInput(edm::Handle<T>& handle,
+                                            std::vector<edm::EDGetTokenT<T>> const& tokens,
+                                            const edm::Event& e) {
+  for (auto const& token : tokens) {
+    handle = e.getHandle(token);
     if (handle.isValid() && !handle->empty()) {
-      LogDebug("Input") << inputTag;
       return true;
     }
   }
diff --git a/CalibTracker/SiStripCommon/plugins/ShallowDigisProducer.h b/CalibTracker/SiStripCommon/plugins/ShallowDigisProducer.h
@@ -3,34 +3,38 @@
 
 #include "FWCore/Framework/interface/stream/EDProducer.h"
 #include "FWCore/Framework/interface/Frameworkfwd.h"
-#include "FWCore/Utilities/interface/InputTag.h"
+#include "FWCore/Utilities/interface/EDGetToken.h"
 #include "CondFormats/DataRecord/interface/SiStripNoisesRcd.h"
 #include "CondFormats/SiStripObjects/interface/SiStripNoises.h"
+#include "DataFormats/Common/interface/DetSetVector.h"
+#include "DataFormats/Common/interface/DetSetVectorNew.h"
+#include "DataFormats/SiStripDigi/interface/SiStripDigi.h"
 
 class ShallowDigisProducer : public edm::stream::EDProducer<> {
 public:
   explicit ShallowDigisProducer(const edm::ParameterSet &);
 
 private:
   struct products {
-    std::unique_ptr<std::vector<unsigned> > id;
-    std::unique_ptr<std::vector<unsigned> > subdet;
-    std::unique_ptr<std::vector<unsigned> > strip;
-    std::unique_ptr<std::vector<unsigned> > adc;
-    std::unique_ptr<std::vector<float> > noise;
+    std::unique_ptr<std::vector<unsigned>> id;
+    std::unique_ptr<std::vector<unsigned>> subdet;
+    std::unique_ptr<std::vector<unsigned>> strip;
+    std::unique_ptr<std::vector<unsigned>> adc;
+    std::unique_ptr<std::vector<float>> noise;
     products()
         : id(new std::vector<unsigned>()),
           subdet(new std::vector<unsigned>()),
           strip(new std::vector<unsigned>()),
           adc(new std::vector<unsigned>()),
           noise(new std::vector<float>()) {}
   };
-  std::vector<edm::InputTag> inputTags;
+  std::vector<edm::EDGetTokenT<edm::DetSetVector<SiStripDigi>>> oldTokens_;
+  std::vector<edm::EDGetTokenT<edmNew::DetSetVector<SiStripDigi>>> newTokens_;
   edm::ESGetToken<SiStripNoises, SiStripNoisesRcd> noisesToken_;
 
   void produce(edm::Event &, const edm::EventSetup &) override;
   template <class T>
-  bool findInput(edm::Handle<T> &, const edm::Event &);
+  bool findInput(edm::Handle<T> &, std::vector<edm::EDGetTokenT<T>> const &, const edm::Event &);
   template <class T>
   void recordDigis(const T &, products &, const SiStripNoises &noises);
   void insert(products &, edm::Event &);
diff --git a/DQM/Physics/src/SingleTopTChannelLeptonDQM.cc b/DQM/Physics/src/SingleTopTChannelLeptonDQM.cc
@@ -67,7 +67,8 @@ namespace SingleTopTChannelLepton {
       }
 
       if (elecExtras.existsAs<std::string>("rho")) {
-        rhoTag = elecExtras.getParameter<edm::InputTag>("rho");
+        auto rhoTag = elecExtras.getParameter<edm::InputTag>("rho");
+        rhoToken_ = iC.consumes(rhoTag);
       }
       // electronId is optional; in case it's not found the
       // InputTag will remain empty
@@ -356,7 +357,9 @@ namespace SingleTopTChannelLepton {
     edm::Handle<edm::View<reco::GsfElectron>> elecs;
     reco::GsfElectron e;
     edm::Handle<double> _rhoHandle;
-    event.getByLabel(rhoTag, _rhoHandle);
+    if (!rhoToken_.isUninitialized()) {
+      _rhoHandle = event.getHandle(rhoToken_);
+    }
     if (!event.getByToken(elecs_, elecs))
       return;
 
diff --git a/DQM/Physics/src/SingleTopTChannelLeptonDQM.h b/DQM/Physics/src/SingleTopTChannelLeptonDQM.h
@@ -150,7 +150,7 @@ namespace SingleTopTChannelLepton {
     std::string elecIso_;
     /// extra selection on electrons
     std::unique_ptr<StringCutObjectSelector<reco::GsfElectron>> elecSelect_;
-    edm::InputTag rhoTag;
+    edm::EDGetTokenT<double> rhoToken_;
 
     /// extra selection on primary vertices; meant to investigate the pile-up
     /// effect
diff --git a/DQM/Physics/src/SingleTopTChannelLeptonDQM_miniAOD.cc b/DQM/Physics/src/SingleTopTChannelLeptonDQM_miniAOD.cc
@@ -69,7 +69,8 @@ namespace SingleTopTChannelLepton_miniAOD {
       }
 
       if (elecExtras.existsAs<std::string>("rho")) {
-        rhoTag = elecExtras.getParameter<edm::InputTag>("rho");
+        auto rhoTag = elecExtras.getParameter<edm::InputTag>("rho");
+        rhoToken_ = iC.consumes(rhoTag);
       }
       // electronId is optional; in case it's not found the
       // InputTag will remain empty
@@ -416,8 +417,9 @@ namespace SingleTopTChannelLepton_miniAOD {
       return;
 
     edm::Handle<double> _rhoHandle;
-    event.getByLabel(rhoTag, _rhoHandle);
-    //if (!event.getByToken(elecs_, elecs)) return;
+    if (!rhoToken_.isUninitialized()) {
+      _rhoHandle = event.getHandle(rhoToken_);
+    }
 
     // check availability of electron id
     edm::Handle<edm::ValueMap<float>> electronId;
diff --git a/DQM/Physics/src/SingleTopTChannelLeptonDQM_miniAOD.h b/DQM/Physics/src/SingleTopTChannelLeptonDQM_miniAOD.h
@@ -94,7 +94,7 @@ namespace SingleTopTChannelLepton_miniAOD {
     /// to be of form signalPath:MonitorPath
     std::vector<std::string> triggerPaths_;
 
-    edm::InputTag rhoTag;
+    edm::EDGetTokenT<double> rhoToken_;
 
     /// electronId label
     edm::EDGetTokenT<edm::ValueMap<float> > electronId_;
diff --git a/DQM/Physics/src/TopSingleLeptonDQM.cc b/DQM/Physics/src/TopSingleLeptonDQM.cc
@@ -61,7 +61,8 @@ namespace TopSingleLepton {
       }
 
       if (elecExtras.existsAs<std::string>("rho")) {
-        rhoTag = elecExtras.getParameter<edm::InputTag>("rho");
+        auto rhoTag = elecExtras.getParameter<edm::InputTag>("rho");
+        rhoToken_ = iC.consumes(rhoTag);
       }
       // electronId is optional; in case it's not found the
       // InputTag will remain empty
@@ -371,8 +372,6 @@ namespace TopSingleLepton {
 
     // fill monitoring plots for electrons
     edm::Handle<edm::View<reco::GsfElectron>> elecs;
-    edm::Handle<double> _rhoHandle;
-    event.getByLabel(rhoTag, _rhoHandle);
     if (!event.getByToken(elecs_, elecs))
       return;
 
@@ -383,6 +382,10 @@ namespace TopSingleLepton {
         return;
       }
     }
+    edm::Handle<double> _rhoHandle;
+    if (!rhoToken_.isUninitialized()) {
+      _rhoHandle = event.getHandle(rhoToken_);
+    }
     // loop electron collection
     unsigned int eMult = 0, eMultIso = 0;
     std::vector<const reco::GsfElectron*> isoElecs;
diff --git a/DQM/Physics/src/TopSingleLeptonDQM.h b/DQM/Physics/src/TopSingleLeptonDQM.h
@@ -137,7 +137,7 @@ namespace TopSingleLepton {
     double eidCutValue_;
     // electron ISO things
 
-    edm::InputTag rhoTag;
+    edm::EDGetTokenT<double> rhoToken_;
 
     /// extra selection on electrons
 
diff --git a/DQM/Physics/src/TopSingleLeptonDQM_miniAOD.cc b/DQM/Physics/src/TopSingleLeptonDQM_miniAOD.cc
@@ -70,7 +70,8 @@ namespace TopSingleLepton_miniAOD {
       }
 
       if (elecExtras.existsAs<std::string>("rho")) {
-        rhoTag = elecExtras.getParameter<edm::InputTag>("rho");
+        auto rhoTag = elecExtras.getParameter<edm::InputTag>("rho");
+        rhoToken_ = iC.consumes(rhoTag);
       }
       // electronId is optional; in case it's not found the
       // InputTag will remain empty
@@ -406,8 +407,9 @@ namespace TopSingleLepton_miniAOD {
       return;
 
     edm::Handle<double> _rhoHandle;
-    event.getByLabel(rhoTag, _rhoHandle);
-    //if (!event.getByToken(elecs_, elecs)) return;
+    if (!rhoToken_.isUninitialized()) {
+      _rhoHandle = event.getHandle(rhoToken_);
+    }
 
     // check availability of electron id
     edm::Handle<edm::ValueMap<float>> electronId;
diff --git a/DQM/Physics/src/TopSingleLeptonDQM_miniAOD.h b/DQM/Physics/src/TopSingleLeptonDQM_miniAOD.h
@@ -94,7 +94,7 @@ namespace TopSingleLepton_miniAOD {
     /// to be of form signalPath:MonitorPath
     std::vector<std::string> triggerPaths_;
 
-    edm::InputTag rhoTag;
+    edm::EDGetTokenT<double> rhoToken_;
 
     /// electronId label
     edm::EDGetTokenT<edm::ValueMap<float> > electronId_;
diff --git a/FWCore/Framework/interface/EDConsumerBase.h b/FWCore/Framework/interface/EDConsumerBase.h
@@ -90,6 +90,15 @@ namespace edm {
     // ---------- const member functions ---------------------
     ProductResolverIndexAndSkipBit indexFrom(EDGetToken, BranchType, TypeID const&) const;
     ProductResolverIndexAndSkipBit uncheckedIndexFrom(EDGetToken) const;
+    /**returns edm::ProductResolverIndexInvalid if type and branch do not match the index
+     this can happen if the same InputTag is used for different products */
+    ProductResolverIndexAndSkipBit indexFromIfExactMatch(EDGetToken, BranchType, TypeID const&) const;
+    EDGetToken getRegisteredToken(TypeID const& typeID,
+                                  std::string const& label,
+                                  std::string const& instance,
+                                  std::string const& processName,
+                                  BranchType branchType,
+                                  bool skipCurrentProcess) const;
 
     void itemsToGet(BranchType, std::vector<ProductResolverIndexAndSkipBit>&) const;
     void itemsMayGet(BranchType, std::vector<ProductResolverIndexAndSkipBit>&) const;
diff --git a/FWCore/Framework/interface/PrincipalGetAdapter.h b/FWCore/Framework/interface/PrincipalGetAdapter.h
@@ -107,6 +107,7 @@ edm::Ref<AppleCollection> ref(refApples, index);
 #include "FWCore/Utilities/interface/ProductLabels.h"
 #include "FWCore/Utilities/interface/propagate_const.h"
 #include "FWCore/Utilities/interface/Transition.h"
+#include "FWCore/Utilities/interface/ProductResolverIndex.h"
 
 namespace edm {
 
diff --git a/FWCore/Framework/src/EDConsumerBase.cc b/FWCore/Framework/src/EDConsumerBase.cc
@@ -256,6 +256,44 @@ ProductResolverIndexAndSkipBit EDConsumerBase::uncheckedIndexFrom(EDGetToken iTo
   return m_tokenInfo.get<kLookupInfo>(iToken.index()).m_index;
 }
 
+ProductResolverIndexAndSkipBit EDConsumerBase::indexFromIfExactMatch(EDGetToken iToken,
+                                                                     BranchType iBranch,
+                                                                     TypeID const& iType) const {
+  if (UNLIKELY(iToken.index() >= m_tokenInfo.size())) {
+    throwBadToken(iType, iToken);
+  }
+  const auto& info = m_tokenInfo.get<kLookupInfo>(iToken.index());
+  if (LIKELY(iBranch == info.m_branchType)) {
+    if (LIKELY(iType == info.m_type)) {
+      return info.m_index;
+    }
+  }
+  return ProductResolverIndexAndSkipBit(edm::ProductResolverIndexInvalid, false);
+}
+
+EDGetToken EDConsumerBase::getRegisteredToken(TypeID const& typeID,
+                                              std::string const& label,
+                                              std::string const& instance,
+                                              std::string const& processName,
+                                              BranchType branchType,
+                                              bool skipCurrentProcess) const {
+  auto const itBegin = m_tokenInfo.begin<kLookupInfo>();
+  for (auto it = itBegin, itEnd = m_tokenInfo.end<kLookupInfo>(); it != itEnd; ++it) {
+    if (it->m_type == typeID && it->m_branchType == branchType &&
+        it->m_index.skipCurrentProcess() == skipCurrentProcess) {
+      auto index = it - itBegin;
+      auto const& labels = m_tokenInfo.get<kLabels>(index);
+      unsigned int labelStart = labels.m_startOfModuleLabel;
+      const char* moduleLabel = &(m_tokenLabels[labelStart]);
+      if (label == moduleLabel && instance == (moduleLabel + labels.m_deltaToProductInstance) &&
+          (skipCurrentProcess or (processName == (moduleLabel + labels.m_deltaToProcessName)))) {
+        return EDGetToken{static_cast<unsigned int>(index)};
+      }
+    }
+  }
+  return EDGetToken{EDGetToken::s_uninitializedValue};
+}
+
 void EDConsumerBase::itemsToGet(BranchType iBranch, std::vector<ProductResolverIndexAndSkipBit>& oIndices) const {
   //how many are we adding?
   unsigned int count = 0;
@@ -363,8 +401,8 @@ void EDConsumerBase::throwBadToken(edm::TypeID const& iType, EDGetToken iToken)
   throw cms::Exception("BadToken")
       << "A get using a EDGetToken with the C++ type '" << iType.className() << "' was made using a token with a value "
       << iToken.index()
-      << " which is beyond the range used by this module.\n Please check that the variable is being initialized from a "
-         "'consumes' call from this module.\n You can not share EDGetToken values between modules.";
+      << " which is beyond the range used by this module.\n Please check that the variable is being initialized from "
+         "a 'consumes' call from this module.\n You can not share EDGetToken values between modules.";
 }
 
 void EDConsumerBase::throwConsumesCallAfterFrozen(TypeToGet const& typeToGet, InputTag const& inputTag) const {
diff --git a/FWCore/Framework/src/Principal.cc b/FWCore/Framework/src/Principal.cc
@@ -450,16 +450,36 @@ namespace edm {
                                                    ModuleCallingContext const* mcc) const {
     bool skipCurrentProcess = inputTag.willSkipCurrentProcess();
 
-    ProductResolverIndex index = inputTag.indexFor(typeID, branchType(), &productRegistry());
-
+    auto token = inputTag.cachedToken();
+
+    // a null consumer can happen for tests and RandomNumberGeneratorService which calls getByLabel
+    // without setting a EDConsumerBase
+    if (token.isUninitialized() and consumer) {
+      std::string const* processName = &inputTag.process();
+      if (inputTag.process() == InputTag::kCurrentProcess) {
+        processName = &processConfiguration_->processName();
+      }
+      token = consumer->getRegisteredToken(
+          typeID, inputTag.label(), inputTag.instance(), *processName, branchType(), skipCurrentProcess);
+      if (token.isUninitialized()) {
+        failedToRegisterConsumes(kindOfType,
+                                 typeID,
+                                 inputTag.label(),
+                                 inputTag.instance(),
+                                 appendCurrentProcessIfAlias(inputTag.process(), processConfiguration_->processName()));
+      }
+      inputTag.cacheToken(token);
+    }
+    //check that the InputTag is not being used for a different type/Principal than the first call
+    auto index = consumer ? consumer->indexFromIfExactMatch(token, branchType(), typeID).productResolverIndex()
+                          : ProductResolverIndexInvalid;
     if (index == ProductResolverIndexInvalid) {
       char const* processName = inputTag.process().c_str();
       if (skipCurrentProcess) {
         processName = "\0";
       } else if (inputTag.process() == InputTag::kCurrentProcess) {
         processName = processConfiguration_->processName().c_str();
       }
-
       index =
           productLookup().index(kindOfType, typeID, inputTag.label().c_str(), inputTag.instance().c_str(), processName);
 
@@ -490,14 +510,6 @@ namespace edm {
         }
         return nullptr;
       }
-      inputTag.tryToCacheIndex(index, typeID, branchType(), &productRegistry());
-    }
-    if (UNLIKELY(consumer and (not consumer->registeredToConsume(index, skipCurrentProcess, branchType())))) {
-      failedToRegisterConsumes(kindOfType,
-                               typeID,
-                               inputTag.label(),
-                               inputTag.instance(),
-                               appendCurrentProcessIfAlias(inputTag.process(), processConfiguration_->processName()));
     }
 
     auto const& productResolver = productResolvers_[index];
diff --git a/FWCore/Utilities/interface/InputTag.h b/FWCore/Utilities/interface/InputTag.h
diff --git a/FWCore/Utilities/src/InputTag.cc b/FWCore/Utilities/src/InputTag.cc
diff --git a/FWCore/Utilities/test/InputTag_t.cpp b/FWCore/Utilities/test/InputTag_t.cpp
diff --git a/FWCore/Utilities/test/test_catch2_InputTag.cc b/FWCore/Utilities/test/test_catch2_InputTag.cc
