298 ATH_MSG_INFO(
"**************************************************");
299 ATH_MSG_INFO(
" Building HGTD geometry , side = " << bPos <<
" ");
300 ATH_MSG_INFO(
"**************************************************" );
302 GeoFullPhysVol* HGTDparent =
new GeoFullPhysVol( logicalEnvelope );
305 double motherHalfZ = ((GeoTube*) HGTDparent->getLogVol()->getShape())->getZHalfLength();
306 double modulePackageHalfZtot = 3.5/2 + 4./2;
313 std::vector<std::string> hgtdVolumes;
314 hgtdVolumes.push_back(
"HGTD::ModeratorOut");
315 hgtdVolumes.push_back(
"HGTD::BackCover");
316 hgtdVolumes.push_back(
"HGTD::ToleranceBack");
317 hgtdVolumes.push_back(
"HGTD::ModeratorIn");
319 hgtdVolumes.push_back(
"HGTD::ModuleLayer3");
320 hgtdVolumes.push_back(
"HGTD::SupportPlate");
321 hgtdVolumes.push_back(
"HGTD::CoolingPlate");
322 hgtdVolumes.push_back(
"HGTD::SupportPlate");
323 hgtdVolumes.push_back(
"HGTD::ModuleLayer2");
325 hgtdVolumes.push_back(
"HGTD::ToleranceMid");
327 hgtdVolumes.push_back(
"HGTD::ModuleLayer1");
328 hgtdVolumes.push_back(
"HGTD::SupportPlate");
329 hgtdVolumes.push_back(
"HGTD::CoolingPlate");
330 hgtdVolumes.push_back(
"HGTD::SupportPlate");
331 hgtdVolumes.push_back(
"HGTD::ModuleLayer0");
333 hgtdVolumes.push_back(
"HGTD::ToleranceFront");
334 hgtdVolumes.push_back(
"HGTD::FrontCover");
336 hgtdVolumes.push_back(
"HGTD::InnerRCover1");
337 hgtdVolumes.push_back(
"HGTD::InnerRCover2");
338 hgtdVolumes.push_back(
"HGTD::InnerRCover3");
339 hgtdVolumes.push_back(
"HGTD::OuterRCover");
340 hgtdVolumes.push_back(
"HGTD::PeripheralCoolingLines");
354 std::vector<double> flexSheetInnerR;
355 double currentInnerR = 144.;
356 for (
int flexSheet = 0; flexSheet < 8; flexSheet++) {
357 flexSheetInnerR.push_back(currentInnerR);
359 currentInnerR +=
m_boxVolPars[
"HGTDModule0"].xHalf*2 * (2 + 2 * (flexSheet < 4 ? 0.2 : 0.8) );
363 GeoPhysVol* flexPackagePhysical[2] = {};
364 for (
int flexVolume = 0; flexVolume < 2; flexVolume++) {
365 std::vector<double> rInner = flexSheetInnerR;
366 if (flexVolume)
reverse(rInner.begin(), rInner.end());
368 GeoTube* flexPackageSolid =
new GeoTube(packagePars.
rMin, packagePars.
rMax, packagePars.
zHalf);
370 flexPackagePhysical[flexVolume] =
new GeoPhysVol(flexPackageLogical);
372 double flexZoffset = packagePars.
zHalf - flexPars.
zHalf;
373 for (
int flexSheet = 0; flexSheet < 8; flexSheet++) {
374 GeoTube* hgtdFlexSolid =
new GeoTube(rInner[flexSheet], flexPars.
rMax, flexPars.
zHalf);
375 GeoLogVol* hgtdFlexLogical =
new GeoLogVol(
"HGTD::FlexTube"+
std::to_string(flexSheet),
377 GeoPhysVol* hgtdFlexPhysical =
new GeoPhysVol(hgtdFlexLogical);
378 flexPackagePhysical[flexVolume]->add(
new GeoTransform(GeoTrf::TranslateZ3D(flexZoffset)));
379 flexPackagePhysical[flexVolume]->add(hgtdFlexPhysical);
381 ATH_MSG_DEBUG(
"Flex layer (" << (flexSheet ?
"front" :
"back") <<
")" << flexSheet <<
", Rmin = " << std::setw(5)
382 << rInner[flexSheet] <<
" mm, flexZoffset = " << flexZoffset <<
" mm" );
392 std::vector<double> coolingTubeRadii;
393 double coolingTubeRadius = 130.;
394 coolingTubeRadii.push_back(coolingTubeRadius);
398 ATH_MSG_INFO(
"Will now calculate cooling-loop positions for the two-ring layout");
399 for (
int i = 0;
i < 18;
i++) {
400 coolingTubeRadius += (418-130.)/18;
401 coolingTubeRadii.push_back(coolingTubeRadius);
403 for (
int i = 0;
i < 12;
i++) {
404 coolingTubeRadius += (658-418.)/14;
405 coolingTubeRadii.push_back(coolingTubeRadius);
407 coolingTubeRadius = 710.;
408 coolingTubeRadii.push_back(coolingTubeRadius);
409 for (
int i = 0;
i < 7;
i++) {
410 coolingTubeRadius += (890-710.)/6;
411 coolingTubeRadii.push_back(coolingTubeRadius);
415 ATH_MSG_INFO(
"Will now calculate cooling-loop positions for the three-ring layout");
417 int numberOfLoops = 34;
418 float loopDistance = (674.-130.)/numberOfLoops;
419 for (
int i = 0;
i < numberOfLoops;
i++) {
420 coolingTubeRadius += loopDistance;
421 coolingTubeRadii.push_back(coolingTubeRadius);
424 coolingTubeRadius = 720;
425 coolingTubeRadii.push_back(coolingTubeRadius);
427 loopDistance = (900.-720.)/numberOfLoops;
428 for (
int i = 0;
i < numberOfLoops;
i++) {
429 coolingTubeRadius += loopDistance;
430 coolingTubeRadii.push_back(coolingTubeRadius);
433 ATH_MSG_DEBUG(
"Cooling tubes will be created at the following radii (" << coolingTubeRadii.size() <<
" in total):");
434 for (
size_t i = 0;
i < coolingTubeRadii.size();
i++) {
444 GeoTube* periphElec_solid =
new GeoTube(periphElPars.
rMin, periphElPars.
rMax, periphElPars.
zHalf);
446 GeoPhysVol* periphElec_phys =
new GeoPhysVol(periphElec_log);
448 std::array< GeoPhysVol*, 4 > moduleLayerPhysical = {};
455 double zModuleLayerF = 0.;
456 double zModuleLayerB = 0.;
457 for (
size_t vol = 0; vol < hgtdVolumes.size(); vol++) {
459 std::string
v = hgtdVolumes[vol];
468 if (
v.substr(9,8) !=
"erRCover" &&
v !=
"HGTD::PeripheralCoolingLines") {
469 std::string vPrev = hgtdVolumes[vol-1];
475 if (
v.substr(0,15) ==
"HGTD::Tolerance")
continue;
478 if (
v.substr(0,17) ==
"HGTD::ModuleLayer")
484 GeoPhysVol* hgtdSubVolumePhysical =
new GeoPhysVol(hgtdSubVolumeLogical);
487 if (
v ==
"HGTD::CoolingPlate") {
491 HGTDparent->add(
new GeoTransform(GeoTrf::TranslateZ3D(
m_cylVolPars[
v].zOffsetLocal +
pow(-1,
side)*zOffsetPeriphElec)));
492 HGTDparent->add(periphElec_phys);
496 for (
size_t i = 0;
i < coolingTubeRadii.size();
i++) {
498 GeoTorus* coolingTubeSolid =
new GeoTorus(
m_cylVolPars[
"HGTD::CoolingTubeFluid"].zHalf,
m_cylVolPars[
"HGTD::CoolingTube"].zHalf,
499 coolingTubeRadii[
i], 0, 2*
M_PI);
500 GeoLogVol* coolingTubeLogical =
new GeoLogVol(
"HGTD::CoolingTube", coolingTubeSolid,
502 GeoPhysVol* coolingTubePhysical =
new GeoPhysVol(coolingTubeLogical);
503 hgtdSubVolumePhysical->add(coolingTubePhysical);
505 GeoTorus* coolingFluidSolid =
new GeoTorus(0,
m_cylVolPars[
"HGTD::CoolingTubeFluid"].zHalf,
506 coolingTubeRadii[
i], 0, 2*
M_PI);
507 GeoLogVol* coolingFluidLogical =
new GeoLogVol(
"HGTD::CoolingFluid", coolingFluidSolid,
509 GeoPhysVol* coolingFluidPhysical =
new GeoPhysVol(coolingFluidLogical);
510 hgtdSubVolumePhysical->add(coolingFluidPhysical);
515 if (
v.substr(0,17) ==
"HGTD::ModuleLayer") {
521 bool Lside =
layer % 2;
523 zFlex = -modulePackageHalfZtot +
m_cylVolPars[
"HGTD::FlexPackage"].zHalf;
524 zModuleLayerF = modulePackageHalfZtot - modulePackageHalfZ;
527 zFlex = modulePackageHalfZtot -
m_cylVolPars[
"HGTD::FlexPackage"].zHalf;
528 zModuleLayerB = -modulePackageHalfZtot + modulePackageHalfZ;
532 hgtdSubVolumePhysical->add(
new GeoTransform(GeoTrf::TranslateZ3D(zFlex)));
533 hgtdSubVolumePhysical->add(flexPackagePhysical[(Lside ? 0 : 1)]);
537 HGTDparent->add(
new GeoTransform( GeoTrf::TranslateZ3D(
m_cylVolPars[
v].zOffsetLocal) *
541 HGTDparent->add( hgtdSubVolumePhysical );
542 moduleLayerPhysical[
layer] = hgtdSubVolumePhysical;
546 HGTDparent->add(
new GeoTransform(GeoTrf::TranslateZ3D(
m_cylVolPars[
v].zOffsetLocal)));
547 HGTDparent->add(hgtdSubVolumePhysical);
552 <<
" ), local z = " << std::setw(6) <<
m_cylVolPars[
v].zOffsetLocal
555 <<
" mm, DZ = " << std::setw(5) <<
m_cylVolPars[
v].zHalf <<
" mm" );
564 std::vector<std::string> moduleVolumes;
565 moduleVolumes.push_back(
"HGTD::GlueAsic");
566 moduleVolumes.push_back(
"HGTD::ASIC");
567 moduleVolumes.push_back(
"HGTD::LGADInactive");
568 moduleVolumes.push_back(
"SensorPlaceHolder");
569 moduleVolumes.push_back(
"HGTD::GlueSensor");
570 moduleVolumes.push_back(
"HGTD::Hybrid");
571 moduleVolumes.push_back(
"HGTD::ModuleSpace");
573 int endcap = bPos ? +2 : -2;
574 double thickness = 2.*
m_boxVolPars[
"HGTDSiSensor0"].zHalf;
582 unsigned int maxRows = 21;
593 int Lside =
layer % 2;
595 std::vector<std::string> volumes = moduleVolumes;
596 if ( Lside != 0 )
reverse( volumes.begin(), volumes.end() );
605 double moduleHalfWidth =
m_boxVolPars[moduleName].xHalf;
606 double moduleHalfHeight =
m_boxVolPars[moduleName].yHalf;
612 for (
int q = 0;
q < 4;
q++) {
613 float quadrot =
q*90.;
615 for (
unsigned int row = 0;
row < maxRows;
row ++ ) {
616 std::vector< ModulePosition > ModsPerRow = tmpQuadrant[
row ];
619 if (
m_outputIdfr &&
q == 0 ) std::cout <<
" Row #"<<
row + 1 <<
" :: " << ModsPerRow.size() << std::endl;
621 for (
unsigned int mod = 0;
mod < ModsPerRow.size();
mod ++ ) {
624 double myx = -9999999.9 , myy = -9999999.9 , myrot = -9999999.9;
625 int myphi = -1 , myeta = - 1;
626 std::string module_string =
formModuleName(
layer,
q, maxRows,
row,
mod,
module, myx, myy, myrot, myphi, myeta );
628 if ( module_string ==
"" || myrot == -9999999.9 || myeta == -1 )
629 ATH_MSG_WARNING (
" Please check the module at layer "<<
layer <<
" quadrant " <<
q <<
" row "<<
row <<
" mod " <<
mod <<
" not well retrieved ! " );
632 GeoBox* moduleSolid =
new GeoBox( moduleHalfWidth, moduleHalfHeight, modulePackageHalfZ);
633 GeoLogVol* moduleLogical =
new GeoLogVol( moduleName + module_string, moduleSolid,
m_materialMgr->
getMaterial(
"std::Air"));
634 GeoFullPhysVol* modulePhysical =
new GeoFullPhysVol( moduleLogical );
637 if (
q == 0 &&
row == 0 &&
mod == 0 )
638 ATH_MSG_DEBUG(
"Will now build up an individual HGTD module of layer " <<
layer <<
" and quadrant " <<
q <<
" (" << module_string <<
")" );
642 if (volumes[
comp] ==
"SensorPlaceHolder") volumes[
comp] = sensorName;
644 std::string
c = volumes[
comp];
649 std::string cPrev = volumes[
comp-1];
654 if (volumes[
comp] ==
"HGTD::ModuleSpace")
continue;
660 double xOffsetLocal = moduleHalfWidth - comp_halfx;
663 GeoBox* sensorCompSolidVol =
new GeoBox(comp_halfx, comp_halfy,
m_boxVolPars[
c].zHalf);
667 GeoLogVol* sensorCompLogicalVol =
new GeoLogVol(
m_boxVolPars[
c].
name+attach, sensorCompSolidVol,
669 GeoFullPhysVol* sensorCompPhysicalVol =
new GeoFullPhysVol(sensorCompLogicalVol);
671 if (volumes[
comp] == sensorName) {
673 Identifier idwafer = hgtdId->
wafer_id( endcap,
layer, myphi, myeta );
678 <<
" upon HGTD_ID => ec: " << endcap <<
", layer: " <<
layer <<
", quadrant: " <<
q
679 <<
", row: " << myphi <<
", module: "<< myeta );
680 ATH_MSG_DEBUG(
" HGTD Module: " <<
m_boxVolPars[
c].
name+module_string <<
", posX: " << myx <<
", posY: " << myy <<
", rot: " << quadrot + myrot );
687 GeoAlignableTransform* xform =
new GeoAlignableTransform(sensorTransform);
689 modulePhysical->add( xform );
690 modulePhysical->add( sensorCompPhysicalVol );
695 modulePhysical->add(
new GeoTransform(GeoTrf::TranslateZ3D(
m_boxVolPars[
c].zOffsetLocal)*GeoTrf::TranslateX3D(xOffsetLocal)));
696 modulePhysical->add(sensorCompPhysicalVol);
700 if (
mod == 0 &&
q == 0 && volumes[
comp] != sensorName )
702 <<
" ), in-sensor-layer local z = " << std::setw(7) <<
m_boxVolPars[
c].zOffsetLocal <<
" mm"
703 <<
", DX = " << std::setw(5) <<
m_boxVolPars[
c].xHalf <<
" mm"
704 <<
", DY = " << std::setw(5) <<
m_boxVolPars[
c].yHalf <<
" mm"
705 <<
", DZ = " << std::setw(5) <<
m_boxVolPars[
c].zHalf <<
" mm" );
708 double zModule = ( Lside == 0 ? zModuleLayerF : zModuleLayerB );
710 GeoTransform* moduleTransform =
new GeoTransform( GeoTrf::TranslateZ3D(zModule) *
711 GeoTrf::TranslateX3D(myx) *
712 GeoTrf::TranslateY3D(myy) *
714 moduleLayerPhysical[
layer]->add( moduleTransform );
715 moduleLayerPhysical[
layer]->add( modulePhysical );
724 ATH_MSG_INFO(
"**************************************************" );
725 ATH_MSG_INFO(
" Done building HGTD with " << totMod <<
" modules " );
726 ATH_MSG_INFO(
"**************************************************" );