Phase2-294B Extend functionality of RecHitTools of HGCal and add a testing code

RecoLocalCalo/HGCalRecAlgos/interface/RecHitTools.h

@@ -22,7 +22,15 @@ namespace edm {
 namespace hgcal {
   class RecHitTools {
   public:
-    RecHitTools() : geom_(nullptr), fhOffset_(0), bhOffset_(0), fhLastLayer_(0), noseLastLayer_(0), geometryType_(0) {}
+    RecHitTools()
+        : geom_(nullptr),
+          eeOffset_(0),
+          fhOffset_(0),
+          bhFirstLayer_(0),
+          bhOffset_(0),
+          fhLastLayer_(0),
+          noseLastLayer_(0),
+          geometryType_(0) {}
     ~RecHitTools() {}
 
     void setGeometry(CaloGeometry const&);
@@ -66,9 +74,10 @@ namespace hgcal {
     inline const CaloGeometry* getGeometry() const { return geom_; };
     unsigned int lastLayerEE(bool nose = false) const { return (nose ? HFNoseDetId::HFNoseLayerEEmax : fhOffset_); }
     unsigned int lastLayerFH() const { return fhLastLayer_; }
-    unsigned int firstLayerBH() const { return bhOffset_ + 1; }
+    unsigned int firstLayerBH() const { return bhFirstLayer_; }
     unsigned int lastLayerBH() const { return bhLastLayer_; }
     unsigned int lastLayer(bool nose = false) const { return (nose ? noseLastLayer_ : bhLastLayer_); }
+    std::pair<uint32_t, uint32_t> firstAndLastLayer(DetId::Detector det, int subdet) const;
     unsigned int maxNumberOfWafersPerLayer(bool nose = false) const {
       return (nose ? maxNumberOfWafersNose_ : maxNumberOfWafersPerLayer_);
     }
@@ -78,7 +87,7 @@ namespace hgcal {
 
   private:
     const CaloGeometry* geom_;
-    unsigned int fhOffset_, bhOffset_, bhLastLayer_, fhLastLayer_, noseLastLayer_;
+    unsigned int eeOffset_, fhOffset_, bhFirstLayer_, bhLastLayer_, bhOffset_, fhLastLayer_, noseLastLayer_;
     unsigned int maxNumberOfWafersPerLayer_, maxNumberOfWafersNose_;
     int geometryType_;
     int bhMaxIphi_;

RecoLocalCalo/HGCalRecAlgos/src/RecHitTools.cc

@@ -73,29 +73,32 @@ void RecHitTools::setGeometry(const CaloGeometry& geom) {
   //check if it's the new geometry
   if (geomEE) {
     geometryType_ = 1;
-    fhOffset_ = (geomEE->topology().dddConstants()).layers(true);
+    eeOffset_ = (geomEE->topology().dddConstants()).getLayerOffset();
     wmaxEE = (geomEE->topology().dddConstants()).waferCount(0);
     auto geomFH = static_cast<const HGCalGeometry*>(
         geom_->getSubdetectorGeometry(DetId::HGCalHSi, ForwardSubdetector::ForwardEmpty));
+    fhOffset_ = (geomFH->topology().dddConstants()).getLayerOffset();
     wmaxFH = (geomFH->topology().dddConstants()).waferCount(0);
-    fhLastLayer_ = fhOffset_ + (geomFH->topology().dddConstants()).layers(true);
+    fhLastLayer_ = fhOffset_ + (geomFH->topology().dddConstants()).lastLayer(true);
     auto geomBH = static_cast<const HGCalGeometry*>(
         geom_->getSubdetectorGeometry(DetId::HGCalHSc, ForwardSubdetector::ForwardEmpty));
-    bhOffset_ =
-        fhOffset_ + (geomBH->topology().dddConstants()).firstLayer() - (geomEE->topology().dddConstants()).firstLayer();
-    bhLastLayer_ = bhOffset_ + (geomBH->topology().dddConstants()).layers(true);
+    bhOffset_ = (geomBH->topology().dddConstants()).getLayerOffset();
+    bhFirstLayer_ = bhOffset_ + (geomBH->topology().dddConstants()).firstLayer();
+    bhLastLayer_ = bhOffset_ + (geomBH->topology().dddConstants()).lastLayer(true);
     bhMaxIphi_ = geomBH->topology().dddConstants().maxCells(true);
   } else {
     geometryType_ = 0;
     geomEE =
         static_cast<const HGCalGeometry*>(geom_->getSubdetectorGeometry(DetId::Forward, ForwardSubdetector::HGCEE));
-    fhOffset_ = (geomEE->topology().dddConstants()).layers(true);
+    eeOffset_ = (geomEE->topology().dddConstants()).getLayerOffset();
     wmaxEE = 1 + (geomEE->topology().dddConstants()).waferMax();
     auto geomFH =
         static_cast<const HGCalGeometry*>(geom_->getSubdetectorGeometry(DetId::Forward, ForwardSubdetector::HGCHEF));
-    bhOffset_ = fhOffset_ + (geomFH->topology().dddConstants()).layers(true);
+    fhOffset_ = (geomFH->topology().dddConstants()).getLayerOffset();
+    fhLastLayer_ = fhOffset_ + (geomFH->topology().dddConstants()).layers(true);
+    bhOffset_ = fhLastLayer_;
+    bhFirstLayer_ = bhOffset_ + 1;
     wmaxFH = 1 + (geomFH->topology().dddConstants()).waferMax();
-    fhLastLayer_ = bhOffset_;
     auto geomBH =
         static_cast<const HcalGeometry*>(geom_->getSubdetectorGeometry(DetId::Hcal, HcalSubdetector::HcalEndcap));
     bhLastLayer_ = bhOffset_ + (geomBH->topology().dddConstants())->getMaxDepth(1);
@@ -470,6 +473,18 @@ float RecHitTools::getPt(const DetId& id, const float& hitEnergy, const float& v
   return pt;
 }
 
+std::pair<uint32_t, uint32_t> RecHitTools::firstAndLastLayer(DetId::Detector det, int subdet) const {
+  if ((det == DetId::HGCalEE) || ((det == DetId::Forward) && (subdet == HGCEE))) {
+    return std::make_pair(eeOffset_ + 1, fhOffset_);
+  } else if ((det == DetId::HGCalHSi) || ((det == DetId::Forward) && (subdet == HGCHEF))) {
+    return std::make_pair(fhOffset_ + 1, fhLastLayer_);
+  } else if ((det == DetId::Forward) && (subdet == HFNose)) {
+    return std::make_pair(1, noseLastLayer_);
+  } else {
+    return std::make_pair(bhFirstLayer_, bhLastLayer_);
+  }
+}
+
 bool RecHitTools::maskCell(const DetId& id, int corners) const {
   if (id.det() == DetId::Hcal) {
     return false;

RecoLocalCalo/HGCalRecAlgos/test/BuildFile.xml

@@ -0,0 +1,9 @@
+<use name="FWCore/MessageLogger"/>
+<use name="FWCore/ParameterSet"/>
+<use name="FWCore/Framework"/>
+<use name="Geometry/HGCalGeometry"/>
+<use name="Geometry/Records"/>
+<use name="RecoLocalCalo/HGCalRecAlgos"/>
+<flags EDM_PLUGIN="1"/>
+<library name="RecoLocalCaloHGCalRecAlgosTestPlugin" file="*.cc">
+</library>

RecoLocalCalo/HGCalRecAlgos/test/HGCalTestRecHitTools.cc

@@ -0,0 +1,57 @@
+#include "FWCore/Framework/interface/one/EDAnalyzer.h"
+#include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
+#include "Geometry/CaloGeometry/interface/CaloGeometry.h"
+#include "Geometry/Records/interface/CaloGeometryRecord.h"
+#include "DataFormats/ForwardDetId/interface/HGCScintillatorDetId.h"
+#include "DataFormats/ForwardDetId/interface/HGCSiliconDetId.h"
+#include "RecoLocalCalo/HGCalRecAlgos/interface/RecHitTools.h"
+
+#include <vector>
+
+class HGCalTestRecHitTools : public edm::one::EDAnalyzer<> {
+public:
+  explicit HGCalTestRecHitTools(const edm::ParameterSet&);
+  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
+
+  void beginJob() override {}
+  void analyze(edm::Event const& iEvent, edm::EventSetup const&) override;
+  void endJob() override {}
+
+private:
+  const edm::ESGetToken<CaloGeometry, CaloGeometryRecord> tok_geom_;
+  hgcal::RecHitTools tool_;
+};
+
+HGCalTestRecHitTools::HGCalTestRecHitTools(const edm::ParameterSet&)
+    : tok_geom_(esConsumes<CaloGeometry, CaloGeometryRecord>()) {}
+
+void HGCalTestRecHitTools::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
+  edm::ParameterSetDescription desc;
+  descriptions.add("hgcalRecHitTools", desc);
+}
+
+void HGCalTestRecHitTools::analyze(const edm::Event& /*iEvent*/, const edm::EventSetup& iSetup) {
+  const CaloGeometry geo = iSetup.getData(tok_geom_);
+  tool_.setGeometry(geo);
+
+  edm::LogVerbatim("HGCalGeom") << "EE: Last Layer " << tool_.lastLayerEE();
+  edm::LogVerbatim("HGCalGeom") << "FH: Last Layer " << tool_.lastLayerFH();
+  edm::LogVerbatim("HGCalGeom") << "BH: First & Last Layer " << tool_.firstLayerBH() << ":" << tool_.lastLayerBH();
+  edm::LogVerbatim("HGCalGeom") << "Last Layer " << tool_.lastLayer();
+  std::vector<DetId::Detector> dets = {DetId::HGCalEE, DetId::HGCalHSi, DetId::HGCalHSc};
+  for (const auto& det : dets) {
+    auto layer = tool_.firstAndLastLayer(det, 0);
+    edm::LogVerbatim("HGCalGeom") << "First & Last Layer for Det " << det << " are " << layer.first << ":"
+                                  << layer.second;
+  }
+
+  edm::LogVerbatim("HGCalGeom") << "Maximum # of wafers per layer " << tool_.maxNumberOfWafersPerLayer();
+  edm::LogVerbatim("HGCalGeom") << "Maximum # of iphi: " << tool_.getScintMaxIphi();
+  edm::LogVerbatim("HGCalGeom") << "Geometry type " << tool_.getGeometryType();
+}
+
+DEFINE_FWK_MODULE(HGCalTestRecHitTools);

RecoLocalCalo/HGCalRecAlgos/test/testHGCalRecHitTools_cfg.py

@@ -0,0 +1,38 @@
+import FWCore.ParameterSet.Config as cms
+
+from Configuration.Eras.Era_Phase2C11_cff import Phase2C11
+process = cms.Process('PROD',Phase2C11)
+
+process.load("SimGeneral.HepPDTESSource.pdt_cfi")
+process.load('Configuration.Geometry.GeometryExtended2026D86Reco_cff')
+process.load('FWCore.MessageService.MessageLogger_cfi')
+process.load("RecoLocalCalo.HGCalRecAlgos.hgcalRecHitTools_cfi")
+
+if hasattr(process,'MessageLogger'):
+    process.MessageLogger.HGCalGeom=dict()
+
+process.load("IOMC.RandomEngine.IOMC_cff")
+process.RandomNumberGeneratorService.generator.initialSeed = 456789
+
+process.source = cms.Source("EmptySource")
+
+process.generator = cms.EDProducer("FlatRandomEGunProducer",
+    PGunParameters = cms.PSet(
+        PartID = cms.vint32(14),
+        MinEta = cms.double(-3.5),
+        MaxEta = cms.double(3.5),
+        MinPhi = cms.double(-3.14159265359),
+        MaxPhi = cms.double(3.14159265359),
+        MinE   = cms.double(9.99),
+        MaxE   = cms.double(10.01)
+    ),
+    AddAntiParticle = cms.bool(False),
+    Verbosity       = cms.untracked.int32(0),
+    firstRun        = cms.untracked.uint32(1)
+)
+
+process.maxEvents = cms.untracked.PSet(
+    input = cms.untracked.int32(1)
+)
+
+process.p1 = cms.Path(process.generator*process.hgcalRecHitTools)