CMS 3D CMS Logo
List of all members | Public Member Functions | Public Attributes
HcalBarrelAlgo Struct Reference

Public Member Functions

void constructInsideDetectors (dd4hep::Volume &detector, const std::string &name, int id, double dx, double dy, double dz, int type, cms::DDNamespace &ns)
 
void constructInsideLayers (dd4hep::Volume &laylog, const std::string &nm, int id, int nAbs, double rin, double d1, double alpha1, double d2, double alpha2, double t1, double t2, cms::DDNamespace &ns)
 
dd4hep::Volume constructMidLayer (dd4hep::Volume laylog, const std::string &nm, double rin, double alpha, cms::DDNamespace &ns)
 
dd4hep::Volume constructSideLayer (dd4hep::Volume &laylog, const std::string &nm, int nAbs, double rin, double alpha, cms::DDNamespace &ns)
 
dd4hep::Rotation3D getRotation (std::string &rotation, std::string &rotns, cms::DDNamespace &ns)
 
 HcalBarrelAlgo ()=delete
 
 HcalBarrelAlgo (cms::DDParsingContext &ctxt, xml_h &e)
 

Public Attributes

std::vector< double > absorbD
 
std::vector< std::string > absorbMat
 
std::vector< std::string > absorbName
 
std::vector< double > absorbT
 
std::vector< double > detdP1
 
std::vector< double > detdP2
 
std::string detMat
 
std::string detMatPl
 
std::string detMatSc
 
std::vector< int > detPosY
 
std::string detRot
 
std::vector< double > detT11
 
std::vector< double > detT12
 
std::vector< double > detT21
 
std::vector< double > detT22
 
std::vector< double > detTsc
 
std::vector< int > detType
 
std::vector< double > detWidth1
 
std::vector< double > detWidth2
 
std::string genMaterial
 
std::string idName
 
std::string idNameSpace
 
int idOffset
 
std::vector< int > layerAbsorb
 
std::vector< double > layerAlpha
 
std::vector< double > layerD1
 
std::vector< double > layerD2
 
std::vector< double > layerGap
 
std::vector< int > layerId
 
std::vector< std::string > layerLabel
 
std::vector< std::string > layerMat
 
std::vector< double > layerT1
 
std::vector< double > layerT2
 
std::vector< double > layerWidth
 
double middleD
 
std::string middleMat
 
double middleW
 
std::vector< std::string > midMat
 
std::vector< std::string > midName
 
std::vector< double > midT
 
std::vector< double > midW
 
int nAbsorber
 
int nhalf
 
int nLayers
 
int nMidAbs
 
int nsectors
 
int nsectortot
 
int nSideAbs
 
double rinner
 
std::vector< double > rmax
 
std::string rotHalf
 
std::string rotns
 
double router
 
int rzones
 
std::vector< std::string > sideAbsMat
 
std::vector< std::string > sideAbsName
 
std::vector< double > sideAbsW
 
std::vector< double > sideD
 
std::vector< std::string > sideMat
 
std::vector< double > sideT
 
std::vector< double > theta
 
std::vector< double > ttheta
 
std::vector< double > zoff
 

Detailed Description

Definition at line 22 of file DDHCalBarrelAlgo.cc.

Constructor & Destructor Documentation

◆ HcalBarrelAlgo() [1/2]

HcalBarrelAlgo::HcalBarrelAlgo ( )
delete

◆ HcalBarrelAlgo() [2/2]

HcalBarrelAlgo::HcalBarrelAlgo ( cms::DDParsingContext &  ctxt,
xml_h &  e 
)
inline

!!!!!!!!!!!!!!!!Should be zero. And removed as soon as

Definition at line 142 of file DDHCalBarrelAlgo.cc.

142  {
143  cms::DDNamespace ns(ctxt, e, true);
144  cms::DDAlgoArguments args(ctxt, e);
145 #ifdef EDM_ML_DEBUG
146  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: Creating an instance";
147 #endif
148 
149  genMaterial = args.value<std::string>("MaterialName");
150  nsectors = args.value<int>("NSector");
151  nsectortot = args.value<int>("NSectorTot");
152  nhalf = args.value<int>("NHalf");
153  rinner = args.value<double>("RIn");
154  router = args.value<double>("ROut");
155  rzones = args.value<int>("RZones");
156  rotHalf = args.value<std::string>("RotHalf");
157  rotns = args.value<std::string>("RotNameSpace");
158 
159  theta = args.value<std::vector<double> >("Theta");
160  rmax = args.value<std::vector<double> >("RMax");
161  zoff = args.value<std::vector<double> >("ZOff");
162  for (int i = 0; i < rzones; i++) {
163  ttheta.emplace_back(tan(theta[i])); //*deg already done in XML
164  }
165  if (rzones > 3)
166  rmax[2] = (zoff[3] - zoff[2]) / ttheta[2];
167 
168 #ifdef EDM_ML_DEBUG
169  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: General material " << genMaterial << "\tSectors " << nsectors
170  << ", " << nsectortot << "\tHalves " << nhalf << "\tRotation matrix " << rotns << ":"
171  << rotHalf << "\n\t\t" << convertCmToMm(rinner) << "\t" << convertCmToMm(router)
172  << "\t" << rzones;
173  for (int i = 0; i < rzones; i++)
174  edm::LogVerbatim("HCalGeom") << "\tTheta[" << i << "] = " << theta[i] << "\trmax[" << i
175  << "] = " << convertCmToMm(rmax[i]) << "\tzoff[" << i
176  << "] = " << convertCmToMm(zoff[i]);
177 #endif
178  //Layers
180  nLayers = args.value<int>("NLayers");
181 #ifdef EDM_ML_DEBUG
182  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: Layer\t" << nLayers;
183 #endif
184  layerId = args.value<std::vector<int> >("Id");
185  layerLabel = args.value<std::vector<std::string> >("LayerLabel");
186  layerMat = args.value<std::vector<std::string> >("LayerMat");
187  layerWidth = args.value<std::vector<double> >("LayerWidth");
188  layerD1 = args.value<std::vector<double> >("D1");
189  layerD2 = args.value<std::vector<double> >("D2");
190  layerAlpha = args.value<std::vector<double> >("Alpha2");
191  layerT1 = args.value<std::vector<double> >("T1");
192  layerT2 = args.value<std::vector<double> >("T2");
193  layerAbsorb = args.value<std::vector<int> >("AbsL");
194  layerGap = args.value<std::vector<double> >("Gap");
195 #ifdef EDM_ML_DEBUG
196  for (int i = 0; i < nLayers; i++)
197  edm::LogVerbatim("HCalGeom") << layerLabel[i] << "\t" << layerId[i] << "\t" << layerMat[i] << "\t"
198  << convertCmToMm(layerWidth[i]) << "\t" << convertCmToMm(layerD1[i]) << "\t"
199  << convertCmToMm(layerD2[i]) << "\t" << layerAlpha[i] << "\t"
200  << convertCmToMm(layerT1[i]) << "\t" << convertCmToMm(layerT2[i]) << "\t"
201  << layerAbsorb[i] << "\t" << convertCmToMm(layerGap[i]);
202 #endif
203 
205  //Absorber Layers and middle part
206  absorbName = args.value<std::vector<std::string> >("AbsorbName");
207  absorbMat = args.value<std::vector<std::string> >("AbsorbMat");
208  absorbD = args.value<std::vector<double> >("AbsorbD");
209  absorbT = args.value<std::vector<double> >("AbsorbT");
210  nAbsorber = absorbName.size();
211 #ifdef EDM_ML_DEBUG
212  for (int i = 0; i < nAbsorber; i++)
213  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << absorbName[i] << " Material " << absorbMat[i] << " d "
214  << convertCmToMm(absorbD[i]) << " t " << convertCmToMm(absorbT[i]);
215 #endif
216  middleMat = args.value<std::string>("MiddleMat");
217  middleD = args.value<double>("MiddleD");
218  middleW = args.value<double>("MiddleW");
219 #ifdef EDM_ML_DEBUG
220  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: Middle material " << middleMat << " d " << convertCmToMm(middleD)
221  << " w " << convertCmToMm(middleW);
222 #endif
223  midName = args.value<std::vector<std::string> >("MidAbsName");
224  midMat = args.value<std::vector<std::string> >("MidAbsMat");
225  midW = args.value<std::vector<double> >("MidAbsW");
226  midT = args.value<std::vector<double> >("MidAbsT");
227  nMidAbs = midName.size();
228 #ifdef EDM_ML_DEBUG
229  for (int i = 0; i < nMidAbs; i++)
230  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << midName[i] << " Material " << midMat[i] << " W "
231  << convertCmToMm(midW[i]) << " T " << convertCmToMm(midT[i]);
232 #endif
233 
234  //Absorber layers in the side part
235  sideMat = args.value<std::vector<std::string> >("SideMat");
236  sideD = args.value<std::vector<double> >("SideD");
237  sideT = args.value<std::vector<double> >("SideT");
238 #ifdef EDM_ML_DEBUG
239  for (unsigned int i = 0; i < sideMat.size(); i++)
240  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: Side material " << sideMat[i] << " d "
241  << convertCmToMm(sideD[i]) << " t " << convertCmToMm(sideT[i]);
242 #endif
243  sideAbsName = args.value<std::vector<std::string> >("SideAbsName");
244  sideAbsMat = args.value<std::vector<std::string> >("SideAbsMat");
245  sideAbsW = args.value<std::vector<double> >("SideAbsW");
246  nSideAbs = sideAbsName.size();
247 #ifdef EDM_ML_DEBUG
248  for (int i = 0; i < nSideAbs; i++)
249  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << sideAbsName[i] << " Material " << sideAbsMat[i] << " W "
250  << convertCmToMm(sideAbsW[i]);
251 #endif
252 
254  // Detectors
255 
256  detMat = args.value<std::string>("DetMat");
257  detRot = args.value<std::string>("DetRot");
258  detMatPl = args.value<std::string>("DetMatPl");
259  detMatSc = args.value<std::string>("DetMatSc");
260 #ifdef EDM_ML_DEBUG
261  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: Detector (" << nLayers << ") Rotation matrix " << rotns << ":"
262  << detRot << "\n\t\t" << detMat << "\t" << detMatPl << "\t" << detMatSc;
263 #endif
264  detType = args.value<std::vector<int> >("DetType");
265  detdP1 = args.value<std::vector<double> >("DetdP1");
266  detdP2 = args.value<std::vector<double> >("DetdP2");
267  detT11 = args.value<std::vector<double> >("DetT11");
268  detT12 = args.value<std::vector<double> >("DetT12");
269  detTsc = args.value<std::vector<double> >("DetTsc");
270  detT21 = args.value<std::vector<double> >("DetT21");
271  detT22 = args.value<std::vector<double> >("DetT22");
272  detWidth1 = args.value<std::vector<double> >("DetWidth1");
273  detWidth2 = args.value<std::vector<double> >("DetWidth2");
274  detPosY = args.value<std::vector<int> >("DetPosY");
275 #ifdef EDM_ML_DEBUG
276  for (int i = 0; i < nLayers; i++)
277  edm::LogVerbatim("HCalGeom") << i + 1 << "\t" << detType[i] << "\t" << convertCmToMm(detdP1[i]) << ", "
278  << convertCmToMm(detdP2[i]) << "\t" << convertCmToMm(detT11[i]) << ", "
279  << convertCmToMm(detT12[i]) << "\t" << convertCmToMm(detTsc[i]) << "\t"
280  << convertCmToMm(detT21[i]) << ", " << convertCmToMm(detT22[i]) << "\t"
281  << convertCmToMm(detWidth1[i]) << "\t" << convertCmToMm(detWidth2[i]) << "\t"
282  << detPosY[i];
283 #endif
284 
285  // idName = parentName.name();
286  idName = args.value<std::string>("MotherName");
287  idNameSpace = ns.name();
288  idOffset = args.value<int>("IdOffset");
289 #ifdef EDM_ML_DEBUG
290  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: Parent " << args.parentName() << " idName " << idName
291  << " NameSpace " << idNameSpace << " Offset " << idOffset;
292  edm::LogVerbatim("HCalGeom") << "==>> Constructing DDHCalBarrelAlgo...\n"
293  << "DDHCalBarrelAlgo: General volume...";
294 #endif
295 
296  double alpha = (1._pi) / nsectors;
297  double dphi = nsectortot * (2._pi) / nsectors;
298  int nsec, ntot(15);
299  if (nhalf == 1)
300  nsec = 8;
301  else
302  nsec = 15;
303  int nf = ntot - nsec;
304 
305  //Calculate zmin... see HCalBarrel.hh picture. For polyhedra
306  //Rmin and Rmax are distances to vertex
307  double zmax = zoff[3];
308  double zstep5 = zoff[4];
309  double zstep4 = (zoff[1] + rmax[1] * ttheta[1]);
310  if ((zoff[2] + rmax[1] * ttheta[2]) > zstep4)
311  zstep4 = (zoff[2] + rmax[1] * ttheta[2]);
312  double zstep3 = (zoff[1] + rmax[0] * ttheta[1]);
313  double zstep2 = (zoff[0] + rmax[0] * ttheta[0]);
314  double zstep1 = (zoff[0] + rinner * ttheta[0]);
315  double rout = router;
316  double rout1 = rmax[3];
317  double rin = rinner;
318  double rmid1 = rmax[0];
319  double rmid2 = rmax[1];
320  double rmid3 = (zoff[4] - zoff[2]) / ttheta[2];
321  double rmid4 = rmax[2];
322 
323  std::vector<double> pgonZ = {-zmax,
324  -zstep5,
325  -zstep5,
326  -zstep4,
327  -zstep3,
328  -zstep2,
329  -zstep1,
330  0,
331  zstep1,
332  zstep2,
333  zstep3,
334  zstep4,
335  zstep5,
336  zstep5,
337  zmax};
338 
339  std::vector<double> pgonRmin = {
340  rmid4, rmid3, rmid3, rmid2, rmid1, rmid1, rin, rin, rin, rmid1, rmid1, rmid2, rmid3, rmid3, rmid4};
341 
342  std::vector<double> pgonRmax = {
343  rout1, rout1, rout, rout, rout, rout, rout, rout, rout, rout, rout, rout, rout, rout1, rout1};
344 
345  std::vector<double> pgonZHalf = {0, zstep1, zstep2, zstep3, zstep4, zstep5, zstep5, zmax};
346 
347  std::vector<double> pgonRminHalf = {rin, rin, rmid1, rmid1, rmid2, rmid3, rmid3, rmid4};
348 
349  std::vector<double> pgonRmaxHalf = {rout, rout, rout, rout, rout, rout, rout1, rout1};
350 
351  std::string name("Null");
352  dd4hep::Solid solid;
353  if (nf == 0) {
354  solid = dd4hep::Polyhedra(ns.prepend(idName), nsectortot, -alpha, dphi, pgonZ, pgonRmin, pgonRmax);
355 #ifdef EDM_ML_DEBUG
356  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Polyhedra made of " << genMaterial
357  << " with " << nsectortot << " sectors from " << convertRadToDeg(-alpha) << " to "
358  << convertRadToDeg(-alpha + dphi) << " and with " << nsec << " sections ";
359  for (unsigned int i = 0; i < pgonZ.size(); i++)
360  edm::LogVerbatim("HCalGeom") << "\t"
361  << "\tZ = " << convertCmToMm(pgonZ[i]) << "\tRmin = " << convertCmToMm(pgonRmin[i])
362  << "\tRmax = " << convertCmToMm(pgonRmax[i]);
363 #endif
364  } else {
365  solid = dd4hep::Polyhedra(ns.prepend(idName), nsectortot, -alpha, dphi, pgonZHalf, pgonRminHalf, pgonRmaxHalf);
366 #ifdef EDM_ML_DEBUG
367  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Polyhedra made of " << genMaterial
368  << " with " << nsectortot << " sectors from " << convertRadToDeg(-alpha) << " to "
369  << convertRadToDeg(-alpha + dphi) << " and with " << nsec << " sections ";
370  for (unsigned int i = 0; i < pgonZHalf.size(); i++)
371  edm::LogVerbatim("HCalGeom") << "\t"
372  << "\tZ = " << convertCmToMm(pgonZHalf[i])
373  << "\tRmin = " << convertCmToMm(pgonRminHalf[i])
374  << "\tRmax = " << convertCmToMm(pgonRmaxHalf[i]);
375 #endif
376  }
377 
378  dd4hep::Material matter = ns.material(genMaterial);
379  dd4hep::Volume genlogic(solid.name(), solid, matter);
380  dd4hep::Volume parentName = ns.volume(args.parentName());
381  parentName.placeVolume(genlogic, 1);
382 #ifdef EDM_ML_DEBUG
383  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << genlogic.name() << " number 1 positioned in "
384  << parentName.name() << " at (0, 0, 0) with no rotation";
385 #endif
386  //Forward and backwards halfs
387  name = idName + "Half";
388  nf = (ntot + 1) / 2;
389  solid = dd4hep::Polyhedra(ns.prepend(name), nsectortot, -alpha, dphi, pgonZHalf, pgonRminHalf, pgonRmaxHalf);
390 #ifdef EDM_ML_DEBUG
391  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Polyhedra made of " << genMaterial
392  << " with " << nsectortot << " sectors from " << convertRadToDeg(-alpha) << " to "
393  << convertRadToDeg(-alpha + dphi) << " and with " << nf << " sections ";
394  for (unsigned int i = 0; i < pgonZHalf.size(); i++)
395  edm::LogVerbatim("HCalGeom") << "\t"
396  << "\tZ = " << convertCmToMm(pgonZHalf[i])
397  << "\tRmin = " << convertCmToMm(pgonRminHalf[i])
398  << "\tRmax = " << convertCmToMm(pgonRmaxHalf[i]);
399 #endif
400  dd4hep::Volume genlogich(solid.name(), solid, matter);
401  genlogic.placeVolume(genlogich, 1);
402 #ifdef EDM_ML_DEBUG
403  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << genlogich.name() << " number 1 positioned in "
404  << genlogic.name() << " at (0, 0, 0) with no rotation";
405 #endif
406  if (nhalf != 1) {
407  dd4hep::Rotation3D rot = getRotation(rotHalf, rotns, ns);
408  genlogic.placeVolume(genlogich, 2, rot);
409 #ifdef EDM_ML_DEBUG
410  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << genlogich.name() << " number 2 positioned in "
411  << genlogic.name() << " at (0, 0, 0) with " << rot;
412 #endif
413  } //end if (getNhalf...
414 
415  //Construct sector (from -alpha to +alpha)
416  name = idName + "Module";
417  solid = dd4hep::Polyhedra(ns.prepend(name), 1, -alpha, 2 * alpha, pgonZHalf, pgonRminHalf, pgonRmaxHalf);
418  dd4hep::Volume seclogic(solid.name(), solid, matter);
419 #ifdef EDM_ML_DEBUG
420  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Polyhedra made of " << matter.name()
421  << " with 1 sector from " << convertRadToDeg(-alpha) << " to "
422  << convertRadToDeg(alpha) << " and with " << nf << " sections";
423  for (unsigned int i = 0; i < pgonZHalf.size(); i++)
424  edm::LogVerbatim("HCalGeom") << "\t\tZ = " << convertCmToMm(pgonZHalf[i])
425  << "\tRmin = " << convertCmToMm(pgonRminHalf[i])
426  << "\tRmax = " << convertCmToMm(pgonRmaxHalf[i]);
427 #endif
428 
429  for (int ii = 0; ii < nsectortot; ii++) {
430  double phi = ii * 2 * alpha;
431  dd4hep::Rotation3D rotation;
432  if (phi != 0) {
433  rotation = dd4hep::RotationZ(phi);
434 #ifdef EDM_ML_DEBUG
435  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: Creating a new "
436  << "rotation around Z " << convertRadToDeg(phi);
437 #endif
438  } //if phideg!=0
439  genlogich.placeVolume(seclogic, ii + 1, rotation);
440 #ifdef EDM_ML_DEBUG
441  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << seclogic.name() << " number " << ii + 1
442  << " positioned in " << genlogich.name() << " at (0, 0, 0) with " << rotation;
443 #endif
444  }
445 
446  //Construct the things inside the sector
447 #ifdef EDM_ML_DEBUG
448  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: Layers (" << nLayers << ") ...";
449 #endif
450  rin = rinner;
451  for (int i = 0; i < nLayers; i++) {
452  std::string name = idName + layerLabel[i];
453  dd4hep::Material matter = ns.material(layerMat[i]);
454  double width = layerWidth[i];
455  double rout = rin + width;
456 
457  int in = 0, out = 0;
458  for (int j = 0; j < rzones - 1; j++) {
459  if (rin >= rmax[j])
460  in = j + 1;
461  if (rout > rmax[j])
462  out = j + 1;
463  }
464  double zout = zoff[in] + rin * ttheta[in];
465 
467  //vertical walls are allowed in SolidPolyhedra
468  int nsec = 2;
469  std::vector<double> pgonZ, pgonRmin, pgonRmax;
470  // index 0
471  pgonZ.emplace_back(0);
472  pgonRmin.emplace_back(rin);
473  pgonRmax.emplace_back(rout);
474  // index 1
475  pgonZ.emplace_back(zout);
476  pgonRmin.emplace_back(rin);
477  pgonRmax.emplace_back(rout);
478  if (in == out) {
479  if (in <= 3) {
480  //index 2
481  pgonZ.emplace_back(zoff[in] + rout * ttheta[in]);
482  pgonRmin.emplace_back(pgonRmax[1]);
483  pgonRmax.emplace_back(pgonRmax[1]);
484  nsec++;
485  }
486  } else {
487  if (in == 3) {
488  //redo index 1, add index 2
489  pgonZ[1] = (zoff[out] + rmax[out] * ttheta[out]);
490  pgonZ.emplace_back(pgonZ[1]);
491  pgonRmin.emplace_back(pgonRmin[1]);
492  pgonRmax.emplace_back(rmax[in]);
493  //index 3
494  pgonZ.emplace_back(zoff[in] + rmax[in] * ttheta[in]);
495  pgonRmin.emplace_back(pgonRmin[2]);
496  pgonRmax.emplace_back(pgonRmax[2]);
497  nsec += 2;
498  } else {
499  //index 2
500  pgonZ.emplace_back(zoff[in] + rmax[in] * ttheta[in]);
501  pgonRmin.emplace_back(rmax[in]);
502  pgonRmax.emplace_back(pgonRmax[1]);
503  nsec++;
504  if (in == 0) {
505  pgonZ.emplace_back(zoff[out] + rmax[in] * ttheta[out]);
506  pgonRmin.emplace_back(pgonRmin[2]);
507  pgonRmax.emplace_back(pgonRmax[2]);
508  nsec++;
509  }
510  if (in <= 1) {
511  pgonZ.emplace_back(zoff[out] + rout * ttheta[out]);
512  pgonRmin.emplace_back(rout);
513  pgonRmax.emplace_back(rout);
514  nsec++;
515  }
516  }
517  }
518  //Solid & volume
519  dd4hep::Solid solid;
520  double alpha1 = alpha;
521  if (layerGap[i] > 1.e-6) {
522  double rmid = 0.5 * (rin + rout);
523  double width = rmid * tan(alpha) - layerGap[i];
524  alpha1 = atan(width / rmid);
525 #ifdef EDM_ML_DEBUG
526  edm::LogVerbatim("HCalGeom") << "\tAlpha_1 modified from " << convertRadToDeg(alpha) << " to "
527  << convertRadToDeg(alpha1) << " Rmid " << convertCmToMm(rmid) << " Reduced width "
528  << convertCmToMm(width);
529 #endif
530  }
531  solid = dd4hep::Polyhedra(ns.prepend(name), 1, -alpha1, 2 * alpha1, pgonZ, pgonRmin, pgonRmax);
532  dd4hep::Volume glog(solid.name(), solid, matter);
533 #ifdef EDM_ML_DEBUG
534  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " (Layer " << i << ") Polyhedra made of "
535  << matter.name() << " with 1 sector from " << convertRadToDeg(-alpha1) << " to "
536  << convertRadToDeg(alpha1) << " and with " << nsec << " sections";
537  for (unsigned int k = 0; k < pgonZ.size(); k++)
538  edm::LogVerbatim("HCalGeom") << "\t\t" << convertCmToMm(pgonZ[k]) << "\t" << convertCmToMm(pgonRmin[k]) << "\t"
539  << convertCmToMm(pgonRmax[k]);
540 #endif
541 
542  seclogic.placeVolume(glog, layerId[i]);
543 #ifdef EDM_ML_DEBUG
544  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << glog.name() << " number " << layerId[i]
545  << " positioned in " << seclogic.name() << " at (0,0,0) with no rotation";
546 #endif
547  constructInsideLayers(glog,
548  layerLabel[i],
549  layerId[i],
550  layerAbsorb[i],
551  rin,
552  layerD1[i],
553  alpha1,
554  layerD2[i],
555  layerAlpha[i],
556  layerT1[i],
557  layerT2[i],
558  ns);
559  rin = rout;
560  }
561  }

References zMuMuMuonUserData::alpha, writedatasetfile::args, geant_units::operators::convertCmToMm(), angle_units::operators::convertRadToDeg(), MillePedeFileConverter_cfg::e, mps_fire::i, versionedElectronIDProducer_cfi::idName, cuy::ii, recoMuon::in, dqmiolumiharvest::j, dqmdumpme::k, cms::DDNamespace::material(), g4SimHits_cfi::Material, Skims_PA_cff::name, cms::DDNamespace::name(), MuonTCMETValueMapProducer_cff::nLayers, MillePedeFileConverter_cfg::out, HGCalGeometryMode::Polyhedra, cms::DDNamespace::prepend(), makeMuonMisalignmentScenario::rot, idealTransformation::rotation, AlCaHLTBitMon_QueryRunRegistry::string, funct::tan(), theta(), cms::DDNamespace::volume(), ApeEstimator_cff::width, and SiStripMonitorCluster_cfi::zmax.

Member Function Documentation

◆ constructInsideDetectors()

void HcalBarrelAlgo::constructInsideDetectors ( dd4hep::Volume &  detector,
const std::string &  name,
int  id,
double  dx,
double  dy,
double  dz,
int  type,
cms::DDNamespace &  ns 
)
inline

Definition at line 888 of file DDHCalBarrelAlgo.cc.

895  {
896 #ifdef EDM_ML_DEBUG
897  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: \t\tInside detector " << id << "...";
898 #endif
899 
900  dd4hep::Material plmatter = ns.material(detMatPl);
901  dd4hep::Material scmatter = ns.material(detMatSc);
902  std::string plname = DDSplit(detector.name()).first + "Plastic_";
903  std::string scname = idName + "Scintillator" + name;
904 
905  id--;
906  dd4hep::Solid solid;
907  dd4hep::Volume glog;
908  double wid, y = 0;
909  double dx1, dx2, shiftX;
910 
911  if (type == 1) {
912  wid = 0.5 * detWidth1[id];
913  dx1 = 0.5 * detT11[id];
914  dx2 = 0.5 * detT21[id];
915  shiftX = detdP1[id];
916  if (detPosY[id] > 0)
917  y = -dy + wid;
918  } else {
919  wid = 0.5 * detWidth2[id];
920  dx1 = 0.5 * detT12[id];
921  dx2 = 0.5 * detT22[id];
922  shiftX = detdP2[id];
923  }
924 
925  solid = dd4hep::Box(ns.prepend(plname + "1"), dx1, wid, dz);
926  glog = dd4hep::Volume(solid.name(), solid, plmatter);
927 #ifdef EDM_ML_DEBUG
928  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Box made of " << plmatter.name()
929  << " of dimensions " << convertCmToMm(dx1) << ", " << convertCmToMm(wid) << ", "
930  << convertCmToMm(dz);
931 #endif
932 
933  double x = shiftX + dx1 - dx;
934  detector.placeVolume(glog, 1, dd4hep::Position(x, y, 0));
935 #ifdef EDM_ML_DEBUG
936  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << glog.name() << " Number 1 positioned in " << detector.name()
937  << " at (" << convertCmToMm(x) << "," << convertCmToMm(y) << ",0) with no rotation";
938 #endif
939  solid = dd4hep::Box(ns.prepend(scname), 0.5 * detTsc[id], wid, dz);
940  glog = dd4hep::Volume(solid.name(), solid, scmatter);
941 #ifdef EDM_ML_DEBUG
942  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Box made of " << scmatter.name()
943  << " of dimensions " << convertCmToMm(0.5 * detTsc[id]) << ", " << convertCmToMm(wid)
944  << ", " << convertCmToMm(dz);
945 #endif
946 
947  x += dx1 + 0.5 * detTsc[id];
948  int copyNo = id * 10 + detType[id];
949  detector.placeVolume(glog, copyNo, dd4hep::Position(x, y, 0));
950 #ifdef EDM_ML_DEBUG
951  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << glog.name() << " Number " << copyNo << " positioned in "
952  << detector.name() << " at (" << convertCmToMm(x) << "," << convertCmToMm(y)
953  << ",0) with no rotation";
954 #endif
955  solid = dd4hep::Box(ns.prepend(plname + "2"), dx2, wid, dz);
956  glog = dd4hep::Volume(solid.name(), solid, plmatter);
957 #ifdef EDM_ML_DEBUG
958  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Box made of " << plmatter.name()
959  << " of dimensions " << convertCmToMm(dx2) << ", " << convertCmToMm(wid) << ", "
960  << convertCmToMm(dz);
961 #endif
962 
963  x += 0.5 * detTsc[id] + dx2;
964  detector.placeVolume(glog, 1, dd4hep::Position(x, y, 0));
965 #ifdef EDM_ML_DEBUG
966  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << glog.name() << " Number 1 positioned in " << detector.name()
967  << " at (" << convertCmToMm(x) << "," << convertCmToMm(y) << ",0) with no rotation";
968 #endif
969  }

References geant_units::operators::convertCmToMm(), DDSplit(), hgcalTestNeighbor_cfi::detector, PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, dqmdumpme::first, triggerObjects_cff::id, versionedElectronIDProducer_cfi::idName, cms::DDNamespace::material(), g4SimHits_cfi::Material, Skims_PA_cff::name, PixelTestBeamValidation_cfi::Position, cms::DDNamespace::prepend(), and AlCaHLTBitMon_QueryRunRegistry::string.

◆ constructInsideLayers()

void HcalBarrelAlgo::constructInsideLayers ( dd4hep::Volume &  laylog,
const std::string &  nm,
int  id,
int  nAbs,
double  rin,
double  d1,
double  alpha1,
double  d2,
double  alpha2,
double  t1,
double  t2,
cms::DDNamespace &  ns 
)
inline

Definition at line 563 of file DDHCalBarrelAlgo.cc.

574  {
575 #ifdef EDM_ML_DEBUG
576  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: \t\tInside layer " << id << "...";
577 #endif
578 
580  //Pointers to the Rotation Matrices and to the Materials
581  dd4hep::Rotation3D rot = getRotation(detRot, rotns, ns);
582 
583  std::string nam0 = nm + "In";
584  std::string name = idName + nam0;
585  dd4hep::Material matter = ns.material(detMat);
586 
587  dd4hep::Solid solid;
588  dd4hep::Volume glog, mother;
589  double rsi, dx, dy, dz, x, y;
590  int i, in;
591  //Two lower volumes
592  if (alpha1 > 0) {
593  rsi = rin + d1;
594  in = 0;
595  for (i = 0; i < rzones - 1; i++) {
596  if (rsi >= rmax[i])
597  in = i + 1;
598  }
599  dx = 0.5 * t1;
600  dy = 0.5 * rsi * (tan(alpha1) - tan(alpha2));
601  dz = 0.5 * (zoff[in] + rsi * ttheta[in]);
602  x = rsi + dx;
603  y = 0.5 * rsi * (tan(alpha1) + tan(alpha2));
604  dd4hep::Position r11(x, y, dz);
605  dd4hep::Position r12(x, -y, dz);
606 
607  solid = dd4hep::Box(ns.prepend(name + "1"), dx, dy, dz);
608 #ifdef EDM_ML_DEBUG
609  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Box made of " << matter.name()
610  << " of dimensions " << convertCmToMm(dx) << ", " << convertCmToMm(dy) << ", "
611  << convertCmToMm(dz);
612 #endif
613  glog = dd4hep::Volume(solid.name(), solid, matter);
614 
615  if (nAbs != 0) {
616  mother = constructSideLayer(laylog, name, nAbs, rin, alpha1, ns);
617  } else {
618  mother = laylog;
619  }
620  mother.placeVolume(glog, idOffset + 1, r11);
621  mother.placeVolume(glog, idOffset + 2, dd4hep::Transform3D(rot, r12));
622 #ifdef EDM_ML_DEBUG
623  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << glog.name() << " Number " << idOffset + 1
624  << " positioned in " << mother.name() << " at (" << convertCmToMm(x) << ","
625  << convertCmToMm(y) << "," << convertCmToMm(dz) << ") with no rotation\n"
626  << "DDHCalBarrelAlgo: " << glog.name() << " Number " << idOffset + 2
627  << " positioned in " << mother.name() << " at (" << convertCmToMm(x) << ","
628  << -convertCmToMm(y) << "," << convertCmToMm(dz) << ") with " << rot;
629 #endif
630  //Constructin the plastics and scintillators inside
631  constructInsideDetectors(glog, nam0 + "1", id, dx, dy, dz, 1, ns);
632  }
633 
634  //Upper volume
635  rsi = rin + d2;
636  in = 0;
637  for (i = 0; i < rzones - 1; i++) {
638  if (rsi >= rmax[i])
639  in = i + 1;
640  }
641  dx = 0.5 * t2;
642  dy = 0.5 * rsi * tan(alpha2);
643  dz = 0.5 * (zoff[in] + rsi * ttheta[in]);
644  x = rsi + dx;
645  dd4hep::Position r21(x, dy, dz);
646  dd4hep::Position r22(x, -dy, dz);
647 
648  solid = dd4hep::Box(ns.prepend(name + "2"), dx, dy, dz);
649 #ifdef EDM_ML_DEBUG
650  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Box made of " << matter.name()
651  << " of dimensions " << convertCmToMm(dx) << ", " << convertCmToMm(dy) << ", "
652  << convertCmToMm(dz);
653 #endif
654  glog = dd4hep::Volume(solid.name(), solid, matter);
655 
656  if (nAbs < 0) {
657  mother = constructMidLayer(laylog, name, rin, alpha1, ns);
658  } else {
659  mother = laylog;
660  }
661  mother.placeVolume(glog, idOffset + 3, r21);
662  mother.placeVolume(glog, idOffset + 4, dd4hep::Transform3D(rot, r22));
663 #ifdef EDM_ML_DEBUG
664  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << glog.name() << " Number " << idOffset + 3
665  << " positioned in " << mother.name() << " at (" << convertCmToMm(x) << ","
666  << convertCmToMm(dy) << "," << convertCmToMm(dz)
667  << ") with no rotation\nDDHCalBarrelAlgo: " << glog.name() << " Number "
668  << idOffset + 4 << " positioned in " << mother.name() << " at (" << convertCmToMm(x)
669  << "," << -convertCmToMm(dy) << "," << convertCmToMm(dz) << ") with " << rot;
670 #endif
671  //Constructin the plastics and scintillators inside
672  constructInsideDetectors(glog, nam0 + "2", id, dx, dy, dz, 2, ns);
673  }

References geant_units::operators::convertCmToMm(), d1, PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, mps_fire::i, versionedElectronIDProducer_cfi::idName, recoMuon::in, cms::DDNamespace::material(), g4SimHits_cfi::Material, Skims_PA_cff::name, PixelTestBeamValidation_cfi::Position, cms::DDNamespace::prepend(), makeMuonMisalignmentScenario::rot, AlCaHLTBitMon_QueryRunRegistry::string, RandomServiceHelper::t1, RandomServiceHelper::t2, and funct::tan().

◆ constructMidLayer()

dd4hep::Volume HcalBarrelAlgo::constructMidLayer ( dd4hep::Volume  laylog,
const std::string &  nm,
double  rin,
double  alpha,
cms::DDNamespace &  ns 
)
inline

Definition at line 749 of file DDHCalBarrelAlgo.cc.

750  {
751  dd4hep::Solid solid;
752  dd4hep::Volume log, glog;
753  std::string name = nm + "Mid";
754  for (int k = 0; k < nAbsorber; k++) {
755  std::string namek = name + absorbName[k];
756  double rsi = rin + absorbD[k];
757  int in = 0;
758  for (int i = 0; i < rzones - 1; i++) {
759  if (rsi >= rmax[i])
760  in = i + 1;
761  }
762  std::vector<double> pgonZ, pgonRmin, pgonRmax;
763  // index 0
764  pgonZ.emplace_back(0.0);
765  pgonRmin.emplace_back(rsi);
766  pgonRmax.emplace_back(rsi + absorbT[k]);
767  // index 1
768  pgonZ.emplace_back(zoff[in] + rsi * ttheta[in]);
769  pgonRmin.emplace_back(rsi);
770  pgonRmax.emplace_back(pgonRmax[0]);
771  // index 2
772  pgonZ.emplace_back(zoff[in] + pgonRmax[0] * ttheta[in]);
773  pgonRmin.emplace_back(pgonRmax[1]);
774  pgonRmax.emplace_back(pgonRmax[1]);
775  solid = dd4hep::Polyhedra(ns.prepend(namek), 1, -alpha, 2 * alpha, pgonZ, pgonRmin, pgonRmax);
776  dd4hep::Material matter = ns.material(absorbMat[k]);
777  log = dd4hep::Volume(solid.name(), solid, matter);
778 #ifdef EDM_ML_DEBUG
779  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Polyhedra made of " << matter.name()
780  << " with 1 sector from " << convertRadToDeg(-alpha) << " to "
781  << convertRadToDeg(alpha) << " and with " << pgonZ.size() << " sections";
782  for (unsigned int ii = 0; ii < pgonZ.size(); ii++)
783  edm::LogVerbatim("HCalGeom") << "\t\tZ = " << convertCmToMm(pgonZ[ii])
784  << "\tRmin = " << convertCmToMm(pgonRmin[ii])
785  << "\tRmax = " << convertCmToMm(pgonRmax[ii]);
786 #endif
787 
788  laylog.placeVolume(log, 1);
789 #ifdef EDM_ML_DEBUG
790  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << log.name() << " Number 1 positioned in " << laylog.name()
791  << " at (0,0,0) with no rotation";
792 #endif
793  if (k == 0) {
794  double rmin = pgonRmin[0];
795  double rmax = pgonRmax[0];
796  dd4hep::Volume mother = log;
797  for (int i = 0; i < 1; i++) {
798  double alpha1 = atan(midW[i] / rmin);
799  std::string namek = name + midName[i];
800  solid = dd4hep::Polyhedra(ns.prepend(namek), 1, -alpha1, 2 * alpha1, pgonZ, pgonRmin, pgonRmax);
801  dd4hep::Material matter1 = ns.material(midMat[i]);
802  log = dd4hep::Volume(solid.name(), solid, matter1);
803 #ifdef EDM_ML_DEBUG
804  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Polyhedra made of "
805  << matter1.name() << " with 1 sector from " << convertRadToDeg(-alpha1) << " to "
806  << convertRadToDeg(alpha1) << " and with " << pgonZ.size() << " sections";
807  for (unsigned int ii = 0; ii < pgonZ.size(); ii++)
808  edm::LogVerbatim("HCalGeom") << "\t\tZ = " << convertCmToMm(pgonZ[ii])
809  << "\tRmin = " << convertCmToMm(pgonRmin[ii])
810  << "\tRmax = " << convertCmToMm(pgonRmax[ii]);
811 #endif
812 
813  mother.placeVolume(log, 1);
814 #ifdef EDM_ML_DEBUG
815  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << log.name() << " Number 1 positioned in "
816  << mother.name() << " at (0,0,0) with no rotation";
817 #endif
818  mother = log;
819  }
820 
821  // Now the layer with detectors
822  double rmid = rmin + middleD;
823  pgonRmin[0] = rmid;
824  pgonRmax[0] = rmax;
825  pgonRmin[1] = rmid;
826  pgonRmax[1] = rmax;
827  pgonZ[1] = zoff[in] + rmid * ttheta[in];
828  pgonRmin[2] = rmax;
829  pgonRmax[2] = rmax;
830  pgonZ[2] = zoff[in] + rmax * ttheta[in];
831  double alpha1 = atan(middleW / rmin);
832  solid = dd4hep::Polyhedra(ns.prepend(name), 1, -alpha1, 2 * alpha1, pgonZ, pgonRmin, pgonRmax);
833  dd4hep::Material matter1 = ns.material(middleMat);
834  glog = dd4hep::Volume(solid.name(), solid, matter1);
835 #ifdef EDM_ML_DEBUG
836  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Polyhedra made of " << matter1.name()
837  << " with 1 sector from " << convertRadToDeg(-alpha1) << " to "
838  << convertRadToDeg(alpha1) << " and with " << pgonZ.size() << " sections";
839  for (unsigned int ii = 0; ii < pgonZ.size(); ii++)
840  edm::LogVerbatim("HCalGeom") << "\t\tZ = " << convertCmToMm(pgonZ[ii])
841  << "\tRmin = " << convertCmToMm(pgonRmin[ii])
842  << "\tRmax = " << convertCmToMm(pgonRmax[ii]);
843 #endif
844 
845  mother.placeVolume(glog, 1);
846 #ifdef EDM_ML_DEBUG
847  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << glog.name() << " Number 1 positioned in "
848  << mother.name() << " at (0,0,0) with no rotation";
849 #endif
850  // Now the remaining absorber layers
851  for (int i = 1; i < nMidAbs; i++) {
852  namek = name + midName[i];
853  rmid = rmin + midT[i];
854  pgonRmin[0] = rmin;
855  pgonRmax[0] = rmid;
856  pgonRmin[1] = rmin;
857  pgonRmax[1] = rmid;
858  pgonZ[1] = zoff[in] + rmin * ttheta[in];
859  pgonRmin[2] = rmid;
860  pgonRmax[2] = rmid;
861  pgonZ[2] = zoff[in] + rmid * ttheta[in];
862  alpha1 = atan(midW[i] / rmin);
863  solid = dd4hep::Polyhedra(ns.prepend(namek), 1, -alpha1, 2 * alpha1, pgonZ, pgonRmin, pgonRmax);
864  dd4hep::Material matter2 = ns.material(midMat[i]);
865  log = dd4hep::Volume(solid.name(), solid, matter2);
866 #ifdef EDM_ML_DEBUG
867  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Polyhedra made of "
868  << matter2.name() << " with 1 sector from " << convertRadToDeg(-alpha1) << " to "
869  << convertRadToDeg(alpha1) << " and with " << pgonZ.size() << " sections";
870  for (unsigned int ii = 0; ii < pgonZ.size(); ii++)
871  edm::LogVerbatim("HCalGeom") << "\t\tZ = " << convertCmToMm(pgonZ[ii])
872  << "\tRmin = " << convertCmToMm(pgonRmin[ii])
873  << "\tRmax = " << convertCmToMm(pgonRmax[ii]);
874 #endif
875 
876  mother.placeVolume(log, i);
877 #ifdef EDM_ML_DEBUG
878  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << log.name() << " Number " << i << " positioned in "
879  << mother.name() << " at (0,0,0) with no rotation";
880 #endif
881  mother = log;
882  }
883  }
884  }
885  return glog;
886  }

References zMuMuMuonUserData::alpha, geant_units::operators::convertCmToMm(), angle_units::operators::convertRadToDeg(), mps_fire::i, cuy::ii, recoMuon::in, dqmdumpme::k, dqm-mbProfile::log, cms::DDNamespace::material(), g4SimHits_cfi::Material, Skims_PA_cff::name, HGCalGeometryMode::Polyhedra, cms::DDNamespace::prepend(), and AlCaHLTBitMon_QueryRunRegistry::string.

◆ constructSideLayer()

dd4hep::Volume HcalBarrelAlgo::constructSideLayer ( dd4hep::Volume &  laylog,
const std::string &  nm,
int  nAbs,
double  rin,
double  alpha,
cms::DDNamespace &  ns 
)
inline

Definition at line 675 of file DDHCalBarrelAlgo.cc.

676  {
677  //Extra absorber layer
678  int k = abs(nAbs) - 1;
679  std::string namek = nm + "Side";
680  double rsi = rin + sideD[k];
681  int in = 0;
682  for (int i = 0; i < rzones - 1; i++) {
683  if (rsi >= rmax[i])
684  in = i + 1;
685  }
686  std::vector<double> pgonZ, pgonRmin, pgonRmax;
687  // index 0
688  pgonZ.emplace_back(0.0);
689  pgonRmin.emplace_back(rsi);
690  pgonRmax.emplace_back(rsi + sideT[k]);
691  // index 1
692  pgonZ.emplace_back(zoff[in] + rsi * ttheta[in]);
693  pgonRmin.emplace_back(rsi);
694  pgonRmax.emplace_back(pgonRmax[0]);
695  // index 2
696  pgonZ.emplace_back(zoff[in] + pgonRmax[0] * ttheta[in]);
697  pgonRmin.emplace_back(pgonRmax[1]);
698  pgonRmax.emplace_back(pgonRmax[1]);
699  dd4hep::Solid solid = dd4hep::Polyhedra(ns.prepend(namek), 1, -alpha, 2 * alpha, pgonZ, pgonRmin, pgonRmax);
700  dd4hep::Material matter = ns.material(sideMat[k]);
701  dd4hep::Volume glog(solid.name(), solid, matter);
702 #ifdef EDM_ML_DEBUG
703  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Polyhedra made of " << sideMat[k]
704  << " with 1 sector from " << convertRadToDeg(-alpha) << " to "
705  << convertRadToDeg(alpha) << " and with " << pgonZ.size() << " sections";
706  for (unsigned int ii = 0; ii < pgonZ.size(); ii++)
707  edm::LogVerbatim("HCalGeom") << "\t\tZ = " << convertCmToMm(pgonZ[ii])
708  << "\tRmin = " << convertCmToMm(pgonRmin[ii])
709  << "\tRmax = " << convertCmToMm(pgonRmax[ii]);
710 #endif
711 
712  laylog.placeVolume(glog, 1);
713 #ifdef EDM_ML_DEBUG
714  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << glog.name() << " Number 1 positioned in " << laylog.name()
715  << " at (0,0,0) with no rotation";
716 #endif
717  if (nAbs < 0) {
718  dd4hep::Volume mother = glog;
719  double rmid = pgonRmax[0];
720  for (int i = 0; i < nSideAbs; i++) {
721  double alpha1 = atan(sideAbsW[i] / rmid);
722  if (alpha1 > 0) {
723  std::string name = namek + sideAbsName[i];
724  solid = dd4hep::Polyhedra(ns.prepend(name), 1, -alpha1, 2 * alpha1, pgonZ, pgonRmin, pgonRmax);
725  dd4hep::Material matter = ns.material(sideAbsMat[i]);
726  dd4hep::Volume log(solid.name(), solid, matter);
727 #ifdef EDM_ML_DEBUG
728  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Polyhedra made of " << sideAbsMat[i]
729  << " with 1 sector from " << convertRadToDeg(-alpha1) << " to "
730  << convertRadToDeg(alpha1) << " and with " << pgonZ.size() << " sections";
731  for (unsigned int ii = 0; ii < pgonZ.size(); ii++)
732  edm::LogVerbatim("HCalGeom") << "\t\tZ = " << convertCmToMm(pgonZ[ii])
733  << "\tRmin = " << convertCmToMm(pgonRmin[ii])
734  << "\tRmax = " << convertCmToMm(pgonRmax[ii]);
735 #endif
736 
737  mother.placeVolume(log, 1);
738 #ifdef EDM_ML_DEBUG
739  edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << log.name() << " Number 1 positioned in "
740  << mother.name() << " at (0,0,0) with no rotation";
741 #endif
742  mother = log;
743  }
744  }
745  }
746  return glog;
747  }

References funct::abs(), zMuMuMuonUserData::alpha, geant_units::operators::convertCmToMm(), angle_units::operators::convertRadToDeg(), mps_fire::i, cuy::ii, recoMuon::in, dqmdumpme::k, dqm-mbProfile::log, cms::DDNamespace::material(), g4SimHits_cfi::Material, Skims_PA_cff::name, HGCalGeometryMode::Polyhedra, cms::DDNamespace::prepend(), and AlCaHLTBitMon_QueryRunRegistry::string.

◆ getRotation()

dd4hep::Rotation3D HcalBarrelAlgo::getRotation ( std::string &  rotation,
std::string &  rotns,
cms::DDNamespace &  ns 
)
inline

Definition at line 971 of file DDHCalBarrelAlgo.cc.

971  {
972  std::string rot = (strchr(rotation.c_str(), NAMESPACE_SEP) == nullptr) ? (rotns + ":" + rotation) : rotation;
973 #ifdef EDM_ML_DEBUG
974  edm::LogVerbatim("HCalGeom") << "getRotation: " << rotation << ":" << rot << ":" << ns.rotation(rot);
975 #endif
976  return ns.rotation(rot);
977  }

References NAMESPACE_SEP, makeMuonMisalignmentScenario::rot, idealTransformation::rotation, cms::DDNamespace::rotation(), and AlCaHLTBitMon_QueryRunRegistry::string.

Member Data Documentation

◆ absorbD

std::vector<double> HcalBarrelAlgo::absorbD

Definition at line 89 of file DDHCalBarrelAlgo.cc.

◆ absorbMat

std::vector<std::string> HcalBarrelAlgo::absorbMat

Definition at line 88 of file DDHCalBarrelAlgo.cc.

◆ absorbName

std::vector<std::string> HcalBarrelAlgo::absorbName

Definition at line 87 of file DDHCalBarrelAlgo.cc.

◆ absorbT

std::vector<double> HcalBarrelAlgo::absorbT

Definition at line 90 of file DDHCalBarrelAlgo.cc.

◆ detdP1

std::vector<double> HcalBarrelAlgo::detdP1

Definition at line 125 of file DDHCalBarrelAlgo.cc.

◆ detdP2

std::vector<double> HcalBarrelAlgo::detdP2

Definition at line 126 of file DDHCalBarrelAlgo.cc.

◆ detMat

std::string HcalBarrelAlgo::detMat

Definition at line 120 of file DDHCalBarrelAlgo.cc.

◆ detMatPl

std::string HcalBarrelAlgo::detMatPl

Definition at line 122 of file DDHCalBarrelAlgo.cc.

◆ detMatSc

std::string HcalBarrelAlgo::detMatSc

Definition at line 123 of file DDHCalBarrelAlgo.cc.

◆ detPosY

std::vector<int> HcalBarrelAlgo::detPosY

Definition at line 134 of file DDHCalBarrelAlgo.cc.

◆ detRot

std::string HcalBarrelAlgo::detRot

Definition at line 121 of file DDHCalBarrelAlgo.cc.

◆ detT11

std::vector<double> HcalBarrelAlgo::detT11

Definition at line 127 of file DDHCalBarrelAlgo.cc.

◆ detT12

std::vector<double> HcalBarrelAlgo::detT12

Definition at line 128 of file DDHCalBarrelAlgo.cc.

◆ detT21

std::vector<double> HcalBarrelAlgo::detT21

Definition at line 130 of file DDHCalBarrelAlgo.cc.

◆ detT22

std::vector<double> HcalBarrelAlgo::detT22

Definition at line 131 of file DDHCalBarrelAlgo.cc.

◆ detTsc

std::vector<double> HcalBarrelAlgo::detTsc

Definition at line 129 of file DDHCalBarrelAlgo.cc.

◆ detType

std::vector<int> HcalBarrelAlgo::detType

Definition at line 124 of file DDHCalBarrelAlgo.cc.

◆ detWidth1

std::vector<double> HcalBarrelAlgo::detWidth1

Definition at line 132 of file DDHCalBarrelAlgo.cc.

◆ detWidth2

std::vector<double> HcalBarrelAlgo::detWidth2

Definition at line 133 of file DDHCalBarrelAlgo.cc.

◆ genMaterial

std::string HcalBarrelAlgo::genMaterial

Definition at line 34 of file DDHCalBarrelAlgo.cc.

◆ idName

std::string HcalBarrelAlgo::idName

Definition at line 136 of file DDHCalBarrelAlgo.cc.

◆ idNameSpace

std::string HcalBarrelAlgo::idNameSpace

Definition at line 137 of file DDHCalBarrelAlgo.cc.

◆ idOffset

int HcalBarrelAlgo::idOffset

Definition at line 138 of file DDHCalBarrelAlgo.cc.

◆ layerAbsorb

std::vector<int> HcalBarrelAlgo::layerAbsorb

Definition at line 83 of file DDHCalBarrelAlgo.cc.

◆ layerAlpha

std::vector<double> HcalBarrelAlgo::layerAlpha

Definition at line 80 of file DDHCalBarrelAlgo.cc.

◆ layerD1

std::vector<double> HcalBarrelAlgo::layerD1

Definition at line 78 of file DDHCalBarrelAlgo.cc.

◆ layerD2

std::vector<double> HcalBarrelAlgo::layerD2

Definition at line 79 of file DDHCalBarrelAlgo.cc.

◆ layerGap

std::vector<double> HcalBarrelAlgo::layerGap

Definition at line 84 of file DDHCalBarrelAlgo.cc.

◆ layerId

std::vector<int> HcalBarrelAlgo::layerId

Definition at line 74 of file DDHCalBarrelAlgo.cc.

◆ layerLabel

std::vector<std::string> HcalBarrelAlgo::layerLabel

Definition at line 75 of file DDHCalBarrelAlgo.cc.

◆ layerMat

std::vector<std::string> HcalBarrelAlgo::layerMat

Definition at line 76 of file DDHCalBarrelAlgo.cc.

◆ layerT1

std::vector<double> HcalBarrelAlgo::layerT1

Definition at line 81 of file DDHCalBarrelAlgo.cc.

◆ layerT2

std::vector<double> HcalBarrelAlgo::layerT2

Definition at line 82 of file DDHCalBarrelAlgo.cc.

◆ layerWidth

std::vector<double> HcalBarrelAlgo::layerWidth

Definition at line 77 of file DDHCalBarrelAlgo.cc.

◆ middleD

double HcalBarrelAlgo::middleD

Definition at line 92 of file DDHCalBarrelAlgo.cc.

◆ middleMat

std::string HcalBarrelAlgo::middleMat

Definition at line 91 of file DDHCalBarrelAlgo.cc.

◆ middleW

double HcalBarrelAlgo::middleW

Definition at line 93 of file DDHCalBarrelAlgo.cc.

◆ midMat

std::vector<std::string> HcalBarrelAlgo::midMat

Definition at line 96 of file DDHCalBarrelAlgo.cc.

◆ midName

std::vector<std::string> HcalBarrelAlgo::midName

Definition at line 95 of file DDHCalBarrelAlgo.cc.

◆ midT

std::vector<double> HcalBarrelAlgo::midT

Definition at line 98 of file DDHCalBarrelAlgo.cc.

◆ midW

std::vector<double> HcalBarrelAlgo::midW

Definition at line 97 of file DDHCalBarrelAlgo.cc.

◆ nAbsorber

int HcalBarrelAlgo::nAbsorber

Definition at line 86 of file DDHCalBarrelAlgo.cc.

◆ nhalf

int HcalBarrelAlgo::nhalf

Definition at line 37 of file DDHCalBarrelAlgo.cc.

◆ nLayers

int HcalBarrelAlgo::nLayers

Definition at line 73 of file DDHCalBarrelAlgo.cc.

◆ nMidAbs

int HcalBarrelAlgo::nMidAbs

Definition at line 94 of file DDHCalBarrelAlgo.cc.

◆ nsectors

int HcalBarrelAlgo::nsectors

Definition at line 35 of file DDHCalBarrelAlgo.cc.

◆ nsectortot

int HcalBarrelAlgo::nsectortot

Definition at line 36 of file DDHCalBarrelAlgo.cc.

◆ nSideAbs

int HcalBarrelAlgo::nSideAbs

Definition at line 103 of file DDHCalBarrelAlgo.cc.

◆ rinner

double HcalBarrelAlgo::rinner

Definition at line 38 of file DDHCalBarrelAlgo.cc.

◆ rmax

std::vector<double> HcalBarrelAlgo::rmax

Definition at line 41 of file DDHCalBarrelAlgo.cc.

◆ rotHalf

std::string HcalBarrelAlgo::rotHalf

Definition at line 44 of file DDHCalBarrelAlgo.cc.

◆ rotns

std::string HcalBarrelAlgo::rotns

Definition at line 45 of file DDHCalBarrelAlgo.cc.

◆ router

double HcalBarrelAlgo::router

Definition at line 38 of file DDHCalBarrelAlgo.cc.

◆ rzones

int HcalBarrelAlgo::rzones

Definition at line 39 of file DDHCalBarrelAlgo.cc.

◆ sideAbsMat

std::vector<std::string> HcalBarrelAlgo::sideAbsMat

Definition at line 105 of file DDHCalBarrelAlgo.cc.

◆ sideAbsName

std::vector<std::string> HcalBarrelAlgo::sideAbsName

Definition at line 104 of file DDHCalBarrelAlgo.cc.

◆ sideAbsW

std::vector<double> HcalBarrelAlgo::sideAbsW

Definition at line 106 of file DDHCalBarrelAlgo.cc.

◆ sideD

std::vector<double> HcalBarrelAlgo::sideD

Definition at line 101 of file DDHCalBarrelAlgo.cc.

◆ sideMat

std::vector<std::string> HcalBarrelAlgo::sideMat

Definition at line 100 of file DDHCalBarrelAlgo.cc.

◆ sideT

std::vector<double> HcalBarrelAlgo::sideT

Definition at line 102 of file DDHCalBarrelAlgo.cc.

◆ theta

std::vector<double> HcalBarrelAlgo::theta

Definition at line 40 of file DDHCalBarrelAlgo.cc.

Referenced by Tau.Tau::zImpact().

◆ ttheta

std::vector<double> HcalBarrelAlgo::ttheta

Definition at line 43 of file DDHCalBarrelAlgo.cc.

◆ zoff

std::vector<double> HcalBarrelAlgo::zoff

Definition at line 42 of file DDHCalBarrelAlgo.cc.

HcalBarrelAlgo::detWidth2
std::vector< double > detWidth2
Definition: DDHCalBarrelAlgo.cc:133
writedatasetfile.args
args
Definition: writedatasetfile.py:18
HcalBarrelAlgo::nhalf
int nhalf
Definition: DDHCalBarrelAlgo.cc:37
RandomServiceHelper.t2
t2
Definition: RandomServiceHelper.py:257
DDAxes::y
ApeEstimator_cff.width
width
Definition: ApeEstimator_cff.py:24
HcalBarrelAlgo::idName
std::string idName
Definition: DDHCalBarrelAlgo.cc:136
HcalBarrelAlgo::detType
std::vector< int > detType
Definition: DDHCalBarrelAlgo.cc:124
HcalBarrelAlgo::nMidAbs
int nMidAbs
Definition: DDHCalBarrelAlgo.cc:94
mps_fire.i
i
Definition: mps_fire.py:355
HcalBarrelAlgo::sideMat
std::vector< std::string > sideMat
Definition: DDHCalBarrelAlgo.cc:100
HcalBarrelAlgo::sideAbsMat
std::vector< std::string > sideAbsMat
Definition: DDHCalBarrelAlgo.cc:105
g4SimHits_cfi.Material
Material
Definition: g4SimHits_cfi.py:547
HcalBarrelAlgo::detdP2
std::vector< double > detdP2
Definition: DDHCalBarrelAlgo.cc:126
HcalBarrelAlgo::layerLabel
std::vector< std::string > layerLabel
Definition: DDHCalBarrelAlgo.cc:75
cms::DDNamespace::material
dd4hep::Material material(const std::string &name) const
Definition: DDNamespace.cc:121
HcalBarrelAlgo::layerGap
std::vector< double > layerGap
Definition: DDHCalBarrelAlgo.cc:84
HcalBarrelAlgo::constructInsideLayers
void constructInsideLayers(dd4hep::Volume &laylog, const std::string &nm, int id, int nAbs, double rin, double d1, double alpha1, double d2, double alpha2, double t1, double t2, cms::DDNamespace &ns)
Definition: DDHCalBarrelAlgo.cc:563
HcalBarrelAlgo::detT12
std::vector< double > detT12
Definition: DDHCalBarrelAlgo.cc:128
zMuMuMuonUserData.alpha
alpha
zGenParticlesMatch = cms.InputTag(""),
Definition: zMuMuMuonUserData.py:9
angle_units::operators::convertRadToDeg
constexpr NumType convertRadToDeg(NumType radians)
Definition: angle_units.h:21
cms::DDNamespace
Definition: DDNamespace.h:16
HcalBarrelAlgo::theta
std::vector< double > theta
Definition: DDHCalBarrelAlgo.cc:40
HcalBarrelAlgo::rinner
double rinner
Definition: DDHCalBarrelAlgo.cc:38
HcalBarrelAlgo::layerD1
std::vector< double > layerD1
Definition: DDHCalBarrelAlgo.cc:78
HcalBarrelAlgo::layerD2
std::vector< double > layerD2
Definition: DDHCalBarrelAlgo.cc:79
HcalBarrelAlgo::idOffset
int idOffset
Definition: DDHCalBarrelAlgo.cc:138
DDAxes::x
HcalBarrelAlgo::layerT2
std::vector< double > layerT2
Definition: DDHCalBarrelAlgo.cc:82
HcalBarrelAlgo::ttheta
std::vector< double > ttheta
Definition: DDHCalBarrelAlgo.cc:43
HcalBarrelAlgo::detT11
std::vector< double > detT11
Definition: DDHCalBarrelAlgo.cc:127
HcalBarrelAlgo::middleD
double middleD
Definition: DDHCalBarrelAlgo.cc:92
HcalBarrelAlgo::detMatPl
std::string detMatPl
Definition: DDHCalBarrelAlgo.cc:122
dqmdumpme.first
first
Definition: dqmdumpme.py:55
HcalBarrelAlgo::idNameSpace
std::string idNameSpace
Definition: DDHCalBarrelAlgo.cc:137
HcalBarrelAlgo::midMat
std::vector< std::string > midMat
Definition: DDHCalBarrelAlgo.cc:96
HcalBarrelAlgo::constructMidLayer
dd4hep::Volume constructMidLayer(dd4hep::Volume laylog, const std::string &nm, double rin, double alpha, cms::DDNamespace &ns)
Definition: DDHCalBarrelAlgo.cc:749
HcalBarrelAlgo::constructSideLayer
dd4hep::Volume constructSideLayer(dd4hep::Volume &laylog, const std::string &nm, int nAbs, double rin, double alpha, cms::DDNamespace &ns)
Definition: DDHCalBarrelAlgo.cc:675
HcalBarrelAlgo::constructInsideDetectors
void constructInsideDetectors(dd4hep::Volume &detector, const std::string &name, int id, double dx, double dy, double dz, int type, cms::DDNamespace &ns)
Definition: DDHCalBarrelAlgo.cc:888
HcalBarrelAlgo::nsectortot
int nsectortot
Definition: DDHCalBarrelAlgo.cc:36
RandomServiceHelper.t1
t1
Definition: RandomServiceHelper.py:256
HcalBarrelAlgo::layerAbsorb
std::vector< int > layerAbsorb
Definition: DDHCalBarrelAlgo.cc:83
HcalBarrelAlgo::layerT1
std::vector< double > layerT1
Definition: DDHCalBarrelAlgo.cc:81
SiStripMonitorCluster_cfi.zmax
zmax
Definition: SiStripMonitorCluster_cfi.py:201
HcalBarrelAlgo::detMat
std::string detMat
Definition: DDHCalBarrelAlgo.cc:120
HcalBarrelAlgo::layerWidth
std::vector< double > layerWidth
Definition: DDHCalBarrelAlgo.cc:77
HcalBarrelAlgo::detTsc
std::vector< double > detTsc
Definition: DDHCalBarrelAlgo.cc:129
cms::DDNamespace::prepend
std::string prepend(const std::string &) const
Definition: DDNamespace.cc:66
HcalBarrelAlgo::nsectors
int nsectors
Definition: DDHCalBarrelAlgo.cc:35
HcalBarrelAlgo::layerAlpha
std::vector< double > layerAlpha
Definition: DDHCalBarrelAlgo.cc:80
HcalBarrelAlgo::rotns
std::string rotns
Definition: DDHCalBarrelAlgo.cc:45
PixelTestBeamValidation_cfi.Position
Position
Definition: PixelTestBeamValidation_cfi.py:62
HcalBarrelAlgo::zoff
std::vector< double > zoff
Definition: DDHCalBarrelAlgo.cc:42
HcalBarrelAlgo::midName
std::vector< std::string > midName
Definition: DDHCalBarrelAlgo.cc:95
dqmdumpme.k
k
Definition: dqmdumpme.py:60
cms::DDNamespace::rotation
const dd4hep::Rotation3D & rotation(const std::string &name) const
Definition: DDNamespace.cc:130
HcalBarrelAlgo::rotHalf
std::string rotHalf
Definition: DDHCalBarrelAlgo.cc:44
HcalBarrelAlgo::detdP1
std::vector< double > detdP1
Definition: DDHCalBarrelAlgo.cc:125
HcalBarrelAlgo::genMaterial
std::string genMaterial
Definition: DDHCalBarrelAlgo.cc:34
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
cms::Volume
dd4hep::Volume Volume
Definition: DDFilteredView.h:45
idealTransformation.rotation
dictionary rotation
Definition: idealTransformation.py:1
HcalBarrelAlgo::detT21
std::vector< double > detT21
Definition: DDHCalBarrelAlgo.cc:130
geant_units::operators::convertCmToMm
constexpr NumType convertCmToMm(NumType centimeters)
Definition: GeantUnits.h:68
HcalBarrelAlgo::nSideAbs
int nSideAbs
Definition: DDHCalBarrelAlgo.cc:103
HcalBarrelAlgo::midT
std::vector< double > midT
Definition: DDHCalBarrelAlgo.cc:98
recoMuon::in
Definition: RecoMuonEnumerators.h:6
HcalBarrelAlgo::nAbsorber
int nAbsorber
Definition: DDHCalBarrelAlgo.cc:86
funct::tan
Tan< T >::type tan(const T &t)
Definition: Tan.h:22
HcalBarrelAlgo::rzones
int rzones
Definition: DDHCalBarrelAlgo.cc:39
edm::LogVerbatim
Definition: MessageLogger.h:297
HcalBarrelAlgo::sideAbsName
std::vector< std::string > sideAbsName
Definition: DDHCalBarrelAlgo.cc:104
cms::DDAlgoArguments
Definition: DDAlgoArguments.h:28
PVValHelper::dy
Definition: PVValidationHelpers.h:49
HcalBarrelAlgo::sideD
std::vector< double > sideD
Definition: DDHCalBarrelAlgo.cc:101
HcalBarrelAlgo::nLayers
int nLayers
Definition: DDHCalBarrelAlgo.cc:73
HcalBarrelAlgo::absorbName
std::vector< std::string > absorbName
Definition: DDHCalBarrelAlgo.cc:87
DDAxes::phi
HcalBarrelAlgo::layerId
std::vector< int > layerId
Definition: DDHCalBarrelAlgo.cc:74
type
type
Definition: HCALResponse.h:21
HcalBarrelAlgo::rmax
std::vector< double > rmax
Definition: DDHCalBarrelAlgo.cc:41
HcalBarrelAlgo::router
double router
Definition: DDHCalBarrelAlgo.cc:38
HcalBarrelAlgo::absorbD
std::vector< double > absorbD
Definition: DDHCalBarrelAlgo.cc:89
HcalBarrelAlgo::detMatSc
std::string detMatSc
Definition: DDHCalBarrelAlgo.cc:123
HcalBarrelAlgo::sideAbsW
std::vector< double > sideAbsW
Definition: DDHCalBarrelAlgo.cc:106
HcalBarrelAlgo::getRotation
dd4hep::Rotation3D getRotation(std::string &rotation, std::string &rotns, cms::DDNamespace &ns)
Definition: DDHCalBarrelAlgo.cc:971
PVValHelper::dz
Definition: PVValidationHelpers.h:50
triggerObjects_cff.id
id
Definition: triggerObjects_cff.py:31
HGCalGeometryMode::Polyhedra
Definition: HGCalGeometryMode.h:26
HcalBarrelAlgo::layerMat
std::vector< std::string > layerMat
Definition: DDHCalBarrelAlgo.cc:76
HcalBarrelAlgo::middleW
double middleW
Definition: DDHCalBarrelAlgo.cc:93
HcalBarrelAlgo::middleMat
std::string middleMat
Definition: DDHCalBarrelAlgo.cc:91
makeMuonMisalignmentScenario.rot
rot
Definition: makeMuonMisalignmentScenario.py:322
Skims_PA_cff.name
name
Definition: Skims_PA_cff.py:17
HcalBarrelAlgo::detT22
std::vector< double > detT22
Definition: DDHCalBarrelAlgo.cc:131
HcalBarrelAlgo::sideT
std::vector< double > sideT
Definition: DDHCalBarrelAlgo.cc:102
dqm-mbProfile.log
log
Definition: dqm-mbProfile.py:17
NAMESPACE_SEP
#define NAMESPACE_SEP
Definition: DDNamespace.h:79
hgcalTestNeighbor_cfi.detector
detector
Definition: hgcalTestNeighbor_cfi.py:6
MillePedeFileConverter_cfg.out
out
Definition: MillePedeFileConverter_cfg.py:31
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
HcalBarrelAlgo::detRot
std::string detRot
Definition: DDHCalBarrelAlgo.cc:121
dqmiolumiharvest.j
j
Definition: dqmiolumiharvest.py:66
HcalBarrelAlgo::absorbMat
std::vector< std::string > absorbMat
Definition: DDHCalBarrelAlgo.cc:88
cuy.ii
ii
Definition: cuy.py:590
PVValHelper::dx
Definition: PVValidationHelpers.h:48
d1
static constexpr float d1
Definition: L1EGammaCrystalsEmulatorProducer.cc:85
HcalBarrelAlgo::absorbT
std::vector< double > absorbT
Definition: DDHCalBarrelAlgo.cc:90
HcalBarrelAlgo::detWidth1
std::vector< double > detWidth1
Definition: DDHCalBarrelAlgo.cc:132
DDSplit
std::pair< std::string, std::string > DDSplit(const std::string &n)
split into (name,namespace), separator = ':'
Definition: DDSplit.cc:3
HcalBarrelAlgo::midW
std::vector< double > midW
Definition: DDHCalBarrelAlgo.cc:97
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
HcalBarrelAlgo::detPosY
std::vector< int > detPosY
Definition: DDHCalBarrelAlgo.cc:134
Generated for CMSSW Reference Manual by doxygen 1.8.16