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; }