ATLAS Offline Software
Public Member Functions | Public Attributes | Private Member Functions | Private Attributes | List of all members
MuonGM::MuonChamberLite Class Reference

#include <MuonChamberLite.h>

Inheritance diagram for MuonGM::MuonChamberLite:
Collaboration diagram for MuonGM::MuonChamberLite:

Public Member Functions

 MuonChamberLite (const MYSQL &mysql, Station *s, std::map< std::string, GeoFullPhysVol * > *mapFPV, std::map< std::string, GeoAlignableTransform * > *mapAXF)
 
GeoVPhysVol * addReadoutLayers (const MYSQL &mysql, MuonDetectorManager *manager, int ieta, int iphi, bool is_mirrored, bool &isAssembly)
 
virtual void print () const override
 
void setKeyset (std::set< std::string > *keySet)
 
void setLogVolName (const std::string &str)
 
bool msgLvl (const MSG::Level lvl) const
 Test the output level. More...
 
MsgStream & msg () const
 The standard message stream. More...
 
MsgStream & msg (const MSG::Level lvl) const
 The standard message stream. More...
 
void setLevel (MSG::Level lvl)
 Change the current logging level. More...
 

Public Attributes

double width {0.}
 
double length {0.}
 
double thickness {0.}
 
double longWidth {0.}
 
std::array< double, 10 > rotangle {}
 
std::string name {}
 
std::string logVolName {}
 

Private Member Functions

void setCscReadoutGeom (const MYSQL &mysql, CscReadoutElement *re, const CscComponent *cc, const Position &p)
 
void setMdtReadoutGeom (const MYSQL &mysql, MdtReadoutElement *re, const MdtComponent *cc, const Position &p)
 
void setRpcReadoutGeom (const MYSQL &mysql, RpcReadoutElement *re, const RpcComponent *cc, const Position &p)
 
void setTgcReadoutGeom (const MYSQL &mysql, TgcReadoutElement *re, const TgcComponent *cc, const Position &p, const std::string &statname)
 
void initMessaging () const
 Initialize our message level and MessageSvc. More...
 

Private Attributes

Station * m_station {nullptr}
 
std::map< std::string, GeoFullPhysVol * > * m_mapFPV {nullptr}
 
std::map< std::string, GeoAlignableTransform * > * m_mapAXF {nullptr}
 
std::set< std::string > * m_keySet {nullptr}
 
std::string m_nm
 Message source name. More...
 
boost::thread_specific_ptr< MsgStream > m_msg_tls
 MsgStream instance (a std::cout like with print-out levels) More...
 
std::atomic< IMessageSvc * > m_imsg { nullptr }
 MessageSvc pointer. More...
 
std::atomic< MSG::Level > m_lvl { MSG::NIL }
 Current logging level. More...
 
std::atomic_flag m_initialized ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
 Messaging initialized (initMessaging) More...
 

Detailed Description

Definition at line 31 of file MuonChamberLite.h.

Constructor & Destructor Documentation

◆ MuonChamberLite()

MuonGM::MuonChamberLite::MuonChamberLite ( const MYSQL &  mysql,
Station *  s,
std::map< std::string, GeoFullPhysVol * > *  mapFPV,
std::map< std::string, GeoAlignableTransform * > *  mapAXF 
)

Definition at line 84 of file MuonChamberLite.cxx.

86  :
87  DetectorElement(s->GetName()),
88  AthMessaging{"MuonchamberLite"},
89  m_mapFPV(mapFPV),
90  m_mapAXF(mapAXF)
91  {
92  width = s->GetWidth1();
93  longWidth = s->GetWidth2();
94  thickness = s->GetThickness(mysql);
95  length = s->GetLength();
96  m_station = s;
97 
98  // CSL envelope is too small for its components - enlarge it slightly
99  std::string stname(m_station->GetName(), 0, 3);
100  if (stname == "CSL")
101  longWidth *= 1.015;
102 
103 
104  }

Member Function Documentation

◆ addReadoutLayers()

GeoVPhysVol * MuonGM::MuonChamberLite::addReadoutLayers ( const MYSQL &  mysql,
MuonDetectorManager *  manager,
int  ieta,
int  iphi,
bool  is_mirrored,
bool &  isAssembly 
)

< fi here goes from 0 to 7; in amdb from 1 to 8;

< fi here goes from 0 to 7; in amdb from 1 to 8;

init design : design uses global (converting back to local) positions

Definition at line 106 of file MuonChamberLite.cxx.

108  {
109 
110 
111 
112  ATH_MSG_VERBOSE( " Building a MuonChamberLite 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 
123  double extratop = m_station->GetExtraTopThickness();
124  double extrabottom = m_station->GetExtraBottomThickness();
125  double totthick = thickness + extratop + extrabottom;
126 
127 
128  double amdbOrigine_along_length = m_station->getAmdbOrigine_along_length();
129  double amdbOrigine_along_thickness = m_station->getAmdbOrigine_along_thickness(mysql);
130 
131 
132  // This will allow the MDT tube structure to be mirrored w.r.t. the chamber at z>0
133  // and to correctly place any other component in the m_station
134  if (zi < 0 && !is_mirrored && stName[0] == 'B') {
135  if (m_station->hasMdts()) {
136  amdbOrigine_along_length += halfpitch;
137  }
138  }
139  ATH_MSG_VERBOSE( "amdb origine: in the length direction = "
140  << amdbOrigine_along_length << " in the thickness direction = " << amdbOrigine_along_thickness);
141 
142  if (isAssembly) {
143  ATH_MSG_DEBUG("Station " << stName << " at zi, fi " << zi << " " << fi + 1 << " will be described as Assembly" );
144 
145  }
146 
147  // for BOG in layout Q we will have to shorten CHV, CMI as these
148  // are not shortened in AMDB
149 
150 
151  // if this is a BOG, we want to make cutouts in the MOTHER VOLUME
152  if (stName.compare(0, 3, "BOG") == 0 && (manager->IncludeCutoutsBogFlag() || manager->IncludeCutoutsFlag())) {
153 
154  ATH_MSG_VERBOSE( "amdb org: length= " << amdbOrigine_along_length << " thickness= " << amdbOrigine_along_thickness );
155 
156  std::string statType = stName.substr(0, 3);
157  if (m_station->GetNrOfCutouts() > 0) {
158  ATH_MSG_DEBUG( "Station " << stName << " at zi, fi " << zi << " " << fi + 1 << " has components with cutouts " );
159  isAssembly = true;
160 
161  // look for FIRST component with cutouts and loop over all of the cutouts:
162  bool foundCutouts = false;
163  for (int j = 0; j < m_station->GetNrOfComponents(); j++) {
164  StandardComponent *c = static_cast<StandardComponent *>(m_station->GetComponent(j));
165 
166  if (!foundCutouts) {
167  for (int ii = 0; ii < m_station->GetNrOfCutouts(); ii++) {
168  Cutout *cut = m_station->GetCutout(ii);
169  // if this is a BOG in layout Q, set the CP param:
170  // (both cuts have same length so ok to reset it)
171  // also do here some tweaking to prevent undershoot
172  // of the cutouts wrt mother volume:
173  if (std::abs(cut->dx - 600.7) < 0.1) {
174  cut->dx = cut->dx + 10. * Gaudi::Units::mm;
175  cut->widthXs = cut->widthXs + 20. * Gaudi::Units::mm;
176  cut->widthXl = cut->widthXl + 20. * Gaudi::Units::mm;
177  }
178  if (std::abs(cut->dx + 600.7) < 0.1) {
179  cut->dx = cut->dx - 10. * Gaudi::Units::mm;
180  cut->widthXs = cut->widthXs + 20. * Gaudi::Units::mm;
181  cut->widthXl = cut->widthXl + 20. * Gaudi::Units::mm;
182  }
183  if (std::abs(cut->lengthY - 180.2) < 0.001) {
184  cut->lengthY = cut->lengthY + (0.010) * Gaudi::Units::mm;
185  }
186  if (std::abs(cut->dy - 1019.8) < 0.001) {
187  cut->dy = 1216.4185 - cut->lengthY;
188  }
189  // create the cutout with the full thickness of the STATION
190  cut->setThickness(totthick * 1.01); // extra to be sure
191  if ((cut->subtype == mysql.allocPosFindSubtype(std::string(statType), fi, zi)) && (cut->icut == mysql.allocPosFindCutout(std::string(statType), fi, zi)) &&
192  (cut->ijob == c->index)) {
193 
194  foundCutouts = true;
195  }
196  } // Loop over cutouts
197  } // If no cutouts
198  } // Loop over components
199  }
200  } // end of special loop just for cutouts
201 
202 
203 
204  double ypos{0.}, zpos{0.}, xpos{0.}, irad{0.};
205  std::array<int, 2 > ndbz{0, 0};
206 
207  // Compute how many RPC modules there are in the m_station
208  int nDoubletR{0}, nRpc{0}, nTgc{0}, nCsc{0}, nMdt{0};
209  double previous_depth = 0.;
210 
211  ATH_MSG_VERBOSE( " Station Name = " << stName << " fi/zi " << fi << "/" << zi << " defining the n. of DoubletR to " );
212 
213 
214  for (int j = 0; j < m_station->GetNrOfComponents(); j++) {
215  StandardComponent *d = static_cast<StandardComponent *>(m_station->GetComponent(j));
216  std::string_view cn = std::string_view(d->name).substr(0, 3);
217  if (cn == "RPC") {
218  nRpc++;
219  if (nRpc == 1)
220  nDoubletR++;
221  double depth = -thickness / 2. + d->posz + d->GetThickness(mysql) / 2.;
222  // BI RPC Chambers have one one doubletR
223  if (!(stname.compare(0, 2, "BI") == 0) && nDoubletR == 1 && nRpc > 1 && depth * previous_depth < 0)
224  nDoubletR++;
225 
226  previous_depth = depth;
227  }
228  else if (cn == "CSC") {
229  nCsc++;
230  }
231  else if (cn == "TGC") {
232  nTgc++;
233  }
234  else if (cn == "MDT") {
235  nMdt++;
236  }
237  }
238  ATH_MSG_DEBUG( "nDoubletR: " << nDoubletR<<" nMdt/Rpc/Tgc/Csc " << nMdt << "/" << nRpc << "/" << nTgc << "/" << nCsc );
239 
240  // Get location and dimensions of long beams and pass them to cross beams
241  // in order to make holes
242  int numLB = -1;
243  double LBheight{0.}, LBwidth{0.};
244  std::array<double, 2> LBpos{-1, -1};
245  for (int i = 0; i < m_station->GetNrOfComponents(); i++) {
246  StandardComponent *c = static_cast<StandardComponent *>(m_station->GetComponent(i));
247  std::string_view cname = std::string_view(c->name).substr(0, 2);
248  if (cname == "LB") {
249  const LBI *lb = dynamic_cast<const LBI *>(mysql.GetTechnology(c->name));
250  numLB++;
251  LBpos[numLB] = c->posy + c->dy / 2.;
252  LBheight = lb->height;
253  LBwidth = c->dy;
254  }
255  if (numLB > 0)
256  break; // only 2 LBs per chamber
257  }
258 
259  for (int i = 0; i < m_station->GetNrOfComponents(); i++) {
260  StandardComponent *c = static_cast<StandardComponent *>(m_station->GetComponent(i));
261  std::string_view cname = std::string_view(c->name).substr(0, 3);
262  if (cname == "CRO" || cname == "CMI" || cname == "CHV") {
263  CbmComponent *ccbm = static_cast<CbmComponent *>(c);
264  ccbm->lb_height = LBheight;
265  ccbm->lb_width = LBwidth;
266  ccbm->hole_pos1 = LBpos[0];
267  ccbm->hole_pos2 = LBpos[1];
268  }
269  }
270 
271  // Look for the subtype of the CMI in the chamber to let LB know ...
272  std::string CMIcomponentNumber = "";
273  for (int j = 0; j < m_station->GetNrOfComponents(); j++) {
274  StandardComponent *d = static_cast<StandardComponent *>(m_station->GetComponent(j));
275  std::string_view cn = std::string_view(d->name).substr(0, 3);
276  if (cn == "CMI") {
277  CMIcomponentNumber = (d->name).substr(3, 2);
278  break;
279  }
280  }
281 
282  for (int j = 0; j < m_station->GetNrOfComponents(); j++) {
283  StandardComponent *d = static_cast<StandardComponent *>(m_station->GetComponent(j));
284  std::string_view cn = std::string_view(d->name).substr(0, 2);
285  if (cn == "LB") {
286  LbiComponent *lbic = static_cast<LbiComponent *>(d);
287  if (lbic) {
288  lbic->associated_CMIsubtype = CMIcomponentNumber;
289  } else
290  ATH_MSG_ERROR( "MuonChamberLite :: cannot associate a CMI subtype to the LB component " );
291  }
292  }
293 
294  // Build the MuonStation(readout-geometry) corresponding to this MuonChamberLite(raw-geometry)
295  MuonStation *mstat;
296  if (stName.compare(0, 1, "B") == 0) {
297  mstat = new MuonStation(stName.substr(0, 3), width, totthick, length, longWidth, totthick, length, zi, fi + 1,
298  (zi < 0 && !is_mirrored));
299  } else {
300  mstat = new MuonStation(stName.substr(0, 3), width, length, totthick, longWidth, length, totthick, zi, fi + 1,
301  (zi < 0 && !is_mirrored));
302  }
303 
304  manager->addMuonStation(std::unique_ptr<MuonStation>(mstat));
305  ATH_MSG_DEBUG( " Building a MuonStation for this MuonChamberLite " << m_station->GetName()
306  << " at zi, fi " << zi << " " << fi + 1 << " is_mirrored " << is_mirrored);
307 
308  GeoFullPhysVol *ptrd=(*m_mapFPV)[std::string(stName)+"_Station"+"_"+std::to_string(zi)+"_"+std::to_string(fi)];
309  mstat->setPhysVol(ptrd);
310  // here the big loop over the components !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
311  for (int i = 0; i < m_station->GetNrOfComponents(); i++) {
312  StandardComponent *c = static_cast<StandardComponent *>(m_station->GetComponent(i));
313  ATH_MSG_VERBOSE( " Component index " << c->index << " in loop for " << stName << " " << stationType << " at zi, fi " << zi << " " << fi + 1 << " cName "
314  << c->name << " thickness " << c->GetThickness(mysql) << " length " << c->dy << " w, lw " << c->dx1 << " " << c->dx2 );
315  ATH_MSG_VERBOSE( " Component local (amdb) coords " << c->posx << " " << c->posy << " " << c->posz );
316 
317  ypos = -thickness / 2. + c->posz + c->GetThickness(mysql) / 2.;
318  zpos = 0.;
319  xpos = 0.;
320 
321  ypos = -thickness / 2. + (c->posz + amdbOrigine_along_thickness) + c->GetThickness(mysql) / 2.;
322  zpos = -length / 2. + amdbOrigine_along_length + c->posy + c->dy / 2.;
323  xpos = c->posx;
324 
325  const std::string &techname = c->name;
326  std::string_view type = std::string_view(techname).substr(0, 3);
327 
328 
329 
330  GeoIntrusivePtr<GeoFullPhysVol> lvm{}, lvr{}, lvt{}, lvc{};
331 
332 
333 
334  // Are there cutouts?
335  std::string statType = stName.substr(0, 3);
336  double cthickness = c->GetThickness(mysql);
337  int ncutouts = 0;
338  std::vector<Cutout *> vcutdef;
339  std::vector<std::unique_ptr<Cutout>> vcutdef_todel;
340  for (int ii = 0; ii < m_station->GetNrOfCutouts(); ii++) {
341  Cutout *cut = m_station->GetCutout(ii);
342  cut->setThickness(cthickness * 1.01); // extra thickness to be sure
343 
344  if ((cut->subtype == mysql.allocPosFindSubtype(std::string(statType), fi, zi)) && (cut->icut == mysql.allocPosFindCutout(std::string(statType), fi, zi)) && (cut->ijob == c->index)) {
345 
346  double tempdx = cut->dx;
347  double tempdy = cut->dy;
348  double templengthY = cut->lengthY;
349  cut->dx = 0.;
350  cut->dy = 0.;
351 
352  if (stName.compare(0, 3, "BOG") == 0) {
353  // make the cutouts a bit longer
354  cut->lengthY = templengthY + 31.;
355  }
356 
357  cut->dx = tempdx;
358  cut->dy = tempdy;
359 
360  if (std::abs(cut->dead1) > 1. && techname == "MDT03")
361  cut->dy = cut->dy + 15.0 * cos(cut->dead1 * Gaudi::Units::deg);
362  // should compensate for the dy position defined in amdb at the bottom of the foam in ML 1 of EMS1,3 and BOS 6
363  // can be applied only for layout >=r.04.04 in rel 15.6.X.Y due to the frozen Tier0 policy
364 
365  cut->lengthY = templengthY;
366  // in thickness, cutout will coincide with component
367  // not needed (DHW) double xposcut = 0.; // rel. to component thickness
368  ncutouts++;
369  ATH_MSG_VERBOSE( "A new cutout for this component " );
370  ATH_MSG_VERBOSE( *cut );
371 
372  // Corrected cutout values for BMS7, BMS14
373  if (stName.compare(0, 3, "BMS") == 0) {
374  if (fi == 3) { // stationPhi = 4
375  if (std::abs(zi) == 1) { // stationEta = +-1
376  double margin = 1.0; // make cutout a little bigger to avoid coincident boundaries
377 
378  if (type == "RPC" || type == "DED") {
379  cut->widthXl += 2 * margin;
380  cut->widthXs += 2 * margin;
381  cut->dx += margin;
382  cut->lengthY += 2 * margin;
383 
384  if (zi > 0)
385  cut->dy = -margin;
386  }
387  }
388 
389  if (zi == -1) {
390  if (type == "MDT")
391  cut->dy = 0.;
392  }
393  }
394  }
395 
396  // the following is a fine tuning ----- MUST CHECK for a better solution
397  if (stName.compare(0, 3,"BOS") == 0 && zi == -6 && type == "MDT") {
398  cut->dy = c->dy - cut->dy - cut->lengthY - halfpitch;
399  cut->dead1 = 30.; // why this is not 30. or -30. already ?????
400  if (techname == "MDT03")
401  cut->dy = cut->dy + 30.0; // *cos(cut->dead1*Gaudi::Units::deg);
402  ATH_MSG_VERBOSE( "Cut dead1 for BOS 6 on C side is " << cut->dead1 );
403 
404  }
405 
406  // this mirroring of the cutout is necessary only for barrel MDT chambers; for EC the cutout will be automatically mirrored
407  // this fix cannot be applied in 15.6.X.Y for layout < r.04.04 due to the frozen tier0 policy
408 
409  if (type == "MDT" && (is_mirrored || zi < 0) && stName.compare(0, 1, "B") == 0) {
410  // MDT in chambers explicitly described at z<0 have to be
411  // rotated by 180deg to adj. tube staggering
412  // reverse the position (x amdb) of the cutout if the m_station is mirrored
413  Cutout *cutmirr = new Cutout(*cut);
414  cutmirr->dx = -cutmirr->dx;
415  // this way, after the rotation by 180 Gaudi::Units::deg, the cut will be at the same global phi
416  // it has for the m_station at z>0
417  vcutdef.push_back(cutmirr);
418  vcutdef_todel.emplace_back(cutmirr);
419  ATH_MSG_VERBOSE( "adding for application mirrored cut \n" << *cutmirr );
420 
421  } else if (type == "RPC" || type == "DED") {
422  Cutout *cutRpcType = new Cutout(*cut);
423  // temporary for testing fixes to r.03.09
424  if (stName.compare(0, 3, "BMS") == 0 && zi == 4 && (c->index == 20 || c->index == 21 || c->index == 24 || c->index == 25)) {
425  cutRpcType->dy = 1102.5;
426  }
427 
428  if (stName.compare(0, 3, "BOS") == 0 && zi == 6 && type == "DED")
429  cutRpcType->dy = 706.;
430 
431  cutRpcType->dy = cutRpcType->dy - c->posy;
432  cutRpcType->dx = cutRpcType->dx - c->posx;
433 
434  if (type == "RPC") {
435  RpcComponent *rp = static_cast<RpcComponent *>(c);
436  if (rp->iswap == -1) {
437  cutRpcType->dy = c->dy - (cutRpcType->dy + cutRpcType->lengthY);
438  }
439  }
440 
441  ATH_MSG_VERBOSE( " Rpc or ded cutout redefined as follows \n" << *cutRpcType );
442  vcutdef.push_back(cutRpcType);
443  vcutdef_todel.emplace_back(cutRpcType);
444  } else if (type == "TGC") {
445  // In AMDB, y coordinates of cutout and component are given by
446  // radius from detector z-axis. To get standard y value of cutout,
447  // subtract radius of component from radius of cutout
448  Cutout *tgccut = new Cutout(*cut);
449  tgccut->dy -= c->posy; //
450 
451  ATH_MSG_VERBOSE( " Tgc cutout redefined as follows \n" << *tgccut );
452  vcutdef.push_back(tgccut);
453  vcutdef_todel.emplace_back(tgccut);
454  } else {
455  vcutdef.push_back(cut);
456  }
457  }
458  } // Loop over cutouts in m_station
459 
460  if (ncutouts > 0) {
461  ATH_MSG_DEBUG( c->name << " of station " << stName << " at fi/zi " << fi + 1 << "/" << zi << " has " << ncutouts << " cutouts " );
462  }
463  // define here the total transform that will be applied to component:
464  GeoTrf::Transform3D htcomponent(GeoTrf::Transform3D::Identity());
465  GeoAlignableTransform *xfaligncomponent{nullptr};
466  // for RPCs we need a vector of transforms for M28 geometry...
467 
468  if (type == "CRO") {
469  if (stName.compare(0, 1, "B") != 0 && is_mirrored)
470  mstat->setxAmdbCRO(-xpos);
471  else
472  mstat->setxAmdbCRO(xpos);
473  }
474 
475  if (type == "MDT") {
476  MdtComponent *md= static_cast<MdtComponent *> (c);
477  htcomponent = GeoTrf::TranslateX3D(ypos) * GeoTrf::TranslateZ3D(zpos) * GeoTrf::TranslateY3D(xpos);
478 
479  if (zi < 0 && !is_mirrored && stName[0] == 'B') {
480  // this (rotation + shift of halfpitch) will mirror the tube structure w.r.t. the chamber at z>0
481  htcomponent = htcomponent * GeoTrf::RotateX3D(180. * Gaudi::Units::deg);
482  htcomponent = htcomponent * GeoTrf::TranslateZ3D(halfpitch);
483  }
484 
485  // ss - 24-05-2006 I don't really understand if this is needed at all
486  // it was introduced by Isabel T.
487  if (zi < 0 && stName.compare(0, 3, "BOG") == 0 && is_mirrored) {
488  // htcomponent = htcomponent*GeoTrf::RotateX3D(180.*Gaudi::Units::deg);
489  // tubes OK but chambers wrong
490  // htcomponent = GeoTrf::RotateX3D(180.*Gaudi::Units::deg)*htcomponent;
491  // chambers OK but tubes wrong
492  htcomponent = GeoTrf::RotateX3D(180. * Gaudi::Units::deg) * htcomponent * GeoTrf::RotateX3D(180. * Gaudi::Units::deg); // turn chambers but go back for tubes
493  } // ss - 24-05-2006 I don't really understand if this is needed at all
494 
495  std::string key =std::string( stName) + techname;
496  xfaligncomponent = (*m_mapAXF)[key+"_"+std::to_string(zi)+"_"+std::to_string(fi)+"_"+std::to_string(md->index)];
497 
498  // for cutouts:
499  // MDT cutouts for BOS1,5, BMS7,14, (problem with BMS4,10), EMS, BMG and BIS MDT14
500  bool mdtCutoutFlag = ((stname == "BOS" && std::abs(zi) == 6) || stname == "BMG" || techname == "MDT14" || (stname == "BMS" && (std::abs(zi) == 1 && fi == 3)) ||
501  (stname == "EMS" && (std::abs(zi) == 1 || std::abs(zi) == 3)));
502  if (((manager->IncludeCutoutsFlag() && mdtCutoutFlag) || (manager->IncludeCutoutsBogFlag() && stName.compare(0, 3, "BOG") == 0)) && zi >= 0) {
503  key += "p" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0);
504  } else if (((manager->IncludeCutoutsFlag() && mdtCutoutFlag) || (manager->IncludeCutoutsBogFlag() && stName.compare(0, 3, "BOG")) == 0) && zi < 0) {
505  key += "m" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0);
506  }
507  if (m_keySet->find(key)==m_keySet->end()) {
508  std::unique_ptr<Mdt> r = std::make_unique<Mdt>(mysql, c, stName + techname);
509  if ((manager->IncludeCutoutsFlag() && mdtCutoutFlag) || (manager->IncludeCutoutsBogFlag() && stName.compare(0, 3, "BOG") == 0)) {
510  if (!vcutdef.empty()) r->processCutouts(vcutdef);
511  }
512  m_keySet->insert(key);
513  }
514  lvm = (*m_mapFPV)[key+"_"+std::to_string(zi)+"_"+std::to_string(fi)+"_"+std::to_string(md->index)];
515 
516  } else if (type == "RPC") {
517  // position stuff needed for cutout, used to be below:
518  RpcComponent *rp = static_cast<RpcComponent *>(c);
519  int ndivy = rp->ndivy;
520  int ndivz = rp->ndivz;
521 
522  if (ndivz != 1 || ndivy != 1) {
523  ATH_MSG_ERROR( " RPC segmentation z,y " << ndivz << " " << ndivy );
524  }
525 
526  double xpos = c->posx;
527  // implement really the mirror symmetry
528  if (is_mirrored)
529  xpos = -xpos;
530 
531  ATH_MSG_VERBOSE( " In station " << stName << " with " << nDoubletR << " doubletR,"
532  << " RPC " << (c->name).substr(3, 2) << " has swap flag = " << rp->iswap << " ypos, zpos " << ypos << " " << zpos << " " );
533 
534  htcomponent = GeoTrf::TranslateX3D(ypos) * GeoTrf::TranslateY3D(xpos) * GeoTrf::TranslateZ3D(zpos);
535  if (rp->iswap == -1) { // this is like amdb iswap
536  htcomponent = htcomponent * GeoTrf::RotateY3D(180 * Gaudi::Units::deg);
537  }
538 
539  // end of position stuff
540 
541  bool rpcCutoutFlag = (stname == "BOS" && std::abs(zi) == 6) || (stname == "BMS" && (std::abs(zi) == 2 || std::abs(zi) == 4 || std::abs(zi) == 6)) ||
542  (stname == "BMS" && std::abs(zi) == 1 && fi == 3);
543  std::string key = stName + techname;
544  if (((manager->IncludeCutoutsFlag() && rpcCutoutFlag) || (manager->IncludeCutoutsBogFlag() && stName.compare(0, 3, "BOG") == 0)) && zi >= 0) {
545  key += "p" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0) + "_" +
546  buildString(vcutdef.size(), 0) + "_" + buildString(rp->iswap, 0);
547  } else if (((manager->IncludeCutoutsFlag() && rpcCutoutFlag) || (manager->IncludeCutoutsBogFlag() && stName.compare(0, 3, "BOG") == 0)) && zi < 0) {
548  key += "m" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0) + "_" +
549  buildString(vcutdef.size(), 0) + "_" + buildString(rp->iswap, 0);
550  }
551  xfaligncomponent = (*m_mapAXF)[key+"_"+std::to_string(zi)+"_"+std::to_string(fi)+"_"+std::to_string(rp->index)];
552  lvr = (*m_mapFPV)[key+"_"+std::to_string(zi)+"_"+std::to_string(fi)+"_"+std::to_string(rp->index)];
553  } else if (type == "TGC") {
554  TgcComponent *tg = static_cast<TgcComponent *>(m_station->GetComponent(i));
555  TgcComponent *tgInner = static_cast<TgcComponent *>(m_station->GetComponent(0));
556  irad = tgInner->posy;
557  TgcComponent *tgOuter = static_cast<TgcComponent *>(m_station->GetComponent(m_station->GetNrOfComponents() - 1));
558  double orad = tgOuter->posy + tgOuter->dy;
559  double start = -(orad - irad) / 2. + (tg->posy - irad) + tg->dy / 2;
560  double xstart = -thickness / 2. + tg->GetThickness(mysql) / 2.;
561  htcomponent = GeoTrf::TranslateX3D(xstart + tg->posz) * GeoTrf::TranslateZ3D(start);
562 
563  // Define key for this TGC component
564  std::string key = std::string(stName) + techname;
565  if (manager->IncludeCutoutsFlag()) {
566  if (mysql.allocPosFindCutout(statType, fi, zi) > 0) {
567  // If there is a cutout for this chamber, give it a special key
568  if (zi >= 0) {
569  key += "p" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0);
570  } else if (zi < 0) {
571  key += "m" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0);
572  }
573  }
574  }
575 
576  key += std::to_string(int(10 * c->dx1));
577  xfaligncomponent = (*m_mapAXF)[key+"_"+std::to_string(zi)+"_"+std::to_string(fi)];
578 
579  lvt = (*m_mapFPV)[key+"_"+std::to_string(zi)+"_"+std::to_string(fi)];
580 
581  } else if (type == "CSC") {
582  htcomponent = GeoTrf::TranslateX3D(ypos) * GeoTrf::TranslateZ3D(zpos);
583  // Here define the key for this CSC component
584  std::string key = std::string(stName) + techname;
585  if (manager->IncludeCutoutsFlag() && zi >= 0) {
586  key += "p" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0);
587  } else if (manager->IncludeCutoutsFlag() && zi < 0) {
588  key += "m" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0);
589  }
590 
591  xfaligncomponent = (*m_mapAXF)[key+"_"+std::to_string(zi)+"_"+std::to_string(fi)];
592  lvc=(*m_mapFPV)[key+"_"+std::to_string(zi)+"_"+std::to_string(fi)];
593  } else {
594  if (type != "MDT" && type != "RPC" && type != "TGC" && type != "SUP" && type != "DED" && type != "SPA" && type != "CHV" && type != "CRO" && type != "CMI" &&
595  type != "LB0" && type != "LBI") {
596  ATH_MSG_WARNING("Unknown component " << type );
597  }
598  }
599 
600  // Place components in chamber envelope
601  if (lvm && manager->mdtIdHelper()) {
602  int stationEta = zi;
603  int stationPhi = fi + 1;
604  int ml = 1;
605  int tubel = 1;
606  int tube = 1;
607  if (ypos > 5.)
608  ml = 2; // Need >5 instead of >0 because BIS78 is not perfectly centered
609 
610 
611  const MdtIdHelper *mdt_id = manager->mdtIdHelper();
612  std::unique_ptr<MdtReadoutElement> det = std::make_unique<MdtReadoutElement>(lvm, stName, manager);
613  Position ip = mysql.GetStationPosition(stName.substr(0, 3), fi, zi);
614  setMdtReadoutGeom(mysql, det.get(), static_cast<MdtComponent *>(c), ip);
615  det->setHasCutouts(ncutouts > 0);
616  det->setNMdtInStation(nMdt);
617  Identifier id = mdt_id->channelID(stationType, stationEta, stationPhi, ml, tubel, tube);
618  det->setIdentifier(id);
619  det->setMultilayer(ml);
620  det->setParentMuonStation(mstat);
621  det->geoInitDone();
622 
623  if (ml == 1) {
624  // set fixed point for MDT deformations: s0,z0,t0 for the point at lowest t,z (z,y amdb) and s=x=0
625  mstat->setBlineFixedPointInAmdbLRS(c->posx, c->posy, c->posz);
626  } else {
627  const Amg::Vector3D b0 = mstat->getBlineFixedPointInAmdbLRS();
628  if (c->posy < b0.y())
629  mstat->setBlineFixedPointInAmdbLRS(b0.x(), c->posy, b0.z());
630  }
631 
632  int jobIndex = c->index;
633 
634  mstat->addMuonReadoutElementWithAlTransf(det.get(), xfaligncomponent, jobIndex);
635  manager->addMdtReadoutElement(std::move(det));
636  }
637 
638  if (lvc && manager->cscIdHelper()) {
639  CscComponent *cs = static_cast<CscComponent *>(m_station->GetComponent(i));
640  int stationEta = zi;
641  int stationPhi = fi + 1;
642  int chamberLayer = 1;
643  if (ypos > 0.)
644  chamberLayer = 2;
645 
646  std::unique_ptr<CscReadoutElement> det = std::make_unique<CscReadoutElement>(lvc, stName, manager);
647  Position ip = mysql.GetStationPosition(stName.substr(0, 3), fi, zi);
648  setCscReadoutGeom(mysql, det.get(), cs, ip);
649 
650  const CscIdHelper *csc_id = manager->cscIdHelper();
651  det->setHasCutouts(ncutouts > 0);
652  Identifier id = csc_id->channelID(stationType, stationEta, stationPhi, chamberLayer, 1, 0, 1);
653  det->setIdentifier(id);
654 
655  det->setChamberLayer(chamberLayer);
656  det->setParentMuonStation(mstat);
657 
658  int jobIndex = c->index;
659  //
660  mstat->addMuonReadoutElementWithAlTransf(det.get(), xfaligncomponent, jobIndex);
661 
662 
663 
664  // set alignment parameters for the wire layers
665  manager->addCscReadoutElement(std::move(det));
666  }
667 
668  if (lvt && manager->tgcIdHelper()) {
669 
670  ATH_MSG_DEBUG( " Adding a TGC chamber to the tree zi,fi, is_mirrored " << zi << " " << fi + 1 << " " << is_mirrored );
671 
672 
673  TgcComponent *tg = static_cast<TgcComponent *>(m_station->GetComponent(i));
674 
675  ATH_MSG_VERBOSE( "There's a TGC named " << techname << " of thickness " << tg->GetThickness(mysql) );
676 
677  const TgcIdHelper *tgc_id = manager->tgcIdHelper();
678  int stationEta = 0;
679  stationEta = tg->index;
680  if (zi < 0)
681  stationEta = -stationEta;
682  int stationPhi = 0;
683  stationPhi = stationPhiTGC(stName, fi + 1,zi);
684 
685  std::unique_ptr<TgcReadoutElement> det = std::make_unique<TgcReadoutElement>(lvt, stName, manager);
686  Position ip = mysql.GetStationPosition(stName.substr(0, 3), fi, zi);
687  setTgcReadoutGeom(mysql, det.get(), tg, ip, stName);
688  det->setHasCutouts(ncutouts > 0);
689  Identifier id = tgc_id->channelID(stationType, stationEta, stationPhi, 1, false, 1);
690  det->setIdentifier(id);
691  det->setParentMuonStation(mstat);
692 
693  int jobIndex = c->index;
694 
695  mstat->addMuonReadoutElementWithAlTransf(det.get(), xfaligncomponent, jobIndex);
696 
697  manager->addTgcReadoutElement(std::move(det));
698  }
699  if (lvr && RPCON && manager->rpcIdHelper()) {
700  RpcComponent *rp = static_cast<RpcComponent *>(c);
701  int ndivy = rp->ndivy;
702  int ndivz = rp->ndivz;
703 
704  if (ndivz != 1 || ndivy != 1) {
705  ATH_MSG_ERROR( " RPC segmentation z,y " << ndivz << " " << ndivy );
706  }
707 
708  double zpos = -length / 2. + c->posy + c->dy / 2.;
709  double xpos = c->posx;
710 
711  // implement really the mirror symmetry
712  if (is_mirrored)
713  xpos = -xpos;
714  // ... putting back to here!
715 
716  const RpcIdHelper *rpc_id = manager->rpcIdHelper();
717  int stationEta = zi;
718  int stationPhi = fi + 1;
719  int doubletR = 1;
720  int doubletZ = 1;
721 
722  if (nRpc > 1 && nDoubletR == 2 && ypos > 0.)
723  doubletR = 2;
724  ndbz[doubletR - 1]++;
725 
726  // the BI RPCs are 3-gap RPCs mounted inside of the BI (s)MDTs
727  if (stname.find("BI") != std::string::npos) {
728  if (stname.find("BIS") != std::string::npos) {
729  // for BIS78, there is a second RPC doubletZ at amdb-y (MuonGeoModel-z)=144mm inside the station
730  if (std::abs(stationEta)>= 7){
731  ATH_MSG_DEBUG("BIS78 station eta: "<<stationEta<<" phi: "<<stationPhi<<" dR: "<<doubletR<<" dZ:"<< doubletZ <<" rp: "<<rp->posz);
732  }
733  if (std::abs(stationEta) >= 7 && rp->posz > 80)
734  doubletZ = 2;
735  else
736  doubletZ = 1;
737  } else {
738  // 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
739  // only for BIL, there are sometimes 2 RPCs per 1 MDT station, namely for stationEta 1,3,4,6
740  if (stname.find("BIL") != std::string::npos && std::abs(stationEta) < 7 && std::abs(stationEta) != 2 && std::abs(stationEta) != 5) {
741  if (rp->posy > 1)
742  doubletZ = 2; // put the chamber with positive amdb-z to doubletZ=2
743  } else
744  doubletZ = 1;
745  }
746  } else {
747  if (zi <= 0 && !is_mirrored) {
748  if (zpos < -100 * Gaudi::Units::mm)
749  doubletZ = 2;
750  } else {
751  if (zpos > 100 * Gaudi::Units::mm)
752  doubletZ = 2;
753  }
754  }
755 
756  // BMS (BOG) RPCs can have |xpos|=950 (|xpos|=350)
757  if (std::abs(xpos) > 100. * Gaudi::Units::mm) {
758  if (ndbz[doubletR - 1] > 2) {
759  doubletZ = 3;
760  }
761  ndbz[doubletR - 1]--;
762  }
763 
764  int dbphi = 1;
765 
766  // this special patch is needed for BMS in the ribs where xpos is ~950mm;
767  // the theshold to 100mm (too low) caused a bug
768  // in BOG at eta +/-4 and stationEta 7 (not 6) ==>> 28 Jan 2016 raising the threshold to 400.mm
769  // doublet phi not aware of pos. in space !!!
770  if (xpos > 400. * Gaudi::Units::mm)
771  dbphi = 2;
772 
773  int doubletPhi = dbphi;
774  //
775  if (zi < 0 && is_mirrored && doubletZ == 3) {
776  doubletPhi++;
777  if (doubletPhi > 2)
778  doubletPhi = 1;
779  } else if (zi < 0 && is_mirrored && doubletZ == 2 && doubletR == 1 && stName == "BMS6") {
780  doubletPhi++;
781  if (doubletPhi > 2)
782  doubletPhi = 1;
783  }
784  // never defined fields: set to the lower limit
785  int gasGap = 1;
786  int measuresPhi = 0;
787  int strip = 1;
788 
789  int tag = doubletZ + doubletR * 100 + dbphi * 1000;
790  if (rp->iswap == -1)
791  tag = -1 * tag;
792  if (useAssemblies || isAssembly) {
793  //
794  } else {
795  int tag = rp->index + doubletR * 100 + dbphi * 1000;
796  if (rp->iswap == -1)
797  tag = -1 * tag;
798 
799  }
800 
801 
802  std::unique_ptr<RpcReadoutElement> det = std::make_unique<RpcReadoutElement>(lvr, stName, zi, fi + 1, is_mirrored, manager);
803  Position ip = mysql.GetStationPosition(stName.substr(0, 3), fi, zi);
804  setRpcReadoutGeom(mysql, det.get(), rp, ip);
805  det->setHasCutouts(ncutouts > 0);
806  Identifier id = rpc_id->channelID(stationType, stationEta, stationPhi, doubletR, doubletZ, doubletPhi, gasGap, measuresPhi, strip);
807  det->setIdentifier(id);
808  det->setDoubletR(doubletR);
809  det->setDoubletZ(doubletZ);
810  det->setDoubletPhi(doubletPhi);
811  if (stName.find("BI") != std::string::npos)
812  det->setNumberOfLayers(3); // all BI RPCs always have 3 gas gaps
813  det->setParentMuonStation(mstat);
814 
815  int jobIndex = c->index;
816 
817  mstat->addMuonReadoutElementWithAlTransf(det.get(), xfaligncomponent, jobIndex);
818 
819 
820 
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  det->setYTranslation(yItr->second);
825  std::map<std::string, float>::const_iterator zItr = rpcZTrans.find(techname);
826  if (zItr != rpcZTrans.end())
827  det->setZTranslation(zItr->second);
828  }
829 
830  det->fillCache(); // fill temporary cache (global position on known yet)
831  det->initDesign();
832  det->clearCache(); // clear temporary cache
833  manager->addRpcReadoutElement(std::move(det));
834 
835  } // if (lvr && RPCON && manager->rpcIdHelper()) {
836 
837  } // End big loop over components
838  mstat->updateBlineFixedPointInAmdbLRS();
839 
840  return ptrd;
841  }

◆ initMessaging()

void AthMessaging::initMessaging ( ) const
privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

40 {
41  m_imsg = Athena::getMessageSvc();
42  m_lvl = m_imsg ?
43  static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
44  MSG::INFO;
45 }

◆ msg() [1/2]

MsgStream & AthMessaging::msg ( ) const
inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 164 of file AthMessaging.h.

165 {
166  MsgStream* ms = m_msg_tls.get();
167  if (!ms) {
168  if (!m_initialized.test_and_set()) initMessaging();
169  ms = new MsgStream(m_imsg,m_nm);
170  m_msg_tls.reset( ms );
171  }
172 
173  ms->setLevel (m_lvl);
174  return *ms;
175 }

◆ msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level  lvl) const
inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 179 of file AthMessaging.h.

180 { return msg() << lvl; }

◆ msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Test the output level.

Parameters
lvlThe message level to test against
Returns
boolean Indicating if messages at given level will be printed
Return values
trueMessages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

152 {
153  if (!m_initialized.test_and_set()) initMessaging();
154  if (m_lvl <= lvl) {
155  msg() << lvl;
156  return true;
157  } else {
158  return false;
159  }
160 }

◆ print()

void MuonGM::MuonChamberLite::print ( ) const
overridevirtual

Implements MuonGM::DetectorElement.

Definition at line 1075 of file MuonChamberLite.cxx.

1075  {
1076  ATH_MSG_INFO("MuonChamberLite " << name << " :" );
1077  }

◆ setCscReadoutGeom()

void MuonGM::MuonChamberLite::setCscReadoutGeom ( const MYSQL &  mysql,
CscReadoutElement *  re,
const CscComponent *  cc,
const Position &  p 
)
private

Definition at line 843 of file MuonChamberLite.cxx.

844  {
845 
846  re->m_Ssize = cc->dx1;
847  re->m_LongSsize = cc->dx2;
848  re->m_Rsize = cc->dy;
849  re->m_LongRsize = cc->dy;
850  re->m_Zsize = cc->GetThickness(mysql);
851  re->m_LongZsize = cc->GetThickness(mysql);
852  re->m_RlengthUpToMaxWidth = cc->maxwdy;
853  re->m_excent = cc->excent;
854 
855  // Csc features specific to this readout element
856  std::string tname = cc->name;
857  re->setTechnologyName(tname);
858 
859  if (ip.isAssigned) {
860  re->setStationS(ip.shift);
861  } else {
862  throw std::runtime_error(" MuonChamberLite::setCscReadoutGeom: position not found ");
863  }
864 
865  const CSC *thisc = dynamic_cast<const CSC*>(mysql.GetTechnology(tname));
866  re->m_anodecathode_distance = thisc->anocathodist;
867  re->m_ngasgaps = thisc->numOfLayers;
868  re->m_nstriplayers = thisc->numOfLayers;
869  re->m_nwirelayers = thisc->numOfLayers;
870  re->m_roxacellwidth = thisc->roxacellwith;
871  re->m_nEtastripsperlayer = thisc->nEtastrips;
872  re->m_nPhistripsperlayer = thisc->nPhistrips;
873  re->m_Etastrippitch = thisc->cathreadoutpitch;
874  re->m_Phistrippitch = thisc->phireadoutpitch;
875  re->m_Etastripwidth = re->m_Etastrippitch;
876  re->m_Phistripwidth = re->m_Phistrippitch;
877  }

◆ setKeyset()

void MuonGM::MuonChamberLite::setKeyset ( std::set< std::string > *  keySet)
inline

Definition at line 47 of file MuonChamberLite.h.

47 {m_keySet=keySet;};

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level  lvl)
inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

29 {
30  m_lvl = lvl;
31 }

◆ setLogVolName()

void MuonGM::DetectorElement::setLogVolName ( const std::string &  str)
inlineinherited

Definition at line 22 of file DetectorElement.h.

22 { logVolName = str; }

◆ setMdtReadoutGeom()

void MuonGM::MuonChamberLite::setMdtReadoutGeom ( const MYSQL &  mysql,
MdtReadoutElement *  re,
const MdtComponent *  cc,
const Position &  p 
)
private

Definition at line 879 of file MuonChamberLite.cxx.

880  {
881  re->m_Ssize = cc->dx1;
882  re->m_LongSsize = cc->dx2;
883 
884  if (re->m_inBarrel) {
885  re->m_Rsize = cc->GetThickness(mysql);
886  re->m_LongRsize = cc->GetThickness(mysql);
887  re->m_Zsize = cc->dy;
888  re->m_LongZsize = cc->dy;
889  } else {
890  re->m_Rsize = cc->dy;
891  re->m_LongRsize = cc->dy;
892  re->m_Zsize = cc->GetThickness(mysql);
893  re->m_LongZsize = cc->GetThickness(mysql);
894  }
895 
896  re->m_cutoutShift = cc->cutoutTubeXShift;
897  re->m_tubelenStepSize = cc->tubelenStepSize;
898 
899  if (ip.isAssigned) {
900  re->setStationS(ip.shift);
901  } else {
902  throw std::runtime_error(" MuonChamberLite::setMdtReadoutGeom: position not found ");
903  }
904 
905  std::string tname = cc->name;
906  re->setTechnologyName(tname);
907  const MDT *thism = dynamic_cast<const MDT*>(mysql.GetTechnology(tname));
908  re->m_nlayers = thism->numOfLayers;
909  re->m_tubepitch = thism->pitch;
910  re->m_tubelayerpitch = thism->y[1] - thism->y[0];
911  re->m_endpluglength = thism->tubeEndPlugLength;
912  re->m_deadlength = cc->deadx; // thism->tubeDeadLength;
913  re->m_innerRadius = thism->innerRadius;
914  re->m_tubeWallThickness = thism->tubeWallThickness;
915 
916  if (re->m_inBarrel) {
917  re->m_ntubesperlayer = int(re->m_Zsize / re->m_tubepitch);
918  re->m_nsteps = 1; // all tubes have the same length
919  re->m_ntubesinastep = re->m_ntubesperlayer;
920  re->m_tubelength[0] = re->m_Ssize;
921  } else {
922  re->m_ntubesperlayer = int(re->m_Rsize / re->m_tubepitch);
923  re->m_nsteps = int(re->m_Rsize / re->m_tubelenStepSize);
924  re->m_ntubesinastep = int(re->m_tubelenStepSize / re->m_tubepitch);
925  re->m_tubelength[0] = re->m_Ssize;
926  double diff = (re->m_LongSsize - re->m_Ssize) * (re->m_LongRsize - re->m_tubepitch / 2.) / re->m_LongRsize;
927  for (int is = 0; is < re->m_nsteps; ++is) {
928  double len = re->m_Ssize + is * diff / re->m_nsteps;
929  re->m_tubelength[is] = len;
930  }
931  }
932 
933  for (int tl = 0; tl < re->m_nlayers; ++tl) {
934  re->m_firstwire_x[tl] = thism->x[tl];
935  re->m_firstwire_y[tl] = thism->y[tl];
936  }
937  }

◆ setRpcReadoutGeom()

void MuonGM::MuonChamberLite::setRpcReadoutGeom ( const MYSQL &  mysql,
RpcReadoutElement *  re,
const RpcComponent *  cc,
const Position &  p 
)
private

the values from MuonGeoModel have an offset of 0.74, TO BE INVESTIGATED, cf. ATLASSIM-5021 On the other hand this detector has never sent any good data. So the investigation doesn't really matter

Definition at line 939 of file MuonChamberLite.cxx.

942  {
943 
944  re->m_Ssize = cc->dx1;
945  re->m_LongSsize = cc->dx2;
946  re->m_Rsize = cc->GetThickness(mysql);
947  re->m_LongRsize = cc->GetThickness(mysql);
948  re->m_Zsize = cc->dy;
949  re->m_LongZsize = cc->dy;
950 
951  re->m_hasDEDontop = true;
952  if (cc->iswap == -1)
953  re->m_hasDEDontop = false;
954 
955  if (ip.isAssigned) {
956  re->setStationS(ip.shift);
957  } else {
958  ATH_MSG_ERROR( " MuonChamber::setRpcReadoutGeom: position not found " );
959  assert(0);
960  }
961 
962  std::string tname = cc->name;
963  re->setTechnologyName(tname);
964  const RPC *thisr = dynamic_cast<const RPC*>(mysql.GetTechnology(tname));
965  re->m_nphigasgaps = thisr->NGasGaps_in_s;
966  re->m_gasgapssize = re->m_Ssize / re->m_nphigasgaps - 2. * thisr->bakeliteframesize;
967  re->m_gasgapzsize = re->m_Zsize - 2. * thisr->bakeliteframesize;
968  re->m_nphistrippanels = thisr->NstripPanels_in_s;
969  re->m_phistrippitch = thisr->stripPitchS;
970  re->m_etastrippitch = thisr->stripPitchZ;
971 
972  if (re->getStationName().find("BI") != std::string::npos) {
973  re->setNumberOfLayers(3); // all BI RPCs always have 3 gas gaps
974 
975  }
976  const RPC* genericRpc = dynamic_cast<const RPC*>(mysql.GetATechnology("RPC0"));
977 
978  if (re->numberOfLayers() == 3) {
979  constexpr double rpc3GapLayerThickness = 11.8; // gas vol. + ( bakelite + graphite + PET )x2
980  for (int gasGap =1 ; gasGap <= re->numberOfLayers(); ++gasGap) {
983  re->m_gasGap_xPos[gasGap -1] = (gasGap - 2) * rpc3GapLayerThickness - 0.74;
984  }
985  } else {
986  re->m_gasGap_xPos[0] = -re->m_Rsize / 2. + thisr->externalSupPanelThickness + genericRpc->stripPanelThickness
987  + genericRpc->GasGapThickness / 2;
988  re->m_gasGap_xPos[1] = re->m_gasGap_xPos[0] + genericRpc->rpcLayerThickness +
989  genericRpc->centralSupPanelThickness;
990  if (!re->m_hasDEDontop) {
991  std::swap(re->m_gasGap_xPos[0], re->m_gasGap_xPos[1]);
992  }
993  }
994 
995  re->m_phistripwidth = re->m_phistrippitch - genericRpc->stripSeparation;
996  re->m_etastripwidth = re->m_etastrippitch - genericRpc->stripSeparation;
997  re->m_nphistripsperpanel = int((re->m_Ssize / re->m_nphistrippanels) / re->m_phistrippitch);
998  if (re->getStationName().compare(0, 3, "BME") != 0) {
999  re->m_nphistripsperpanel-=(re->m_nphistripsperpanel % 8) ;
1000  }
1001  re->m_netastripsperpanel = int((re->m_Zsize) / re->m_etastrippitch);
1002  re->m_netastripsperpanel -= (re->m_netastripsperpanel % 8);
1003 
1004  re->m_phipaneldead = re->m_Ssize / re->m_nphistrippanels -
1005  re->m_nphistripsperpanel * re->m_phistrippitch +
1006  genericRpc->stripSeparation;
1007  re->m_phipaneldead = re->m_phipaneldead / 2.;
1008  re->m_etapaneldead = re->m_Zsize - re->m_netastripsperpanel * re->m_etastrippitch + genericRpc->stripSeparation;
1009  re->m_etapaneldead = re->m_etapaneldead / 2.;
1010  re->m_phistriplength = re->m_LongZsize;
1011  re->m_etastriplength = re->m_LongSsize / re->m_nphistrippanels;
1012 
1013  re->m_first_phistrip_s[0] = -re->m_Ssize / 2. + re->m_phipaneldead + re->m_phistripwidth / 2.;
1014  if (re->m_nphistrippanels == 2) {
1015  re->m_first_phistrip_s[1] = re->m_phipaneldead + re->m_phistripwidth / 2.;
1016  }
1017 
1018  double offset = 0.;
1019  re->m_phistrip_z = -re->m_Zsize / 2. + offset + re->m_phistriplength / 2.;
1020 
1021  // first strip position on each eta panel
1022  re->m_first_etastrip_z = -re->m_Zsize / 2. + re->m_etapaneldead + re->m_etastripwidth / 2.;
1023  re->m_etastrip_s[0] = -re->m_Ssize / 2. + offset + re->m_etastriplength / 2.;
1024  if (re->m_nphistrippanels == 2) {
1025  re->m_etastrip_s[1] = re->m_Ssize / 2. - offset - re->m_etastriplength / 2.;
1026  }
1027 
1028  }

◆ setTgcReadoutGeom()

void MuonGM::MuonChamberLite::setTgcReadoutGeom ( const MYSQL &  mysql,
TgcReadoutElement *  re,
const TgcComponent *  cc,
const Position &  p,
const std::string &  statname 
)
private

Definition at line 1030 of file MuonChamberLite.cxx.

1034  {
1035 
1036  re->setSsize(cc->dx1);
1037  re->setLongSsize(cc->dx2);
1038  re->setRsize(cc->dy);
1039  re->setLongRsize(cc->dy);
1040  re->setZsize(cc->GetThickness(mysql));
1041  re->setLongZsize(cc->GetThickness(mysql));
1042 
1043 
1044  const TGC *genericTgc = dynamic_cast<const TGC*>(mysql.GetATechnology("TGC0"));
1045  re->setFrameThickness(genericTgc->frame_h,
1046  genericTgc->frame_ab);
1047 
1048 
1049  const std::string &tname = cc->name;
1050  int tname_index = MuonGM::strtoint(tname, 3, 2);
1051  re->setTechnologyName(tname);
1052 
1053  if (ip.isAssigned) {
1054  re->setStationS(ip.shift);
1055  } else {
1056  throw std::runtime_error(" MuonChamberLite::setTgcReadoutGeom position not found ");
1057  }
1058 
1059  re->setReadOutName(stName.substr(0, 4) + '_' + std::to_string(cc->index));
1060  re->setReadOutParams(mysql.GetTgcRPars(tname_index));
1061 
1062  const TGC *thist = dynamic_cast<const TGC*>(mysql.GetTechnology(tname));
1063  const std::size_t ncomp = (thist->materials).size();
1064 
1065  unsigned int gasGap{0};
1066  for (std::size_t i = 0; i < ncomp; ++i) {
1067  double newpos = -re->getZsize() / 2. + thist->positions[i] + thist->tck[i] / 2.;
1068 
1069  if ( thist->materials[i].find("TGCGas") != std::string::npos) {
1070  re->setPlaneZ(newpos, ++gasGap);
1071  }
1072  }
1073  }

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

◆ length

double MuonGM::MuonChamberLite::length {0.}

Definition at line 35 of file MuonChamberLite.h.

◆ logVolName

std::string MuonGM::DetectorElement::logVolName {}
inherited

Definition at line 18 of file DetectorElement.h.

◆ longWidth

double MuonGM::MuonChamberLite::longWidth {0.}

Definition at line 37 of file MuonChamberLite.h.

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }
mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

◆ m_keySet

std::set<std::string>* MuonGM::MuonChamberLite::m_keySet {nullptr}
private

Definition at line 63 of file MuonChamberLite.h.

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }
mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

◆ m_mapAXF

std::map<std::string, GeoAlignableTransform*>* MuonGM::MuonChamberLite::m_mapAXF {nullptr}
private

Definition at line 62 of file MuonChamberLite.h.

◆ m_mapFPV

std::map<std::string, GeoFullPhysVol*>* MuonGM::MuonChamberLite::m_mapFPV {nullptr}
private

Definition at line 61 of file MuonChamberLite.h.

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls
mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

◆ m_nm

std::string AthMessaging::m_nm
privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_station

Station* MuonGM::MuonChamberLite::m_station {nullptr}
private

Definition at line 59 of file MuonChamberLite.h.

◆ name

std::string MuonGM::DetectorElement::name {}
inherited

Definition at line 17 of file DetectorElement.h.

◆ rotangle

std::array<double,10> MuonGM::MuonChamberLite::rotangle {}

Definition at line 39 of file MuonChamberLite.h.

◆ thickness

double MuonGM::MuonChamberLite::thickness {0.}

Definition at line 36 of file MuonChamberLite.h.

◆ width

double MuonGM::MuonChamberLite::width {0.}

Definition at line 34 of file MuonChamberLite.h.

The documentation for this class was generated from the following files:
MuonGM::Station::hasMdts
bool hasMdts() const
Definition: Station.h:88
AthMessaging::m_lvl
std::atomic< MSG::Level > m_lvl
Current logging level.
Definition: AthMessaging.h:138
MuonIdHelper::stationNameIndex
int stationNameIndex(const std::string &name) const
Definition: MuonIdHelper.cxx:852
beamspotman.r
def r
Definition: beamspotman.py:672
Muon::nsw::STGTPSegments::moduleIDBits::stationPhi
constexpr uint8_t stationPhi
station Phi 1 to 8
Definition: NSWSTGTPDecodeBitmaps.h:161
dumpTgcDigiDeadChambers.gasGap
list gasGap
Definition: dumpTgcDigiDeadChambers.py:33
MuonGM::DetectorElement::name
std::string name
Definition: DetectorElement.h:17
egammaParameters::depth
@ depth
pointing depth of the shower as calculated in egammaqgcld
Definition: egammaParamDefs.h:276
MuonGM::MuonChamberLite::m_station
Station * m_station
Definition: MuonChamberLite.h:59
python.SystemOfUnits.mm
float mm
Definition: SystemOfUnits.py:98
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
MuonGM::Station::GetExtraBottomThickness
double GetExtraBottomThickness() const
Definition: Station.cxx:155
RPCON
#define RPCON
Definition: MuonChamberLite.cxx:60
MuonGM::MuonChamberLite::longWidth
double longWidth
Definition: MuonChamberLite.h:37
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
hist_file_dump.d
d
Definition: hist_file_dump.py:142
mergePhysValFiles.start
start
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:13
Muon::MuonStationIndex::stName
const std::string & stName(StIndex index)
convert StIndex into a string
Definition: MuonStationIndex.cxx:104
MuonGM::MuonChamberLite::width
double width
Definition: MuonChamberLite.h:34
createCablingJSON.doubletR
int doubletR
Definition: createCablingJSON.py:15
deg
#define deg
Definition: SbPolyhedron.cxx:17
mc.diff
diff
Definition: mc.SFGenPy8_MuMu_DD.py:14
MuonGM::MuonChamberLite::m_keySet
std::set< std::string > * m_keySet
Definition: MuonChamberLite.h:63
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
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:936
AthMessaging::m_imsg
std::atomic< IMessageSvc * > m_imsg
MessageSvc pointer.
Definition: AthMessaging.h:135
RpcIdHelper
Definition: RpcIdHelper.h:51
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition: getMessageSvc.cxx:20
keylayer_zslicemap.strip
strip
Definition: keylayer_zslicemap.py:151
MuonGM::MuonChamberLite::setCscReadoutGeom
void setCscReadoutGeom(const MYSQL &mysql, CscReadoutElement *re, const CscComponent *cc, const Position &p)
Definition: MuonChamberLite.cxx:843
MuonGM::MuonChamberLite::setRpcReadoutGeom
void setRpcReadoutGeom(const MYSQL &mysql, RpcReadoutElement *re, const RpcComponent *cc, const Position &p)
Definition: MuonChamberLite.cxx:939
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
TrigConf::MSGTC::Level
Level
Definition: Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStream.h:21
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
python.BunchSpacingUtils.lb
lb
Definition: BunchSpacingUtils.py:86
useAssemblies
#define useAssemblies
Definition: MuonChamberLite.cxx:61
lumiFormat.i
int i
Definition: lumiFormat.py:85
TGC
Definition: TgcBase.h:6
MuonGM::MuonChamberLite::m_mapAXF
std::map< std::string, GeoAlignableTransform * > * m_mapAXF
Definition: MuonChamberLite.h:62
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
python.CaloAddPedShiftConfig.str
str
Definition: CaloAddPedShiftConfig.py:42
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
MuonGM::Station::getAmdbOrigine_along_length
double getAmdbOrigine_along_length() const
Definition: Station.cxx:553
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
MdtIdHelper
Definition: MdtIdHelper.h:61
AthMessaging
Class to provide easy MsgStream access and capabilities.
Definition: AthMessaging.h:55
find_tgc_unfilled_channelids.ip
ip
Definition: find_tgc_unfilled_channelids.py:3
MuonGM::Station::GetExtraTopThickness
double GetExtraTopThickness() const
Definition: Station.cxx:151
WriteCalibToCool.swap
swap
Definition: WriteCalibToCool.py:94
AthMessaging::msg
MsgStream & msg() const
The standard message stream.
Definition: AthMessaging.h:164
MuonGM::MuonChamberLite::m_mapFPV
std::map< std::string, GeoFullPhysVol * > * m_mapFPV
Definition: MuonChamberLite.h:61
RPC
@ RPC
Definition: RegSelEnums.h:32
CscIdHelper::channelID
Identifier channelID(int stationName, int stationEta, int stationPhi, int chamberLayer, int wireLayer, int measuresPhi, int strip) const
Definition: CscIdHelper.cxx:711
MuonGM::MuonChamberLite::length
double length
Definition: MuonChamberLite.h:35
MdtIdHelper::channelID
Identifier channelID(int stationName, int stationEta, int stationPhi, int multilayer, int tubeLayer, int tube) const
Definition: MdtIdHelper.cxx:664
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
MuonGM::MuonChamberLite::thickness
double thickness
Definition: MuonChamberLite.h:36
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
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
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
MuonGM::Station::GetNrOfComponents
int GetNrOfComponents() const
Definition: Station.cxx:322
CscIdHelper
Definition: CscIdHelper.h:52
MuonGM::MuonChamberLite::setMdtReadoutGeom
void setMdtReadoutGeom(const MYSQL &mysql, MdtReadoutElement *re, const MdtComponent *cc, const Position &p)
Definition: MuonChamberLite.cxx:879
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.Constants.INFO
int INFO
Definition: Control/AthenaCommon/python/Constants.py:15
AthMessaging::m_nm
std::string m_nm
Message source name.
Definition: AthMessaging.h:129
re
const boost::regex re(r_e)
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
python.SystemOfUnits.s
float s
Definition: SystemOfUnits.py:147
MuonGM::Station::GetCutout
Cutout * GetCutout(int i) const
Definition: Station.cxx:85
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:588
MuonGM::DetectorElement::logVolName
std::string logVolName
Definition: DetectorElement.h:18
python.Logging.manager
manager
Definition: PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/Logging.py:92
dqt_zlumi_alleff_HIST.tl
tl
Definition: dqt_zlumi_alleff_HIST.py:73
CSC
@ CSC
Definition: RegSelEnums.h:34
CaloCondBlobAlgs_fillNoiseFromASCII.tag
string tag
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:23
AthMessaging::initMessaging
void initMessaging() const
Initialize our message level and MessageSvc.
Definition: AthMessaging.cxx:39
Muon::nsw::STGTPSegments::moduleIDBits::stationEta
constexpr uint8_t stationEta
1 to 3
Definition: NSWSTGTPDecodeBitmaps.h:159
rp
ReadCards * rp
Definition: IReadCards.cxx:26
AthMessaging::m_msg_tls
boost::thread_specific_ptr< MsgStream > m_msg_tls
MsgStream instance (a std::cout like with print-out levels)
Definition: AthMessaging.h:132
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
python.compressB64.c
def c
Definition: compressB64.py:93
calibdata.tube
tube
Definition: calibdata.py:30
MuonGM::DetectorElement::DetectorElement
DetectorElement(const std::string &n)
Definition: DetectorElement.h:20
MDT
@ MDT
Definition: RegSelEnums.h:31
python.handimod.cc
int cc
Definition: handimod.py:522
MuonGM::MuonChamberLite::setTgcReadoutGeom
void setTgcReadoutGeom(const MYSQL &mysql, TgcReadoutElement *re, const TgcComponent *cc, const Position &p, const std::string &statname)
Definition: MuonChamberLite.cxx:1030
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
python.SystemOfUnits.ms
float ms
Definition: SystemOfUnits.py:148
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Mon Oct 27 2025 22:01:56 for ATLAS Offline Software by   doxygen 1.8.18