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 83 of file MuonChamberLite.cxx.

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

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 105 of file MuonChamberLite.cxx.

107  {
108 
109 
110 
111  ATH_MSG_VERBOSE( " Building a MuonChamberLite for m_station " << m_station->GetName() << " at zi, fi " << zi << " " << fi + 1 << " is_mirrored " << is_mirrored
112  << " is assembly = " << isAssembly );
113 
114  std::string stname(m_station->GetName(), 0, 3);
115 
116  double halfpitch = m_station->mdtHalfPitch(mysql);
117  const std::string stName = m_station->GetName();
118 
119  const MdtIdHelper *mdt_id = manager->mdtIdHelper();
120  int stationType = mdt_id->stationNameIndex(stName.substr(0, 3));
121 
122  double extratop = m_station->GetExtraTopThickness();
123  double extrabottom = m_station->GetExtraBottomThickness();
124  double totthick = thickness + extratop + extrabottom;
125 
126 
127  double amdbOrigine_along_length = m_station->getAmdbOrigine_along_length();
128  double amdbOrigine_along_thickness = m_station->getAmdbOrigine_along_thickness(mysql);
129 
130 
131  // This will allow the MDT tube structure to be mirrored w.r.t. the chamber at z>0
132  // and to correctly place any other component in the m_station
133  if (zi < 0 && !is_mirrored && stName[0] == 'B') {
134  if (m_station->hasMdts()) {
135  amdbOrigine_along_length += halfpitch;
136  }
137  }
138  ATH_MSG_VERBOSE( "amdb origine: in the length direction = "
139  << amdbOrigine_along_length << " in the thickness direction = " << amdbOrigine_along_thickness);
140 
141  if (isAssembly) {
142  ATH_MSG_DEBUG("Station " << stName << " at zi, fi " << zi << " " << fi + 1 << " will be described as Assembly" );
143 
144  }
145 
146  // for BOG in layout Q we will have to shorten CHV, CMI as these
147  // are not shortened in AMDB
148 
149 
150  // if this is a BOG, we want to make cutouts in the MOTHER VOLUME
151  if (stName.compare(0, 3, "BOG") == 0 && (manager->IncludeCutoutsBogFlag() || manager->IncludeCutoutsFlag())) {
152 
153  ATH_MSG_VERBOSE( "amdb org: length= " << amdbOrigine_along_length << " thickness= " << amdbOrigine_along_thickness );
154 
155  std::string statType = stName.substr(0, 3);
156  if (m_station->GetNrOfCutouts() > 0) {
157  ATH_MSG_DEBUG( "Station " << stName << " at zi, fi " << zi << " " << fi + 1 << " has components with cutouts " );
158  isAssembly = true;
159 
160  // look for FIRST component with cutouts and loop over all of the cutouts:
161  bool foundCutouts = false;
162  for (int j = 0; j < m_station->GetNrOfComponents(); j++) {
163  StandardComponent *c = (StandardComponent *)m_station->GetComponent(j);
164 
165  if (!foundCutouts) {
166  for (int ii = 0; ii < m_station->GetNrOfCutouts(); ii++) {
167  Cutout *cut = m_station->GetCutout(ii);
168  // if this is a BOG in layout Q, set the CP param:
169  // (both cuts have same length so ok to reset it)
170  // also do here some tweaking to prevent undershoot
171  // of the cutouts wrt mother volume:
172  if (std::abs(cut->dx - 600.7) < 0.1) {
173  cut->dx = cut->dx + 10. * Gaudi::Units::mm;
174  cut->widthXs = cut->widthXs + 20. * Gaudi::Units::mm;
175  cut->widthXl = cut->widthXl + 20. * Gaudi::Units::mm;
176  }
177  if (std::abs(cut->dx + 600.7) < 0.1) {
178  cut->dx = cut->dx - 10. * Gaudi::Units::mm;
179  cut->widthXs = cut->widthXs + 20. * Gaudi::Units::mm;
180  cut->widthXl = cut->widthXl + 20. * Gaudi::Units::mm;
181  }
182  if (std::abs(cut->lengthY - 180.2) < 0.001) {
183  cut->lengthY = cut->lengthY + (0.010) * Gaudi::Units::mm;
184  }
185  if (std::abs(cut->dy - 1019.8) < 0.001) {
186  cut->dy = 1216.4185 - cut->lengthY;
187  }
188  // create the cutout with the full thickness of the STATION
189  cut->setThickness(totthick * 1.01); // extra to be sure
190  if ((cut->subtype == mysql.allocPosFindSubtype(std::string(statType), fi, zi)) && (cut->icut == mysql.allocPosFindCutout(std::string(statType), fi, zi)) &&
191  (cut->ijob == c->index)) {
192 
193  foundCutouts = true;
194  }
195  } // Loop over cutouts
196  } // If no cutouts
197  } // Loop over components
198  }
199  } // end of special loop just for cutouts
200 
201 
202 
203  double ypos{0.}, zpos{0.}, xpos{0.}, irad{0.};
204  std::array<int, 2 > ndbz{0, 0};
205 
206  // Compute how many RPC modules there are in the m_station
207  int nDoubletR{0}, nRpc{0}, nTgc{0}, nCsc{0}, nMdt{0};
208  double previous_depth = 0.;
209 
210  ATH_MSG_VERBOSE( " Station Name = " << stName << " fi/zi " << fi << "/" << zi << " defining the n. of DoubletR to " );
211 
212 
213  for (int j = 0; j < m_station->GetNrOfComponents(); j++) {
214  StandardComponent *d = (StandardComponent *)m_station->GetComponent(j);
215  std::string_view cn = std::string_view(d->name).substr(0, 3);
216  if (cn == "RPC") {
217  nRpc++;
218  if (nRpc == 1)
219  nDoubletR++;
220  double depth = -thickness / 2. + d->posz + d->GetThickness(mysql) / 2.;
221  // BI RPC Chambers have one one doubletR
222  if (!(stname.compare(0, 2, "BI") == 0) && nDoubletR == 1 && nRpc > 1 && depth * previous_depth < 0)
223  nDoubletR++;
224 
225  previous_depth = depth;
226  }
227  else if (cn == "CSC") {
228  nCsc++;
229  }
230  else if (cn == "TGC") {
231  nTgc++;
232  }
233  else if (cn == "MDT") {
234  nMdt++;
235  }
236  }
237  ATH_MSG_DEBUG( "nDoubletR: " << nDoubletR<<" nMdt/Rpc/Tgc/Csc " << nMdt << "/" << nRpc << "/" << nTgc << "/" << nCsc );
238 
239  // Get location and dimensions of long beams and pass them to cross beams
240  // in order to make holes
241  int numLB = -1;
242  double LBheight{0.}, LBwidth{0.};
243  std::array<double, 2> LBpos{-1, -1};
244  for (int i = 0; i < m_station->GetNrOfComponents(); i++) {
245  StandardComponent *c = (StandardComponent *)m_station->GetComponent(i);
246  std::string_view cname = std::string_view(c->name).substr(0, 2);
247  if (cname == "LB") {
248  const LBI *lb = dynamic_cast<const LBI *>(mysql.GetTechnology(c->name));
249  numLB++;
250  LBpos[numLB] = c->posy + c->dy / 2.;
251  LBheight = lb->height;
252  LBwidth = c->dy;
253  }
254  if (numLB > 0)
255  break; // only 2 LBs per chamber
256  }
257 
258  for (int i = 0; i < m_station->GetNrOfComponents(); i++) {
259  StandardComponent *c = (StandardComponent *)m_station->GetComponent(i);
260  std::string_view cname = std::string_view(c->name).substr(0, 3);
261  if (cname == "CRO" || cname == "CMI" || cname == "CHV") {
262  CbmComponent *ccbm = (CbmComponent *)c;
263  ccbm->lb_height = LBheight;
264  ccbm->lb_width = LBwidth;
265  ccbm->hole_pos1 = LBpos[0];
266  ccbm->hole_pos2 = LBpos[1];
267  }
268  }
269 
270  // Look for the subtype of the CMI in the chamber to let LB know ...
271  std::string CMIcomponentNumber = "";
272  for (int j = 0; j < m_station->GetNrOfComponents(); j++) {
273  StandardComponent *d = (StandardComponent *)m_station->GetComponent(j);
274  std::string_view cn = std::string_view(d->name).substr(0, 3);
275  if (cn == "CMI") {
276  CMIcomponentNumber = (d->name).substr(3, 2);
277  break;
278  }
279  }
280 
281  for (int j = 0; j < m_station->GetNrOfComponents(); j++) {
282  StandardComponent *d = (StandardComponent *)m_station->GetComponent(j);
283  std::string_view cn = std::string_view(d->name).substr(0, 2);
284  if (cn == "LB") {
285  LbiComponent *lbic = (LbiComponent *)d;
286  if (lbic) {
287  lbic->associated_CMIsubtype = CMIcomponentNumber;
288  } else
289  ATH_MSG_ERROR( "MuonChamberLite :: cannot associate a CMI subtype to the LB component " );
290  }
291  }
292 
293  // Build the MuonStation(readout-geometry) corresponding to this MuonChamberLite(raw-geometry)
294  MuonStation *mstat;
295  if (stName.compare(0, 1, "B") == 0) {
296  mstat = new MuonStation(stName.substr(0, 3), width, totthick, length, longWidth, totthick, length, zi, fi + 1,
297  (zi < 0 && !is_mirrored));
298  } else {
299  mstat = new MuonStation(stName.substr(0, 3), width, length, totthick, longWidth, length, totthick, zi, fi + 1,
300  (zi < 0 && !is_mirrored));
301  }
302  manager->addMuonStation(std::unique_ptr<MuonStation>(mstat));
303  ATH_MSG_DEBUG( " Building a MuonStation for this MuonChamberLite " << m_station->GetName()
304  << " at zi, fi " << zi << " " << fi + 1 << " is_mirrored " << is_mirrored);
305 
306  GeoFullPhysVol *ptrd=(*m_mapFPV)[std::string(stName)+"_Station"+"_"+std::to_string(zi)+"_"+std::to_string(fi)];
307  // here the big loop over the components !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
308  for (int i = 0; i < m_station->GetNrOfComponents(); i++) {
309  StandardComponent *c = (StandardComponent *)m_station->GetComponent(i);
310  ATH_MSG_VERBOSE( " Component index " << c->index << " in loop for " << stName << " " << stationType << " at zi, fi " << zi << " " << fi + 1 << " cName "
311  << c->name << " thickness " << c->GetThickness(mysql) << " length " << c->dy << " w, lw " << c->dx1 << " " << c->dx2 );
312  ATH_MSG_VERBOSE( " Component local (amdb) coords " << c->posx << " " << c->posy << " " << c->posz );
313 
314  ypos = -thickness / 2. + c->posz + c->GetThickness(mysql) / 2.;
315  zpos = 0.;
316  xpos = 0.;
317 
318  ypos = -thickness / 2. + (c->posz + amdbOrigine_along_thickness) + c->GetThickness(mysql) / 2.;
319  zpos = -length / 2. + amdbOrigine_along_length + c->posy + c->dy / 2.;
320  xpos = c->posx;
321 
322  const std::string &techname = c->name;
323  std::string_view type = std::string_view(techname).substr(0, 3);
324 
325 
326 
327  GeoFullPhysVol *lvm = nullptr;
328  GeoFullPhysVol *lvr = nullptr;
329  GeoFullPhysVol *lvt = nullptr;
330  GeoFullPhysVol *lvc = nullptr;
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 = (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= (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 = (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 = (TgcComponent *)m_station->GetComponent(i);
555  TgcComponent *tgInner = (TgcComponent *)m_station->GetComponent(0);
556  irad = tgInner->posy;
557  TgcComponent *tgOuter = (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  char chswidth[32];
577  sprintf(chswidth, "%i", int(10 * c->dx1));
578  key += chswidth;
579  xfaligncomponent = (*m_mapAXF)[key+"_"+std::to_string(zi)+"_"+std::to_string(fi)];
580 
581  lvt = (*m_mapFPV)[key+"_"+std::to_string(zi)+"_"+std::to_string(fi)];
582 
583  } else if (type == "CSC") {
584  htcomponent = GeoTrf::TranslateX3D(ypos) * GeoTrf::TranslateZ3D(zpos);
585  // Here define the key for this CSC component
586  std::string key = std::string(stName) + techname;
587  if (manager->IncludeCutoutsFlag() && zi >= 0) {
588  key += "p" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0);
589  } else if (manager->IncludeCutoutsFlag() && zi < 0) {
590  key += "m" + buildString(mysql.allocPosFindSubtype(statType, fi, zi), 0) + "_" + buildString(mysql.allocPosFindCutout(statType, fi, zi), 0);
591  }
592 
593  xfaligncomponent = (*m_mapAXF)[key+"_"+std::to_string(zi)+"_"+std::to_string(fi)];
594  lvc=(*m_mapFPV)[key+"_"+std::to_string(zi)+"_"+std::to_string(fi)];
595  } else {
596  if (type != "MDT" && type != "RPC" && type != "TGC" && type != "SUP" && type != "DED" && type != "SPA" && type != "CHV" && type != "CRO" && type != "CMI" &&
597  type != "LB0" && type != "LBI") {
598  ATH_MSG_WARNING("Unknown component " << type );
599  }
600  }
601 
602  // Place components in chamber envelope
603  if (lvm && manager->mdtIdHelper()) {
604  int stationEta = zi;
605  int stationPhi = fi + 1;
606  int ml = 1;
607  int tubel = 1;
608  int tube = 1;
609  if (ypos > 5.)
610  ml = 2; // Need >5 instead of >0 because BIS78 is not perfectly centered
611 
612 
613  const MdtIdHelper *mdt_id = manager->mdtIdHelper();
614  std::unique_ptr<MdtReadoutElement> det = std::make_unique<MdtReadoutElement>(lvm, stName, manager);
615  Position ip = mysql.GetStationPosition(stName.substr(0, 3), fi, zi);
616  setMdtReadoutGeom(mysql, det.get(), (MdtComponent *)c, ip);
617  det->setHasCutouts(ncutouts > 0);
618  det->setNMdtInStation(nMdt);
619  Identifier id = mdt_id->channelID(stationType, stationEta, stationPhi, ml, tubel, tube);
620  det->setIdentifier(id);
621  det->setMultilayer(ml);
622  det->setParentStationPV(PVConstLink(ptrd));
623  det->setParentMuonStation(mstat);
624  det->geoInitDone();
625 
626  if (ml == 1) {
627  // set fixed point for MDT deformations: s0,z0,t0 for the point at lowest t,z (z,y amdb) and s=x=0
628  mstat->setBlineFixedPointInAmdbLRS(c->posx, c->posy, c->posz);
629  } else {
630  const Amg::Vector3D b0 = mstat->getBlineFixedPointInAmdbLRS();
631  if (c->posy < b0.y())
632  mstat->setBlineFixedPointInAmdbLRS(b0.x(), c->posy, b0.z());
633  }
634 
635  int jobIndex = c->index;
636 
637  mstat->addMuonReadoutElementWithAlTransf(det.get(), xfaligncomponent, jobIndex);
638  manager->addMdtReadoutElement(std::move(det));
639  }
640 
641  if (lvc && manager->cscIdHelper()) {
642  CscComponent *cs = (CscComponent *)m_station->GetComponent(i);
643  int stationEta = zi;
644  int stationPhi = fi + 1;
645  int chamberLayer = 1;
646  if (ypos > 0.)
647  chamberLayer = 2;
648 
649  std::unique_ptr<CscReadoutElement> det = std::make_unique<CscReadoutElement>(lvc, stName, manager);
650  Position ip = mysql.GetStationPosition(stName.substr(0, 3), fi, zi);
651  setCscReadoutGeom(mysql, det.get(), cs, ip);
652 
653  const CscIdHelper *csc_id = manager->cscIdHelper();
654  det->setHasCutouts(ncutouts > 0);
655  Identifier id = csc_id->channelID(stationType, stationEta, stationPhi, chamberLayer, 1, 0, 1);
656  det->setIdentifier(id);
657 
658  det->setChamberLayer(chamberLayer);
659  det->setParentStationPV(PVConstLink(ptrd));
660  det->setParentMuonStation(mstat);
661 
662  int jobIndex = c->index;
663  //
664  mstat->addMuonReadoutElementWithAlTransf(det.get(), xfaligncomponent, jobIndex);
665 
666 
667 
668  // set alignment parameters for the wire layers
669  manager->addCscReadoutElement(std::move(det));
670  }
671 
672  if (lvt && manager->tgcIdHelper()) {
673 
674  ATH_MSG_DEBUG( " Adding a TGC chamber to the tree zi,fi, is_mirrored " << zi << " " << fi + 1 << " " << is_mirrored );
675 
676 
677  TgcComponent *tg = (TgcComponent *)m_station->GetComponent(i);
678 
679  ATH_MSG_VERBOSE( "There's a TGC named " << techname << " of thickness " << tg->GetThickness(mysql) );
680 
681  const TgcIdHelper *tgc_id = manager->tgcIdHelper();
682  int stationEta = 0;
683  stationEta = tg->index;
684  if (zi < 0)
685  stationEta = -stationEta;
686  int stationPhi = 0;
687  stationPhi = stationPhiTGC(stName, fi + 1,zi);
688 
689  std::unique_ptr<TgcReadoutElement> det = std::make_unique<TgcReadoutElement>(lvt, stName, manager);
690  Position ip = mysql.GetStationPosition(stName.substr(0, 3), fi, zi);
691  setTgcReadoutGeom(mysql, det.get(), tg, ip, stName);
692  det->setHasCutouts(ncutouts > 0);
693  Identifier id = tgc_id->channelID(stationType, stationEta, stationPhi, 1, false, 1);
694  det->setIdentifier(id);
695  det->setParentStationPV(PVConstLink(ptrd));
696  det->setParentMuonStation(mstat);
697 
698  int jobIndex = c->index;
699 
700  mstat->addMuonReadoutElementWithAlTransf(det.get(), xfaligncomponent, jobIndex);
701 
702  manager->addTgcReadoutElement(std::move(det));
703  }
704  if (lvr && RPCON && manager->rpcIdHelper()) {
705  RpcComponent *rp = (RpcComponent *)c;
706  int ndivy = rp->ndivy;
707  int ndivz = rp->ndivz;
708 
709  if (ndivz != 1 || ndivy != 1) {
710  ATH_MSG_ERROR( " RPC segmentation z,y " << ndivz << " " << ndivy );
711  }
712 
713  double zpos = -length / 2. + c->posy + c->dy / 2.;
714  double xpos = c->posx;
715 
716  // implement really the mirror symmetry
717  if (is_mirrored)
718  xpos = -xpos;
719  // ... putting back to here!
720 
721  const RpcIdHelper *rpc_id = manager->rpcIdHelper();
722  int stationEta = zi;
723  int stationPhi = fi + 1;
724  int doubletR = 1;
725  int doubletZ = 1;
726 
727  if (nRpc > 1 && nDoubletR == 2 && ypos > 0.)
728  doubletR = 2;
729  ndbz[doubletR - 1]++;
730 
731  // the BI RPCs are 3-gap RPCs mounted inside of the BI (s)MDTs
732  if (stname.find("BI") != std::string::npos) {
733  if (stname.find("BIS") != std::string::npos) {
734  // for BIS78, there is a second RPC doubletZ at amdb-y (MuonGeoModel-z)=144mm inside the station
735  if (std::abs(stationEta)>= 7){
736  ATH_MSG_DEBUG("BIS78 station eta: "<<stationEta<<" phi: "<<stationPhi<<" dR: "<<doubletR<<" dZ:"<< doubletZ <<" rp: "<<rp->posz);
737  }
738  if (std::abs(stationEta) >= 7 && rp->posz > 80)
739  doubletZ = 2;
740  else
741  doubletZ = 1;
742  } else {
743  // 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
744  // only for BIL, there are sometimes 2 RPCs per 1 MDT station, namely for stationEta 1,3,4,6
745  if (stname.find("BIL") != std::string::npos && std::abs(stationEta) < 7 && std::abs(stationEta) != 2 && std::abs(stationEta) != 5) {
746  if (rp->posy > 1)
747  doubletZ = 2; // put the chamber with positive amdb-z to doubletZ=2
748  } else
749  doubletZ = 1;
750  }
751  } else {
752  if (zi <= 0 && !is_mirrored) {
753  if (zpos < -100 * Gaudi::Units::mm)
754  doubletZ = 2;
755  } else {
756  if (zpos > 100 * Gaudi::Units::mm)
757  doubletZ = 2;
758  }
759  }
760 
761  // BMS (BOG) RPCs can have |xpos|=950 (|xpos|=350)
762  if (std::abs(xpos) > 100. * Gaudi::Units::mm) {
763  if (ndbz[doubletR - 1] > 2) {
764  doubletZ = 3;
765  }
766  ndbz[doubletR - 1]--;
767  }
768 
769  int dbphi = 1;
770 
771  // this special patch is needed for BMS in the ribs where xpos is ~950mm;
772  // the theshold to 100mm (too low) caused a bug
773  // in BOG at eta +/-4 and stationEta 7 (not 6) ==>> 28 Jan 2016 raising the threshold to 400.mm
774  // doublet phi not aware of pos. in space !!!
775  if (xpos > 400. * Gaudi::Units::mm)
776  dbphi = 2;
777 
778  int doubletPhi = dbphi;
779  //
780  if (zi < 0 && is_mirrored && doubletZ == 3) {
781  doubletPhi++;
782  if (doubletPhi > 2)
783  doubletPhi = 1;
784  } else if (zi < 0 && is_mirrored && doubletZ == 2 && doubletR == 1 && stName == "BMS6") {
785  doubletPhi++;
786  if (doubletPhi > 2)
787  doubletPhi = 1;
788  }
789  // never defined fields: set to the lower limit
790  int gasGap = 1;
791  int measuresPhi = 0;
792  int strip = 1;
793 
794  int tag = doubletZ + doubletR * 100 + dbphi * 1000;
795  if (rp->iswap == -1)
796  tag = -1 * tag;
797  if (useAssemblies || isAssembly) {
798  //
799  } else {
800  int tag = rp->index + doubletR * 100 + dbphi * 1000;
801  if (rp->iswap == -1)
802  tag = -1 * tag;
803 
804  }
805 
806 
807  std::unique_ptr<RpcReadoutElement> det = std::make_unique<RpcReadoutElement>(lvr, stName, zi, fi + 1, is_mirrored, manager);
808  Position ip = mysql.GetStationPosition(stName.substr(0, 3), fi, zi);
809  setRpcReadoutGeom(mysql, det.get(), rp, ip);
810  det->setHasCutouts(ncutouts > 0);
811  Identifier id = rpc_id->channelID(stationType, stationEta, stationPhi, doubletR, doubletZ, doubletPhi, gasGap, measuresPhi, strip);
812  det->setIdentifier(id);
813  det->setDoubletR(doubletR);
814  det->setDoubletZ(doubletZ);
815  det->setDoubletPhi(doubletPhi);
816  if (stName.find("BI") != std::string::npos)
817  det->setNumberOfLayers(3); // all BI RPCs always have 3 gas gaps
818  det->setParentStationPV(PVConstLink(ptrd));
819  det->setParentMuonStation(mstat);
820 
821  int jobIndex = c->index;
822 
823  mstat->addMuonReadoutElementWithAlTransf(det.get(), xfaligncomponent, jobIndex);
824 
825 
826 
827  if (stName.find("BI") != std::string::npos) {
828  std::map<std::string, float>::const_iterator yItr = rpcYTrans.find(techname);
829  if (yItr != rpcYTrans.end())
830  det->setYTranslation(yItr->second);
831  std::map<std::string, float>::const_iterator zItr = rpcZTrans.find(techname);
832  if (zItr != rpcZTrans.end())
833  det->setZTranslation(zItr->second);
834  }
835 
836  det->fillCache(); // fill temporary cache (global position on known yet)
837  det->initDesign();
838  det->clearCache(); // clear temporary cache
839  manager->addRpcReadoutElement(std::move(det));
840 
841  } // if (lvr && RPCON && manager->rpcIdHelper()) {
842 
843  } // End big loop over components
844  mstat->updateBlineFixedPointInAmdbLRS();
845 
846  return ptrd;
847  }

◆ 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 1084 of file MuonChamberLite.cxx.

1084  {
1085  ATH_MSG_INFO("MuonChamberLite " << name << " :" );
1086  }

◆ setCscReadoutGeom()

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

Definition at line 849 of file MuonChamberLite.cxx.

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

◆ 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 885 of file MuonChamberLite.cxx.

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

◆ 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 945 of file MuonChamberLite.cxx.

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

◆ setTgcReadoutGeom()

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

Definition at line 1036 of file MuonChamberLite.cxx.

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

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:846
beamspotman.r
def r
Definition: beamspotman.py:676
Muon::nsw::STGTPSegments::moduleIDBits::stationPhi
constexpr uint8_t stationPhi
station Phi 1 to 8
Definition: NSWSTGTPDecodeBitmaps.h:129
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.s
int s
Definition: SystemOfUnits.py:131
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
MuonGM::Station::GetExtraBottomThickness
double GetExtraBottomThickness() const
Definition: Station.cxx:155
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
RPCON
#define RPCON
Definition: MuonChamberLite.cxx:59
MuonGM::MuonChamberLite::longWidth
double longWidth
Definition: MuonChamberLite.h:37
TgcIdHelper
Definition: TgcIdHelper.h:50
MuonGM::Station::getAmdbOrigine_along_thickness
double getAmdbOrigine_along_thickness(const MYSQL &mysql) const
Definition: Station.cxx:558
index
Definition: index.py:1
hist_file_dump.d
d
Definition: hist_file_dump.py:137
mergePhysValFiles.start
start
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:14
MuonGM::MuonChamberLite::width
double width
Definition: MuonChamberLite.h:34
createCablingJSON.doubletR
int doubletR
Definition: createCablingJSON.py:10
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:940
AthMessaging::m_imsg
std::atomic< IMessageSvc * > m_imsg
MessageSvc pointer.
Definition: AthMessaging.h:135
python.SystemOfUnits.ms
int ms
Definition: SystemOfUnits.py:132
RpcIdHelper
Definition: RpcIdHelper.h:51
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:849
MuonGM::MuonChamberLite::setRpcReadoutGeom
void setRpcReadoutGeom(const MYSQL &mysql, RpcReadoutElement *re, const RpcComponent *cc, const Position &p)
Definition: MuonChamberLite.cxx:945
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
MuonGM::Component::dy
double dy
Definition: Component.h:21
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:88
useAssemblies
#define useAssemblies
Definition: MuonChamberLite.cxx:60
lumiFormat.i
int i
Definition: lumiFormat.py:92
TGC
Definition: TgcBase.h:6
MuonGM::MuonChamberLite::m_mapAXF
std::map< std::string, GeoAlignableTransform * > * m_mapAXF
Definition: MuonChamberLite.h:62
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
WritePulseShapeToCool.det
det
Definition: WritePulseShapeToCool.py:204
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
MuonGM::Station::GetName
std::string GetName() const
Definition: Station.cxx:110
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:706
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:659
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.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
python.CaloScaleNoiseConfig.str
str
Definition: CaloScaleNoiseConfig.py:78
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:885
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
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
checkFileSG.fi
fi
Definition: checkFileSG.py:65
MuonGM::Station::GetCutout
Cutout * GetCutout(int i) const
Definition: Station.cxx:85
createCablingJSON.doubletPhi
int doubletPhi
Definition: createCablingJSON.py:11
TgcIdHelper::channelID
Identifier channelID(int stationName, int stationEta, int stationPhi, int gasGap, int isStrip, int channel) const
Definition: TgcIdHelper.cxx:583
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:24
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:127
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::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:31
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:523
MuonGM::MuonChamberLite::setTgcReadoutGeom
void setTgcReadoutGeom(const MYSQL &mysql, TgcReadoutElement *re, const TgcComponent *cc, const Position &p, const std::string &statname)
Definition: MuonChamberLite.cxx:1036
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Generated on Tue Jul 2 2024 22:23:30 for ATLAS Offline Software by   doxygen 1.8.18