ATLAS Offline Software
Public Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
ActsTrk::MuonDetectorBuilderTool Class Reference

#include <MuonDetectorBuilderTool.h>

Inheritance diagram for ActsTrk::MuonDetectorBuilderTool:
Collaboration diagram for ActsTrk::MuonDetectorBuilderTool:

Public Member Functions

virtual ~MuonDetectorBuilderTool ()=default
 
StatusCode initialize () override final
 
Acts::Experimental::DetectorComponent construct (const Acts::GeometryContext &context) const override final
 

Private Types

using MaterialPtr = GeoIntrusivePtr< const GeoMaterial >
 

Private Member Functions

void processPassiveNodes (const ActsGeometryContext &gctx, const GeoChildNodeWithTrf &node, const std::string &name, std::vector< std::shared_ptr< Acts::Experimental::DetectorVolume >> &passiveVolumes, const GeoTrf::Transform3D &transform, Acts::VolumeBoundFactory &boundFactory) const
 
std::shared_ptr< Acts::Surface > getChamberMaterial (const MuonGMR4::Chamber &chamber, const Amg::Transform3D &chamberTransform, const int totalMaterials, Acts::SurfaceBoundFactory &boundSet) const
 
std::pair< std::vector< std::shared_ptr< Acts::Experimental::DetectorVolume > >, std::vector< std::shared_ptr< Acts::Surface > > > constructElements (const ActsGeometryContext &gctx, const MuonGMR4::Chamber &mChamber, std::pair< unsigned int, unsigned int > chId) const
 
bool checkDummyMaterial (const PVConstLink &vol) const
 
void getMaterialContent (const PVConstLink &vol, std::vector< std::pair< MaterialPtr, double >> &materialContent) const
 
std::pair< MaterialPtr, double > getMaterial (const PVConstLink &vol) const
 

Private Attributes

const MuonGMR4::MuonDetectorManager * m_detMgr {nullptr}
 
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc {this, "IdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
 
Gaudi::Property< bool > m_dumpDetector {this, "dumpDetector", false, "If set to true the entire MS system are dumped into a visualization file format, will take a long time with sensitives"}
 
Gaudi::Property< bool > m_dumpPassive {this, "dumpPassive", false, "If set to true the passive volumes are dumped into a visualization file format"}
 
Gaudi::Property< bool > m_dumpDetectorVolumes {this, "dumpDetectorVolumes", false, "If set to true the detector volumes are dumped into a visualization file format, will take a long time with sensitives"}
 
Gaudi::Property< bool > m_dumpMaterialSurfaces {this, "dumpMaterialSurfaces", false, "If set to true the material surfaces are dumped into a visualization file format"}
 
Gaudi::Property< bool > m_buildSensitives {this, "BuildSensitives", true, "If set to true all sensitive elements are built"}
 

Detailed Description

Definition at line 20 of file MuonDetectorBuilderTool.h.

Member Typedef Documentation

◆ MaterialPtr

using ActsTrk::MuonDetectorBuilderTool::MaterialPtr = GeoIntrusivePtr<const GeoMaterial>
private

Definition at line 67 of file MuonDetectorBuilderTool.h.

Constructor & Destructor Documentation

◆ ~MuonDetectorBuilderTool()

virtual ActsTrk::MuonDetectorBuilderTool::~MuonDetectorBuilderTool ( )
virtualdefault

Member Function Documentation

◆ checkDummyMaterial()

bool ActsTrk::MuonDetectorBuilderTool::checkDummyMaterial ( const PVConstLink &  vol) const
private

Definition at line 316 of file MuonDetectorBuilderTool.cxx.

316  {
317  static const std::unordered_set<std::string> dummyMaterials{
318  "special::Ether",
319  "WorldLog::Air",
320  "std::Air",
321  "Air"
322  };
323  const std::string materialName = vol->getLogVol()->getMaterial()->getName();
324  return dummyMaterials.find(materialName) != dummyMaterials.end();
325  }

◆ construct()

Acts::Experimental::DetectorComponent ActsTrk::MuonDetectorBuilderTool::construct ( const Acts::GeometryContext &  context) const
finaloverride

Definition at line 75 of file MuonDetectorBuilderTool.cxx.

75  {
76  ATH_MSG_DEBUG("Building Muon Detector Volume");
77  const MuonChamberSet chambers = m_detMgr->getAllChambers();
78  const ActsGeometryContext* gctx = context.get<const ActsGeometryContext* >();
79  std::vector< volumePtr > detectorVolumeBoundingVolumes{};
80  std::vector< volumePtr > detectorVolumePassiveVolumes{};
81 
82  detectorVolumeBoundingVolumes.reserve(chambers.size());
83  std::vector<surfacePtr> surfaces{};
84  std::vector<surfacePtr> materialSurfaces{};
85 
86  auto portalGenerator = Acts::Experimental::defaultPortalAndSubPortalGenerator();
87  unsigned int numChambers = chambers.size();
88 
89  Acts::SurfaceBoundFactory materialBounds{};
90  for(const MuonGMR4::Chamber* chamber : chambers){
91  unsigned int num = 0;
92  //Gather the passives in each chamber
93  surfacePtr material{getChamberMaterial(*chamber, chamber->localToGlobalTrans(*gctx), materialSurfaces.size(), materialBounds)};
94  std::shared_ptr<Acts::TrapezoidVolumeBounds> bounds = chamber->bounds();
95  materialSurfaces.push_back(material);
96  std::pair<std::vector<volumePtr>, std::vector<surfacePtr>> readoutElements =
97  constructElements(*gctx, *chamber, std::make_pair(numChambers,num));
98  readoutElements.second.push_back(material);
99  volumePtr detectorVolume = Acts::Experimental::DetectorVolumeFactory::construct(portalGenerator,
100  gctx->context(),
101  chamber->identString(),
102  chamber->localToGlobalTrans(*gctx),
103  bounds, readoutElements.second,
104  readoutElements.first,
105  Acts::Experimental::tryAllSubVolumes(),
106  Acts::Experimental::tryAllPortalsAndSurfaces());
107 
108  detectorVolume->assignGeometryId(Acts::GeometryIdentifier{}.withLayer(numChambers--));
109  if(m_dumpDetectorVolumes){
110  //If we want to view each volume independently
111  Acts::ObjVisualization3D helper;
112  Acts::GeometryView3D::drawDetectorVolume(helper, *detectorVolume, gctx->context());
113  helper.write(objFileName(chamber->identString()));
114  helper.clear();
115  }
116  detectorVolumeBoundingVolumes.push_back(std::move(detectorVolume));
117  readoutElements.first.clear();
118  readoutElements.second.clear();
119  }
120 
121  if(m_dumpMaterialSurfaces){
122  Acts::ObjVisualization3D helper;
123  for (const auto& surf : materialSurfaces){
124  Acts::GeometryView3D::drawSurface(helper, *surf, gctx->context());
125  }
126  helper.write("materialSurfaces.obj");
127  helper.clear();
128  }
129 
130  ATH_MSG_VERBOSE("Number of detector volumes: "<< detectorVolumeBoundingVolumes.size());
131  ATH_MSG_VERBOSE("Number of chamber passives volumes: "<< detectorVolumePassiveVolumes.size());
132  std::vector<GeoChildNodeWithTrf> childNodes = getChildrenWithRef(m_detMgr->getTreeTop(0), false);
133  std::set<std::string> skipNodes{"MuonBarrel", "NSW", "MuonEndcap_sideA", "MuonEndcap_sideC","TGCSystem"};
134  for (const GeoChildNodeWithTrf& node : childNodes){
135  //These are taken care of in the chambers
136  if(skipNodes.count(node.nodeName)) {
137  ATH_MSG_VERBOSE("Skipping volume "<<node.nodeName);
138  continue;
139  }
140  ATH_MSG_VERBOSE("Processing passive node "<<node.nodeName);
141  // processPassiveNodes(*gctx, node, node.nodeName, detectorVolumePassiveVolumes, node.transform);
142  }
143  ATH_MSG_VERBOSE("Number of total passive volumes: "<< detectorVolumePassiveVolumes.size());
144 
145  if (m_dumpPassive){
146  ATH_MSG_VERBOSE("Writing passiveVolumes.obj");
147  Acts::ObjVisualization3D helper;
148  for (const auto& vol : detectorVolumePassiveVolumes){
149  Acts::GeometryView3D::drawDetectorVolume(helper, *vol, gctx->context());
150  }
151  helper.write(objFileName("passiveVolumes"));
152  helper.clear();
153  }
154 
155  //Add the passive volumes to the end of detectorVolumeBoundingVolumes
156  detectorVolumeBoundingVolumes.insert(detectorVolumeBoundingVolumes.end(), detectorVolumePassiveVolumes.begin(), detectorVolumePassiveVolumes.end());
157 
158  std::unique_ptr<Acts::CutoutCylinderVolumeBounds> msBounds = std::make_unique<Acts::CutoutCylinderVolumeBounds>(0, 4000, 14500, 22500, 3200);
159  volumePtr msDetectorVolume = Acts::Experimental::DetectorVolumeFactory::construct(
160  portalGenerator, gctx->context(), "Muon Spectrometer Envelope",
161  Acts::Transform3::Identity(), std::move(msBounds), surfaces,
162  detectorVolumeBoundingVolumes, Acts::Experimental::tryAllSubVolumes(),
163  Acts::Experimental::tryAllPortalsAndSurfaces());
164  msDetectorVolume->assignGeometryId(Acts::GeometryIdentifier{}.withVolume(15));
165 
166  if (m_dumpDetector) {
167  ATH_MSG_VERBOSE("Writing detector.obj");
168  Acts::ObjVisualization3D helper;
169  Acts::GeometryView3D::drawDetectorVolume(helper, *msDetectorVolume, gctx->context());
170  helper.write(objFileName("detector"));
171  helper.clear();
172  }
173 
174  Acts::Experimental::DetectorComponent::PortalContainer portalContainer;
175  for (auto [ip, p] : Acts::enumerate(msDetectorVolume->portalPtrs())) {
176  portalContainer[ip] = p;
177  }
178  detectorVolumeBoundingVolumes.push_back(msDetectorVolume);
179  return Acts::Experimental::DetectorComponent{
180  {detectorVolumeBoundingVolumes},
181  portalContainer,
182  {{msDetectorVolume}, Acts::Experimental::tryAllSubVolumes()}};
183  }

◆ constructElements()

std::pair< std::vector< volumePtr >, std::vector< surfacePtr > > ActsTrk::MuonDetectorBuilderTool::constructElements ( const ActsGeometryContext &  gctx,
const MuonGMR4::Chamber &  mChamber,
std::pair< unsigned int, unsigned int >  chId 
) const
private

Definition at line 186 of file MuonDetectorBuilderTool.cxx.

188  {
189 
190  std::vector<volumePtr> readoutDetectorVolumes{};
191  std::vector<surfacePtr> readoutSurfaces{};
192  if(!m_buildSensitives) return std::make_pair(readoutDetectorVolumes, readoutSurfaces);
193  Acts::GeometryIdentifier::Value surfId{1};
194  Acts::GeometryIdentifier::Value mdtId{1};
195 
196  const MuonGMR4::Chamber::ReadoutSet& readoutElements = mChamber.readoutEles();
197 
198  for(const MuonGMR4::MuonReadoutElement* ele : readoutElements){
199  switch (ele->detectorType()) {
200  case DetectorType::Mdt: {
201  ATH_MSG_VERBOSE("Building MultiLayer for MDT Detector Volume");
202  const auto* mdtReadoutEle = static_cast<const MuonGMR4::MdtReadoutElement*>(ele);
203  const MuonGMR4::MdtReadoutElement::parameterBook& parameters{mdtReadoutEle->getParameters()};
204  std::vector<surfacePtr> surfaces{};
205  //loop over the tubes to get the surfaces
206  for(unsigned int lay=1; lay<=mdtReadoutEle->numLayers(); ++lay){
207  for(unsigned int tube=1; tube<=mdtReadoutEle->numTubesInLay(); ++tube){
208  const IdentifierHash measHash{mdtReadoutEle->measurementHash(lay,tube)};
209  if (!mdtReadoutEle->isValid(measHash)) continue;
210  surfacePtr surface = mdtReadoutEle->surfacePtr(measHash);
211  surface->assignGeometryId(Acts::GeometryIdentifier{}.withLayer(chId.first).withVolume(chId.second).withBoundary(mdtId).withSensitive(++surfId));
212  surfaces.push_back(surface);
213  }
214  }
215 
216  //Get the transformation to the chamber's frame
217  const Amg::Vector3D toChamber = mChamber.globalToLocalTrans(gctx)*mdtReadoutEle->center(gctx);
218  const Acts::Transform3 mdtTransform = mChamber.localToGlobalTrans(gctx) * Amg::getTranslate3D(toChamber);
219 
220  Acts::Experimental::MultiWireStructureBuilder::Config mlCfg{};
221  mlCfg.name = m_idHelperSvc->toStringDetEl(mdtReadoutEle->identify());
222  mlCfg.mlSurfaces = std::move(surfaces);
223  mlCfg.transform = mdtTransform;
224  auto mdtBounds = std::make_unique<Acts::TrapezoidVolumeBounds>(parameters.shortHalfX, parameters.longHalfX, parameters.halfY, parameters.halfHeight);
225  using BoundsV = Acts::TrapezoidVolumeBounds::BoundValues;
226  mlCfg.mlBounds= mdtBounds->values();
227 
228  mlCfg.mlBinning = {{{Acts::AxisDirection::AxisY, Acts::AxisBoundaryType::Bound,
229  -mdtBounds->get(BoundsV::eHalfLengthY),
230  mdtBounds->get(BoundsV::eHalfLengthY),
231  static_cast<std::size_t>(std::lround(2*mdtBounds->get(BoundsV::eHalfLengthY)/parameters.tubePitch))}, 2u},
232  {{Acts::AxisDirection::AxisZ, Acts::AxisBoundaryType::Bound,
233  -mdtBounds->get(BoundsV::eHalfLengthZ),
234  mdtBounds->get(BoundsV::eHalfLengthZ),
235  static_cast<std::size_t>(std::lround(2*mdtBounds->get(BoundsV::eHalfLengthZ)/parameters.tubePitch))}, 1u}};
236 
237  Acts::Experimental::MultiWireStructureBuilder mdtBuilder(mlCfg);
238  volumePtr mdtVolume = mdtBuilder.construct(gctx.context()).volumes[0];
239  mdtVolume->assignGeometryId(Acts::GeometryIdentifier{}.withLayer(chId.first).withVolume(chId.second).withBoundary(mdtId++));
240  readoutDetectorVolumes.push_back(mdtVolume);
241  break;
242  } case DetectorType::Rpc:
243  case DetectorType::Tgc:
244  case DetectorType::sTgc:
245  case DetectorType::Mm: {
246  ATH_MSG_VERBOSE("Building plane surfaces "<<m_idHelperSvc->toStringDetEl(ele->identify()));
247  std::vector<surfacePtr> detSurfaces = ele->getSurfaces();
248  for (surfacePtr& surf : detSurfaces) {
249  surf->assignGeometryId(Acts::GeometryIdentifier{}.withLayer(chId.first).withVolume(chId.second).withSensitive(++surfId));
250  readoutSurfaces.push_back(std::move(surf));
251  }
252  break;
253  } default:
254  THROW_EXCEPTION("Unknown detector type "<<ActsTrk::to_string(ele->detectorType()));
255  }
256  }
257 
258  return std::make_pair(std::move(readoutDetectorVolumes), std::move(readoutSurfaces));
259 
260  }

◆ getChamberMaterial()

surfacePtr ActsTrk::MuonDetectorBuilderTool::getChamberMaterial ( const MuonGMR4::Chamber &  chamber,
const Amg::Transform3D &  chamberTransform,
const int  totalMaterials,
Acts::SurfaceBoundFactory &  boundSet 
) const
private

Definition at line 262 of file MuonDetectorBuilderTool.cxx.

265  {
266  auto bounds = boundSet.makeBounds<Acts::TrapezoidBounds>(chamber.halfXShort(), chamber.halfXLong(), chamber.halfY());
267  const float thickness = chamber.halfZ() * 2;
268  PVConstLink parentVolume = chamber.readoutEles().front()->getMaterialGeom()->getParent();
269  std::pair<MaterialPtr, double> geoMaterials = getMaterial(parentVolume);
270  const Acts::Material aMat = Acts::GeoModel::geoMaterialConverter(*geoMaterials.first);
271  //rotate about the z axis
272  std::shared_ptr<Acts::PlaneSurface> surface = Acts::Surface::makeShared<Acts::PlaneSurface>(chamberTransform, bounds);
273  Acts::MaterialSlab slab{aMat, thickness};
274  std::shared_ptr<Acts::HomogeneousSurfaceMaterial> material = std::make_shared<Acts::HomogeneousSurfaceMaterial>(slab);
275  surface->assignSurfaceMaterial(material);
276  surface->assignGeometryId(Acts::GeometryIdentifier{}.withVolume(29).withSensitive(totalMaterials));
277  return surface;
278  }

◆ getMaterial()

std::pair< MuonDetectorBuilderTool::MaterialPtr, double > ActsTrk::MuonDetectorBuilderTool::getMaterial ( const PVConstLink &  vol) const
private

Definition at line 281 of file MuonDetectorBuilderTool.cxx.

281  {
282  std::vector<std::pair<MaterialPtr, double>> materialContent{};
283  getMaterialContent(vol, materialContent);
284 
285  //blend the material
286  double totalVolume{0.};
287  double totalMass{0.};
288  for(const auto& [material, volume] : materialContent){
289  totalVolume += volume;
290  totalMass += volume * material->getDensity();
291  }
292 
293  //create the new GeoMaterial object
294  auto blendedMaterial = make_intrusive<GeoMaterial>("BlendedMaterial", totalMass/totalVolume);
295  for(const auto& [material, volume] : materialContent){
296  blendedMaterial->add(material, material->getDensity() * volume / totalMass);
297  }
298  blendedMaterial->lock();
299  return {blendedMaterial, totalVolume};
300  }

◆ getMaterialContent()

void ActsTrk::MuonDetectorBuilderTool::getMaterialContent ( const PVConstLink &  vol,
std::vector< std::pair< MaterialPtr, double >> &  materialContent 
) const
private

Definition at line 302 of file MuonDetectorBuilderTool.cxx.

302  {
303  double volume{0.};
304  if(!checkDummyMaterial(vol)) volume = vol->getLogVol()->getShape()->volume();
305  for(std::size_t c=0; c < vol->getNChildVols(); ++c){
306  const PVConstLink child = vol->getChildVol(c);
307  double childVol = child->getLogVol()->getShape()->volume();
308  //dummy material does not contribute
309  if(!checkDummyMaterial(child)) volume -= childVol;
310  getMaterialContent(child, materialContent);
311  }
312  //skip dummy materials
313  if(!checkDummyMaterial(vol)) materialContent.emplace_back(vol->getLogVol()->getMaterial(), volume);
314  }

◆ initialize()

StatusCode ActsTrk::MuonDetectorBuilderTool::initialize ( )
finaloverride

Definition at line 67 of file MuonDetectorBuilderTool.cxx.

67  {
68  ATH_CHECK(detStore()->retrieve(m_detMgr));
69  ATH_CHECK(m_idHelperSvc.retrieve());
70  ATH_MSG_DEBUG("ACTS version is: v"<< Acts::VersionMajor << "." << Acts::VersionMinor << "." << Acts::VersionPatch << " [" << Acts::CommitHash << "]");
71 
72  return StatusCode::SUCCESS;
73  }

◆ processPassiveNodes()

void ActsTrk::MuonDetectorBuilderTool::processPassiveNodes ( const ActsGeometryContext &  gctx,
const GeoChildNodeWithTrf &  node,
const std::string &  name,
std::vector< std::shared_ptr< Acts::Experimental::DetectorVolume >> &  passiveVolumes,
const GeoTrf::Transform3D &  transform,
Acts::VolumeBoundFactory &  boundFactory 
) const
private

Definition at line 327 of file MuonDetectorBuilderTool.cxx.

332  {
333  std::vector<GeoChildNodeWithTrf> children = getChildrenWithRef(node.volume, false);
334  for(const GeoChildNodeWithTrf& childNode : children){
335  ATH_MSG_DEBUG("Child transform " << GeoTrf::toString(childNode.transform) << " Parent transform " << GeoTrf::toString(transform));
336  ATH_MSG_DEBUG("Combined transform " << GeoTrf::toString(transform * childNode.transform));
337  ATH_MSG_DEBUG("Child name " << name+"/"+childNode.nodeName);
338  processPassiveNodes(gctx, childNode, name+"/"+childNode.nodeName, passiveVolumes, transform * childNode.transform, boundFactory);
339  }
340  if (!children.empty()) return;
341  ATH_MSG_VERBOSE("Drawing volume named "<<name);
342  const GeoShape* shape = node.volume->getLogVol()->getShape();
343  const GeoMaterial* geoMaterial = node.volume->getLogVol()->getMaterial();
344  const Acts::Material aMat = Acts::GeoModel::geoMaterialConverter(*geoMaterial);
345  std::shared_ptr<Acts::HomogeneousVolumeMaterial> material = std::make_shared<Acts::HomogeneousVolumeMaterial>(aMat);
346  ATH_MSG_DEBUG("FINAL TRANSFORM " << GeoTrf::toString(transform));
347 
348  auto rawVolume = Acts::GeoModel::convertVolume(transform, shape, boundFactory);
349  volumePtr volume = Acts::GeoModel::convertDetectorVolume(gctx.context(), *rawVolume, std::format("{}_{}", name ,passiveVolumes.size()), {});
350  volume->assignGeometryId(Acts::GeometryIdentifier{}.withVolume(30).withSensitive(passiveVolumes.size()));
351  volume->assignVolumeMaterial(material);
352  passiveVolumes.push_back(volume);
353  }

Member Data Documentation

◆ m_buildSensitives

Gaudi::Property<bool> ActsTrk::MuonDetectorBuilderTool::m_buildSensitives {this, "BuildSensitives", true, "If set to true all sensitive elements are built"}
private

Definition at line 58 of file MuonDetectorBuilderTool.h.

◆ m_detMgr

const MuonGMR4::MuonDetectorManager* ActsTrk::MuonDetectorBuilderTool::m_detMgr {nullptr}
private

Definition at line 47 of file MuonDetectorBuilderTool.h.

◆ m_dumpDetector

Gaudi::Property<bool> ActsTrk::MuonDetectorBuilderTool::m_dumpDetector {this, "dumpDetector", false, "If set to true the entire MS system are dumped into a visualization file format, will take a long time with sensitives"}
private

Definition at line 50 of file MuonDetectorBuilderTool.h.

◆ m_dumpDetectorVolumes

Gaudi::Property<bool> ActsTrk::MuonDetectorBuilderTool::m_dumpDetectorVolumes {this, "dumpDetectorVolumes", false, "If set to true the detector volumes are dumped into a visualization file format, will take a long time with sensitives"}
private

Definition at line 54 of file MuonDetectorBuilderTool.h.

◆ m_dumpMaterialSurfaces

Gaudi::Property<bool> ActsTrk::MuonDetectorBuilderTool::m_dumpMaterialSurfaces {this, "dumpMaterialSurfaces", false, "If set to true the material surfaces are dumped into a visualization file format"}
private

Definition at line 56 of file MuonDetectorBuilderTool.h.

◆ m_dumpPassive

Gaudi::Property<bool> ActsTrk::MuonDetectorBuilderTool::m_dumpPassive {this, "dumpPassive", false, "If set to true the passive volumes are dumped into a visualization file format"}
private

Definition at line 52 of file MuonDetectorBuilderTool.h.

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> ActsTrk::MuonDetectorBuilderTool::m_idHelperSvc {this, "IdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
private

Definition at line 48 of file MuonDetectorBuilderTool.h.

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
vtune_athena.format
format
Definition: vtune_athena.py:14
calibdata.chamber
chamber
Definition: calibdata.py:31
ActsTrk::MuonDetectorBuilderTool::getMaterialContent
void getMaterialContent(const PVConstLink &vol, std::vector< std::pair< MaterialPtr, double >> &materialContent) const
Definition: MuonDetectorBuilderTool.cxx:302
ActsTrk::MuonDetectorBuilderTool::getMaterial
std::pair< MaterialPtr, double > getMaterial(const PVConstLink &vol) const
Definition: MuonDetectorBuilderTool.cxx:281
ActsTrk::DetectorType::Tgc
@ Tgc
Resitive Plate Chambers.
MuonGMR4::MuonReadoutElement
The MuonReadoutElement is an abstract class representing the geometry representing the muon detector.
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/MuonReadoutElement.h:38
ActsTrk::MuonDetectorBuilderTool::constructElements
std::pair< std::vector< std::shared_ptr< Acts::Experimental::DetectorVolume > >, std::vector< std::shared_ptr< Acts::Surface > > > constructElements(const ActsGeometryContext &gctx, const MuonGMR4::Chamber &mChamber, std::pair< unsigned int, unsigned int > chId) const
Definition: MuonDetectorBuilderTool.cxx:186
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
ActsTrk::DetectorType::sTgc
@ sTgc
Micromegas (NSW)
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:77
runBeamSpotCalibration.helper
helper
Definition: runBeamSpotCalibration.py:115
ActsGeometryContext::context
Acts::GeometryContext context() const
Definition: ActsGeometryContext.h:45
MuonGMR4::Chamber
Definition: Chamber.h:23
ActsTrk::MuonDetectorBuilderTool::m_dumpPassive
Gaudi::Property< bool > m_dumpPassive
Definition: MuonDetectorBuilderTool.h:52
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
Amg::toString
std::string toString(const Translation3D &translation, int precision=4)
GeoPrimitvesToStringConverter.
Definition: GeoPrimitivesToStringConverter.h:40
ActsTrk::DetectorType::Mm
@ Mm
Maybe not needed in the migration.
MuonGMR4::MdtReadoutElement::parameterBook
Set of parameters to describe a MDT chamber.
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/MdtReadoutElement.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
ActsTrk::MuonDetectorBuilderTool::m_dumpMaterialSurfaces
Gaudi::Property< bool > m_dumpMaterialSurfaces
Definition: MuonDetectorBuilderTool.h:56
ActsTrk::MuonDetectorBuilderTool::m_buildSensitives
Gaudi::Property< bool > m_buildSensitives
Definition: MuonDetectorBuilderTool.h:58
MuonGMR4::Chamber::ReadoutSet
std::vector< const MuonReadoutElement * > ReadoutSet
Define the list of read out elements of the chamber.
Definition: Chamber.h:26
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
ActsTrk::volumePtr
std::shared_ptr< DetectorVolume > volumePtr
Definition: MuonDetectorBuilderTool.cxx:63
MuonGMR4::Chamber::localToGlobalTrans
const Amg::Transform3D & localToGlobalTrans(const ActsGeometryContext &gctx) const
Returns the transformation chamber frame -> global transformation.
Definition: Chamber.cxx:121
ActsTrk::MuonDetectorBuilderTool::getChamberMaterial
std::shared_ptr< Acts::Surface > getChamberMaterial(const MuonGMR4::Chamber &chamber, const Amg::Transform3D &chamberTransform, const int totalMaterials, Acts::SurfaceBoundFactory &boundSet) const
Definition: MuonDetectorBuilderTool.cxx:262
find_tgc_unfilled_channelids.ip
ip
Definition: find_tgc_unfilled_channelids.py:3
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ActsGeometryContext
Include the GeoPrimitives which need to be put first.
Definition: ActsGeometryContext.h:27
ActsTrk::objFileName
std::string objFileName(std::string str)
Definition: MuonDetectorBuilderTool.cxx:57
MuonChamberSet
MuonGMR4::MuonDetectorManager::MuonChamberSet MuonChamberSet
Definition: MuonDetectorBuilderTool.cxx:53
trigbs_pickEvents.num
num
Definition: trigbs_pickEvents.py:76
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
MuonGMR4::MuonDetectorManager::getTreeTop
PVConstLink getTreeTop(unsigned int i) const override final
Returns the i-the tree top GeoModel volume.
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/src/MuonDetectorManager.cxx:152
ActsTrk::DetectorType::Mdt
@ Mdt
MuonSpectrometer.
MuonGMR4::Chamber::readoutEles
const ReadoutSet & readoutEles() const
Returns the list of contained readout elements.
Definition: Chamber.cxx:115
ActsTrk::MuonDetectorBuilderTool::m_dumpDetector
Gaudi::Property< bool > m_dumpDetector
Definition: MuonDetectorBuilderTool.h:50
MuonGMR4::MdtReadoutElement
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/MdtReadoutElement.h:18
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
ActsTrk::MuonDetectorBuilderTool::processPassiveNodes
void processPassiveNodes(const ActsGeometryContext &gctx, const GeoChildNodeWithTrf &node, const std::string &name, std::vector< std::shared_ptr< Acts::Experimental::DetectorVolume >> &passiveVolumes, const GeoTrf::Transform3D &transform, Acts::VolumeBoundFactory &boundFactory) const
Definition: MuonDetectorBuilderTool.cxx:327
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
THROW_EXCEPTION
#define THROW_EXCEPTION(MESSAGE)
Definition: throwExcept.h:10
ActsTrk::MuonDetectorBuilderTool::checkDummyMaterial
bool checkDummyMaterial(const PVConstLink &vol) const
Definition: MuonDetectorBuilderTool.cxx:316
ActsTrk::MuonDetectorBuilderTool::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MuonDetectorBuilderTool.h:48
ActsTrk::MuonDetectorBuilderTool::m_dumpDetectorVolumes
Gaudi::Property< bool > m_dumpDetectorVolumes
Definition: MuonDetectorBuilderTool.h:54
ActsTrk::DetectorType::Rpc
@ Rpc
Monitored Drift Tubes.
python.DecayParser.children
children
Definition: DecayParser.py:31
physics_parameters.parameters
parameters
Definition: physics_parameters.py:144
ActsTrk::MuonDetectorBuilderTool::m_detMgr
const MuonGMR4::MuonDetectorManager * m_detMgr
Definition: MuonDetectorBuilderTool.h:47
MuonGMR4::Chamber::globalToLocalTrans
Amg::Transform3D globalToLocalTrans(const ActsGeometryContext &gctx) const
Returns the global -> local transformation.
Definition: Chamber.cxx:124
ActsTrk::surfacePtr
std::shared_ptr< Acts::Surface > surfacePtr
Definition: MuonBlueprintNodeBuilder.h:41
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
MuonGMR4::MuonDetectorManager::getAllChambers
MuonChamberSet getAllChambers() const
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/src/MuonDetectorManager.cxx:215
Material
@ Material
Definition: MaterialTypes.h:8
python.compressB64.c
def c
Definition: compressB64.py:93
calibdata.tube
tube
Definition: calibdata.py:30
node
Definition: node.h:21
Amg::getTranslate3D
Amg::Transform3D getTranslate3D(const double X, const double Y, const double Z)
: Returns a shift transformation along an arbitrary axis
Definition: GeoPrimitivesHelpers.h:289
Generated on Mon Sep 29 2025 21:58:57 for ATLAS Offline Software by   doxygen 1.8.18