File indexing completed on 2021-02-14 23:30:05
0001
0002
0003
0004
0005
0006
0007 #include <cmath>
0008 #include <algorithm>
0009 #include <map>
0010 #include <string>
0011 #include <vector>
0012
0013 #include "DataFormats/Math/interface/angle_units.h"
0014 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0015 #include "DetectorDescription/Core/interface/DDSplit.h"
0016 #include "DetectorDescription/DDCMS/interface/DDPlugins.h"
0017 #include "DetectorDescription/DDCMS/interface/DDutils.h"
0018 #include "DD4hep/DetFactoryHelper.h"
0019
0020
0021 using namespace angle_units::operators;
0022
0023 struct HcalBarrelAlgo {
0024
0025
0026
0027
0028
0029
0030
0031
0032
0033
0034
0035 std::string genMaterial;
0036 int nsectors;
0037 int nsectortot;
0038 int nhalf;
0039 double rinner, router;
0040 int rzones;
0041 std::vector<double> theta;
0042 std::vector<double> rmax;
0043 std::vector<double> zoff;
0044 std::vector<double> ttheta;
0045 std::string rotHalf;
0046 std::string rotns;
0047
0048
0049
0050
0051
0052
0053
0054
0055
0056
0057
0058
0059
0060
0061
0062
0063
0064
0065
0066
0067
0068
0069
0070
0071
0072
0073
0074 int nLayers;
0075 std::vector<int> layerId;
0076 std::vector<std::string> layerLabel;
0077 std::vector<std::string> layerMat;
0078 std::vector<double> layerWidth;
0079 std::vector<double> layerD1;
0080 std::vector<double> layerD2;
0081 std::vector<double> layerAlpha;
0082 std::vector<double> layerT1;
0083 std::vector<double> layerT2;
0084 std::vector<int> layerAbsorb;
0085 std::vector<double> layerGap;
0086
0087 int nAbsorber;
0088 std::vector<std::string> absorbName;
0089 std::vector<std::string> absorbMat;
0090 std::vector<double> absorbD;
0091 std::vector<double> absorbT;
0092 std::string middleMat;
0093 double middleD;
0094 double middleW;
0095 int nMidAbs;
0096 std::vector<std::string> midName;
0097 std::vector<std::string> midMat;
0098 std::vector<double> midW;
0099 std::vector<double> midT;
0100
0101 std::vector<std::string> sideMat;
0102 std::vector<double> sideD;
0103 std::vector<double> sideT;
0104 int nSideAbs;
0105 std::vector<std::string> sideAbsName;
0106 std::vector<std::string> sideAbsMat;
0107 std::vector<double> sideAbsW;
0108
0109
0110
0111
0112
0113
0114
0115
0116
0117
0118
0119
0120
0121 std::string detMat;
0122 std::string detRot;
0123 std::string detMatPl;
0124 std::string detMatSc;
0125 std::vector<int> detType;
0126 std::vector<double> detdP1;
0127 std::vector<double> detdP2;
0128 std::vector<double> detT11;
0129 std::vector<double> detT12;
0130 std::vector<double> detTsc;
0131 std::vector<double> detT21;
0132 std::vector<double> detT22;
0133 std::vector<double> detWidth1;
0134 std::vector<double> detWidth2;
0135 std::vector<int> detPosY;
0136
0137 std::string idName;
0138 std::string idNameSpace;
0139 int idOffset;
0140
0141 HcalBarrelAlgo() = delete;
0142
0143 HcalBarrelAlgo(cms::DDParsingContext& ctxt, xml_h& e) {
0144 cms::DDNamespace ns(ctxt, e, true);
0145 cms::DDAlgoArguments args(ctxt, e);
0146 #ifdef EDM_ML_DEBUG
0147 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: Creating an instance";
0148 #endif
0149
0150 genMaterial = args.value<std::string>("MaterialName");
0151 nsectors = args.value<int>("NSector");
0152 nsectortot = args.value<int>("NSectorTot");
0153 nhalf = args.value<int>("NHalf");
0154 rinner = args.value<double>("RIn");
0155 router = args.value<double>("ROut");
0156 rzones = args.value<int>("RZones");
0157 rotHalf = args.value<std::string>("RotHalf");
0158 rotns = args.value<std::string>("RotNameSpace");
0159
0160 theta = args.value<std::vector<double> >("Theta");
0161 rmax = args.value<std::vector<double> >("RMax");
0162 zoff = args.value<std::vector<double> >("ZOff");
0163 for (int i = 0; i < rzones; i++) {
0164 ttheta.emplace_back(tan(theta[i]));
0165 }
0166 if (rzones > 3)
0167 rmax[2] = (zoff[3] - zoff[2]) / ttheta[2];
0168
0169 #ifdef EDM_ML_DEBUG
0170 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: General material " << genMaterial << "\tSectors " << nsectors
0171 << ", " << nsectortot << "\tHalves " << nhalf << "\tRotation matrix " << rotns << ":"
0172 << rotHalf << "\n\t\t" << cms::convert2mm(rinner) << "\t" << cms::convert2mm(router)
0173 << "\t" << rzones;
0174 for (int i = 0; i < rzones; i++)
0175 edm::LogVerbatim("HCalGeom") << "\tTheta[" << i << "] = " << theta[i] << "\trmax[" << i
0176 << "] = " << cms::convert2mm(rmax[i]) << "\tzoff[" << i
0177 << "] = " << cms::convert2mm(zoff[i]);
0178 #endif
0179
0180
0181 nLayers = args.value<int>("NLayers");
0182 #ifdef EDM_ML_DEBUG
0183 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: Layer\t" << nLayers;
0184 #endif
0185 layerId = args.value<std::vector<int> >("Id");
0186 layerLabel = args.value<std::vector<std::string> >("LayerLabel");
0187 layerMat = args.value<std::vector<std::string> >("LayerMat");
0188 layerWidth = args.value<std::vector<double> >("LayerWidth");
0189 layerD1 = args.value<std::vector<double> >("D1");
0190 layerD2 = args.value<std::vector<double> >("D2");
0191 layerAlpha = args.value<std::vector<double> >("Alpha2");
0192 layerT1 = args.value<std::vector<double> >("T1");
0193 layerT2 = args.value<std::vector<double> >("T2");
0194 layerAbsorb = args.value<std::vector<int> >("AbsL");
0195 layerGap = args.value<std::vector<double> >("Gap");
0196 #ifdef EDM_ML_DEBUG
0197 for (int i = 0; i < nLayers; i++)
0198 edm::LogVerbatim("HCalGeom") << layerLabel[i] << "\t" << layerId[i] << "\t" << layerMat[i] << "\t"
0199 << cms::convert2mm(layerWidth[i]) << "\t" << cms::convert2mm(layerD1[i]) << "\t"
0200 << cms::convert2mm(layerD2[i]) << "\t" << layerAlpha[i] << "\t"
0201 << cms::convert2mm(layerT1[i]) << "\t" << cms::convert2mm(layerT2[i]) << "\t"
0202 << layerAbsorb[i] << "\t" << cms::convert2mm(layerGap[i]);
0203 #endif
0204
0205
0206
0207 absorbName = args.value<std::vector<std::string> >("AbsorbName");
0208 absorbMat = args.value<std::vector<std::string> >("AbsorbMat");
0209 absorbD = args.value<std::vector<double> >("AbsorbD");
0210 absorbT = args.value<std::vector<double> >("AbsorbT");
0211 nAbsorber = absorbName.size();
0212 #ifdef EDM_ML_DEBUG
0213 for (int i = 0; i < nAbsorber; i++)
0214 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << absorbName[i] << " Material " << absorbMat[i] << " d "
0215 << cms::convert2mm(absorbD[i]) << " t " << cms::convert2mm(absorbT[i]);
0216 #endif
0217 middleMat = args.value<std::string>("MiddleMat");
0218 middleD = args.value<double>("MiddleD");
0219 middleW = args.value<double>("MiddleW");
0220 #ifdef EDM_ML_DEBUG
0221 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: Middle material " << middleMat << " d "
0222 << cms::convert2mm(middleD) << " w " << cms::convert2mm(middleW);
0223 #endif
0224 midName = args.value<std::vector<std::string> >("MidAbsName");
0225 midMat = args.value<std::vector<std::string> >("MidAbsMat");
0226 midW = args.value<std::vector<double> >("MidAbsW");
0227 midT = args.value<std::vector<double> >("MidAbsT");
0228 nMidAbs = midName.size();
0229 #ifdef EDM_ML_DEBUG
0230 for (int i = 0; i < nMidAbs; i++)
0231 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << midName[i] << " Material " << midMat[i] << " W "
0232 << cms::convert2mm(midW[i]) << " T " << cms::convert2mm(midT[i]);
0233 #endif
0234
0235
0236 sideMat = args.value<std::vector<std::string> >("SideMat");
0237 sideD = args.value<std::vector<double> >("SideD");
0238 sideT = args.value<std::vector<double> >("SideT");
0239 #ifdef EDM_ML_DEBUG
0240 for (unsigned int i = 0; i < sideMat.size(); i++)
0241 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: Side material " << sideMat[i] << " d "
0242 << cms::convert2mm(sideD[i]) << " t " << cms::convert2mm(sideT[i]);
0243 #endif
0244 sideAbsName = args.value<std::vector<std::string> >("SideAbsName");
0245 sideAbsMat = args.value<std::vector<std::string> >("SideAbsMat");
0246 sideAbsW = args.value<std::vector<double> >("SideAbsW");
0247 nSideAbs = sideAbsName.size();
0248 #ifdef EDM_ML_DEBUG
0249 for (int i = 0; i < nSideAbs; i++)
0250 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << sideAbsName[i] << " Material " << sideAbsMat[i] << " W "
0251 << cms::convert2mm(sideAbsW[i]);
0252 #endif
0253
0254
0255
0256
0257 detMat = args.value<std::string>("DetMat");
0258 detRot = args.value<std::string>("DetRot");
0259 detMatPl = args.value<std::string>("DetMatPl");
0260 detMatSc = args.value<std::string>("DetMatSc");
0261 #ifdef EDM_ML_DEBUG
0262 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: Detector (" << nLayers << ") Rotation matrix " << rotns << ":"
0263 << detRot << "\n\t\t" << detMat << "\t" << detMatPl << "\t" << detMatSc;
0264 #endif
0265 detType = args.value<std::vector<int> >("DetType");
0266 detdP1 = args.value<std::vector<double> >("DetdP1");
0267 detdP2 = args.value<std::vector<double> >("DetdP2");
0268 detT11 = args.value<std::vector<double> >("DetT11");
0269 detT12 = args.value<std::vector<double> >("DetT12");
0270 detTsc = args.value<std::vector<double> >("DetTsc");
0271 detT21 = args.value<std::vector<double> >("DetT21");
0272 detT22 = args.value<std::vector<double> >("DetT22");
0273 detWidth1 = args.value<std::vector<double> >("DetWidth1");
0274 detWidth2 = args.value<std::vector<double> >("DetWidth2");
0275 detPosY = args.value<std::vector<int> >("DetPosY");
0276 #ifdef EDM_ML_DEBUG
0277 for (int i = 0; i < nLayers; i++)
0278 edm::LogVerbatim("HCalGeom") << i + 1 << "\t" << detType[i] << "\t" << cms::convert2mm(detdP1[i]) << ", "
0279 << cms::convert2mm(detdP2[i]) << "\t" << cms::convert2mm(detT11[i]) << ", "
0280 << cms::convert2mm(detT12[i]) << "\t" << cms::convert2mm(detTsc[i]) << "\t"
0281 << cms::convert2mm(detT21[i]) << ", " << cms::convert2mm(detT22[i]) << "\t"
0282 << cms::convert2mm(detWidth1[i]) << "\t" << cms::convert2mm(detWidth2[i]) << "\t"
0283 << detPosY[i];
0284 #endif
0285
0286
0287 idName = args.value<std::string>("MotherName");
0288 idNameSpace = ns.name();
0289 idOffset = args.value<int>("IdOffset");
0290 #ifdef EDM_ML_DEBUG
0291 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: Parent " << args.parentName() << " idName " << idName
0292 << " NameSpace " << idNameSpace << " Offset " << idOffset;
0293 edm::LogVerbatim("HCalGeom") << "==>> Constructing DDHCalBarrelAlgo...\n"
0294 << "DDHCalBarrelAlgo: General volume...";
0295 #endif
0296
0297 double alpha = (1._pi) / nsectors;
0298 double dphi = nsectortot * (2._pi) / nsectors;
0299 int nsec, ntot(15);
0300 if (nhalf == 1)
0301 nsec = 8;
0302 else
0303 nsec = 15;
0304 int nf = ntot - nsec;
0305
0306
0307
0308 double zmax = zoff[3];
0309 double zstep5 = zoff[4];
0310 double zstep4 = (zoff[1] + rmax[1] * ttheta[1]);
0311 if ((zoff[2] + rmax[1] * ttheta[2]) > zstep4)
0312 zstep4 = (zoff[2] + rmax[1] * ttheta[2]);
0313 double zstep3 = (zoff[1] + rmax[0] * ttheta[1]);
0314 double zstep2 = (zoff[0] + rmax[0] * ttheta[0]);
0315 double zstep1 = (zoff[0] + rinner * ttheta[0]);
0316 double rout = router;
0317 double rout1 = rmax[3];
0318 double rin = rinner;
0319 double rmid1 = rmax[0];
0320 double rmid2 = rmax[1];
0321 double rmid3 = (zoff[4] - zoff[2]) / ttheta[2];
0322 double rmid4 = rmax[2];
0323
0324 std::vector<double> pgonZ = {-zmax,
0325 -zstep5,
0326 -zstep5,
0327 -zstep4,
0328 -zstep3,
0329 -zstep2,
0330 -zstep1,
0331 0,
0332 zstep1,
0333 zstep2,
0334 zstep3,
0335 zstep4,
0336 zstep5,
0337 zstep5,
0338 zmax};
0339
0340 std::vector<double> pgonRmin = {
0341 rmid4, rmid3, rmid3, rmid2, rmid1, rmid1, rin, rin, rin, rmid1, rmid1, rmid2, rmid3, rmid3, rmid4};
0342
0343 std::vector<double> pgonRmax = {
0344 rout1, rout1, rout, rout, rout, rout, rout, rout, rout, rout, rout, rout, rout, rout1, rout1};
0345
0346 std::vector<double> pgonZHalf = {0, zstep1, zstep2, zstep3, zstep4, zstep5, zstep5, zmax};
0347
0348 std::vector<double> pgonRminHalf = {rin, rin, rmid1, rmid1, rmid2, rmid3, rmid3, rmid4};
0349
0350 std::vector<double> pgonRmaxHalf = {rout, rout, rout, rout, rout, rout, rout1, rout1};
0351
0352 std::string name("Null");
0353 dd4hep::Solid solid;
0354 if (nf == 0) {
0355 solid = dd4hep::Polyhedra(ns.prepend(idName), nsectortot, -alpha, dphi, pgonZ, pgonRmin, pgonRmax);
0356 #ifdef EDM_ML_DEBUG
0357 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Polyhedra made of " << genMaterial
0358 << " with " << nsectortot << " sectors from " << convertRadToDeg(-alpha) << " to "
0359 << convertRadToDeg(-alpha + dphi) << " and with " << nsec << " sections ";
0360 for (unsigned int i = 0; i < pgonZ.size(); i++)
0361 edm::LogVerbatim("HCalGeom") << "\t"
0362 << "\tZ = " << cms::convert2mm(pgonZ[i])
0363 << "\tRmin = " << cms::convert2mm(pgonRmin[i])
0364 << "\tRmax = " << cms::convert2mm(pgonRmax[i]);
0365 #endif
0366 } else {
0367 solid = dd4hep::Polyhedra(ns.prepend(idName), nsectortot, -alpha, dphi, pgonZHalf, pgonRminHalf, pgonRmaxHalf);
0368 #ifdef EDM_ML_DEBUG
0369 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Polyhedra made of " << genMaterial
0370 << " with " << nsectortot << " sectors from " << convertRadToDeg(-alpha) << " to "
0371 << convertRadToDeg(-alpha + dphi) << " and with " << nsec << " sections ";
0372 for (unsigned int i = 0; i < pgonZHalf.size(); i++)
0373 edm::LogVerbatim("HCalGeom") << "\t\tZ = " << cms::convert2mm(pgonZHalf[i])
0374 << "\tRmin = " << cms::convert2mm(pgonRminHalf[i])
0375 << "\tRmax = " << cms::convert2mm(pgonRmaxHalf[i]);
0376 #endif
0377 }
0378
0379 dd4hep::Material matter = ns.material(genMaterial);
0380 dd4hep::Volume genlogic(solid.name(), solid, matter);
0381 dd4hep::Volume parentName = ns.volume(args.parentName());
0382 parentName.placeVolume(genlogic, 1);
0383 #ifdef EDM_ML_DEBUG
0384 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << genlogic.name() << " number 1 positioned in "
0385 << parentName.name() << " at (0, 0, 0) with no rotation";
0386 #endif
0387
0388 name = idName + "Half";
0389 nf = (ntot + 1) / 2;
0390 solid = dd4hep::Polyhedra(ns.prepend(name), nsectortot, -alpha, dphi, pgonZHalf, pgonRminHalf, pgonRmaxHalf);
0391 #ifdef EDM_ML_DEBUG
0392 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Polyhedra made of " << genMaterial
0393 << " with " << nsectortot << " sectors from " << convertRadToDeg(-alpha) << " to "
0394 << convertRadToDeg(-alpha + dphi) << " and with " << nf << " sections ";
0395 for (unsigned int i = 0; i < pgonZHalf.size(); i++)
0396 edm::LogVerbatim("HCalGeom") << "\t\tZ = " << cms::convert2mm(pgonZHalf[i])
0397 << "\tRmin = " << cms::convert2mm(pgonRminHalf[i])
0398 << "\tRmax = " << cms::convert2mm(pgonRmaxHalf[i]);
0399 #endif
0400 dd4hep::Volume genlogich(solid.name(), solid, matter);
0401 genlogic.placeVolume(genlogich, 1);
0402 #ifdef EDM_ML_DEBUG
0403 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << genlogich.name() << " number 1 positioned in "
0404 << genlogic.name() << " at (0, 0, 0) with no rotation";
0405 #endif
0406 if (nhalf != 1) {
0407 dd4hep::Rotation3D rot = getRotation(rotHalf, rotns, ns);
0408 genlogic.placeVolume(genlogich, 2, rot);
0409 #ifdef EDM_ML_DEBUG
0410 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << genlogich.name() << " number 2 positioned in "
0411 << genlogic.name() << " at (0, 0, 0) with " << rot;
0412 #endif
0413 }
0414
0415
0416 name = idName + "Module";
0417 solid = dd4hep::Polyhedra(ns.prepend(name), 1, -alpha, 2 * alpha, pgonZHalf, pgonRminHalf, pgonRmaxHalf);
0418 dd4hep::Volume seclogic(solid.name(), solid, matter);
0419 #ifdef EDM_ML_DEBUG
0420 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Polyhedra made of " << matter.name()
0421 << " with 1 sector from " << convertRadToDeg(-alpha) << " to "
0422 << convertRadToDeg(alpha) << " and with " << nf << " sections";
0423 for (unsigned int i = 0; i < pgonZHalf.size(); i++)
0424 edm::LogVerbatim("HCalGeom") << "\t\tZ = " << cms::convert2mm(pgonZHalf[i])
0425 << "\tRmin = " << cms::convert2mm(pgonRminHalf[i])
0426 << "\tRmax = " << cms::convert2mm(pgonRmaxHalf[i]);
0427 #endif
0428
0429 for (int ii = 0; ii < nsectortot; ii++) {
0430 double phi = ii * 2 * alpha;
0431 dd4hep::Rotation3D rotation;
0432 if (phi != 0) {
0433 rotation = dd4hep::RotationZ(phi);
0434 #ifdef EDM_ML_DEBUG
0435 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: Creating a new "
0436 << "rotation around Z " << convertRadToDeg(phi);
0437 #endif
0438 }
0439 genlogich.placeVolume(seclogic, ii + 1, rotation);
0440 #ifdef EDM_ML_DEBUG
0441 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << seclogic.name() << " number " << ii + 1
0442 << " positioned in " << genlogich.name() << " at (0, 0, 0) with " << rotation;
0443 #endif
0444 }
0445
0446
0447 #ifdef EDM_ML_DEBUG
0448 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: Layers (" << nLayers << ") ...";
0449 #endif
0450 rin = rinner;
0451 for (int i = 0; i < nLayers; i++) {
0452 std::string name = idName + layerLabel[i];
0453 dd4hep::Material matter = ns.material(layerMat[i]);
0454 double width = layerWidth[i];
0455 double rout = rin + width;
0456
0457 int in = 0, out = 0;
0458 for (int j = 0; j < rzones - 1; j++) {
0459 if (rin >= rmax[j])
0460 in = j + 1;
0461 if (rout > rmax[j])
0462 out = j + 1;
0463 }
0464 double zout = zoff[in] + rin * ttheta[in];
0465
0466
0467
0468 int nsec = 2;
0469 std::vector<double> pgonZ, pgonRmin, pgonRmax;
0470
0471 pgonZ.emplace_back(0);
0472 pgonRmin.emplace_back(rin);
0473 pgonRmax.emplace_back(rout);
0474
0475 pgonZ.emplace_back(zout);
0476 pgonRmin.emplace_back(rin);
0477 pgonRmax.emplace_back(rout);
0478 if (in == out) {
0479 if (in <= 3) {
0480
0481 pgonZ.emplace_back(zoff[in] + rout * ttheta[in]);
0482 pgonRmin.emplace_back(pgonRmax[1]);
0483 pgonRmax.emplace_back(pgonRmax[1]);
0484 nsec++;
0485 }
0486 } else {
0487 if (in == 3) {
0488
0489 pgonZ[1] = (zoff[out] + rmax[out] * ttheta[out]);
0490 pgonZ.emplace_back(pgonZ[1]);
0491 pgonRmin.emplace_back(pgonRmin[1]);
0492 pgonRmax.emplace_back(rmax[in]);
0493
0494 pgonZ.emplace_back(zoff[in] + rmax[in] * ttheta[in]);
0495 pgonRmin.emplace_back(pgonRmin[2]);
0496 pgonRmax.emplace_back(pgonRmax[2]);
0497 nsec += 2;
0498 } else {
0499
0500 pgonZ.emplace_back(zoff[in] + rmax[in] * ttheta[in]);
0501 pgonRmin.emplace_back(rmax[in]);
0502 pgonRmax.emplace_back(pgonRmax[1]);
0503 nsec++;
0504 if (in == 0) {
0505 pgonZ.emplace_back(zoff[out] + rmax[in] * ttheta[out]);
0506 pgonRmin.emplace_back(pgonRmin[2]);
0507 pgonRmax.emplace_back(pgonRmax[2]);
0508 nsec++;
0509 }
0510 if (in <= 1) {
0511 pgonZ.emplace_back(zoff[out] + rout * ttheta[out]);
0512 pgonRmin.emplace_back(rout);
0513 pgonRmax.emplace_back(rout);
0514 nsec++;
0515 }
0516 }
0517 }
0518
0519 dd4hep::Solid solid;
0520 double alpha1 = alpha;
0521 if (layerGap[i] > 1.e-6) {
0522 double rmid = 0.5 * (rin + rout);
0523 double width = rmid * tan(alpha) - layerGap[i];
0524 alpha1 = atan(width / rmid);
0525 #ifdef EDM_ML_DEBUG
0526 edm::LogVerbatim("HCalGeom") << "\tAlpha_1 modified from " << convertRadToDeg(alpha) << " to "
0527 << convertRadToDeg(alpha1) << " Rmid " << cms::convert2mm(rmid)
0528 << " Reduced width " << cms::convert2mm(width);
0529 #endif
0530 }
0531 solid = dd4hep::Polyhedra(ns.prepend(name), 1, -alpha1, 2 * alpha1, pgonZ, pgonRmin, pgonRmax);
0532 dd4hep::Volume glog(solid.name(), solid, matter);
0533 #ifdef EDM_ML_DEBUG
0534 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " (Layer " << i << ") Polyhedra made of "
0535 << matter.name() << " with 1 sector from " << convertRadToDeg(-alpha1) << " to "
0536 << convertRadToDeg(alpha1) << " and with " << nsec << " sections";
0537 for (unsigned int k = 0; k < pgonZ.size(); k++)
0538 edm::LogVerbatim("HCalGeom") << "\t\t" << cms::convert2mm(pgonZ[k]) << "\t" << cms::convert2mm(pgonRmin[k])
0539 << "\t" << cms::convert2mm(pgonRmax[k]);
0540 #endif
0541
0542 seclogic.placeVolume(glog, layerId[i]);
0543 #ifdef EDM_ML_DEBUG
0544 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << glog.name() << " number " << layerId[i]
0545 << " positioned in " << seclogic.name() << " at (0,0,0) with no rotation";
0546 #endif
0547 constructInsideLayers(glog,
0548 layerLabel[i],
0549 layerId[i],
0550 layerAbsorb[i],
0551 rin,
0552 layerD1[i],
0553 alpha1,
0554 layerD2[i],
0555 layerAlpha[i],
0556 layerT1[i],
0557 layerT2[i],
0558 ns);
0559 rin = rout;
0560 }
0561 }
0562
0563 void constructInsideLayers(dd4hep::Volume& laylog,
0564 const std::string& nm,
0565 int id,
0566 int nAbs,
0567 double rin,
0568 double d1,
0569 double alpha1,
0570 double d2,
0571 double alpha2,
0572 double t1,
0573 double t2,
0574 cms::DDNamespace& ns) {
0575 #ifdef EDM_ML_DEBUG
0576 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: \t\tInside layer " << id << "...";
0577 #endif
0578
0579
0580
0581 dd4hep::Rotation3D rot = getRotation(detRot, rotns, ns);
0582
0583 std::string nam0 = nm + "In";
0584 std::string name = idName + nam0;
0585 dd4hep::Material matter = ns.material(detMat);
0586
0587 dd4hep::Solid solid;
0588 dd4hep::Volume glog, mother;
0589 double rsi, dx, dy, dz, x, y;
0590 int i, in;
0591
0592 if (alpha1 > 0) {
0593 rsi = rin + d1;
0594 in = 0;
0595 for (i = 0; i < rzones - 1; i++) {
0596 if (rsi >= rmax[i])
0597 in = i + 1;
0598 }
0599 dx = 0.5 * t1;
0600 dy = 0.5 * rsi * (tan(alpha1) - tan(alpha2));
0601 dz = 0.5 * (zoff[in] + rsi * ttheta[in]);
0602 x = rsi + dx;
0603 y = 0.5 * rsi * (tan(alpha1) + tan(alpha2));
0604 dd4hep::Position r11(x, y, dz);
0605 dd4hep::Position r12(x, -y, dz);
0606
0607 solid = dd4hep::Box(ns.prepend(name + "1"), dx, dy, dz);
0608 #ifdef EDM_ML_DEBUG
0609 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Box made of " << matter.name()
0610 << " of dimensions " << cms::convert2mm(dx) << ", " << cms::convert2mm(dy) << ", "
0611 << cms::convert2mm(dz);
0612 #endif
0613 glog = dd4hep::Volume(solid.name(), solid, matter);
0614
0615 if (nAbs != 0) {
0616 mother = constructSideLayer(laylog, name, nAbs, rin, alpha1, ns);
0617 } else {
0618 mother = laylog;
0619 }
0620 mother.placeVolume(glog, idOffset + 1, r11);
0621 mother.placeVolume(glog, idOffset + 2, dd4hep::Transform3D(rot, r12));
0622 #ifdef EDM_ML_DEBUG
0623 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << glog.name() << " Number " << (idOffset + 1)
0624 << " positioned in " << mother.name() << " at (" << cms::convert2mm(x) << ","
0625 << cms::convert2mm(y) << "," << cms::convert2mm(dz) << ") with no rotation\n"
0626 << "DDHCalBarrelAlgo: " << glog.name() << " Number " << (idOffset + 2)
0627 << " positioned in " << mother.name() << " at (" << cms::convert2mm(x) << ","
0628 << -cms::convert2mm(y) << "," << cms::convert2mm(dz) << ") with " << rot;
0629 #endif
0630
0631 constructInsideDetectors(glog, nam0 + "1", id, dx, dy, dz, 1, ns);
0632 }
0633
0634
0635 rsi = rin + d2;
0636 in = 0;
0637 for (i = 0; i < rzones - 1; i++) {
0638 if (rsi >= rmax[i])
0639 in = i + 1;
0640 }
0641 dx = 0.5 * t2;
0642 dy = 0.5 * rsi * tan(alpha2);
0643 dz = 0.5 * (zoff[in] + rsi * ttheta[in]);
0644 x = rsi + dx;
0645 dd4hep::Position r21(x, dy, dz);
0646 dd4hep::Position r22(x, -dy, dz);
0647
0648 solid = dd4hep::Box(ns.prepend(name + "2"), dx, dy, dz);
0649 #ifdef EDM_ML_DEBUG
0650 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Box made of " << matter.name()
0651 << " of dimensions " << cms::convert2mm(dx) << ", " << cms::convert2mm(dy) << ", "
0652 << cms::convert2mm(dz);
0653 #endif
0654 glog = dd4hep::Volume(solid.name(), solid, matter);
0655
0656 if (nAbs < 0) {
0657 mother = constructMidLayer(laylog, name, rin, alpha1, ns);
0658 } else {
0659 mother = laylog;
0660 }
0661 mother.placeVolume(glog, idOffset + 3, r21);
0662 mother.placeVolume(glog, idOffset + 4, dd4hep::Transform3D(rot, r22));
0663 #ifdef EDM_ML_DEBUG
0664 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << glog.name() << " Number " << (idOffset + 3)
0665 << " positioned in " << mother.name() << " at (" << cms::convert2mm(x) << ","
0666 << cms::convert2mm(dy) << "," << cms::convert2mm(dz)
0667 << ") with no rotation\nDDHCalBarrelAlgo: " << glog.name() << " Number "
0668 << (idOffset + 4) << " positioned in " << mother.name() << " at ("
0669 << cms::convert2mm(x) << "," << -cms::convert2mm(dy) << "," << cms::convert2mm(dz)
0670 << ") with " << rot;
0671 #endif
0672
0673 constructInsideDetectors(glog, nam0 + "2", id, dx, dy, dz, 2, ns);
0674 }
0675
0676 dd4hep::Volume constructSideLayer(
0677 dd4hep::Volume& laylog, const std::string& nm, int nAbs, double rin, double alpha, cms::DDNamespace& ns) {
0678
0679 int k = abs(nAbs) - 1;
0680 std::string namek = nm + "Side";
0681 double rsi = rin + sideD[k];
0682 int in = 0;
0683 for (int i = 0; i < rzones - 1; i++) {
0684 if (rsi >= rmax[i])
0685 in = i + 1;
0686 }
0687 std::vector<double> pgonZ, pgonRmin, pgonRmax;
0688
0689 pgonZ.emplace_back(0.0);
0690 pgonRmin.emplace_back(rsi);
0691 pgonRmax.emplace_back(rsi + sideT[k]);
0692
0693 pgonZ.emplace_back(zoff[in] + rsi * ttheta[in]);
0694 pgonRmin.emplace_back(rsi);
0695 pgonRmax.emplace_back(pgonRmax[0]);
0696
0697 pgonZ.emplace_back(zoff[in] + pgonRmax[0] * ttheta[in]);
0698 pgonRmin.emplace_back(pgonRmax[1]);
0699 pgonRmax.emplace_back(pgonRmax[1]);
0700 dd4hep::Solid solid = dd4hep::Polyhedra(ns.prepend(namek), 1, -alpha, 2 * alpha, pgonZ, pgonRmin, pgonRmax);
0701 dd4hep::Material matter = ns.material(sideMat[k]);
0702 dd4hep::Volume glog(solid.name(), solid, matter);
0703 #ifdef EDM_ML_DEBUG
0704 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Polyhedra made of " << sideMat[k]
0705 << " with 1 sector from " << convertRadToDeg(-alpha) << " to "
0706 << convertRadToDeg(alpha) << " and with " << pgonZ.size() << " sections";
0707 for (unsigned int ii = 0; ii < pgonZ.size(); ii++)
0708 edm::LogVerbatim("HCalGeom") << "\t\tZ = " << cms::convert2mm(pgonZ[ii])
0709 << "\tRmin = " << cms::convert2mm(pgonRmin[ii])
0710 << "\tRmax = " << cms::convert2mm(pgonRmax[ii]);
0711 #endif
0712
0713 laylog.placeVolume(glog, 1);
0714 #ifdef EDM_ML_DEBUG
0715 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << glog.name() << " Number 1 positioned in " << laylog.name()
0716 << " at (0,0,0) with no rotation";
0717 #endif
0718 if (nAbs < 0) {
0719 dd4hep::Volume mother = glog;
0720 double rmid = pgonRmax[0];
0721 for (int i = 0; i < nSideAbs; i++) {
0722 double alpha1 = atan(sideAbsW[i] / rmid);
0723 if (alpha1 > 0) {
0724 std::string name = namek + sideAbsName[i];
0725 solid = dd4hep::Polyhedra(ns.prepend(name), 1, -alpha1, 2 * alpha1, pgonZ, pgonRmin, pgonRmax);
0726 dd4hep::Material matter = ns.material(sideAbsMat[i]);
0727 dd4hep::Volume log(solid.name(), solid, matter);
0728 #ifdef EDM_ML_DEBUG
0729 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Polyhedra made of " << sideAbsMat[i]
0730 << " with 1 sector from " << convertRadToDeg(-alpha1) << " to "
0731 << convertRadToDeg(alpha1) << " and with " << pgonZ.size() << " sections";
0732 for (unsigned int ii = 0; ii < pgonZ.size(); ii++)
0733 edm::LogVerbatim("HCalGeom") << "\t\tZ = " << cms::convert2mm(pgonZ[ii])
0734 << "\tRmin = " << cms::convert2mm(pgonRmin[ii])
0735 << "\tRmax = " << cms::convert2mm(pgonRmax[ii]);
0736 #endif
0737
0738 mother.placeVolume(log, 1);
0739 #ifdef EDM_ML_DEBUG
0740 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << log.name() << " Number 1 positioned in "
0741 << mother.name() << " at (0,0,0) with no rotation";
0742 #endif
0743 mother = log;
0744 }
0745 }
0746 }
0747 return glog;
0748 }
0749
0750 dd4hep::Volume constructMidLayer(
0751 dd4hep::Volume laylog, const std::string& nm, double rin, double alpha, cms::DDNamespace& ns) {
0752 dd4hep::Solid solid;
0753 dd4hep::Volume log, glog;
0754 std::string name = nm + "Mid";
0755 for (int k = 0; k < nAbsorber; k++) {
0756 std::string namek = name + absorbName[k];
0757 double rsi = rin + absorbD[k];
0758 int in = 0;
0759 for (int i = 0; i < rzones - 1; i++) {
0760 if (rsi >= rmax[i])
0761 in = i + 1;
0762 }
0763 std::vector<double> pgonZ, pgonRmin, pgonRmax;
0764
0765 pgonZ.emplace_back(0.0);
0766 pgonRmin.emplace_back(rsi);
0767 pgonRmax.emplace_back(rsi + absorbT[k]);
0768
0769 pgonZ.emplace_back(zoff[in] + rsi * ttheta[in]);
0770 pgonRmin.emplace_back(rsi);
0771 pgonRmax.emplace_back(pgonRmax[0]);
0772
0773 pgonZ.emplace_back(zoff[in] + pgonRmax[0] * ttheta[in]);
0774 pgonRmin.emplace_back(pgonRmax[1]);
0775 pgonRmax.emplace_back(pgonRmax[1]);
0776 solid = dd4hep::Polyhedra(ns.prepend(namek), 1, -alpha, 2 * alpha, pgonZ, pgonRmin, pgonRmax);
0777 dd4hep::Material matter = ns.material(absorbMat[k]);
0778 log = dd4hep::Volume(solid.name(), solid, matter);
0779 #ifdef EDM_ML_DEBUG
0780 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Polyhedra made of " << matter.name()
0781 << " with 1 sector from " << convertRadToDeg(-alpha) << " to "
0782 << convertRadToDeg(alpha) << " and with " << pgonZ.size() << " sections";
0783 for (unsigned int ii = 0; ii < pgonZ.size(); ii++)
0784 edm::LogVerbatim("HCalGeom") << "\t\tZ = " << cms::convert2mm(pgonZ[ii])
0785 << "\tRmin = " << cms::convert2mm(pgonRmin[ii])
0786 << "\tRmax = " << cms::convert2mm(pgonRmax[ii]);
0787 #endif
0788
0789 laylog.placeVolume(log, 1);
0790 #ifdef EDM_ML_DEBUG
0791 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << log.name() << " Number 1 positioned in " << laylog.name()
0792 << " at (0,0,0) with no rotation";
0793 #endif
0794 if (k == 0) {
0795 double rmin = pgonRmin[0];
0796 double rmax = pgonRmax[0];
0797 dd4hep::Volume mother = log;
0798 for (int i = 0; i < 1; i++) {
0799 double alpha1 = atan(midW[i] / rmin);
0800 std::string namek = name + midName[i];
0801 solid = dd4hep::Polyhedra(ns.prepend(namek), 1, -alpha1, 2 * alpha1, pgonZ, pgonRmin, pgonRmax);
0802 dd4hep::Material matter1 = ns.material(midMat[i]);
0803 log = dd4hep::Volume(solid.name(), solid, matter1);
0804 #ifdef EDM_ML_DEBUG
0805 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Polyhedra made of "
0806 << matter1.name() << " with 1 sector from " << convertRadToDeg(-alpha1) << " to "
0807 << convertRadToDeg(alpha1) << " and with " << pgonZ.size() << " sections";
0808 for (unsigned int ii = 0; ii < pgonZ.size(); ii++)
0809 edm::LogVerbatim("HCalGeom") << "\t\tZ = " << cms::convert2mm(pgonZ[ii])
0810 << "\tRmin = " << cms::convert2mm(pgonRmin[ii])
0811 << "\tRmax = " << cms::convert2mm(pgonRmax[ii]);
0812 #endif
0813
0814 mother.placeVolume(log, 1);
0815 #ifdef EDM_ML_DEBUG
0816 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << log.name() << " Number 1 positioned in "
0817 << mother.name() << " at (0,0,0) with no rotation";
0818 #endif
0819 mother = log;
0820 }
0821
0822
0823 double rmid = rmin + middleD;
0824 pgonRmin[0] = rmid;
0825 pgonRmax[0] = rmax;
0826 pgonRmin[1] = rmid;
0827 pgonRmax[1] = rmax;
0828 pgonZ[1] = zoff[in] + rmid * ttheta[in];
0829 pgonRmin[2] = rmax;
0830 pgonRmax[2] = rmax;
0831 pgonZ[2] = zoff[in] + rmax * ttheta[in];
0832 double alpha1 = atan(middleW / rmin);
0833 solid = dd4hep::Polyhedra(ns.prepend(name), 1, -alpha1, 2 * alpha1, pgonZ, pgonRmin, pgonRmax);
0834 dd4hep::Material matter1 = ns.material(middleMat);
0835 glog = dd4hep::Volume(solid.name(), solid, matter1);
0836 #ifdef EDM_ML_DEBUG
0837 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Polyhedra made of " << matter1.name()
0838 << " with 1 sector from " << convertRadToDeg(-alpha1) << " to "
0839 << convertRadToDeg(alpha1) << " and with " << pgonZ.size() << " sections";
0840 for (unsigned int ii = 0; ii < pgonZ.size(); ii++)
0841 edm::LogVerbatim("HCalGeom") << "\t\tZ = " << cms::convert2mm(pgonZ[ii])
0842 << "\tRmin = " << cms::convert2mm(pgonRmin[ii])
0843 << "\tRmax = " << cms::convert2mm(pgonRmax[ii]);
0844 #endif
0845
0846 mother.placeVolume(glog, 1);
0847 #ifdef EDM_ML_DEBUG
0848 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << glog.name() << " Number 1 positioned in "
0849 << mother.name() << " at (0,0,0) with no rotation";
0850 #endif
0851
0852 for (int i = 1; i < nMidAbs; i++) {
0853 namek = name + midName[i];
0854 rmid = rmin + midT[i];
0855 pgonRmin[0] = rmin;
0856 pgonRmax[0] = rmid;
0857 pgonRmin[1] = rmin;
0858 pgonRmax[1] = rmid;
0859 pgonZ[1] = zoff[in] + rmin * ttheta[in];
0860 pgonRmin[2] = rmid;
0861 pgonRmax[2] = rmid;
0862 pgonZ[2] = zoff[in] + rmid * ttheta[in];
0863 alpha1 = atan(midW[i] / rmin);
0864 solid = dd4hep::Polyhedra(ns.prepend(namek), 1, -alpha1, 2 * alpha1, pgonZ, pgonRmin, pgonRmax);
0865 dd4hep::Material matter2 = ns.material(midMat[i]);
0866 log = dd4hep::Volume(solid.name(), solid, matter2);
0867 #ifdef EDM_ML_DEBUG
0868 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Polyhedra made of "
0869 << matter2.name() << " with 1 sector from " << convertRadToDeg(-alpha1) << " to "
0870 << convertRadToDeg(alpha1) << " and with " << pgonZ.size() << " sections";
0871 for (unsigned int ii = 0; ii < pgonZ.size(); ii++)
0872 edm::LogVerbatim("HCalGeom") << "\t\tZ = " << cms::convert2mm(pgonZ[ii])
0873 << "\tRmin = " << cms::convert2mm(pgonRmin[ii])
0874 << "\tRmax = " << cms::convert2mm(pgonRmax[ii]);
0875 #endif
0876
0877 mother.placeVolume(log, i);
0878 #ifdef EDM_ML_DEBUG
0879 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << log.name() << " Number " << i << " positioned in "
0880 << mother.name() << " at (0,0,0) with no rotation";
0881 #endif
0882 mother = log;
0883 }
0884 }
0885 }
0886 return glog;
0887 }
0888
0889 void constructInsideDetectors(dd4hep::Volume& detector,
0890 const std::string& name,
0891 int id,
0892 double dx,
0893 double dy,
0894 double dz,
0895 int type,
0896 cms::DDNamespace& ns) {
0897 #ifdef EDM_ML_DEBUG
0898 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: \t\tInside detector " << id << "...";
0899 #endif
0900
0901 dd4hep::Material plmatter = ns.material(detMatPl);
0902 dd4hep::Material scmatter = ns.material(detMatSc);
0903 std::string plname = DDSplit(detector.name()).first + "Plastic_";
0904 std::string scname = idName + "Scintillator" + name;
0905
0906 id--;
0907 dd4hep::Solid solid;
0908 dd4hep::Volume glog;
0909 double wid, y = 0;
0910 double dx1, dx2, shiftX;
0911
0912 if (type == 1) {
0913 wid = 0.5 * detWidth1[id];
0914 dx1 = 0.5 * detT11[id];
0915 dx2 = 0.5 * detT21[id];
0916 shiftX = detdP1[id];
0917 if (detPosY[id] > 0)
0918 y = -dy + wid;
0919 } else {
0920 wid = 0.5 * detWidth2[id];
0921 dx1 = 0.5 * detT12[id];
0922 dx2 = 0.5 * detT22[id];
0923 shiftX = detdP2[id];
0924 }
0925
0926 solid = dd4hep::Box(ns.prepend(plname + "1"), dx1, wid, dz);
0927 glog = dd4hep::Volume(solid.name(), solid, plmatter);
0928 #ifdef EDM_ML_DEBUG
0929 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Box made of " << plmatter.name()
0930 << " of dimensions " << cms::convert2mm(dx1) << ", " << cms::convert2mm(wid) << ", "
0931 << cms::convert2mm(dz);
0932 #endif
0933
0934 double x = shiftX + dx1 - dx;
0935 detector.placeVolume(glog, 1, dd4hep::Position(x, y, 0));
0936 #ifdef EDM_ML_DEBUG
0937 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << glog.name() << " Number 1 positioned in " << detector.name()
0938 << " at (" << cms::convert2mm(x) << "," << cms::convert2mm(y)
0939 << ",0) with no rotation";
0940 #endif
0941 solid = dd4hep::Box(ns.prepend(scname), 0.5 * detTsc[id], wid, dz);
0942 glog = dd4hep::Volume(solid.name(), solid, scmatter);
0943 #ifdef EDM_ML_DEBUG
0944 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Box made of " << scmatter.name()
0945 << " of dimensions " << cms::convert2mm(0.5 * detTsc[id]) << ", "
0946 << cms::convert2mm(wid) << ", " << cms::convert2mm(dz);
0947 #endif
0948
0949 x += dx1 + 0.5 * detTsc[id];
0950 int copyNo = id * 10 + detType[id];
0951 detector.placeVolume(glog, copyNo, dd4hep::Position(x, y, 0));
0952 #ifdef EDM_ML_DEBUG
0953 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << glog.name() << " Number " << copyNo << " positioned in "
0954 << detector.name() << " at (" << cms::convert2mm(x) << "," << cms::convert2mm(y)
0955 << ",0) with no rotation";
0956 #endif
0957 solid = dd4hep::Box(ns.prepend(plname + "2"), dx2, wid, dz);
0958 glog = dd4hep::Volume(solid.name(), solid, plmatter);
0959 #ifdef EDM_ML_DEBUG
0960 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << solid.name() << " Box made of " << plmatter.name()
0961 << " of dimensions " << cms::convert2mm(dx2) << ", " << cms::convert2mm(wid) << ", "
0962 << cms::convert2mm(dz);
0963 #endif
0964
0965 x += 0.5 * detTsc[id] + dx2;
0966 detector.placeVolume(glog, 1, dd4hep::Position(x, y, 0));
0967 #ifdef EDM_ML_DEBUG
0968 edm::LogVerbatim("HCalGeom") << "DDHCalBarrelAlgo: " << glog.name() << " Number 1 positioned in " << detector.name()
0969 << " at (" << cms::convert2mm(x) << "," << cms::convert2mm(y)
0970 << ",0) with no rotation";
0971 #endif
0972 }
0973
0974 dd4hep::Rotation3D getRotation(std::string& rotation, std::string& rotns, cms::DDNamespace& ns) {
0975 std::string rot = (strchr(rotation.c_str(), NAMESPACE_SEP) == nullptr) ? (rotns + ":" + rotation) : rotation;
0976 #ifdef EDM_ML_DEBUG
0977 edm::LogVerbatim("HCalGeom") << "getRotation: " << rotation << ":" << rot << ":" << ns.rotation(rot);
0978 #endif
0979 return ns.rotation(rot);
0980 }
0981 };
0982
0983 static long algorithm(dd4hep::Detector& , cms::DDParsingContext& ctxt, xml_h e) {
0984 HcalBarrelAlgo hcalbarrelalgo(ctxt, e);
0985 #ifdef EDM_ML_DEBUG
0986 edm::LogVerbatim("HCalGeom") << "<<== End of DDHCalBarrelAlgo construction";
0987 #endif
0988 return cms::s_executed;
0989 }
0990
0991
0992 DECLARE_DDCMS_DETELEMENT(DDCMS_hcal_DDHCalBarrelAlgo, algorithm)