Barycenter histograms for TkDQM

DQM/SiPixelPhase1Config/python/SiPixelPhase1OfflineDQM_harvesting_cff.py

@@ -14,6 +14,7 @@
                                                 + SiPixelPhase1RawDataHarvester
                                                 + RunQTests_offline
                                                 + SiPixelPhase1SummaryOffline
+                                                + SiPixelBarycenterOffline
                                                   )
 
 siPixelPhase1OfflineDQM_harvesting_cosmics = siPixelPhase1OfflineDQM_harvesting.copyAndExclude([

DQM/SiPixelPhase1Config/python/SiPixelPhase1OfflineDQM_source_cff.py

@@ -19,6 +19,8 @@
 from DQM.SiPixelPhase1Common.SiPixelPhase1RawData_cfi import *
 #Summary maps
 from DQM.SiPixelPhase1Summary.SiPixelPhase1Summary_cfi import *
+#Barycenter plots
+from DQM.SiPixelPhase1Summary.SiPixelBarycenter_cfi import *
 
 from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import *
 from RecoLocalTracker.SiStripClusterizer.SiStripClusterChargeCut_cfi import *

DQM/SiPixelPhase1Summary/BuildFile.xml

@@ -5,5 +5,6 @@
 <use name="Geometry/CommonDetUnit"/>
 <use name="Geometry/Records"/>
 <use name="Geometry/TrackerGeometryBuilder"/>
+<use name="Alignment/TrackerAlignment"/>
 <use name="boost"/>
 <flags EDM_PLUGIN="1"/>

DQM/SiPixelPhase1Summary/interface/SiPixelBarycenter.h

@@ -0,0 +1,69 @@
+#ifndef DQM_SiPixelPhase1Summary_SiPixelBarycenter_h
+#define DQM_SiPixelPhase1Summary_SiPixelBarycenter_h
+// -*- C++ -*-
+//
+// Package:     SiPixelPhase1Summary
+// Class  :     SiPixelBarycenter
+//
+/**
+
+ Description: Barycenter plot generation for the Phase 1 pixel
+
+ Usage:
+    <usage>
+
+*/
+//
+// Original Author:  Danilo Meuser
+//         Created:  26th May 2021
+//
+
+// user include files
+#include "FWCore/Framework/interface/MakerMacros.h"
+
+#include "DQMServices/Core/interface/DQMStore.h"
+#include "DQMServices/Core/interface/DQMEDHarvester.h"
+
+#include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/Framework/interface/LuminosityBlock.h"
+
+#include "CondFormats/AlignmentRecord/interface/TrackerAlignmentRcd.h"
+#include "CondFormats/AlignmentRecord/interface/GlobalPositionRcd.h"
+#include "CondFormats/Alignment/interface/Alignments.h"
+
+#include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
+#include "Geometry/Records/interface/TrackerTopologyRcd.h"
+
+class SiPixelBarycenter : public DQMEDHarvester {
+public:
+  explicit SiPixelBarycenter(const edm::ParameterSet& conf);
+  ~SiPixelBarycenter() override;
+
+protected:
+  void beginRun(edm::Run const& run, edm::EventSetup const& eSetup) override;
+
+  void dqmEndLuminosityBlock(DQMStore::IBooker& iBooker,
+                             DQMStore::IGetter& iGetter,
+                             edm::LuminosityBlock const& lumiSeg,
+                             edm::EventSetup const& c) override;
+  void dqmEndJob(DQMStore::IBooker& iBooker, DQMStore::IGetter& iGetter) override;
+
+private:
+  const edm::ESGetToken<Alignments, TrackerAlignmentRcd> alignmentToken_;
+  const edm::ESGetToken<Alignments, GlobalPositionRcd> gprToken_;
+  const edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> trackerTopologyToken_;
+
+  std::map<std::string, MonitorElement*> barycenters_;
+
+  //book the barycenter histograms
+  void bookBarycenterHistograms(DQMStore::IBooker& iBooker);
+
+  //fill the barycenter histograms
+  void fillBarycenterHistograms(DQMStore::IBooker& iBooker,
+                                DQMStore::IGetter& iGetter,
+                                const std::vector<AlignTransform>& input,
+                                const std::vector<AlignTransform>& GPR,
+                                const TrackerTopology& tTopo);
+};
+
+#endif

DQM/SiPixelPhase1Summary/interface/SiPixelBarycenterHelper.h

@@ -0,0 +1,224 @@
+#ifndef DQM_SiPixelPhase1Summary_SiPixelBarycenterHelper_h
+#define DQM_SiPixelPhase1Summary_SiPixelBarycenterHelper_h
+
+#include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+#include "CondFormats/Alignment/interface/Alignments.h"
+#include "Alignment/TrackerAlignment/interface/TrackerNameSpace.h"
+#include "DataFormats/TrackerCommon/interface/PixelBarrelName.h"
+#include "DataFormats/TrackerCommon/interface/PixelEndcapName.h"
+
+// Helper mainly based on https://github.com/cms-sw/cmssw/blob/master/CondCore/AlignmentPlugins/interface/AlignmentPayloadInspectorHelper.h
+
+namespace DQMBarycenter {
+
+  enum coordinate {
+    t_x = 1,
+    t_y = 2,
+    t_z = 3,
+    rot_alpha = 4,
+    rot_beta = 5,
+    rot_gamma = 6,
+  };
+
+  enum partitions {
+    BPix = 1,
+    FPix_zp = 2,
+    FPix_zm = 3,
+    BPix_xp = 4,
+    BPix_xm = 5,
+    FPix_zp_xp = 6,
+    FPix_zm_xp = 7,
+    FPix_zp_xm = 8,
+    FPix_zm_xm = 9,
+  };
+
+  enum class PARTITION {
+    BPIX,        // 0 Barrel Pixel
+    FPIX_zp,     // 1 Forward Pixel Z-Plus
+    FPIX_zm,     // 2 Forward Pixel Z-Minus
+    BPIX_xp,     // 3 Barrel Pixel X-Plus
+    BPIX_xm,     // 4 Barrel Pixel X-Minus
+    FPIX_zp_xp,  // 5 Forward Pixel Z-Plus X-Plus
+    FPIX_zm_xp,  // 6 Forward Pixel Z-Minus X-Plus
+    FPIX_zp_xm,  // 7 Forward Pixel Z-Plus X-Minus
+    FPIX_zm_xm,  // 8 Forward Pixel Z-Minus X-Minus
+    LAST = FPIX_zm_xm
+  };
+
+  extern const PARTITION PARTITIONS[(int)PARTITION::LAST + 1];
+  const PARTITION PARTITIONS[] = {
+      PARTITION::BPIX,
+      PARTITION::FPIX_zp,
+      PARTITION::FPIX_zm,
+      PARTITION::BPIX_xp,
+      PARTITION::BPIX_xm,
+      PARTITION::FPIX_zp_xp,
+      PARTITION::FPIX_zm_xp,
+      PARTITION::FPIX_zp_xm,
+      PARTITION::FPIX_zm_xm,
+  };
+
+  class TkAlBarycenters {
+    std::map<DQMBarycenter::PARTITION, double> Xbarycenters;
+    std::map<DQMBarycenter::PARTITION, double> Ybarycenters;
+    std::map<DQMBarycenter::PARTITION, double> Zbarycenters;
+    std::map<DQMBarycenter::PARTITION, double> nmodules;
+
+  public:
+    inline void init();
+
+    /*--------------------------------------------------------------------*/
+    inline const std::array<double, 9> getX()
+    /*--------------------------------------------------------------------*/
+    {
+      return {{Xbarycenters[PARTITION::BPIX],
+               Xbarycenters[PARTITION::FPIX_zm],
+               Xbarycenters[PARTITION::FPIX_zp],
+               Xbarycenters[PARTITION::BPIX_xp],
+               Xbarycenters[PARTITION::BPIX_xm],
+               Xbarycenters[PARTITION::FPIX_zp_xp],
+               Xbarycenters[PARTITION::FPIX_zm_xp],
+               Xbarycenters[PARTITION::FPIX_zp_xm],
+               Xbarycenters[PARTITION::FPIX_zm_xm]}};
+    };
+
+    /*--------------------------------------------------------------------*/
+    inline const std::array<double, 9> getY()
+    /*--------------------------------------------------------------------*/
+    {
+      return {{Ybarycenters[PARTITION::BPIX],
+               Ybarycenters[PARTITION::FPIX_zm],
+               Ybarycenters[PARTITION::FPIX_zp],
+               Ybarycenters[PARTITION::BPIX_xp],
+               Ybarycenters[PARTITION::BPIX_xm],
+               Ybarycenters[PARTITION::FPIX_zp_xp],
+               Ybarycenters[PARTITION::FPIX_zm_xp],
+               Ybarycenters[PARTITION::FPIX_zp_xm],
+               Ybarycenters[PARTITION::FPIX_zm_xm]}};
+    };
+
+    /*--------------------------------------------------------------------*/
+    inline const std::array<double, 9> getZ()
+    /*--------------------------------------------------------------------*/
+    {
+      return {{Zbarycenters[PARTITION::BPIX],
+               Zbarycenters[PARTITION::FPIX_zm],
+               Zbarycenters[PARTITION::FPIX_zp],
+               Zbarycenters[PARTITION::BPIX_xp],
+               Zbarycenters[PARTITION::BPIX_xm],
+               Zbarycenters[PARTITION::FPIX_zp_xp],
+               Zbarycenters[PARTITION::FPIX_zm_xp],
+               Zbarycenters[PARTITION::FPIX_zp_xm],
+               Zbarycenters[PARTITION::FPIX_zm_xm]}};
+    };
+    inline virtual ~TkAlBarycenters() {}
+
+    /*--------------------------------------------------------------------*/
+    inline void computeBarycenters(const std::vector<AlignTransform>& input,
+                                   const TrackerTopology& tTopo,
+                                   const std::map<DQMBarycenter::coordinate, float>& GPR)
+    /*--------------------------------------------------------------------*/
+    {
+      for (const auto& ali : input) {
+        if (DetId(ali.rawId()).det() != DetId::Tracker) {
+          edm::LogWarning("SiPixelBarycenters::computeBarycenters")
+              << "Encountered invalid Tracker DetId:" << ali.rawId() << " " << DetId(ali.rawId()).det()
+              << " is different from " << DetId::Tracker << "  - terminating ";
+          assert(DetId(ali.rawId()).det() != DetId::Tracker);
+        }
+
+        const auto& tns = align::TrackerNameSpace(&tTopo);
+        int subid = DetId(ali.rawId()).subdetId();
+        if (subid == PixelSubdetector::PixelBarrel || subid == PixelSubdetector::PixelEndcap) {  // use only pixel
+          switch (subid) {  // Separate BPIX, FPIX_zp and FPIX_zm
+            case PixelSubdetector::PixelBarrel:
+              Xbarycenters[PARTITION::BPIX] += (ali.translation().x());
+              Ybarycenters[PARTITION::BPIX] += (ali.translation().y());
+              Zbarycenters[PARTITION::BPIX] += (ali.translation().z());
+              nmodules[PARTITION::BPIX]++;
+              break;
+            case PixelSubdetector::PixelEndcap:
+              // minus side
+              if (tns.tpe().endcapNumber(ali.rawId()) == 1) {
+                Xbarycenters[PARTITION::FPIX_zm] += (ali.translation().x());
+                Ybarycenters[PARTITION::FPIX_zm] += (ali.translation().y());
+                Zbarycenters[PARTITION::FPIX_zm] += (ali.translation().z());
+                nmodules[PARTITION::FPIX_zm]++;
+              }  // plus side
+              else {
+                Xbarycenters[PARTITION::FPIX_zp] += (ali.translation().x());
+                Ybarycenters[PARTITION::FPIX_zp] += (ali.translation().y());
+                Zbarycenters[PARTITION::FPIX_zp] += (ali.translation().z());
+                nmodules[PARTITION::FPIX_zp]++;
+              }
+              break;
+            default:
+              edm::LogError("PixelDQM") << "Unrecognized partition for barycenter computation " << subid << std::endl;
+              break;
+          }
+
+          switch (subid) {  // Separate following the PCL HLS
+            case PixelSubdetector::PixelBarrel:
+              if ((PixelBarrelName(DetId(ali.rawId()), true).shell() == PixelBarrelName::mO) ||
+                  (PixelBarrelName(DetId(ali.rawId()), true).shell() == PixelBarrelName::pO)) {  // BPIX x-
+                Xbarycenters[PARTITION::BPIX_xm] += (ali.translation().x());
+                Ybarycenters[PARTITION::BPIX_xm] += (ali.translation().y());
+                Zbarycenters[PARTITION::BPIX_xm] += (ali.translation().z());
+                nmodules[PARTITION::BPIX_xm]++;
+              } else {  // BPIX x+
+                Xbarycenters[PARTITION::BPIX_xp] += (ali.translation().x());
+                Ybarycenters[PARTITION::BPIX_xp] += (ali.translation().y());
+                Zbarycenters[PARTITION::BPIX_xp] += (ali.translation().z());
+                nmodules[PARTITION::BPIX_xp]++;
+              }
+              break;
+            case PixelSubdetector::PixelEndcap:
+              if (PixelEndcapName(DetId(ali.rawId()), true).halfCylinder() == PixelEndcapName::mO) {  //FPIX z- x-
+                Xbarycenters[PARTITION::FPIX_zm_xm] += (ali.translation().x());
+                Ybarycenters[PARTITION::FPIX_zm_xm] += (ali.translation().y());
+                Zbarycenters[PARTITION::FPIX_zm_xm] += (ali.translation().z());
+                nmodules[PARTITION::FPIX_zm_xm]++;
+              } else if (PixelEndcapName(DetId(ali.rawId()), true).halfCylinder() ==
+                         PixelEndcapName::mI) {  //FPIX z- x+
+                Xbarycenters[PARTITION::FPIX_zm_xp] += (ali.translation().x());
+                Ybarycenters[PARTITION::FPIX_zm_xp] += (ali.translation().y());
+                Zbarycenters[PARTITION::FPIX_zm_xp] += (ali.translation().z());
+                nmodules[PARTITION::FPIX_zm_xp]++;
+              } else if (PixelEndcapName(DetId(ali.rawId()), true).halfCylinder() ==
+                         PixelEndcapName::pO) {  //FPIX z+ x-
+                Xbarycenters[PARTITION::FPIX_zp_xm] += (ali.translation().x());
+                Ybarycenters[PARTITION::FPIX_zp_xm] += (ali.translation().y());
+                Zbarycenters[PARTITION::FPIX_zp_xm] += (ali.translation().z());
+                nmodules[PARTITION::FPIX_zp_xm]++;
+              } else if (PixelEndcapName(DetId(ali.rawId()), true).halfCylinder() ==
+                         PixelEndcapName::pI) {  //FPIX z+ x+
+                Xbarycenters[PARTITION::FPIX_zp_xp] += (ali.translation().x());
+                Ybarycenters[PARTITION::FPIX_zp_xp] += (ali.translation().y());
+                Zbarycenters[PARTITION::FPIX_zp_xp] += (ali.translation().z());
+                nmodules[PARTITION::FPIX_zp_xp]++;
+              } else {
+                edm::LogError("PixelDQM") << "Unrecognized partition for barycenter computation " << subid << std::endl;
+              }
+              break;
+            default:
+              edm::LogError("PixelDQM") << "Unrecognized partition for barycenter computation " << subid << std::endl;
+              break;
+          }
+        }
+      }
+
+      for (const auto& p : PARTITIONS) {
+        Xbarycenters[p] /= nmodules[p];
+        Ybarycenters[p] /= nmodules[p];
+        Zbarycenters[p] /= nmodules[p];
+
+        Xbarycenters[p] += GPR.at(DQMBarycenter::t_x);
+        Ybarycenters[p] += GPR.at(DQMBarycenter::t_y);
+        Zbarycenters[p] += GPR.at(DQMBarycenter::t_z);
+      }
+    }
+  };
+}  // namespace DQMBarycenter
+
+#endif

DQM/SiPixelPhase1Summary/python/SiPixelBarycenter_cfi.py

@@ -0,0 +1,8 @@
+import FWCore.ParameterSet.Config as cms
+from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
+
+#
+# This object is used to make changes for different running scenarios
+#
+
+SiPixelBarycenterOffline = DQMEDHarvester("SiPixelBarycenter")