MultiCluster-CaloParticle associator

Alignment/CommonAlignment/interface/AlignableObjectId.h

@@ -7,6 +7,7 @@
 class TrackerGeometry;
 class DTGeometry;
 class CSCGeometry;
+class GEMGeometry;
 
 /// Allows conversion between type and name, and vice-versa
 class AlignableObjectId {
@@ -15,7 +16,7 @@ class AlignableObjectId {
   enum class Geometry { RunI, PhaseI, PhaseII, General, Unspecified };
 
   AlignableObjectId(Geometry);
-  AlignableObjectId(const TrackerGeometry*, const DTGeometry*, const CSCGeometry*);
+  AlignableObjectId(const TrackerGeometry*, const DTGeometry*, const CSCGeometry*, const GEMGeometry*);
   AlignableObjectId(const AlignableObjectId&) = default;
   AlignableObjectId& operator=(const AlignableObjectId&) = default;
   AlignableObjectId(AlignableObjectId&&) = default;
@@ -43,7 +44,7 @@ class AlignableObjectId {
 
 private:
   static Geometry trackerGeometry(const TrackerGeometry*);
-  static Geometry muonGeometry(const DTGeometry*, const CSCGeometry*);
+  static Geometry muonGeometry(const DTGeometry*, const CSCGeometry*, const GEMGeometry*);
 
   const entry* entries_{nullptr};
   Geometry geometry_{Geometry::Unspecified};

Alignment/CommonAlignment/interface/StructureType.h

@@ -81,6 +81,12 @@ namespace align {
     AlignableCSCRing,
     AlignableCSCChamber,
     AlignableCSCLayer,  // = 110
+    AlignableGEMEndcap,
+    AlignableGEMStation,
+    AlignableGEMRing,
+    AlignableGEMSuperChamber,
+    AlignableGEMChamber,
+    AlignableGEMEtaPartition,
     AlignableMuon,
 
     Detector,  // = 112 (what for?)

Alignment/CommonAlignment/src/AlignableCompositeBuilder.cc

@@ -18,7 +18,7 @@ AlignableCompositeBuilder ::AlignableCompositeBuilder(const TrackerTopology* tra
                                                       const TrackerGeometry* trackerGeometry,
                                                       const AlignableIndexer& alignableIndexer)
     : trackerTopology_(trackerTopology),
-      alignableObjectId_(trackerGeometry, nullptr, nullptr),
+      alignableObjectId_(trackerGeometry, nullptr, nullptr, nullptr),
       alignableIndexer_(alignableIndexer) {}
 
 //_____________________________________________________________________________

Alignment/CommonAlignment/src/AlignableObjectId.cc

@@ -135,6 +135,12 @@ namespace {
                                                       {align::AlignableCSCRing, "CSCRing"},
                                                       {align::AlignableCSCChamber, "CSCChamber"},
                                                       {align::AlignableCSCLayer, "CSCLayer"},
+                                                      {align::AlignableGEMEndcap, "GEMEndcap"},
+                                                      {align::AlignableGEMStation, "GEMStation"},
+                                                      {align::AlignableGEMRing, "GEMRing"},
+                                                      {align::AlignableGEMSuperChamber, "GEMSuperChamber"},
+                                                      {align::AlignableGEMChamber, "GEMChamber"},
+                                                      {align::AlignableGEMEtaPartition, "GEMEtaPartition"},
                                                       {align::AlignableMuon, "Muon"},
 
                                                       {align::BeamSpot, "BeamSpot"},
@@ -201,6 +207,12 @@ namespace {
                                                        {align::AlignableCSCRing, "CSCRing"},
                                                        {align::AlignableCSCChamber, "CSCChamber"},
                                                        {align::AlignableCSCLayer, "CSCLayer"},
+                                                       {align::AlignableGEMEndcap, "GEMEndcap"},
+                                                       {align::AlignableGEMStation, "GEMStation"},
+                                                       {align::AlignableGEMRing, "GEMRing"},
+                                                       {align::AlignableGEMSuperChamber, "GEMSuperChamber"},
+                                                       {align::AlignableGEMChamber, "GEMChamber"},
+                                                       {align::AlignableGEMEtaPartition, "GEMEtaPartition"},
                                                        {align::AlignableMuon, "Muon"},
 
                                                        {align::BeamSpot, "BeamSpot"},
@@ -246,8 +258,9 @@ AlignableObjectId ::AlignableObjectId(AlignableObjectId::Geometry geometry) : ge
 //_____________________________________________________________________________
 AlignableObjectId ::AlignableObjectId(const TrackerGeometry *tracker,
                                       const DTGeometry *muonDt,
-                                      const CSCGeometry *muonCsc)
-    : AlignableObjectId(commonGeometry(trackerGeometry(tracker), muonGeometry(muonDt, muonCsc))) {}
+                                      const CSCGeometry *muonCsc,
+                                      const GEMGeometry *muonGem)
+    : AlignableObjectId(commonGeometry(trackerGeometry(tracker), muonGeometry(muonDt, muonCsc, muonGem))) {}
 
 //_____________________________________________________________________________
 align::StructureType AlignableObjectId::nameToType(const std::string &name) const { return stringToId(name.c_str()); }
@@ -299,7 +312,9 @@ AlignableObjectId::Geometry AlignableObjectId ::trackerGeometry(const TrackerGeo
   }
 }
 
-AlignableObjectId::Geometry AlignableObjectId ::muonGeometry(const DTGeometry *, const CSCGeometry *) {
+AlignableObjectId::Geometry AlignableObjectId ::muonGeometry(const DTGeometry *,
+                                                             const CSCGeometry *,
+                                                             const GEMGeometry *) {
   // muon alignment structure types are identical for all kinds of geometries
   return Geometry::General;
 }

Alignment/CommonAlignmentMonitor/plugins/AlignmentMonitorAsAnalyzer.cc

@@ -39,6 +39,7 @@
 #include "Geometry/TrackerGeometryBuilder/interface/TrackerGeomBuilderFromGeometricDet.h"
 #include "Geometry/DTGeometry/interface/DTGeometry.h"
 #include "Geometry/CSCGeometry/interface/CSCGeometry.h"
+#include "Geometry/GEMGeometry/interface/GEMGeometry.h"
 #include "Geometry/Records/interface/TrackerTopologyRcd.h"
 #include "Geometry/CommonTopologies/interface/GeometryAligner.h"
 #include "CondFormats/GeometryObjects/interface/PTrackerParameters.h"
@@ -50,6 +51,8 @@
 #include "CondFormats/AlignmentRecord/interface/DTAlignmentErrorExtendedRcd.h"
 #include "CondFormats/AlignmentRecord/interface/CSCAlignmentRcd.h"
 #include "CondFormats/AlignmentRecord/interface/CSCAlignmentErrorExtendedRcd.h"
+#include "CondFormats/AlignmentRecord/interface/GEMAlignmentRcd.h"
+#include "CondFormats/AlignmentRecord/interface/GEMAlignmentErrorExtendedRcd.h"
 #include "CondFormats/AlignmentRecord/interface/GlobalPositionRcd.h"
 #include "CondFormats/Alignment/interface/DetectorGlobalPosition.h"
 
@@ -81,7 +84,16 @@ class AlignmentMonitorAsAnalyzer : public edm::EDAnalyzer {
   std::unique_ptr<AlignmentParameterStore> m_alignmentParameterStore;
 
   std::vector<std::unique_ptr<AlignmentMonitorBase>> m_monitors;
-  std::string idealGeometryLabel;
+  edm::ESGetToken<DTGeometry, MuonGeometryRecord> esTokenDT_;
+  edm::ESGetToken<CSCGeometry, MuonGeometryRecord> esTokenCSC_;
+  edm::ESGetToken<GEMGeometry, MuonGeometryRecord> esTokenGEM_;
+  edm::ESGetToken<Alignments, GlobalPositionRcd> esTokenGPR_;
+  edm::ESGetToken<Alignments, DTAlignmentRcd> esTokenDTAl_;
+  edm::ESGetToken<AlignmentErrorsExtended, DTAlignmentErrorExtendedRcd> esTokenDTAPE_;
+  edm::ESGetToken<Alignments, CSCAlignmentRcd> esTokenCSCAl_;
+  edm::ESGetToken<AlignmentErrorsExtended, CSCAlignmentErrorExtendedRcd> esTokenCSCAPE_;
+  edm::ESGetToken<Alignments, GEMAlignmentRcd> esTokenGEMAl_;
+  edm::ESGetToken<AlignmentErrorsExtended, GEMAlignmentErrorExtendedRcd> esTokenGEMAPE_;
   bool m_firstEvent;
 };
 
@@ -99,7 +111,9 @@ class AlignmentMonitorAsAnalyzer : public edm::EDAnalyzer {
 AlignmentMonitorAsAnalyzer::AlignmentMonitorAsAnalyzer(const edm::ParameterSet& iConfig)
     : m_tjTag(iConfig.getParameter<edm::InputTag>("tjTkAssociationMapTag")),
       m_aliParamStoreCfg(iConfig.getParameter<edm::ParameterSet>("ParameterStore")),
-      idealGeometryLabel("idealForAlignmentMonitorAsAnalyzer") {
+      esTokenDT_(esConsumes(edm::ESInputTag("", "idealForAlignmentMonitorAsAnalyzer"))),
+      esTokenCSC_(esConsumes(edm::ESInputTag("", "idealForAlignmentMonitorAsAnalyzer"))),
+      esTokenGEM_(esConsumes(edm::ESInputTag("", "idealForAlignmentMonitorAsAnalyzer"))) {
   std::vector<std::string> monitors = iConfig.getUntrackedParameter<std::vector<std::string>>("monitors");
 
   for (auto const& mon : monitors) {
@@ -129,13 +143,11 @@ void AlignmentMonitorAsAnalyzer::analyze(const edm::Event& iEvent, const edm::Ev
     TrackerGeomBuilderFromGeometricDet trackerBuilder;
     std::shared_ptr<TrackerGeometry> theTracker(trackerBuilder.build(&(*theGeometricDet), *ptp, tTopo));
 
-    edm::ESHandle<DTGeometry> theMuonDT;
-    edm::ESHandle<CSCGeometry> theMuonCSC;
-    iSetup.get<MuonGeometryRecord>().get(idealGeometryLabel, theMuonDT);
-    iSetup.get<MuonGeometryRecord>().get(idealGeometryLabel, theMuonCSC);
+    edm::ESHandle<DTGeometry> theMuonDT = iSetup.getHandle(esTokenDT_);
+    edm::ESHandle<CSCGeometry> theMuonCSC = iSetup.getHandle(esTokenCSC_);
+    edm::ESHandle<GEMGeometry> theMuonGEM = iSetup.getHandle(esTokenGEM_);
 
-    edm::ESHandle<Alignments> globalPositionRcd;
-    iSetup.get<GlobalPositionRcd>().get(globalPositionRcd);
+    edm::ESHandle<Alignments> globalPositionRcd = iSetup.getHandle(esTokenGPR_);
 
     edm::ESHandle<Alignments> alignments;
     iSetup.get<TrackerAlignmentRcd>().get(alignments);
@@ -146,29 +158,33 @@ void AlignmentMonitorAsAnalyzer::analyze(const edm::Event& iEvent, const edm::Ev
                                              &(*alignmentErrors),
                                              align::DetectorGlobalPosition(*globalPositionRcd, DetId(DetId::Tracker)));
 
-    edm::ESHandle<Alignments> dtAlignments;
-    iSetup.get<DTAlignmentRcd>().get(dtAlignments);
-    edm::ESHandle<AlignmentErrorsExtended> dtAlignmentErrorsExtended;
-    iSetup.get<DTAlignmentErrorExtendedRcd>().get(dtAlignmentErrorsExtended);
+    edm::ESHandle<Alignments> dtAlignments = iSetup.getHandle(esTokenDTAl_);
+    ;
+    edm::ESHandle<AlignmentErrorsExtended> dtAlignmentErrorsExtended = iSetup.getHandle(esTokenDTAPE_);
     aligner.applyAlignments<DTGeometry>(&(*theMuonDT),
                                         &(*dtAlignments),
                                         &(*dtAlignmentErrorsExtended),
                                         align::DetectorGlobalPosition(*globalPositionRcd, DetId(DetId::Muon)));
 
-    edm::ESHandle<Alignments> cscAlignments;
-    iSetup.get<CSCAlignmentRcd>().get(cscAlignments);
-    edm::ESHandle<AlignmentErrorsExtended> cscAlignmentErrorsExtended;
-    iSetup.get<CSCAlignmentErrorExtendedRcd>().get(cscAlignmentErrorsExtended);
+    edm::ESHandle<Alignments> cscAlignments = iSetup.getHandle(esTokenCSCAl_);
+    edm::ESHandle<AlignmentErrorsExtended> cscAlignmentErrorsExtended = iSetup.getHandle(esTokenCSCAPE_);
     aligner.applyAlignments<CSCGeometry>(&(*theMuonCSC),
                                          &(*cscAlignments),
                                          &(*cscAlignmentErrorsExtended),
                                          align::DetectorGlobalPosition(*globalPositionRcd, DetId(DetId::Muon)));
 
+    edm::ESHandle<Alignments> gemAlignments = iSetup.getHandle(esTokenGEMAl_);
+    edm::ESHandle<AlignmentErrorsExtended> gemAlignmentErrorsExtended = iSetup.getHandle(esTokenGEMAPE_);
+    aligner.applyAlignments<GEMGeometry>(&(*theMuonGEM),
+                                         &(*gemAlignments),
+                                         &(*gemAlignmentErrorsExtended),
+                                         align::DetectorGlobalPosition(*globalPositionRcd, DetId(DetId::Muon)));
+
     // within an analyzer, modules can't expect to see any selected alignables!
     align::Alignables empty_alignables;
 
     m_alignableTracker = std::make_unique<AlignableTracker>(&(*theTracker), tTopo);
-    m_alignableMuon = std::make_unique<AlignableMuon>(&(*theMuonDT), &(*theMuonCSC));
+    m_alignableMuon = std::make_unique<AlignableMuon>(&(*theMuonDT), &(*theMuonCSC), &(*theMuonGEM));
     m_alignmentParameterStore = std::make_unique<AlignmentParameterStore>(empty_alignables, m_aliParamStoreCfg);
 
     for (auto const& monitor : m_monitors) {

Alignment/CommonAlignmentProducer/interface/AlignmentProducerBase.h

@@ -51,6 +51,7 @@
 
 #include "Geometry/DTGeometry/interface/DTGeometry.h"
 #include "Geometry/CSCGeometry/interface/CSCGeometry.h"
+#include "Geometry/GEMGeometry/interface/GEMGeometry.h"
 #include "Geometry/CommonTopologies/interface/GeometryAligner.h"
 #include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
 #include "Geometry/Records/interface/IdealGeometryRecord.h"
@@ -114,6 +115,7 @@ class AlignmentProducerBase {
   std::shared_ptr<TrackerGeometry> trackerGeometry_;
   edm::ESHandle<DTGeometry> muonDTGeometry_;
   edm::ESHandle<CSCGeometry> muonCSCGeometry_;
+  edm::ESHandle<GEMGeometry> muonGEMGeometry_;
   const bool doTracker_, doMuon_, useExtras_;
 
   /// Map with tracks/trajectories

Alignment/CommonAlignmentProducer/src/AlignmentProducerBase.cc

@@ -425,6 +425,7 @@ void AlignmentProducerBase::createGeometries(const edm::EventSetup& iSetup, cons
   if (doMuon_) {
     iSetup.get<MuonGeometryRecord>().get(idealGeometryLabel, muonDTGeometry_);
     iSetup.get<MuonGeometryRecord>().get(idealGeometryLabel, muonCSCGeometry_);
+    iSetup.get<MuonGeometryRecord>().get(idealGeometryLabel, muonGEMGeometry_);
   }
 }
 
@@ -452,6 +453,9 @@ void AlignmentProducerBase::applyAlignmentsToDB(const edm::EventSetup& setup) {
 
       applyDB<CSCGeometry, CSCAlignmentRcd, CSCAlignmentErrorExtendedRcd>(
           &*muonCSCGeometry_, setup, align::DetectorGlobalPosition(*globalPositions_, DetId(DetId::Muon)));
+
+      applyDB<GEMGeometry, GEMAlignmentRcd, GEMAlignmentErrorExtendedRcd>(
+          &*muonGEMGeometry_, setup, align::DetectorGlobalPosition(*globalPositions_, DetId(DetId::Muon)));
     }
   }
 }
@@ -468,9 +472,9 @@ void AlignmentProducerBase::createAlignables(const TrackerTopology* tTopo, bool
 
   if (doMuon_) {
     if (update) {
-      alignableMuon_->update(&*muonDTGeometry_, &*muonCSCGeometry_);
+      alignableMuon_->update(&*muonDTGeometry_, &*muonCSCGeometry_, &*muonGEMGeometry_);
     } else {
-      alignableMuon_ = std::make_unique<AlignableMuon>(&*muonDTGeometry_, &*muonCSCGeometry_);
+      alignableMuon_ = std::make_unique<AlignableMuon>(&*muonDTGeometry_, &*muonCSCGeometry_, &*muonGEMGeometry_);
     }
   }
 
@@ -646,12 +650,15 @@ void AlignmentProducerBase::applyAlignmentsToGeometry() {
 
     std::unique_ptr<Alignments> dtAlignments{alignableMuon_->dtAlignments()};
     std::unique_ptr<Alignments> cscAlignments{alignableMuon_->cscAlignments()};
+    std::unique_ptr<Alignments> gemAlignments{alignableMuon_->gemAlignments()};
 
     std::unique_ptr<AlignmentErrorsExtended> dtAlignmentErrExt{alignableMuon_->dtAlignmentErrorsExtended()};
     std::unique_ptr<AlignmentErrorsExtended> cscAlignmentErrExt{alignableMuon_->cscAlignmentErrorsExtended()};
+    std::unique_ptr<AlignmentErrorsExtended> gemAlignmentErrExt{alignableMuon_->gemAlignmentErrorsExtended()};
 
     aligner.applyAlignments(&*muonDTGeometry_, dtAlignments.get(), dtAlignmentErrExt.get(), AlignTransform());
     aligner.applyAlignments(&*muonCSCGeometry_, cscAlignments.get(), cscAlignmentErrExt.get(), AlignTransform());
+    aligner.applyAlignments(&*muonGEMGeometry_, gemAlignments.get(), gemAlignmentErrExt.get(), AlignTransform());
   }
 }
 

Alignment/LaserAlignment/plugins/LaserAlignment.cc

@@ -17,7 +17,13 @@
 ///
 ///
 LaserAlignment::LaserAlignment(edm::ParameterSet const& theConf)
-    : theEvents(0),
+    : topoToken_(esConsumes()),
+      geomToken_(esConsumes()),
+      geomDetToken_(esConsumes()),
+      ptpToken_(esConsumes()),
+      gprToken_(esConsumes()),
+      stripPedestalsToken_(esConsumes()),
+      theEvents(0),
       theDoPedestalSubtraction(theConf.getUntrackedParameter<bool>("SubtractPedestals", true)),
       theUseMinuitAlgorithm(theConf.getUntrackedParameter<bool>("RunMinuitAlignmentTubeAlgorithm", false)),
       theApplyBeamKinkCorrections(theConf.getUntrackedParameter<bool>("ApplyBeamKinkCorrections", true)),
@@ -271,32 +277,28 @@ void LaserAlignment::beginJob() {
 void LaserAlignment::produce(edm::Event& theEvent, edm::EventSetup const& theSetup) {
   if (firstEvent_) {
     //Retrieve tracker topology from geometry
-    edm::ESHandle<TrackerTopology> tTopoHandle;
-    theSetup.get<TrackerTopologyRcd>().get(tTopoHandle);
-    const TrackerTopology* const tTopo = tTopoHandle.product();
+    const TrackerTopology* const tTopo = &theSetup.getData(topoToken_);
 
     // access the tracker
-    theSetup.get<TrackerDigiGeometryRecord>().get(theTrackerGeometry);
-    theSetup.get<IdealGeometryRecord>().get(gD);
+    gD = theSetup.getHandle(geomDetToken_);
+    theTrackerGeometry = theSetup.getHandle(geomToken_);
 
     // access pedestals (from db..) if desired
     edm::ESHandle<SiStripPedestals> pedestalsHandle;
     if (theDoPedestalSubtraction) {
-      theSetup.get<SiStripPedestalsRcd>().get(pedestalsHandle);
+      pedestalsHandle = theSetup.getHandle(stripPedestalsToken_);
       fillPedestalProfiles(pedestalsHandle);
     }
 
     // global positions
-    //  edm::ESHandle<Alignments> theGlobalPositionRcd;
-    theSetup.get<TrackerDigiGeometryRecord>().getRecord<GlobalPositionRcd>().get(theGlobalPositionRcd);
+    theGlobalPositionRcd = &theSetup.getData(gprToken_);
 
     // select the reference geometry
     if (!updateFromInputGeometry) {
       // the AlignableTracker object is initialized with the ideal geometry
-      edm::ESHandle<GeometricDet> theGeometricDet;
-      theSetup.get<IdealGeometryRecord>().get(theGeometricDet);
-      edm::ESHandle<PTrackerParameters> ptp;
-      theSetup.get<PTrackerParametersRcd>().get(ptp);
+      const GeometricDet* theGeometricDet = &theSetup.getData(geomDetToken_);
+      const PTrackerParameters* ptp = &theSetup.getData(ptpToken_);
+
       TrackerGeomBuilderFromGeometricDet trackerBuilder;
       TrackerGeometry* theRefTracker = trackerBuilder.build(&*theGeometricDet, *ptp, tTopo);
 

Alignment/LaserAlignment/plugins/LaserAlignment.h

@@ -127,6 +127,14 @@ class LaserAlignment : public edm::one::EDProducer<edm::EndRunProducer> {
                                  LASGlobalData<LASCoordinateSet>&,
                                  LASBarrelAlignmentParameterSet&);
 
+  /// Tokens for ESconsumes
+  const edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> topoToken_;
+  const edm::ESGetToken<TrackerGeometry, TrackerDigiGeometryRecord> geomToken_;
+  const edm::ESGetToken<GeometricDet, IdealGeometryRecord> geomDetToken_;
+  const edm::ESGetToken<PTrackerParameters, PTrackerParametersRcd> ptpToken_;
+  const edm::ESGetToken<Alignments, GlobalPositionRcd> gprToken_;
+  const edm::ESGetToken<SiStripPedestals, SiStripPedestalsRcd> stripPedestalsToken_;
+
   /// counter for the total number of events processed
   int theEvents;