Merge pull request #45095 from bsunanda/Phase2-hgx357

Phase2-hgx357 Add a new version of HGCalCellOffest to provide a more correct results for the cell areas

Author: cmsbuild

Geometry/HGCalCommonData/interface/HGCalCellOffset.h

@@ -9,20 +9,26 @@
 
 class HGCalCellOffset {
 public:
-  HGCalCellOffset(double waferSize, int32_t nFine, int32_t nCoarse, double guardRingOffset_, double mouseBiteCut_);
+  HGCalCellOffset(double waferSize,
+                  int32_t nFine,
+                  int32_t nCoarse,
+                  double guardRingOffset_,
+                  double mouseBiteCut_,
+                  double sizeOffset_);
 
   std::pair<double, double> cellOffsetUV2XY1(int32_t u, int32_t v, int32_t placementIndex, int32_t type);
   std::pair<double, double> cellOffsetUV2XY1(
       int32_t u, int32_t v, int32_t placementIndex, int32_t type, int32_t partialType);
   double cellAreaUV(int32_t u, int32_t v, int32_t placementIndex, int32_t type, bool reco);
+  double cellAreaUV(int32_t u, int32_t v, int32_t placementIndex, int32_t type, int32_t partialType, bool reco);
 
 private:
   const double sqrt3_ = std::sqrt(3.0);
   const double sqrt3By2_ = (0.5 * sqrt3_);
   std::array<std::array<std::array<double, 6>, 6>, 2> offsetX, offsetY;
   std::array<std::array<std::array<double, 6>, 11>, 2> offsetPartialX, offsetPartialY;
   int32_t ncell_[2];
-  double cellX_[2], cellY_[2], fullArea[2], cellArea[2][6];
+  double cellX_[2], cellY_[2], fullArea[2], cellArea[2][6], cellAreaPartial[2][11];
   std::unique_ptr<HGCalCell> hgcalcell_;
 };
 

Geometry/HGCalCommonData/interface/HGCalDDDConstants.h

@@ -17,6 +17,7 @@
 #include "DataFormats/GeometryVector/interface/GlobalPoint.h"
 #include "Geometry/HGCalCommonData/interface/HGCalCassette.h"
 #include "Geometry/HGCalCommonData/interface/HGCalCell.h"
+#include "Geometry/HGCalCommonData/interface/HGCalCellOffset.h"
 #include "Geometry/HGCalCommonData/interface/HGCalCellUV.h"
 #include "Geometry/HGCalCommonData/interface/HGCalGeometryMode.h"
 #include "Geometry/HGCalCommonData/interface/HGCalGeomTools.h"
@@ -59,6 +60,7 @@ class HGCalDDDConstants {
   }
   std::pair<double, double> cellEtaPhiTrap(int type, int irad) const;
   bool cellInLayer(int waferU, int waferV, int cellU, int cellV, int lay, int zside, bool reco) const;
+  const HGCalCellOffset* cellOffset() const { return cellOffset_.get(); }
   double cellSizeHex(int type) const;
   inline std::pair<double, double> cellSizeTrap(int type, int irad) const {
     return std::make_pair(hgpar_->radiusLayer_[type][irad - 1], hgpar_->radiusLayer_[type][irad]);
@@ -258,6 +260,7 @@ class HGCalDDDConstants {
   HGCalCassette hgcassette_;
   std::unique_ptr<HGCalCell> hgcell_;
   std::unique_ptr<HGCalCellUV> hgcellUV_;
+  std::unique_ptr<HGCalCellOffset> cellOffset_;
   HGCalGeomTools geomTools_;
   constexpr static double k_horizontalShift = 1.0;
   constexpr static float dPhiMin = 0.02;

Geometry/HGCalCommonData/src/HGCalCellOffset.cc

@@ -35,11 +35,21 @@ HGCalDDDConstants::HGCalDDDConstants(const HGCalParameters* hp, const std::strin
     hgcell_ = std::make_unique<HGCalCell>(2.0 * rmaxT_, hgpar_->nCellsFine_, hgpar_->nCellsCoarse_);
     hgcellUV_ = std::make_unique<HGCalCellUV>(
         2.0 * rmax_, hgpar_->sensorSeparation_, hgpar_->nCellsFine_, hgpar_->nCellsCoarse_);
+    cellOffset_ = std::make_unique<HGCalCellOffset>(hgpar_->waferSize_,
+                                                    hgpar_->nCellsFine_,
+                                                    hgpar_->nCellsCoarse_,
+                                                    hgpar_->guardRingOffset_,
+                                                    hgpar_->mouseBite_,
+                                                    hgpar_->sensorSizeOffset_);
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCalGeom") << "rmax_ " << rmax_ << ":" << rmaxT_ << ":" << hexside_ << ":" << hexsideT_
                                   << " CellSize " << 0.5 * HGCalParameters::k_ScaleFromDDD * hgpar_->cellSize_[0] << ":"
                                   << 0.5 * HGCalParameters::k_ScaleFromDDD * hgpar_->cellSize_[1];
 #endif
+  } else {
+    hgcell_.reset();
+    hgcellUV_.reset();
+    cellOffset_.reset();
   }
   if (cassetteMode()) {
     hgcassette_.setParameter(hgpar_->cassettes_, hgpar_->cassetteShift_);

Geometry/HGCalCommonData/src/HGCalDDDConstants.cc

@@ -62,6 +62,7 @@ class HGCalCellOffsetTester : public edm::one::EDAnalyzer<> {
   const int partial_;
   const double mouseBiteCut_;
   const double guardRingOffset_;
+  const double sizeOffset_;
   std::ofstream outputFile;
 };
 
@@ -71,10 +72,11 @@ HGCalCellOffsetTester::HGCalCellOffsetTester(const edm::ParameterSet& iC)
       placeIndex_(iC.getParameter<int>("cellPlacementIndex")),
       partial_(iC.getParameter<int>("cellType")),
       mouseBiteCut_(iC.getParameter<double>("mouseBiteCut")),
-      guardRingOffset_(iC.getParameter<double>("guardRingOffset")) {
+      guardRingOffset_(iC.getParameter<double>("guardRingOffset")),
+      sizeOffset_(iC.getParameter<double>("sizeOffset")) {
   edm::LogVerbatim("HGCalGeom") << "Test positions for wafer of size " << waferSize_ << " Type " << waferType_
                                 << " Placement Index " << placeIndex_ << " GuardRing offset " << guardRingOffset_
-                                << " Mousebite cut " << mouseBiteCut_;
+                                << " Mousebite cut " << mouseBiteCut_ << " SizeOffset " << sizeOffset_;
 
   outputFile.open("nand.csv");
   if (!outputFile.is_open()) {
@@ -89,9 +91,10 @@ void HGCalCellOffsetTester::fillDescriptions(edm::ConfigurationDescriptions& des
   desc.add<double>("waferSize", 167.4408);
   desc.add<int>("waferType", 0);
   desc.add<int>("cellPlacementIndex", 11);
-  desc.add<int>("cellType", 22);
+  desc.add<int>("cellType", 0);
   desc.add<double>("mouseBiteCut", 5.0);
   desc.add<double>("guardRingOffset", 0.9);
+  desc.add<double>("sizeOffset", 0.435);
   descriptions.add("hgcalCellOffsetTester", desc);
 }
 
@@ -101,7 +104,7 @@ void HGCalCellOffsetTester::analyze(const edm::Event&, const edm::EventSetup&) {
   int nCells = (waferType_ == 0) ? nFine : nCoarse;
   HGCalCellUV wafer(waferSize_, 0.0, nFine, nCoarse);
   HGCalCell wafer2(waferSize_, nFine, nCoarse);
-  HGCalCellOffset offset(waferSize_, nFine, nCoarse, guardRingOffset_, mouseBiteCut_);
+  HGCalCellOffset offset(waferSize_, nFine, nCoarse, guardRingOffset_, mouseBiteCut_, sizeOffset_);
   edm::LogVerbatim("HGCalGeom") << "\nHGCalPartialCellTester:: nCells " << nCells << " and placement index "
                                 << placeIndex_ << "\n\n";
   for (int ui = 0; ui < 2 * nCells; ui++) {
@@ -121,17 +124,19 @@ void HGCalCellOffsetTester::analyze(const edm::Event&, const edm::EventSetup&) {
           //                               << " ,yoff " << xyOffset.second << comment;
 
           std::pair<double, double> xyOffsetLD = offset.cellOffsetUV2XY1(ui, vi, placeIndex_, waferType_, partial_);
+          auto area = offset.cellAreaUV(ui, vi, placeIndex_, waferType_, partial_, true);
           //	std::pair<double, double> xyOffsetHD = offset.cellOffsetUV2XY1HD(ui, vi, placeIndex_, waferType_);
           outputFile << xyOffsetLD.first + xy1.first << "," << xyOffsetLD.second + xy1.second << "," << uv1.first << ","
-                     << uv1.second << "," << std::endl;
+                     << uv1.second << "," << area << std::endl;
 
           std::string comment = ((uv1.first != ui) || (uv1.second != vi))
                                     ? " ***** ERROR (u, v) from the methods dosent match *****"
                                     : "";
           edm::LogVerbatim("HGCalGeom") << "u = " << ui << " v = " << vi << " type = " << waferType_
                                         << " placement index " << placeIndex_ << " u " << uv1.first << " v "
                                         << uv1.second << " x " << xy1.first << " ,y " << xy1.second << " xoff "
-                                        << xyOffsetLD.first << " ,yoff " << xyOffsetLD.second << comment;
+                                        << xyOffsetLD.first << " ,yoff " << xyOffsetLD.second << " , area " << area
+                                        << comment;
         }
       }
     }

Geometry/HGCalCommonData/test/HGCalCellOffsetTester.cc

@@ -55,7 +55,7 @@ class HGCalSD : public CaloSD, public Observer<const BeginOfJob *> {
   std::string nameX_;
   HGCalGeometryMode::GeometryMode geom_mode_;
   double eminHit_, slopeMin_, distanceFromEdge_;
-  double waferSize_, mouseBiteCut_, guardRingOffset_, weight_;
+  double waferSize_, mouseBiteCut_, guardRingOffset_, sensorSizeOffset_, weight_;
   int levelT1_, levelT2_, cornerMinMask_;
   bool storeAllG4Hits_;
   bool fiducialCut_, rejectMB_, waferRot_, checkID_;

SimG4CMS/Calo/interface/HGCalSD.h

@@ -420,7 +420,7 @@ void CaloSD::EndOfEvent(G4HCofThisEvent*) {
     if (theHC[k] == nullptr)
       edm::LogVerbatim("CaloSim") << "CaloSD: EndofEvent entered for container " << k << " with no entries";
     else
-      edm::LogVerbatim("CaloSim") << "CaloSD: EndofEvent entered for container " << k << " with " << theHC[0]->entries()
+      edm::LogVerbatim("CaloSim") << "CaloSD: EndofEvent entered for container " << k << " with " << theHC[k]->entries()
                                   << " entries";
   }
 #endif

SimG4CMS/Calo/src/CaloSD.cc

@@ -279,17 +279,17 @@ void HGCalSD::update(const BeginOfJob* job) {
     waferSize_ = hgcons_->waferSize(false);
     double mouseBite = hgcons_->mouseBite(false);
     guardRingOffset_ = hgcons_->guardRingOffset(false);
-    double sensorSizeOffset = hgcons_->sensorSizeOffset(false);
+    sensorSizeOffset_ = hgcons_->sensorSizeOffset(false);
     if (useOffset > 0) {
       rejectMB_ = true;
       fiducialCut_ = true;
     }
-    double mouseBiteNew = (fiducialCut_) ? (mouseBite + guardRingOffset_ + sensorSizeOffset / cos30deg_) : mouseBite;
+    double mouseBiteNew = (fiducialCut_) ? (mouseBite + guardRingOffset_ + sensorSizeOffset_ / cos30deg_) : mouseBite;
     mouseBiteCut_ = waferSize_ * tan30deg_ - mouseBiteNew;
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCSim") << "HGCalSD::Initialized with mode " << geom_mode_ << " Slope cut " << slopeMin_
                                << " top Level " << levelT1_ << ":" << levelT2_ << " useSimWt " << useSimWt_ << " wafer "
-                               << waferSize_ << ":" << mouseBite << ":" << guardRingOffset_ << ":" << sensorSizeOffset
+                               << waferSize_ << ":" << mouseBite << ":" << guardRingOffset_ << ":" << sensorSizeOffset_
                                << ":" << mouseBiteNew << ":" << mouseBiteCut_ << " useOffset " << useOffset
                                << " dd4hep " << dd4hep_;
 #endif
@@ -337,7 +337,7 @@ void HGCalSD::update(const BeginOfJob* job) {
   if ((nHC_ > 1) && calibCells_)
     newCollection(collName_[1], ps_);
   cellOffset_ = std::make_unique<HGCalCellOffset>(
-      waferSize_, hgcons_->getUVMax(0), hgcons_->getUVMax(1), guardRingOffset_, mouseBiteCut_);
+      waferSize_, hgcons_->getUVMax(0), hgcons_->getUVMax(1), guardRingOffset_, mouseBiteCut_, sensorSizeOffset_);
 }
 
 void HGCalSD::initRun() {}