static DD4hep::Geometry::Ref_t createTkLayoutTrackerEndcap(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
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.zmax());
// 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.zmin());
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.zmax() - dimensions.zmin()));
Volume envelopeVolume(detName, envelopeShape, lcdd.air());
envelopeVolume.setVisAttributes(lcdd.invisible());
Component xDiscs = xmlElement.child("discs");
Component xFirstDisc = xDiscs.child("discZPls");
Component xFirstDiscRings = xFirstDisc.child("rings");
// create disc volume
double discThickness = (xFirstDisc.zmax() - xFirstDisc.zmin());
DD4hep::Geometry::Tube discShape(dimensions.rmin(), dimensions.rmax(), 0.5 * discThickness);
Volume discVolume("disc", discShape, lcdd.air());
discVolume.setVisAttributes(lcdd.invisible());
// generate rings and place in discs
int moduleCounter = 0;
for (DD4hep::XML::Collection_t xRingColl(xFirstDiscRings, _U(ring)); nullptr != xRingColl; ++xRingColl) {
Component xRing = static_cast<Component>(xRingColl);
Component xRingModules = xRing.child("modules");
Component xModuleOdd = xRingModules.child("moduleOdd");
Component xModuleEven = xRingModules.child("moduleEven");
Component xModuleProperties = xRing.child("moduleProperties");
Component xModulePropertiesComp = xModuleProperties.child("components");
Component xSensorProperties = xRing.child("sensorProperties");
Volume moduleVolume("module",
DD4hep::Geometry::Trapezoid(0.5 * xModuleProperties.attr<double>("modWidthMin"),
0.5 * xModuleProperties.attr<double>("modWidthMax"),
0.5 * xModuleProperties.attr<double>("modThickness"),
0.5 * xModuleProperties.attr<double>("modThickness"),
0.5 * xSensorProperties.attr<double>("sensorLength")),
lcdd.material("Air"));
// place components in module
double integratedCompThickness = 0;
int componentCounter = 0;
for (DD4hep::XML::Collection_t xCompColl(xModulePropertiesComp, _U(component)); nullptr != xCompColl; ++xCompColl) {
Component xComp = static_cast<Component>(xCompColl);
Volume componentVolume("component",
DD4hep::Geometry::Trapezoid(0.5 * xModuleProperties.attr<double>("modWidthMin"),
0.5 * xModuleProperties.attr<double>("modWidthMax"),
0.5 * xComp.thickness(),
0.5 * xComp.thickness(),
0.5 * xSensorProperties.attr<double>("sensorLength")),
lcdd.material(xComp.materialStr()));
PlacedVolume placedComponentVolume = moduleVolume.placeVolume(
componentVolume,
DD4hep::Geometry::Position(
0, integratedCompThickness - 0.5 * xModuleProperties.attr<double>("modThickness"), 0));
placedComponentVolume.addPhysVolID("component", componentCounter);
componentVolume.setSensitiveDetector(sensDet);
integratedCompThickness += xComp.thickness();
++componentCounter;
}
unsigned int nPhi = xRing.attr<int>("nModules");
double lX, lY, lZ;
double phi = 0;
double phiTilt, thetaTilt;
for (unsigned int phiIndex = 0; phiIndex < nPhi; ++phiIndex) {
if (0 == phiIndex % 2) {
// the rotation for the odd module is already taken care
// of by the position in tklayout xml
phi = 2 * dd4hep::pi * static_cast<double>(phiIndex) / static_cast<double>(nPhi);
lX = xModuleEven.X();
lY = xModuleEven.Y();
lZ = xModuleEven.Z() - dimensions.zmin() - discThickness * 0.5;
phiTilt = xModuleEven.attr<double>("phiTilt");
thetaTilt = xModuleEven.attr<double>("thetaTilt");
} else {
lX = xModuleOdd.X();
lY = xModuleOdd.Y();
lZ = xModuleOdd.Z() - dimensions.zmin() - discThickness * 0.5;
phiTilt = xModuleOdd.attr<double>("phiTilt");
thetaTilt = xModuleOdd.attr<double>("thetaTilt");
}
// position module in the x-y plane, smaller end inward
// and incorporate phi tilt if any
DD4hep::Geometry::RotationY lRotation1(M_PI * 0.5);
DD4hep::Geometry::RotationX lRotation2(M_PI * 0.5 + phiTilt);
// align radially
DD4hep::Geometry::RotationZ lRotation3(atan(lY / lX));
// theta tilt, if any -- note the different convention between
// tklayout and here, thus the subtraction of pi / 2
DD4hep::Geometry::RotationY lRotation4(thetaTilt - M_PI * 0.5);
DD4hep::Geometry::RotationZ lRotation_PhiPos(phi);
// position in disk
DD4hep::Geometry::Translation3D lTranslation(lX, lY, lZ);
DD4hep::Geometry::Transform3D myTrafo(lRotation4 * lRotation3 * lRotation2 * lRotation1, lTranslation);
PlacedVolume placedModuleVolume = discVolume.placeVolume(moduleVolume, lRotation_PhiPos * myTrafo);
placedModuleVolume.addPhysVolID("module", moduleCounter);
++moduleCounter;
}
}
unsigned int discCounter = 0;
double currentZ;
for (DD4hep::XML::Collection_t xDiscColl(xDiscs, "discZPls"); nullptr != xDiscColl; ++xDiscColl) {
Component xDisc = static_cast<Component>(xDiscColl);
currentZ = xDisc.z() - dimensions.zmin() - 0.5 * (dimensions.zmax() - dimensions.zmin());
PlacedVolume placedDiscVolume = envelopeVolume.placeVolume(discVolume, DD4hep::Geometry::Position(0, 0, currentZ));
placedDiscVolume.addPhysVolID("disc", discCounter);
++discCounter;
}
// 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.zmin() - 0.5 * (dimensions.zmax() - dimensions.zmin()));
PlacedVolume placedGenericTrackerEndcap_pos = posnegEnvelopeVolume.placeVolume(
envelopeVolume,
DD4hep::Geometry::Position(0, 0, dimensions.zmin() + 0.5 * (dimensions.zmax() - dimensions.zmin())));
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;
}
/**
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;
}
void buildOneSide(MsgStream& lLog, DD4hep::Geometry::LCDD& aLcdd, DD4hep::Geometry::SensitiveDetector& aSensDet,
DD4hep::Geometry::Volume& aEnvelope, DD4hep::XML::Handle_t& aXmlElement, int sign) {
DD4hep::XML::Dimension dim(aXmlElement.child(_Unicode(dimensions)));
DD4hep::XML::DetElement active = aXmlElement.child(_Unicode(active));
std::string activeMaterial = active.materialStr();
double activeThickness = active.thickness();
DD4hep::XML::DetElement readout = aXmlElement.child(_Unicode(readout));
std::string readoutMaterial = readout.materialStr();
double readoutThickness = readout.thickness();
DD4hep::XML::DetElement passive = aXmlElement.child(_Unicode(passive));
DD4hep::XML::DetElement passiveInner = passive.child(_Unicode(inner));
DD4hep::XML::DetElement passiveOuter = passive.child(_Unicode(outer));
DD4hep::XML::DetElement passiveGlue = passive.child(_Unicode(glue));
double passiveInnerThickness = passiveInner.thickness();
double passiveOuterThickness = passiveOuter.thickness();
double passiveGlueThickness = passiveGlue.thickness();
double passiveThickness = passiveInnerThickness + passiveOuterThickness + passiveGlueThickness;
std::string passiveInnerMaterial = passiveInner.materialStr();
std::string passiveOuterMaterial = passiveOuter.materialStr();
std::string passiveGlueMaterial = passiveGlue.materialStr();
std::string passiveMaterial;
if (passiveInnerThickness < passiveThickness) {
passiveMaterial = "Air";
} else {
passiveMaterial = passiveInnerMaterial;
}
DD4hep::Geometry::SensitiveDetector sensDet = aSensDet;
DD4hep::XML::Dimension sensDetType = aXmlElement.child(_U(sensitive));
sensDet.setType(sensDetType.typeStr());
lLog << MSG::INFO << " rmin (cm) = " << dim.rmin1() << " rmin (cm) = " << dim.rmin2() << " rmax (cm) = " << dim.rmax()
<< " length (cm) = " << dim.dz() << " Sensitive volume of type: " << sensDetType.typeStr() << endmsg;
double length = dim.dz() * 2;
// First disc set is different: readout is first (HV), then half of active material, then absorber (GND)
// Next disc sets have active material on both sides
double lengthWithoutFirst = length - readoutThickness - activeThickness / 2. - passiveThickness;
uint numDiscs = floor(lengthWithoutFirst / (activeThickness + readoutThickness + passiveThickness));
double marginOutside = (lengthWithoutFirst - numDiscs * (activeThickness + readoutThickness + passiveThickness)) / 2.;
// add the first disc set to the number of all discs
numDiscs += 1;
lLog << MSG::INFO << "Thickness of active material in between absorbers (cm) = " << activeThickness
<< "\nThickness of absorber discs (cm) = " << passiveThickness
<< "\nThickness of readout disc placed in between absorber plates (cm) = " << readoutThickness
<< "\nNumber of absorber/readout discs: " << numDiscs
<< "\nMargin outside first readout disc and last absorber disc, filled with non-sensitive active medium (cm) = "
<< marginOutside << endmsg;
lLog << MSG::INFO << "Detector length: (cm) " << length << endmsg;
// Place components starting from closer to the collision-point
double zOffset = (length / 2. - marginOutside) * -sign;
double rMax = dim.rmax();
// First disc to place is readout
zOffset += sign * (readoutThickness / 2.);
double nonAbsorberRmin = std::min(dim.rmin1(), dim.rmin2());
double tanTheta = fabs(dim.rmin2() - dim.rmin1()) / (2 * dim.dz());
nonAbsorberRmin +=
(marginOutside + readoutThickness + activeThickness / 2.) * tanTheta; // for first readout position
double dR1 = passiveThickness * tanTheta; // between readout and passive
double dR2 = (activeThickness + readoutThickness + passiveThickness) * tanTheta; // between two readout discs
DD4hep::Geometry::Tube readoutShapePre(nonAbsorberRmin, rMax, readoutThickness / 2.);
DD4hep::Geometry::Tube activeShapePre(nonAbsorberRmin, rMax, activeThickness / 4.);
DD4hep::Geometry::Volume readoutVolPre("readoutPre", readoutShapePre, aLcdd.material(readoutMaterial));
if (readout.isSensitive()) {
lLog << MSG::INFO << "Readout volume set as sensitive" << endmsg;
readoutVolPre.setSensitiveDetector(aSensDet);
}
DD4hep::Geometry::Volume activeVolPre("activePre", activeShapePre, aLcdd.material(activeMaterial));
activeVolPre.setSensitiveDetector(sensDet);
DD4hep::Geometry::PlacedVolume readoutPhysVolPre =
aEnvelope.placeVolume(readoutVolPre, DD4hep::Geometry::Position(0, 0, zOffset));
readoutPhysVolPre.addPhysVolID("layer", 0);
readoutPhysVolPre.addPhysVolID("type", 2); // 0 = active, 1 = passive, 2 = readout
std::vector<DD4hep::Geometry::PlacedVolume> activePhysVols;
activePhysVols.reserve(numDiscs * 2);
activePhysVols.push_back(aEnvelope.placeVolume(
activeVolPre, DD4hep::Geometry::Position(0, 0, zOffset + sign * (readoutThickness / 2. + activeThickness / 4.))));
lLog << MSG::DEBUG << "Placing first readout at " << zOffset
<< " and active at z= " << zOffset + sign * (activeThickness / 4. + readoutThickness / 2.) << endmsg;
// Now place complete sets of discs: absorber|active|readout|active
zOffset += sign * (readoutThickness / 2. + activeThickness / 2. + passiveThickness / 2.);
// Loop placing readout, active and passive discs
for (uint iDiscs = 0; iDiscs < numDiscs - 1; iDiscs++) {
nonAbsorberRmin += dR2;
// readout and active discs have the same radius, but different thickness
DD4hep::Geometry::Tube activeShapeBeforeSubtraction(nonAbsorberRmin, rMax,
activeThickness / 2. + readoutThickness / 2.);
DD4hep::Geometry::Tube readoutShape(nonAbsorberRmin, rMax, readoutThickness / 2.);
DD4hep::Geometry::SubtractionSolid activeShape(activeShapeBeforeSubtraction, readoutShape);
DD4hep::Geometry::Tube passiveShape(nonAbsorberRmin + dR1, rMax, passiveThickness / 2.);
DD4hep::Geometry::Volume activeVol("active", activeShape, aLcdd.material(activeMaterial));
DD4hep::Geometry::Volume readoutVol("readout", readoutShape, aLcdd.material(readoutMaterial));
DD4hep::Geometry::Volume passiveVol("passive", passiveShape, aLcdd.material(passiveMaterial));
activeVol.setSensitiveDetector(sensDet);
if (readout.isSensitive()) {
lLog << MSG::DEBUG << "Passive inner volume set as sensitive" << endmsg;
readoutVol.setSensitiveDetector(aSensDet);
}
if (passive.isSensitive()) {
lLog << MSG::DEBUG << "Passive volume set as sensitive" << endmsg;
passiveVol.setSensitiveDetector(aSensDet);
}
// absorber may consist of inner and outer material
if (passiveInnerThickness < passiveThickness) {
// create shapes
DD4hep::Geometry::Tube passiveInnerShape(nonAbsorberRmin + dR1, rMax, passiveInnerThickness / 2.);
DD4hep::Geometry::Tube passiveGlueShape(nonAbsorberRmin + dR1, rMax, passiveGlueThickness / 4.);
DD4hep::Geometry::Tube passiveOuterShape(nonAbsorberRmin + dR1, rMax, passiveOuterThickness / 4.);
// create volumes
DD4hep::Geometry::Volume passiveInnerVol(passiveInnerMaterial + "_passive", passiveInnerShape,
aLcdd.material(passiveInnerMaterial));
DD4hep::Geometry::Volume passiveOuterVol(passiveOuterMaterial + "_passive", passiveOuterShape,
aLcdd.material(passiveOuterMaterial));
DD4hep::Geometry::Volume passiveGlueVol(passiveGlueMaterial + "_passive", passiveGlueShape,
aLcdd.material(passiveGlueMaterial));
if (passive.isSensitive()) {
lLog << MSG::INFO << "Passive volumes (inner, outer, glue) set as sensitive" << endmsg;
passiveInnerVol.setSensitiveDetector(aSensDet);
passiveOuterVol.setSensitiveDetector(aSensDet);
passiveGlueVol.setSensitiveDetector(aSensDet);
}
// place volumes
DD4hep::Geometry::PlacedVolume passiveInnerPhysVol =
passiveVol.placeVolume(passiveInnerVol, DD4hep::Geometry::Position(0, 0, 0));
DD4hep::Geometry::PlacedVolume passiveOuterPhysVolBelow = passiveVol.placeVolume(
passiveOuterVol,
DD4hep::Geometry::Position(0, 0, passiveInnerThickness / 2. + passiveGlueThickness / 2. +
passiveOuterThickness / 4.));
DD4hep::Geometry::PlacedVolume passiveOuterPhysVolAbove = passiveVol.placeVolume(
passiveOuterVol,
DD4hep::Geometry::Position(0, 0, -passiveInnerThickness / 2. - passiveGlueThickness / 2. -
passiveOuterThickness / 4.));
DD4hep::Geometry::PlacedVolume passiveGluePhysVolBelow = passiveVol.placeVolume(
passiveGlueVol, DD4hep::Geometry::Position(0, 0, -passiveInnerThickness / 2. - passiveGlueThickness / 4.));
DD4hep::Geometry::PlacedVolume passiveGluePhysVolAbove = passiveVol.placeVolume(
passiveGlueVol, DD4hep::Geometry::Position(0, 0, passiveInnerThickness / 2. + passiveGlueThickness / 4.));
passiveInnerPhysVol.addPhysVolID("subtype", 0);
passiveOuterPhysVolBelow.addPhysVolID("subtype", 1);
passiveOuterPhysVolAbove.addPhysVolID("subtype", 2);
passiveGluePhysVolBelow.addPhysVolID("subtype", 3);
passiveGluePhysVolAbove.addPhysVolID("subtype", 4);
}
DD4hep::Geometry::PlacedVolume passivePhysVol =
aEnvelope.placeVolume(passiveVol, DD4hep::Geometry::Position(0, 0, zOffset));
passivePhysVol.addPhysVolID("layer", iDiscs);
passivePhysVol.addPhysVolID("type", 1); // 0 = active, 1 = passive, 2 = readout
DD4hep::Geometry::PlacedVolume readoutPhysVol = aEnvelope.placeVolume(
readoutVol,
DD4hep::Geometry::Position(0, 0, zOffset +
sign * (passiveThickness / 2. + activeThickness / 2. + readoutThickness / 2.)));
readoutPhysVol.addPhysVolID("layer", iDiscs + 1); // +1 because first readout is placed before that loop
readoutPhysVol.addPhysVolID("type", 2); // 0 = active, 1 = passive, 2 = readout
activePhysVols.push_back(aEnvelope.placeVolume(
activeVol,
DD4hep::Geometry::Position(0, 0, zOffset +
sign * (passiveThickness / 2. + activeThickness / 2. + readoutThickness / 2.))));
lLog << MSG::DEBUG << "Placing passive at z= " << zOffset
<< " readout at z= " << zOffset + sign * (passiveThickness / 2. + activeThickness / 2. + readoutThickness / 2.)
<< " active at " << zOffset + sign * (passiveThickness / 2. + activeThickness / 2. + readoutThickness / 2.)
<< endmsg;
zOffset += sign * (readoutThickness + activeThickness + passiveThickness);
if (iDiscs == numDiscs - 2) {
// finish detector with the last disc of abosrber (for GND layer)
DD4hep::Geometry::PlacedVolume passivePhysVolPost =
aEnvelope.placeVolume(passiveVol, DD4hep::Geometry::Position(0, 0, zOffset));
passivePhysVolPost.addPhysVolID("layer", iDiscs + 1);
passivePhysVolPost.addPhysVolID("type", 2); // 0 = active, 1 = passive, 2 = readout
lLog << MSG::DEBUG << "Placing last passive disc at z= " << zOffset << endmsg;
}
for (uint iActive = 0; iActive < activePhysVols.size(); iActive++) {
activePhysVols[iActive].addPhysVolID("layer", iActive + 1); // +1 because first active is placed before that loop
activePhysVols[iActive].addPhysVolID("type", 0); // 0 = active, 1 = passive, 2 = readout
}
}
return;
}