Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Public Member Functions | Private Attributes | List of all members
HGTD_TrackingGeometryBuilderCond Class Reference

#include <HGTD_TrackingGeometryBuilderCond.h>

Inheritance diagram for HGTD_TrackingGeometryBuilderCond:
Collaboration diagram for HGTD_TrackingGeometryBuilderCond:

Public Member Functions

 HGTD_TrackingGeometryBuilderCond (const std::string &, const std::string &, const IInterface *)
 Constructor. More...
 
virtual ~HGTD_TrackingGeometryBuilderCond ()
 Destructor. More...
 
virtual StatusCode initialize () override
 AlgTool initailize method. More...
 
virtual std::unique_ptr< Trk::TrackingGeometry > trackingGeometry (const EventContext &ctx, Trk::TrackingVolume *innerVol, SG::WriteCondHandle< Trk::TrackingGeometry > &whandle) const override
 TrackingGeometry Interface method. More...
 
virtual Trk::GeometrySignature geometrySignature () const override
 The unique signature. More...
 

Private Attributes

ServiceHandle< IEnvelopeDefSvc > m_enclosingEnvelopeSvc
 Service to handle the envelope definition. More...
 
ToolHandle< Trk::ILayerBuilderCond > m_layerBuilder
 Helper tools for the geometry building. More...
 
ToolHandle< Trk::ITrackingVolumeCreator > m_trackingVolumeCreator
 Helper Tool to create TrackingVolumes. More...
 
bool m_indexStaticLayers
 configurations for the layer builder More...
 
bool m_buildBoundaryLayers
 create boundary layers More...
 
bool m_replaceJointBoundaries
 run with replacement of all joint boundaries
More...
 
int m_layerBinningType
 binning type for layers More...
 
unsigned int m_colorCodeConfig
 Color code for layers. More...
 

Detailed Description

Definition at line 31 of file HGTD_TrackingGeometryBuilderCond.h.

Constructor & Destructor Documentation

◆ HGTD_TrackingGeometryBuilderCond()

HGTD_TrackingGeometryBuilderCond::HGTD_TrackingGeometryBuilderCond ( const std::string &  t,
const std::string &  n,
const IInterface *  p 
)

Constructor.

Definition at line 31 of file HGTD_TrackingGeometryBuilderCond.cxx.

31  :
32  base_class(t,n,p),
33  m_enclosingEnvelopeSvc("AtlasEnvelopeDefSvc", n),
34  m_trackingVolumeCreator("Trk::CylinderVolumeCreator/CylinderVolumeCreator"),
35  m_indexStaticLayers(true),
36  m_buildBoundaryLayers(true),
37  m_replaceJointBoundaries(true),
38  m_layerBinningType(2),
39  m_colorCodeConfig(3)
40 {
41  // envelope definition service
42  declareProperty("EnvelopeDefinitionSvc", m_enclosingEnvelopeSvc );
43  declareProperty("LayerBuilder", m_layerBuilder);
44  declareProperty("TrackingVolumeCreator", m_trackingVolumeCreator);
45 
46  declareProperty("IndexStaticLayers", m_indexStaticLayers);
47  declareProperty("BuildBoundaryLayers", m_buildBoundaryLayers);
48  declareProperty("ReplaceAllJointBoundaries", m_replaceJointBoundaries);
49  declareProperty("LayerBinningType", m_layerBinningType);
50  declareProperty("ColorCode", m_colorCodeConfig);
51 
52 }

◆ ~HGTD_TrackingGeometryBuilderCond()

HGTD_TrackingGeometryBuilderCond::~HGTD_TrackingGeometryBuilderCond ( )
virtualdefault

Destructor.

Member Function Documentation

◆ geometrySignature()

virtual Trk::GeometrySignature HGTD_TrackingGeometryBuilderCond::geometrySignature ( ) const
inlineoverridevirtual

The unique signature.

Definition at line 52 of file HGTD_TrackingGeometryBuilderCond.h.

52 { return Trk::HGTD; }

◆ initialize()

StatusCode HGTD_TrackingGeometryBuilderCond::initialize ( )
overridevirtual

AlgTool initailize method.

Definition at line 60 of file HGTD_TrackingGeometryBuilderCond.cxx.

61 {
62  // retrieve envelope definition service
63  ATH_CHECK(m_enclosingEnvelopeSvc.retrieve());
64 
65  // retrieve the layer provider
66  ATH_CHECK(m_layerBuilder.retrieve());
67 
68  // retrieve the volume creator
69  ATH_CHECK(m_trackingVolumeCreator.retrieve());
70 
71  ATH_MSG_INFO( "initialize() succesful" );
72  return StatusCode::SUCCESS;
73 }

◆ trackingGeometry()

std::unique_ptr< Trk::TrackingGeometry > HGTD_TrackingGeometryBuilderCond::trackingGeometry ( const EventContext &  ctx,
Trk::TrackingVolume *  innerVol,
SG::WriteCondHandle< Trk::TrackingGeometry > &  whandle 
) const
overridevirtual

TrackingGeometry Interface method.

Definition at line 76 of file HGTD_TrackingGeometryBuilderCond.cxx.

81 {
82 
83  ATH_MSG_VERBOSE( "Starting to build HGTD_TrackingGeometry ..." );
84 
85  // the enclosed input volume (ID)
86  double enclosedInnerSectorHalflength = std::numeric_limits<float>::max();
87  double enclosedOuterRadius = 0.;
88  double enclosedInnerRadius = 0.;
89 
90  if (innerVol) {
91  ATH_MSG_VERBOSE( "Got Inner Detector Volume: " << innerVol->volumeName() );
92  innerVol->screenDump(msg(MSG::VERBOSE));
93 
94  // retrieve dimensions
95  const Trk::CylinderVolumeBounds* innerDetectorBounds
96  = dynamic_cast<const Trk::CylinderVolumeBounds*>(&(innerVol->volumeBounds()));
97  if (!innerDetectorBounds) std::abort();
98 
99  enclosedInnerSectorHalflength = innerDetectorBounds->halflengthZ();
100  enclosedOuterRadius = innerDetectorBounds->outerRadius();
101  enclosedInnerRadius = innerDetectorBounds->innerRadius();
102  }
103 
104  float enclosedOuterSectorHalflength = std::numeric_limits<float>::max();
105  // for the HGTD we only need the first envelope definition
106  for (const auto & bounds : m_enclosingEnvelopeSvc->getCaloRZBoundary()) {
107  if (std::abs(bounds.second) < enclosedOuterSectorHalflength) {
108  enclosedOuterSectorHalflength = std::abs(bounds.second);
109  }
110  }
111 
112  // in case you have no inner volume you need to find the
113  // envelope extensions --> beampipe and HGTD
114  if (not innerVol) {
115  // from the beampipe envelope you get the inner z extension
116  for (const auto & bounds : m_enclosingEnvelopeSvc->getBeamPipeRZBoundary()) {
117  if (std::abs(bounds.second) < enclosedInnerSectorHalflength) {
118  enclosedInnerSectorHalflength = std::abs(bounds.second);
119  }
120  }
121  // from the calo envelope you get the outer radius
122  for (const auto & bounds : m_enclosingEnvelopeSvc->getCaloRZBoundary()) {
123  if (std::abs(bounds.second) == enclosedOuterSectorHalflength) {
124  if (bounds.first>enclosedOuterRadius)
125  enclosedOuterRadius=bounds.first;
126  }
127  }
128  }
129 
130  ATH_MSG_VERBOSE("Got Dimensions Zmin/Rmin - Zmax/Rmax: "
131  << enclosedInnerSectorHalflength << "/" << enclosedInnerRadius
132  << " - " << enclosedOuterSectorHalflength << "/"
133  << enclosedOuterRadius);
134 
135  // prepare the layers
136  std::vector<Trk::Layer*> negativeLayers;
137  std::vector<Trk::Layer*> positiveLayers;
138 
139  std::unique_ptr<const std::vector<Trk::DiscLayer*> > discLayers = m_layerBuilder->discLayers(ctx, whandle);
140 
141  float maxZ = -9999.;
142  float minZ = 9999.;
143  float thickness = -9999;
144 
145  // loop and fill positive and negative Layers
146  if (discLayers && !discLayers->empty()){
147  // loop over and push into the return/cache vector
148  for (const auto & discLayer : (*discLayers) ){
149  // get the center posituion
150  float zpos = discLayer->surfaceRepresentation().center().z();
151  if (zpos > 0) {
152  positiveLayers.push_back(discLayer);
153  // only saving layer info for positive side
154  // as the detector is simmetric
155  maxZ = std::max(maxZ, zpos);
156  minZ = std::min(minZ, zpos);
157  thickness = std::max(thickness, float(discLayer->thickness()));
158  }
159  else {
160  negativeLayers.push_back(discLayer);
161  }
162  }
163  }
164 
165  float envelope = thickness*0.5;
166  float minZ_HGTD = minZ-envelope;
167  float maxZ_HGTD = maxZ+envelope;
168  float maxZ_HGTDEnclosure = enclosedOuterSectorHalflength;
169 
170  // dummy material property
171  auto materialProperties = std::make_unique<Trk::Material>();
172 
173  float zGapPos = 0.5*(minZ_HGTD+enclosedInnerSectorHalflength);
174  float gapHalfLengthZ = 0.5*(minZ_HGTD-enclosedInnerSectorHalflength);
175 
176  // create the gap between the ID and the HGTD endcap volumes
177  Amg::Transform3D* negativeInnerGapTrans = new Amg::Transform3D(Amg::Translation3D(Amg::Vector3D(0.,0.,-zGapPos)));
178  Trk::CylinderVolumeBounds* negativeInnerGapBounds = new Trk::CylinderVolumeBounds(enclosedInnerRadius,enclosedOuterRadius,gapHalfLengthZ);
179 
180  Trk::TrackingVolume * negativeInnerGapVolume =
181  new Trk::TrackingVolume(negativeInnerGapTrans,
182  negativeInnerGapBounds,
183  *materialProperties,
184  nullptr, nullptr,
185  m_layerBuilder->identification()+"::NegativeInnerGap");
186 
187  Amg::Transform3D* positiveInnerGapTrans = new Amg::Transform3D(Amg::Translation3D(Amg::Vector3D(0.,0.,zGapPos)));
188  Trk::CylinderVolumeBounds* positiveInnerGapBounds = new Trk::CylinderVolumeBounds(enclosedInnerRadius,enclosedOuterRadius,gapHalfLengthZ);
189 
190  Trk::TrackingVolume * positiveInnerGapVolume =
191  new Trk::TrackingVolume(positiveInnerGapTrans,
192  positiveInnerGapBounds,
193  *materialProperties,
194  nullptr, nullptr,
195  m_layerBuilder->identification()+"::PositiveInnerGap");
196 
197  // create dummy inner volume if not built already
198  if (not innerVol) {
199  Trk::CylinderVolumeBounds* idBounds = new Trk::CylinderVolumeBounds(enclosedInnerRadius,
200  enclosedInnerSectorHalflength);
201  Amg::Transform3D* idTr = new Amg::Transform3D(Trk::s_idTransform);
202  // dummy objects
203  Trk::LayerArray* dummyLayers = nullptr;
204  Trk::TrackingVolumeArray* dummyVolumes = nullptr;
205 
206  innerVol = new Trk::TrackingVolume(idTr, idBounds, *materialProperties,
207  dummyLayers, dummyVolumes,
208  "HGTD::GapVolumes::DummyID");
209  }
210 
211  std::vector<Trk::TrackingVolume*> inBufferVolumes;
212  inBufferVolumes.push_back(negativeInnerGapVolume);
213  inBufferVolumes.push_back(innerVol);
214  inBufferVolumes.push_back(positiveInnerGapVolume);
215 
216  Trk::TrackingVolume* inDetEnclosed =
217  m_trackingVolumeCreator->createContainerTrackingVolume(inBufferVolumes,
218  *materialProperties,
219  "HGTD::Container::EnclosedInnerDetector");
220 
221  // create the tracking volumes
222  // create the three volumes
223  Trk::TrackingVolume* negativeVolume =
224  m_trackingVolumeCreator->createTrackingVolume(negativeLayers,
225  *materialProperties,
226  enclosedInnerRadius, enclosedOuterRadius,
227  -maxZ_HGTD, -minZ_HGTD,
228  m_layerBuilder->identification()+"::NegativeEndcap",
229  (Trk::BinningType)m_layerBinningType);
230 
231 
232  Trk::TrackingVolume* positiveVolume =
233  m_trackingVolumeCreator->createTrackingVolume(positiveLayers,
234  *materialProperties,
235  enclosedInnerRadius, enclosedOuterRadius,
236  minZ_HGTD, maxZ_HGTD,
237  m_layerBuilder->identification()+"::PositiveEndcap",
238  (Trk::BinningType)m_layerBinningType);
239 
240  // the base volumes have been created
241  ATH_MSG_VERBOSE('\t' << '\t'<< "Volumes have been created, now pack them into a triple.");
242  negativeVolume->registerColorCode(m_colorCodeConfig);
243  inDetEnclosed->registerColorCode(m_colorCodeConfig);
244  positiveVolume->registerColorCode(m_colorCodeConfig);
245 
246  // pack them together
247  std::vector<Trk::TrackingVolume*> tripleVolumes;
248  tripleVolumes.push_back(negativeVolume);
249  tripleVolumes.push_back(inDetEnclosed);
250  tripleVolumes.push_back(positiveVolume);
251 
252  // create the tiple container
253  Trk::TrackingVolume* tripleContainer =
254  m_trackingVolumeCreator->createContainerTrackingVolume(tripleVolumes,
255  *materialProperties,
256  "HGTD::Containers::" + m_layerBuilder->identification(),
257  m_buildBoundaryLayers,
258  m_replaceJointBoundaries);
259 
260  ATH_MSG_VERBOSE( '\t' << '\t'<< "Created container volume with bounds: " << tripleContainer->volumeBounds() );
261 
262  // finally create the two endplates: negative
263  Trk::TrackingVolume* negativeEnclosure = m_trackingVolumeCreator->createGapTrackingVolume(
264  *materialProperties,
265  enclosedInnerRadius,
266  enclosedOuterRadius,
267  -maxZ_HGTDEnclosure,
268  -maxZ_HGTD,
269  1,
270  false,
271  "HGTD::Gaps::NegativeEnclosure" + m_layerBuilder->identification());
272 
273  // finally create the two endplates: positive
274  Trk::TrackingVolume* positiveEnclosure = m_trackingVolumeCreator->createGapTrackingVolume(
275  *materialProperties,
276  enclosedInnerRadius,
277  enclosedOuterRadius,
278  maxZ_HGTD,
279  maxZ_HGTDEnclosure,
280  1,
281  false,
282  "HGTD::Gaps::PositiveEnclosure" + m_layerBuilder->identification());
283  // and the final tracking volume
284  std::vector<Trk::TrackingVolume*> enclosedVolumes;
285  enclosedVolumes.push_back(negativeEnclosure);
286  enclosedVolumes.push_back(tripleContainer);
287  enclosedVolumes.push_back(positiveEnclosure);
288 
289  Trk::TrackingVolume* enclosedDetector =
290  m_trackingVolumeCreator->createContainerTrackingVolume(enclosedVolumes,
291  *materialProperties,
292  "HGTD::Detectors::"+m_layerBuilder->identification(),
293  m_buildBoundaryLayers,
294  m_replaceJointBoundaries);
295 
296  ATH_MSG_VERBOSE( '\t' << '\t'<< "Created enclosed HGTD volume with bounds: " << enclosedDetector->volumeBounds() );
297 
298  // create the TrackingGeometry ------------------------------------------------------
299  auto hgtdTrackingGeometry = std::make_unique<Trk::TrackingGeometry>(enclosedDetector);
300 
301  if (m_indexStaticLayers and hgtdTrackingGeometry)
302  hgtdTrackingGeometry->indexStaticLayers( geometrySignature() );
303  if (msgLvl(MSG::VERBOSE) && hgtdTrackingGeometry)
304  hgtdTrackingGeometry->printVolumeHierarchy(msg(MSG::VERBOSE));
305 
306  return hgtdTrackingGeometry;
307 }

Member Data Documentation

◆ m_buildBoundaryLayers

bool HGTD_TrackingGeometryBuilderCond::m_buildBoundaryLayers
private

create boundary layers

Definition at line 66 of file HGTD_TrackingGeometryBuilderCond.h.

◆ m_colorCodeConfig

unsigned int HGTD_TrackingGeometryBuilderCond::m_colorCodeConfig
private

Color code for layers.

Definition at line 72 of file HGTD_TrackingGeometryBuilderCond.h.

◆ m_enclosingEnvelopeSvc

ServiceHandle<IEnvelopeDefSvc> HGTD_TrackingGeometryBuilderCond::m_enclosingEnvelopeSvc
private

Service to handle the envelope definition.

Definition at line 56 of file HGTD_TrackingGeometryBuilderCond.h.

◆ m_indexStaticLayers

bool HGTD_TrackingGeometryBuilderCond::m_indexStaticLayers
private

configurations for the layer builder

forces robust indexing for layers

Definition at line 64 of file HGTD_TrackingGeometryBuilderCond.h.

◆ m_layerBinningType

int HGTD_TrackingGeometryBuilderCond::m_layerBinningType
private

binning type for layers

Definition at line 70 of file HGTD_TrackingGeometryBuilderCond.h.

◆ m_layerBuilder

ToolHandle<Trk::ILayerBuilderCond> HGTD_TrackingGeometryBuilderCond::m_layerBuilder
private

Helper tools for the geometry building.

Definition at line 58 of file HGTD_TrackingGeometryBuilderCond.h.

◆ m_replaceJointBoundaries

bool HGTD_TrackingGeometryBuilderCond::m_replaceJointBoundaries
private

run with replacement of all joint boundaries

Definition at line 68 of file HGTD_TrackingGeometryBuilderCond.h.

◆ m_trackingVolumeCreator

ToolHandle<Trk::ITrackingVolumeCreator> HGTD_TrackingGeometryBuilderCond::m_trackingVolumeCreator
private

Helper Tool to create TrackingVolumes.

Definition at line 60 of file HGTD_TrackingGeometryBuilderCond.h.

The documentation for this class was generated from the following files:
HGTD_TrackingGeometryBuilderCond::m_colorCodeConfig
unsigned int m_colorCodeConfig
Color code for layers.
Definition: HGTD_TrackingGeometryBuilderCond.h:72
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
HGTD_TrackingGeometryBuilderCond::m_replaceJointBoundaries
bool m_replaceJointBoundaries
run with replacement of all joint boundaries
Definition: HGTD_TrackingGeometryBuilderCond.h:68
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
Trk::BinningType
BinningType
Definition: BinningType.h:31
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
Trk::TrackingVolume::registerColorCode
void registerColorCode(unsigned int icolor)
Register the color code.
HGTD_TrackingGeometryBuilderCond::m_indexStaticLayers
bool m_indexStaticLayers
configurations for the layer builder
Definition: HGTD_TrackingGeometryBuilderCond.h:64
HGTD_TrackingGeometryBuilderCond::m_buildBoundaryLayers
bool m_buildBoundaryLayers
create boundary layers
Definition: HGTD_TrackingGeometryBuilderCond.h:66
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
beamspotman.n
n
Definition: beamspotman.py:731
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
Trk::CylinderVolumeBounds::halflengthZ
double halflengthZ() const
This method returns the halflengthZ.
Definition: CylinderVolumeBounds.h:207
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
HGTD_TrackingGeometryBuilderCond::m_layerBinningType
int m_layerBinningType
binning type for layers
Definition: HGTD_TrackingGeometryBuilderCond.h:70
Trk::HGTD
@ HGTD
Definition: GeometrySignature.h:31
HGTD_TrackingGeometryBuilderCond::m_trackingVolumeCreator
ToolHandle< Trk::ITrackingVolumeCreator > m_trackingVolumeCreator
Helper Tool to create TrackingVolumes.
Definition: HGTD_TrackingGeometryBuilderCond.h:60
HGTD_TrackingGeometryBuilderCond::m_enclosingEnvelopeSvc
ServiceHandle< IEnvelopeDefSvc > m_enclosingEnvelopeSvc
Service to handle the envelope definition.
Definition: HGTD_TrackingGeometryBuilderCond.h:56
HGTD_TrackingGeometryBuilderCond::geometrySignature
virtual Trk::GeometrySignature geometrySignature() const override
The unique signature.
Definition: HGTD_TrackingGeometryBuilderCond.h:52
Trk::CylinderVolumeBounds
Definition: CylinderVolumeBounds.h:70
Trk::TrackingVolume::volumeName
const std::string & volumeName() const
Returns the VolumeName - for debug reason, might be depreciated later.
Trk::CylinderVolumeBounds::outerRadius
double outerRadius() const
This method returns the outer radius.
Definition: CylinderVolumeBounds.h:191
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Trk::CylinderVolumeBounds::innerRadius
double innerRadius() const
This method returns the inner radius.
Definition: CylinderVolumeBounds.h:187
Amg::Translation3D
Eigen::Translation< double, 3 > Translation3D
Definition: GeoPrimitives.h:44
Trk::Volume::volumeBounds
const VolumeBounds & volumeBounds() const
returns the volumeBounds()
Definition: Volume.h:97
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:13
Trk::BinnedArray
Definition: BinnedArray.h:38
Trk::TrackingVolume
Definition: TrackingVolume.h:121
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
HGTD_TrackingGeometryBuilderCond::m_layerBuilder
ToolHandle< Trk::ILayerBuilderCond > m_layerBuilder
Helper tools for the geometry building.
Definition: HGTD_TrackingGeometryBuilderCond.h:58
Trk::TrackingVolume::screenDump
void screenDump(MsgStream &msg) const
Definition: TrackingVolume.cxx:1493
Generated on Thu Apr 24 2025 21:34:15 for ATLAS Offline Software by   doxygen 1.8.18