Merge pull request #41983 from bsunanda/Phase2-hgx341B

Phase2-hgx341B Try to provide the dd4hep version of the plugins for passive components of V18 Silicon modules of HGCal

Geometry/HGCalCommonData/data/dd4hep/testHGCalPassive.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0"?>
+<DDDefinition>
+  <open_geometry/>
+  <close_geometry/>
+
+  <IncludeSection>
+    <Include ref="Geometry/CMSCommonData/data/materials/2021/v3/materials.xml"/>
+    <Include ref="Geometry/CMSCommonData/data/rotations.xml"/>
+    <Include ref="Geometry/CMSCommonData/data/extend/v2/cmsextent.xml"/>
+    <Include ref="Geometry/CMSCommonData/data/cavernData/2021/v1/cavernData.xml"/>
+    <Include ref="Geometry/CMSCommonData/data/cms/2026/v5/cms.xml"/>
+    <Include ref="Geometry/CMSCommonData/data/cmsMother.xml"/>
+    <Include ref="Geometry/CMSCommonData/data/eta3/etaMax.xml"/>
+    <Include ref="Geometry/CMSCommonData/data/caloBase/2026/v7/caloBase.xml"/>
+    <Include ref="Geometry/HGCalCommonData/data/hgcalMaterial/v2/hgcalMaterial.xml"/>
+    <Include ref="Geometry/HGCalCommonData/data/hgcal/v18/hgcal.xml"/>
+    <Include ref="Geometry/HGCalCommonData/data/hgcalPassive/v18/hgcalPassive.xml"/>
+    <Include ref="Geometry/HGCalCommonData/data/hgcalPassive/v18/hgcalpos.xml"/>
+   </IncludeSection>
+
+ </DDDefinition>
+

Geometry/HGCalCommonData/plugins/dd4hep/DDHGCalPassiveFull.cc

@@ -0,0 +1,134 @@
+///////////////////////////////////////////////////////////////////////////////
+// File: DDHGCalPassiveFull.cc
+// Description: Geometry factory class for the passive part of a full silicon
+//              module
+// Created by Sunanda Banerjee
+///////////////////////////////////////////////////////////////////////////////
+
+#include <string>
+#include <vector>
+#include <sstream>
+
+#include "DD4hep/DetFactoryHelper.h"
+#include "DataFormats/Math/interface/angle_units.h"
+#include "DetectorDescription/DDCMS/interface/DDPlugins.h"
+#include "DetectorDescription/DDCMS/interface/DDutils.h"
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+
+//#define EDM_ML_DEBUG
+using namespace angle_units::operators;
+
+struct HGCalPassiveFull {
+  HGCalPassiveFull() { throw cms::Exception("HGCalGeom") << "Wrong initialization to HGCalPassiveFull"; }
+  HGCalPassiveFull(cms::DDParsingContext& ctxt, xml_h e) {
+    cms::DDNamespace ns(ctxt, e, true);
+    cms::DDAlgoArguments args(ctxt, e);
+#ifdef EDM_ML_DEBUG
+    edm::LogVerbatim("HGCalGeom") << "DDHGCalPassiveFull: Creating an instance";
+#endif
+    std::string parentName = args.parentName();
+    std::string material = args.value<std::string>("ModuleMaterial");
+    double thick = args.value<double>("ModuleThickness");
+    double waferSize = args.value<double>("WaferSize");
+    double waferSepar = args.value<double>("SensorSeparation");
+#ifdef EDM_ML_DEBUG
+    edm::LogVerbatim("HGCalGeom") << "DDHGCalPassiveFull: Module " << parentName << " made of " << material << " T "
+                                  << thick << " Wafer 2r " << waferSize << " Half Separation " << waferSepar;
+#endif
+    std::vector<std::string> layerNames = args.value<std::vector<std::string>>("LayerNames");
+    std::vector<std::string> materials = args.value<std::vector<std::string>>("LayerMaterials");
+    std::vector<double> layerThick = args.value<std::vector<double>>("LayerThickness");
+    std::vector<int> copyNumber;
+    copyNumber.resize(materials.size(), 1);
+#ifdef EDM_ML_DEBUG
+    edm::LogVerbatim("HGCalGeom") << "DDHGCalPassiveFull: " << layerNames.size() << " types of volumes";
+    for (unsigned int i = 0; i < layerNames.size(); ++i)
+      edm::LogVerbatim("HGCalGeom") << "Volume [" << i << "] " << layerNames[i] << " of thickness " << layerThick[i]
+                                    << " filled with " << materials[i];
+#endif
+    std::vector<int> layerType = args.value<std::vector<int>>("LayerType");
+#ifdef EDM_ML_DEBUG
+    std::ostringstream st1;
+    for (unsigned int i = 0; i < layerType.size(); ++i)
+      st1 << " [" << i << "] " << layerType[i];
+    edm::LogVerbatim("HGCalGeom") << "There are " << layerType.size() << " blocks" << st1.str();
+
+    edm::LogVerbatim("HGCalGeom") << "==>> Executing DDHGCalPassiveFull...";
+#endif
+
+    static constexpr double tol = 0.00001;
+    static const double sqrt3 = std::sqrt(3.0);
+    double rM = 0.5 * (waferSize + waferSepar);
+    double RM2 = rM / sqrt3;
+
+    // First the mother
+    std::vector<double> xM = {rM, 0, -rM, -rM, 0, rM};
+    std::vector<double> yM = {RM2, 2 * RM2, RM2, -RM2, -2 * RM2, -RM2};
+    std::vector<double> zw = {-0.5 * thick, 0.5 * thick};
+    std::vector<double> zx(2, 0), zy(2, 0), scale(2, 1.0);
+    dd4hep::Solid solid = dd4hep::ExtrudedPolygon(xM, yM, zw, zx, zy, scale);
+    ns.addSolidNS(ns.prepend(parentName), solid);
+    dd4hep::Material matter = ns.material(material);
+    dd4hep::Volume glogM = dd4hep::Volume(solid.name(), solid, matter);
+    ns.addVolumeNS(glogM);
+#ifdef EDM_ML_DEBUG
+    edm::LogVerbatim("HGCalGeom") << "DDHGCalPassiveFull: " << solid.name() << " extruded polygon made of "
+                                  << matter.name() << " z|x|y|s (0) " << zw[0] << ":" << zx[0] << ":" << zy[0] << ":"
+                                  << scale[0] << " z|x|y|s (1) " << zw[1] << ":" << zx[1] << ":" << zy[1] << ":"
+                                  << scale[1] << " and " << xM.size() << " edges";
+    for (unsigned int kk = 0; kk < xM.size(); ++kk)
+      edm::LogVerbatim("HGCalGeom") << "[" << kk << "] " << xM[kk] << ":" << yM[kk];
+#endif
+
+    // Then the layers
+    std::vector<dd4hep::Volume> glogs(materials.size());
+    double zi(-0.5 * thick), thickTot(0.0);
+    for (unsigned int l = 0; l < layerType.size(); l++) {
+      unsigned int i = layerType[l];
+      if (copyNumber[i] == 1) {
+        zw[0] = -0.5 * layerThick[i];
+        zw[1] = 0.5 * layerThick[i];
+        std::string layerName = parentName + layerNames[i];
+        solid = dd4hep::ExtrudedPolygon(xM, yM, zw, zx, zy, scale);
+        ns.addSolidNS(ns.prepend(layerName), solid);
+        matter = ns.material(materials[i]);
+        glogs[i] = dd4hep::Volume(solid.name(), solid, matter);
+        ns.addVolumeNS(glogs[i]);
+#ifdef EDM_ML_DEBUG
+        edm::LogVerbatim("HGCalGeom") << "DDHGCalPassiveFull: Layer " << i << ":" << l << ":" << solid.name()
+                                      << " extruded polygon made of " << matter.name() << " z|x|y|s (0) " << zw[0]
+                                      << ":" << zx[0] << ":" << zy[0] << ":" << scale[0] << " z|x|y|s (1) " << zw[1]
+                                      << ":" << zx[1] << ":" << zy[1] << ":" << scale[1] << " and " << xM.size()
+                                      << " edges";
+        for (unsigned int kk = 0; kk < xM.size(); ++kk)
+          edm::LogVerbatim("HGCalGeom") << "[" << kk << "] " << xM[kk] << ":" << yM[kk];
+#endif
+      }
+      dd4hep::Position tran0(0, 0, (zi + 0.5 * layerThick[i]));
+      glogM.placeVolume(glogs[i], copyNumber[i], tran0);
+#ifdef EDM_ML_DEBUG
+      edm::LogVerbatim("HGCalGeom") << "DDHGCalPassiveFull: " << glogs[i].name() << " number " << copyNumber[i]
+                                    << " positioned in " << glogM.name() << " at " << tran0 << " with no rotation";
+#endif
+      ++copyNumber[i];
+      zi += layerThick[i];
+      thickTot += layerThick[i];
+    }
+    if ((std::abs(thickTot - thick) >= tol) && (!layerType.empty())) {
+      if (thickTot > thick) {
+        edm::LogError("HGCalGeom") << "Thickness of the partition " << thick << " is smaller than " << thickTot
+                                   << ": thickness of all its components **** ERROR ****";
+      } else {
+        edm::LogWarning("HGCalGeom") << "Thickness of the partition " << thick << " does not match with " << thickTot
+                                     << " of the components";
+      }
+    }
+  }
+};
+
+static long algorithm(dd4hep::Detector& /* description */, cms::DDParsingContext& ctxt, xml_h e) {
+  HGCalPassiveFull passiveFullAlgo(ctxt, e);
+  return cms::s_executed;
+}
+
+DECLARE_DDCMS_DETELEMENT(DDCMS_hgcal_DDHGCalPassiveFull, algorithm)

Geometry/HGCalCommonData/plugins/dd4hep/DDHGCalPassivePartial.cc

@@ -0,0 +1,156 @@
+///////////////////////////////////////////////////////////////////////////////
+// File: DDHGCalPassivePartial.cc
+// Description: Geometry factory class for the passive part of a partial
+//              silicon module
+// Created by Sunanda Banerjee
+///////////////////////////////////////////////////////////////////////////////
+
+#include <string>
+#include <vector>
+#include <sstream>
+
+#include "DD4hep/DetFactoryHelper.h"
+#include "DataFormats/Math/interface/angle_units.h"
+#include "DetectorDescription/DDCMS/interface/DDPlugins.h"
+#include "DetectorDescription/DDCMS/interface/DDutils.h"
+#include "Geometry/HGCalCommonData/interface/HGCalWaferMask.h"
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+
+//#define EDM_ML_DEBUG
+using namespace angle_units::operators;
+
+struct HGCalPassivePartial {
+  HGCalPassivePartial() { throw cms::Exception("HGCalGeom") << "Wrong initialization to HGCalPassivePartial"; }
+  HGCalPassivePartial(cms::DDParsingContext& ctxt, xml_h e) {
+    cms::DDNamespace ns(ctxt, e, true);
+    cms::DDAlgoArguments args(ctxt, e);
+#ifdef EDM_ML_DEBUG
+    edm::LogVerbatim("HGCalGeom") << "DDHGCalPassivePartial: Creating an instance";
+#endif
+    std::string parentName = args.parentName();
+    std::string material = args.value<std::string>("ModuleMaterial");
+    double thick = args.value<double>("ModuleThickness");
+    double waferSize = args.value<double>("WaferSize");
+    double waferSepar = args.value<double>("SensorSeparation");
+#ifdef EDM_ML_DEBUG
+    edm::LogVerbatim("HGCalGeom") << "DDHGCalPassivePartial: Module " << parentName << " made of " << material << " T "
+                                  << thick << " Wafer 2r " << waferSize << " Half Separation " << waferSepar;
+#endif
+    std::vector<std::string> tags = args.value<std::vector<std::string>>("Tags");
+    std::vector<int> partialTypes = args.value<std::vector<int>>("PartialTypes");
+    std::vector<int> placementIndex = args.value<std::vector<int>>("PlacementIndex");
+    std::vector<std::string> placementIndexTags = args.value<std::vector<std::string>>("PlacementIndexTags");
+#ifdef EDM_ML_DEBUG
+    edm::LogVerbatim("HGCalGeom") << "DDHGCalPassivePartial: " << tags.size() << " variations of wafer types";
+    for (unsigned int k = 0; k < tags.size(); ++k) {
+      for (unsigned int m = 0; m < placementIndex.size(); ++m) {
+        edm::LogVerbatim("HGCalGeom") << "Type[" << k << "] " << tags[k] << " Partial " << partialTypes[k]
+                                      << " Placement Index " << placementIndex[m] << " Tag " << placementIndexTags[m];
+      }
+    }
+#endif
+    std::vector<std::string> layerNames = args.value<std::vector<std::string>>("LayerNames");
+    std::vector<std::string> materials = args.value<std::vector<std::string>>("LayerMaterials");
+    std::vector<double> layerThick = args.value<std::vector<double>>("LayerThickness");
+#ifdef EDM_ML_DEBUG
+    edm::LogVerbatim("HGCalGeom") << "DDHGCalPassivePartial: " << layerNames.size() << " types of volumes";
+    for (unsigned int i = 0; i < layerNames.size(); ++i)
+      edm::LogVerbatim("HGCalGeom") << "Volume [" << i << "] " << layerNames[i] << " of thickness " << layerThick[i]
+                                    << " filled with " << materials[i];
+#endif
+    std::vector<int> layerType = args.value<std::vector<int>>("LayerType");
+#ifdef EDM_ML_DEBUG
+    std::ostringstream st1;
+    for (unsigned int i = 0; i < layerType.size(); ++i)
+      st1 << " [" << i << "] " << layerType[i];
+    edm::LogVerbatim("HGCalGeom") << "There are " << layerType.size() << " blocks" << st1.str();
+
+    edm::LogVerbatim("HGCalGeom") << "==>> Executing DDHGCalPassivePartial...";
+#endif
+
+    static constexpr double tol = 0.00001;
+
+    // Loop over all types
+    for (unsigned int k = 0; k < tags.size(); ++k) {
+      for (unsigned int m = 0; m < placementIndex.size(); ++m) {
+        // First the mother
+        std::string mother = parentName + placementIndexTags[m] + tags[k];
+        std::vector<std::pair<double, double>> wxy =
+            HGCalWaferMask::waferXY(partialTypes[k], placementIndex[m], (waferSize + waferSepar), 0.0, 0.0, 0.0);
+        std::vector<double> xM, yM;
+        for (unsigned int i = 0; i < (wxy.size() - 1); ++i) {
+          xM.emplace_back(wxy[i].first);
+          yM.emplace_back(wxy[i].second);
+        }
+        std::vector<double> zw = {-0.5 * thick, 0.5 * thick};
+        std::vector<double> zx(2, 0), zy(2, 0), scale(2, 1.0);
+        dd4hep::Solid solid = dd4hep::ExtrudedPolygon(xM, yM, zw, zx, zy, scale);
+        ns.addSolidNS(ns.prepend(mother), solid);
+        dd4hep::Material matter = ns.material(material);
+        dd4hep::Volume glogM = dd4hep::Volume(solid.name(), solid, matter);
+        ns.addVolumeNS(glogM);
+#ifdef EDM_ML_DEBUG
+        edm::LogVerbatim("HGCalGeom") << "DDHGCalPassivePartial: " << solid.name() << " extruded polygon made of "
+                                      << matter.name() << " z|x|y|s (0) " << zw[0] << ":" << zx[0] << ":" << zy[0]
+                                      << ":" << scale[0] << " z|x|y|s (1) " << zw[1] << ":" << zx[1] << ":" << zy[1]
+                                      << ":" << scale[1] << " and " << xM.size() << " edges";
+        for (unsigned int kk = 0; kk < xM.size(); ++kk)
+          edm::LogVerbatim("HGCalGeom") << "[" << kk << "] " << xM[kk] << ":" << yM[kk];
+#endif
+
+        // Then the layers
+        std::vector<dd4hep::Volume> glogs(materials.size());
+        std::vector<int> copyNumber;
+        copyNumber.resize(materials.size(), 1);
+        double zi(-0.5 * thick), thickTot(0.0);
+        for (unsigned int l = 0; l < layerType.size(); l++) {
+          unsigned int i = layerType[l];
+          if (copyNumber[i] == 1) {
+            zw[0] = -0.5 * layerThick[i];
+            zw[1] = 0.5 * layerThick[i];
+            std::string layerName = mother + layerNames[i];
+            solid = dd4hep::ExtrudedPolygon(xM, yM, zw, zx, zy, scale);
+            ns.addSolidNS(ns.prepend(layerName), solid);
+            matter = ns.material(materials[i]);
+            glogs[i] = dd4hep::Volume(solid.name(), solid, matter);
+            ns.addVolumeNS(glogs[i]);
+#ifdef EDM_ML_DEBUG
+            edm::LogVerbatim("HGCalGeom")
+                << "DDHGCalPassivePartial: Layer " << i << ":" << l << ":" << solid.name()
+                << " extruded polygon made of " << matter.name() << " z|x|y|s (0) " << zw[0] << ":" << zx[0] << ":"
+                << zy[0] << ":" << scale[0] << " z|x|y|s (1) " << zw[1] << ":" << zx[1] << ":" << zy[1] << ":"
+                << scale[1] << " and " << xM.size() << " edges";
+            for (unsigned int kk = 0; kk < xM.size(); ++kk)
+              edm::LogVerbatim("HGCalGeom") << "[" << kk << "] " << xM[kk] << ":" << yM[kk];
+#endif
+          }
+          dd4hep::Position tran(0, 0, (zi + 0.5 * layerThick[i]));
+          glogM.placeVolume(glogs[i], copyNumber[i], tran);
+#ifdef EDM_ML_DEBUG
+          edm::LogVerbatim("HGCalGeom") << "DDHGCalPassivePartial: " << glogs[i].name() << " number " << copyNumber[i]
+                                        << " positioned in " << glogM.name() << " at " << tran << " with no rotation";
+#endif
+          ++copyNumber[i];
+          zi += layerThick[i];
+          thickTot += layerThick[i];
+        }
+        if ((std::abs(thickTot - thick) >= tol) && (!layerType.empty())) {
+          if (thickTot > thick) {
+            edm::LogError("HGCalGeom") << "Thickness of the partition " << thick << " is smaller than " << thickTot
+                                       << ": thickness of all its components **** ERROR ****";
+          } else {
+            edm::LogWarning("HGCalGeom") << "Thickness of the partition " << thick << " does not match with "
+                                         << thickTot << " of the components";
+          }
+        }
+      }
+    }
+  }
+};
+
+static long algorithm(dd4hep::Detector& /* description */, cms::DDParsingContext& ctxt, xml_h e) {
+  HGCalPassivePartial passivePartialAlgo(ctxt, e);
+  return cms::s_executed;
+}
+
+DECLARE_DDCMS_DETELEMENT(DDCMS_hgcal_DDHGCalPassivePartial, algorithm)

Geometry/HGCalCommonData/test/python/dumpHGCalPassive_cfg.py

@@ -1,14 +1,42 @@
+###############################################################################
+# Way to use this:
+#   cmsRun dumpHGCalPassive_cfg.py type=DDD
+#
+#   Options for type DDD, DD4hep
+#
+###############################################################################
 import FWCore.ParameterSet.Config as cms
+import os, sys, importlib, re
+import FWCore.ParameterSet.VarParsing as VarParsing
+
+####################################################################
+### SETUP OPTIONS
+options = VarParsing.VarParsing('standard')
+options.register('type',
+                 "DDD",
+                  VarParsing.VarParsing.multiplicity.singleton,
+                  VarParsing.VarParsing.varType.string,
+                  "type of operations: DDD, DD4hep")
+
+### get and parse the command line arguments
+options.parseArguments()
+
 from Configuration.Eras.Era_Phase2C17I13M9_cff import Phase2C17I13M9
 process = cms.Process('GeomDump',Phase2C17I13M9)
-
-geomFile = "Geometry.HGCalCommonData.testHGCalPassiveXML_cfi"
-fileName = "hgcalPassiveDDD.root"
+if (options.type == "DD4hep"):
+    geomFile = "Geometry/HGCalCommonData/data/dd4hep/testHGCalPassive.xml"
+    fileName = "hgcalPassiveDD4hep.root"
+    process.DDDetectorESProducer = cms.ESSource("DDDetectorESProducer",
+                                                confGeomXMLFiles = cms.FileInPath(geomFile),
+    appendToDataLabel = cms.string('DDHGCal'))
+else:
+    geomFile = "Geometry.HGCalCommonData.testHGCalPassiveXML_cfi"
+    fileName = "hgcalPassiveDDD.root"
+    process.load(geomFile)
 
 print("Geometry file: ", geomFile)
 print("Output file:   ", fileName)
 
-process.load(geomFile)
 process.load('FWCore.MessageService.MessageLogger_cfi')
 
 if 'MessageLogger' in process.__dict__:
@@ -24,12 +52,15 @@
     input = cms.untracked.int32(1)
 )
 
-process.add_(cms.ESProducer("TGeoMgrFromDdd",
-        verbose = cms.untracked.bool(False),
-        level   = cms.untracked.int32(14)
-))
-
-process.dump = cms.EDAnalyzer("DumpSimGeometry",
-                              outputFileName = cms.untracked.string(fileName))
+if (options.type == "DD4hep"):
+    process.dump = cms.EDAnalyzer("DDTestDumpFile",
+                                  outputFileName = cms.untracked.string(fileName),
+                                  DDDetector = cms.ESInputTag('','DDHGCal'))
+else:
+    process.add_(cms.ESProducer("TGeoMgrFromDdd",
+                                verbose = cms.untracked.bool(False),
+                                level   = cms.untracked.int32(14)))
+    process.dump = cms.EDAnalyzer("DumpSimGeometry",
+                                  outputFileName = cms.untracked.string(fileName))
 
 process.p = cms.Path(process.dump)