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 createHCal (
DD4hep::Geometry::LCDD& lcdd,
xml_h xmlElement,
DD4hep::Geometry::SensitiveDetector sensDet
) {
// Get the Gaudi message service and message stream:
ServiceHandle<IMessageSvc> msgSvc("MessageSvc", "HCalConstruction");
MsgStream lLog(&(*msgSvc), "HCalConstruction");
xml_det_t xmlDet = xmlElement;
std::string detName = xmlDet.nameStr();
//Make DetElement
DetElement hCal(detName, xmlDet.id());
// Get status for the RecoGeometry what is status?
// xml_comp_t xmlStatus = xmlDet.child(_U(status));
// int status = xmlStatus.id();
// add Extension to Detlement for the RecoGeometry
// Let's skip this for now...
// Det::DetCylinderVolume* detVolume = new Det::DetCylinderVolume(status);
// hCal.addExtension<Det::IDetExtension>(detVolume);
// Make volume that envelopes the whole barrel; set material to air
Dimension dimensions(xmlDet.dimensions());
DD4hep::Geometry::Tube envelopeShape(dimensions.rmin(), dimensions.rmax(), dimensions.dz());
Volume envelopeVolume(detName, envelopeShape, lcdd.air());
// Invisibility seems to be broken in visualisation tags, have to hardcode that
// envelopeVolume.setVisAttributes(lcdd, dimensions.visStr());
envelopeVolume.setVisAttributes(lcdd.invisible());
// set the sensitive detector type to the DD4hep calorimeter
sensDet.setType("SimpleCalorimeterSD");
// Add structural support made of steel inside of HCal
xml_comp_t xFacePlate = xmlElement.child("face_plate");
double dRhoFacePlate = xFacePlate.thickness();
double sensitiveBarrelRmin = dimensions.rmin() + dRhoFacePlate;
DetElement facePlate("facePlate", 0);
DD4hep::Geometry::Tube facePlateShape(dimensions.rmin(), sensitiveBarrelRmin, dimensions.dz());
Volume facePlateVol("facePlate", facePlateShape, lcdd.material(xFacePlate.materialStr()));
facePlateVol.setVisAttributes(lcdd, xFacePlate.visStr());
PlacedVolume placedFacePlate = envelopeVolume.placeVolume(facePlateVol);
placedFacePlate.addPhysVolID("facePlate", facePlate.id());
facePlate.setPlacement(placedFacePlate);
// Add structural support made of steel at both ends of HCal
xml_comp_t xEndPlate = xmlElement.child("end_plate");
double dZEndPlate = xEndPlate.thickness();
DD4hep::Geometry::Tube endPlateShape(dimensions.rmin(), dimensions.rmax(), dZEndPlate);
Volume endPlateVol("endPlate", endPlateShape, lcdd.material(xEndPlate.materialStr()));
endPlateVol.setVisAttributes(lcdd, xEndPlate.visStr());
DetElement endPlatePos("endPlate", 0);
DD4hep::Geometry::Position posOffset(0, 0, dimensions.dz() - dZEndPlate);
PlacedVolume placedEndPlatePos = envelopeVolume.placeVolume(endPlateVol, posOffset);
placedEndPlatePos.addPhysVolID("endPlatePos", endPlatePos.id());
endPlatePos.setPlacement(placedEndPlatePos);
DetElement endPlateNeg("endPlate", 1);
DD4hep::Geometry::Position negOffset(0, 0, -dimensions.dz() + dZEndPlate);
PlacedVolume placedEndPlateNeg = envelopeVolume.placeVolume(endPlateVol, negOffset);
placedEndPlateNeg.addPhysVolID("endPlateNeg", endPlateNeg.id());
endPlateNeg.setPlacement(placedEndPlateNeg);
// Hard-coded assumption that we have two different sequences for the modules
std::vector<xml_comp_t> sequences = {xmlElement.child("sequence_a"), xmlElement.child("sequence_b")};
// NOTE: This assumes that both have the same dimensions!
Dimension moduleDimensions(sequences[0].dimensions());
double dzModule = moduleDimensions.dz();
// calculate the number of modules fitting in phi, Z and Rho
unsigned int numModulesPhi = moduleDimensions.phiBins();
unsigned int numModulesZ = static_cast<unsigned>(dimensions.dz() / dzModule);
unsigned int numModulesR = static_cast<unsigned>((dimensions.rmax() - sensitiveBarrelRmin) / moduleDimensions.dr());
lLog << MSG::DEBUG << "constructing " << numModulesPhi << " modules per ring in phi, "
<< numModulesZ << " rings in Z, "
<< numModulesR << " rings (layers) in Rho"
<< numModulesR*numModulesZ*numModulesPhi << " modules" << endmsg;
// Calculate correction along z based on the module size (can only have natural number of modules)
double dzDetector = numModulesZ * dzModule + dZEndPlate;
lLog << MSG::INFO << "correction of dz:" << dimensions.dz() - dzDetector << endmsg;
// calculate the dimensions of one module:
double dphi = 2 * dd4hep::pi / static_cast<double>(numModulesPhi);
double tn = tan(dphi / 2.);
double spacing = moduleDimensions.x();
double dy0 = moduleDimensions.dz();
double dz0 = moduleDimensions.dr() / 2.;
double drWedge = cos(dphi / 2.) * (dimensions.rmax() - sensitiveBarrelRmin) * 0.5;
double dxWedge1 = tn * sensitiveBarrelRmin - spacing;
double dxWedge2 = tn * cos(dphi / 2.) * dimensions.rmax() - spacing;
// First we construct one wedge with width of one module:
Volume subWedgeVolume("subWedge", DD4hep::Geometry::Trapezoid(
dxWedge1, dxWedge2, dzModule, dzModule, drWedge
), lcdd.material("Air")
);
for (unsigned int idxLayer = 0; idxLayer < numModulesR; ++idxLayer) {
auto layerName = std::string("wedge") + DD4hep::XML::_toString(idxLayer, "layer%d");
unsigned int sequenceIdx = idxLayer % 2;
double rminLayer = idxLayer * moduleDimensions.dr();
double rmaxLayer = (idxLayer + 1) * cos(dphi / 2.) * moduleDimensions.dr();
double dx1 = tn * (rminLayer + sensitiveBarrelRmin) - spacing;
double dx2 = tn * cos(dphi / 2.) * (rmaxLayer + sensitiveBarrelRmin) - spacing;
// -drWedge to place it in the middle of the wedge-volume
double rMiddle = rminLayer + 0.5 * moduleDimensions.dr() - drWedge;
Volume moduleVolume(layerName, DD4hep::Geometry::Trapezoid(
dx1, dx2, dy0, dy0, dz0
), lcdd.material("Air")
);
moduleVolume.setVisAttributes(lcdd.invisible());
unsigned int idxSubMod = 0;
// DetElement moduleDet(wedgeDet, layerName, idxLayer);
double modCompZOffset = -moduleDimensions.dz();
for (xml_coll_t xCompColl(sequences[sequenceIdx], _U(module_component)); xCompColl; ++xCompColl, ++idxSubMod) {
xml_comp_t xComp = xCompColl;
std::string subModuleName = layerName+DD4hep::XML::_toString(idxSubMod, "module_component%d");
double dyComp = xComp.thickness();
Volume modCompVol(subModuleName, DD4hep::Geometry::Trapezoid(
dx1, dx2, dyComp, dyComp, dz0
), lcdd.material(xComp.materialStr())
);
if (xComp.isSensitive()) {
modCompVol.setSensitiveDetector(sensDet);
}
modCompVol.setVisAttributes(lcdd, xComp.visStr());
// modCompVol.setVisAttributes(lcdd.invisible());
// DetElement modCompDet(wedgeDet, subModuleName, idxSubMod);
DD4hep::Geometry::Position offset(0, modCompZOffset + dyComp + xComp.y_offset()*2, 0);
PlacedVolume placedModCompVol = moduleVolume.placeVolume(modCompVol, offset);
placedModCompVol.addPhysVolID("sub_module", idxSubMod);
// modCompDet.setPlacement(placedModCompVol);
modCompZOffset += xComp.thickness()*2 + xComp.y_offset()*2;
}
DD4hep::Geometry::Position modOffset(0, 0, rMiddle);
PlacedVolume placedModuleVol = subWedgeVolume.placeVolume(moduleVolume, modOffset);
placedModuleVol.addPhysVolID("layer", idxLayer);
// moduleDet.setPlacement(placedModuleVol);
}
// Now we place the components along z within the wedge
Volume wedgeVolume("wedge", DD4hep::Geometry::Trapezoid(
dxWedge1, dxWedge2, dzDetector, dzDetector, drWedge
), lcdd.material("Air")
);
wedgeVolume.setVisAttributes(lcdd.invisible());
for (unsigned int idxZRow = 0; idxZRow < numModulesZ; ++idxZRow) {
double zOffset = -dzDetector + dZEndPlate * 2 + (2*idxZRow + 1) * dzModule;
auto wedgeRowName = DD4hep::XML::_toString(idxZRow, "row%d");
DD4hep::Geometry::Position wedgeOffset(0, zOffset, 0);
PlacedVolume placedRowVolume = wedgeVolume.placeVolume(subWedgeVolume, wedgeOffset);
placedRowVolume.addPhysVolID("row", idxZRow);
// wedgeDet.setPlacement(placedWedgeVol);
}
// Finally we place all the wedges around phi
for (unsigned int idxPhi = 0; idxPhi < numModulesPhi; ++idxPhi) {
auto modName = DD4hep::XML::_toString(idxPhi, "mod%d");
// Volume and DetElement for one row in Z
DetElement wedgeDet(hCal, modName, idxPhi);
// moduleVolume.setVisAttributes(lcdd, sequences[sequenceIdx].visStr());
// moduleVolume.setVisAttributes(lcdd.invisible());
// calculate position and rotation of this wedge;
// first rotation due to default rotation of trapezoid
double phi = 0.5 * dphi - idxPhi * dphi; // 0.5*dphi for middle of module
double yPosModule = (sensitiveBarrelRmin + drWedge) * cos(phi);
double xPosModule = (sensitiveBarrelRmin + drWedge) * sin(phi);
DD4hep::Geometry::Position moduleOffset(xPosModule, yPosModule, 0);
DD4hep::Geometry::Transform3D trans(
DD4hep::Geometry::RotationX(-0.5*dd4hep::pi)*
DD4hep::Geometry::RotationY(phi),
moduleOffset
);
PlacedVolume placedWedgeVol = envelopeVolume.placeVolume(wedgeVolume, trans);
placedWedgeVol.addPhysVolID("wedge", idxPhi);
wedgeDet.setPlacement(placedWedgeVol);
}
//Place envelope (or barrel) volume
Volume motherVol = lcdd.pickMotherVolume(hCal);
PlacedVolume placedHCal = motherVol.placeVolume(envelopeVolume);
placedHCal.addPhysVolID("system", hCal.id());
hCal.setPlacement(placedHCal);
return hCal;
}
/**
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 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;
}