Updated the PPS PCL workers to support the new AlCaRecoProducer

CalibPPS/AlignmentGlobal/plugins/PPSAlignmentWorker.cc

@@ -88,16 +88,17 @@ class PPSAlignmentWorker : public DQMEDAnalyzer {
   };
 
   // ------------ member data ------------
-  edm::ESGetToken<PPSAlignmentConfiguration, PPSAlignmentConfigurationRcd> esTokenBookHistograms_;
-  edm::ESGetToken<PPSAlignmentConfiguration, PPSAlignmentConfigurationRcd> esTokenAnalyze_;
+  const edm::ESGetToken<PPSAlignmentConfiguration, PPSAlignmentConfigurationRcd> esTokenBookHistograms_;
+  const edm::ESGetToken<PPSAlignmentConfiguration, PPSAlignmentConfigurationRcd> esTokenAnalyze_;
 
-  edm::EDGetTokenT<CTPPSLocalTrackLiteCollection> tracksToken_;
+  const std::vector<edm::InputTag> tracksTags_;
+  std::vector<edm::EDGetTokenT<CTPPSLocalTrackLiteCollection>> tracksTokens_;
 
   SectorData sectorData45_;
   SectorData sectorData56_;
 
-  std::string dqmDir_;
-  bool debug_;
+  const std::string dqmDir_;
+  const bool debug_;
 };
 
 // -------------------------------- DQMEDAnalyzer methods --------------------------------
@@ -108,16 +109,23 @@ PPSAlignmentWorker::PPSAlignmentWorker(const edm::ParameterSet& iConfig)
               edm::ESInputTag("", iConfig.getParameter<std::string>("label")))),
       esTokenAnalyze_(esConsumes<PPSAlignmentConfiguration, PPSAlignmentConfigurationRcd>(
           edm::ESInputTag("", iConfig.getParameter<std::string>("label")))),
-      tracksToken_(consumes<CTPPSLocalTrackLiteCollection>(iConfig.getParameter<edm::InputTag>("tagTracks"))),
+      tracksTags_(iConfig.getParameter<std::vector<edm::InputTag>>("tracksTags")),
       dqmDir_(iConfig.getParameter<std::string>("dqm_dir")),
       debug_(iConfig.getParameter<bool>("debug")) {
   edm::LogInfo("PPSAlignmentWorker").log([&](auto& li) {
     li << "parameters:\n";
     li << "* label: " << iConfig.getParameter<std::string>("label") << "\n";
-    li << "* tagTracks: " << iConfig.getParameter<edm::InputTag>("tagTracks") << "\n";
+    li << "* tracksTags:\n";
+    for (auto& tag : tracksTags_) {
+      li << "    " << tag << ",\n";
+    }
     li << "* dqm_dir: " << dqmDir_ << "\n";
     li << "* debug: " << std::boolalpha << debug_;
   });
+
+  for (auto& tag : tracksTags_) {
+    tracksTokens_.emplace_back(consumes<CTPPSLocalTrackLiteCollection>(tag));
+  }
 }
 
 void PPSAlignmentWorker::bookHistograms(DQMStore::IBooker& iBooker, edm::Run const&, edm::EventSetup const& iSetup) {
@@ -128,7 +136,20 @@ void PPSAlignmentWorker::bookHistograms(DQMStore::IBooker& iBooker, edm::Run con
 }
 
 void PPSAlignmentWorker::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
-  const auto& tracks = iEvent.get(tracksToken_);
+  CTPPSLocalTrackLiteCollection tracks;
+  bool foundProduct = false;
+
+  for (unsigned int i = 0; i < tracksTokens_.size(); i++) {
+    if (auto handle = iEvent.getHandle(tracksTokens_[i])) {
+      tracks = *handle;
+      foundProduct = true;
+      edm::LogInfo("PPSAlignmentWorker") << "Found a product with " << tracksTags_[i];
+      break;
+    }
+  }
+  if (!foundProduct) {
+    throw edm::Exception(edm::errors::ProductNotFound) << "Could not find a product with any of the selected labels.";
+  }
 
   const auto& cfg = iSetup.getData(esTokenAnalyze_);
 
@@ -140,7 +161,7 @@ void PPSAlignmentWorker::fillDescriptions(edm::ConfigurationDescriptions& descri
   edm::ParameterSetDescription desc;
 
   desc.add<std::string>("label", "");
-  desc.add<edm::InputTag>("tagTracks", edm::InputTag("ctppsLocalTrackLiteProducer"));
+  desc.add<std::vector<edm::InputTag>>("tracksTags", {edm::InputTag("ctppsLocalTrackLiteProducer")});
   desc.add<std::string>("dqm_dir", "AlCaReco/PPSAlignment");
   desc.add<bool>("debug", false);
 

CalibPPS/AlignmentGlobal/python/ALCARECOPromptCalibProdPPSAlignment_cff.py

@@ -1,6 +1,12 @@
 import FWCore.ParameterSet.Config as cms
 
-from CalibPPS.AlignmentGlobal.ppsAlignmentWorker_cfi import ppsAlignmentWorker
+from CalibPPS.AlignmentGlobal.ppsAlignmentWorker_cfi import ppsAlignmentWorker as ppsAlignmentWorker_
+
+ppsAlignmentWorker = ppsAlignmentWorker_.clone()
+ppsAlignmentWorker.tracksTags = cms.VInputTag(
+    cms.InputTag("ctppsLocalTrackLiteProducer"),
+    cms.InputTag("ctppsLocalTrackLiteProducerAlCaRecoProducer")
+)
 
 MEtoEDMConvertPPSAlignment = cms.EDProducer('MEtoEDMConverter',
     Name=cms.untracked.string('MEtoEDMConverter'),

CalibPPS/TimingCalibration/plugins/PPSDiamondSampicTimingCalibrationPCLWorker.cc

@@ -62,22 +62,35 @@ class PPSDiamondSampicTimingCalibrationPCLWorker
                   edm::EventSetup const&,
                   Histograms_PPSDiamondSampicTimingCalibrationPCLWorker const&) const override;
 
+  template <typename T>
+  bool searchForProduct(edm::Event const& iEvent,
+                        const std::vector<edm::EDGetTokenT<T>>& tokens,
+                        const std::vector<edm::InputTag>& tags,
+                        edm::Handle<T>& handle) const;
+
   // ------------ member data ------------
-  edm::EDGetTokenT<edm::DetSetVector<TotemTimingDigi>> totemTimingDigiToken_;
-  edm::EDGetTokenT<edm::DetSetVector<TotemTimingRecHit>> totemTimingRecHitToken_;
-  edm::ESGetToken<CTPPSGeometry, VeryForwardRealGeometryRecord> geomEsToken_;
-  std::string folder_;
+  const std::vector<edm::InputTag> digiTags_;
+  const std::vector<edm::InputTag> RecHitTags_;
+
+  std::vector<edm::EDGetTokenT<edm::DetSetVector<TotemTimingDigi>>> totemTimingDigiTokens_;
+  std::vector<edm::EDGetTokenT<edm::DetSetVector<TotemTimingRecHit>>> totemTimingRecHitTokens_;
+
+  const edm::ESGetToken<CTPPSGeometry, VeryForwardRealGeometryRecord> geomEsToken_;
+  const std::string folder_;
 };
 
 //------------------------------------------------------------------------------
 
 PPSDiamondSampicTimingCalibrationPCLWorker::PPSDiamondSampicTimingCalibrationPCLWorker(const edm::ParameterSet& iConfig)
-    : totemTimingDigiToken_(
-          consumes<edm::DetSetVector<TotemTimingDigi>>(iConfig.getParameter<edm::InputTag>("totemTimingDigiTag"))),
-      totemTimingRecHitToken_(
-          consumes<edm::DetSetVector<TotemTimingRecHit>>(iConfig.getParameter<edm::InputTag>("totemTimingRecHitTag"))),
+    : digiTags_(iConfig.getParameter<std::vector<edm::InputTag>>("totemTimingDigiTags")),
+      RecHitTags_(iConfig.getParameter<std::vector<edm::InputTag>>("totemTimingRecHitTags")),
       geomEsToken_(esConsumes<edm::Transition::BeginRun>()),
-      folder_(iConfig.getParameter<std::string>("folder")) {}
+      folder_(iConfig.getParameter<std::string>("folder")) {
+  for (auto& tag : digiTags_)
+    totemTimingDigiTokens_.push_back(consumes<edm::DetSetVector<TotemTimingDigi>>(tag));
+  for (auto& tag : RecHitTags_)
+    totemTimingRecHitTokens_.push_back(consumes<edm::DetSetVector<TotemTimingRecHit>>(tag));
+}
 
 PPSDiamondSampicTimingCalibrationPCLWorker::~PPSDiamondSampicTimingCalibrationPCLWorker() {}
 
@@ -89,8 +102,9 @@ void PPSDiamondSampicTimingCalibrationPCLWorker::dqmAnalyze(
     Histograms_PPSDiamondSampicTimingCalibrationPCLWorker const& histos) const {
   edm::Handle<edm::DetSetVector<TotemTimingDigi>> timingDigi;
   edm::Handle<edm::DetSetVector<TotemTimingRecHit>> timingRecHit;
-  iEvent.getByToken(totemTimingRecHitToken_, timingRecHit);
-  iEvent.getByToken(totemTimingDigiToken_, timingDigi);
+
+  searchForProduct(iEvent, totemTimingDigiTokens_, digiTags_, timingDigi);
+  searchForProduct(iEvent, totemTimingRecHitTokens_, RecHitTags_, timingRecHit);
 
   if (timingRecHit->empty()) {
     edm::LogWarning("PPSDiamondSampicTimingCalibrationPCLWorker:dqmAnalyze")
@@ -143,13 +157,35 @@ void PPSDiamondSampicTimingCalibrationPCLWorker::bookHistograms(
 
 void PPSDiamondSampicTimingCalibrationPCLWorker::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
   edm::ParameterSetDescription desc;
-  desc.add<edm::InputTag>("totemTimingDigiTag", edm::InputTag("totemTimingRawToDigi", "TotemTiming"))
+  desc.add<std::vector<edm::InputTag>>("totemTimingDigiTags", {edm::InputTag("totemTimingRawToDigi", "TotemTiming")})
       ->setComment("input tag for the PPS diamond detectors digi");
-  desc.add<edm::InputTag>("totemTimingRecHitTag", edm::InputTag("totemTimingRecHits"))
+  desc.add<std::vector<edm::InputTag>>("totemTimingRecHitTags", {edm::InputTag("totemTimingRecHits")})
       ->setComment("input tag for the PPS diamond detectors rechits");
   desc.add<std::string>("folder", "AlCaReco/PPSDiamondSampicTimingCalibrationPCL")
       ->setComment("output path for the various DQM plots");
   descriptions.add("PPSDiamondSampicTimingCalibrationPCLWorker", desc);
 }
 
+//------------------------------------------------------------------------------
+
+template <typename T>
+bool PPSDiamondSampicTimingCalibrationPCLWorker::searchForProduct(edm::Event const& iEvent,
+                                                                  const std::vector<edm::EDGetTokenT<T>>& tokens,
+                                                                  const std::vector<edm::InputTag>& tags,
+                                                                  edm::Handle<T>& handle) const {
+  bool foundProduct = false;
+  for (unsigned int i = 0; i < tokens.size(); i++)
+    if (auto h = iEvent.getHandle(tokens[i])) {
+      handle = h;
+      foundProduct = true;
+      edm::LogInfo("searchForProduct") << "Found a product with " << tags[i];
+      break;
+    }
+
+  if (!foundProduct)
+    throw edm::Exception(edm::errors::ProductNotFound) << "Could not find a product with any of the selected labels.";
+
+  return foundProduct;
+}
+
 DEFINE_FWK_MODULE(PPSDiamondSampicTimingCalibrationPCLWorker);

CalibPPS/TimingCalibration/plugins/PPSTimingCalibrationPCLWorker.cc

@@ -41,19 +41,28 @@ class PPSTimingCalibrationPCLWorker : public DQMGlobalEDAnalyzer<TimingCalibrati
                       const edm::EventSetup&,
                       TimingCalibrationHistograms&) const override;
 
-  edm::EDGetTokenT<edm::DetSetVector<CTPPSDiamondRecHit>> diamondRecHitToken_;
-  edm::ESGetToken<CTPPSGeometry, VeryForwardRealGeometryRecord> geomEsToken_;
+  template <typename T>
+  bool searchForProduct(edm::Event const& iEvent,
+                        const std::vector<edm::EDGetTokenT<T>>& tokens,
+                        const std::vector<edm::InputTag>& tags,
+                        edm::Handle<T>& handle) const;
+
+  const std::vector<edm::InputTag> RecHitTags_;
+  std::vector<edm::EDGetTokenT<edm::DetSetVector<CTPPSDiamondRecHit>>> diamondRecHitTokens_;
+  const edm::ESGetToken<CTPPSGeometry, VeryForwardRealGeometryRecord> geomEsToken_;
 
   const std::string dqmDir_;
 };
 
 //------------------------------------------------------------------------------
 
 PPSTimingCalibrationPCLWorker::PPSTimingCalibrationPCLWorker(const edm::ParameterSet& iConfig)
-    : diamondRecHitToken_(
-          consumes<edm::DetSetVector<CTPPSDiamondRecHit>>(iConfig.getParameter<edm::InputTag>("diamondRecHitTag"))),
+    : RecHitTags_(iConfig.getParameter<std::vector<edm::InputTag>>("diamondRecHitTags")),
       geomEsToken_(esConsumes<edm::Transition::BeginRun>()),
-      dqmDir_(iConfig.getParameter<std::string>("dqmDir")) {}
+      dqmDir_(iConfig.getParameter<std::string>("dqmDir")) {
+  for (auto& tag : RecHitTags_)
+    diamondRecHitTokens_.push_back(consumes<edm::DetSetVector<CTPPSDiamondRecHit>>(tag));
+}
 
 //------------------------------------------------------------------------------
 
@@ -85,9 +94,10 @@ void PPSTimingCalibrationPCLWorker::bookHistograms(DQMStore::IBooker& iBooker,
 void PPSTimingCalibrationPCLWorker::dqmAnalyze(const edm::Event& iEvent,
                                                const edm::EventSetup& iSetup,
                                                const TimingCalibrationHistograms& iHists) const {
-  // then extract the rechits information for later processing
   edm::Handle<edm::DetSetVector<CTPPSDiamondRecHit>> dsv_rechits;
-  iEvent.getByToken(diamondRecHitToken_, dsv_rechits);
+  // then extract the rechits information for later processing
+  searchForProduct(iEvent, diamondRecHitTokens_, RecHitTags_, dsv_rechits);
+
   // ensure timing detectors rechits are found in the event content
   if (dsv_rechits->empty()) {
     edm::LogWarning("PPSTimingCalibrationPCLWorker:dqmAnalyze") << "No rechits retrieved from the event content.";
@@ -115,12 +125,32 @@ void PPSTimingCalibrationPCLWorker::dqmAnalyze(const edm::Event& iEvent,
 
 void PPSTimingCalibrationPCLWorker::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
   edm::ParameterSetDescription desc;
-  desc.add<edm::InputTag>("diamondRecHitTag", edm::InputTag("ctppsDiamondUncalibRecHits"))
+  desc.add<std::vector<edm::InputTag>>("diamondRecHitTags", {edm::InputTag("ctppsDiamondRecHits")})
       ->setComment("input tag for the PPS diamond detectors rechits");
   desc.add<std::string>("dqmDir", "AlCaReco/PPSTimingCalibrationPCL")
       ->setComment("output path for the various DQM plots");
 
   descriptions.addWithDefaultLabel(desc);
 }
 
+template <typename T>
+bool PPSTimingCalibrationPCLWorker::searchForProduct(edm::Event const& iEvent,
+                                                     const std::vector<edm::EDGetTokenT<T>>& tokens,
+                                                     const std::vector<edm::InputTag>& tags,
+                                                     edm::Handle<T>& handle) const {
+  bool foundProduct = false;
+  for (unsigned int i = 0; i < tokens.size(); i++)
+    if (auto h = iEvent.getHandle(tokens[i])) {
+      handle = h;
+      foundProduct = true;
+      edm::LogInfo("searchForProduct") << "Found a product with " << tags[i];
+      break;
+    }
+
+  if (!foundProduct)
+    throw edm::Exception(edm::errors::ProductNotFound) << "Could not find a product with any of the selected labels.";
+
+  return foundProduct;
+}
+
 DEFINE_FWK_MODULE(PPSTimingCalibrationPCLWorker);

CalibPPS/TimingCalibration/python/ALCARECOPPSCalTrackBasedSel_Output_cff.py

@@ -7,7 +7,9 @@
     outputCommands = cms.untracked.vstring(
         'keep *_ALCARECOPPSCalTrackBasedSel_*_*',
         'keep *_ctppsDiamondRawToDigi_*_*',
+        'keep *_ctppsDiamondRecHits_*_*',
         'keep *_totemTimingRawToDigi_*_*',
+        'keep *_totemTimingRecHits_*_*',
         'keep *_ctppsLocalTrackLiteProducer_*_*'
     )
 )

CalibPPS/TimingCalibration/python/ALCARECOPromptCalibProdPPSDiamondSampicTimingCalib_cff.py

@@ -1,6 +1,5 @@
 import FWCore.ParameterSet.Config as cms
 
-from RecoPPS.Configuration.recoCTPPS_cff import diamondSampicLocalReconstructionTask
 from CalibPPS.TimingCalibration.PPSDiamondSampicTimingCalibrationPCLWorker_cfi import PPSDiamondSampicTimingCalibrationPCLWorker
 from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
 
@@ -10,9 +9,14 @@
     Frequency = cms.untracked.int32(50),
     MEPathToSave = cms.untracked.string('AlCaReco/PPSDiamondSampicTimingCalibrationPCL')
 )
+
+PPSDiamondSampicTimingCalibrationPCLWorker.totemTimingDigiTags=cms.VInputTag(cms.InputTag("totemTimingRawToDigiAlCaRecoProducer","TotemTiming"),
+                                         			  cms.InputTag("totemTimingRawToDigi","TotemTiming"))
+
+PPSDiamondSampicTimingCalibrationPCLWorker.totemTimingRecHitTags=cms.VInputTag(cms.InputTag("totemTimingRecHitsAlCaRecoProducer"),
+                                                  		    cms.InputTag("totemTimingRecHits"))
 
 taskALCARECOPromptCalibProdPPSDiamondSampicTimingCalib = cms.Task(
-    diamondSampicLocalReconstructionTask,
     PPSDiamondSampicTimingCalibrationPCLWorker,
     MEtoEDMConvertPPSDiamondSampicTimingCalib
 )

CalibPPS/TimingCalibration/python/ALCARECOPromptCalibProdPPSTimingCalib_cff.py

@@ -1,6 +1,5 @@
 import FWCore.ParameterSet.Config as cms
 
-from RecoPPS.Configuration.recoCTPPS_cff import ctppsDiamondRecHits as _ctppsDiamondRecHits
 from CalibPPS.TimingCalibration.ppsTimingCalibrationPCLWorker_cfi import ppsTimingCalibrationPCLWorker
 
 MEtoEDMConvertPPSTimingCalib = cms.EDProducer('MEtoEDMConverter',
@@ -11,18 +10,10 @@
     deleteAfterCopy = cms.untracked.bool(True),
 )
 
-# calibrated rechits/tracks
-ctppsDiamondUncalibRecHits = _ctppsDiamondRecHits.clone(
-    applyCalibration = False
-)
-# this task will be updated to include tracking based on the last
-# calibration values to extract per-channel timing precision estimation
-recoDiamondUncalibLocalReconstructionTask = cms.Task(
-    ctppsDiamondUncalibRecHits,
-)
+ppsTimingCalibrationPCLWorker.diamondRecHitTags=cms.VInputTag(cms.InputTag("ctppsDiamondRecHitsAlCaRecoProducer"),
+                                         			  cms.InputTag("ctppsDiamondRecHits"))
 
 taskALCARECOPromptCalibProdPPSTimingCalib = cms.Task(
-    recoDiamondUncalibLocalReconstructionTask,
     ppsTimingCalibrationPCLWorker,
     MEtoEDMConvertPPSTimingCalib
 )