Update for pepr_CMSSW_12_3_0_pre5

Alignment/CocoaApplication/BuildFile.xml

@@ -2,6 +2,5 @@
 <use   name="root"/>
 <use   name="dd4hep"/>
 <use   name="Alignment/CocoaFit"/>
-<use   name="CondCore/DBOutputService"/>
 <use   name="DetectorDescription/DDCMS"/>
 <flags   EDM_PLUGIN="1"/>

Alignment/CocoaApplication/src/CocoaAnalyzer.cc

@@ -1,5 +1,4 @@
 #include "FWCore/ServiceRegistry/interface/Service.h"
-#include "CondCore/DBOutputService/interface/PoolDBOutputService.h"
 #include "CondFormats/DataRecord/interface/OpticalAlignmentsRcd.h"
 #include "CondFormats/OptAlignObjects/interface/OpticalAlignMeasurementInfo.h"
 #include <DD4hep/DD4hepUnits.h>

Alignment/CocoaFit/interface/CocoaDBMgr.h

@@ -15,6 +15,7 @@
 #include <string>
 #include <iostream>
 #include <map>
+#include <memory>
 
 class Event;
 class EventSetup;
@@ -45,13 +46,13 @@ class CocoaDBMgr {
   bool DumpCocoaResults();
 
 private:
-  OpticalAlignments* BuildOpticalAlignments();
+  std::unique_ptr<OpticalAlignments> BuildOpticalAlignments();
   double GetEntryError(const Entry* entry);
   double GetEntryError(const Entry* entry1, const Entry* entry2);
 
   OpticalAlignInfo GetOptAlignInfoFromOptO(OpticalObject* opto);
 
-  std::pair<Alignments*, AlignmentErrorsExtended*> BuildAlignments(bool bDT);
+  std::pair<std::unique_ptr<Alignments>, std::unique_ptr<AlignmentErrorsExtended> > BuildAlignments(bool bDT);
   AlignTransform* GetAlignInfoFromOptO(OpticalObject* opto);
   AlignTransformErrorExtended* GetAlignInfoErrorFromOptO(OpticalObject* opto);
 

Alignment/CocoaFit/src/CocoaDBMgr.cc

@@ -55,7 +55,7 @@ bool CocoaDBMgr::DumpCocoaResults() {
   cond::Time_t appendTime = Fit::nEvent + 1;
   if (gomgr->GlobalOptions()["writeDBOptAlign"] > 0) {
     //----- Build OpticalAlignments
-    OpticalAlignments* optalign = BuildOpticalAlignments();
+    std::unique_ptr<OpticalAlignments> optalign = BuildOpticalAlignments();
 
     //--- Dump OpticalAlignments
     nrcd = optalign->opticalAlignments_.size();
@@ -67,21 +67,11 @@ bool CocoaDBMgr::DumpCocoaResults() {
       std::cout << " new OA to DB "
                 << "begin " << myDbService->beginOfTime() << " current " << myDbService->currentTime() << " end "
                 << myDbService->endOfTime() << std::endl;
-      myDbService->createNewIOV<OpticalAlignments>(
-          optalign,
-          myDbService->beginOfTime(),
-          myDbService->endOfTime(),
-          //						   myDbService->endOfTime(),
-          "OpticalAlignmentsRcd");
+      myDbService->createOneIOV<OpticalAlignments>(*optalign, myDbService->beginOfTime(), "OpticalAlignmentsRcd");
     } else {
       std::cout << " old OA to DB "
                 << " current " << myDbService->currentTime() << " end " << myDbService->endOfTime() << std::endl;
-      myDbService->appendSinceTime<OpticalAlignments>(
-          optalign,
-          //		      myDbService->endOfTime(),
-          appendTime,
-          //						       myDbService->currentTime(),
-          "OpticalAlignmentsRcd");
+      myDbService->appendOneIOV<OpticalAlignments>(*optalign, appendTime, "OpticalAlignmentsRcd");
     }
 
     /*    }catch(const cond::Exception& er) {
@@ -98,60 +88,53 @@ bool CocoaDBMgr::DumpCocoaResults() {
 
   if (gomgr->GlobalOptions()["writeDBAlign"] > 0) {
     // Build DT alignments and errors
-    std::pair<Alignments*, AlignmentErrorsExtended*> dtali = BuildAlignments(true);
-    Alignments* dt_Alignments = dtali.first;
-    AlignmentErrorsExtended* dt_AlignmentErrors = dtali.second;
+    const auto& dtali = BuildAlignments(true);
+    auto& dt_Alignments = dtali.first;
+    auto& dt_AlignmentErrors = dtali.second;
 
     // Dump DT alignments and errors
     nrcd = dt_Alignments->m_align.size();
     if (myDbService->isNewTagRequest("DTAlignmentRcd")) {
-      myDbService->createNewIOV<Alignments>(
-          &(*dt_Alignments), myDbService->beginOfTime(), myDbService->endOfTime(), "DTAlignmentRcd");
+      myDbService->createOneIOV<Alignments>(*dt_Alignments, myDbService->beginOfTime(), "DTAlignmentRcd");
     } else {
-      myDbService->appendSinceTime<Alignments>(&(*dt_Alignments),
-                                               appendTime,
-                                               //					       myDbService->currentTime(),
-                                               "DTAlignmentRcd");
+      myDbService->appendOneIOV<Alignments>(*dt_Alignments, appendTime, "DTAlignmentRcd");
     }
     if (ALIUtils::debug >= 2)
       std::cout << "DTAlignmentRcd WRITTEN TO DB : " << nrcd << std::endl;
 
     nrcd = dt_AlignmentErrors->m_alignError.size();
     if (myDbService->isNewTagRequest("DTAlignmentErrorExtendedRcd")) {
-      myDbService->createNewIOV<AlignmentErrorsExtended>(
-          &(*dt_AlignmentErrors), myDbService->beginOfTime(), myDbService->endOfTime(), "DTAlignmentErrorExtendedRcd");
+      myDbService->createOneIOV<AlignmentErrorsExtended>(
+          *dt_AlignmentErrors, myDbService->beginOfTime(), "DTAlignmentErrorExtendedRcd");
     } else {
-      myDbService->appendSinceTime<AlignmentErrorsExtended>(
-          &(*dt_AlignmentErrors), appendTime, "DTAlignmentErrorExtendedRcd");
+      myDbService->appendOneIOV<AlignmentErrorsExtended>(
+          *dt_AlignmentErrors, appendTime, "DTAlignmentErrorExtendedRcd");
     }
     if (ALIUtils::debug >= 2)
       std::cout << "DTAlignmentErrorExtendedRcd WRITTEN TO DB : " << nrcd << std::endl;
 
     // Build CSC alignments and errors
-    std::pair<Alignments*, AlignmentErrorsExtended*> cscali = BuildAlignments(false);
-    Alignments* csc_Alignments = cscali.first;
-    AlignmentErrorsExtended* csc_AlignmentErrors = cscali.second;
+    const auto& cscali = BuildAlignments(false);
+    auto& csc_Alignments = cscali.first;
+    auto& csc_AlignmentErrors = cscali.second;
 
     // Dump CSC alignments and errors
     nrcd = csc_Alignments->m_align.size();
     if (myDbService->isNewTagRequest("CSCAlignmentRcd")) {
-      myDbService->createNewIOV<Alignments>(
-          &(*csc_Alignments), myDbService->beginOfTime(), myDbService->endOfTime(), "CSCAlignmentRcd");
+      myDbService->createOneIOV<Alignments>(*csc_Alignments, myDbService->beginOfTime(), "CSCAlignmentRcd");
     } else {
-      myDbService->appendSinceTime<Alignments>(&(*csc_Alignments), appendTime, "CSCAlignmentRcd");
+      myDbService->appendOneIOV<Alignments>(*csc_Alignments, appendTime, "CSCAlignmentRcd");
     }
     if (ALIUtils::debug >= 2)
       std::cout << "CSCAlignmentRcd WRITTEN TO DB : " << nrcd << std::endl;
 
     nrcd = csc_AlignmentErrors->m_alignError.size();
     if (myDbService->isNewTagRequest("CSCAlignmentErrorExtendedRcd")) {
-      myDbService->createNewIOV<AlignmentErrorsExtended>(&(*csc_AlignmentErrors),
-                                                         myDbService->beginOfTime(),
-                                                         myDbService->endOfTime(),
-                                                         "CSCAlignmentErrorExtendedRcd");
+      myDbService->createOneIOV<AlignmentErrorsExtended>(
+          *csc_AlignmentErrors, myDbService->beginOfTime(), "CSCAlignmentErrorExtendedRcd");
     } else {
-      myDbService->appendSinceTime<AlignmentErrorsExtended>(
-          &(*csc_AlignmentErrors), appendTime, "CSCAlignmentErrorExtendedRcd");
+      myDbService->appendOneIOV<AlignmentErrorsExtended>(
+          *csc_AlignmentErrors, appendTime, "CSCAlignmentErrorExtendedRcd");
     }
     if (ALIUtils::debug >= 2)
       std::cout << "CSCAlignmentErrorExtendedRcd WRITTEN TO DB : " << nrcd << std::endl;
@@ -280,8 +263,8 @@ double CocoaDBMgr::GetEntryError(const Entry* entry1, const Entry* entry2) {
 }
 
 //-----------------------------------------------------------------------
-OpticalAlignments* CocoaDBMgr::BuildOpticalAlignments() {
-  OpticalAlignments* optalign = new OpticalAlignments;
+std::unique_ptr<OpticalAlignments> CocoaDBMgr::BuildOpticalAlignments() {
+  std::unique_ptr<OpticalAlignments> optalign = std::make_unique<OpticalAlignments>();
 
   static std::vector<OpticalObject*> optolist = Model::OptOList();
   static std::vector<OpticalObject*>::const_iterator ite;
@@ -298,9 +281,9 @@ OpticalAlignments* CocoaDBMgr::BuildOpticalAlignments() {
 }
 
 //-----------------------------------------------------------------------
-std::pair<Alignments*, AlignmentErrorsExtended*> CocoaDBMgr::BuildAlignments(bool bDT) {
-  Alignments* alignments = new Alignments;
-  AlignmentErrorsExtended* alignmentErrors = new AlignmentErrorsExtended;
+std::pair<std::unique_ptr<Alignments>, std::unique_ptr<AlignmentErrorsExtended> > CocoaDBMgr::BuildAlignments(bool bDT) {
+  std::unique_ptr<Alignments> alignments = std::make_unique<Alignments>();
+  std::unique_ptr<AlignmentErrorsExtended> alignmentErrors = std::make_unique<AlignmentErrorsExtended>();
 
   //read
   static std::vector<OpticalObject*> optolist = Model::OptOList();
@@ -326,7 +309,8 @@ std::pair<Alignments*, AlignmentErrorsExtended*> CocoaDBMgr::BuildAlignments(boo
   if (ALIUtils::debug >= 4)
     std::cout << "CocoaDBMgr::BuildAlignments end with n alignment " << alignments->m_align.size()
               << " n alignmentError " << alignmentErrors->m_alignError.size() << std::endl;
-  return std::pair<Alignments*, AlignmentErrorsExtended*>(alignments, alignmentErrors);
+
+  return std::make_pair(std::move(alignments), std::move(alignmentErrors));
 }
 
 //-----------------------------------------------------------------------

Alignment/CommonAlignmentAlgorithm/interface/IntegratedCalibrationPluginFactory.h

@@ -13,7 +13,7 @@
 #include "FWCore/PluginManager/interface/PluginFactory.h"
 #include "Alignment/CommonAlignmentAlgorithm/interface/IntegratedCalibrationBase.h"
 
-typedef edmplugin::PluginFactory<IntegratedCalibrationBase*(const edm::ParameterSet&)>
+typedef edmplugin::PluginFactory<IntegratedCalibrationBase *(const edm::ParameterSet &, edm::ConsumesCollector &)>
     IntegratedCalibrationPluginFactory;
 
 #endif

Alignment/CommonAlignmentAlgorithm/plugins/SiPixelLorentzAngleCalibration.cc

@@ -23,7 +23,6 @@
 #include "DataFormats/DetId/interface/DetId.h"
 #include "DataFormats/SiPixelDetId/interface/PixelSubdetector.h"
 
-#include "FWCore/Framework/interface/ESHandle.h"
 #include "FWCore/Framework/interface/ESWatcher.h"
 #include "FWCore/Framework/interface/Run.h"
 #include "FWCore/MessageLogger/interface/MessageLogger.h"
@@ -37,6 +36,7 @@
 #include "MagneticField/Engine/interface/MagneticField.h"
 #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
 #include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h"
+#include "FWCore/Framework/interface/ConsumesCollector.h"
 
 #include "TTree.h"
 #include "TFile.h"
@@ -54,7 +54,7 @@
 class SiPixelLorentzAngleCalibration : public IntegratedCalibrationBase {
 public:
   /// Constructor
-  explicit SiPixelLorentzAngleCalibration(const edm::ParameterSet &cfg);
+  explicit SiPixelLorentzAngleCalibration(const edm::ParameterSet &cfg, edm::ConsumesCollector &iC);
 
   /// Destructor
   ~SiPixelLorentzAngleCalibration() override = default;
@@ -116,7 +116,8 @@ class SiPixelLorentzAngleCalibration : public IntegratedCalibrationBase {
   const std::string outFileName_;
   const std::vector<std::string> mergeFileNames_;
   const std::string lorentzAngleLabel_;
-
+  const edm::ESGetToken<SiPixelLorentzAngle, SiPixelLorentzAngleRcd> lorentzAngleToken_;
+  const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> magFieldToken_;
   edm::ESWatcher<SiPixelLorentzAngleRcd> watchLorentzAngleRcd_;
 
   // const AlignableTracker *alignableTracker_;
@@ -134,13 +135,15 @@ class SiPixelLorentzAngleCalibration : public IntegratedCalibrationBase {
 //======================================================================
 //======================================================================
 
-SiPixelLorentzAngleCalibration::SiPixelLorentzAngleCalibration(const edm::ParameterSet &cfg)
+SiPixelLorentzAngleCalibration::SiPixelLorentzAngleCalibration(const edm::ParameterSet &cfg, edm::ConsumesCollector &iC)
     : IntegratedCalibrationBase(cfg),
       saveToDB_(cfg.getParameter<bool>("saveToDB")),
       recordNameDBwrite_(cfg.getParameter<std::string>("recordNameDBwrite")),
       outFileName_(cfg.getParameter<std::string>("treeFile")),
       mergeFileNames_(cfg.getParameter<std::vector<std::string> >("mergeTreeFiles")),
       lorentzAngleLabel_(cfg.getParameter<std::string>("lorentzAngleLabel")),
+      lorentzAngleToken_(iC.esConsumes<edm::Transition::BeginRun>(edm::ESInputTag("", lorentzAngleLabel_))),
+      magFieldToken_(iC.esConsumes()),
       moduleGroupSelCfg_(cfg.getParameter<edm::ParameterSet>("LorentzAngleModuleGroups")) {}
 
 //======================================================================
@@ -165,9 +168,9 @@ void SiPixelLorentzAngleCalibration::beginRun(const edm::Run &run, const edm::Ev
     }
   }
 
-  edm::ESHandle<SiPixelLorentzAngle> lorentzAngleHandle;
+  const SiPixelLorentzAngle *lorentzAngleHandle = &setup.getData(lorentzAngleToken_);
   const auto &lorentzAngleRcd = setup.get<SiPixelLorentzAngleRcd>();
-  lorentzAngleRcd.get(lorentzAngleLabel_, lorentzAngleHandle);
+
   if (cachedLorentzAngleInputs_.find(firstRun) == cachedLorentzAngleInputs_.end()) {
     cachedLorentzAngleInputs_.emplace(firstRun, SiPixelLorentzAngle(*lorentzAngleHandle));
   } else {
@@ -202,8 +205,8 @@ unsigned int SiPixelLorentzAngleCalibration::derivatives(std::vector<ValuesIndex
     const int index =
         moduleGroupSelector_->getParameterIndexFromDetId(hit.det()->geographicalId(), eventInfo.eventId().run());
     if (index >= 0) {  // otherwise not treated
-      edm::ESHandle<MagneticField> magneticField;
-      setup.get<IdealMagneticFieldRecord>().get(magneticField);
+
+      const MagneticField *magneticField = &setup.getData(magFieldToken_);
       const GlobalVector bField(magneticField->inTesla(hit.det()->surface().position()));
       const LocalVector bFieldLocal(hit.det()->surface().toLocal(bField));
       const double dZ = hit.det()->surface().bounds().thickness();  // it is a float only...