ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
MuonChamber.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "GeoPrimitives/GeoPrimitives.h"
6 #include "MuonGeoModel/Csc.h"
7 #include "MuonGeoModel/Cutout.h"
8 #include "MuonGeoModel/Ded.h"
9 #include "MuonGeoModel/FPVMAP.h"
10 #include "MuonGeoModel/Mdt.h"
11 #include "MuonGeoModel/MuonChamber.h"
12 #include "MuonGeoModel/Position.h"
13 #include "MuonGeoModel/Rpc.h"
14 #include "MuonGeoModel/Spacer.h"
15 #include "MuonGeoModel/SpacerBeam.h"
16 #include "MuonGeoModel/Station.h"
17 #include "MuonGeoModel/Tgc.h"
18 #include "MuonReadoutGeometry/GlobalUtilities.h"
19 #include "MuonReadoutGeometry/MuonDetectorManager.h"
20 #include "MuonReadoutGeometry/MuonStation.h"
21 //
22 #include "MuonGeoModel/CbmComponent.h"
23 #include "MuonGeoModel/CscComponent.h"
24 #include "MuonGeoModel/LbiComponent.h"
25 #include "MuonGeoModel/MdtComponent.h"
26 #include "MuonGeoModel/RpcComponent.h"
27 #include "MuonGeoModel/StandardComponent.h"
28 #include "MuonGeoModel/SupComponent.h"
29 #include "MuonGeoModel/TgcComponent.h"
30 #include "MuonReadoutGeometry/CscReadoutElement.h"
31 #include "MuonReadoutGeometry/MdtReadoutElement.h"
32 #include "MuonReadoutGeometry/RpcReadoutElement.h"
33 #include "MuonReadoutGeometry/TgcReadoutElement.h"
34 
35 // just to check subtype, cutout:
36 #include "MuonGeoModel/CSC_Technology.h"
37 #include "MuonGeoModel/LBI_Technology.h"
38 #include "MuonGeoModel/MDT_Technology.h"
39 #include "MuonGeoModel/MYSQL.h"
40 #include "MuonGeoModel/RPC_Technology.h"
41 #include "MuonGeoModel/TGC_Technology.h"
42 //
43 #include "MuonIdHelpers/CscIdHelper.h"
44 #include "MuonIdHelpers/MdtIdHelper.h"
45 #include "MuonIdHelpers/RpcIdHelper.h"
46 #include "MuonIdHelpers/TgcIdHelper.h"
47 //
48 #include "GaudiKernel/SystemOfUnits.h"
49 #include "GeoModelKernel/GeoBox.h"
50 #include "GeoModelKernel/GeoDefinitions.h"
51 #include "GeoModelKernel/GeoFullPhysVol.h"
52 #include "GeoModelKernel/GeoIdentifierTag.h"
53 #include "GeoModelKernel/GeoLogVol.h"
54 #include "GeoModelKernel/GeoMaterial.h"
55 #include "GeoModelKernel/GeoNameTag.h"
56 #include "GeoModelKernel/GeoPhysVol.h"
57 #include "GeoModelKernel/GeoSerialDenominator.h"
58 #include "GeoModelKernel/GeoShapeIntersection.h"
59 #include "GeoModelKernel/GeoShapeShift.h"
60 #include "GeoModelKernel/GeoShapeSubtraction.h"
61 #include "GeoModelKernel/GeoShapeUnion.h"
62 #include "GeoModelKernel/GeoTransform.h"
63 #include "GeoModelKernel/GeoTrd.h"
64 #include "GeoModelKernel/GeoTube.h"
65 
66 #include <fstream>
67 #include <iomanip>
68 #include <vector>
69 
70 #define RPCON true
71 #define useAssemblies false
72 
73 namespace {
74  // const maps holding the y/z translation for BIS RPCs (since they cannot be parsed by amdb)
75  const std::map<std::string, float> rpcYTrans = {
76  std::make_pair<std::string, float>("RPC26", -9.1), // big RPC7
77  std::make_pair<std::string, float>("RPC27", -9.1), // small RPC7
78  std::make_pair<std::string, float>("RPC28", -27.7), // big RPC8
79  std::make_pair<std::string, float>("RPC29", -8.8), // small RPC8
80  };
81  const std::map<std::string, float> rpcZTrans = {
82  std::make_pair<std::string, float>("RPC26", 3.22), // big RPC7
83  std::make_pair<std::string, float>("RPC27", 3.06), // small RPC7
84  std::make_pair<std::string, float>("RPC28", 3.11), // big RPC8
85  std::make_pair<std::string, float>("RPC29", 3.11), // small RPC8
86  };
87 } // namespace
88 
89 namespace MuonGM {
90 
91  // cutouts for BMS at eta=+-1 and phi=4 (RPC/DED/MDT) ok //16 tubes shorter + entire RPC and DED (of dbz1) narrower
92 
93  MuonChamber::MuonChamber(const MYSQL& mysql, Station *s) :
94  DetectorElement(s->GetName()),
95  AthMessaging{"MuGM::MuonChamber"} {
96  width = s->GetWidth1();
97  longWidth = s->GetWidth2();
98  thickness = s->GetThickness(mysql);
99  length = s->GetLength();
100  m_station = s;
101 
102  // CSL envelope is too small for its components - enlarge it slightly
103  std::string stname(m_station->GetName(), 0, 3);
104  if (stname == "CSL")
105  longWidth *= 1.015;
106 
107  }
108 
109  GeoVPhysVol *MuonChamber::build(StoredMaterialManager& matManager,
110  const MYSQL& mysql,
111  MuonDetectorManager *manager, int zi, int fi, bool is_mirrored, bool &isAssembly) {
112  ATH_MSG_VERBOSE( " Building a MuonChamber for m_station " << m_station->GetName() << " at zi, fi " << zi << " " << fi + 1 << " is_mirrored " << is_mirrored
113  << " is assembly = " << isAssembly );
114 
115  std::string stname(m_station->GetName(), 0, 3);
116 
117  double halfpitch = m_station->mdtHalfPitch(mysql);
118  const std::string stName = m_station->GetName();
119 
120  const MdtIdHelper *mdt_id = manager->mdtIdHelper();
121  int stationType = mdt_id->stationNameIndex(stName.substr(0, 3));
122  bool is_barrel = (stName.compare(0, 1, "B") == 0);
123 
124  std::string geometry_version = manager->geometryVersion();
125  double extratop = m_station->GetExtraTopThickness();
126  double extrabottom = m_station->GetExtraBottomThickness();
127  double totthick = thickness + extratop + extrabottom;
128 
129  GeoTrd *maintrd;
130  maintrd = new GeoTrd(totthick / 2, totthick / 2, width / 2, longWidth / 2, length / 2);
131 
132  if (length <= 0) {
133  ATH_MSG_ERROR( " Invalid length " << length << " for m_station " << m_station->GetName() << " fi/zi " << fi + 1 << "/" << zi );
134  }
135 
136  ATH_MSG_VERBOSE( " MuonChamber size thick,w,lw,l " << totthick << ", " << width << ", " << longWidth << ", " << length );
137 
138  const GeoShape *strd = nullptr;
139  double dx = 0.;
140  if ((extratop + extrabottom) != 0.) {
141  // sup on top & bottom
142  dx = extratop / 2. - extrabottom / 2.;
143 
144  ATH_MSG_VERBOSE( " m_station name " << m_station->GetName() << " extra top, bottom, dx = " << extratop << " " << extrabottom );
145  strd = &((*maintrd) << GeoTrf::Translate3D(dx, 0., 0.));
146  } else {
147  strd = maintrd;
148  }
149 
150  double amdbOrigine_along_length = m_station->getAmdbOrigine_along_length();
151  double amdbOrigine_along_thickness = m_station->getAmdbOrigine_along_thickness(mysql);
152 
153  // Fix clash of EIS1 and CSS1. Cut out upper corner of CSS1 envelope (along long width)
154  if (stname == "CSS") {
155  StandardComponent *comp = nullptr;
156  double clen = 0;
157  double cthick = 0;
158  double cypos = 0;
159  double cxpos = 0;
160  for (int i = 0; i < m_station->GetNrOfComponents(); i++) {
161  comp = (StandardComponent *)m_station->GetComponent(i);
162  if ((comp->name).compare(0, 3, "CSC") == 0) {
163  clen = comp->dy;
164  cthick = comp->GetThickness(mysql);
165  cypos = clen - comp->posy + 1.0 - length / 2.;
166  cxpos = -totthick / 2. + comp->posz + cthick / 2. + 0.1;
167  break;
168  }
169  }
170  GeoIntrusivePtr<GeoShape> box{new GeoBox(cthick / 2., longWidth / 2., (length - clen) / 2.)};
171  strd = &(strd->subtract((*box) << GeoTrf::Translate3D(cxpos, 0., cypos)));
172  }
173 
174  if (m_enableFineClashFixing > 0) {
175  // Mother volume modifications for specific chambers
176 
177  // Fix clashes of non-cutout BMS with BTWingRib
178  if ((stname == "BMS" && std::abs(zi) == 5) || (stname == "BMS" && std::abs(zi) == 1 && fi != 3)) {
179  StandardComponent *comp = nullptr;
180  double cutlen = 0.;
181  double cutthick = 0.;
182  double top_edge = 0.;
183  for (int i = m_station->GetNrOfComponents() - 2; i > -1; i--) {
184  comp = (StandardComponent *)m_station->GetComponent(i);
185  top_edge = comp->posy + comp->dy;
186  cutlen = length - top_edge;
187  if ((comp->posy != 0 && cutlen > 0.1) || comp->dy > 0.75 * length) {
188  cutthick = comp->GetThickness(mysql) + 1.;
189  break;
190  }
191  }
192  GeoIntrusivePtr<GeoShape> box1{new GeoBox(cutthick / 2., (longWidth + 2.) / 2., cutlen)};
193  strd = &(strd->subtract((*box1) << GeoTrf::Translate3D((totthick - cutthick) / 2., 0., length / 2.)));
194  }
195  }
196 
197  // Skip mother volume modifications for assembly volumes since they cannot cause clash
198  if (!isAssembly) {
199  bool testEIL = (stname == "EIL" && std::abs(zi) != 1 && (std::abs(zi) != 4 || fi == 0 || fi == 4));
200 
201  if ((m_enableFineClashFixing && (stname == "BML" || stname == "BIL" || stname == "BOL" || stname == "BMS" || stname == "BIS" || stname == "BOS")) || testEIL) {
202  double root3 = 1.7320508;
203  StandardComponent *comp = nullptr;
204  double mdt_half_thick = -1.;
205  double mdt_pos = 0.;
206  double xtube1 = 0;
207  double xtube2 = 0;
208 
209  int index = 0;
210  int mdt_index[4] = {0, 0, 0, 0};
211  for (int i = 0; i < m_station->GetNrOfComponents(); i++) {
212  comp = (StandardComponent *)m_station->GetComponent(i);
213  if (comp->name.compare(0,3,"MDT") == 0) {
214  mdt_index[index] = i;
215  index += 1;
216  }
217  }
218 
219  // Prepare boxes and cylinders for chamber volume mods
220  GeoIntrusivePtr<GeoShape> box{new GeoBox((totthick + 2.) / 2., (longWidth + 2.) / 2., halfpitch)};
221  GeoIntrusivePtr<const GeoShape> frontcyl{new GeoTube(0.0, halfpitch + 0.001, longWidth / 2.)};
222  frontcyl = &((*frontcyl) << GeoTrf::RotateX3D(90. * Gaudi::Units::deg));
223  GeoIntrusivePtr<const GeoShape> backcyl{new GeoTube(0.0, halfpitch - 0.001, (longWidth + 2.) / 2.)};
224  backcyl = &((*backcyl) << GeoTrf::RotateX3D(90. * Gaudi::Units::deg));
225 
226  if (index > 0) {
227  // If chamber has MDTs, shorten length by halfpitch (remove what was added in DBReader.h)
228  strd = &(strd->subtract((*box) << GeoTrf::Translate3D(0., 0., length / 2.)));
229  double sign = 1.;
230  for (int i = 0; i < index; i++) {
231  comp = (StandardComponent *)m_station->GetComponent(mdt_index[i]);
232  mdt_half_thick = comp->GetThickness(mysql) / 2.;
233  mdt_pos = -totthick / 2. + comp->posz + mdt_half_thick;
234  mdt_pos += amdbOrigine_along_thickness;
235  xtube1 = sign * (mdt_half_thick - (root3 + 1.) * halfpitch);
236  xtube2 = sign * (mdt_half_thick - (3 * root3 + 1.) * halfpitch);
237  strd = &(strd->add((*frontcyl) << GeoTrf::Translate3D(mdt_pos + xtube1, 0., length / 2. - halfpitch)));
238  strd = &(strd->subtract((*backcyl) << GeoTrf::Translate3D(mdt_pos + xtube1, 0., -length / 2.)));
239 
240  if (stname == "BIL" || (stname == "BIS" && std::abs(zi) != 8) || testEIL) {
241  strd = &(strd->add((*frontcyl) << GeoTrf::Translate3D(mdt_pos + xtube2, 0., length / 2. - halfpitch)));
242  strd = &(strd->subtract((*backcyl) << GeoTrf::Translate3D(mdt_pos + xtube2, 0., -length / 2.)));
243  }
244 
245  sign *= -1.;
246  }
247  }
248  if (stname != "EIL") {
249  if (zi < 0 && !is_mirrored)
250  strd = &((*strd) << GeoTrf::RotateX3D(180. * Gaudi::Units::deg));
251  }
252 
253  } // fine clash fixing
254  } // !isAssembly
255 
256  // This will allow the MDT tube structure to be mirrored w.r.t. the chamber at z>0
257  // and to correctly place any other component in the m_station
258  if (zi < 0 && !is_mirrored && stName[0] == 'B') {
259  if (m_station->hasMdts()) {
260  amdbOrigine_along_length += halfpitch;
261  }
262  }
263  ATH_MSG_VERBOSE( "amdb origine: in the length direction = " << amdbOrigine_along_length
264  << " in the thickness direction = " << amdbOrigine_along_thickness);
265 
266  if (isAssembly) {
267  ATH_MSG_DEBUG( "Station " << stName << " at zi, fi " << zi << " " << fi + 1 << " will be described as Assembly" );
268  }
269 
270  // for BOG in layout Q we will have to shorten CHV, CMI as these
271  // are not shortened in AMDB
272  // double lengthShiftCP = 0.;
273 
274  // if this is a BOG, we want to make cutouts in the MOTHER VOLUME
275  if (stName.compare(0, 3, "BOG") == 0 && (manager->IncludeCutoutsBogFlag() || manager->IncludeCutoutsFlag())) {
276 
277  ATH_MSG_VERBOSE( "amdb org: length= " << amdbOrigine_along_length << " thickness= " << amdbOrigine_along_thickness );
278 
279  std::string statType = stName.substr(0, 3);
280  if (m_station->GetNrOfCutouts() > 0) {
281  ATH_MSG_DEBUG( "Station " << stName << " at zi, fi " << zi << " " << fi + 1 << " has components with cutouts " );
282  isAssembly = true;
283 
284  // look for FIRST component with cutouts and loop over all of the cutouts:
285  bool foundCutouts = false;
286  for (int j = 0; j < m_station->GetNrOfComponents(); j++) {
287  StandardComponent *c = (StandardComponent *)m_station->GetComponent(j);
288 
289  if (!foundCutouts) {
290  for (int ii = 0; ii < m_station->GetNrOfCutouts(); ii++) {
291  Cutout *cut = m_station->GetCutout(ii);
292  // if this is a BOG in layout Q, set the CP param:
293  // (both cuts have same length so ok to reset it)
294  // also do here some tweaking to prevent undershoot
295  // of the cutouts wrt mother volume:
296  if (std::abs(cut->dx - 600.7) < 0.1) {
297  cut->dx = cut->dx + 10. * Gaudi::Units::mm;
298  cut->widthXs = cut->widthXs + 20. * Gaudi::Units::mm;
299  cut->widthXl = cut->widthXl + 20. * Gaudi::Units::mm;
300  }
301  if (std::abs(cut->dx + 600.7) < 0.1) {
302  cut->dx = cut->dx - 10. * Gaudi::Units::mm;
303  cut->widthXs = cut->widthXs + 20. * Gaudi::Units::mm;
304  cut->widthXl = cut->widthXl + 20. * Gaudi::Units::mm;
305  }
306  if (std::abs(cut->lengthY - 180.2) < 0.001) {
307  cut->lengthY = cut->lengthY + (0.010) * Gaudi::Units::mm;
308  }
309  if (std::abs(cut->dy - 1019.8) < 0.001) {
310  cut->dy = 1216.4185 - cut->lengthY;
311  }
312  // create the cutout with the full thickness of the STATION
313  cut->setThickness(totthick * 1.01); // extra to be sure
314  if ((cut->subtype == mysql.allocPosFindSubtype(std::string(statType), fi, zi)) && (cut->icut == mysql.allocPosFindCutout(std::string(statType), fi, zi)) &&
315  (cut->ijob == c->index)) {
316 
317  foundCutouts = true;
318  }
319  } // Loop over cutouts
320  } // If no cutouts
321  } // Loop over components
322  }
323  } // end of special loop just for cutouts
324 
325  // remove overlaps between end-cap and forward region of TGC stations,
326  // T[1-3]E1_station and T[1-3]F1_station
327  if (stName.compare(0, 1, "T") == 0 && stName.compare(2, 1, "E") == 0 && stName.compare(1, 1, "4") != 0) {
328  GeoTrd *strdoverlap = new GeoTrd(totthick / 4, totthick / 4, width / 2, longWidth / 2, 400. / 2);
329  strd = &(strd->subtract((*strdoverlap) << GeoTrf::Translate3D(-totthick / 4., 0., -length / 2 + 400. / 2.)));
330  }
331 
332  const GeoMaterial *mtrd = nullptr;
333  if (useAssemblies || isAssembly) {
334  mtrd = matManager.getMaterial("special::Ether");
335  } else {
336  mtrd = matManager.getMaterial("std::Air");
337  }
338  GeoLogVol *ltrd = new GeoLogVol(std::string(stName) + "_Station", strd, mtrd);
339  PVLink ptrd = new GeoPhysVol(ltrd);
340 
341  double ypos{0.}, zpos{0.}, xpos{0.}, irad{0.};
342  std::array<int, 2> ndbz{0, 0};
343 
344  // Compute how many RPC modules there are in the m_station
345  int nDoubletR{0}, nRpc{0}, nTgc{0}, nCsc{0}, nMdt{0};
346  double previous_depth = 0.;
347  ATH_MSG_VERBOSE( " Station Name = " << stName << " fi/zi " << fi << "/" << zi << " defining the n. of DoubletR to " );
348 
349  for (int j = 0; j < m_station->GetNrOfComponents(); j++) {
350  StandardComponent *d = (StandardComponent *)m_station->GetComponent(j);
351  std::string_view cn = std::string_view(d->name).substr(0, 3);
352  if (cn == "RPC") {
353  nRpc++;
354  if (nRpc == 1)
355  nDoubletR++;
356  double depth = -thickness / 2. + d->posz + d->GetThickness(mysql) / 2.;
357  // std::cerr << " nRpc, nDoubletR, depth " << nRpc << " " << nDoubletR
358  // << " " << depth;
359  // BI RPC Chambers have one one doubletR
360  if (!(stname.compare(0, 2, "BI") == 0) && nDoubletR == 1 && nRpc > 1 && depth * previous_depth < 0)
361  nDoubletR++;
362  // std::cerr<<" updated to "<<nDoubletR<<std::endl;
363 
364  previous_depth = depth;
365  }
366  if (cn == "CSC") {
367  nCsc++;
368  }
369  if (cn == "TGC") {
370  nTgc++;
371  }
372  if (cn == "MDT") {
373  nMdt++;
374  }
375  }
376  ATH_MSG_DEBUG( " " << nDoubletR<<" nMdt/Rpc/Tgc/Csc " << nMdt << "/" << nRpc << "/" << nTgc << "/" << nCsc );
377 
378  // Get location and dimensions of long beams and pass them to cross beams
379  // in order to make holes
380  int numLB = -1;
381  double LBheight{0.}, LBwidth{0.}, LByShift{0.};
382  std::array<double, 2> LBpos{-1, -1};
383  for (int i = 0; i < m_station->GetNrOfComponents(); i++) {
384  StandardComponent *c = (StandardComponent *)m_station->GetComponent(i);
385  std::string_view cname = std::string_view(c->name).substr(0, 2);
386  if (cname == "LB") {
387  const LBI *lb = dynamic_cast<const LBI *>(mysql.GetTechnology(c->name));
388  LByShift = lb->yShift;
389 
390  numLB++;
391  LBpos[numLB] = c->posy + c->dy / 2.;
392  LBheight = lb->height;
393  LBwidth = c->dy;
394  }
395  if (numLB > 0)
396  break; // only 2 LBs per chamber
397  }
398 
399  for (int i = 0; i < m_station->GetNrOfComponents(); i++) {
400  StandardComponent *c = (StandardComponent *)m_station->GetComponent(i);
401  std::string_view cname = std::string_view(c->name).substr(0, 3);
402  if (cname == "CRO" || cname == "CMI" || cname == "CHV") {
403  CbmComponent *ccbm = (CbmComponent *)c;
404  ccbm->lb_height = LBheight;
405  ccbm->lb_width = LBwidth;
406  ccbm->hole_pos1 = LBpos[0];
407  ccbm->hole_pos2 = LBpos[1];
408  }
409  }
410 
411  // Look for the subtype of the CMI in the chamber to let LB know ...
412  std::string CMIcomponentNumber = "";
413  for (int j = 0; j < m_station->GetNrOfComponents(); j++) {
414  StandardComponent *d = (StandardComponent *)m_station->GetComponent(j);
415  std::string_view cn = std::string_view(d->name).substr(0, 3);
416  if (cn == "CMI") {
417  CMIcomponentNumber = (d->name).substr(3, 2);
418  break;
419  }
420  }
421 
422  for (int j = 0; j < m_station->GetNrOfComponents(); j++) {
423  StandardComponent *d = (StandardComponent *)m_station->GetComponent(j);
424  std::string_view cn = std::string_view(d->name).substr(0, 2);
425  if (cn == "LB") {
426  LbiComponent *lbic = (LbiComponent *)d;
427  if (lbic) {
428  lbic->associated_CMIsubtype = CMIcomponentNumber;
429  } else
430  ATH_MSG_ERROR( "MuonChamber :: cannot associate a CMI subtype to the LB component " );
431  }
432  }
433 
434  // Build the MuonStation(readout-geometry) corresponding to this MuonChamber(raw-geometry)
435  MuonStation *mstat{nullptr};
436  if (stName.compare(0, 1, "B") == 0) {
437  mstat = new MuonStation(stName.substr(0, 3), width, totthick, length, longWidth, totthick, length, zi, fi + 1,
438  (zi < 0 && !is_mirrored));
439  } else {
440  mstat = new MuonStation(stName.substr(0, 3), width, length, totthick, longWidth, length, totthick, zi, fi + 1,
441  (zi < 0 && !is_mirrored));
442  }
443  mstat->setPhysVol(ptrd);
444  manager->addMuonStation(std::unique_ptr<MuonStation>(mstat));
445  ATH_MSG_DEBUG( " Building a MuonStation for this MuonChamber "
446  << m_station->GetName() << " at zi, fi " << zi << " " << fi + 1 << " is_mirrored " << is_mirrored);
447 
448  // here the big loop over the components !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
449 
450  for (int i = 0; i < m_station->GetNrOfComponents(); i++) {
451  StandardComponent *c = (StandardComponent *)m_station->GetComponent(i);
452  ATH_MSG_VERBOSE( " Component index " << c->index << " in loop for " << stName << " " << stationType << " at zi, fi " << zi << " " << fi + 1 << " cName "
453  << c->name << " thickness " << c->GetThickness(mysql) << " length " << c->dy << " w, lw " << c->dx1 << " " << c->dx2 );
454  ATH_MSG_VERBOSE( " Component local (amdb) coords " << c->posx << " " << c->posy << " " << c->posz );
455 
456  ypos = -thickness / 2. + c->posz + c->GetThickness(mysql) / 2.;
457  zpos = 0.;
458  xpos = 0.;
459 
460  ypos = -thickness / 2. + (c->posz + amdbOrigine_along_thickness) + c->GetThickness(mysql) / 2.;
461  zpos = -length / 2. + amdbOrigine_along_length + c->posy + c->dy / 2.;
462  xpos = c->posx;
463 
464  const std::string &techname = c->name;
465  std::string_view type = std::string_view(techname).substr(0, 3);
466 
467  PVLink lv{}, lvd{}, lvs{}, lvo{};
468  GeoIntrusivePtr<GeoFullPhysVol> lvm{}, lvr{}, lvt{}, lvc{};
469 
470  double BeamHeight{0.};
471 
472  // Are there cutouts?
473  std::string statType = stName.substr(0, 3);
474  double cthickness = c->GetThickness(mysql);
475  int ncutouts = 0;
476  std::vector<Cutout *> vcutdef;
477  std::vector<std::unique_ptr<Cutout>> vcutdef_todel;
478  for (int ii = 0; ii < m_station->GetNrOfCutouts(); ii++) {
479  Cutout *cut = m_station->GetCutout(ii);
480  cut->setThickness(cthickness * 1.01); // extra thickness to be sure
481 
482  if ((cut->subtype == mysql.allocPosFindSubtype(std::string(statType), fi, zi)) && (cut->icut == mysql.allocPosFindCutout(std::string(statType), fi, zi)) && (cut->ijob == c->index)) {
483 
484  double tempdx = cut->dx;
485  double tempdy = cut->dy;
486  double templengthY = cut->lengthY;
487  cut->dx = 0.;
488  cut->dy = 0.;
489 
490  if (stName.compare(0, 3, "BOG") == 0) {
491  // make the cutouts a bit longer
492  cut->lengthY = templengthY + 31.;
493  }
494 
495  cut->dx = tempdx;
496  cut->dy = tempdy;
497 
498  if (std::abs(cut->dead1) > 1. && techname == "MDT03")
499  cut->dy = cut->dy + 15.0 * cos(cut->dead1 * Gaudi::Units::deg);
500  // should compensate for the dy position defined in amdb at the bottom of the foam in ML 1 of EMS1,3 and BOS 6
501  // can be applied only for layout >=r.04.04 in rel 15.6.X.Y due to the frozen Tier0 policy
502 
503  cut->lengthY = templengthY;
504  // in thickness, cutout will coincide with component
505  // not needed (DHW) double xposcut = 0.; // rel. to component thickness
506  // double yposcut = -xpos+cut->dx; // rel. to component width
507  // double zposcut = -zpos+cut->dy; // rel. to component length
508  // if (stName.substr(0,3)=="BOG")
509  // {
510  // move the extended cut region out a little
511  // if (cut->dy < 10.) zposcut = -zpos+cut->dy - 15.5;
512  // }
513  ncutouts++;
514  ATH_MSG_VERBOSE( "A new cutout for this component " );
515  ATH_MSG_VERBOSE( *cut );
516 
517  // Corrected cutout values for BMS7, BMS14
518  if (stName.compare(0, 3, "BMS") == 0) {
519  if (fi == 3) { // stationPhi = 4
520  if (std::abs(zi) == 1) { // stationEta = +-1
521  double margin = 1.0; // make cutout a little bigger to avoid coincident boundaries
522 
523  if (type == "RPC" || type == "DED") {
524  cut->widthXl += 2 * margin;
525  cut->widthXs += 2 * margin;
526  cut->dx += margin;
527  cut->lengthY += 2 * margin;
528 
529  if (zi > 0)
530  cut->dy = -margin;
531  }
532  }
533 
534  if (zi == -1) {
535  if (type == "MDT")
536  cut->dy = 0.;
537  }
538  }
539  }
540 
541  // the following is a fine tuning ----- MUST CHECK for a better solution
542  if (stName.compare(0, 3,"BOS") == 0 && zi == -6 && type == "MDT") {
543  cut->dy = c->dy - cut->dy - cut->lengthY - halfpitch;
544  cut->dead1 = 30.; // why this is not 30. or -30. already ?????
545  if (techname == "MDT03")
546  cut->dy = cut->dy + 30.0; // *cos(cut->dead1*Gaudi::Units::deg);
547 
548  ATH_MSG_VERBOSE( "Cut dead1 for BOS 6 on C side is " << cut->dead1 );
549 
550  }
551 
552  // this mirroring of the cutout is necessary only for barrel MDT chambers; for EC the cutout will be automatically mirrored
553  // this fix cannot be applied in 15.6.X.Y for layout < r.04.04 due to the frozen tier0 policy
554 
555  if (type == "MDT" && (is_mirrored || zi < 0) && stName.compare(0, 1, "B") == 0) {
556  // MDT in chambers explicitly described at z<0 have to be
557  // rotated by 180deg to adj. tube staggering
558  // reverse the position (x amdb) of the cutout if the m_station is mirrored
559  Cutout *cutmirr = new Cutout(*cut);
560  cutmirr->dx = -cutmirr->dx;
561  // this way, after the rotation by 180 Gaudi::Units::deg, the cut will be at the same global phi
562  // it has for the m_station at z>0
563  vcutdef.push_back(cutmirr);
564  vcutdef_todel.emplace_back(cutmirr);
565  ATH_MSG_VERBOSE( "adding for application mirrored cut \n" << *cutmirr );
566 
567  } else if (type == "RPC" || type == "DED") {
568  Cutout *cutRpcType = new Cutout(*cut);
569  // temporary for testing fixes to r.03.09
570  if (stName.compare(0, 3, "BMS") == 0 && zi == 4 && (c->index == 20 || c->index == 21 || c->index == 24 || c->index == 25)) {
571  cutRpcType->dy = 1102.5;
572  }
573 
574  if (stName.compare(0, 3, "BOS") == 0 && zi == 6 && type == "DED")
575  cutRpcType->dy = 706.;
576 
577  cutRpcType->dy = cutRpcType->dy - c->posy;
578  cutRpcType->dx = cutRpcType->dx - c->posx;
579 
580  if (type == "RPC") {
581  RpcComponent *rp = (RpcComponent *)c;
582  if (rp->iswap == -1) {
583  cutRpcType->dy = c->dy - (cutRpcType->dy + cutRpcType->lengthY);
584  }
585  }
586 
587  ATH_MSG_VERBOSE( " Rpc or ded cutout redefined as follows \n" << *cutRpcType );
588  vcutdef.push_back(cutRpcType);
589  vcutdef_todel.emplace_back(cutRpcType);
590  } else if (type == "TGC") {
591  // In AMDB, y coordinates of cutout and component are given by
592  // radius from detector z-axis. To get standard y value of cutout,
593  // subtract radius of component from radius of cutout
594  Cutout *tgccut = new Cutout(*cut);
595  tgccut->dy -= c->posy; //
596 
597  ATH_MSG_VERBOSE( " Tgc cutout redefined as follows \n" << *tgccut );
598  vcutdef.push_back(tgccut);
599  vcutdef_todel.emplace_back(tgccut);
600  } else {
601  vcutdef.push_back(cut);
602  }
603  }
604  } // Loop over cutouts in m_station
605 
606  if (ncutouts > 0) {
607  ATH_MSG_DEBUG( c->name << " of station " << stName << " at fi/zi " << fi + 1 << "/" << zi << " has " << ncutouts << " cutouts " );
608 
609  }
610  // define here the total transform that will be applied to component:
611  GeoTrf::Transform3D htcomponent(GeoTrf::Transform3D::Identity());
612  GeoTransform *xfcomponent{nullptr};
613  GeoAlignableTransform *xfaligncomponent{nullptr};
614  // for RPCs we need a vector of transforms for M28 geometry...
615 
616  if (type == "CRO") {
617  if (stName.compare(0, 1, "B") != 0 && is_mirrored)
618  mstat->setxAmdbCRO(-xpos);
619  else
620  mstat->setxAmdbCRO(xpos);
621  }
622 
623  if (type == "MDT") {
624  htcomponent = GeoTrf::TranslateX3D(ypos) * GeoTrf::TranslateZ3D(zpos) * GeoTrf::TranslateY3D(xpos);
625 
626  if (zi < 0 && !is_mirrored && stName[0] == 'B') {
627  // this (rotation + shift of halfpitch) will mirror the tube structure w.r.t. the chamber at z>0
628  htcomponent = htcomponent * GeoTrf::RotateX3D(180. * Gaudi::Units::deg);
629  htcomponent = htcomponent * GeoTrf::TranslateZ3D(halfpitch);
630  }
631 
632  // ss - 24-05-2006 I don't really understand if this is needed at all
633  // it was introduced by Isabel T.
634  if (zi < 0 && stName.compare(0, 3, "BOG") == 0 && is_mirrored) {
635  // htcomponent = htcomponent*GeoTrf::RotateX3D(180.*Gaudi::Units::deg);
636  // tubes OK but chambers wrong
637  // htcomponent = GeoTrf::RotateX3D(180.*Gaudi::Units::deg)*htcomponent;
638  // chambers OK but tubes wrong
639  htcomponent = GeoTrf::RotateX3D(180. * Gaudi::Units::deg) * htcomponent * GeoTrf::RotateX3D(180. * Gaudi::Units::deg); // turn chambers but go back for tubes
640  } // ss - 24-05-2006 I don't really understand if this is needed at all
641 
642  xfaligncomponent = new GeoAlignableTransform(htcomponent);
643  std::string key =std::string( stName) + techname;
644 
645  // for cutouts:
646  // MDT cutouts for BOS1,5, BMS7,14, (problem with BMS4,10), EMS, BMG and BIS MDT14
647  bool mdtCutoutFlag = ((stname == "BOS" && std::abs(zi) == 6) || stname == "BMG" || techname == "MDT14" || (stname == "BMS" && (std::abs(zi) == 1 && fi == 3)) ||
648  (stname == "EMS" && (std::abs(zi) == 1 || std::abs(zi) == 3)));
649  if (((manager->IncludeCutoutsFlag() && mdtCutoutFlag) || (manager->IncludeCutoutsBogFlag() && stName.compare(0, 3, "BOG") == 0)) && zi >= 0) {
650  key += "p" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0);
651  } else if (((manager->IncludeCutoutsFlag() && mdtCutoutFlag) || (manager->IncludeCutoutsBogFlag() && stName.compare(0, 3, "BOG")) == 0) && zi < 0) {
652  key += "m" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0);
653  }
654 
655  GeoVPhysVol *fpv = m_FPVMAP->GetDetector(key);
656  if (fpv == nullptr) {
657  std::unique_ptr<Mdt> r = std::make_unique<Mdt>(mysql, c, stName + techname);
658  ATH_MSG_DEBUG( " Building an MDT for station " << key << " component name is " << c->name <<
659  " stName "<<stName<<" techName: "<<techname<< " manager->IncludeCutoutsFlag() "
660  << manager->IncludeCutoutsFlag() << " manager->IncludeCutoutsBogFlag() " << manager->IncludeCutoutsBogFlag() );
661 
662 
663  if ((manager->IncludeCutoutsFlag() && mdtCutoutFlag) || (manager->IncludeCutoutsBogFlag() && stName.compare(0, 3, "BOG") == 0)) {
664  lvm = r->build(matManager, mysql, vcutdef);
665  } else {
666  lvm = r->build(matManager, mysql);
667  }
668  m_FPVMAP->StoreDetector(lvm, key);
669  } else {
670  GeoFullPhysVol *rfpv = (GeoFullPhysVol *)fpv;
671  ATH_MSG_VERBOSE( " This MDT for station " << key << " component name is " << c->name << " already exists; clone it " );
672  lvm = rfpv->clone();
673  }
674 
675  } else if (type == "SPA" && manager->MinimalGeoFlag() == 0) {
676  if (techname == "SPA01" && stName.compare(0, 1, "C") == 0) {
677  ATH_MSG_DEBUG( "Ficticious spacer SPA01 in CSC chamber - skip it " );
678  // ignore SPA 1 component of CSS/CSL chambers in R02.03 (it is there only for AMDB convenience,
679  // leaving the CSC envelop => global position of the m_station unchanged)
680  continue;
681  }
682 
683  htcomponent = GeoTrf::TranslateX3D(ypos) * GeoTrf::TranslateZ3D(zpos);
684  xfcomponent = new GeoTransform(htcomponent);
685  std::string key = std::string(stName) + techname;
686  if ((manager->IncludeCutoutsFlag() || (manager->IncludeCutoutsBogFlag() && stName.compare(0, 3, "BOG") == 0)) && zi >= 0) {
687  key += "p" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0);
688  } else if ((manager->IncludeCutoutsFlag() || (manager->IncludeCutoutsBogFlag() && stName.compare(0, 3,"BOG") == 0)) && zi < 0) {
689  key += "m" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0);
690  }
691 
692  GeoVPhysVol *fpv = m_FPVMAP->GetDetector(key);
693  if (fpv == nullptr) {
694  std::unique_ptr<Spacer>r = std::make_unique<Spacer>(mysql, c);
695  ATH_MSG_DEBUG( " Building a SPA for m_station "<< key << " component name is " << c->name );
696  if (manager->IncludeCutoutsFlag() || (manager->IncludeCutoutsBogFlag() && stName.compare(0, 3, "BOG") == 0)) {
697  lv = r->build(matManager, 1);
698  } else {
699  lv = r->build(matManager);
700  }
701  ATH_MSG_DEBUG( " Storing in FPVMAP with key " << key );
702  m_FPVMAP->StoreDetector(lv, key);
703  } else {
704  lv = fpv;
705  }
706  } else if ((type == "CHV" || type == "CRO" || type == "CMI" || type == "LB0" || type == "LBI") && manager->MinimalGeoFlag() == 0) {
707  std::unique_ptr<SpacerBeam> r = std::make_unique<SpacerBeam>(mysql, c);
708  BeamHeight = r->height;
709  ypos = c->posx;
710  double xpos = (c->posz + amdbOrigine_along_thickness) - thickness / 2. + BeamHeight / 2.;
711  if (type.compare(0, 2, "LB") == 0)
712  xpos -= LByShift;
713 
714  double angle = 0.;
715  if (std::abs(c->excent) > 0.001) {
716  angle = atan((longWidth - width) / length / 2.);
717  if (c->excent < 0.)
718  angle = -angle;
719  }
720 
721  // This is an attempt to provide some info to LB construction in order
722  // to avoid the clash of LB with CXx in the endcaps ...
723  if (type == "LB0") {
724  if (stName == "EML1" || stName == "EML6") {
725  if ((c->dx1 > width) && zpos < 0.) {
726  r->width = 0.98 * width;
727  }
728  if ((c->dx1 / longWidth) > 0.98 && zpos > 0.) {
729  double mywidth = 0.93 * longWidth;
730  r->width = mywidth;
731  }
732  }
733  }
734 
735  if (type == "CMI" || type == "CHV" || type == "CRO") {
736  // Shorten CHV, CMI lengths to fit in BOL4 envelope
737  if (stname == "BOL" && zi == 1 && (fi + 1) == 3) {
738  r->length = length - halfpitch;
739  zpos = -halfpitch / 2.;
740  }
741  }
742 
743  if (!is_mirrored) {
744  htcomponent = GeoTrf::Translate3D(xpos, ypos, zpos) * GeoTrf::RotateX3D(angle);
745  } else {
746  htcomponent = GeoTrf::Translate3D(xpos, -ypos, zpos) * GeoTrf::RotateX3D(-angle);
747  }
748  xfcomponent = new GeoTransform(htcomponent);
749 
750  std::string key = stName + techname;
751  if ((manager->IncludeCutoutsFlag() || (manager->IncludeCutoutsBogFlag() && stName.compare(0, 3, "BOG") == 0)) && zi >= 0) {
752  key += "p" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0);
753  } else if ((manager->IncludeCutoutsFlag() || (manager->IncludeCutoutsBogFlag() && stName.compare(0, 3, "BOG") == 0)) && zi < 0) {
754  key += "m" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0);
755  }
756  // can have LB of different length in same m_station:
757  if (type.substr(0, 2) == "LB")
758  key += buildString(int(c->dx1), 0);
759 
760  ATH_MSG_DEBUG( " Building a SpacerBeam for m_station "<< key << " component name is "<< c->name );
761  GeoVPhysVol *fpv = m_FPVMAP->GetDetector(key);
762  if (fpv == nullptr || (stName.compare(0, 3, "BOG") == 0 && type == "CMI")) {
763  if (stName.compare(0, 3, "BOG") == 0) {
764  ATH_MSG_VERBOSE( " Building a SpacerBeam for station " << key << " component name is " << c->name );
765  }
766  if (manager->IncludeCutoutsFlag() || (manager->IncludeCutoutsBogFlag() && stName.compare(0, 3, "BOG") == 0)) {
767  lvo = r->build(matManager, 1, is_barrel);
768  } else {
769  lvo = r->build(matManager, is_barrel);
770  }
771  m_FPVMAP->StoreDetector(lvo, key);
772  // AMDB origin is in bottom centre of bottom cross-piece at
773  // end of bar.
774  // From centre, it is -height/2 in x, 0 in y, -length/2 in z
775  } else {
776  if (stName.compare(0, 3,"BOG") == 0)
777  ATH_MSG_VERBOSE( " This spacerbeam for station " << key << " component name is " << c->name << " already exists; re-use it " );
778  lvo = fpv;
779  }
780 
781  } else if (type == "RPC") {
782  // position stuff needed for cutout, used to be below:
783  RpcComponent *rp = (RpcComponent *)c;
784  int ndivy = rp->ndivy;
785  int ndivz = rp->ndivz;
786 
787  if (ndivz != 1 || ndivy != 1) {
788  ATH_MSG_ERROR( " RPC segmentation z,y " << ndivz << " " << ndivy );
789  }
790 
791  double xpos = c->posx;
792  // implement really the mirror symmetry
793  if (is_mirrored)
794  xpos = -xpos;
795 
796  ATH_MSG_VERBOSE( " In station " << stName << " with " << nDoubletR << " doubletR,"
797  << " RPC " << (c->name).substr(3, 2) << " has swap flag = " << rp->iswap << " ypos, zpos " << ypos << " " << zpos << " " );
798 
799  htcomponent = GeoTrf::TranslateX3D(ypos) * GeoTrf::TranslateY3D(xpos) * GeoTrf::TranslateZ3D(zpos);
800  if (rp->iswap == -1) { // this is like amdb iswap
801  htcomponent = htcomponent * GeoTrf::RotateY3D(180 * Gaudi::Units::deg);
802  }
803  xfaligncomponent = new GeoAlignableTransform(htcomponent);
804 
805  // end of position stuff
806 
807  bool rpcCutoutFlag = (stname == "BOS" && std::abs(zi) == 6) || (stname == "BMS" && (std::abs(zi) == 2 || std::abs(zi) == 4 || std::abs(zi) == 6)) ||
808  (stname == "BMS" && std::abs(zi) == 1 && fi == 3);
809  std::string key = stName + techname;
810  if (((manager->IncludeCutoutsFlag() && rpcCutoutFlag) || (manager->IncludeCutoutsBogFlag() && stName.compare(0, 3, "BOG") == 0)) && zi >= 0) {
811  key += "p" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0) + "_" +
812  buildString(vcutdef.size(), 0) + "_" + buildString(rp->iswap, 0);
813  } else if (((manager->IncludeCutoutsFlag() && rpcCutoutFlag) || (manager->IncludeCutoutsBogFlag() && stName.compare(0, 3, "BOG") == 0)) && zi < 0) {
814  key += "m" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0) + "_" +
815  buildString(vcutdef.size(), 0) + "_" + buildString(rp->iswap, 0);
816  }
817  PVLink fpv = m_FPVMAP->GetDetector(key);
818  if (fpv == nullptr) {
819  std::unique_ptr<Rpc> r = std::make_unique<Rpc>(mysql, c);
820  r->setLogVolName(std::string(stName) + techname);
821  if (stName.find("BI") != std::string::npos) {
822  std::map<std::string, float>::const_iterator yItr = rpcYTrans.find(techname);
823  if (yItr != rpcYTrans.end())
824  r->y_translation = yItr->second;
825  std::map<std::string, float>::const_iterator zItr = rpcZTrans.find(techname);
826  if (zItr != rpcZTrans.end())
827  r->z_translation = zItr->second;
828  }
829 
830  if ((manager->IncludeCutoutsFlag() && rpcCutoutFlag) || (manager->IncludeCutoutsBogFlag() && stName.compare(0, 3, "BOG") == 0)) {
831  lvr = r->build(matManager, mysql, manager->MinimalGeoFlag(), 1, vcutdef);
832  } else {
833  lvr = r->build(matManager, mysql, manager->MinimalGeoFlag());
834  }
835 
836  m_FPVMAP->StoreDetector(lvr, key);
837  } else {
838  auto rfpv = dynamic_pointer_cast<GeoFullPhysVol>(fpv);
839  lvr = rfpv->clone();
840  }
841 
842  } else if (type == "DED" && manager->MinimalGeoFlag() == 0) {
843  double xpos = c->posx;
844  if (is_mirrored)
845  xpos = -xpos;
846  htcomponent = GeoTrf::TranslateX3D(ypos) * GeoTrf::TranslateY3D(xpos) * GeoTrf::TranslateZ3D(zpos);
847 
848  xfcomponent = new GeoTransform(htcomponent);
849 
850  bool dedCutoutFlag = (stname == "BOS" && std::abs(zi) == 6) || (stname == "BMS" && (std::abs(zi) == 2 || std::abs(zi) == 4 || std::abs(zi) == 6)) ||
851  (stname == "BMS" && std::abs(zi) == 1 && fi == 3);
852  std::string key = std::string(stName) + techname;
853  if (((manager->IncludeCutoutsFlag() && dedCutoutFlag) || (manager->IncludeCutoutsBogFlag() && stName.compare(0, 3,"BOG") == 0)) && zi >= 0) {
854  key += "p" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0) + "_" +
855  buildString(vcutdef.size(), 0);
856  } else if (((manager->IncludeCutoutsFlag() && dedCutoutFlag) || (manager->IncludeCutoutsBogFlag() && stName.compare(0, 3, "BOG") == 0)) && zi < 0) {
857  key += "m" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0) + "_" +
858  buildString(vcutdef.size(), 0);
859  }
860  key += buildString(int(c->dy), 0) + "_" + buildString(int(c->dx1), 0);
861  PVLink fpv = m_FPVMAP->GetDetector(key);
862 
863  if (fpv == nullptr) {
864  std::unique_ptr<Ded> r = std::make_unique<Ded>(mysql, c);
865  ATH_MSG_VERBOSE( " Building a DED for station " << key << " component name is " << c->name );
866  if ((manager->IncludeCutoutsFlag() && dedCutoutFlag) || (manager->IncludeCutoutsBogFlag() && stName.compare(0, 3, "BOG") == 0)) {
867  lvd = r->build(matManager, mysql, 1, vcutdef);
868  } else {
869  lvd = r->build(matManager, mysql);
870  }
871 
872  m_FPVMAP->StoreDetector(lvd, key);
873  } else {
874  lvd = fpv;
875  ATH_MSG_VERBOSE( " Re-using DED for station " << key << " component name is " << c->name );
876  }
877 
878  } else if (type == "SUP" && manager->MinimalGeoFlag() == 0) {
879  ypos = -thickness / 2. + c->posz;
880  double zpos = -length / 2. + c->posy + c->dy / 2. - SupComponent::zAMDB0(mysql, *c);
881  ypos = ypos - SupComponent::xAMDB0(mysql, *c);
882  double xpos = c->posx - SupComponent::yAMDB0(mysql, *c);
883 
884  htcomponent = GeoTrf::TranslateX3D(ypos) * GeoTrf::TranslateY3D(xpos) * GeoTrf::TranslateZ3D(zpos);
885  std::string key = std::string(stName) + techname;
886  if ((manager->IncludeCutoutsFlag() || (manager->IncludeCutoutsBogFlag() && stName.compare(0, 3,"BOG") == 0)) && zi >= 0) {
887  key += "p" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0);
888  } else if ((manager->IncludeCutoutsFlag() || (manager->IncludeCutoutsBogFlag() && stName.compare(0, 3,"BOG") == 0)) && zi < 0) {
889  key += "m" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0);
890  }
891 
892  GeoVPhysVol *fpv = m_FPVMAP->GetDetector(key);
893  if (fpv == nullptr) {
894  m_FPVMAP->StoreDetector(lvs, key);
895  } else {
896  lvs = fpv;
897  }
898 
899  } else if (type == "TGC") {
900  TgcComponent *tg = (TgcComponent *)m_station->GetComponent(i);
901  TgcComponent *tgInner = (TgcComponent *)m_station->GetComponent(0);
902  irad = tgInner->posy;
903  TgcComponent *tgOuter = (TgcComponent *)m_station->GetComponent(m_station->GetNrOfComponents() - 1);
904  double orad = tgOuter->posy + tgOuter->dy;
905  double start = -(orad - irad) / 2. + (tg->posy - irad) + tg->dy / 2;
906  double xstart = -thickness / 2. + tg->GetThickness(mysql) / 2.;
907  htcomponent = GeoTrf::TranslateX3D(xstart + tg->posz) * GeoTrf::TranslateZ3D(start);
908  xfaligncomponent = new GeoAlignableTransform(htcomponent);
909 
910  // Define key for this TGC component
911  std::string key = std::string(stName) + techname;
912  if (manager->IncludeCutoutsFlag()) {
913  if (mysql.allocPosFindCutout(statType, fi, zi) > 0) {
914  // If there is a cutout for this chamber, give it a special key
915  if (zi >= 0) {
916  key += "p" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0);
917  } else if (zi < 0) {
918  key += "m" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0);
919  }
920  }
921  }
922 
923  char chswidth[32];
924  sprintf(chswidth, "%i", static_cast<int>(10 * c->dx1));
925  key += chswidth;
926 
927  GeoVPhysVol *fpv = m_FPVMAP->GetDetector(key);
928  if (fpv == nullptr) {
929  std::unique_ptr<Tgc> t = std::make_unique<Tgc>(mysql, c);
930  t->setLogVolName(std::string(stName) + techname);
931  if (manager->IncludeCutoutsFlag()) {
932  lvt = t->build(matManager, mysql, manager->MinimalGeoFlag(), 1, vcutdef);
933  } else {
934  lvt = t->build(matManager, mysql, manager->MinimalGeoFlag());
935  }
936  m_FPVMAP->StoreDetector(lvt, key);
937  } else {
938  GeoFullPhysVol *rfpv = (GeoFullPhysVol *)fpv;
939  lvt = rfpv->clone();
940  }
941 
942  } else if (type == "CSC") {
943  htcomponent = GeoTrf::TranslateX3D(ypos) * GeoTrf::TranslateZ3D(zpos);
944  xfaligncomponent = new GeoAlignableTransform(htcomponent);
945  // Here define the key for this CSC component
946  std::string key = std::string(stName) + techname;
947  if (manager->IncludeCutoutsFlag() && zi >= 0) {
948  key += "p" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0);
949  } else if (manager->IncludeCutoutsFlag() && zi < 0) {
950  key += "m" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0);
951  }
952 
953  GeoVPhysVol *fpv = m_FPVMAP->GetDetector(key);
954  if (fpv == nullptr) {
955  std::unique_ptr<Csc> t = std::make_unique<Csc>(mysql, c);
956  t->setLogVolName(std::string(stName) + techname);
957 
958  if (manager->IncludeCutoutsFlag()) {
959  lvc = t->build(matManager, mysql, manager->MinimalGeoFlag(), 1, vcutdef);
960  } else {
961  lvc = t->build(matManager, mysql, manager->MinimalGeoFlag());
962  }
963 
964  m_FPVMAP->StoreDetector(lvc, key);
965  } else {
966  GeoFullPhysVol *rfpv = (GeoFullPhysVol *)fpv;
967  lvc = rfpv->clone();
968  }
969 
970  } else {
971  if (type != "MDT" && type != "RPC" && type != "TGC" && type != "SUP" && type != "DED" && type != "SPA" && type != "CHV" && type != "CRO" && type != "CMI" &&
972  type != "LB0" && type != "LBI") {
973  ATH_MSG_INFO( "Unknown component " << type );
974  }
975  }
976 
977  // Place components in chamber envelope
978  if (lvm && manager->mdtIdHelper()) {
979  int stationEta = zi;
980  int stationPhi = fi + 1;
981  int ml = 1;
982  int tubel = 1;
983  int tube = 1;
984  if (ypos > 5.)
985  ml = 2; // Need >5 instead of >0 because BIS78 is not perfectly centered
986  std::string stag = "ml[" + MuonGM::buildString(ml, 0) + "]" + techname + "component";
987 
988  GeoNameTag *nm = new GeoNameTag(stag);
989  ptrd->add(new GeoIdentifierTag(c->index));
990  ptrd->add(nm);
991 
992  xfaligncomponent->setDelta(GeoTrf::Transform3D::Identity());
993  // delete xfcomponent;
994  ptrd->add(xfaligncomponent);
995  ptrd->add(lvm);
996  const MdtIdHelper *mdt_id = manager->mdtIdHelper();
997  std::unique_ptr<MdtReadoutElement> det = std::make_unique<MdtReadoutElement>(lvm, stName, manager);
998  Position ip = mysql.GetStationPosition(stName.substr(0, 3), fi, zi);
999  setMdtReadoutGeom(mysql, det.get(), (MdtComponent *)c, ip);
1000  det->setHasCutouts(ncutouts > 0);
1001  det->setNMdtInStation(nMdt);
1002  Identifier id = mdt_id->channelID(stationType, stationEta, stationPhi, ml, tubel, tube);
1003  det->setIdentifier(id);
1004  det->setMultilayer(ml);
1005  det->setParentStationPV(PVConstLink(ptrd));
1006  det->setParentMuonStation(mstat);
1007  det->geoInitDone();
1008 
1009  if (ml == 1) {
1010  // set fixed point for MDT deformations: s0,z0,t0 for the point at lowest t,z (z,y amdb) and s=x=0
1011  mstat->setBlineFixedPointInAmdbLRS(c->posx, c->posy, c->posz);
1012  } else {
1013  Amg::Vector3D b0 = mstat->getBlineFixedPointInAmdbLRS();
1014  if (c->posy < b0.y())
1015  mstat->setBlineFixedPointInAmdbLRS(b0.x(), c->posy, b0.z());
1016  }
1017 
1018  int jobIndex = c->index;
1019 
1020  mstat->addMuonReadoutElementWithAlTransf(det.get(), xfaligncomponent, jobIndex);
1021  ATH_MSG_DEBUG( std::string(stName + techname) << " trying to build a MDT Id from stType/eta/phi/ml/tl/t " << stationType << "/" << stationEta << "/"
1022  << stationPhi << "/" << ml << "/" << tubel << "/" << tube << endmsg << " Copy number is " << c->index << " tagName " << stag );
1023 
1024 
1025  manager->addMdtReadoutElement(std::move(det));
1026  }
1027 
1028  if (lvc && manager->cscIdHelper()) {
1029  CscComponent *cs = (CscComponent *)m_station->GetComponent(i);
1030  int stationEta = zi;
1031  int stationPhi = fi + 1;
1032  int chamberLayer = 1;
1033  if (ypos > 0.)
1034  chamberLayer = 2;
1035  std::string stag = "cl[" + MuonGM::buildString(chamberLayer, 0) + "]" + techname + "component";
1036  GeoNameTag *nm = new GeoNameTag(stag);
1037  ptrd->add(new GeoIdentifierTag(c->index));
1038  ptrd->add(nm);
1039 
1040  xfaligncomponent->setDelta(GeoTrf::Transform3D::Identity());
1041  // delete xfcomponent;
1042  ptrd->add(xfaligncomponent);
1043  ptrd->add(lvc);
1044 
1045  std::unique_ptr<CscReadoutElement> det = std::make_unique<CscReadoutElement>(lvc, stName, manager);
1046  Position ip = mysql.GetStationPosition(stName.substr(0, 3), fi, zi);
1047  setCscReadoutGeom(mysql, det.get(), cs, ip);
1048 
1049  const CscIdHelper *csc_id = manager->cscIdHelper();
1050  det->setHasCutouts(ncutouts > 0);
1051  Identifier id = csc_id->channelID(stationType, stationEta, stationPhi, chamberLayer, 1, 0, 1);
1052  det->setIdentifier(id);
1053  det->setChamberLayer(chamberLayer);
1054  det->setParentStationPV(PVConstLink(ptrd));
1055  det->setParentMuonStation(mstat);
1056 
1057  int jobIndex = c->index;
1058  // mstat->addMuonReadoutElement(det,jobIndex);
1059  mstat->addMuonReadoutElementWithAlTransf(det.get(), xfaligncomponent, jobIndex);
1060  ATH_MSG_DEBUG( stName << techname << " trying to build a CSC Id from stType/eta/phi/ml " << stationType << "/" << stationEta << "/"
1061  << stationPhi << "/" << chamberLayer << "/ and /1/0/1" << endmsg << " Copy number is " << c->index << " tagName " << stag );
1062 
1063  // set alignment parameters for the wire layers
1064  manager->addCscReadoutElement(std::move(det));
1065  }
1066 
1067  if (lvt && manager->tgcIdHelper()) {
1068  ATH_MSG_DEBUG( " Adding a TGC chamber to the tree zi,fi, is_mirrored " << zi << " " << fi + 1 << " " << is_mirrored );
1069 
1070  TgcComponent *tg = (TgcComponent *)m_station->GetComponent(i);
1071  ATH_MSG_VERBOSE( "There's a TGC named " << techname << " of thickness " << tg->GetThickness(mysql) );
1072 
1073  const TgcIdHelper *tgc_id = manager->tgcIdHelper();
1074  int stationEta = 0;
1075  stationEta = tg->index;
1076  if (zi < 0)
1077  stationEta = -stationEta;
1078  int stationPhi = 0;
1079  stationPhi = MuonGM::stationPhiTGC(stName, fi + 1, zi);
1080  int ttag = 1000 * stationPhi + tg->index;
1081  std::string stag = "stPhiJob[" + MuonGM::buildString(ttag, 0) + "]" + techname + "tgccomponent";
1082  GeoNameTag *nm = new GeoNameTag(stag);
1083  int geoid = 0;
1084  if (useAssemblies || isAssembly) {
1085  geoid = c->index;
1086  } else {
1087  if (zi < 0)
1088  ttag = -ttag;
1089  geoid = ttag;
1090  }
1091  ptrd->add(new GeoIdentifierTag(geoid));
1092  ptrd->add(nm);
1093 
1094  xfaligncomponent->setDelta(GeoTrf::Transform3D::Identity());
1095 
1096  // delete xfcomponent;
1097  ptrd->add(xfaligncomponent);
1098  ptrd->add(lvt);
1099 
1100  std::unique_ptr<TgcReadoutElement> det = std::make_unique<TgcReadoutElement>(lvt, stName, manager);
1101  Position ip = mysql.GetStationPosition(stName.substr(0, 3), fi, zi);
1102  setTgcReadoutGeom(mysql, det.get(), tg, ip, stName);
1103  det->setHasCutouts(ncutouts > 0);
1104  Identifier id = tgc_id->channelID(stationType, stationEta, stationPhi, 1, false, 1);
1105  det->setIdentifier(id);
1106  det->setParentStationPV(PVConstLink(ptrd));
1107  det->setParentMuonStation(mstat);
1108 
1109  int jobIndex = c->index;
1110 
1111  mstat->addMuonReadoutElementWithAlTransf(det.get(), xfaligncomponent, jobIndex);
1112 
1113  ATH_MSG_DEBUG( stName << techname << " trying to build a TGC Id from stType/eta/phi " << stationType << "/" << stationEta << "/" << stationPhi
1114  << "/ and /1/0/1" << endmsg << " Copy number is " << geoid << " tagName = " << stag );
1115  manager->addTgcReadoutElement(std::move(det));
1116  }
1117 
1118  if (lvr && RPCON && manager->rpcIdHelper()) {
1119  RpcComponent *rp = (RpcComponent *)c;
1120  int ndivy = rp->ndivy;
1121  int ndivz = rp->ndivz;
1122 
1123  if (ndivz != 1 || ndivy != 1) {
1124  ATH_MSG_ERROR( " RPC segmentation z,y " << ndivz << " " << ndivy );
1125  }
1126 
1127  double zpos = -length / 2. + c->posy + c->dy / 2.;
1128  double xpos = c->posx;
1129 
1130  // implement really the mirror symmetry
1131  if (is_mirrored)
1132  xpos = -xpos;
1133  // ... putting back to here!
1134 
1135  const RpcIdHelper *rpc_id = manager->rpcIdHelper();
1136  int stationEta = zi;
1137  int stationPhi = fi + 1;
1138  int doubletR = 1;
1139  int doubletZ = 1;
1140 
1141  if (nRpc > 1 && nDoubletR == 2 && ypos > 0.)
1142  doubletR = 2;
1143  ndbz[doubletR - 1]++;
1144 
1145  // the BI RPCs are 3-gap RPCs mounted inside of the BI (s)MDTs
1146  if (stname.find("BI") != std::string::npos) {
1147  if (stname.find("BIS") != std::string::npos) {
1148  // for BIS78, there is a second RPC doubletZ at amdb-y (MuonGeoModel-z)=144mm inside the station
1149  if (std::abs(stationEta)>= 7){
1150  ATH_MSG_DEBUG("BIS78 station eta: "<<stationEta<<" phi: "<<stationPhi<<" dR: "<<doubletR<<" dZ:"<< doubletZ <<" rp: "<<rp->posz);
1151  }
1152  if (std::abs(stationEta) >= 7 && rp->posz > 80)
1153  doubletZ = 2;
1154  else
1155  doubletZ = 1;
1156  } else {
1157  // for BIL/BIM/BIR, we have 10 RPCs put on 6 MDT stations, thus, need to exploit doubletZ as additional variable on top of stationEta
1158  // only for BIL, there are sometimes 2 RPCs per 1 MDT station, namely for stationEta 1,3,4,6
1159  if (stname.find("BIL") != std::string::npos && std::abs(stationEta) < 7 && std::abs(stationEta) != 2 && std::abs(stationEta) != 5) {
1160  if (rp->posy > 1)
1161  doubletZ = 2; // put the chamber with positive amdb-z to doubletZ=2
1162  } else
1163  doubletZ = 1;
1164  }
1165  } else {
1166  if (zi <= 0 && !is_mirrored) {
1167  if (zpos < -100 * Gaudi::Units::mm)
1168  doubletZ = 2;
1169  } else {
1170  if (zpos > 100 * Gaudi::Units::mm)
1171  doubletZ = 2;
1172  }
1173  }
1174 
1175  // BMS (BOG) RPCs can have |xpos|=950 (|xpos|=350)
1176  if (std::abs(xpos) > 100. * Gaudi::Units::mm) {
1177  if (ndbz[doubletR - 1] > 2) {
1178  doubletZ = 3;
1179  }
1180  ndbz[doubletR - 1]--;
1181  }
1182 
1183  int dbphi = 1;
1184 
1185  // this special patch is needed for BMS in the ribs where xpos is ~950mm;
1186  // the theshold to 100mm (too low) caused a bug
1187  // in BOG at eta +/-4 and stationEta 7 (not 6) ==>> 28 Jan 2016 raising the threshold to 400.mm
1188  // doublet phi not aware of pos. in space !!!
1189  if (xpos > 400. * Gaudi::Units::mm)
1190  dbphi = 2;
1191 
1192  int doubletPhi = dbphi;
1193  // doublet phi aware of pos. in space !!!
1194  if (zi < 0 && is_mirrored && doubletZ == 3) {
1195  doubletPhi++;
1196  if (doubletPhi > 2)
1197  doubletPhi = 1;
1198  } else if (zi < 0 && is_mirrored && doubletZ == 2 && doubletR == 1 && stName == "BMS6") {
1199  doubletPhi++;
1200  if (doubletPhi > 2)
1201  doubletPhi = 1;
1202  }
1203  // never defined fields: set to the lower limit
1204  int gasGap = 1;
1205  int measuresPhi = 0;
1206  int strip = 1;
1207 
1208  int geoid = 0;
1209  std::string stag;
1210  int tag = doubletZ + doubletR * 100 + dbphi * 1000;
1211  if (rp->iswap == -1)
1212  tag = -1 * tag;
1213  stag = "SwapdbPdbRdbZ[" + MuonGM::buildString(tag, 0) + "]" + techname + "rpccomponent";
1214  if (useAssemblies || isAssembly) {
1215  geoid = c->index;
1216  } else {
1217  int tag = rp->index + doubletR * 100 + dbphi * 1000;
1218  if (rp->iswap == -1)
1219  tag = -1 * tag;
1220  geoid = tag;
1221  }
1222 
1223  GeoNameTag *nm = new GeoNameTag(stag);
1224  ptrd->add(new GeoIdentifierTag(geoid));
1225  ptrd->add(nm);
1226 
1227  xfaligncomponent->setDelta(GeoTrf::Transform3D::Identity());
1228  // delete xfcomponent;
1229  ptrd->add(xfaligncomponent);
1230  ptrd->add(lvr);
1231 
1232  std::unique_ptr<RpcReadoutElement> det = std::make_unique<RpcReadoutElement>(lvr, stName, zi, fi + 1, is_mirrored, manager);
1233  Position ip = mysql.GetStationPosition(stName.substr(0, 3), fi, zi);
1234  setRpcReadoutGeom(mysql, det.get(), rp, ip);
1235  Identifier id = rpc_id->channelID(stationType, stationEta, stationPhi, doubletR, doubletZ, doubletPhi, gasGap, measuresPhi, strip);
1236  det->setIdentifier(id);
1237  det->setHasCutouts(ncutouts > 0);
1238  det->setDoubletR(doubletR);
1239  det->setDoubletZ(doubletZ);
1240  det->setDoubletPhi(doubletPhi);
1241 
1242  ATH_MSG_DEBUG( stName << techname << " trying to build a RPC Id from stType/eta/phi/dbR/dbZ/dbP " << stationType << "/" << stationEta << "/"
1243  << stationPhi << "/" << doubletR << "/" << doubletZ << "/" << doubletPhi << "///" << gasGap << "/" << measuresPhi << "/" << strip << endmsg
1244  << " Copy number " << geoid << " tagName= " << stag );
1245  det->setParentStationPV(PVConstLink(ptrd));
1246  det->setParentMuonStation(mstat);
1247 
1248  int jobIndex = c->index;
1249 
1250  mstat->addMuonReadoutElementWithAlTransf(det.get(), xfaligncomponent, jobIndex);
1251 
1252 
1253  if (stName.find("BI") != std::string::npos) {
1254  std::map<std::string, float>::const_iterator yItr = rpcYTrans.find(techname);
1255  if (yItr != rpcYTrans.end())
1256  det->setYTranslation(yItr->second);
1257  std::map<std::string, float>::const_iterator zItr = rpcZTrans.find(techname);
1258  if (zItr != rpcZTrans.end())
1259  det->setZTranslation(zItr->second);
1260  }
1261 
1262  det->fillCache(); // fill temporary cache (global position on known yet)
1263  det->initDesign();
1264  det->clearCache(); // clear temporary cache
1265  manager->addRpcReadoutElement(std::move(det));
1266  } // if (lvr && RPCON && manager->rpcIdHelper()) {
1267 
1268  if (lvs && RPCON) {
1269  std::string cname = c->name;
1270  ATH_MSG_VERBOSE( " yes, the component is a SupComponent named " << cname );
1271  GeoNameTag *nm = new GeoNameTag(stName + "_stName " + techname + " supcomponent");
1272  ptrd->add(new GeoIdentifierTag(c->index));
1273  ptrd->add(nm);
1274  ptrd->add(xfcomponent);
1275  ATH_MSG_VERBOSE( " register x" );
1276  ATH_MSG_VERBOSE( " register y" );
1277  ATH_MSG_VERBOSE( " register z" );
1278 
1279  ptrd->add(lvs);
1280  ATH_MSG_VERBOSE( " register lvs" );
1281  }
1282 
1283  if (lvd && RPCON) {
1284  GeoNameTag *nm = new GeoNameTag(stName + "_stName " + techname + " dedcomponent");
1285  ptrd->add(new GeoIdentifierTag(c->index));
1286  ptrd->add(nm);
1287 
1288  ptrd->add(xfcomponent);
1289  ptrd->add(lvd);
1290  }
1291 
1292  if (lvo) {
1293  // translate from AMDB chamber coordinates:
1294  // (move chamber origin and swap axes around)
1295  // D-line gives AMDB coords of AMDB component origin
1296  // we need MuonGM coords of MuonGM component origin...
1297  // take off length/2, thickness/2 to get to AMDB chamber org
1298  // then put back GetLength()/2, GetThickness()/2 to get to
1299  // component org.
1300  GeoNameTag *nm = new GeoNameTag(stName + "_stName " + techname + " component");
1301  ptrd->add(new GeoIdentifierTag(c->index));
1302  ptrd->add(nm);
1303 
1304  ptrd->add(xfcomponent);
1305  ptrd->add(lvo);
1306  }
1307 
1308  if (lv) {
1309  GeoNameTag *nm = new GeoNameTag(stName + "_stName " + techname + " component");
1310  ptrd->add(new GeoIdentifierTag(c->index));
1311  ptrd->add(nm);
1312  ptrd->add(xfcomponent);
1313  ptrd->add(lv);
1314  }
1315 
1316  } // End big loop over components
1317  mstat->updateBlineFixedPointInAmdbLRS();
1318 
1319  return ptrd;
1320  }
1321 
1322  void MuonChamber::setCscReadoutGeom(const MYSQL& mysql,
1323  CscReadoutElement *re, const CscComponent *cc, const Position &ip) {
1324 
1325  re->m_Ssize = cc->dx1;
1326  re->m_LongSsize = cc->dx2;
1327  re->m_Rsize = cc->dy;
1328  re->m_LongRsize = cc->dy;
1329  re->m_Zsize = cc->GetThickness(mysql);
1330  re->m_LongZsize = cc->GetThickness(mysql);
1331  re->m_RlengthUpToMaxWidth = cc->maxwdy;
1332  re->m_excent = cc->excent;
1333 
1334  // Csc features specific to this readout element
1335  std::string tname = cc->name;
1336  re->setTechnologyName(tname);
1337 
1338  if (ip.isAssigned) {
1339  re->setStationS(ip.shift);
1340  } else {
1341  ATH_MSG_ERROR( " MuonChamber::setCscReadoutGeom: position not found " );
1342  assert(0);
1343  }
1344 
1345  const CSC *thisc = dynamic_cast<const CSC*>(mysql.GetTechnology(tname));
1346  re->m_anodecathode_distance = thisc->anocathodist;
1347  re->m_ngasgaps = thisc->numOfLayers;
1348  re->m_nstriplayers = thisc->numOfLayers;
1349  re->m_nwirelayers = thisc->numOfLayers;
1350  re->m_roxacellwidth = thisc->roxacellwith;
1351  re->m_nEtastripsperlayer = thisc->nEtastrips;
1352  re->m_nPhistripsperlayer = thisc->nPhistrips;
1353  re->m_Etastrippitch = thisc->cathreadoutpitch;
1354  re->m_Phistrippitch = thisc->phireadoutpitch;
1355  re->m_Etastripwidth = re->m_Etastrippitch;
1356  re->m_Phistripwidth = re->m_Phistrippitch;
1357  }
1358 
1359  void MuonChamber::setMdtReadoutGeom(const MYSQL& mysql,
1360  MdtReadoutElement *re, const MdtComponent *cc, const Position &ip) {
1361 
1362  re->m_Ssize = cc->dx1;
1363  re->m_LongSsize = cc->dx2;
1364 
1365  if (re->m_inBarrel) {
1366  re->m_Rsize = cc->GetThickness(mysql);
1367  re->m_LongRsize = cc->GetThickness(mysql);
1368  re->m_Zsize = cc->dy;
1369  re->m_LongZsize = cc->dy;
1370  } else {
1371  re->m_Rsize = cc->dy;
1372  re->m_LongRsize = cc->dy;
1373  re->m_Zsize = cc->GetThickness(mysql);
1374  re->m_LongZsize = cc->GetThickness(mysql);
1375  }
1376 
1377  re->m_cutoutShift = cc->cutoutTubeXShift;
1378  re->m_tubelenStepSize = cc->tubelenStepSize;
1379 
1380  if (ip.isAssigned) {
1381  re->setStationS(ip.shift);
1382  } else {
1383  ATH_MSG_ERROR( " MuonChamber::setMdtReadoutGeom: position not found " );
1384  assert(0);
1385  }
1386 
1387  std::string tname = cc->name;
1388  re->setTechnologyName(tname);
1389  const MDT *thism = dynamic_cast<const MDT*>(mysql.GetTechnology(tname));
1390  re->m_nlayers = thism->numOfLayers;
1391  re->m_tubepitch = thism->pitch;
1392  re->m_tubelayerpitch = thism->y[1] - thism->y[0];
1393  re->m_endpluglength = thism->tubeEndPlugLength;
1394  re->m_deadlength = cc->deadx; // thism->tubeDeadLength;
1395  re->m_innerRadius = thism->innerRadius;
1396  re->m_tubeWallThickness = thism->tubeWallThickness;
1397 
1398  if (re->m_inBarrel) {
1399  re->m_ntubesperlayer = int(re->m_Zsize / re->m_tubepitch);
1400  re->m_nsteps = 1; // all tubes have the same length
1401  re->m_ntubesinastep = re->m_ntubesperlayer;
1402  re->m_tubelength[0] = re->m_Ssize;
1403  } else {
1404  re->m_ntubesperlayer = int(re->m_Rsize / re->m_tubepitch);
1405  re->m_nsteps = int(re->m_Rsize / re->m_tubelenStepSize);
1406  re->m_ntubesinastep = int(re->m_tubelenStepSize / re->m_tubepitch);
1407  re->m_tubelength[0] = re->m_Ssize;
1408  double diff = (re->m_LongSsize - re->m_Ssize) * (re->m_LongRsize - re->m_tubepitch / 2.) / re->m_LongRsize;
1409  for (int is = 0; is < re->m_nsteps; ++is) {
1410  double len = re->m_Ssize + is * diff / re->m_nsteps;
1411  re->m_tubelength[is] = len;
1412  }
1413  }
1414 
1415  for (int tl = 0; tl < re->m_nlayers; ++tl) {
1416  re->m_firstwire_x[tl] = thism->x[tl];
1417  re->m_firstwire_y[tl] = thism->y[tl];
1418  }
1419  }
1420 
1421  void MuonChamber::setRpcReadoutGeom(const MYSQL& mysql,
1422  RpcReadoutElement *re,
1423  const RpcComponent *cc,
1424  const Position &ip) {
1425  re->m_Ssize = cc->dx1;
1426  re->m_LongSsize = cc->dx2;
1427  re->m_Rsize = cc->GetThickness(mysql);
1428  re->m_LongRsize = cc->GetThickness(mysql);
1429  re->m_Zsize = cc->dy;
1430  re->m_LongZsize = cc->dy;
1431 
1432  re->m_hasDEDontop = true;
1433  if (cc->iswap == -1)
1434  re->m_hasDEDontop = false;
1435 
1436  if (ip.isAssigned) {
1437  re->setStationS(ip.shift);
1438  } else {
1439  ATH_MSG_ERROR( " MuonChamber::setRpcReadoutGeom: position not found " );
1440  assert(0);
1441  }
1442 
1443  std::string tname = cc->name;
1444  re->setTechnologyName(tname);
1445  const RPC *thisr = dynamic_cast<const RPC*>(mysql.GetTechnology(tname));
1446  re->m_nphigasgaps = thisr->NGasGaps_in_s;
1447  re->m_gasgapssize = re->m_Ssize / re->m_nphigasgaps - 2. * thisr->bakeliteframesize;
1448  re->m_gasgapzsize = re->m_Zsize - 2. * thisr->bakeliteframesize;
1449  re->m_nphistrippanels = thisr->NstripPanels_in_s;
1450  re->m_phistrippitch = thisr->stripPitchS;
1451  re->m_etastrippitch = thisr->stripPitchZ;
1452 
1453  if (re->getStationName().find("BI") != std::string::npos) {
1454  re->setNumberOfLayers(3); // all BI RPCs always have 3 gas gaps
1455 
1456  }
1457  const RPC* genericRpc = dynamic_cast<const RPC*>(mysql.GetATechnology("RPC0"));
1458 
1459  if (re->numberOfLayers() == 3) {
1460  constexpr double rpc3GapLayerThickness = 11.8; // gas vol. + ( bakelite + graphite + PET )x2
1461  for (int gasGap =1 ; gasGap <= re->numberOfLayers(); ++gasGap) {
1464  re->m_gasGap_xPos[gasGap -1] = (gasGap - 2) * rpc3GapLayerThickness - 0.74;
1465  }
1466  } else {
1467  re->m_gasGap_xPos[0] = -re->m_Rsize / 2. + thisr->externalSupPanelThickness + genericRpc->stripPanelThickness
1468  + genericRpc->GasGapThickness / 2;
1469  re->m_gasGap_xPos[1] = re->m_gasGap_xPos[0] + genericRpc->rpcLayerThickness +
1470  genericRpc->centralSupPanelThickness;
1471  if (!re->m_hasDEDontop) {
1472  std::swap(re->m_gasGap_xPos[0], re->m_gasGap_xPos[1]);
1473  }
1474  }
1475 
1476  re->m_phistripwidth = re->m_phistrippitch - genericRpc->stripSeparation;
1477  re->m_etastripwidth = re->m_etastrippitch - genericRpc->stripSeparation;
1478  re->m_nphistripsperpanel = int((re->m_Ssize / re->m_nphistrippanels) / re->m_phistrippitch);
1479  if (re->getStationName().compare(0, 3, "BME") != 0) {
1480  re->m_nphistripsperpanel-=(re->m_nphistripsperpanel % 8) ;
1481  }
1482  re->m_netastripsperpanel = int((re->m_Zsize) / re->m_etastrippitch);
1483  re->m_netastripsperpanel -= (re->m_netastripsperpanel % 8);
1484 
1485  re->m_phipaneldead = re->m_Ssize / re->m_nphistrippanels -
1486  re->m_nphistripsperpanel * re->m_phistrippitch +
1487  genericRpc->stripSeparation;
1488  re->m_phipaneldead = re->m_phipaneldead / 2.;
1489  re->m_etapaneldead = re->m_Zsize - re->m_netastripsperpanel * re->m_etastrippitch + genericRpc->stripSeparation;
1490  re->m_etapaneldead = re->m_etapaneldead / 2.;
1491  re->m_phistriplength = re->m_LongZsize;
1492  re->m_etastriplength = re->m_LongSsize / re->m_nphistrippanels;
1493 
1494  re->m_first_phistrip_s[0] = -re->m_Ssize / 2. + re->m_phipaneldead + re->m_phistripwidth / 2.;
1495  if (re->m_nphistrippanels == 2) {
1496  re->m_first_phistrip_s[1] = re->m_phipaneldead + re->m_phistripwidth / 2.;
1497  }
1498 
1499  double offset = 0.;
1500  re->m_phistrip_z = -re->m_Zsize / 2. + offset + re->m_phistriplength / 2.;
1501 
1502  // first strip position on each eta panel
1503  re->m_first_etastrip_z = -re->m_Zsize / 2. + re->m_etapaneldead + re->m_etastripwidth / 2.;
1504  re->m_etastrip_s[0] = -re->m_Ssize / 2. + offset + re->m_etastriplength / 2.;
1505  if (re->m_nphistrippanels == 2) {
1506  re->m_etastrip_s[1] = re->m_Ssize / 2. - offset - re->m_etastriplength / 2.;
1507  }
1508  }
1509 
1510  void MuonChamber::setTgcReadoutGeom(const MYSQL& mysql,
1511  TgcReadoutElement *re,
1512  const TgcComponent *cc,
1513  const Position &ip,
1514  const std::string& stName) {
1515 
1516  re->setSsize(cc->dx1);
1517  re->setLongSsize(cc->dx2);
1518  re->setRsize(cc->dy);
1519  re->setLongRsize(cc->dy);
1520  re->setZsize(cc->GetThickness(mysql));
1521  re->setLongZsize(cc->GetThickness(mysql));
1522 
1523  const TGC *genericTgc = dynamic_cast<const TGC*>(mysql.GetATechnology("TGC0"));
1524  re->setFrameThickness(genericTgc->frame_h,
1525  genericTgc->frame_ab);
1526 
1527 
1528  const std::string &tname = cc->name;
1529  int tname_index = MuonGM::strtoint(tname, 3, 2);
1530  re->setTechnologyName(tname);
1531 
1532  if (ip.isAssigned) {
1533  re->setStationS(ip.shift);
1534  } else {
1535  throw std::runtime_error(" MuonChamberLite::setTgcReadoutGeom position not found ");
1536  }
1537 
1538  char index[2];
1539  sprintf(index, "%i", cc->index);
1540 
1541  re->setReadOutName(stName.substr(0, 4) + '_' + index);
1542  re->setReadOutParams(mysql.GetTgcRPars(tname_index));
1543 
1544  const TGC *thist = dynamic_cast<const TGC*>(mysql.GetTechnology(tname));
1545  const std::size_t ncomp = (thist->materials).size();
1546 
1547  unsigned int gasGap{0};
1548  for (std::size_t i = 0; i < ncomp; ++i) {
1549  double newpos = -re->getZsize() / 2. + thist->positions[i] + thist->tck[i] / 2.;
1550  if ( thist->materials[i].find("TGCGas") != std::string::npos) {
1551  re->setPlaneZ(newpos, ++gasGap);
1552  }
1553  }
1554  }
1555 
1556  void MuonChamber::print() const {
1557  ATH_MSG_INFO( "MuonChamber " << name << " :" );
1558  }
1559  void MuonChamber::setFineClashFixingFlag(int value) { m_enableFineClashFixing = value; }
1560  void MuonChamber::setFPVMAP(FPVMAP *fpvmap) { m_FPVMAP = fpvmap; }
1561 
1562 
1563 } // namespace MuonGM
CscIdHelper.h
MuonGM::CbmComponent::lb_width
double lb_width
Definition: CbmComponent.h:16
MuonGM::CbmComponent::hole_pos1
double hole_pos1
Definition: CbmComponent.h:17
MuonGM::Station::hasMdts
bool hasMdts() const
Definition: Station.h:88
MuonGM::MuonChamber::setFineClashFixingFlag
void setFineClashFixingFlag(int value)
Definition: MuonChamber.cxx:1559
plotting.yearwise_luminosity_vs_mu.comp
comp
Definition: yearwise_luminosity_vs_mu.py:23
MuonIdHelper::stationNameIndex
int stationNameIndex(const std::string &name) const
Definition: MuonIdHelper.cxx:842
beamspotman.r
def r
Definition: beamspotman.py:676
MuonGM::RPC::bakeliteframesize
double bakeliteframesize
Definition: RPC_Technology.h:47
MuonGM::MYSQL::GetTechnology
Technology * GetTechnology(const std::string &name)
Definition: MYSQL.cxx:105
MuonGM::MuonChamber::print
virtual void print() const override
Definition: MuonChamber.cxx:1556
MdtReadoutElement.h
MuonGM::TGC::materials
std::vector< std::string > materials
Definition: TGC_Technology.h:20
MuonGM::StandardComponent::index
int index
Definition: StandardComponent.h:27
dumpTgcDigiDeadChambers.gasGap
list gasGap
Definition: dumpTgcDigiDeadChambers.py:33
MuonGM::DetectorElement::name
std::string name
Definition: DetectorElement.h:17
MuonGM
Ensure that the Athena extensions are properly loaded.
Definition: GeoMuonHits.h:27
egammaParameters::depth
@ depth
pointing depth of the shower as calculated in egammaqgcld
Definition: egammaParamDefs.h:276
python.SystemOfUnits.mm
float mm
Definition: SystemOfUnits.py:97
MuonGM::TgcComponent
Definition: TgcComponent.h:14
MuonGM::CSC::phireadoutpitch
double phireadoutpitch
Definition: CSC_Technology.h:38
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
CscComponent.h
MuonGM::Station::GetExtraBottomThickness
double GetExtraBottomThickness() const
Definition: Station.cxx:155
MuonGM::CbmComponent
Definition: CbmComponent.h:12
MuonGM::MYSQL::allocPosFindSubtype
int allocPosFindSubtype(const std::string &statType, int fi, int zi) const
Definition: MYSQL.cxx:196
MuonGM::TGC::frame_ab
double frame_ab
Definition: TGC_Technology.h:19
TRTCalib_Extractor.det
det
Definition: TRTCalib_Extractor.py:36
TgcIdHelper
Definition: TgcIdHelper.h:50
MuonGM::Station::getAmdbOrigine_along_thickness
double getAmdbOrigine_along_thickness(const MYSQL &mysql) const
Definition: Station.cxx:558
RPCON
#define RPCON
Definition: MuonChamber.cxx:70
MuonGM::StandardComponent::GetThickness
double GetThickness(const MYSQL &mysql) const
Definition: StandardComponent.cxx:27
MuonGM::MuonChamber::setTgcReadoutGeom
void setTgcReadoutGeom(const MYSQL &mysql, TgcReadoutElement *re, const TgcComponent *cc, const Position &p, const std::string &statname)
Definition: MuonChamber.cxx:1510
index
Definition: index.py:1
hist_file_dump.d
d
Definition: hist_file_dump.py:143
MuonGM::MuonChamber::m_station
Station * m_station
Definition: MuonChamber.h:58
MuonGM::TGC::tck
std::vector< double > tck
Definition: TGC_Technology.h:22
Rpc.h
Spacer.h
mergePhysValFiles.start
start
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:14
FPVMAP.h
Muon::MuonStationIndex::stName
const std::string & stName(StIndex index)
convert StIndex into a string
Definition: MuonStationIndex.cxx:104
MuonGM::Cutout::dx
double dx
Definition: Cutout.h:23
MuonGM::MuonChamber::width
double width
Definition: MuonChamber.h:32
MuonGM::Station
Definition: Station.h:40
createCablingJSON.doubletR
int doubletR
Definition: createCablingJSON.py:15
MuonGM::MDT::tubeEndPlugLength
double tubeEndPlugLength
Definition: MDT_Technology.h:22
MuonGM::RPC::stripPitchS
double stripPitchS
Definition: RPC_Technology.h:64
deg
#define deg
Definition: SbPolyhedron.cxx:17
mc.diff
diff
Definition: mc.SFGenPy8_MuMu_DD.py:14
MuonGM::MDT::numOfLayers
int numOfLayers
Definition: MDT_Technology.h:17
MuonGM::MYSQL
Definition: MYSQL.h:43
MuonGM::CscComponent
Definition: CscComponent.h:11
MuonGM::RPC::NGasGaps_in_s
int NGasGaps_in_s
Definition: RPC_Technology.h:43
MuonGM::RpcReadoutElement
An RpcReadoutElement corresponds to a single RPC module; therefore typicaly a barrel muon station con...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/RpcReadoutElement.h:55
Csc.h
MuonGM::MuonChamber::setCscReadoutGeom
void setCscReadoutGeom(const MYSQL &mysql, CscReadoutElement *re, const CscComponent *cc, const Position &p)
Definition: MuonChamber.cxx:1322
athena.value
value
Definition: athena.py:124
MuonGM::MDT::tubeWallThickness
double tubeWallThickness
Definition: MDT_Technology.h:23
MuonGM::CscReadoutElement
Definition: CscReadoutElement.h:56
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
MuonGM::MYSQL::allocPosFindCutout
int allocPosFindCutout(const std::string &statType, int fi, int zi) const
Definition: MYSQL.cxx:201
RpcIdHelper::channelID
Identifier channelID(int stationName, int stationEta, int stationPhi, int doubletR, int doubletZ, int doubletPhi, int gasGap, int measuresPhi, int strip) const
Definition: RpcIdHelper.cxx:931
MuonGM::LBI
Definition: LBI_Technology.h:13
MuonGM::MYSQL::GetStationPosition
Position GetStationPosition(const std::string &nameType, int fi, int zi) const
Definition: MYSQL.cxx:71
MuonGM::MuonChamber::MuonChamber
MuonChamber(const MYSQL &mysql, Station *s)
Definition: MuonChamber.cxx:93
MuonGM::CSC::roxacellwith
double roxacellwith
Definition: CSC_Technology.h:29
RpcIdHelper
Definition: RpcIdHelper.h:51
MuonGM::DetectorElement
Definition: DetectorElement.h:15
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
MuonGM::StandardComponent
Definition: StandardComponent.h:15
RpcIdHelper.h
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
MuonGM::CbmComponent::lb_height
double lb_height
Definition: CbmComponent.h:15
Ded.h
Station.h
MuonGM::CSC
Definition: CSC_Technology.h:13
MuonGM::CSC::anocathodist
double anocathodist
Definition: CSC_Technology.h:23
MuonGM::CSC::nEtastrips
int nEtastrips
Definition: CSC_Technology.h:39
MuonGM::RPC::GasGapThickness
double GasGapThickness
Definition: RPC_Technology.h:45
MuonGM::SupComponent::xAMDB0
static double xAMDB0(const MYSQL &mysql, const StandardComponent &c)
Definition: SupComponent.cxx:12
MuonGM::MDT
Definition: MDT_Technology.h:15
TgcComponent.h
MuonGM::TGC::frame_h
double frame_h
Definition: TGC_Technology.h:18
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
GeoPrimitives.h
MuonGM::MuonChamber::m_enableFineClashFixing
int m_enableFineClashFixing
Definition: MuonChamber.h:59
MuonChamber.h
MuonGM::MdtComponent
Definition: MdtComponent.h:12
MuonGM::Component::dy
double dy
Definition: Component.h:21
MuonGM::MuonChamber::setMdtReadoutGeom
void setMdtReadoutGeom(const MYSQL &mysql, MdtReadoutElement *re, const MdtComponent *cc, const Position &p)
Definition: MuonChamber.cxx:1359
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
python.BunchSpacingUtils.lb
lb
Definition: BunchSpacingUtils.py:87
MuonGM::Position
Definition: Position.h:11
MuonGM::MdtReadoutElement
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MdtReadoutElement.h:51
StandardComponent.h
CbmComponent.h
lumiFormat.i
int i
Definition: lumiFormat.py:85
MuonGM::LbiComponent
Definition: LbiComponent.h:12
TGC
Definition: TgcBase.h:6
MuonGM::CbmComponent::hole_pos2
double hole_pos2
Definition: CbmComponent.h:18
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
MuonGM::FPVMAP
Definition: FPVMAP.h:17
angle
double angle(const GeoTrf::Vector2D &a, const GeoTrf::Vector2D &b)
Definition: TRTDetectorFactory_Full.cxx:73
MuonGM::MDT::y
std::array< double, 4 > y
Definition: MDT_Technology.h:25
MuonGM::RpcComponent
Definition: RpcComponent.h:12
Cutout.h
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
RPC_Technology.h
MuonGM::MuonStation
Definition: MuonStation.h:51
MuonGM::Station::getAmdbOrigine_along_length
double getAmdbOrigine_along_length() const
Definition: Station.cxx:553
CscReadoutElement.h
MuonGM::TgcReadoutElement
A TgcReadoutElement corresponds to a single TGC chamber; therefore typically a TGC station contains s...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/TgcReadoutElement.h:42
BindingsTest.cut
cut
This script demonstrates how to call a C++ class from Python Also how to use PyROOT is shown.
Definition: BindingsTest.py:13
MuonGM::Cutout::dy
double dy
Definition: Cutout.h:24
MdtIdHelper
Definition: MdtIdHelper.h:61
sign
int sign(int a)
Definition: TRT_StrawNeighbourSvc.h:107
AthMessaging
Class to provide easy MsgStream access and capabilities.
Definition: AthMessaging.h:55
MdtIdHelper.h
find_tgc_unfilled_channelids.ip
ip
Definition: find_tgc_unfilled_channelids.py:3
MuonGM::Station::GetExtraTopThickness
double GetExtraTopThickness() const
Definition: Station.cxx:151
SpacerBeam.h
MuonGM::MuonChamber::longWidth
double longWidth
Definition: MuonChamber.h:35
MuonGM::CSC::cathreadoutpitch
double cathreadoutpitch
Definition: CSC_Technology.h:37
MuonGM::RPC::centralSupPanelThickness
double centralSupPanelThickness
Definition: RPC_Technology.h:28
MuonGM::MDT::innerRadius
double innerRadius
Definition: MDT_Technology.h:19
CSC_Technology.h
WriteCalibToCool.swap
swap
Definition: WriteCalibToCool.py:94
GlobalUtilities.h
LBI_Technology.h
useAssemblies
#define useAssemblies
Definition: MuonChamber.cxx:71
MYSQL.h
MuonGM::StandardComponent::posy
double posy
Definition: StandardComponent.h:20
MuonGM::SupComponent::yAMDB0
static double yAMDB0(const MYSQL &mysql, const StandardComponent &c)
Definition: SupComponent.cxx:16
MuonGM::TGC::positions
std::vector< double > positions
Definition: TGC_Technology.h:21
CscIdHelper::channelID
Identifier channelID(int stationName, int stationEta, int stationPhi, int chamberLayer, int wireLayer, int measuresPhi, int strip) const
Definition: CscIdHelper.cxx:706
MuonGM::MuonChamber::build
GeoVPhysVol * build(StoredMaterialManager &matManager, const MYSQL &mysql, MuonDetectorManager *manager, int ieta, int iphi, bool is_mirrored, bool &isAssembly)
Definition: MuonChamber.cxx:109
MdtIdHelper::channelID
Identifier channelID(int stationName, int stationEta, int stationPhi, int multilayer, int tubeLayer, int tube) const
Definition: MdtIdHelper.cxx:659
MuonGM::CSC::numOfLayers
int numOfLayers
Definition: CSC_Technology.h:16
LbiComponent.h
MuonGM::MDT::x
std::array< double, 4 > x
Definition: MDT_Technology.h:26
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
MuonGM::MuonChamber::m_FPVMAP
FPVMAP * m_FPVMAP
Definition: MuonChamber.h:61
MuonGM::SupComponent::zAMDB0
static double zAMDB0(const MYSQL &mysql, const StandardComponent &c)
Definition: SupComponent.cxx:20
MuonDetectorManager.h
MDT_Technology.h
MuonGM::RPC::stripPitchZ
double stripPitchZ
Definition: RPC_Technology.h:65
MuonGM::Station::GetNrOfCutouts
int GetNrOfCutouts() const
Definition: Station.cxx:324
MuonGM::strtoint
int strtoint(std::string_view str, unsigned int istart, unsigned int length)
Definition: GlobalUtilities.cxx:37
Position.h
MuonGM::RPC::externalSupPanelThickness
double externalSupPanelThickness
Definition: RPC_Technology.h:19
Mdt.h
DeMoScan.index
string index
Definition: DeMoScan.py:364
CalibCoolCompareRT.nm
nm
Definition: CalibCoolCompareRT.py:110
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
Base_Fragment.width
width
Definition: Sherpa_i/share/common/Base_Fragment.py:59
MuonGM::Station::GetNrOfComponents
int GetNrOfComponents() const
Definition: Station.cxx:322
MuonGM::RPC::rpcLayerThickness
double rpcLayerThickness
Definition: RPC_Technology.h:34
CscIdHelper
Definition: CscIdHelper.h:52
MuonGM::RPC::stripPanelThickness
double stripPanelThickness
Definition: RPC_Technology.h:67
MuonGM::MuonDetectorManager
The MuonDetectorManager stores the transient representation of the Muon Spectrometer geometry and pro...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonDetectorManager.h:50
re
const boost::regex re(r_e)
MuonGM::MuonChamber::thickness
double thickness
Definition: MuonChamber.h:34
MuonGM::MYSQL::GetATechnology
const Technology * GetATechnology(const std::string &name) const
Definition: MYSQL.cxx:162
makeTRTBarrelCans.dx
tuple dx
Definition: makeTRTBarrelCans.py:20
MuonGM::RPC
Definition: RPC_Technology.h:14
StoredMaterialManager::getMaterial
virtual const GeoMaterial * getMaterial(const std::string &name)=0
MuonGM::stationPhiTGC
int stationPhiTGC(std::string_view stName, int fi, int zi_input)
Converts the AMDB phi index to the Identifier phi Index.
Definition: GlobalUtilities.cxx:44
convertTimingResiduals.offset
offset
Definition: convertTimingResiduals.py:71
MuonGM::Cutout::lengthY
double lengthY
Definition: Cutout.h:27
StoredMaterialManager
This class holds one or more material managers and makes them storeable, under StoreGate.
Definition: StoredMaterialManager.h:28
python.SystemOfUnits.s
float s
Definition: SystemOfUnits.py:146
MuonGM::Station::GetCutout
Cutout * GetCutout(int i) const
Definition: Station.cxx:85
MuonGM::MYSQL::GetTgcRPars
GeoModel::TransientConstSharedPtr< TgcReadoutParams > GetTgcRPars(const std::string &name) const
Definition: MYSQL.cxx:88
createCablingJSON.doubletPhi
int doubletPhi
Definition: createCablingJSON.py:16
TgcIdHelper::channelID
Identifier channelID(int stationName, int stationEta, int stationPhi, int gasGap, int isStrip, int channel) const
Definition: TgcIdHelper.cxx:583
TgcReadoutElement.h
TgcIdHelper.h
MuonGM::RPC::NstripPanels_in_s
int NstripPanels_in_s
Definition: RPC_Technology.h:60
python.Logging.manager
manager
Definition: PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/Logging.py:92
RpcComponent.h
dqt_zlumi_alleff_HIST.tl
tl
Definition: dqt_zlumi_alleff_HIST.py:73
TGC_Technology.h
MdtComponent.h
CaloCondBlobAlgs_fillNoiseFromASCII.tag
string tag
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:24
MuonGM::FPVMAP::GetDetector
GeoVPhysVol * GetDetector(const std::string &name)
Definition: FPVMAP.cxx:17
rp
ReadCards * rp
Definition: IReadCards.cxx:26
MuonGM::MDT::pitch
double pitch
Definition: MDT_Technology.h:18
MuonStation.h
MuonGM::Cutout
Definition: Cutout.h:14
MuonGM::buildString
std::string buildString(int i, int ncha)
Definition: GlobalUtilities.cxx:23
MuonGM::Station::GetComponent
Component * GetComponent(int i) const
Definition: Station.cxx:83
MuonGM::Station::GetName
const std::string & GetName() const
Definition: Station.cxx:110
MuonGM::Station::mdtHalfPitch
double mdtHalfPitch(const MYSQL &mysql) const
Definition: Station.cxx:343
MuonGM::RPC::stripSeparation
double stripSeparation
Definition: RPC_Technology.h:66
python.compressB64.c
def c
Definition: compressB64.py:93
MuonGM::FPVMAP::StoreDetector
void StoreDetector(GeoVPhysVol *s, const std::string &name)
Definition: FPVMAP.cxx:27
length
double length(const pvec &v)
Definition: FPGATrackSimLLPDoubletHoughTransformTool.cxx:26
MuonGM::LbiComponent::associated_CMIsubtype
std::string associated_CMIsubtype
Definition: LbiComponent.h:14
MuonGM::MuonChamber::setRpcReadoutGeom
void setRpcReadoutGeom(const MYSQL &mysql, RpcReadoutElement *re, const RpcComponent *cc, const Position &p)
Definition: MuonChamber.cxx:1421
SupComponent.h
calibdata.tube
tube
Definition: calibdata.py:31
Tgc.h
python.handimod.cc
int cc
Definition: handimod.py:523
MuonGM::MuonChamber::setFPVMAP
void setFPVMAP(FPVMAP *fpvmap)
Definition: MuonChamber.cxx:1560
MuonGM::CSC::nPhistrips
int nPhistrips
Definition: CSC_Technology.h:40
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
MuonGM::StandardComponent::posz
double posz
Definition: StandardComponent.h:21
RpcReadoutElement.h
Identifier
Definition: IdentifierFieldParser.cxx:14
MuonGM::MuonChamber::length
double length
Definition: MuonChamber.h:33
Generated on Fri May 9 2025 21:14:54 for ATLAS Offline Software by   doxygen 1.8.18