[NOT TO MERGE] PR test DD4hep in 14_0

Configuration/PyReleaseValidation/README.md

@@ -88,7 +88,7 @@ The offsets currently in use are:
 * 0.999: 0.99 with Phase-2 premixing with PU50
 * 0.9821: Production-like premixing stage2
 * 0.9921: Production-like premixing stage1+stage2
-* 0.911: DD4hep reading geometry from XML
+* 0.911: DD4hep reading geometry from XML 
 * 0.912: DD4hep reading geometry from the DB
 * 0.914: DDD DB
 * 0.101: Phase-2 aging, 1000fb-1

Geometry/HGCalCommonData/interface/HGCalParameters.h

@@ -72,13 +72,13 @@ class HGCalParameters {
   std::array<int, 4> getID(unsigned int k) const;
 
   std::string name_;
-  int detectorType_;
-  int useSimWt_;
-  int nCells_;
-  int nSectors_;
-  int firstLayer_;
-  int firstMixedLayer_;
-  HGCalGeometryMode::GeometryMode mode_;
+  int detectorType_ = 0;
+  int useSimWt_ = 0;
+  int nCells_ = 0;
+  int nSectors_ = 0;
+  int firstLayer_ = 0;
+  int firstMixedLayer_ = 0;
+  HGCalGeometryMode::GeometryMode mode_ = HGCalGeometryMode::Square;
 
   std::vector<double> cellSize_;
   std::vector<double> slopeMin_;
@@ -146,62 +146,62 @@ class HGCalParameters {
   std::vector<double> rLimit_;
   std::vector<int> cellFine_;
   std::vector<int> cellCoarse_;
-  double waferR_;
+  double waferR_ = 0.;
   std::vector<int> levelT_;
-  int levelZSide_;
+  int levelZSide_ = 0;
   layer_map copiesInLayers_;
-  int nCellsFine_;
-  int nCellsCoarse_;
-  double waferSize_;
-  double waferThick_;
-  double sensorSeparation_;
-  double sensorSizeOffset_;
-  double guardRingOffset_;
-  double mouseBite_;
-  int useOffset_;
-  int waferUVMax_;
+  int nCellsFine_ = 0;
+  int nCellsCoarse_ = 0;
+  double waferSize_ = 0.;
+  double waferThick_ = 0.;
+  double sensorSeparation_ = 0.;
+  double sensorSizeOffset_ = 0.;
+  double guardRingOffset_ = 0.;
+  double mouseBite_ = 0.;
+  int useOffset_ = 0;
+  int waferUVMax_ = 0;
   std::vector<int> waferUVMaxLayer_;
-  bool defineFull_;
+  bool defineFull_ = false;
   std::vector<double> waferThickness_;
   std::vector<double> cellThickness_;
   std::vector<double> radius100to200_;
   std::vector<double> radius200to300_;
-  int choiceType_;
-  int nCornerCut_;
-  double fracAreaMin_;
-  double zMinForRad_;
+  int choiceType_ = 0;
+  int nCornerCut_ = 0;
+  double fracAreaMin_ = 0.;
+  double zMinForRad_ = 0.;
   std::vector<double> radiusMixBoundary_;
   std::vector<int> nPhiBinBH_;
   std::vector<int> layerFrontBH_;
   std::vector<double> rMinLayerBH_;
   std::vector<double> radiusLayer_[2];
   std::vector<int> iradMinBH_;
   std::vector<int> iradMaxBH_;
-  double minTileSize_;
+  double minTileSize_ = 0.;
   std::vector<int> firstModule_;
   std::vector<int> lastModule_;
-  int layerOffset_;
-  double layerRotation_;
+  int layerOffset_ = 0;
+  double layerRotation_ = 0.;
   std::vector<int> layerType_;
   std::vector<int> layerCenter_;
   wafer_map wafersInLayers_;
   wafer_map typesInLayers_;
   waferT_map waferTypes_;
-  int waferMaskMode_;
-  int waferZSide_;
+  int waferMaskMode_ = 0;
+  int waferZSide_ = 0;
   waferInfo_map waferInfoMap_;
   std::vector<std::pair<double, double> > layerRotV_;
   tileInfo_map tileInfoMap_;
   std::vector<std::pair<double, double> > tileRingR_;
   std::vector<std::pair<int, int> > tileRingRange_;
-  int cassettes_;
-  int nphiCassette_;
-  int phiOffset_;
+  int cassettes_ = 0;
+  int nphiCassette_ = 0;
+  int phiOffset_ = 0;
   std::vector<double> cassetteShift_;
-  double calibCellRHD_;
+  double calibCellRHD_ = 0.;
   std::vector<int> calibCellFullHD_;
   std::vector<int> calibCellPartHD_;
-  double calibCellRLD_;
+  double calibCellRLD_ = 0.;
   std::vector<int> calibCellFullLD_;
   std::vector<int> calibCellPartLD_;
 

Geometry/HGCalCommonData/src/HGCalGeomParameters.cc

@@ -881,11 +881,12 @@ void HGCalGeomParameters::loadGeometryHexagonModule(const DDCompactView* cpv,
   DDFilteredView fv2(*cpv, filter2);
   dodet = fv2.firstChild();
   while (dodet) {
+    std::vector<int> copy = fv2.copyNumbers();
+    int nsiz = static_cast<int>(copy.size());
 #ifdef EDM_ML_DEBUG
     ++ntot2;
+    edm::LogVerbatim("HGCalGeom") << "loadGeometryHexagonModule:: nsiz " << nsiz << " Ltop " << levelTop;
 #endif
-    std::vector<int> copy = fv2.copyNumbers();
-    int nsiz = static_cast<int>(copy.size());
     if (levelTop < nsiz) {
       int lay = copy[levelTop];
       int zside = (nsiz > php.levelZSide_) ? copy[php.levelZSide_] : -1;
@@ -903,17 +904,23 @@ void HGCalGeomParameters::loadGeometryHexagonModule(const DDCompactView* cpv,
       if (lay == 0) {
         throw cms::Exception("DDException")
             << "Funny layer # " << lay << " zp " << zside << " in " << nsiz << " components";
-      } else if (sol.shape() == DDSolidShape::ddtubs) {
+      } else if ((sol.shape() == DDSolidShape::ddtubs) || (sol.shape() == DDSolidShape::ddbox)) {
         if (zvals.find(std::make_pair(lay, zside)) != zvals.end()) {
           if (std::find(php.layer_.begin(), php.layer_.end(), lay) == php.layer_.end())
             php.layer_.emplace_back(lay);
           auto itr = layers.find(lay);
           if (itr == layers.end()) {
-            const DDTubs& tube = static_cast<DDTubs>(sol);
-            double rin = HGCalParameters::k_ScaleFromDDD * tube.rIn();
-            double rout = (php.firstMixedLayer_ > 0 && lay >= php.firstMixedLayer_)
-                              ? php.radiusMixBoundary_[lay - php.firstMixedLayer_]
-                              : HGCalParameters::k_ScaleFromDDD * tube.rOut();
+            double rin(0), rout(0);
+            if (sol.shape() == DDSolidShape::ddtubs) {
+              const DDTubs& tube = static_cast<DDTubs>(sol);
+              rin = HGCalParameters::k_ScaleFromDDD * tube.rIn();
+              rout = (php.firstMixedLayer_ > 0 && lay >= php.firstMixedLayer_)
+                         ? php.radiusMixBoundary_[lay - php.firstMixedLayer_]
+                         : HGCalParameters::k_ScaleFromDDD * tube.rOut();
+            } else {
+              const DDBox& box = static_cast<DDBox>(sol);
+              rout = HGCalParameters::k_ScaleFromDDD * box.halfX();
+            }
             double zp = zvals[std::make_pair(lay, 1)];
             HGCalGeomParameters::layerParameters laypar(rin, rout, zp);
             layers[lay] = laypar;
@@ -1018,6 +1025,7 @@ void HGCalGeomParameters::loadGeometryHexagonModule(const cms::DDCompactView* cp
     int nsiz = static_cast<int>(fv2.level());
 #ifdef EDM_ML_DEBUG
     ++ntot2;
+    edm::LogVerbatim("HGCalGeom") << "loadGeometryHexagonModule:: nsiz " << nsiz << " Ltop " << levelTop;
 #endif
     if (nsiz > levelTop) {
       std::vector<int> copy = fv2.copyNos();
@@ -1043,10 +1051,15 @@ void HGCalGeomParameters::loadGeometryHexagonModule(const cms::DDCompactView* cp
           auto itr = layers.find(lay);
           if (itr == layers.end()) {
             const std::vector<double>& pars = fv2.parameters();
-            double rin = HGCalParameters::k_ScaleFromDD4hep * pars[0];
-            double rout = (php.firstMixedLayer_ > 0 && lay >= php.firstMixedLayer_)
-                              ? php.radiusMixBoundary_[lay - php.firstMixedLayer_]
-                              : HGCalParameters::k_ScaleFromDD4hep * pars[1];
+            double rin(0), rout(0);
+            if (dd4hep::isA<dd4hep::Box>(fv2.solid())) {
+              rout = HGCalParameters::k_ScaleFromDD4hep * pars[0];
+            } else {
+              rin = HGCalParameters::k_ScaleFromDD4hep * pars[0];
+              rout = (php.firstMixedLayer_ > 0 && lay >= php.firstMixedLayer_)
+                         ? php.radiusMixBoundary_[lay - php.firstMixedLayer_]
+                         : HGCalParameters::k_ScaleFromDD4hep * pars[1];
+            }
             double zp = zvals[std::make_pair(lay, 1)];
             HGCalGeomParameters::layerParameters laypar(rin, rout, zp);
             layers[lay] = laypar;
@@ -1515,7 +1528,7 @@ void HGCalGeomParameters::loadSpecParsHexagon8(HGCalParameters& php) {
     edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters: cell[" << k << "] Thickness " << php.cellThickness_[k];
   edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters: Polynomial "
                                 << "parameters for 120 to 200 micron "
-                                << "transition with" << php.radius100to200_.size() << " elements";
+                                << "transition with " << php.radius100to200_.size() << " elements";
   for (unsigned int k = 0; k < php.radius100to200_.size(); ++k)
     edm::LogVerbatim("HGCalGeom") << "Element [" << k << "] " << php.radius100to200_[k];
   edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters: Polynomial "
@@ -1534,8 +1547,10 @@ void HGCalGeomParameters::loadSpecParsHexagon8(HGCalParameters& php) {
   for (unsigned int k = 0; k < php.zFrontTop_.size(); ++k)
     edm::LogVerbatim("HGCalGeom") << "HGCalParameters: Boundary[" << k << "] Top Z = " << php.zFrontTop_[k]
                                   << " Slope = " << php.slopeTop_[k] << " rMax = " << php.rMaxFront_[k];
-  edm::LogVerbatim("HGCalGeom") << "HGCalParameters: Z-Boundary " << php.zRanges_[0] << ":" << php.zRanges_[1] << ":"
-                                << php.zRanges_[2] << ":" << php.zRanges_[3];
+  std::ostringstream st1;
+  for (unsigned int k = 0; k < php.zRanges_.size(); ++k)
+    st1 << ":" << php.zRanges_[k];
+  edm::LogVerbatim("HGCalGeom") << "HGCalParameters: Z-Boundary[" << php.zRanges_.size() << "] " << st1.str();
   edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters: LayerOffset " << php.layerOffset_ << " in array of size "
                                 << php.layerCenter_.size();
   for (unsigned int k = 0; k < php.layerCenter_.size(); ++k)
@@ -1603,8 +1618,11 @@ void HGCalGeomParameters::loadSpecParsTrapezoid(const DDFilteredView& fv, HGCalP
   php.layerFrontBH_ = dbl_to_int(getDDDArray("LayerFrontBH", sv, 0));
   php.rMinLayerBH_ = getDDDArray("RMinLayerBH", sv, 0);
   rescale(php.rMinLayerBH_, HGCalParameters::k_ScaleFromDDD);
+  assert(php.nPhiBinBH_.size() > 1);
   php.nCellsFine_ = php.nPhiBinBH_[0];
   php.nCellsCoarse_ = php.nPhiBinBH_[1];
+  assert(0 != php.nCellsFine_);
+  assert(0 != php.nCellsCoarse_);
   php.cellSize_.emplace_back(2.0 * M_PI / php.nCellsFine_);
   php.cellSize_.emplace_back(2.0 * M_PI / php.nCellsCoarse_);
 
@@ -1692,8 +1710,11 @@ void HGCalGeomParameters::loadSpecParsTrapezoid(const cms::DDFilteredView& fv,
   php.layerFrontBH_ = dbl_to_int(fv.get<std::vector<double> >(sdTag1, "LayerFrontBH"));
   php.rMinLayerBH_ = fv.get<std::vector<double> >(sdTag1, "RMinLayerBH");
   rescale(php.rMinLayerBH_, HGCalParameters::k_ScaleFromDD4hep);
+  assert(php.nPhiBinBH_.size() > 1);
   php.nCellsFine_ = php.nPhiBinBH_[0];
   php.nCellsCoarse_ = php.nPhiBinBH_[1];
+  assert(0 != php.nCellsFine_);
+  assert(0 != php.nCellsCoarse_);
   php.cellSize_.emplace_back(2.0 * M_PI / php.nCellsFine_);
   php.cellSize_.emplace_back(2.0 * M_PI / php.nCellsCoarse_);
 
@@ -1803,8 +1824,10 @@ void HGCalGeomParameters::loadSpecParsTrapezoid(HGCalParameters& php) {
     edm::LogVerbatim("HGCalGeom") << "HGCalParameters: Boundary[" << k << "] Top Z = " << php.zFrontTop_[k]
                                   << " Slope = " << php.slopeTop_[k] << " rMax = " << php.rMaxFront_[k];
 
-  edm::LogVerbatim("HGCalGeom") << "HGCalParameters: Z-Boundary " << php.zRanges_[0] << ":" << php.zRanges_[1] << ":"
-                                << php.zRanges_[2] << ":" << php.zRanges_[3];
+  std::ostringstream st1;
+  for (unsigned int k = 0; k < php.zRanges_.size(); ++k)
+    st1 << ":" << php.zRanges_[k];
+  edm::LogVerbatim("HGCalGeom") << "HGCalParameters: Z-Boundary[" << php.zRanges_.size() << "] " << st1.str();
 
   edm::LogVerbatim("HGCalGeom") << "HGCalParameters: LayerOffset " << php.layerOffset_ << " in array of size "
                                 << php.layerCenter_.size();

Geometry/HGCalCommonData/src/HGCalParametersFromDD.cc

@@ -123,6 +123,8 @@ bool HGCalParametersFromDD::build(const DDCompactView* cpv,
         php.mouseBite_ = HGCalParameters::k_ScaleFromDDD * getDDDValue("MouseBite", sv2);
         php.useOffset_ = static_cast<int>(getDDDValue("UseOffset", sv2));
         php.waferR_ = HGCalParameters::k_ScaleToDDD * php.waferSize_ * tan30deg_;
+        assert(php.nCellsFine_ != 0);
+        assert(php.nCellsCoarse_ != 0);
         php.cellSize_.emplace_back(HGCalParameters::k_ScaleToDDD * php.waferSize_ / php.nCellsFine_);
         php.cellSize_.emplace_back(HGCalParameters::k_ScaleToDDD * php.waferSize_ / php.nCellsCoarse_);
 #ifdef EDM_ML_DEBUG
@@ -355,6 +357,8 @@ bool HGCalParametersFromDD::build(const cms::DDCompactView* cpv,
       tempD = fv.get<std::vector<double> >(namet, "UseOffset");
       php.useOffset_ = static_cast<int>(tempD[0]);
       php.waferR_ = HGCalParameters::k_ScaleToDDD * php.waferSize_ * tan30deg_;
+      assert(php.nCellsFine_ != 0);
+      assert(php.nCellsCoarse_ != 0);
       php.cellSize_.emplace_back(HGCalParameters::k_ScaleToDDD * php.waferSize_ / php.nCellsFine_);
       php.cellSize_.emplace_back(HGCalParameters::k_ScaleToDDD * php.waferSize_ / php.nCellsCoarse_);
 #ifdef EDM_ML_DEBUG
@@ -496,6 +500,7 @@ void HGCalParametersFromDD::getCellPosition(HGCalParameters& php, int type) {
   std::vector<int> indtypes;
 #endif
   int N = (type == 1) ? php.nCellsCoarse_ : php.nCellsFine_;
+  assert(N != 0);
   double R = php.waferSize_ / (3 * N);
   double r = 0.5 * R * sqrt(3.0);
   int n2 = N / 2;