Merge CMSSW_10_6_X into CMSSW_10_6_DEVEL_X.

Geometry/HGCalCommonData/data/hgcalHEmix/v10/hgcalHEmix.xml

@@ -35,11 +35,11 @@
       1, 2, 3, 4, 5,  1, 2, 3, 4, 5,  1, 2, 3, 4, 5,
       1, 2, 3, 4, 5,  1, 2, 3, 4, 5</Vector>
     <Vector name="LayerSense" type="numeric" nEntries="70">
-      0, 0, 0, 1, 0,  0, 0, 0, 1, 0,  0, 0, 0, 1, 0,
-      0, 0, 0, 1, 0,  0, 0, 0, 1, 0,  0, 0, 0, 1, 0,
-      0, 0, 0, 1, 0,  0, 0, 0, 1, 0,  0, 0, 0, 1, 0,
-      0, 0, 0, 1, 0,  0, 0, 0, 1, 0,  0, 0, 0, 1, 0,
-      0, 0, 0, 1, 0,  0, 0, 0, 1, 0</Vector>
+      -1, 0, 0, 1, 0, -1, 0, 0, 1, 0, -1, 0, 0, 1, 0,
+      -1, 0, 0, 1, 0, -1, 0, 0, 1, 0, -1, 0, 0, 1, 0,
+      -1, 0, 0, 1, 0, -1, 0, 0, 1, 0, -1, 0, 0, 1, 0,
+      -1, 0, 0, 1, 0, -1, 0, 0, 1, 0, -1, 0, 0, 1, 0,
+      -1, 0, 0, 1, 0, -1, 0, 0, 1, 0</Vector>
     <Numeric name="FirstLayer"       value="[hgcal:FirstMixedLayer]"/>
     <Numeric name="AbsorberMode"     value="1"/>
     <Vector name="TopMaterialNames" type="string" nEntries="6">

Geometry/HGCalCommonData/data/hgcalHEsil/v10/hgcalHEsil.xml

@@ -36,14 +36,14 @@
       1, 2, 3, 4, 5, 6, 8, 7, 8, 9, 8, 10, 11,
       1, 2, 3, 4, 5, 6, 8, 7, 8, 9, 8, 10, 11 </Vector>
     <Vector name="LayerSense" type="numeric" nEntries="104">
-      0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0</Vector>
+      -1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
+      -1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
+      -1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
+      -1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
+      -1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
+      -1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
+      -1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
+      -1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0</Vector>
     <Numeric name="FirstLayer"       value="1"/>
     <Numeric name="AbsorberMode"     value="1"/>
     <Numeric name="zMinBlock"        value="[hgcal:zHGCalHEsil1]"/>

Geometry/HGCalCommonData/plugins/DDHGCalEEAlgo.cc

@@ -4,6 +4,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "FWCore/MessageLogger/interface/MessageLogger.h"
+#include "DataFormats/Math/interface/GeantUnits.h"
 #include "DetectorDescription/Core/interface/DDutils.h"
 #include "DetectorDescription/Core/interface/DDSolid.h"
 #include "DetectorDescription/Core/interface/DDMaterial.h"
@@ -12,10 +13,10 @@
 #include "Geometry/HGCalCommonData/plugins/DDHGCalEEAlgo.h"
 #include "Geometry/HGCalCommonData/interface/HGCalGeomTools.h"
 #include "Geometry/HGCalCommonData/interface/HGCalParameters.h"
-#include "CLHEP/Units/GlobalPhysicalConstants.h"
-#include "CLHEP/Units/GlobalSystemOfUnits.h"
 
 //#define EDM_ML_DEBUG
+using namespace geant_units;
+using namespace geant_units::operators;
 
 DDHGCalEEAlgo::DDHGCalEEAlgo() {
 #ifdef EDM_ML_DEBUG
@@ -103,6 +104,8 @@ void DDHGCalEEAlgo::initialize(const DDNumericArguments & nArgs,
   waferSize_    = nArgs["waferSize"];
   waferSepar_   = nArgs["SensorSeparation"];
   sectors_      = (int)(nArgs["Sectors"]);
+  alpha_        = piRadians/sectors_;
+  cosAlpha_     = cos(alpha_);
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "zStart " << zMinBlock_ 
 				<< " radius for wafer type separation uses "
@@ -111,7 +114,8 @@ void DDHGCalEEAlgo::initialize(const DDNumericArguments & nArgs,
 				<< ":" << nCutRadPar_ << ":" << fracAreaMin_
 				<< " wafer width " << waferSize_ 
 				<< " separations " << waferSepar_
-				<< " sectors " << sectors_;
+				<< " sectors " << sectors_ << ":"
+				<< convertRadToDeg(alpha_) << ":" << cosAlpha_;
   for (unsigned int k=0; k<rad100to200_.size(); ++k)
     edm::LogVerbatim("HGCalGeom") << "[" << k << "] 100-200 " <<rad100to200_[k]
 				  << " 200-300 " << rad200to300_[k];
@@ -187,6 +191,8 @@ void DDHGCalEEAlgo::constructLayers(const DDLogicalPart& module,
       int     copy   = copyNumber_[ii];
       double  hthick = 0.5*thick_[ii];
       double  rinB   = HGCalGeomTools::radius(zo,zFrontB_,rMinFront_,slopeB_);
+      std::pair<double,double> zr = HGCalGeomTools::zradius(zz,zz+thick_[ii],
+							    zFrontT_,rMaxFront_);
       zz            += hthick;
       thickTot      += thick_[ii];
 
@@ -203,23 +209,36 @@ void DDHGCalEEAlgo::constructLayers(const DDLogicalPart& module,
       DDMaterial matter(matName);
       DDLogicalPart glog;
       if (layerSense_[ly] < 1) {
-	double alpha = CLHEP::pi/sectors_;
-	int    nsec  = (layerSense_[ly] == 0 || absorbMode_ == 0) ? 2 : 2;
+	int    nsec  = (layerSense_[ly] == 0 || absorbMode_ == 0 ||
+			zr.first < 0) ? 2 : 3;
 	std::vector<double> pgonZ(nsec), pgonRin(nsec), pgonRout(nsec);
-	double rmax  = routF*cos(alpha) - tol;
-	pgonZ[0]    =-hthick;  pgonZ[1]    = hthick;
-	pgonRin[0]  = rinB;    pgonRin[1]  = rinB;   
-	pgonRout[0] = rmax;    pgonRout[1] = rmax;   
+	if (layerSense_[ly] == 0 || absorbMode_ == 0) {
+	  double rmax  = routF*cosAlpha_ - tol;
+	  pgonZ[0]    =-hthick;  pgonZ[1]    = hthick;
+	  pgonRin[0]  = rinB;    pgonRin[1]  = rinB;   
+	  pgonRout[0] = rmax;    pgonRout[1] = rmax;
+	} else {
+	  for (int isec=0; isec<nsec; ++isec) {
+	    double zs = ((isec == 0) ? (zz-hthick) : (isec == nsec-1) ?
+			 (zz+hthick) : zr.first);
+            double rm = (((isec == 0) || (isec == nsec-1)) ?
+			 HGCalGeomTools::radius(zs,zFrontT_,rMaxFront_,slopeT_)
+			 : zr.second)*cosAlpha_ - tol;
+	    pgonZ[isec]    = zs-zz;
+	    pgonRin[isec]  = rinB;
+	    pgonRout[isec] = rm;
+	  }
+	}
 	DDSolid solid = DDSolidFactory::polyhedra(DDName(name, nameSpace_),
-						  sectors_,-alpha,CLHEP::twopi,
+						  sectors_, -alpha_, 2._pi,
 						  pgonZ, pgonRin, pgonRout);
 	glog = DDLogicalPart(solid.ddname(), matter, solid);
 #ifdef EDM_ML_DEBUG
 	edm::LogVerbatim("HGCalGeom") << "DDHGCalEEAlgo: " << solid.name() 
 				      << " polyhedra of " << sectors_ 
 				      << " sectors covering " 
-				      << -alpha/CLHEP::deg << ":" 
-				      << (-alpha+CLHEP::twopi)/CLHEP::deg
+				      << convertRadToDeg(-alpha_) << ":" 
+				      << convertRadToDeg(-alpha_+2._pi)
 				      << " with " << pgonZ.size()
 				      << " sections and filled with "
 				      << matName << ":" << &matter;
@@ -230,17 +249,15 @@ void DDHGCalEEAlgo::constructLayers(const DDLogicalPart& module,
 #endif
       } else {
 	DDSolid solid = DDSolidFactory::tubs(DDName(name, nameSpace_), 
-					     hthick, rinB, routF, 0.0,
-					     CLHEP::twopi);
+					     hthick, rinB, routF, 0.0, 2._pi);
 	glog = DDLogicalPart(solid.ddname(), matter, solid);
 #ifdef EDM_ML_DEBUG
 	edm::LogVerbatim("HGCalGeom") << "DDHGCalEEAlgo: " << solid.name() 
 				      << " Tubs made of " << matName << ":"
 				      << &matter << " of dimensions " << rinB 
 				      << ", " << routF << ", " << hthick
-				      << ", 0.0, " << CLHEP::twopi/CLHEP::deg
-				      << " and position " << glog.name() 
-				      << " number " << copy;
+				      << ", 0.0, 360.0 and position " 
+				      << glog.name() << " number " << copy;
 #endif
 	positionSensitive(glog,rinB,routF,zz,layerSense_[ly],cpv);
       }

Geometry/HGCalCommonData/plugins/DDHGCalEEAlgo.h

@@ -66,6 +66,7 @@ class DDHGCalEEAlgo : public DDAlgorithm {
   std::vector<double>      rMaxFront_;    //Corresponding rMax's
   std::string              nameSpace_;    //Namespace of this and ALL sub-parts
   std::unordered_set<int>  copies_;       //List of copy #'s
+  double                   alpha_, cosAlpha_;
 };
 
 #endif

Geometry/HGCalCommonData/plugins/DDHGCalHEAlgo.cc

@@ -4,16 +4,17 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "FWCore/MessageLogger/interface/MessageLogger.h"
+#include "DataFormats/Math/interface/GeantUnits.h"
 #include "DetectorDescription/Core/interface/DDutils.h"
 #include "DetectorDescription/Core/interface/DDSolid.h"
 #include "DetectorDescription/Core/interface/DDCurrentNamespace.h"
 #include "DetectorDescription/Core/interface/DDSplit.h"
 #include "Geometry/HGCalCommonData/plugins/DDHGCalHEAlgo.h"
 #include "Geometry/HGCalCommonData/interface/HGCalGeomTools.h"
 #include "Geometry/HGCalCommonData/interface/HGCalParameters.h"
-#include "CLHEP/Units/GlobalPhysicalConstants.h"
-#include "CLHEP/Units/GlobalSystemOfUnits.h"
 
+using namespace geant_units;
+using namespace geant_units::operators;
 //#define EDM_ML_DEBUG
 
 DDHGCalHEAlgo::DDHGCalHEAlgo() {
@@ -147,6 +148,8 @@ void DDHGCalHEAlgo::initialize(const DDNumericArguments & nArgs,
   waferSize_    = nArgs["waferSize"];
   waferSepar_   = nArgs["SensorSeparation"];
   sectors_      = (int)(nArgs["Sectors"]);
+  alpha_        = piRadians/sectors_;
+  cosAlpha_     = cos(alpha_);
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "DDHGCalHEAlgo: zStart " << zMinBlock_ 
 				<< " radius for wafer type separation uses "
@@ -155,7 +158,8 @@ void DDHGCalHEAlgo::initialize(const DDNumericArguments & nArgs,
 				<< ":" << nCutRadPar_ << ":" << fracAreaMin_
 				<< " wafer width " << waferSize_ 
 				<< " separations " << waferSepar_
-				<< " sectors " << sectors_;
+				<< " sectors " << sectors_ << ":"
+				<< convertRadToDeg(alpha_) << ":" << cosAlpha_;
   for (unsigned int k=0; k<rad100to200_.size(); ++k)
     edm::LogVerbatim("HGCalGeom") << "[" << k << "] 100-200 " <<rad100to200_[k]
 				  << " 200-300 " << rad200to300_[k];
@@ -231,6 +235,8 @@ void DDHGCalHEAlgo::constructLayers(const DDLogicalPart& module,
       int     copy   = copyNumber_[ii];
       double  hthick = 0.5*thick_[ii];
       double  rinB   = HGCalGeomTools::radius(zo,zFrontB_,rMinFront_,slopeB_);
+      std::pair<double,double> zr = HGCalGeomTools::zradius(zz,zz+thick_[ii],
+							    zFrontT_,rMaxFront_);
       zz            += hthick;
       thickTot      += thick_[ii];
 
@@ -247,23 +253,38 @@ void DDHGCalHEAlgo::constructLayers(const DDLogicalPart& module,
       DDMaterial matter(matName);
       DDLogicalPart glog;
       if (layerSense_[ly] < 1) {
-	double alpha = CLHEP::pi/sectors_;
-	int    nsec  = (layerSense_[ly] == 0 || absorbMode_ == 0) ? 2 : 2;
+        int    nsec  = (layerSense_[ly] == 0 || absorbMode_ == 0 ||
+                        zr.first < 0) ? 2 : 3;
 	std::vector<double> pgonZ(nsec), pgonRin(nsec), pgonRout(nsec);
-	double rmax  = routF*cos(alpha) - tol;
-	pgonZ[0]    =-hthick;  pgonZ[1]    = hthick;
-	pgonRin[0]  = rinB;    pgonRin[1]  = rinB;   
-	pgonRout[0] = rmax;    pgonRout[1] = rmax;   
+        if (layerSense_[ly] == 0 || absorbMode_ == 0) {
+	  double rmax  = (std::min(routF,
+				  HGCalGeomTools::radius(zz+hthick,zFrontT_,rMaxFront_,slopeT_))*
+			  cosAlpha_) - tol;
+	  pgonZ[0]    =-hthick;  pgonZ[1]    = hthick;
+	  pgonRin[0]  = rinB;    pgonRin[1]  = rinB;   
+	  pgonRout[0] = rmax;    pgonRout[1] = rmax;   
+        } else {
+          for (int isec=0; isec<nsec; ++isec) {
+            double zs = ((isec == 0) ? (zz-hthick) : (isec == nsec-1) ?
+                         (zz+hthick) : zr.first);
+            double rm = (((isec == 0) || (isec == nsec-1)) ?
+			 HGCalGeomTools::radius(zs,zFrontT_,rMaxFront_,slopeT_)
+			 : zr.second)*cosAlpha_ - tol;
+            pgonZ[isec]    = zs-zz;
+            pgonRin[isec]  = rinB;
+            pgonRout[isec] = rm;
+          }
+        }
 	DDSolid solid = DDSolidFactory::polyhedra(DDName(name, nameSpace_),
-						  sectors_,-alpha,CLHEP::twopi,
+						  sectors_, -alpha_, 2._pi,
 						  pgonZ, pgonRin, pgonRout);
 	glog = DDLogicalPart(solid.ddname(), matter, solid);
 #ifdef EDM_ML_DEBUG
 	edm::LogVerbatim("HGCalGeom") << "DDHGCalHEAlgo: " << solid.name()
 				      << " polyhedra of " << sectors_ 
 				      << " sectors covering " 
-				      << -alpha/CLHEP::deg << ":" 
-				      << (-alpha+CLHEP::twopi)/CLHEP::deg
+				      << convertRadToDeg(-alpha_) << ":" 
+				      << convertRadToDeg(-alpha_+2._pi)
 				      << " with " << pgonZ.size()<<" sections";
 	for (unsigned int k=0; k<pgonZ.size(); ++k)
 	  edm::LogVerbatim("HGCalGeom") << "[" << k << "] z " << pgonZ[k] 
@@ -272,17 +293,15 @@ void DDHGCalHEAlgo::constructLayers(const DDLogicalPart& module,
 #endif
       } else {
 	DDSolid solid = DDSolidFactory::tubs(DDName(name, nameSpace_), 
-					     hthick, rinB, routF, 0.0,
-					     CLHEP::twopi);
+					     hthick, rinB, routF, 0.0, 2._pi);
 	glog = DDLogicalPart(solid.ddname(), matter, solid);
 #ifdef EDM_ML_DEBUG
 	edm::LogVerbatim("HGCalGeom") << "DDHGCalHEAlgo: " << solid.name()
 				      << " Tubs made of " << matName 
 				      << " of dimensions " << rinB 
 				      << ", " << routF << ", " << hthick
-				      << ", 0.0, " << CLHEP::twopi/CLHEP::deg;
-	edm::LogVerbatim("HGCalGeom") << "Position in: " << glog.name() 
-				      << " number "	<< copy;
+				      << ", 0.0, 360.0 and positioned in: "
+				      << glog.name() << " number " << copy;
 #endif
 	positionMix(glog, name, copy, thick_[ii], matter, rinB, rMixLayer_[i],
 		    routF, zz, cpv);
@@ -336,15 +355,13 @@ void DDHGCalHEAlgo::positionMix(const DDLogicalPart& glog,
   // Make the top part first
   std::string name = nameM+"Top";
   DDSolid solid = DDSolidFactory::tubs(DDName(name, nameSpace_), 
-				       hthick, rmid, rout, 0.0,
-				       CLHEP::twopi);
+				       hthick, rmid, rout, 0.0, 2._pi);
   glog1 = DDLogicalPart(solid.ddname(), matter, solid);
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "DDHGCalHEAlgo: " << solid.name() 
 				<< " Tubs made of " << matter.name() 
 				<< " of dimensions " << rmid << ", " << rout 
-				<< ", " << hthick << ", 0.0, " 
-				<< CLHEP::twopi/CLHEP::deg;
+				<< ", " << hthick << ", 0.0, 360.0";
 #endif
   cpv.position(glog1, glog, 1, tran, rot);
 #ifdef EDM_ML_DEBUG
@@ -368,7 +385,7 @@ void DDHGCalHEAlgo::positionMix(const DDLogicalPart& glog,
 		   DDSplit(materialsTop_[ii]).second);
     DDMaterial matter1(matName);
     solid = DDSolidFactory::tubs(DDName(name,nameSpace_), hthickl, rmid, rout,
-				 0.0, CLHEP::twopi);
+				 0.0, 2._pi);
     DDLogicalPart glog2 = DDLogicalPart(solid.ddname(), matter1, solid);
 #ifdef EDM_ML_DEBUG
     double eta1 = -log(tan(0.5*atan(rmid/zz)));
@@ -379,8 +396,7 @@ void DDHGCalHEAlgo::positionMix(const DDLogicalPart& glog,
     edm::LogVerbatim("HGCalGeom") << "DDHGCalHEAlgo: " << solid.name() 
 				  << " Tubs made of " << matName 
 				  << " of dimensions " << rmid << ", " << rout
-				  << ", " << hthickl <<", 0.0, "
-				  << CLHEP::twopi/CLHEP::deg;
+				  << ", " << hthickl <<", 0.0, 360.0";
 #endif
     zpos += hthickl;
     DDTranslation r1(0,0,zpos);
@@ -409,14 +425,13 @@ void DDHGCalHEAlgo::positionMix(const DDLogicalPart& glog,
   // Make the bottom part next
   name  = nameM+"Bottom";
   solid = DDSolidFactory::tubs(DDName(name, nameSpace_), 
-			       hthick, rin, rmid, 0.0, CLHEP::twopi);
+			       hthick, rin, rmid, 0.0, 2._pi);
   glog1 = DDLogicalPart(solid.ddname(), matter, solid);
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "DDHGCalHEAlgo: " << solid.name() 
 				<< " Tubs made of " << matter.name() 
 				<< " of dimensions " << rin << ", " << rmid 
-				<< ", " << hthick << ", 0.0, " 
-				<< CLHEP::twopi/CLHEP::deg;
+				<< ", " << hthick << ", 0.0, 360.0";
 #endif
   cpv.position(glog1, glog, 1, tran, rot);
 #ifdef EDM_ML_DEBUG
@@ -441,7 +456,7 @@ void DDHGCalHEAlgo::positionMix(const DDLogicalPart& glog,
 		   DDSplit(materialsBot_[ii]).second);
     DDMaterial matter1(matName);
     solid = DDSolidFactory::tubs(DDName(name,nameSpace_), hthickl, rin, rmid,
-				 0.0, CLHEP::twopi);
+				 0.0, 2._pi);
     DDLogicalPart glog2 = DDLogicalPart(solid.ddname(), matter1, solid);
 #ifdef EDM_ML_DEBUG
     double eta1 = -log(tan(0.5*atan(rin/zz)));
@@ -452,8 +467,7 @@ void DDHGCalHEAlgo::positionMix(const DDLogicalPart& glog,
     edm::LogVerbatim("HGCalGeom") << "DDHGCalHEAlgo: " << solid.name() 
 				  << " Tubs made of " << matName 
 				  << " of dimensions " << rin << ", " << rmid 
-				  << ", " << hthickl <<", 0.0, "
-				  << CLHEP::twopi/CLHEP::deg;
+				  << ", " << hthickl <<", 0.0, 360.0";
 #endif
     zpos += hthickl;
     DDTranslation r1(0,0,zpos);

Geometry/HGCalCommonData/plugins/DDHGCalHEAlgo.h

@@ -84,6 +84,7 @@ class DDHGCalHEAlgo : public DDAlgorithm {
   std::vector<double>      rMaxFront_;    //Corresponding rMax's
   std::string              nameSpace_;    //Namespace of this and ALL sub-parts
   std::unordered_set<int>  copies_;       //List of copy #'s
+  double                   alpha_, cosAlpha_;
 };
 
 #endif

Geometry/HGCalCommonData/python/testHGCV10XML_cfi.py

@@ -36,6 +36,8 @@
         'Geometry/HGCalCommonData/data/hgcalwafer/v9/hgcalwafer.xml',
         'Geometry/HGCalCommonData/data/hgcalcell/v9/hgcalcell.xml',
         'Geometry/HGCalCommonData/data/hgcalCons/v10/hgcalCons.xml',
+        'Geometry/HGCalSimData/data/hgcsensv9.xml',
+        'Geometry/HGCalSimData/data/hgcProdCutsv9.xml',
     )+
     cms.vstring(
         'Geometry/CMSCommonData/data/FieldParameters.xml',

SimG4CMS/Calo/src/HcalNumberingFromPS.cc

@@ -8,7 +8,6 @@
 #include <iomanip>
 
 //#define EDM_ML_DEBUG
-using namespace geant_units;
 using namespace geant_units::operators;
 
 HcalNumberingFromPS::HcalNumberingFromPS(const edm::ParameterSet& conf) {

SimG4CMS/Calo/test/python/runHGC4_cfg.py

@@ -5,6 +5,8 @@
 process.load("IOMC.EventVertexGenerators.VtxSmearedGauss_cfi")
 #process.load("Configuration.Geometry.GeometryExtended2023D28_cff")
 process.load("Geometry.HGCalCommonData.testHGCV10XML_cfi")
+process.load("Geometry.HGCalCommonData.hgcalParametersInitialization_cfi")
+process.load("Geometry.HGCalCommonData.hgcalNumberingInitialization_cfi")
 process.load("Configuration.StandardSequences.MagneticField_cff")
 process.load("Configuration.EventContent.EventContent_cff")
 process.load('Configuration.StandardSequences.Generator_cff')