/** Factory for a configurable, generic tracker endcap. @author: Valentin Volkl */ static DD4hep::Geometry::Ref_t createGenericTrackerEndcap(DD4hep::Geometry::LCDD& lcdd, DD4hep::XML::Handle_t xmlElement, DD4hep::Geometry::SensitiveDetector sensDet) { // shorthands DD4hep::XML::DetElement xmlDet = static_cast<DD4hep::XML::DetElement>(xmlElement); Dimension dimensions(xmlDet.dimensions()); // get sensitive detector type from xml DD4hep::XML::Dimension sdTyp = xmlElement.child("sensitive"); // retrieve the type if (xmlDet.isSensitive()) { sensDet.setType(sdTyp.typeStr()); // set for the whole detector } // definition of top volume std::string detName = xmlDet.nameStr(); DetElement GenericTrackerEndcapWorld(detName, xmlDet.id()); // envelope volume with the max dimensions of tracker for visualization etc. // contains both endcaps, in forward and in backwards direction // the part between -z1 and z1 is subtracted from the envelope DD4hep::Geometry::Tube posnegEnvelopeShape_add(dimensions.rmin(), dimensions.rmax(), (dimensions.z2())); // make the negative shape slighly larger in the radial direction // to be sure that everything is subtracted between -z1 and z1 DD4hep::Geometry::Box posnegEnvelopeShape_subtract( dimensions.rmax() * 1.001, dimensions.rmax() * 1.001, dimensions.z1()); DD4hep::Geometry::SubtractionSolid posnegEnvelopeShape(posnegEnvelopeShape_add, posnegEnvelopeShape_subtract); Volume posnegEnvelopeVolume(detName, posnegEnvelopeShape, lcdd.air()); posnegEnvelopeVolume.setVisAttributes(lcdd.invisible()); // envelope volume for one of the endcaps, either forward or backward DD4hep::Geometry::Tube envelopeShape(dimensions.rmin(), dimensions.rmax(), 0.5 * (dimensions.z2() - dimensions.z1())); Volume envelopeVolume(detName, envelopeShape, lcdd.air()); envelopeVolume.setVisAttributes(lcdd.invisible()); // loop over 'layer' nodes in xml unsigned int layerCounter = 0; for (DD4hep::XML::Collection_t xLayerColl(xmlElement, _U(layers)); nullptr != xLayerColl; ++xLayerColl) { DD4hep::XML::Component xLayer = static_cast<DD4hep::XML::Component>(xLayerColl); // create petals unsigned int nPhi = static_cast<unsigned int>(getAttrValueWithFallback(xLayer, "nPhi", 16)); const double lModuleTwistAngle = getAttrValueWithFallback(xLayer, "module_twist_angle", 0.05 * M_PI); double dr = xLayer.rmax() - xLayer.rmin(); double dphi = 2 * dd4hep::pi / static_cast<double>(nPhi); double tn = tan(dphi); Volume petalVolume( "petal", DD4hep::Geometry::Trapezoid( 0.5 * xLayer.rmin() * tn, 0.5 * xLayer.rmax() * tn, xLayer.thickness(), xLayer.thickness(), 0.5 * dr), lcdd.material("Silicon")); petalVolume.setVisAttributes(lcdd, xLayer.visStr()); petalVolume.setSensitiveDetector(sensDet); // handle repeat attribute in xml double layerThickness; unsigned int numLayers; double current_z; // "repeat" layers equidistant between rmin and rmax numLayers = xLayer.repeat(); layerThickness = (xLayer.z2() - xLayer.z1()) / numLayers; // create layers. for (unsigned int repeatIndex = 0; repeatIndex < numLayers; ++repeatIndex) { DD4hep::Geometry::Tube layerShape(xLayer.rmin(), xLayer.rmax(), 0.5 * layerThickness); Volume layerVolume("layer" + std::to_string(layerCounter), layerShape, lcdd.air()); layerVolume.setVisAttributes(lcdd.invisible()); ++layerCounter; // place layers not at center, but at z1 value of containing envelope // subtract half of the envelope length current_z = (repeatIndex + 0.5) * layerThickness + xLayer.z1() - dimensions.z1(); PlacedVolume placedLayerVolume = envelopeVolume.placeVolume( layerVolume, DD4hep::Geometry::Position(0, 0, current_z - 0.5 * (dimensions.z2() - dimensions.z1()))); placedLayerVolume.addPhysVolID("layer", layerCounter); double phi; double r = xLayer.rmin(); for (unsigned int phiIndex = 0; phiIndex < nPhi; ++phiIndex) { phi = 2 * dd4hep::pi * static_cast<double>(phiIndex) / static_cast<double>(nPhi); // oriented along z at first DD4hep::Geometry::Translation3D lTranslation_ringPhiPos(0, 0, r + 0.5 * dr); DD4hep::Geometry::RotationY lRotation_ringPhiPos(phi); DD4hep::Geometry::RotationX lRotation_orientRing(0.5 * dd4hep::pi); // twist petals slightly so they can overlap DD4hep::Geometry::RotationZ lRotation_twist(lModuleTwistAngle); PlacedVolume placedPetalVolume = layerVolume.placeVolume( petalVolume, lRotation_orientRing * lRotation_ringPhiPos * lTranslation_ringPhiPos * lRotation_twist); placedPetalVolume.addPhysVolID("petal", phiIndex); } } } // top of the hierarchy Volume motherVol = lcdd.pickMotherVolume(GenericTrackerEndcapWorld); PlacedVolume placedEnvelopeVolume = motherVol.placeVolume(posnegEnvelopeVolume); placedEnvelopeVolume.addPhysVolID("system", xmlDet.id()); // place everything twice -- forward / backward DD4hep::Geometry::Translation3D lTranslation_posEnvelope( 0, 0, -dimensions.z1() - 0.5 * (dimensions.z2() - dimensions.z1())); PlacedVolume placedGenericTrackerEndcap_pos = posnegEnvelopeVolume.placeVolume( envelopeVolume, DD4hep::Geometry::Position(0, 0, dimensions.z1() + 0.5 * (dimensions.z2() - dimensions.z1()))); PlacedVolume placedGenericTrackerEndcap_neg = posnegEnvelopeVolume.placeVolume( envelopeVolume, lTranslation_posEnvelope * DD4hep::Geometry::RotationX(dd4hep::pi)); placedGenericTrackerEndcap_pos.addPhysVolID("posneg", 0); placedGenericTrackerEndcap_neg.addPhysVolID("posneg", 1); GenericTrackerEndcapWorld.setPlacement(placedEnvelopeVolume); return GenericTrackerEndcapWorld; }
static DD4hep::Geometry::Ref_t createTkLayoutTrackerBarrel(DD4hep::Geometry::LCDD& lcdd, DD4hep::XML::Handle_t xmlElement, DD4hep::Geometry::SensitiveDetector sensDet) { // shorthands DD4hep::XML::DetElement xmlDet = static_cast<DD4hep::XML::DetElement>(xmlElement); Dimension dimensions(xmlDet.dimensions()); // get sensitive detector type from xml DD4hep::XML::Dimension sdTyp = xmlElement.child(_Unicode(sensitive)); // sensitive detector used for all sensitive parts of this detector sensDet.setType(sdTyp.typeStr()); // definition of top volume // has min/max dimensions of tracker for visualization etc. std::string detectorName = xmlDet.nameStr(); DetElement topDetElement(detectorName, xmlDet.id()); Acts::ActsExtension::Config barrelConfig; barrelConfig.isBarrel = true; // detElement owns extension Acts::ActsExtension* detWorldExt = new Acts::ActsExtension(barrelConfig); topDetElement.addExtension<Acts::IActsExtension>(detWorldExt); DD4hep::Geometry::Tube topVolumeShape( dimensions.rmin(), dimensions.rmax(), (dimensions.zmax() - dimensions.zmin()) * 0.5); Volume topVolume(detectorName, topVolumeShape, lcdd.air()); topVolume.setVisAttributes(lcdd.invisible()); // counts all layers - incremented in the inner loop over repeat - tags unsigned int layerCounter = 0; double integratedModuleComponentThickness = 0; double phi = 0; // loop over 'layer' nodes in xml DD4hep::XML::Component xLayers = xmlElement.child(_Unicode(layers)); for (DD4hep::XML::Collection_t xLayerColl(xLayers, _U(layer)); nullptr != xLayerColl; ++xLayerColl) { DD4hep::XML::Component xLayer = static_cast<DD4hep::XML::Component>(xLayerColl); DD4hep::XML::Component xRods = xLayer.child("rods"); DD4hep::XML::Component xRodEven = xRods.child("rodOdd"); DD4hep::XML::Component xRodOdd = xRods.child("rodEven"); DD4hep::XML::Component xModulesEven = xRodEven.child("modules"); DD4hep::XML::Component xModulePropertiesOdd = xRodOdd.child("moduleProperties"); DD4hep::XML::Component xModulesOdd = xRodOdd.child("modules"); DD4hep::Geometry::Tube layerShape(xLayer.rmin(), xLayer.rmax(), dimensions.zmax()); Volume layerVolume("layer", layerShape, lcdd.material("Air")); layerVolume.setVisAttributes(lcdd.invisible()); PlacedVolume placedLayerVolume = topVolume.placeVolume(layerVolume); placedLayerVolume.addPhysVolID("layer", layerCounter); DetElement lay_det(topDetElement, "layer" + std::to_string(layerCounter), layerCounter); Acts::ActsExtension::Config layConfig; layConfig.isLayer = true; // the local coordinate systems of modules in dd4hep and acts differ // see http://acts.web.cern.ch/ACTS/latest/doc/group__DD4hepPlugins.html layConfig.axes = "XzY"; // correct translation of local x axis in dd4hep to local x axis in acts // detElement owns extension Acts::ActsExtension* layerExtension = new Acts::ActsExtension(layConfig); lay_det.addExtension<Acts::IActsExtension>(layerExtension); lay_det.setPlacement(placedLayerVolume); DD4hep::XML::Component xModuleComponentsOdd = xModulePropertiesOdd.child("components"); integratedModuleComponentThickness = 0; int moduleCounter = 0; Volume moduleVolume; for (DD4hep::XML::Collection_t xModuleComponentOddColl(xModuleComponentsOdd, _U(component)); nullptr != xModuleComponentOddColl; ++xModuleComponentOddColl) { DD4hep::XML::Component xModuleComponentOdd = static_cast<DD4hep::XML::Component>(xModuleComponentOddColl); moduleVolume = Volume("module", DD4hep::Geometry::Box(0.5 * xModulePropertiesOdd.attr<double>("modWidth"), 0.5 * xModuleComponentOdd.thickness(), 0.5 * xModulePropertiesOdd.attr<double>("modLength")), lcdd.material(xModuleComponentOdd.materialStr())); unsigned int nPhi = xRods.repeat(); DD4hep::XML::Handle_t currentComp; for (unsigned int phiIndex = 0; phiIndex < nPhi; ++phiIndex) { double lX = 0; double lY = 0; double lZ = 0; if (0 == phiIndex % 2) { phi = 2 * M_PI * static_cast<double>(phiIndex) / static_cast<double>(nPhi); currentComp = xModulesEven; } else { currentComp = xModulesOdd; } for (DD4hep::XML::Collection_t xModuleColl(currentComp, _U(module)); nullptr != xModuleColl; ++xModuleColl) { DD4hep::XML::Component xModule = static_cast<DD4hep::XML::Component>(xModuleColl); double currentPhi = atan2(xModule.Y(), xModule.X()); double componentOffset = integratedModuleComponentThickness - 0.5 * xModulePropertiesOdd.attr<double>("modThickness") + 0.5 * xModuleComponentOdd.thickness(); lX = xModule.X() + cos(currentPhi) * componentOffset; lY = xModule.Y() + sin(currentPhi) * componentOffset; lZ = xModule.Z(); DD4hep::Geometry::Translation3D moduleOffset(lX, lY, lZ); DD4hep::Geometry::Transform3D lTrafo(DD4hep::Geometry::RotationZ(atan2(lY, lX) + 0.5 * M_PI), moduleOffset); DD4hep::Geometry::RotationZ lRotation(phi); PlacedVolume placedModuleVolume = layerVolume.placeVolume(moduleVolume, lRotation * lTrafo); if (xModuleComponentOdd.isSensitive()) { placedModuleVolume.addPhysVolID("module", moduleCounter); moduleVolume.setSensitiveDetector(sensDet); DetElement mod_det(lay_det, "module" + std::to_string(moduleCounter), moduleCounter); mod_det.setPlacement(placedModuleVolume); ++moduleCounter; } } } integratedModuleComponentThickness += xModuleComponentOdd.thickness(); } ++layerCounter; } Volume motherVol = lcdd.pickMotherVolume(topDetElement); PlacedVolume placedGenericTrackerBarrel = motherVol.placeVolume(topVolume); placedGenericTrackerBarrel.addPhysVolID("system", topDetElement.id()); topDetElement.setPlacement(placedGenericTrackerBarrel); return topDetElement; }
static DD4hep::Geometry::Ref_t createGenericTrackerBarrel(DD4hep::Geometry::LCDD& lcdd, DD4hep::XML::Handle_t xmlElement, DD4hep::Geometry::SensitiveDetector sensDet) { // shorthands DD4hep::XML::DetElement xmlDet = static_cast<DD4hep::XML::DetElement>(xmlElement); Dimension dimensions(xmlDet.dimensions()); // get sensitive detector type from xml DD4hep::XML::Dimension sdTyp = xmlElement.child("sensitive"); if (xmlDet.isSensitive()) { // sensitive detector used for all sensitive parts of this detector sensDet.setType(sdTyp.typeStr()); } // definition of top volume // has min/max dimensions of tracker for visualization etc. std::string detectorName = xmlDet.nameStr(); DetElement topDetElement(detectorName, xmlDet.id()); DD4hep::Geometry::Tube topVolumeShape(dimensions.rmin(), dimensions.rmax(), dimensions.dz()); Volume topVolume(detectorName, topVolumeShape, lcdd.air()); topVolume.setVisAttributes(lcdd.invisible()); // counts all layers - incremented in the inner loop over repeat - tags unsigned int layerCounter = 0; // loop over 'layer' nodes in xml for (DD4hep::XML::Collection_t xLayerColl(xmlElement, _U(layers)); nullptr != xLayerColl; ++xLayerColl) { DD4hep::XML::Component xLayer = static_cast<DD4hep::XML::Component>(xLayerColl); DD4hep::XML::Component xModuleComponents = xmlElement.child("module_components"); DD4hep::XML::Component xModule = utils::getNodeByStrAttr(xmlElement, "module", "name", xLayer.attr<std::string>("module")); // optional parameters double stereo_offset = utils::getAttrValueWithFallback(xLayer, "stereo_offset", 0.0); double module_twist_angle = utils::getAttrValueWithFallback(xLayer, "module_twist_angle", 0.1 * M_PI); double stereo_module_overlap = utils::getAttrValueWithFallback(xLayer, "stereo_module_overlap", 0.0); // get total thickness of module unsigned int idxSubMod = 0; double totalModuleComponentThickness = 0; for (DD4hep::XML::Collection_t xCompColl(xModuleComponents, _U(module_component)); nullptr != xCompColl; ++xCompColl, ++idxSubMod) { DD4hep::XML::Component xComp = static_cast<DD4hep::XML::Component>(xCompColl); totalModuleComponentThickness += xComp.thickness(); } // now that thickness is known: define module components volumes idxSubMod = 0; double integratedModuleComponentThickness = 0; std::vector<Volume> moduleComponentVector; for (DD4hep::XML::Collection_t xCompColl(xModuleComponents, _U(module_component)); nullptr != xCompColl; ++xCompColl, ++idxSubMod) { DD4hep::XML::Component xComp = static_cast<DD4hep::XML::Component>(xCompColl); std::string moduleComponentName = "layer" + std::to_string(layerCounter) + "_rod_module_component" + std::to_string(idxSubMod) + "_" + xComp.materialStr(); Volume moduleComponentVolume(moduleComponentName, DD4hep::Geometry::Box(xModule.width(), xComp.thickness(), xModule.length()), lcdd.material(xComp.materialStr())); moduleComponentVolume.setVisAttributes(lcdd, xComp.visStr()); if (xComp.isSensitive()) { moduleComponentVolume.setSensitiveDetector(sensDet); } moduleComponentVector.push_back(moduleComponentVolume); } // definition of module volume (smallest independent subdetector) // define the module whose name was given in the "layer" xml Element Volume moduleVolume("module", DD4hep::Geometry::Box(xModule.width(), xModule.thickness(), xModule.length()), lcdd.material("Air")); moduleVolume.setVisAttributes(lcdd, xModule.visStr()); // definition of rod volume (longitudinal arrangement of modules) Volume rodVolume("GenericTrackerBarrel_layer" + std::to_string(layerCounter) + "_rod", DD4hep::Geometry::Box(xModule.width(), xModule.thickness(), xLayer.dz()), lcdd.material("Air")); rodVolume.setVisAttributes(lcdd.invisible()); /// @todo: allow for more than one type of module components // analogous to module // place module substructure in module std::string moduleComponentName = "moduleComponent"; idxSubMod = 0; for (DD4hep::XML::Collection_t xCompColl(xModuleComponents, _U(module_component)); nullptr != xCompColl; ++xCompColl, ++idxSubMod) { DD4hep::XML::Component xComp = static_cast<DD4hep::XML::Component>(xCompColl); DD4hep::Geometry::Position offset(0, -0.5 * totalModuleComponentThickness + integratedModuleComponentThickness, 0); integratedModuleComponentThickness += xComp.thickness(); PlacedVolume placedModuleComponentVolume = moduleVolume.placeVolume(moduleComponentVector[idxSubMod], offset); placedModuleComponentVolume.addPhysVolID("module_component", idxSubMod); } // handle repeat attribute in xml // "repeat" layers equidistant between rmin and rmax double numRepeat = xLayer.repeat(); double layerThickness = (xLayer.rmax() - xLayer.rmin()) / numRepeat; double layer_rmin = xLayer.rmin(); unsigned int nPhi = 0; double r = 0; double phi = 0; // loop over repeated layers defined by one layer tag for (unsigned int repeatIndex = 0; repeatIndex < numRepeat; ++repeatIndex) { ++layerCounter; // let r be the middle between two equidistant layer boundaries r = layer_rmin + (0.5 + repeatIndex) * layerThickness; // definition of layer volumes DD4hep::Geometry::Tube layerShape(r - 0.5*layerThickness, r + 0.5*layerThickness, xLayer.dz()); std::string layerName = "layer" + std::to_string(layerCounter); Volume layerVolume(layerName, layerShape, lcdd.material("Silicon")); layerVolume.setVisAttributes(lcdd.invisible()); PlacedVolume placedLayerVolume = topVolume.placeVolume(layerVolume); placedLayerVolume.addPhysVolID("layer", layerCounter); // approximation of tklayout values double phiOverlapFactor = utils::getAttrValueWithFallback(xLayer, "phi_overlap_factor", 1.15); nPhi = static_cast<unsigned int>( phiOverlapFactor * 2 * M_PI * r / (2 * xModule.width())); for (unsigned int phiIndex = 0; phiIndex < nPhi; ++phiIndex) { phi = 2 * M_PI * static_cast<double>(phiIndex) / static_cast<double>(nPhi); DD4hep::Geometry::Translation3D lTranslation(r * cos(phi), r * sin(phi), 0); DD4hep::Geometry::RotationZ lRotation(phi + module_twist_angle + 0.5 * M_PI); PlacedVolume placedRodVolume = layerVolume.placeVolume(rodVolume, lTranslation * lRotation); placedRodVolume.addPhysVolID("rod", phiIndex); } } // placement of modules within rods unsigned int zRepeat = static_cast<int>(xLayer.dz() / (xModule.length() - stereo_module_overlap)); // stereo overlap for (unsigned int zIndex = 0; zIndex < zRepeat; ++zIndex) { stereo_offset *= -1.; DD4hep::Geometry::Position moduleOffset(0, stereo_offset, zIndex * 2 * (xModule.length() - stereo_module_overlap) - xLayer.dz() + xModule.length() - stereo_module_overlap); PlacedVolume placedModuleVolume = rodVolume.placeVolume(moduleVolume, moduleOffset); placedModuleVolume.addPhysVolID("module", zIndex); } } Volume motherVol = lcdd.pickMotherVolume(topDetElement); PlacedVolume placedGenericTrackerBarrel = motherVol.placeVolume(topVolume); placedGenericTrackerBarrel.addPhysVolID("system", topDetElement.id()); topDetElement.setPlacement(placedGenericTrackerBarrel); return topDetElement; }