ATLAS Offline Software
Public Types | Public Member Functions | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
Muon::MuonStationBuilderImpl Class Reference

#include <MuonStationBuilderImpl.h>

Inheritance diagram for Muon::MuonStationBuilderImpl:
Collaboration diagram for Muon::MuonStationBuilderImpl:

Public Types

using GMInfo = std::pair< Amg::Transform3D, int >
 
using DetachedVolVec = std::vector< std::unique_ptr< Trk::DetachedTrackingVolume > >
 

Public Member Functions

virtual ~MuonStationBuilderImpl ()=default
 
virtual StatusCode initialize () override
 
DetachedVolVec buildDetachedTrackingVolumesImpl (const MuonGM::MuonDetectorManager *muonMgr, bool blend=false) const
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

 MuonStationBuilderImpl (const std::string &, const std::string &, const IInterface *)
 
std::vector< std::pair< const GeoVPhysVol *, std::vector< GMInfo > > > retrieveGMsensitive (const MuonGM::MuonDetectorManager *muonMgr) const
 
std::unique_ptr< Trk::DetachedTrackingVolume > buildDetachedTrackingVolumeType (const MuonGM::MuonDetectorManager *muonMgr, const GeoVPhysVol *gv, GMInfo info) const
 
void glueComponents (Trk::DetachedTrackingVolume *) const
 
void encloseLayers (const Trk::DetachedTrackingVolume *) const
 
void identifyLayers (Trk::DetachedTrackingVolume *, Identifier, int, int, const MuonGM::MuonDetectorManager *) const
 
void identifyNSWLayers (Trk::DetachedTrackingVolume &station, const Identifier &id) const
 
void identifyPrototype (Trk::TrackingVolume &station, int eta, int phi, const Amg::Transform3D &transf, const MuonGM::MuonDetectorManager *muonMgr) const
 
Identifier resolveId (std::string vname, GMInfo gm_info, int &eta, int &phi, const MuonGM::MuonDetectorManager *muonMgr) const
 
void checkLayerId (std::string_view comment, const MuonGM::MuonDetectorManager *muonMgr, Identifier id, const Trk::Layer *lay) const
 
void getNSWStationsForTranslation (const GeoVPhysVol *pv, const std::string &name, const Amg::Transform3D &, std::vector< std::pair< std::pair< const GeoLogVol *, Trk::MaterialProperties * >, std::vector< Amg::Transform3D >>> &vols, std::vector< std::string > &volNames) const
 
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Protected Attributes

ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
 
ToolHandle< Muon::MuonStationTypeBuilder > m_muonStationTypeBuilder
 Helper Tool to create TrackingVolume Arrays. More...
 
ToolHandle< Trk::ITrackingVolumeHelper > m_trackingVolumeHelper
 Helper Tool to create TrackingVolumes. More...
 
Trk::Material m_muonMaterial
 the material More...
 
Trk::GMTreeBrowser m_gmBrowser
 
Trk::VolumeConverter m_volumeConverter
 material converter More...
 
Trk::GeoMaterialConverter m_materialConverter
 
Gaudi::Property< bool > m_buildBarrel {this, "BuildBarrelStations", true}
 
Gaudi::Property< bool > m_buildEndcap {this, "BuildEndcapStations", true}
 
Gaudi::Property< bool > m_buildCsc {this, "BuildCSCStations", true}
 
Gaudi::Property< bool > m_buildTgc {this, "BuildTGCStations", true}
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

The Muon::MuonStationBuilderImpl retrieves muon stations from Muon Geometry Tree prototypes built with help of Muon::MuonStationTypeBuilder by Sarka.nosp@m..Tod.nosp@m.orova.nosp@m.@cer.nosp@m.n.ch

Definition at line 42 of file MuonStationBuilderImpl.h.

Member Typedef Documentation

◆ DetachedVolVec

using Muon::MuonStationBuilderImpl::DetachedVolVec = std::vector<std::unique_ptr<Trk::DetachedTrackingVolume> >

Definition at line 48 of file MuonStationBuilderImpl.h.

◆ GMInfo

using Muon::MuonStationBuilderImpl::GMInfo = std::pair<Amg::Transform3D, int>

Definition at line 44 of file MuonStationBuilderImpl.h.

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ ~MuonStationBuilderImpl()

virtual Muon::MuonStationBuilderImpl::~MuonStationBuilderImpl ( )
virtualdefault

◆ MuonStationBuilderImpl()

Muon::MuonStationBuilderImpl::MuonStationBuilderImpl ( const std::string &  t,
const std::string &  n,
const IInterface *  p 
)
protected

Definition at line 68 of file MuonStationBuilderImpl.cxx.

71  : AthAlgTool(t, n, p) {}

Member Function Documentation

◆ buildDetachedTrackingVolumesImpl()

MuonStationBuilderImpl::DetachedVolVec Muon::MuonStationBuilderImpl::buildDetachedTrackingVolumesImpl ( const MuonGM::MuonDetectorManager *  muonMgr,
bool  blend = false 
) const

Definition at line 99 of file MuonStationBuilderImpl.cxx.

99  {
100 
101  DetachedVolVec translatedStations{};
102 
103  // retrieve muon station branches from GeoModel tree
104  std::vector<std::pair<const GeoVPhysVol*, std::vector<GMInfo>>> stations = retrieveGMsensitive(muonMgr);
105 
106  for (const auto& mstation : stations) {
107  // build prototype
108  std::unique_ptr<Trk::DetachedTrackingVolume> msType = buildDetachedTrackingVolumeType(muonMgr, mstation.first,
109  mstation.second[0]);
110  if (!msType) {
111  continue;
112  }
113  // clone prototype
114  std::string name = mstation.first->getLogVol()->getName();
115  // NSW prototypes built at position
116  if (name.substr(0, 4) == "sTGC" || name.substr(0, 2) == "MM") {
117  for (unsigned int i = 0; i < mstation.second.size(); i++) {
118  std::string sName = name.substr(name.find('-') + 1);
119  Identifier nswId = m_muonStationTypeBuilder->identifyNSW(sName, mstation.second[i].first);
120  // clone station from prototype
121  Amg::Transform3D trdef(mstation.second[i].first *
122  mstation.second[0].first.inverse());
123  std::unique_ptr<Trk::DetachedTrackingVolume> newStat{msType->clone(name, trdef)};
124  // identify layer representation
125  Trk::Layer* layer = (newStat->layerRepresentation());
126  layer->setLayerType(nswId.get_identifier32().get_compact());
127  // identify layers
128  identifyNSWLayers(*newStat, nswId);
129  // collect
130  translatedStations.push_back(std::move(newStat));
131  } // end clone NSW stations
132  } else {
133  for (auto gminfo : mstation.second) {
134  // clone station from prototype
135  std::unique_ptr<Trk::DetachedTrackingVolume> newStat{msType->clone(name, gminfo.first)};
136  // identify layer representation
137  Trk::Layer* layer = newStat->layerRepresentation();
138  int eta{0}, phi{0};
139  Identifier stId = resolveId(name, gminfo, eta, phi, muonMgr);
140  layer->setLayerType(stId.get_identifier32().get_compact());
141  // glue components
142  glueComponents(newStat.get());
143  // identify layers
144  identifyLayers(newStat.get(), stId, eta, phi, muonMgr);
145  // collect
146  translatedStations.push_back(std::move(newStat));
147  } // end clone non-NSW
148  }
149  } // end loop over prototypes
150 
151  ATH_MSG_DEBUG( "returns " << translatedStations.size() << " stations");
152  return translatedStations;
153 }

◆ buildDetachedTrackingVolumeType()

std::unique_ptr< Trk::DetachedTrackingVolume > Muon::MuonStationBuilderImpl::buildDetachedTrackingVolumeType ( const MuonGM::MuonDetectorManager *  muonMgr,
const GeoVPhysVol *  gv,
GMInfo  info 
) const
protected

Definition at line 917 of file MuonStationBuilderImpl.cxx.

919  {
920  const GeoLogVol* clv = cv->getLogVol();
921  const std::string& vname = clv->getName();
922  ATH_MSG_DEBUG(name() << " building station prototype for " << cv->getLogVol()->getName());
924  MuonStationTypeBuilder::Cache cache{};
925 
926  std::unique_ptr<Trk::DetachedTrackingVolume> typeStat{};
927 
928  if (vname.substr(0, 4) == "sTGC" || vname.substr(0, 2) == "MM") {
929  std::string sName = vname.substr(vname.find('-') + 1);
930  Identifier nswId = m_muonStationTypeBuilder->identifyNSW(sName, gmInfo.first);
931 
932  if (vname.substr(0, 4) == "sTGC" && m_idHelperSvc->issTgc(nswId)) {
933  return m_muonStationTypeBuilder->process_sTGC(nswId, cv, gmInfo.first);
934  } else if (vname.substr(0, 2) == "MM" && m_idHelperSvc->isMM(nswId)) {
935  return m_muonStationTypeBuilder->process_MM(nswId, cv, gmInfo.first);
936  }
937  }
938 
939  if (!m_buildBarrel && vname.compare(0, 1, "B") == 0)
940  return typeStat;
941  if (!m_buildEndcap && vname.compare(0, 1, "E") == 0)
942  return typeStat;
943  if (!m_buildCsc && vname.compare(0, 1, "C") == 0)
944  return typeStat;
945  if (!m_buildTgc && vname.compare(0, 1, "T") == 0)
946  return typeStat;
947 
948  int etaphi = gmInfo.second; // retrieve eta/phi indexes
949  int sign = (etaphi < 0) ? -1 : 1;
950  etaphi = sign * etaphi;
951  int is_mirr = etaphi / 1000;
952  etaphi = etaphi - is_mirr * 1000;
953  int eta = etaphi / 100;
954  int phi = etaphi - eta * 100;
955  eta = eta * sign;
956  const MuonGM::MuonStation* gmStation = muonMgr->getMuonStation(vname.substr(0, 3), eta, phi);
957  if (!gmStation) {
958  gmStation = muonMgr->getMuonStation(vname.substr(0, 4), eta, phi);
959  }
960  // assembly ?
961  if (!gmStation) {
962  int etaphi = gmInfo.second; // retrieve eta/phi indexes
963  int a_etaphi = static_cast<int>(etaphi / 100000);
964  int sideC = static_cast<int>(a_etaphi / 10000);
965  a_etaphi -= sideC * 10000;
966  is_mirr = static_cast<int>(a_etaphi / 1000);
967  a_etaphi -= is_mirr * 1000;
968  eta = static_cast<int>(a_etaphi / 100);
969  phi = a_etaphi - eta * 100;
970  if (sideC)
971  eta *= -1;
972  gmStation = muonMgr->getMuonStation(vname.substr(0, 3), eta, phi);
973  }
974  //
975  std::string stname = (vname.compare(0, 1, "T") == 0) ? vname : (clv->getName()).substr(0, vname.size() - 8);
976  //
977  if (stname.compare(0, 1, "B") == 0 && eta < 0) {
978  stname = (clv->getName()).substr(0, vname.size() - 8) + "-";
979  }
980  ATH_MSG_VERBOSE(" new station type " << stname << "," << clv->getShape()->type());
981  ATH_MSG_VERBOSE(" prototype built from eta, phi:" << eta << "," << phi);
982 
983  if (stname.compare(0, 2, "CS") == 0 || stname.compare(0, 1, "T") == 0) {
984 
985  if (stname.compare(0, 2, "CS") == 0) {
986  auto csc_station = m_muonStationTypeBuilder->processCscStation(cv, stname, cache);
987  // create layer representation
988  auto layerRepr = m_muonStationTypeBuilder->createLayerRepresentation(*csc_station);
989  // create prototype as detached tracking volume
990  auto layerVec = std ::make_unique<std::vector<Trk::Layer*>>(Muon::release(layerRepr.second));
991  typeStat = std::make_unique<Trk::DetachedTrackingVolume>(stname, csc_station.release(),
992  layerRepr.first.release(), layerVec.release());
993  } else {
994  std::unique_ptr<Trk::TrackingVolume> tgc_station{m_muonStationTypeBuilder->processTgcStation(cv, cache)};
995  // create layer representation
996  auto layerRepr = m_muonStationTypeBuilder->createLayerRepresentation(*tgc_station);
997  // create prototype as detached tracking volume
998  auto layerVec = std ::make_unique<std::vector<Trk::Layer*>>(Muon::release(layerRepr.second));
999  typeStat = std::make_unique<Trk::DetachedTrackingVolume>(stname, tgc_station.release(),
1000  layerRepr.first.release(), layerVec.release());
1001  }
1002 
1003  } else {
1004  const GeoShape* shapeS = clv->getShape();
1005  while (shapeS->type() != "Trd") {
1006  if (shapeS->type() == "Shift") {
1007  const GeoShapeShift* shift = dynamic_cast<const GeoShapeShift*>(shapeS);
1008  shapeS = shift->getOp();
1009  } else if (shapeS->type() == "Subtraction") {
1010  const GeoShapeSubtraction* sub = dynamic_cast<const GeoShapeSubtraction*>(shapeS);
1011  shapeS = sub->getOpA();
1012  } else if (shapeS->type() == "Union") {
1013  const GeoShapeUnion* uni = dynamic_cast<const GeoShapeUnion*>(shapeS);
1014  shapeS = uni->getOpA();
1015  } else {
1016  ATH_MSG_WARNING("unexpected station shape ? "<< shapeS->type() << ", station not built");
1017  break;
1018  }
1019  }
1020  const GeoTrd* trd = dynamic_cast<const GeoTrd*>(shapeS);
1021 
1022  double halfX1{0.}, halfX2{0.}, halfY1{0.}, halfY2{0.}, halfZ{0.};
1023  if (trd) {
1024  //
1025  halfX1 = trd->getXHalfLength1();
1026  halfX2 = trd->getXHalfLength2();
1027  halfY1 = trd->getYHalfLength1();
1028  halfY2 = trd->getYHalfLength2();
1029  halfZ = trd->getZHalfLength();
1030 
1031  // define enveloping volume
1032  std::unique_ptr<Trk::TrackingVolumeArray> confinedVolumes{};
1033  std::vector<std::unique_ptr<Trk::Layer>> confinedLayers{};
1034  std::unique_ptr<Trk::Volume> envelope;
1035  std::string shape = "Trd";
1036  if (halfX1 == halfX2 && halfY1 == halfY2)
1037  shape = "Box";
1038  if (shape == "Box") {
1039  auto envBounds = std::make_unique<Trk::CuboidVolumeBounds>(halfX1, halfY1, halfZ);
1040  // station components
1041  confinedVolumes = m_muonStationTypeBuilder->processBoxStationComponents(cv, *envBounds, cache);
1042  if (!confinedVolumes) {
1043  confinedLayers = m_muonStationTypeBuilder->processBoxComponentsArbitrary(cv, *envBounds, cache);
1044  }
1045  // enveloping volume
1046  envelope = std::make_unique<Trk::Volume>(nullptr, envBounds.release());
1047  } else if (shape == "Trd") {
1048  std::unique_ptr<Trk::TrapezoidVolumeBounds> envBounds{};
1049  Amg::Transform3D transf{Amg::Transform3D::Identity()};
1050  if (halfY1 == halfY2) {
1051  envBounds = std::make_unique<Trk::TrapezoidVolumeBounds>(halfX1, halfX2, halfY1, halfZ);
1052  ATH_MSG_VERBOSE("CAUTION!!!: this trapezoid volume does not require XY -> YZ switch");
1053  }
1054  if (halfY1 != halfY2 && halfX1 == halfX2) {
1055  transf = Amg::getRotateY3D(M_PI_2) * Amg::getRotateZ3D(M_PI_2);
1056  envBounds = std::make_unique<Trk::TrapezoidVolumeBounds>(halfY1, halfY2, halfZ, halfX1);
1057  }
1058  if (halfX1 != halfX2 && halfY1 != halfY2) {
1059  ATH_MSG_WARNING("station envelope arbitrary trapezoid?"<< stname);
1060  }
1061  if (envBounds) {
1062  // station components
1063  confinedVolumes = m_muonStationTypeBuilder->processTrdStationComponents(cv, *envBounds, cache);
1064  // enveloping volume
1065  envelope = std::make_unique<Trk::Volume>(makeTransform(transf), envBounds.release());
1066  }
1067  }
1068 
1069  if (envelope) {
1070  // ready to build the station prototype
1071  std::unique_ptr<Trk::TrackingVolume> newType{};
1072  if (!confinedLayers.empty()) {
1073  auto confinedLayerPtr = std::make_unique<std::vector<Trk::Layer*>>(Muon::release(confinedLayers));
1074  newType = std::make_unique<Trk::TrackingVolume>(*envelope, m_muonMaterial, confinedLayerPtr.release(), stname);
1075  } else {
1076  newType = std::make_unique<Trk::TrackingVolume>(*envelope, m_muonMaterial, nullptr, confinedVolumes.release(), stname);
1077  }
1078 
1079 
1080  // identify prototype
1081  if ((stname.compare(0, 1, "B") == 0 || stname.compare(0, 1, "E") == 0))
1082  identifyPrototype(*newType, eta, phi, gmStation->getTransform(), muonMgr);
1083 
1084  // create layer representation
1085  auto layerRepr = m_muonStationTypeBuilder->createLayerRepresentation(*newType);
1086 
1087  // create prototype as detached tracking volume
1088  auto layerVec = std::make_unique<std::vector<Trk::Layer*>>(Muon::release(layerRepr.second));
1089  typeStat = std::make_unique<Trk::DetachedTrackingVolume>(stname, newType.release(),
1090  layerRepr.first.release(), layerVec.release());
1091  }
1092  }
1093  } // end new station type
1094 
1095  ATH_MSG_DEBUG(" station prototype built for " << vname);
1096 
1098  return typeStat;
1099 }

◆ checkLayerId()

void Muon::MuonStationBuilderImpl::checkLayerId ( std::string_view  comment,
const MuonGM::MuonDetectorManager *  muonMgr,
Identifier  id,
const Trk::Layer *  lay 
) const
protected

Definition at line 1245 of file MuonStationBuilderImpl.cxx.

1246  {
1247 
1248  // RE
1249  if (m_idHelperSvc->isMdt(id)) {
1250  const MuonGM::MdtReadoutElement* mdtRE = muonMgr->getMdtReadoutElement(id);
1251  constexpr double tol = 0.5*Gaudi::Units::mm;
1252  if (mdtRE && !lay->surfaceRepresentation().isOnSurface(mdtRE->transform(id).translation(), tol, tol)) {
1253  ATH_MSG_DEBUG(__FILE__<<":"<<__LINE__<<" "<<comment << ":tube(id) "
1254  <<m_idHelperSvc->toString(id)<<" "<<Amg::toString(mdtRE->transform(id).translation())
1255  <<" not on surface:"<<lay->surfaceRepresentation()<<std::endl<<
1256  " "<<Amg::toString(lay->surfaceRepresentation().transform().inverse()*(mdtRE->transform(id).translation())) );
1257  }
1258  } else if (m_idHelperSvc->isRpc(id)) {
1259  const MuonGM::RpcReadoutElement* rpcRE = muonMgr->getRpcReadoutElement(id);
1260  Amg::Transform3D trid = rpcRE->transform(id);
1261  Amg::Transform3D check_layer_identity = lay->surfaceRepresentation().transform().inverse() * trid;
1262  if (!Amg::doesNotDeform(check_layer_identity)) {
1263  ATH_MSG_DEBUG(__FILE__<<":"<<__LINE__<<" "<<comment<<" "<<Amg::toString(check_layer_identity));
1264  }
1265 
1266  } else if (m_idHelperSvc->isTgc(id)) {
1267  const Amg::Transform3D trid = muonMgr->getTgcReadoutElement(id)->transform(id);
1268  Amg::Transform3D check_layer_identity = lay->surfaceRepresentation().transform().inverse() * trid;
1269  if (!Amg::doesNotDeform(check_layer_identity)) {
1270  ATH_MSG_WARNING(__FILE__<<":"<<__LINE__<<" "<<comment <<" "<<Amg::toString(check_layer_identity));
1271  }
1272  }
1273 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ encloseLayers()

void Muon::MuonStationBuilderImpl::encloseLayers ( const Trk::DetachedTrackingVolume *  ) const
protected

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ getNSWStationsForTranslation()

void Muon::MuonStationBuilderImpl::getNSWStationsForTranslation ( const GeoVPhysVol *  pv,
const std::string &  name,
const Amg::Transform3D &  transform,
std::vector< std::pair< std::pair< const GeoLogVol *, Trk::MaterialProperties * >, std::vector< Amg::Transform3D >>> &  vols,
std::vector< std::string > &  volNames 
) const
protected

Definition at line 643 of file MuonStationBuilderImpl.cxx.

647  {
648  // special code to get the Sensitive volume of the sTGC and MM (so the gas
649  // volume) throught the Frame
650 
651  // subcomponents
652  unsigned int nc = pv->getNChildVols();
653  ATH_MSG_DEBUG("getNSWStationsForTranslation from:"
654  << pv->getLogVol()->getName() << ","
655  << pv->getLogVol()->getMaterial()->getName()
656  << ", looping over " << nc << " children");
657 
658  for (unsigned int ic = 0; ic < nc; ic++) {
659  Amg::Transform3D transf = pv->getXToChildVol(ic);
660  const GeoVPhysVol* cv = pv->getChildVol(ic);
661  const GeoLogVol* clv = cv->getLogVol();
662  std::string childName = clv->getName();
663  ATH_MSG_DEBUG("getNSWStationsForTranslation child " << childName);
664 
665  if (childName.empty()) {
666  childName = "Spacer";
667  }
668  if (childName.size() > 9 && childName.substr(childName.size() - 9, 9) == "Sensitive") {
669  childName += std::to_string(ic);
670  }
671 
672  std::string cName = childName.compare(0, 3, "NSW") == 0 || childName.compare(0, 8, "NewSmall") == 0
673  ? name : name + childName;
674  ATH_MSG_VERBOSE("child number,name,position:" << ic << ":" << clv->getName() << ":"<< Amg::toString(transform * transf));
675 
676  if (!cv->getNChildVols()) {
677  bool found = false;
678  for (unsigned int is = 0; is < vols.size(); is++) {
679  if (cName == volNames[is]) {
680  if (std::abs((transform * transf).translation().perp() -
681  vols[is].second.front().translation().perp()) <
682  1.) {
683  found = true;
684  // order transforms to position prototype at phi=0/
685  // 0.125 pi
686  double phiTr = (transform * transf).translation().phi();
687  if (phiTr > -0.001 && phiTr < 0.4) {
688  vols[is].second.insert(vols[is].second.begin(),
689  transform * transf);
690  } else
691  vols[is].second.push_back(transform * transf);
692  ATH_MSG_VERBOSE(
693  "clone?"
694  << clv->getName() << ","
695  << (transform * transf).translation().perp() << ","
696  << (transform * transf).translation().z() << ","
697  << phiTr);
698 
699  break;
700  }
701  }
702  }
703  if (!found) {
704  std::vector<Amg::Transform3D> volTr;
705  volTr.push_back(transform * transf);
706  // divide mother material ? seems strange - check !
707  // double scale = 1.; // 1./nc;
708  double thick = 2 * m_muonStationTypeBuilder->get_x_size(pv);
709  if (pv->getLogVol()->getMaterial()->getName() != "Ether" &&
710  (childName == "MM_Frame" || childName == "sTGC_Frame")) {
711  Trk::MaterialProperties matComb(0., 10.e10, 10.e10, 13.,
712  26., 0.);
713  Trk::Material newMat = m_materialConverter.convert(
714  pv->getLogVol()->getMaterial());
715  matComb.addMaterial(newMat, thick / newMat.x0());
716  ATH_MSG_VERBOSE(" use mother volume thickness, x0: "
717  << matComb.thickness() << ", "
718  << matComb.x0()
719  << " mat: " << matComb.thicknessInX0());
720  Trk::MaterialProperties* nMat =
721  new Trk::MaterialProperties(matComb);
722  // store mother volume (and not child = Frame)
723  std::pair<const GeoLogVol*, Trk::MaterialProperties*> cpair(
724  pv->getLogVol(), nMat);
725  vols.emplace_back(cpair, volTr);
726  // store extensive name
727  volNames.push_back(cName);
728  ATH_MSG_VERBOSE("new NSW station volume added:"
729  << cName << ", "
730  << clv->getMaterial()->getName() << ", "
731  << volTr.back().translation().z() << ", "
732  << volTr.back().translation().phi()
733  << " mat: " << matComb.thicknessInX0());
734  }
735  // printInfo(cv);
736  }
737  } else {
738  getNSWStationsForTranslation(cv, cName, transform * transf, vols,
739  volNames);
740  }
741  }
742 }

◆ glueComponents()

void Muon::MuonStationBuilderImpl::glueComponents ( Trk::DetachedTrackingVolume *  stat) const
protected

Definition at line 155 of file MuonStationBuilderImpl.cxx.

155  {
156  Trk::TrackingVolumeArray* volArray = stat->trackingVolume()->confinedVolumes();
157  if (!volArray || volArray->arrayObjectsNumber() <= 1) {
158  return;
159  }
160 
161  Trk::BinnedArraySpan<Trk::TrackingVolume* const> components = volArray->arrayObjects();
162  const Trk::BinUtility* binUtilityX = volArray->binUtility();
163  const Trk::CuboidVolumeBounds* cubVolBounds = dynamic_cast<const Trk::CuboidVolumeBounds*>(&(components[0]->volumeBounds()));
164 
165  // identify 'lower' and 'upper' boundary surface
166  Trk::BoundarySurfaceFace low = Trk::negativeFaceXY;
167  Trk::BoundarySurfaceFace up = Trk::positiveFaceXY;
168 
169  // rectangular station in x ordering (MDT barrel)
170  if (cubVolBounds && binUtilityX) {
171  low = Trk::negativeFaceYZ;
172  up = Trk::positiveFaceYZ;
173  }
174 
175  if (low >= 0 && up >= 0) {
176  // glue volumes
177  for (unsigned int i = 0; i < components.size() - 1; ++i) {
178  m_trackingVolumeHelper->glueTrackingVolumes(*(components[i]), up, *(components[i + 1]), low);
179  }
180  }
181 
182 
183 }

◆ identifyLayers()

void Muon::MuonStationBuilderImpl::identifyLayers ( Trk::DetachedTrackingVolume *  station,
Identifier  ,
int  eta,
int  phi,
const MuonGM::MuonDetectorManager *  muonMgr 
) const
protected

Definition at line 185 of file MuonStationBuilderImpl.cxx.

187  {
188  ATH_MSG_VERBOSE(name() << " identifying layers ");
189 
190  const std::string stationName = station->trackingVolume()->volumeName();
191  ATH_MSG_VERBOSE(" in station " << station->name());
192  const std::string stationStr = stationName.substr(0, 3);
193  bool is_valid{false};
194  if (m_idHelperSvc->hasCSC() && stationStr[0] == 'C') {
195  const int cscEtaSt = eta - MuonGM::MuonDetectorManager::NCscStEtaOffset;
196  const Identifier readout_id = muonMgr->cscIdHelper()->channelID(
197  stationStr, cscEtaSt, phi + 1, 1, 1, 0, 1, is_valid);
198  const MuonGM::CscReadoutElement* cscRE =
199  is_valid ? muonMgr->getCscReadoutElement(readout_id) : nullptr;
200  if (!cscRE) {
201  const Identifier backup_id = muonMgr->cscIdHelper()->channelID(
202  stationStr, cscEtaSt, phi + 1, 2, 1, 0, 1, is_valid);
203  cscRE =
204  is_valid ? muonMgr->getCscReadoutElement(backup_id) : nullptr;
205  }
206  if (cscRE) {
207  for (int gasgap = 0; gasgap < cscRE->Ngasgaps(); gasgap++) {
208  Identifier idi = m_idHelperSvc->cscIdHelper().channelID(
209  cscRE->identify(), cscRE->ChamberLayer(), gasgap + 1, 0, 1,
210  is_valid);
211  if (!is_valid)
212  continue;
213  auto stripSurf = dynamic_cast<const Trk::PlaneSurface*>(&(cscRE->surface(idi)));
214  const Amg::Vector3D& gpi = stripSurf->center();
215  Trk::TrackingVolume* assocVol =
216  station->trackingVolume()->associatedSubVolume(gpi);
217  Trk::Layer* assocLay = nullptr;
218  if (assocVol)
219  assocLay = assocVol->associatedLayer(gpi);
220  unsigned int iD = idi.get_identifier32().get_compact();
221  if (assocVol && assocLay) {
222  assocLay->setLayerType(iD);
223  }
224  if (assocLay) {
225  assocLay->setRef((assocLay->surfaceRepresentation().transform().inverse() *gpi)[1]);
226  }
227  }
228  } else {
229  ATH_MSG_DEBUG("cscRE not found:" << stationName << "," << eta << ","
230  << phi);
231  }
232  } else if (stationStr[0] == 'T') {
233  const TgcIdHelper& idHelper{m_idHelperSvc->tgcIdHelper()};
234  int st = 7;
235  if (stationStr == "T1F") {
236  st = 0;
237  } else if (stationStr == "T1E") {
238  st = 1;
239  } else if (stationStr == "T2F") {
240  st = 2;
241  } else if (stationStr == "T2E") {
242  st = 3;
243  } else if (stationStr == "T3F") {
244  st = 4;
245  } else if (stationStr == "T3E") {
246  st = 5;
247  } else if (stationStr == "T4F") {
248  st = 6;
249  }
250 
251  const int stationName =
252  st - MuonGM::MuonDetectorManager::NTgcStatTypeOff;
253  const int zi = eta - MuonGM::MuonDetectorManager::NTgcStEtaOffset;
254  const int stationEta =
255  zi + (eta >= MuonGM::MuonDetectorManager::NTgcStEtaOffset);
256  auto getReadout = [stationName, stationEta, muonMgr, &idHelper](int phi) {
257  const int stationPhi = phi + 1;
258  bool is_valid{false};
259  const Identifier id = idHelper.elementID(stationName, stationEta, stationPhi, is_valid);
260  return is_valid ? muonMgr->getTgcReadoutElement(id) : nullptr;
261  };
262  const MuonGM::TgcReadoutElement* tgc = getReadout(phi - 1);
263 
264  if (!tgc || !(station->trackingVolume()->inside(tgc->center(), 0.))) {
265  unsigned int phit = 0;
266 
267  while (phit < 48) {
268  const MuonGM::TgcReadoutElement* tgct = getReadout(phit);
269  if (tgct &&
270  station->trackingVolume()->inside(tgct->center(), 0.)) {
271  tgc = tgct;
272  phi = phit;
273  // update station identity
274  Identifier oldId(station->layerRepresentation()->layerType());
275  int stationName = idHelper.stationName(oldId);
276  int stationEta = idHelper.stationEta(oldId);
277  Identifier stId = idHelper.channelID(stationName, stationEta, phi,
278  1,1,1, is_valid);
279  station->layerRepresentation()->setLayerType(
280  stId.get_identifier32().get_compact());
281  break;
282  }
283  phit++;
284  }
285  }
286 
287  if (tgc) {
288  const TgcIdHelper& idHelper{m_idHelperSvc->tgcIdHelper()};
289  int etaSt = tgc->getStationEta();
290  int phiSt = tgc->getStationPhi();
291 
292  bool validId{false};
293  Identifier wireId = idHelper.channelID(stationStr, etaSt, phiSt, 1, 0, 1, validId);
294  if (!validId) {
295  ATH_MSG_ERROR("invalid TGC channel:" << wireId);
296  }
297  const Amg::Vector3D gp = tgc->channelPos(wireId);
298  Trk::TrackingVolume* assocVol =
299  station->trackingVolume()->associatedSubVolume(gp);
300  if (!assocVol)
301  ATH_MSG_DEBUG("wrong tgcROE?" << stationStr << "," << etaSt
302  << "," << phiSt);
303  if (assocVol && assocVol->confinedLayers()) {
304  Trk::BinnedArraySpan<Trk::Layer* const> layers =
305  assocVol->confinedLayers()->arrayObjects();
306 
307  for (unsigned int il = 0; il < layers.size(); il++) {
308  wireId = idHelper.channelID(stationStr, etaSt, phiSt, il + 1, 1, 1, validId);
309  if (!validId) {
310  ATH_MSG_ERROR("invalid TGC channel:" << wireId);
311  layers[il]->setLayerType(1);
312  } else {
313  unsigned int id = wireId.get_identifier32().get_compact();
314  layers[il]->setLayerType(id);
315  // validation
316  Identifier checkId(layers[il]->layerType());
317  auto stripSurf = dynamic_cast<const Trk::PlaneSurface*>(&(tgc->surface(checkId)));
318  if ((layers[il]->surfaceRepresentation().transform().inverse() * stripSurf->center()).mag() > 0.001)
319  ATH_MSG_DEBUG("TGC strip plane shifted:"<< st << "," << eta << "," << phi
320  << ":"<< layers[il]->surfaceRepresentation().transform().inverse() * stripSurf->center());
321  }
322  }
323  }
324  } else {
325  ATH_MSG_WARNING(name() << "tgcROE not found for :" << stationName
326  << "," << eta << "," << phi);
327  }
328  } else if (m_idHelperSvc->hasMDT() &&
329  (stationName[0] == 'B' || stationName[0] == 'E')) {
330  // recalculate id
331  Identifier stId(station->layerRepresentation()->layerType());
332  const MdtIdHelper& idHelper{m_idHelperSvc->mdtIdHelper()};
333  const int nameIndex = idHelper.stationNameIndex(stationName.substr(0, 3));
334  if (station->trackingVolume()->confinedVolumes()) {
335  Trk::BinnedArraySpan<Trk::TrackingVolume* const> cVols =
336  station->trackingVolume()->confinedVolumes()->arrayObjects();
337  for (auto* cVol : cVols) {
338  if (cVol->confinedLayers()) {
339  Trk::BinnedArraySpan<Trk::Layer* const> cLays = cVol->confinedLayers()->arrayObjects();
340  const MuonGM::MdtReadoutElement* mdtROE = nullptr;
341  bool is_valid{false};
342 
343  for (auto* cLay : cLays) {
344  Identifier id(cLay->layerType());
345  if (id.get_compact() > 0 && m_idHelperSvc->isMdt(id)) {
346  Identifier newId = idHelper.channelID(nameIndex, eta, phi,
347  idHelper.multilayer(id),
348  idHelper.tubeLayer(id),
349  idHelper.tube(id),
350  is_valid);
351  if (!mdtROE) {
352  mdtROE = is_valid ? muonMgr->getMdtReadoutElement(newId) : nullptr;
353  }
354  unsigned int newid = newId.get_identifier32().get_compact();
355  cLay->setLayerType(newid);
356  // check reference position
357  if (mdtROE) {
358  double ref = cLay->getRef();
359  // double loc = mdtROE->localROPos(newId)[2]; //
360  // this does not take into account ROE shift wrt
361  // TG station/layer
362  double loc = (cLay->surfaceRepresentation().transform().inverse() * mdtROE->tubePos(newId))[1];
363  if (std::abs(ref) > 10e6) {
364  double sign = (ref > 0.) ? 1. : -1.;
365  int dec = int(ref / 1e5);
366  ref = ref - dec * 1e5 -
367  0.5 * (sign + 1) * 1e5;
368  if (std::abs(ref - loc) > 0.001) { // re-pack
369  cLay->setRef(loc + dec * 1e5 + 0.5 * (sign + 1) * 1e5);
370  }
371  } else if (std::abs(ref - loc) > 0.001) {
372  cLay->setRef(loc);
373  }
374  }
375  }
376  }
377  }
378  if (!cVol->confinedArbitraryLayers().empty()) {
379  Trk::ArraySpan<Trk::Layer* const> cLays = cVol->confinedArbitraryLayers();
380  const RpcIdHelper& idHelper{m_idHelperSvc->rpcIdHelper()};
381  for (auto* cLay : cLays) {
382  Identifier id(cLay->layerType());
383  bool is_valid{false};
384  if (m_idHelperSvc->hasRPC() && id.get_compact() > 0 && m_idHelperSvc->isRpc(id)) {
385  Identifier newId = idHelper.channelID(nameIndex, eta, phi,
386  idHelper.doubletR(id), idHelper.doubletZ(id),
387  idHelper.doubletPhi(id), idHelper.gasGap(id),
388  1, idHelper.strip(id),
389  is_valid);
390  int newid = newId.get_identifier32().get_compact();
391  cLay->setLayerType(newid);
392  }
393  }
394  }
395  }
396  }
397  }
398  // by now, all the layers should be identified - verify
399  if (station->trackingVolume()->confinedVolumes()) {
400  Trk::BinnedArraySpan<Trk::TrackingVolume* const> cVols =
401  station->trackingVolume()->confinedVolumes()->arrayObjects();
402  for (auto* cVol : cVols) {
403  if (cVol->confinedLayers()) {
404  Trk::BinnedArraySpan<Trk::Layer* const> cLays =
405  cVol->confinedLayers()->arrayObjects();
406  for (unsigned int il = 0; il < cLays.size(); il++) {
407  Identifier id(cLays[il]->layerType());
408  if (id == 1)
409  ATH_MSG_DEBUG(station->name()
410  << "," << cVol->volumeName()
411  << ", unidentified active layer:" << il);
412  else if (id != 0)
413  checkLayerId("check layer in " + station->name() +
414  " subvolume " + cVol->volumeName(),
415  muonMgr, id, cLays[il]);
416  }
417  }
418  if (!cVol->confinedArbitraryLayers().empty()) {
419  Trk::ArraySpan<Trk::Layer* const> cLays =
420  cVol->confinedArbitraryLayers();
421  for (unsigned int il = 0; il < cLays.size(); il++) {
422  Identifier id(cLays[il]->layerType());
423  if (id == 1)
424  ATH_MSG_DEBUG(station->name()
425  << "," << cVol->volumeName()
426  << ", unidentified active layer:" << il);
427  else if (id != 0)
428  checkLayerId("check arbitrary layer in " +
429  station->name() + " subvolume " +
430  cVol->volumeName(),
431  muonMgr, id, cLays[il]);
432  }
433  }
434  }
435  }
436  if (station->trackingVolume()->confinedLayers()) {
437  Trk::BinnedArraySpan<Trk::Layer* const> cLays =
438  station->trackingVolume()->confinedLayers()->arrayObjects();
439  for (unsigned int il = 0; il < cLays.size(); il++) {
440  Identifier id(cLays[il]->layerType());
441  if (id == 1)
442  ATH_MSG_DEBUG(station->name()
443  << "," << station->name()
444  << ", unidentified active layer:" << il);
445  else if (id != 0)
446  checkLayerId("check confined layer in " + station->name(),
447  muonMgr, id, cLays[il]);
448  }
449  }
450  // end identification check
451 }

◆ identifyNSWLayers()

void Muon::MuonStationBuilderImpl::identifyNSWLayers ( Trk::DetachedTrackingVolume &  station,
const Identifier &  id 
) const
protected

Definition at line 453 of file MuonStationBuilderImpl.cxx.

454  {
455 
456 
457  if (!station.trackingVolume()->confinedLayers()) return;
458  Trk::BinnedArraySpan<Trk::Layer* const> lays = station.trackingVolume()->confinedLayers()->arrayObjects();
459  const bool isStgc{station.name().substr(0, 4) == "sTGC"};
460  const bool isMm{station.name().substr(0, 2) == "MM"};
461  if (!isMm && !isStgc) return;
462  for (unsigned int il = 0; il < lays.size(); il++) {
463  if (isStgc) {
464  const sTgcIdHelper& idHelper{m_idHelperSvc->stgcIdHelper()};
465  const Identifier lid = idHelper.channelID(id, idHelper.multilayer(id), il + 1, 2, 1);
466  lays[il]->setLayerType(lid.get_identifier32().get_compact());
467 
468  } else if (isMm) {
469  const MmIdHelper& idHelper{m_idHelperSvc->mmIdHelper()};
470  const Identifier lid = idHelper.channelID(id, idHelper.multilayer(id), il + 1, 1);
471  lays[il]->setLayerType(lid.get_identifier32().get_compact());
472  }
473  }
474 }

◆ identifyPrototype()

void Muon::MuonStationBuilderImpl::identifyPrototype ( Trk::TrackingVolume &  station,
int  eta,
int  phi,
const Amg::Transform3D &  transf,
const MuonGM::MuonDetectorManager *  muonMgr 
) const
protected

Definition at line 476 of file MuonStationBuilderImpl.cxx.

478  {
479  ATH_MSG_VERBOSE(name() << " identifying prototype ");
480 
481  const std::string& stationName = station.volumeName();
482  ATH_MSG_VERBOSE(" for station " << stationName);
483  const std::string stationNameShort = stationName.substr(0, 3);
484  const char stationFirstChar = stationName[0];
485  bool is_valid{false};
486 
487  if (m_idHelperSvc->hasMDT() && (stationFirstChar == 'B' || stationFirstChar == 'E')) {
488  // MDT
489  const MdtIdHelper& idHelper{m_idHelperSvc->mdtIdHelper()};
490  const int nameIndex = idHelper.stationNameIndex(stationNameShort);
491  for (int multi = 1; multi <= 2; ++multi) {
492  const Identifier ele_id = idHelper.channelID(nameIndex, eta, phi, multi, 1, 1, is_valid);
493  if (!is_valid) {
494  continue;
495  }
496  const MuonGM::MdtReadoutElement* multilayer = muonMgr->getMdtReadoutElement(ele_id);
497  if (!multilayer) {
498  continue;
499  }
500  Trk::TrackingVolume* assocVol = station.associatedSubVolume(transf.inverse() * multilayer->center());
501  if (!assocVol) {
502  ATH_MSG_WARNING("valid multilayer outside station:" << stationName);
503  continue;
504  }
505  int nLayers = multilayer->getNLayers();
506  for (int layer = 1; layer <= nLayers; ++layer) {
507  Identifier id = idHelper.channelID(nameIndex, eta, phi, multi, layer, 1, is_valid);
508  if (!is_valid) {
509  continue;
510  }
511  // retrieve associated layer
512  Trk::Layer* assocLay = assocVol->associatedLayer(transf.inverse() * multilayer->tubePos(id));
513  if (assocLay) {
514  assocLay->setLayerType(id.get_identifier32().get_compact());
515  }
516  }
517  }
518 
519  // RPC ?
520  Trk::BinnedArray<Trk::TrackingVolume>* confinedVolumes = station.confinedVolumes();
521  if (confinedVolumes) {
522  Trk::BinnedArraySpan<Trk::TrackingVolume* const> vols = confinedVolumes->arrayObjects();
523  for (auto* vol : vols) {
524  if (!m_idHelperSvc->hasRPC() || vol->volumeName() != "RPC") {
525  break;
526  }
527 
528  // for active layers do a search of associated ROE
529  Trk::ArraySpan<Trk::Layer* const> layers = vol->confinedArbitraryLayers();
530  int nameIndex = m_idHelperSvc->rpcIdHelper().stationNameIndex(stationNameShort);
532  if (stationNameShort == "BME" || stationNameShort == "BMG") {
533  continue;
534  }
535  // the following checks are not necessarily needed, since
536  // calling channelID with check=true would catch them
537  // However, since these validity checks are slow, let's
538  // manually skip the obvious non-existant ones
539  //
540  // only BOG7/8 and BMS2/4 have doubletZ=3, the remaing BOG
541  // and BOF4 have doubletZ=1
542  int doubletZMax = 2;
543  if (stationNameShort.find("BMS") != std::string::npos && (std::abs(eta) == 2 || std::abs(eta) == 4)) {
544  doubletZMax = 3;
545  }
546  else if (stationNameShort.find("BOG") != std::string::npos) {
547  if (std::abs(eta) == 7 || std::abs(eta) == 8) {
548  doubletZMax = 3;
549  } else {
550  doubletZMax = 1;
551  }
552  } else if (stationNameShort.find("BOF") != std::string::npos && std::abs(eta) == 4){
553  doubletZMax = 1;
554  }
555  // all BOL/BOS and BOF1 have doubletR=1
556  const RpcIdHelper& idHelper{m_idHelperSvc->rpcIdHelper()};
557  for (int doubletR = 1; doubletR <= 2; ++doubletR) {
558  bool isValid{false};
559  const Identifier stationId = idHelper.elementID(nameIndex, eta, phi, doubletR, isValid);
560  if (!isValid) {
561  continue;
562  }
563  for (int doubletZ = 1; doubletZ <= doubletZMax; ++doubletZ) {
564  for (int doubletPhi = 1; doubletPhi <= 2; doubletPhi++) {
565 
566  const Identifier id = idHelper.channelID(stationId, doubletZ, doubletPhi,
567  1, 0, 1, isValid);
568  if (!isValid) {
569  continue;
570  }
571  const MuonGM::RpcReadoutElement* rpc = muonMgr->getRpcReadoutElement(id);
572  if (!rpc) {
573  continue;
574  }
575  for (int gasGap = 1; gasGap <= rpc->numberOfLayers(); ++gasGap) {
576 
577  Identifier etaId = idHelper.channelID(id, doubletZ, doubletPhi,
578  gasGap, 0, 1, isValid);
579 
580  const Amg::Vector3D stripLocPos = transf.inverse() * rpc->stripPos(etaId);
581  for (auto* layer : layers) {
582  if (layer->layerType() == 0 ||
583  !layer->surfaceRepresentation().isOnSurface(stripLocPos, false, 0.5* layer->thickness())){
584  continue;
585  }
586  const Amg::Vector3D locPos1 =layer->surfaceRepresentation().transform().inverse() * stripLocPos;
587  const Amg::Vector3D locPos2 = rpc->surface(etaId).transform().inverse() * rpc->stripPos(etaId);
588 
589  double swap = (std::abs(locPos1[1] - locPos2[0]) > 0.001) ? 20000. : 0.;
590 
591  layer->setLayerType(etaId.get_identifier32().get_compact());
592 
593 
594  const Amg::Vector3D locPos = layer->surfaceRepresentation().transform() *
595  transf.inverse() * rpc->surface(etaId).center();
596  layer->setRef(swap + locPos[0]);
597 
598  }
599  }
600  }
601  }
602  }
603  }
604  }
605  }
606 
607  // by now, all the layers should be identified - verify
608  if (station.confinedVolumes()) {
609  Trk::BinnedArraySpan<Trk::TrackingVolume* const> cVols = station.confinedVolumes()->arrayObjects();
610  for (auto* cVol : cVols) {
611  if (cVol->confinedLayers()) {
612  Trk::BinnedArraySpan<Trk::Layer* const> cLays = cVol->confinedLayers()->arrayObjects();
613  for (unsigned int il = 0; il < cLays.size(); il++) {
614  Identifier id(cLays[il]->layerType());
615  if (id == 1) {
616  ATH_MSG_DEBUG(station.volumeName()<< "," << cVol->volumeName() << ", unidentified active layer:" << il);
617  }
618  }
619  }
620  if (!cVol->confinedArbitraryLayers().empty()) {
621  Trk::ArraySpan<Trk::Layer* const> cLays = cVol->confinedArbitraryLayers();
622  for (unsigned int il = 0; il < cLays.size(); il++) {
623  Identifier id(cLays[il]->layerType());
624  if (id == 1) {
625  ATH_MSG_DEBUG(station.volumeName() << "," << cVol->volumeName() << ", unidentified active layer:" << il);
626  }
627  }
628  }
629  }
630  }
631  if (station.confinedLayers()) {
632  Trk::BinnedArraySpan<Trk::Layer* const> cLays = station.confinedLayers()->arrayObjects();
633  for (unsigned int il = 0; il < cLays.size(); il++) {
634  Identifier id(cLays[il]->layerType());
635  if (id == 1) {
636  ATH_MSG_DEBUG(station.volumeName() << ", unidentified active layer:" << il);
637  }
638  }
639  }
640  // end identification check
641 }

◆ initialize()

StatusCode Muon::MuonStationBuilderImpl::initialize ( )
overridevirtual

Reimplemented in Muon::MuonStationBuilder, and Muon::MuonStationBuilderCond.

Definition at line 75 of file MuonStationBuilderImpl.cxx.

75  {
76  // Retrieve the tracking volume helper
77  // -------------------------------------------------
78  ATH_CHECK(m_trackingVolumeHelper.retrieve());
79  ATH_MSG_INFO("Retrieved tool " << m_trackingVolumeHelper);
80 
81  // Retrieve muon station builder tool
82  // -------------------------------------------------
83  ATH_CHECK(m_muonStationTypeBuilder.retrieve());
84  ATH_MSG_INFO("Retrieved tool " << m_muonStationTypeBuilder);
85 
86  // if no muon materials are declared, take default ones
87 
88  // default material properties
89  m_muonMaterial = Trk::Material(10e10, 10e10, 0., 0., 0.);
90 
91  ATH_MSG_INFO(" initialize() successful");
92 
93  ATH_CHECK(m_idHelperSvc.retrieve());
94 
95  return StatusCode::SUCCESS;
96 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ resolveId()

Identifier Muon::MuonStationBuilderImpl::resolveId ( std::string  vname,
GMInfo  gm_info,
int &  eta,
int &  phi,
const MuonGM::MuonDetectorManager *  muonMgr 
) const
protected

Definition at line 1101 of file MuonStationBuilderImpl.cxx.

1102  {
1103 
1104  Identifier stId(0);
1105 
1106  int etaphi = gm_info.second; // retrieve eta/phi indexes
1107  int sign = (etaphi < 0) ? -1 : 1;
1108  etaphi = sign * etaphi;
1109  int is_mirr = etaphi / 1000;
1110  etaphi = etaphi - is_mirr * 1000;
1111  eta = etaphi / 100;
1112  phi = etaphi - eta * 100;
1113  eta = eta * sign;
1114  const MuonGM::MuonStation* gmStation =
1115  muonMgr->getMuonStation(vname.substr(0, 3), eta, phi);
1116  // try to retrieve
1117  if (!gmStation) {
1118  gmStation = muonMgr->getMuonStation(vname.substr(0, 4), eta, phi);
1119  }
1120  // assembly ?
1121  if (!gmStation) {
1122  int etaphi = gm_info.second; // retrieve eta/phi indexes
1123  int a_etaphi = static_cast<int>(etaphi / 100000);
1124  int sideC = static_cast<int>(a_etaphi / 10000);
1125  a_etaphi -= sideC * 10000;
1126  is_mirr = static_cast<int>(a_etaphi / 1000);
1127  a_etaphi -= is_mirr * 1000;
1128  eta = static_cast<int>(a_etaphi / 100);
1129  phi = a_etaphi - eta * 100;
1130  if (sideC)
1131  eta *= -1;
1132  gmStation = muonMgr->getMuonStation(vname.substr(0, 3), eta, phi);
1133  }
1134  //
1135  if (!gmStation)
1136  ATH_MSG_WARNING("Muon station not found! " << vname << "," << eta << ","
1137  << phi);
1138 
1139  std::string stName;
1140  if (vname.compare(0, 1, "T") == 0 || vname.compare(0, 1, "C") == 0) {
1141  stName = vname.substr(0, 4);
1142  } else {
1143  stName = (vname.substr(0, vname.size() - 8));
1144  if (stName.compare(0, 1, "B") == 0 && eta < 0) {
1145  stName = vname.substr(0, vname.size() - 8) + "-";
1146  }
1147  }
1148  if (!gmStation)
1149  return stId;
1150  Amg::Transform3D transf = gmStation->getTransform();
1151  bool is_valid{false};
1152  if (m_idHelperSvc->hasCSC() && stName.compare(0, 1, "C") == 0) {
1153  stId = m_idHelperSvc->cscIdHelper().elementID(vname.substr(0, 3), eta,
1154  phi, is_valid);
1155  }
1156  // adjust eta,phi
1157  if (vname.compare(0, 1, "C") == 0) {
1158  eta = 1;
1159  if (transf.translation().z() < 0)
1160  eta = 0;
1161  double phic = transf.translation().phi() + 0.1;
1162  phi =
1163  static_cast<int>(phic < 0 ? 4 * phic / M_PI + 8 : 4 * phic / M_PI);
1164  }
1165  if (vname.compare(0, 1, "T") == 0) {
1166  bool az = true;
1167  std::string sub = vname.substr(7, 2);
1168  if (transf.translation().z() < 0)
1169  az = false;
1170  if (sub == "01")
1171  eta = az ? 5 : 4;
1172  else if (sub == "02")
1173  eta = az ? 5 : 4;
1174  else if (sub == "03")
1175  eta = az ? 6 : 3;
1176  else if (sub == "04")
1177  eta = az ? 7 : 2;
1178  else if (sub == "05")
1179  eta = az ? 8 : 1;
1180  else if (sub == "06")
1181  eta = az ? 5 : 4;
1182  else if (sub == "07")
1183  eta = az ? 5 : 4;
1184  else if (sub == "08")
1185  eta = az ? 6 : 3;
1186  else if (sub == "09")
1187  eta = az ? 7 : 2;
1188  else if (sub == "10")
1189  eta = az ? 8 : 1;
1190  else if (sub == "11")
1191  eta = az ? 9 : 0;
1192  else if (sub == "12")
1193  eta = az ? 5 : 4;
1194  else if (sub == "13")
1195  eta = az ? 5 : 4;
1196  else if (sub == "14")
1197  eta = az ? 6 : 3;
1198  else if (sub == "15")
1199  eta = az ? 7 : 2;
1200  else if (sub == "16")
1201  eta = az ? 8 : 1;
1202  else if (sub == "17")
1203  eta = az ? 9 : 0;
1204  else if (sub == "18")
1205  eta = az ? 5 : 4;
1206  else if (sub == "19")
1207  eta = az ? 5 : 4;
1208  else if (sub == "20")
1209  eta = az ? 5 : 4;
1210  else if (sub == "21")
1211  eta = az ? 5 : 4;
1212  else if (sub == "22")
1213  eta = az ? 5 : 4;
1214  }
1215  if (m_idHelperSvc->hasTGC() && stName[0] == 'T') {
1216  int etaSt = eta - 4;
1217  if (eta < 5)
1218  etaSt = eta - 5;
1219  double phic = transf.translation().phi();
1220  if (vname.compare(2, 1, "E") == 0 && vname.compare(0, 3, "T4E") != 0)
1221  phi = static_cast<int>(phic < 0 ? 24 * phic / M_PI + 48
1222  : 24 * phic / M_PI);
1223  else
1224  phi = static_cast<int>(phic < 0 ? 12 * phic / M_PI + 24
1225  : 12 * phic / M_PI);
1226  phi++;
1227  stId = m_idHelperSvc->tgcIdHelper().elementID(vname.substr(0, 3), etaSt,
1228  phi, is_valid);
1229  } else if (m_idHelperSvc->hasRPC() && stName.compare(0, 3, "BML") == 0) {
1230  stId = m_idHelperSvc->rpcIdHelper().elementID(vname.substr(0, 3), eta,
1231  phi, 1, is_valid);
1232  } else if (m_idHelperSvc->hasMDT() && stName.compare(0, 1, "C") != 0) {
1233  stId = m_idHelperSvc->mdtIdHelper().elementID(vname.substr(0, 3), eta,
1234  phi, is_valid);
1235  }
1236  if (!is_valid || !stId.get_compact()) {
1237  ATH_MSG_DEBUG("identifier of the station not found:"
1238  << vname << "," << eta << "," << phi);
1239  if (!stId.get_compact())
1240  return Identifier(0);
1241  }
1242  return stId;
1243 }

◆ retrieveGMsensitive()

std::vector< std::pair< const GeoVPhysVol *, std::vector< GMInfo > > > Muon::MuonStationBuilderImpl::retrieveGMsensitive ( const MuonGM::MuonDetectorManager *  muonMgr) const
protected

Definition at line 745 of file MuonStationBuilderImpl.cxx.

745  {
746 
747  // a single loop over GM tree to retrieve all necessary information
748 
749  std::vector<std::pair<const GeoVPhysVol*,
750  std::vector<GMInfo>>> sensitive;
751 
752  const GeoVPhysVol* top = muonMgr->getTreeTop(0);
753 
754 
755  // NSW stations first to avoid double-counting
756  const GeoVPhysVol* sTGC_top = m_gmBrowser.findTopBranch(top, "sTGC_1");
757  const GeoVPhysVol* MM_top = m_gmBrowser.findTopBranch(top, "MM_1");
758  if (sTGC_top && sTGC_top != top) {
759  ATH_MSG_DEBUG("sTGC GeoModel branch found:" << sTGC_top->getLogVol()->getName());
760  GeoVolumeCursor vol(sTGC_top);
761  while (!vol.atEnd()) {
762  const GeoVPhysVol* cv = vol.getVolume();
763  const std::string& vname = cv->getLogVol()->getName();
764  if (vname.find("sTGC_1") == std::string::npos) {
765  vol.next();
766  continue;
767  }
768  std::vector<std::pair<const GeoVPhysVol*,
769  std::vector<GMInfo>>>::iterator it =
770  sensitive.begin();
771  while (it < sensitive.end()) {
772  if (vname == (*it).first->getLogVol()->getName() &&
773  m_gmBrowser.compareGeoVolumes(cv, (*it).first, 1.e-3) == 0)
774  break;
775  ++it;
776  }
777 
778  if (it == sensitive.end()) {
779  std::vector<std::pair<Amg::Transform3D, int>> cloneList;
780  cloneList.push_back(
781  std::make_pair(vol.getTransform(), 0));
782  sensitive.push_back(std::make_pair(cv, cloneList));
783  } else {
784  Amg::Transform3D transf = vol.getTransform();
785  // order transforms to position prototype at phi=0/ 0.125 pi
786  double phiTr = transf.translation().phi();
787  if (phiTr > -0.001 && phiTr < 0.4)
788  (*it).second.insert((*it).second.begin(),
789  std::make_pair(vol.getTransform(), 0));
790  else
791  (*it).second.push_back(std::make_pair(vol.getTransform(), 0));
792  }
793  vol.next();
794  }
795  }
796 
797  if (MM_top && MM_top != top) {
798  ATH_MSG_DEBUG("MM GeoModel branch found:" << MM_top->getLogVol()->getName());
799  GeoVolumeCursor vol(MM_top);
800  while (!vol.atEnd()) {
801  const GeoVPhysVol* cv = vol.getVolume();
802  const std::string& vname = cv->getLogVol()->getName();
803  if (vname.find("MM_1") == std::string::npos) {
804  vol.next();
805  continue;
806  }
807  std::vector<std::pair<const GeoVPhysVol*,
808  std::vector<GMInfo>>>::iterator it =
809  sensitive.begin();
810  while (it < sensitive.end()) {
811  if (vname == (*it).first->getLogVol()->getName() &&
812  m_gmBrowser.compareGeoVolumes(cv, (*it).first, 1.e-3) == 0)
813  break;
814  ++it;
815  }
816 
817  if (it == sensitive.end()) {
818  std::vector<std::pair<Amg::Transform3D, int>> cloneList;
819  cloneList.push_back(std::make_pair(vol.getTransform(), 0));
820  sensitive.push_back(std::make_pair(cv, cloneList));
821  } else {
822  Amg::Transform3D transf = vol.getTransform();
823  // order transforms to position prototype at phi=0/ 0.125 pi
824  double phiTr = transf.translation().phi();
825  if (phiTr > -0.001 && phiTr < 0.4)
826  (*it).second.insert((*it).second.begin(), std::make_pair(vol.getTransform(), 0));
827  else
828  (*it).second.push_back(std::make_pair(vol.getTransform(), 0));
829  }
830  vol.next();
831  }
832  }
833 
834  GeoVolumeCursor vol(top);
835  while (!vol.atEnd()) {
836  const GeoVPhysVol* cv = &(*(vol.getVolume()));
837  const std::string& vname = cv->getLogVol()->getName();
838  if (vname.find("Station") == std::string::npos &&
839  vname.find("MM_1") == std::string::npos &&
840  vname.find("sTGC_1") == std::string::npos) {
841  vol.next();
842  continue;
843  }
844 
845  // TGC stations retrieved at level-1
846  if (vname.substr(0, 1) == "T") {
847 
848  for (const auto&[tv, tvTrf] : geoGetVolumes(cv)) {
849  const GeoLogVol* tlv = tv->getLogVol();
850  const Amg::Transform3D transform = vol.getTransform() * tvTrf;
851  const std::string& tgc_name = tlv->getName();
852 
853  std::vector<std::pair<const GeoVPhysVol*,
854  std::vector<GMInfo>>>::iterator it =
855  sensitive.begin();
856  while (it < sensitive.end()) {
857  if (tgc_name == (*it).first->getLogVol()->getName() &&
858  m_gmBrowser.compareGeoVolumes(tv, (*it).first, 1.e-3) ==
859  0)
860  break;
861  ++it;
862  }
863 
864  if (it == sensitive.end()) {
865  std::vector<std::pair<Amg::Transform3D, int>> cloneList;
866  cloneList.push_back(std::make_pair(transform, vol.getId()));
867  sensitive.push_back(std::make_pair(tv, cloneList));
868  } else {
869  Amg::Transform3D transf = transform;
870  // order transforms to position prototype at phi=0/ 0.125 pi
871  double phiTr = transf.translation().phi();
872  if (phiTr > -0.001 && phiTr < 0.4)
873  (*it).second.insert((*it).second.begin(),
874  std::make_pair(transform, vol.getId()));
875  else
876  (*it).second.push_back(std::make_pair(transform, vol.getId()));
877  }
878 
879  } // end loop over TGC
880 
881  } else {
882 
883  std::vector<std::pair<const GeoVPhysVol*,
884  std::vector<GMInfo>>>::iterator it =
885  sensitive.begin();
886  while (it < sensitive.end()) {
887  if (vname == (*it).first->getLogVol()->getName() &&
888  m_gmBrowser.compareGeoVolumes(cv, (*it).first, 1.e-3) == 0)
889  break;
890  ++it;
891  }
892 
893  if (it == sensitive.end()) {
894  std::vector<std::pair<Amg::Transform3D, int>> cloneList;
895  cloneList.push_back(std::make_pair(vol.getTransform(), vol.getId()));
896  sensitive.push_back(std::make_pair(cv, cloneList));
897  } else {
898  Amg::Transform3D transf = vol.getTransform();
899  // order transforms to position prototype at phi=0/ 0.125 pi
900  double phiTr = transf.translation().phi();
901  if (phiTr > -0.001 && phiTr < 0.4)
902  (*it).second.insert((*it).second.begin(),
903  std::make_pair(vol.getTransform(), vol.getId()));
904  else
905  (*it).second.push_back(std::make_pair(vol.getTransform(), vol.getId()));
906  }
907  } // end non-TGC
908  vol.next();
909  }
910 
911  ATH_MSG_DEBUG("Number of muon station types in GeoModel tree:" << sensitive.size());
912 
913  return sensitive;
914 }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_buildBarrel

Gaudi::Property<bool> Muon::MuonStationBuilderImpl::m_buildBarrel {this, "BuildBarrelStations", true}
protected

Definition at line 111 of file MuonStationBuilderImpl.h.

◆ m_buildCsc

Gaudi::Property<bool> Muon::MuonStationBuilderImpl::m_buildCsc {this, "BuildCSCStations", true}
protected

Definition at line 113 of file MuonStationBuilderImpl.h.

◆ m_buildEndcap

Gaudi::Property<bool> Muon::MuonStationBuilderImpl::m_buildEndcap {this, "BuildEndcapStations", true}
protected

Definition at line 112 of file MuonStationBuilderImpl.h.

◆ m_buildTgc

Gaudi::Property<bool> Muon::MuonStationBuilderImpl::m_buildTgc {this, "BuildTGCStations", true}
protected

Definition at line 114 of file MuonStationBuilderImpl.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_gmBrowser

Trk::GMTreeBrowser Muon::MuonStationBuilderImpl::m_gmBrowser
protected

Definition at line 107 of file MuonStationBuilderImpl.h.

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Muon::MuonStationBuilderImpl::m_idHelperSvc
protected
Initial value:
{
this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

Definition at line 56 of file MuonStationBuilderImpl.h.

◆ m_materialConverter

Trk::GeoMaterialConverter Muon::MuonStationBuilderImpl::m_materialConverter
protected

Definition at line 110 of file MuonStationBuilderImpl.h.

◆ m_muonMaterial

Trk::Material Muon::MuonStationBuilderImpl::m_muonMaterial
protected

the material

shape converter

Definition at line 104 of file MuonStationBuilderImpl.h.

◆ m_muonStationTypeBuilder

ToolHandle<Muon::MuonStationTypeBuilder> Muon::MuonStationBuilderImpl::m_muonStationTypeBuilder
protected
Initial value:
{
this, "StationTypeBuilder",
"Muon::MuonStationTypeBuilder/"
"MuonStationTypeBuilder"}

Helper Tool to create TrackingVolume Arrays.

Definition at line 91 of file MuonStationBuilderImpl.h.

◆ m_trackingVolumeHelper

ToolHandle<Trk::ITrackingVolumeHelper> Muon::MuonStationBuilderImpl::m_trackingVolumeHelper
protected
Initial value:
{
this, "TrackingVolumeHelper",
"Trk::TrackingVolumeHelper/TrackingVolumeHelper"}

Helper Tool to create TrackingVolumes.

Definition at line 98 of file MuonStationBuilderImpl.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_volumeConverter

Trk::VolumeConverter Muon::MuonStationBuilderImpl::m_volumeConverter
protected

material converter

Definition at line 108 of file MuonStationBuilderImpl.h.

The documentation for this class was generated from the following files:
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
MuonGM::MuonDetectorManager::getRpcReadoutElement
const RpcReadoutElement * getRpcReadoutElement(const Identifier &id) const
access via extended identifier (requires unpacking)
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonDetectorManager.cxx:168
geoGetVolumes
GeoVolumeVec_t geoGetVolumes(const GeoGraphNode *node, int depthLimit=1, int sizeHint=20)
Return the child volumes and associated transforms.
Definition: GeoVisitVolumes.cxx:211
PlotCalibFromCool.il
il
Definition: PlotCalibFromCool.py:381
Trk::Layer::setRef
void setRef(double)
set the reference measure
Muon::MuonStationBuilderImpl::checkLayerId
void checkLayerId(std::string_view comment, const MuonGM::MuonDetectorManager *muonMgr, Identifier id, const Trk::Layer *lay) const
Definition: MuonStationBuilderImpl.cxx:1245
Muon::makeTransform
Amg::Transform3D * makeTransform(const Amg::Transform3D &trf)
Definition: MuonSpectrometer/MuonDetDescr/MuonTrackingGeometry/MuonTrackingGeometry/Utils.h:14
python.SystemOfUnits.second
int second
Definition: SystemOfUnits.py:120
Muon::nsw::STGTPSegments::moduleIDBits::stationPhi
constexpr uint8_t stationPhi
station Phi 1 to 8
Definition: NSWSTGTPDecodeBitmaps.h:129
MuonGM::MuonClusterReadoutElement::transform
virtual const Amg::Transform3D & transform() const override
Return local to global transform.
Definition: MuonClusterReadoutElement.h:124
dumpTgcDigiDeadChambers.gasGap
list gasGap
Definition: dumpTgcDigiDeadChambers.py:33
MuonGM::MdtReadoutElement::getNLayers
int getNLayers() const
Returns the number of tube layers inside the multilayer.
top
TopConfig A simple configuration that is NOT a singleton.
Definition: AnalysisTrackingHelper.cxx:58
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
Trk::BinnedArray::binUtility
virtual const BinUtility * binUtility() const =0
Return the BinUtility.
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
Trk::Layer::setLayerType
void setLayerType(int identifier)
set the Layer coding
MuonGM::MdtReadoutElement::center
virtual const Amg::Vector3D & center(const Identifier &) const override final
Return the center of the surface associated with this identifier In the case of silicon it returns th...
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
ZDC::sideC
BySideTypeMod sideC(-1)
MuonGM::MuonClusterReadoutElement::center
virtual const Amg::Vector3D & center() const override
Return the center of the element.
Definition: MuonClusterReadoutElement.h:125
perp
Scalar perp() const
perp method - perpenticular length
Definition: AmgMatrixBasePlugin.h:35
Trk::Volume::inside
bool inside(const Amg::Vector3D &gp, double tol=0.) const
Inside() method for checks.
Definition: Volume.cxx:90
dumpTgcDigiDeadChambers.stationName
dictionary stationName
Definition: dumpTgcDigiDeadChambers.py:30
Trk::CuboidVolumeBounds
Definition: CuboidVolumeBounds.h:52
TgcIdHelper
Definition: TgcIdHelper.h:50
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
Muon::MuonStationBuilderImpl::m_gmBrowser
Trk::GMTreeBrowser m_gmBrowser
Definition: MuonStationBuilderImpl.h:107
Trk::DetachedTrackingVolume::trackingVolume
const TrackingVolume * trackingVolume() const
returns the TrackingVolume
Definition: DetachedTrackingVolume.h:125
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Muon::MuonStationBuilderImpl::identifyPrototype
void identifyPrototype(Trk::TrackingVolume &station, int eta, int phi, const Amg::Transform3D &transf, const MuonGM::MuonDetectorManager *muonMgr) const
Definition: MuonStationBuilderImpl.cxx:476
Muon::MuonStationBuilderImpl::identifyNSWLayers
void identifyNSWLayers(Trk::DetachedTrackingVolume &station, const Identifier &id) const
Definition: MuonStationBuilderImpl.cxx:453
MuonGM::CscReadoutElement::ChamberLayer
int ChamberLayer() const
Definition: CscReadoutElement.h:290
MuonGM::MuonStation::getTransform
Amg::Transform3D getTransform() const
Definition: MuonStation.h:169
Trk::TrackingVolume::associatedSubVolume
const TrackingVolume * associatedSubVolume(const Amg::Vector3D &gp) const
Return the associated sub Volume, returns THIS if no subVolume exists.
Definition: TrackingVolume.cxx:710
Muon::MuonStationBuilderImpl::m_buildTgc
Gaudi::Property< bool > m_buildTgc
Definition: MuonStationBuilderImpl.h:114
module_driven_slicing.layers
layers
Definition: module_driven_slicing.py:114
skel.it
it
Definition: skel.GENtoEVGEN.py:423
Trk::GeoMaterialConverter::convert
static Material convert(const GeoMaterial *gm)
Single conversion , input type GeoMaterial - output type Trk::MaterialProperties.
Definition: GeoMaterialConverter.cxx:18
createCablingJSON.doubletR
int doubletR
Definition: createCablingJSON.py:10
M_PI
#define M_PI
Definition: ActiveFraction.h:11
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
Trk::positiveFaceXY
@ positiveFaceXY
Definition: BoundarySurfaceFace.h:33
MuonGM::RpcReadoutElement
An RpcReadoutElement corresponds to a single RPC module; therefore typicaly a barrel muon station con...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/RpcReadoutElement.h:54
MuonGM::CscReadoutElement
Definition: CscReadoutElement.h:56
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
PlotCalibFromCool.multi
multi
Definition: PlotCalibFromCool.py:99
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
isValid
bool isValid(const T &p)
Definition: AtlasPID.h:214
Muon::MuonStationBuilderImpl::retrieveGMsensitive
std::vector< std::pair< const GeoVPhysVol *, std::vector< GMInfo > > > retrieveGMsensitive(const MuonGM::MuonDetectorManager *muonMgr) const
Definition: MuonStationBuilderImpl.cxx:745
Trk::Surface::center
const Amg::Vector3D & center() const
Returns the center position of the Surface.
MuonGM::MuonClusterReadoutElement::surface
virtual const Trk::PlaneSurface & surface() const override
access to chamber surface (phi orientation), uses the first gas gap
Definition: MuonClusterReadoutElement.h:123
Trk::BoundarySurfaceFace
BoundarySurfaceFace
Definition: BoundarySurfaceFace.h:31
Trk::BinnedArray::arrayObjectsNumber
virtual unsigned int arrayObjectsNumber() const =0
Number of Entries in the Array.
RpcIdHelper
Definition: RpcIdHelper.h:51
Trk::Layer::layerType
int layerType() const
get the Layer coding
MuonGM::TgcReadoutElement::channelPos
Amg::Vector3D channelPos(const Identifier &id) const
Returns the position of the active channel (wireGang or strip)
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
Amg::getRotateZ3D
Amg::Transform3D getRotateZ3D(double angle)
get a rotation transformation around Z-axis
Definition: GeoPrimitivesHelpers.h:270
Trk::TrackingVolume::confinedLayers
const LayerArray * confinedLayers() const
Return the subLayer array.
MuonGM::MuonDetectorManager::getTgcReadoutElement
const TgcReadoutElement * getTgcReadoutElement(const Identifier &id) const
access via extended identifier (requires unpacking)
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonDetectorManager.cxx:247
MuonGM::CscReadoutElement::Ngasgaps
int Ngasgaps() const
Definition: CscReadoutElement.h:308
Trk::GMTreeBrowser::compareGeoVolumes
int compareGeoVolumes(const GeoVPhysVol *gv1, const GeoVPhysVol *gv2, double tolerance, bool printFullInfo=false, int level=0) const
Recursive comparison of trees/branches/volumes : in quiet mode (printFullInfo=False) ,...
Definition: GMTreeBrowser.cxx:42
Trk::Surface::isOnSurface
virtual bool isOnSurface(const Amg::Vector3D &glopo, const BoundaryCheck &bchk=true, double tol1=0., double tol2=0.) const
This method returns true if the GlobalPosition is on the Surface for both, within or without check of...
Definition: Surface.cxx:123
Trk::Material::x0
float x0() const
Definition: Material.h:226
AthCommonDataStore
Definition: AthCommonDataStore.h:52
Amg::toString
std::string toString(const Translation3D &translation, int precision=4)
GeoPrimitvesToStringConverter.
Definition: GeoPrimitivesToStringConverter.h:40
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
Trk::Layer::surfaceRepresentation
virtual const Surface & surfaceRepresentation() const =0
Transforms the layer into a Surface representation for extrapolation.
Muon::MuonStationBuilderImpl::glueComponents
void glueComponents(Trk::DetachedTrackingVolume *) const
Definition: MuonStationBuilderImpl.cxx:155
MuonGM::MuonDetectorManager::getMdtReadoutElement
const MdtReadoutElement * getMdtReadoutElement(const Identifier &id) const
access via extended identifier (requires unpacking)
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonDetectorManager.cxx:204
Identifier32::get_compact
value_type get_compact(void) const
Get the compact id.
Definition: Identifier32.h:171
MuonGM::MdtReadoutElement
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MdtReadoutElement.h:50
Muon::MuonStationBuilderImpl::m_muonStationTypeBuilder
ToolHandle< Muon::MuonStationTypeBuilder > m_muonStationTypeBuilder
Helper Tool to create TrackingVolume Arrays.
Definition: MuonStationBuilderImpl.h:91
lumiFormat.i
int i
Definition: lumiFormat.py:92
Trk::ArraySpan
std::span< T > ArraySpan
Definition: DetachedTrackingVolume.h:34
MuonGM::MuonDetectorManager::getCscReadoutElement
const CscReadoutElement * getCscReadoutElement(const Identifier &id) const
access via extended identifier (requires unpacking)
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonDetectorManager.cxx:225
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
beamspotman.n
n
Definition: beamspotman.py:731
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
Amg::doesNotDeform
bool doesNotDeform(const Amg::Transform3D &trans)
Checks whether the linear part of the transformation rotates or stetches any of the basis vectors.
Definition: GeoPrimitivesHelpers.h:338
MuonGM::MuonStation
Definition: MuonStation.h:51
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
CalibCoolCompareRT.up
up
Definition: CalibCoolCompareRT.py:109
MuonGM::TgcReadoutElement
A TgcReadoutElement corresponds to a single TGC chamber; therefore typically a TGC station contains s...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/TgcReadoutElement.h:42
MdtIdHelper
Definition: MdtIdHelper.h:61
Muon::MuonStationBuilderImpl::m_trackingVolumeHelper
ToolHandle< Trk::ITrackingVolumeHelper > m_trackingVolumeHelper
Helper Tool to create TrackingVolumes.
Definition: MuonStationBuilderImpl.h:98
sign
int sign(int a)
Definition: TRT_StrawNeighbourSvc.h:127
Trk::GMTreeBrowser::findTopBranch
static const GeoVPhysVol * findTopBranch(const GeoVPhysVol *gv, std::string_view name)
search of top branch : returns mother volume for children matching name
Definition: GMTreeBrowser.cxx:442
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Trk::negativeFaceXY
@ negativeFaceXY
Definition: BoundarySurfaceFace.h:32
Muon::MuonStationBuilderImpl::buildDetachedTrackingVolumeType
std::unique_ptr< Trk::DetachedTrackingVolume > buildDetachedTrackingVolumeType(const MuonGM::MuonDetectorManager *muonMgr, const GeoVPhysVol *gv, GMInfo info) const
Definition: MuonStationBuilderImpl.cxx:917
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
MuonGM::MuonDetectorManager::NTgcStEtaOffset
static constexpr int NTgcStEtaOffset
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonDetectorManager.h:161
WriteCalibToCool.swap
swap
Definition: WriteCalibToCool.py:94
beamspotman.stat
stat
Definition: beamspotman.py:266
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
Muon::MuonStationBuilderImpl::m_materialConverter
Trk::GeoMaterialConverter m_materialConverter
Definition: MuonStationBuilderImpl.h:110
Muon::MuonStationBuilderImpl::resolveId
Identifier resolveId(std::string vname, GMInfo gm_info, int &eta, int &phi, const MuonGM::MuonDetectorManager *muonMgr) const
Definition: MuonStationBuilderImpl.cxx:1101
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
Trk::BinUtility
Definition: BinUtility.h:39
grepfile.ic
int ic
Definition: grepfile.py:33
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
CaloCondBlobAlgs_fillNoiseFromASCII.comment
string comment
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:27
Trk::DetachedTrackingVolume::clone
DetachedTrackingVolume * clone(const std::string &name, Amg::Transform3D &shift) const
clone with transform
Definition: DetachedTrackingVolume.cxx:75
MuonGM::MuonDetectorManager::NCscStEtaOffset
static constexpr int NCscStEtaOffset
Identifier <-> AMDB conversion constants in use.
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonDetectorManager.h:159
Trk::TrackingVolume::volumeName
const std::string & volumeName() const
Returns the VolumeName - for debug reason, might be depreciated later.
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
CscIdHelper::channelID
Identifier channelID(int stationName, int stationEta, int stationPhi, int chamberLayer, int wireLayer, int measuresPhi, int strip) const
Definition: CscIdHelper.cxx:706
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:191
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
Muon::MuonStationBuilderImpl::getNSWStationsForTranslation
void getNSWStationsForTranslation(const GeoVPhysVol *pv, const std::string &name, const Amg::Transform3D &, std::vector< std::pair< std::pair< const GeoLogVol *, Trk::MaterialProperties * >, std::vector< Amg::Transform3D >>> &vols, std::vector< std::string > &volNames) const
Definition: MuonStationBuilderImpl.cxx:643
MuonGM::RpcReadoutElement::stripPos
Amg::Vector3D stripPos(const Identifier &id) const
Definition: MuonDetDescr/MuonReadoutGeometry/src/RpcReadoutElement.cxx:177
Trk::BinnedArray::arrayObjects
virtual BinnedArraySpan< T *const > arrayObjects()=0
Return all objects of the Array non-const we can still modify the T.
sTgcIdHelper
Definition: sTgcIdHelper.h:55
Amg::getRotateY3D
Amg::Transform3D getRotateY3D(double angle)
get a rotation transformation around Y-axis
Definition: GeoPrimitivesHelpers.h:261
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
MuonGM::RpcReadoutElement::numberOfLayers
virtual int numberOfLayers(bool measphi=true) const override final
number of layers in phi/eta projection, same for eta/phi planes
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
MuonGM::MuonDetectorManager::getMuonStation
const MuonStation * getMuonStation(const std::string &stName, int eta, int phi) const
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonDetectorManager.cxx:137
Muon::MuonStationBuilderImpl::m_buildEndcap
Gaudi::Property< bool > m_buildEndcap
Definition: MuonStationBuilderImpl.h:112
Trk::MaterialProperties
Definition: MaterialProperties.h:40
MuonGM::MdtReadoutElement::tubePos
Amg::Vector3D tubePos(const Identifier &id) const
Returns the global position of the given tube.
a
TList * a
Definition: liststreamerinfos.cxx:10
h
MmIdHelper
Definition: MmIdHelper.h:54
CondAlgsOpts.found
int found
Definition: CondAlgsOpts.py:101
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
ref
const boost::regex ref(r_ef)
Trk::PlaneSurface
Definition: PlaneSurface.h:64
Trk::TrackingVolume::confinedVolumes
const TrackingVolumeArray * confinedVolumes() const
Return the subLayer array.
MuonGM::MuonReadoutElement::identify
Identifier identify() const override final
Returns the ATLAS Identifier of the MuonReadOutElement.
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonReadoutElement.h:184
python.changerun.pv
pv
Definition: changerun.py:81
MuonGM::MuonDetectorManager::getTreeTop
virtual PVConstLink getTreeTop(unsigned int i) const
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonDetectorManager.cxx:115
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
Trk::negativeFaceYZ
@ negativeFaceYZ
Definition: BoundarySurfaceFace.h:34
Muon::MuonStationBuilderImpl::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MuonStationBuilderImpl.h:56
Trk::DetachedTrackingVolume::layerRepresentation
const Layer * layerRepresentation() const
returns layer representation
Definition: DetachedTrackingVolume.h:136
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
Muon::MuonStationBuilderImpl::m_muonMaterial
Trk::Material m_muonMaterial
the material
Definition: MuonStationBuilderImpl.h:104
createCablingJSON.doubletPhi
int doubletPhi
Definition: createCablingJSON.py:11
Muon::MuonStationBuilderImpl::m_buildCsc
Gaudi::Property< bool > m_buildCsc
Definition: MuonStationBuilderImpl.h:113
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
MuonGM::MuonDetectorManager::cscIdHelper
const CscIdHelper * cscIdHelper() const
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonDetectorManager.h:224
Trk::Material
Definition: Material.h:116
Trk::BinnedArray
Definition: BinnedArray.h:38
MuonGM::MdtReadoutElement::transform
virtual const Amg::Transform3D & transform(const Identifier &id) const override final
Return local to global transform associated with this identifier.
Muon::nsw::STGTPSegments::moduleIDBits::stationEta
constexpr uint8_t stationEta
1 to 3
Definition: NSWSTGTPDecodeBitmaps.h:127
Identifier::get_identifier32
Identifier32 get_identifier32(void) const
Get the 32-bit version Identifier, will be invalid if >32 bits needed.
MuonGM::MuonDetectorManager::NTgcStatTypeOff
static constexpr int NTgcStatTypeOff
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonDetectorManager.h:160
Trk::DetachedTrackingVolume::name
std::string name() const
returns the Name
Definition: DetachedTrackingVolume.h:134
Trk::positiveFaceYZ
@ positiveFaceYZ
Definition: BoundarySurfaceFace.h:35
Trk::TrackingVolume
Definition: TrackingVolume.h:121
Trk::TrackingVolume::associatedLayer
const Layer * associatedLayer(const Amg::Vector3D &gp) const
Return the associated Layer.
Definition: TrackingVolume.cxx:569
Trk::Surface::transform
const Amg::Transform3D & transform() const
Returns HepGeom::Transform3D by reference.
Material
@ Material
Definition: MaterialTypes.h:8
Trk::BinnedArraySpan
std::span< T > BinnedArraySpan
Definition: BinnedArray.h:34
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
Muon::MuonStationBuilderImpl::identifyLayers
void identifyLayers(Trk::DetachedTrackingVolume *, Identifier, int, int, const MuonGM::MuonDetectorManager *) const
Definition: MuonStationBuilderImpl.cxx:185
mag
Scalar mag() const
mag method
Definition: AmgMatrixBasePlugin.h:25
Muon::release
std::vector< ObjType * > release(std::vector< std::unique_ptr< ObjType >> &objVec)
Definition: MuonSpectrometer/MuonDetDescr/MuonTrackingGeometry/MuonTrackingGeometry/Utils.h:18
Muon::MuonStationBuilderImpl::m_buildBarrel
Gaudi::Property< bool > m_buildBarrel
Definition: MuonStationBuilderImpl.h:111
plotBeamSpotMon.nc
int nc
Definition: plotBeamSpotMon.py:83
MuonGM::MuonReadoutElement::getStationPhi
int getStationPhi() const
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonReadoutElement.h:194
MuonGM::MuonReadoutElement::getStationEta
int getStationEta() const
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonReadoutElement.h:193
fitman.k
k
Definition: fitman.py:528
Trk::Layer
Definition: Layer.h:73
Muon::MuonStationBuilderImpl::DetachedVolVec
std::vector< std::unique_ptr< Trk::DetachedTrackingVolume > > DetachedVolVec
Definition: MuonStationBuilderImpl.h:48
Generated on Fri Jun 28 2024 22:22:37 for ATLAS Offline Software by   doxygen 1.8.18