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

#include <TgcSlbDataHelper.h>

Inheritance diagram for Muon::TgcSlbDataHelper:
Collaboration diagram for Muon::TgcSlbDataHelper:

Public Types

enum  {
  SLB_WD =0, SLB_SD, SLB_WT, SLB_ST,
  SLB_EIFI, SLB_NONE
}
 SLB Module Type in SLB Header. More...
 

Public Member Functions

 TgcSlbDataHelper (void)
 Constructor. More...
 
virtual ~TgcSlbDataHelper (void)
 Destructor. More...
 
 TgcSlbDataHelper (const TgcSlbDataHelper &)=delete
 
TgcSlbDataHelper & operator= (const TgcSlbDataHelper &)=delete
 
void convertToHits (uint16_t subDetectorId, uint16_t rodId, const TgcSlbData *slb, std::vector< TgcRawData * > &vChannel) const
 Convert to Hits. More...
 
void convertToCoincidences (uint16_t subDetectorId, uint16_t rodId, const TgcSlbData *slb, std::vector< TgcRawData * > &vChannel) const
 Convert to coincidences. More...
 
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...
 

Static Public Member Functions

static bool setType (uint16_t subDetectorId, uint16_t rodId, TgcSlbData *slb, int moduleType)
 Set SLB Type based on sswId and moduleType. More...
 
static bool isAdjacent (int ibit)
 Adjacent or not. More...
 
static uint16_t getSector (bool forward, uint16_t subDetectorId, uint16_t rodId, const TgcSlbData *slb)
 Set sector for HpT/SL based on slbId. More...
 

Protected Types

enum  {
  N_LPT_D = 2, N_LPT_TW = 3, N_LPT_TS = 8, N_LPT_I = 8,
  N_HPT_F = 6, N_HPT_E = 13, N_SL = 2
}
 Number of Trigger block in an SLB. More...
 

Protected Member Functions

void getLPTforDoublet (const bool *bitArray, bool hit[], int delta[], int pos[]) const
 Decode low-pT coincidence (tracklet) information for doublet from bit array. More...
 
void getLPTforTripletWire (const bool *bitArray, bool hit[], int pos[]) const
 Decode low-pT coincidence (tracklet) information for triplet wire from bit array. More...
 
void getLPTforTripletStrip (const bool *bitArray, bool hit[], int pos[]) const
 Decode low-pT coincidence (tracklet) information for triplet strip from bit array. More...
 
void getLPTforInner (const bool *bitArray, bool hit[]) const
 Decode low-pT coincidence (tracklet) information for inner from bit array. More...
 
void getSL_F (const bool *bitArray, bool &cand3plus, bool hit[], bool muplus[], uint16_t pt[], bool overlap[], uint16_t roi[]) const
 Decode Sector Logic coincidence information for forward region from bit array. More...
 
void getSL_E (const bool *bitArray, bool &cand3plus, bool hit[], bool muplus[], uint16_t pt[], bool overlap[], uint16_t roi[]) const
 Decode Sector Logic coincidence information for endcap region from bit array. More...
 
void getHPT_F (const bool *bitArray, bool hit[], bool strip[], uint16_t chip[], uint16_t index[], bool hipt[], uint16_t hitId[], uint16_t sub[], int16_t delta[]) const
 Decode high-pT coincidence information for forward region from bit array. More...
 
void getHPT_E (const bool *bitArray, bool hit[], bool strip[], uint16_t chip[], uint16_t index[], bool hipt[], uint16_t hitId[], uint16_t sub[], int16_t delta[]) const
 Decode high-pT coincidence information for endcap region from bit array. More...
 

Static Protected Member Functions

static bool isValid_HPT (bool hit, bool strip, uint16_t chip, uint16_t index, bool hipt, uint16_t hitId, uint16_t pos, int16_t delta)
 Check if it is valid high-pT coincidence or not. More...
 

Private Member Functions

void initMessaging () const
 Initialize our message level and MessageSvc. More...
 

Static Private Member Functions

static uint16_t getVal (const bool *bitArray, std::size_t start, std::size_t width)
 Get a value in a range of a bitArray. More...
 

Private Attributes

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

This is the SLB data helper class which stores bit map, reconstructs to hits and coincidences, and converts to celladdr and data.

Author
Susumu Oda Susum.nosp@m.u.Od.nosp@m.a@cer.nosp@m.n.ch
Hisaya Kurashige

This class was developed by Tadashi Maeno.

Definition at line 31 of file TgcSlbDataHelper.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

SLB Module Type in SLB Header.

Enumerator
SLB_WD 
SLB_SD 
SLB_WT 
SLB_ST 
SLB_EIFI 
SLB_NONE 

Definition at line 36 of file TgcSlbDataHelper.h.

36  {
37  SLB_WD =0,
38  SLB_SD,
39  SLB_WT,
40  SLB_ST,
41  SLB_EIFI,
42  SLB_NONE
43  };

◆ anonymous enum

anonymous enum
protected

Number of Trigger block in an SLB.

Enumerator
N_LPT_D 
N_LPT_TW 
N_LPT_TS 
N_LPT_I 
N_HPT_F 
N_HPT_E 
N_SL 

Definition at line 84 of file TgcSlbDataHelper.h.

84  {
85  N_LPT_D = 2,
86  N_LPT_TW = 3,
87  N_LPT_TS = 8,
88  N_LPT_I = 8,
89  N_HPT_F = 6,
90  N_HPT_E = 13, // additional 2 for duplicate strip hits
91  N_SL = 2
92  };

Constructor & Destructor Documentation

◆ TgcSlbDataHelper() [1/2]

Muon::TgcSlbDataHelper::TgcSlbDataHelper ( void  )

Constructor.

Definition at line 21 of file TgcSlbDataHelper.cxx.

22  : AthMessaging ("Muon::TgcSlbDataHelper")
23 {
24 }

◆ ~TgcSlbDataHelper()

Muon::TgcSlbDataHelper::~TgcSlbDataHelper ( void  )
virtualdefault

Destructor.

◆ TgcSlbDataHelper() [2/2]

Muon::TgcSlbDataHelper::TgcSlbDataHelper ( const TgcSlbDataHelper &  )
delete

Member Function Documentation

◆ convertToCoincidences()

void Muon::TgcSlbDataHelper::convertToCoincidences ( uint16_t  subDetectorId,
uint16_t  rodId,
const TgcSlbData *  slb,
std::vector< TgcRawData * > &  vChannel 
) const

Convert to coincidences.

subDetectorID and ROD ID are dummy.

Definition at line 98 of file TgcSlbDataHelper.cxx.

102 {
103  bool hit[8];
104  int delta[8];
105  int pos[8];
106 
107  bool isFirstHit = true;
108 
109  for(unsigned int iBc=TgcSlbData::BC_PREVIOUS; iBc<TgcSlbData::N_BC; ++iBc) {
110  const bool * bitArray = slb->getBitArray(iBc);
111  bool forward;
112  uint16_t sector;
113 
114  TgcRawData * rCh;
115  switch(slb->getType()) {
116  case TgcSlbData::SLB_LPT_D_W: // Doublet Wire
117  getLPTforDoublet(bitArray, hit, delta, pos);
118 
119  for(int i=0; i<N_LPT_D; ++i) {
120  if(!hit[i]) continue;
121  //create TgcRawData object
122  rCh = new TgcRawData(iBc,
123  subDetectorId, rodId,
124  slb->getSswId(), slb->getSbLoc(),
125  slb->getL1Id(), slb->getBcId(),
126  TgcRawData::SLB_TYPE_DOUBLET_WIRE/*DOUBLET WIRE*/,
127  delta[i],
128  0, i, pos[i]);
129  vChannel.push_back(rCh);
130 
131  // DEBUG PRINT
132  if(isFirstHit) {
133  ATH_MSG_DEBUG( "Tgc TgcSlbDataHelper::convertCoincidence :"
134  << " slb type =" << slb->getType() );
135  isFirstHit = false;
136  }
137  ATH_MSG_DEBUG( ((slb->getType()==TgcSlbData::SLB_LPT_D_W) ?
138  "TgcRawData : LPT_D_W " : "TgcRawData : LPT_D_S ")
139  << " BC:" << iBc
140  << " subDetId:" << subDetectorId
141  << " rodId:" << rodId
142  << " sswId:" << slb->getSswId()
143  << " sbLoc:" << slb->getSbLoc()
144  << " slbId:" << slb->getSlbId()
145  << " sub: " << i
146  << " pos:" << pos[i]
147  << " delta:" << delta[i] );
148  } // loop block (i)
149  break;
150 
151  case TgcSlbData::SLB_LPT_D_S: // Doublet Strip
152  getLPTforDoublet(bitArray, hit, delta, pos);
153 
154  for(int i=0; i<N_LPT_D; ++i) {
155  if(!hit[i]) continue;
156  //create TgcRawData object
157  rCh = new TgcRawData(iBc,
158  subDetectorId, rodId,
159  slb->getSswId(), slb->getSbLoc(),
160  slb->getL1Id(), slb->getBcId(),
161  TgcRawData::SLB_TYPE_DOUBLET_STRIP/*DOUBLET STRIP*/,
162  delta[i],
163  0, i, pos[i]);
164  vChannel.push_back(rCh);
165 
166  if(isFirstHit) {
167  ATH_MSG_DEBUG( "Tgc TgcSlbDataHelper::convertCoincidence :"
168  << " slb type =" << slb->getType() );
169  isFirstHit = false;
170  }
171  ATH_MSG_DEBUG( ((slb->getType()==TgcSlbData::SLB_LPT_D_W) ?
172  "TgcRawData : LPT_D_W " : "TgcRawData : LPT_D_S ")
173  << " BC:" << iBc
174  << " subDetId:" << subDetectorId
175  << " rodId:" << rodId
176  << " sswId:" << slb->getSswId()
177  << " sbLoc:" << slb->getSbLoc()
178  << " slbId:" << slb->getSlbId()
179  << " sub: " << i
180  << " pos:" << pos[i]
181  << " delta:" << delta[i] );
182  } // loop block (i)
183  break;
184 
185  case TgcSlbData::SLB_LPT_T_W: // Triplet Wire
186  getLPTforTripletWire(bitArray, hit, pos);
187  for(int i=0; i<N_LPT_TW; ++i) {
188  if(!hit[i]) continue;
189  delta[i]=0;
190  //create TgcRawData object
191  rCh = new TgcRawData(iBc,
192  subDetectorId, rodId,
193  slb->getSswId(), slb->getSbLoc(),
194  slb->getL1Id(), slb->getBcId(),
195  TgcRawData::SLB_TYPE_TRIPLET_WIRE/*TRIPLET WIRE*/,
196  delta[i],
197  0, i, pos[i]);
198  vChannel.push_back(rCh);
199  if(isFirstHit) {
200  ATH_MSG_DEBUG( "Tgc TgcSlbDataHelper::convertCoincidence :"
201  << " slb type =" << slb->getType() );
202  isFirstHit = false;
203  }
204  ATH_MSG_DEBUG( "TgcRawData : LPT_T_W "
205  << " BC:" << iBc
206  << " subDetId:" << subDetectorId
207  << " rodId:" << rodId
208  << " sswId:" << slb->getSswId()
209  << " sbLoc:" << slb->getSbLoc()
210  << " slbId:" << slb->getSlbId()
211  << " sub: " << i
212  << " pos:" << pos[i] );
213  } // loop block
214  break;
215 
216  case TgcSlbData::SLB_LPT_T_S: // Triplet Strip
217  getLPTforTripletStrip(bitArray, hit, pos);
218  for(int i=0; i<N_LPT_TS; ++i) {
219  if(!hit[i]) continue;
220  delta[i]=0;
221  int seg = 0;
222  int subc =i;
223  if(i>3) {
224  seg = 1;
225  subc = i-4;
226  }
227  //create TgcRawData object
228  rCh = new TgcRawData(iBc,
229  subDetectorId, rodId,
230  slb->getSswId(), slb->getSbLoc(),
231  slb->getL1Id(), slb->getBcId(),
232  TgcRawData::SLB_TYPE_TRIPLET_STRIP/*TRIPLET STRIP*/,
233  delta[i],
234  seg, subc, pos[i]);
235  vChannel.push_back(rCh);
236  if(isFirstHit) {
237  ATH_MSG_DEBUG( "Tgc TgcSlbDataHelper::convertCoincidence :"
238  << " slb type =" << slb->getType() );
239  isFirstHit = false;
240  }
241  ATH_MSG_DEBUG( "TgcRawData : LPT_T_S "
242  << " BC:" << iBc
243  << " subDetId:" << subDetectorId
244  << " rodId:" << rodId
245  << " sswId:" << slb->getSswId()
246  << " sbLoc:" << slb->getSbLoc()
247  << " slbId:" << slb->getSlbId()
248  << " seg: " << seg
249  << " sub: " << subc
250  << " pos:" << pos[i] );
251  } // loop block (i)
252  break;
253 
255  // Since EI/FI Wire and Strip hold one SLB in common,
256  // we cannot use SLB type to distinguish Wire and Strip.
257  case TgcSlbData::SLB_LPT_I_W:
258  case TgcSlbData::SLB_LPT_I_S:
259  getLPTforInner(bitArray, hit);
260  for(int i=0; i<N_LPT_I; ++i) {
261  if(!hit[i]) continue;
262  rCh = new TgcRawData(iBc, // uint16_t bcTag
263  subDetectorId, // uint16_t subDetectorId
264  rodId, // uint16_t rodId
265  slb->getSswId(), // uint16_t sswId
266  slb->getSbLoc(), // uint16_t slbId
267  slb->getL1Id(), // uint16_t l1Id
268  slb->getBcId(), // uint16_t bcId
269  (i<(N_LPT_I/2) ? TgcRawData::SLB_TYPE_INNER_STRIP
270  : TgcRawData::SLB_TYPE_INNER_WIRE), // TgcRawData::SlbType slbType
271  // TRIGA HIT (bits 0..3) is for Strip and TRIGB HIT (bits 4..7) is for Wire
272  // https://twiki.cern.ch/twiki/pub/Main/TgcDocument/celladdress2_asic_rev2.pdf
273  0, // int16_t delta, always for Tracklet Inner
274  static_cast<uint16_t>(i>=(N_LPT_I/2)), // uint16_t seg, wire=1;strip=0
275  i%(N_LPT_I/2), // uint16_t sub, Inner 0..3, TRIG0=sub0, TRIG1=sub1, TRIG2=sub2, TRIG3=sub3
276  // https://twiki.cern.ch/twiki/pub/Main/TgcDocument/celladdress2_asic_rev2.pdf
277  0); // uint16_t rphi, always for Tracklet Inner
278  vChannel.push_back(rCh);
279  if(isFirstHit) {
280  ATH_MSG_DEBUG( "Tgc TgcSlbDataHelper::convertCoincidence :"
281  << " slb type =" << slb->getType() );
282  isFirstHit = false;
283  }
284  ATH_MSG_DEBUG( "TgcRawData : "
285  << (rCh->slbType()==TgcRawData::SLB_TYPE_INNER_STRIP ? "LPT_I_S" : "LPT_I_W")
286  << " BC:" << rCh->bcTag()
287  << " subDetId:" << rCh->subDetectorId()
288  << " rodId:" << rCh->rodId()
289  << " sswId:" << rCh->sswId()
290  << " sbLoc:" << rCh->slbId()
291  << " slbId:" << slb->getSlbId()
292  << " seg: " << rCh->segment()
293  << " sub: " << rCh->subMatrix()
294  << " pos:" << rCh->position() );
295  }
296 
297  break;
298 
299  case TgcSlbData::SLB_SL_F: // Forward Sector Logic
300  case TgcSlbData::SLB_SL_E: // Endcap Sector Logic
301 
302  forward = (slb->getType() == TgcSlbData::SLB_SL_F);
303  sector = getSector(forward, subDetectorId, rodId, slb);
304 
305  // SL Output
306  bool cand3plus;
307  bool hitSL[2];
308  bool muplus[2];
309  uint16_t threshold[2];
310  bool overlap[2];
311  uint16_t roi[2];
312  if(forward) {
313  TgcSlbDataHelper::getSL_F(bitArray, cand3plus,
314  hitSL,
315  muplus, threshold,
316  overlap, roi) ;
317  } else {
318  TgcSlbDataHelper::getSL_E(bitArray, cand3plus,
319  hitSL,
320  muplus, threshold,
321  overlap, roi) ;
322  }
323 
324  for(size_t i=0; i<2; ++i) {
325  if(!hitSL[i]) continue;
326  //create TgcRawData object
327  bool veto[2] = {false};
328  rCh = new TgcRawData(iBc,
329  subDetectorId, rodId,
330  slb->getL1Id(), slb->getBcId(),
331  cand3plus,
332  forward,
333  sector,
334  i,
335  muplus[i],
336  threshold[i],
337  overlap[i],
338  veto[i],
339  roi[i]);
340  vChannel.push_back(rCh);
341  if(isFirstHit) {
342  ATH_MSG_DEBUG( "Tgc TgcSlbDataHelper::convertCoincidence :"
343  << " slb type =" << slb->getType() );
344  isFirstHit = false;
345  }
346  ATH_MSG_DEBUG( "TgcRawData : SL "
347  << " BC:" << iBc
348  << " subDetId:" << subDetectorId
349  << " rodId:" << rodId
350  << " sswId:" << slb->getSswId()
351  << " sbLoc:" << slb->getSbLoc()
352  << " slbId:" << slb->getSlbId()
353  << " roi:" << roi[i]
354  << " pt:" << threshold[i] );
355  } // loop candidate (i)
356 
357  // SL Input = Hpt Output
358  bool hitP[N_HPT_E];
359  bool strip[N_HPT_E];
360  uint16_t chip[N_HPT_E];
361  uint16_t index[N_HPT_E];
362  bool hipt[N_HPT_E];
363  uint16_t hitId[N_HPT_E];
364  uint16_t sub[N_HPT_E];
365  int16_t deltaHPT[N_HPT_E];
366 
367  size_t numberOfHit;
368  if(forward) {
369  numberOfHit = N_HPT_F;
370  TgcSlbDataHelper::getHPT_F(bitArray,
371  hitP, strip,
372  chip, index,
373  hipt, hitId,
374  sub, deltaHPT);
375  } else {
376  numberOfHit = N_HPT_E;
377  TgcSlbDataHelper::getHPT_E(bitArray,
378  hitP, strip,
379  chip, index,
380  hipt, hitId,
381  sub, deltaHPT);
382  }
383 
384  for(size_t i=0; i<numberOfHit; ++i) {
385  if(!hitP[i]) continue;
386 
387  // check HighPT data
388  if(!isValid_HPT(hitP[i], strip[i],
389  chip[i], index[i],
390  hipt[i], hitId[i],
391  sub[i], deltaHPT[i])) {
392  std::string hpt_Type="E";
393  if(forward) hpt_Type ="F";
394  if(strip[i]) hpt_Type+="S";
395  else hpt_Type +="W";
396 
397  if(isFirstHit) {
398  ATH_MSG_DEBUG( "Tgc TgcSlbDataHelper::convertCoincidence :"
399  << " slb type =" << slb->getType() );
400  isFirstHit = false;
401  }
402  ATH_MSG_DEBUG( "invalid HPT data " << hpt_Type
403  << " BC:" << iBc
404  << " subDetId:" << subDetectorId
405  << " rodId:" << rodId
406  << " sswId:" << slb->getSswId()
407  << " sbLoc:" << slb->getSbLoc()
408  << " slbId:" << slb->getSlbId()
409  << std::dec
410  << " chip:" << chip[i]
411  << " index:" << index[i]
412  << " hitId:" << hitId[i]
413  << " delta:" << deltaHPT[i] );
414  continue; // skip making TgcRawData
415  }
416 
417  //create TgcRawData object
418  {
419  uint16_t inner[N_HPT_E] = {0};
420  rCh = new TgcRawData(iBc,
421  subDetectorId, rodId,
422  slb->getL1Id(), slb->getBcId(),
423  strip[i],
424  forward,
425  sector,
426  chip[i],
427  index[i],
428  hipt[i],
429  hitId[i],
430  sub[i],
431  deltaHPT[i],
432  inner[i]);
433  }
434  vChannel.push_back(rCh);
435  if(isFirstHit) {
436  ATH_MSG_DEBUG( "Tgc TgcSlbDataHelper::convertCoincidence :"
437  << " slb type =" << slb->getType() );
438  isFirstHit = false;
439  }
440  auto hptType = [&]() {
441  std::string hptType="E";
442  if(forward) hptType ="F";
443  if(strip[i]) hptType+="S";
444  else hptType +="W";
445  return hptType;
446  };
447  ATH_MSG_DEBUG( "TgcRawData : HPT " << hptType()
448  << " BC:" << iBc
449  << " subDetId:" << subDetectorId
450  << " rodId:" << rodId
451  << " sswId:" << slb->getSswId()
452  << " sbLoc:" << slb->getSbLoc()
453  << " slbId:" << slb->getSlbId()
454  << std::dec
455  << " chip:" << chip[i]
456  << " index:" << index[i]
457  << " hitId:" << hitId[i]
458  << " delta:" << deltaHPT[i] );
459  }
460 
461  break;
462 
463  default:
464  break;
465 
466  } // end switch
467  } // end BCtag loop
468 }

◆ convertToHits()

void Muon::TgcSlbDataHelper::convertToHits ( uint16_t  subDetectorId,
uint16_t  rodId,
const TgcSlbData *  slb,
std::vector< TgcRawData * > &  vChannel 
) const

Convert to Hits.

subDetectorID and ROD ID are dummy.

Definition at line 30 of file TgcSlbDataHelper.cxx.

34 {
35  TgcRawData::SlbType type = TgcRawData::SLB_TYPE_UNKNOWN;
36  if((slb->getType() == TgcSlbData::SLB_SL_F) ||
37  (slb->getType() == TgcSlbData::SLB_SL_E)) {
38  return;
39  } else {
40  if(slb->getType() == TgcSlbData::SLB_LPT_D_W) {
41  type = TgcRawData::SLB_TYPE_DOUBLET_WIRE;
42  } else if(slb->getType() == TgcSlbData::SLB_LPT_D_S) {
43  type = TgcRawData::SLB_TYPE_DOUBLET_STRIP;
44  } else if(slb->getType() == TgcSlbData::SLB_LPT_T_W) {
45  type = TgcRawData::SLB_TYPE_TRIPLET_WIRE;
46  } else if(slb->getType() == TgcSlbData::SLB_LPT_T_S) {
47  type = TgcRawData::SLB_TYPE_TRIPLET_STRIP;
48  } else if(slb->getType() == TgcSlbData::SLB_LPT_I_W ||
49  slb->getType() == TgcSlbData::SLB_LPT_I_S) {
50  type = TgcRawData::SLB_TYPE_INNER_WIRE;
51  // Readout formatted Data use TgcRawData::SLB_TYPE_INNER_WIRE for Inner Strip Hits.
52  // http://cern.ch/atlas-tgc/doc/ROBformat.pdf Table 7 : SB type, bits 15..13
53  // Since EI/FI Wire and Strip hold one SLB in common,
54  // we cannot use SLB type to distinguish Wire and Strip.
55  }
56  }
57 
58  bool isFirstHit = true;
59  for(unsigned int iBc=TgcSlbData::BC_PREVIOUS; iBc<TgcSlbData::N_BC; ++iBc) {
60  const bool * bitArray = slb->getBitArray(iBc);
61 
62  // bit 0..39 is assigned for Trigger Data, ignore
63  const int TRIGGER_DATA_OFFSET=40;
64  for(int ibit=TRIGGER_DATA_OFFSET; ibit<TgcSlbData::BITMAP_SIZE; ++ibit) {
65  if(*(bitArray+ibit)) {
66  // cretae TgcRaw
67  TgcRawData * rCh =
68  new TgcRawData(iBc,
69  subDetectorId, rodId,
70  slb->getSswId(), slb->getSbLoc(),
71  slb->getL1Id(), slb->getBcId(),
72  type,
73  isAdjacent(ibit),
74  0,
75  ibit);
76  vChannel.push_back(rCh);
77 
78  // DEBUG PRINT
79  if(isFirstHit) {
80  ATH_MSG_DEBUG( "Tgc TgcSlbDataHelper::convertToHits :"
81  << " slb type =" << slb->getType() );
82  isFirstHit =false;
83  }
84  ATH_MSG_DEBUG( "TgcRawData : HIT "
85  << " BC:" << iBc
86  << " subDetId:" << subDetectorId
87  << " rodId:" << rodId
88  << " sswId:" << slb->getSswId()
89  << " sbLoc:" << slb->getSbLoc()
90  << " slbId:" << slb->getSlbId()
91  << " bit#:" << ibit );
92  } //endif
93  } // loop ibit
94  } // loop iBC
95 }

◆ getHPT_E()

void Muon::TgcSlbDataHelper::getHPT_E ( const bool *  bitArray,
bool  hit[],
bool  strip[],
uint16_t  chip[],
uint16_t  index[],
bool  hipt[],
uint16_t  hitId[],
uint16_t  sub[],
int16_t  delta[] 
) const
protected

Decode high-pT coincidence information for endcap region from bit array.

Definition at line 980 of file TgcSlbDataHelper.cxx.

989 {
990  int16_t dR;
991  bool sign;
992  size_t ibit;
993  int width;
994  size_t ichip;
995 
996  size_t icand =0;
997 
998  // chip 0 for wire : bit 159 ..152
999  // 1st hit :159-153
1000  // dR<0:3>, Sign, H/L, Pos
1001  ichip = 0;
1002  ibit = 160; // start position
1003 
1004  chip[icand] = ichip;
1005  index[icand] = 0; // only 1 hit in chip 0
1006  strip[icand] = false;
1007 
1008  // dR : bit 159-156
1009  width = 4;
1010  ibit -= width;
1011  dR = getVal(bitArray, ibit, width);
1012  //sign : bit 155
1013  width = 1;
1014  ibit -= width;
1015  sign = *(bitArray+ibit);
1016  // calculate delta with sign
1017  if(sign) {
1018  hit[icand] = true;
1019  delta[icand] = dR;
1020  } else {
1021  if(dR==0) {
1022  hit[icand] = false;
1023  delta[icand] = 0;
1024  } else {
1025  hit[icand] = true;
1026  delta[icand] = -dR;
1027  }
1028  }
1029 
1030  // H/L : bit 154
1031  width = 1;
1032  ibit -= width;
1033  hipt[icand] = *(bitArray + ibit);
1034 
1035  // pos : bit 153
1036  width = 1;
1037  ibit -= width;
1038  pos[icand] = getVal(bitArray, ibit, width);
1039 
1040  // Id
1041  // Id is set to 1
1042  if(hit[icand]) hitId[icand] = 1;
1043 
1044  icand +=1;
1045 
1046  // chip 1, 2, 3 for Wire
1047  // chip 1 : 1st hit :151-142, 2nd hit :141-132
1048  // chip 2 : 1st hit :131-122, 2nd hit :121-112
1049  // chip 3 : 1st hit :111-102, 2nd hit :101- 92
1050  // dR<0:3>, Sign, H/L, Pos, ID<0:2>
1051  ibit = 152; // start position
1052 
1053  for(size_t ichip=1; ichip<=3; ++ichip) {
1054  for(size_t idx = 0; idx <2; ++idx) {
1055  chip[icand] = ichip;
1056  strip[icand] = false;
1057  index[icand] = 1 - idx;
1058  // dR
1059  width = 4;
1060  ibit -= width;
1061  dR = getVal(bitArray, ibit, width);
1062  //sign
1063  width = 1;
1064  ibit -= width;
1065  sign = *(bitArray+ibit);
1066  // calculate delta with sign
1067  if(sign) {
1068  hit[icand] = true;
1069  delta[icand] = dR;
1070  } else {
1071  if(dR==0) {
1072  hit[icand] = false;
1073  delta[icand] = 0;
1074  } else {
1075  hit[icand] = true;
1076  delta[icand] = -dR;
1077  }
1078  }
1079 
1080  // H/L
1081  width = 1;
1082  ibit -= width;
1083  hipt[icand] = *(bitArray + ibit);
1084 
1085  // pos
1086  width = 1;
1087  ibit -= width;
1088  pos[icand] = getVal(bitArray, ibit, width);
1089 
1090  // Id
1091  width = 3;
1092  ibit -=width;
1093  hitId[icand] = getVal(bitArray, ibit, width);
1094 
1095  icand +=1;
1096  }
1097  }
1098 
1099  // chip 0,1 for strip
1100  // chip 0 : 1st hit : 87-79, 2nd hit :78-70
1101  // dPhi<0:2>, Sign, H/L, Pos, ID<0:2>
1102  // chip 1 : 1st hit : 63-56, 2nd hit :55-48
1103  // dPhi<0:2>, Sign, H/L, Pos, ID<0>, ID<2>
1104 
1105  int16_t dPhi;
1106  ibit = 88; // chip0 start position
1107  for(size_t ichip=0; ichip<=1; ++ichip) {
1108  if(ichip==1) ibit = 64; // chip1 start position
1109 
1110  for(size_t idx = 0; idx < 2; ++idx) {
1111  chip[icand] = ichip;
1112  strip[icand] = true;
1113  index[icand] = 1 - idx;
1114 
1115  // dPhi
1116  width = 3;
1117  ibit -= width;
1118  dPhi = getVal(bitArray, ibit, width);
1119  //sign
1120  width = 1;
1121  ibit -= width;
1122  sign = *(bitArray+ibit);
1123  // calculate delta with sign
1124  if(sign) {
1125  hit[icand] = true;
1126  delta[icand] = dPhi;
1127  } else {
1128  if(dPhi==0) {
1129  hit[icand] = false;
1130  delta[icand] = 0;
1131  } else {
1132  hit[icand] = true;
1133  delta[icand] = -dPhi;
1134  }
1135  }
1136 
1137  // H/L
1138  width = 1;
1139  ibit -= width;
1140  hipt[icand] = *(bitArray + ibit);
1141 
1142  // pos
1143  width = 1;
1144  ibit -= width;
1145  pos[icand] = getVal(bitArray, ibit, width);
1146 
1147  // Id
1148  if(ichip==0) {
1149  // chip0
1150  width = 3;
1151  ibit -= width;
1152  hitId[icand] = getVal(bitArray, ibit, width);
1153 
1154  } else {
1155  // chip 1
1156  // 2bit : hitId<1>,hitId<0>
1157  width = 2;
1158  ibit -= width;
1159  hitId[icand] = 0;
1160  if(hit[icand]) {
1161  hitId[icand] = getVal(bitArray, ibit, width);
1162 
1163  // duplicate hit for T5 and T6
1164  // because of bug in strip endcap HPT
1165  chip[icand+1] = ichip;
1166  strip[icand+1] = true;
1167  index[icand+1] = 1 - idx;
1168  hit[icand+1] = true;
1169  delta[icand+1] = delta[icand];
1170  pos[icand+1] = pos[icand];
1171  hitId[icand+1] = hitId[icand] + 4;
1172  hipt[icand+1] = hipt[icand];
1173  } else {
1174  // fill no HIT
1175  chip[icand+1] = ichip;
1176  strip[icand+1] = true;
1177  index[icand+1] = 1 - idx;
1178  hit[icand+1] = false;
1179  delta[icand+1] = 0;
1180  pos[icand+1] = 0;
1181  hitId[icand+1] = 0;
1182  hipt[icand+1] = 0;
1183  }
1184  icand++;
1185  }
1186 
1187  icand += 1;
1188  }
1189  }
1190 
1191 }

◆ getHPT_F()

void Muon::TgcSlbDataHelper::getHPT_F ( const bool *  bitArray,
bool  hit[],
bool  strip[],
uint16_t  chip[],
uint16_t  index[],
bool  hipt[],
uint16_t  hitId[],
uint16_t  sub[],
int16_t  delta[] 
) const
protected

Decode high-pT coincidence information for forward region from bit array.

Definition at line 805 of file TgcSlbDataHelper.cxx.

814 {
815  int16_t dR;
816  bool sign;
817  size_t ibit;
818  int width;
819  size_t ichip;
820 
821  size_t icand =0;
822 
823  // chip 0 for wire : bit 159 ..140
824  // 1st hit :159-150, 2nd hit :149-140
825  // dR<0:3>, Sign, H/L, Pos, ID<0:2>
826  ichip = 0;
827  ibit = 160; // start position
828  for(size_t idx = 0; idx <2; ++idx) {
829  chip[icand] = ichip;
830  strip[icand] = false;
831  index[icand] = 1 - idx;
832  // dR
833  width = 4;
834  ibit -= width;
835  dR = getVal(bitArray, ibit, width);
836  //sign
837  width = 1;
838  ibit -= width;
839  sign = *(bitArray+ibit);
840  // calculate delta with sign
841  if(sign) {
842  hit[icand] = true;
843  delta[icand] = dR;
844  } else {
845  if(dR==0) {
846  hit[icand] = false;
847  delta[icand] = 0;
848  } else {
849  hit[icand] = true;
850  delta[icand] = -dR;
851  }
852  }
853 
854  // H/L
855  width = 1;
856  ibit -= width;
857  hipt[icand] = *(bitArray + ibit);
858 
859  // pos
860  width = 1;
861  ibit -= width;
862  pos[icand] = getVal(bitArray, ibit, width);
863 
864  // Id
865  width = 3;
866  ibit -=width;
867  hitId[icand] = getVal(bitArray, ibit, width);
868 
869  icand +=1;
870  }
871 
872  // chip 1 for wire : bit 135 ..120
873  // 1st hit :135-128, 2nd hit :127-120
874  // dR<0:3>, Sign, H/L, Pos, ID<0>
875  ichip=1;
876  ibit = 136; //start position
877  for(size_t idx = 0; idx <2; ++idx) {
878  chip[icand] = ichip;
879  strip[icand] = false;
880  index[icand] = 1 - idx;
881  // dR
882  width = 4;
883  ibit -= width;
884  dR = getVal(bitArray, ibit, width);
885  //sign
886  width = 1;
887  ibit -= width;
888  sign = *(bitArray+ibit);
889  // calculate delta with sign
890  if(sign) {
891  hit[icand] = true;
892  delta[icand] = dR;
893  } else {
894  if(dR==0) {
895  hit[icand] = false;
896  delta[icand] = 0;
897  } else {
898  hit[icand] = true;
899  delta[icand] = -dR;
900  }
901  }
902 
903  // H/L
904  width = 1;
905  ibit -= width;
906  hipt[icand] = *(bitArray + ibit);
907 
908  // pos
909  width = 1;
910  ibit -= width;
911  pos[icand] = getVal(bitArray, ibit, width);
912 
913  // Id
914  width = 1;
915  ibit -=width;
916  hitId[icand] = getVal(bitArray, ibit, width);
917  if(hitId[icand] == 0 && hit[icand]) hitId[icand] = 2;
918 
919  icand +=1;
920  }
921 
922  // chip 0 for strip : bit 119 ..104
923  // 1st hit :119-113, 2nd hit :111-105
924  // dPhi<0:2>, Sign, H/L, Pos, ID<0>
925  int16_t dPhi;
926  ichip = 0; // chip#0 for strip
927  ibit = 120;
928  for(size_t idx = 0; idx <2; ++idx) {
929  chip[icand] = ichip;
930  strip[icand] = true;
931  index[icand] = 1 - idx;
932 
933  // dPhi
934  width = 3;
935  ibit -= width;
936  dPhi = getVal(bitArray, ibit, width);
937  //sign
938  width = 1;
939  ibit -= width;
940  sign = *(bitArray+ibit);
941  // calculate delta with sign
942  if(sign) {
943  hit[icand] = true;
944  delta[icand] = dPhi;
945  } else {
946  if(dPhi ==0) {
947  hit[icand] = false;
948  delta[icand] = 0;
949  } else {
950  hit[icand] = true;
951  delta[icand] = -dPhi;
952  }
953  }
954 
955  // H/L
956  width = 1;
957  ibit -= width;
958  hipt[icand] = *(bitArray + ibit);
959 
960  // pos
961  width = 1;
962  ibit -= width;
963  pos[icand] = getVal(bitArray, ibit, width);
964 
965  // Id
966  // Only HitId<0> is sent
967  width = 1;
968  ibit -=width;
969  hitId[icand] = getVal(bitArray, ibit, width);
970  if(hitId[icand] == 0 && hit[icand]) hitId[icand] = 2;
971 
972  // dummy bit
973  ibit -= 1;
974 
975  icand += 1;
976  }
977 
978 }

◆ getLPTforDoublet()

void Muon::TgcSlbDataHelper::getLPTforDoublet ( const bool *  bitArray,
bool  hit[],
int  delta[],
int  pos[] 
) const
protected

Decode low-pT coincidence (tracklet) information for doublet from bit array.

Definition at line 562 of file TgcSlbDataHelper.cxx.

566 {
567  // 2 x (10 bits of TRIG data)
568  // 0 PT0 PT1 PT2 SGN PS0 PS1 PS2 PS3 PS4
569 
570  size_t ibit=0;
571  for(int blk=0; blk<N_LPT_D; blk++) {
572  uint32_t binary = getVal(bitArray, ibit, 9);
573  hit[blk] = false;
574  // Delta
575  delta[blk] = binary & 0x07;
576  if(delta[blk]==0) {
577  // check sign
578  if(binary &0x08) hit[blk] = true;
579  } else {
580  hit[blk] = true;
581  if((binary & 0x08)==0) delta[blk] *= -1;
582  }
583  // position
584  if(hit[blk]) {
585  pos[blk] = (binary & 0x1F0) >>4;
586  } else {
587  pos[blk] = 0;
588  }
589  ibit +=10;
590  }
591 }

◆ getLPTforInner()

void Muon::TgcSlbDataHelper::getLPTforInner ( const bool *  bitArray,
bool  hit[] 
) const
protected

Decode low-pT coincidence (tracklet) information for inner from bit array.

Definition at line 654 of file TgcSlbDataHelper.cxx.

656 {
657  // 2 x (4bits of TRIG data)
658  // TRIG3 TRIG2 TRIG1 TRIG0
659  // https://twiki.cern.ch/twiki/pub/Main/TgcDocument/celladdress2_asic_rev2.pdf
660 
661  size_t ibit=0;
662  for(int blk=0; blk<N_LPT_I; blk++) {
663  uint32_t binary= getVal(bitArray, ibit, 1);
664  hit[blk] = (binary & 0x1);
665  ibit += 1;
666  }
667 }

◆ getLPTforTripletStrip()

void Muon::TgcSlbDataHelper::getLPTforTripletStrip ( const bool *  bitArray,
bool  hit[],
int  pos[] 
) const
protected

Decode low-pT coincidence (tracklet) information for triplet strip from bit array.

Definition at line 636 of file TgcSlbDataHelper.cxx.

639 {
640  // 8 x (5bits of TRIG datat)
641  // PS0 PS1 PS2 PS3 HIT
642 
643  size_t ibit=0;
644  for(int blk=0; blk<N_LPT_TS; blk++) {
645  uint32_t binary= getVal(bitArray, ibit, 5);
646  pos[blk] = 0;
647  hit[blk] = ((binary & 0x10) !=0);
648  // position
649  if(hit[blk]) pos[blk] = (binary & 0x0F);
650  ibit += 5;
651  }
652 }

◆ getLPTforTripletWire()

void Muon::TgcSlbDataHelper::getLPTforTripletWire ( const bool *  bitArray,
bool  hit[],
int  pos[] 
) const
protected

Decode low-pT coincidence (tracklet) information for triplet wire from bit array.

Definition at line 593 of file TgcSlbDataHelper.cxx.

596 {
597  // 3 x ( 6/7 bits of TRIG Data )
598  size_t ibit=0;
599  int blk;
600  uint32_t binary;
601 
602  // TRIG0
603  // PS0 PS1 PS2 PS3 PS4 HIT
604  blk=0;
605  binary = getVal(bitArray, ibit, 6);
606  pos[blk] = 0;
607  hit[blk] = ((binary & 0x20)!=0);
608  // position
609  if(hit[blk]) pos[blk] = (binary & 0x1F);
610  ibit += 6;
611 
612  // TRIG1
613  // PS0 PS1 PS2 0 PS3 PS4 HIT
614  blk=1;
615  binary = getVal(bitArray, ibit, 3);
616  pos[blk] = 0;
617  hit[blk] = ((binary & 0x04) !=0);
618  // position
619  if(hit[blk]) pos[blk] = (binary & 0x03)*8;
620  ibit += 4;
621  binary = getVal(bitArray, ibit, 3);
622  if(hit[blk]) pos[blk] += (binary & 0x07);
623  ibit += 3;
624 
625  // TRIG2
626  // PS0 PS1 PS2 PS3 PS4 HIT
627  blk=2;
628  binary = getVal(bitArray, ibit, 6);
629  pos[blk] = 0;
630  hit[blk] = ((binary & 0x20) !=0);
631  // position
632  if(hit[blk]) pos[blk] = (binary & 0x1F);
633 
634 }

◆ getSector()

uint16_t Muon::TgcSlbDataHelper::getSector ( bool  forward,
uint16_t  subDetectorId,
uint16_t  rodId,
const TgcSlbData *  slb 
)
static

Set sector for HpT/SL based on slbId.

Definition at line 547 of file TgcSlbDataHelper.cxx.

551 {
552  uint16_t sector = 0;
553 
554  if(forward) {
555  sector = slb->getSbLoc()-4;
556  } else {
557  sector = slb->getSbLoc();
558  }
559  return sector;
560 }

◆ getSL_E()

void Muon::TgcSlbDataHelper::getSL_E ( const bool *  bitArray,
bool &  cand3plus,
bool  hit[],
bool  muplus[],
uint16_t  pt[],
bool  overlap[],
uint16_t  roi[] 
) const
protected

Decode Sector Logic coincidence information for endcap region from bit array.

Definition at line 737 of file TgcSlbDataHelper.cxx.

744 {
745  // 32bits of TRIG data to MuCTPI
746 
747  size_t ibit;
748  uint32_t binary;
749 
750  // clear results
751  for(size_t icand=0;icand <2 ; icand ++) {
752  hit[icand] = false;
753  muplus[icand] = false;
754  pt[icand] = 7;
755  overlap[icand] = false;
756  roi[icand] = 0;
757  }
758  cand3plus = false;
759 
760  // Morethan2: bit 199
761  cand3plus = (*(bitArray+199));
762 
763  //1st Candidate
764  // PT1<0:2> : bit 180 -178
765  ibit =178;
766  binary = getVal(bitArray, ibit, 3);
767  pt[0] = binary;
768 
769  // check hit or not
770  // NOHIT: pT ==7 or pT==0
771  hit[0] = (binary !=7) && (binary != 0);
772 
773  if(hit[0]) {
774  // Charge1 : bit 169
775  muplus[0] = (*(bitArray + 169));
776 
777  // ROI1<0:7> : bit 198 -191
778  ibit =191;
779  binary = getVal(bitArray, ibit, 8);
780  roi[0] = binary;
781  }
782 
783  // 2nd candidate
784  // PT2<0:2> : bit 177 -175
785  ibit =175;
786  binary = getVal(bitArray, ibit, 3);
787  pt[1] = binary;
788 
789  // check hit or not
790  // NOHIT: pT ==7 or pT==0
791  hit[1] = (binary !=7) && (binary != 0);
792 
793  if(hit[1]) {
794  // Charge2 : bit 168
795  muplus[1] = (*(bitArray + 168));
796 
797  // ROI2<0:7> : bit 189 -182
798  ibit =182;
799  binary = getVal(bitArray, ibit, 8);
800  roi[1] = binary;
801  }
802 
803 }

◆ getSL_F()

void Muon::TgcSlbDataHelper::getSL_F ( const bool *  bitArray,
bool &  cand3plus,
bool  hit[],
bool  muplus[],
uint16_t  pt[],
bool  overlap[],
uint16_t  roi[] 
) const
protected

Decode Sector Logic coincidence information for forward region from bit array.

Definition at line 669 of file TgcSlbDataHelper.cxx.

676 {
677  // 32bits of TRIG data to MuCTPI
678 
679  size_t ibit;
680  uint32_t binary;
681 
682  // clear results
683  for(size_t icand=0;icand <2 ; icand ++) {
684  hit[icand] = false;
685  muplus[icand] = false;
686  pt[icand] = 7;
687  overlap[icand] = false;
688  roi[icand] = 0;
689  }
690  cand3plus = false;
691 
692 
693  // Morethan2: bit 199
694  cand3plus = (*(bitArray+199));
695 
696  //1st Candidate
697  // PT1<0:2> : bit 180 -178
698  ibit =178;
699  binary = getVal(bitArray, ibit, 3);
700  pt[0] = binary;
701 
702  // check hit or not
703  // NOHIT: pT ==7 or pT==0
704  hit[0] = (binary !=7) && (binary != 0);
705 
706  if(hit[0]) {
707  // Charge1 : bit 169
708  muplus[0] = (*(bitArray + 169));
709 
710  // ROI1<0:5> : bit 198 -193
711  ibit = 193;
712  binary = getVal(bitArray, ibit, 6);
713  roi[0] = binary;
714  }
715 
716  // 2nd candidate
717  // PT2<0:2> : bit 177 -175
718  ibit = 175;
719  binary = getVal(bitArray, ibit, 3);
720  pt[1] = binary;
721 
722  // check hit or not
723  // NOHIT: pT ==7 or pT==0
724  hit[1] = (binary !=7) && (binary != 0);
725  if(hit[1]) {
726  // Charge2 : bit 168
727  muplus[1] = (*(bitArray + 168));
728 
729  // ROI2<0:5> : bit 189 -184
730  ibit =184;
731  binary = getVal(bitArray, ibit, 6);
732  roi[1] = binary;
733  }
734 
735 }

◆ getVal()

uint16_t Muon::TgcSlbDataHelper::getVal ( const bool *  bitArray,
std::size_t  start,
std::size_t  width 
)
staticprivate

Get a value in a range of a bitArray.

Definition at line 1221 of file TgcSlbDataHelper.cxx.

1222 {
1223  // utility function to get a value of
1224  // bitArray[ start , start + width -1]
1225  // start : MSB
1226  // start + width -1 : LSB
1227  uint16_t binary=0;
1228  size_t ibit = start+width-1;
1229  for(size_t i= 0; i<width; ++i) {
1230  if(bitArray[ibit]) {
1231  binary += (1<<i);
1232  }
1233  ibit -=1;
1234  }
1235  return binary;
1236 }

◆ 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 }

◆ isAdjacent()

bool Muon::TgcSlbDataHelper::isAdjacent ( int  ibit)
static

Adjacent or not.

Definition at line 534 of file TgcSlbDataHelper.cxx.

535 {
536  bool value=false;
537  value = value || ((ibit<200) && (ibit>193));
538  value = value || ((ibit<162) && (ibit>149));
539  value = value || ((ibit<118) && (ibit>109));
540  value = value || ((ibit<78) && (ibit>73));
541  value = value || ((ibit<42) && (ibit>39));
542 
543  return value;
544 }

◆ isValid_HPT()

bool Muon::TgcSlbDataHelper::isValid_HPT ( bool  hit,
bool  strip,
uint16_t  chip,
uint16_t  index,
bool  hipt,
uint16_t  hitId,
uint16_t  pos,
int16_t  delta 
)
staticprotected

Check if it is valid high-pT coincidence or not.

Definition at line 1194 of file TgcSlbDataHelper.cxx.

1202 {
1203  bool isOK = true;
1204 
1205  // check hitId
1206  if(hit) {
1207  // check hitId
1208  isOK = (hitId !=0) && (hitId !=7);
1209  // check delta
1210  if(!hipt || strip) {
1211  isOK = isOK && (abs(delta)<8);
1212  }
1213  } else {
1214  // check hitId
1215  isOK = (hitId==0);
1216  }
1217 
1218  return isOK;
1219 }

◆ 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 }

◆ operator=()

TgcSlbDataHelper& Muon::TgcSlbDataHelper::operator= ( const TgcSlbDataHelper &  )
delete

◆ 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 }

◆ setType()

bool Muon::TgcSlbDataHelper::setType ( uint16_t  subDetectorId,
uint16_t  rodId,
TgcSlbData *  slb,
int  moduleType 
)
static

Set SLB Type based on sswId and moduleType.

Definition at line 471 of file TgcSlbDataHelper.cxx.

476 {
477  bool ret = true;
478  switch(slb->getSswId()) {
479  case 9: // SL
480  if((slb->getSbLoc() == 4) || (slb->getSbLoc() == 5)) {
481  slb->setType(TgcSlbData::SLB_SL_F);
482  } else {
483  slb->setType(TgcSlbData::SLB_SL_E);
484  }
485  break;
486 
487  case 8: // EI/FI
488  // October 24, 2008, Susumu Oda
489  // This is not correct.
490  // One SLB for EI/FI is shared by EI/FI wire and
491  // EI/FI strip. Wire and strip should be defined
492  // with not sbLoc but bit position. A,B-inputs
493  // are used by strip and C,D-inputs are used by wire.
494  // Since there is no immediate solution and no
495  // necessitiy, I leave the following several lines.
496  if((slb->getSbLoc() == 0) || (slb->getSbLoc() == 2)) {
497  slb->setType(TgcSlbData::SLB_LPT_I_W);
498  } else {
499  slb->setType(TgcSlbData::SLB_LPT_I_S);
500  }
501  break;
502 
503  case 0: // EWT/EST
504  case 1: // EWT/EST
505  case 2: // FWT/FST
506  if(slb->getSbLoc() >=16) {
507  slb->setType(TgcSlbData::SLB_LPT_T_S);
508  } else {
509  slb->setType(TgcSlbData::SLB_LPT_T_W);
510  }
511  break;
512 
513  case 3: // EWD/ESD
514  case 4: // EWD/ESD
515  case 5: // EWD/ESD
516  case 6: // EWD/ESD
517  case 7: // FWD/FSD
518  if(slb->getSbLoc() >=16) {
519  slb->setType(TgcSlbData::SLB_LPT_D_S);
520  } else {
521  slb->setType(TgcSlbData::SLB_LPT_D_W);
522  }
523  break;
524 
525  default:
526  slb->setType(TgcSlbData::SLB_NONE);
527  ret = false;
528  break;
529  }
530  return ret;
531 }

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.

◆ m_imsg

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

MessageSvc pointer.

Definition at line 135 of file AthMessaging.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_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.

The documentation for this class was generated from the following files:
AthMessaging::m_lvl
std::atomic< MSG::Level > m_lvl
Current logging level.
Definition: AthMessaging.h:138
TgcRawData::SLB_TYPE_DOUBLET_STRIP
@ SLB_TYPE_DOUBLET_STRIP
Definition: TgcRawData.h:33
Muon::TgcSlbDataHelper::N_LPT_I
@ N_LPT_I
Definition: TgcSlbDataHelper.h:88
Muon::TgcSlbDataHelper::N_LPT_TW
@ N_LPT_TW
Definition: TgcSlbDataHelper.h:86
Muon::TgcSlbData::BC_PREVIOUS
@ BC_PREVIOUS
Definition: TgcSlbData.h:27
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
index
Definition: index.py:1
Muon::TgcSlbDataHelper::getSL_E
void getSL_E(const bool *bitArray, bool &cand3plus, bool hit[], bool muplus[], uint16_t pt[], bool overlap[], uint16_t roi[]) const
Decode Sector Logic coincidence information for endcap region from bit array.
Definition: TgcSlbDataHelper.cxx:737
Muon::TgcSlbDataHelper::isAdjacent
static bool isAdjacent(int ibit)
Adjacent or not.
Definition: TgcSlbDataHelper.cxx:534
Muon::TgcSlbDataHelper::N_LPT_D
@ N_LPT_D
Definition: TgcSlbDataHelper.h:85
mergePhysValFiles.start
start
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:14
Muon::TgcSlbDataHelper::getVal
static uint16_t getVal(const bool *bitArray, std::size_t start, std::size_t width)
Get a value in a range of a bitArray.
Definition: TgcSlbDataHelper.cxx:1221
Muon::TgcSlbData::BITMAP_SIZE
@ BITMAP_SIZE
Definition: TgcSlbData.h:31
test_pyathena.pt
pt
Definition: test_pyathena.py:11
Muon::TgcSlbData::SLB_SL_F
@ SLB_SL_F
Definition: TgcSlbData.h:42
athena.value
value
Definition: athena.py:124
TgcRawData::subDetectorId
uint16_t subDetectorId() const
Definition: TgcRawData.h:264
Muon::TgcSlbDataHelper::SLB_SD
@ SLB_SD
Definition: TgcSlbDataHelper.h:38
Muon::TgcSlbData::SLB_NONE
@ SLB_NONE
Definition: TgcSlbData.h:44
Muon::TgcSlbDataHelper::SLB_NONE
@ SLB_NONE
Definition: TgcSlbDataHelper.h:42
Muon::TgcSlbDataHelper::SLB_EIFI
@ SLB_EIFI
Definition: TgcSlbDataHelper.h:41
AthMessaging::m_imsg
std::atomic< IMessageSvc * > m_imsg
MessageSvc pointer.
Definition: AthMessaging.h:135
python.SystemOfUnits.ms
int ms
Definition: SystemOfUnits.py:132
xAOD::int16_t
setScaleOne setStatusOne setSaturated int16_t
Definition: gFexGlobalRoI_v1.cxx:55
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition: getMessageSvc.cxx:20
keylayer_zslicemap.strip
strip
Definition: keylayer_zslicemap.py:151
TgcRawData::SLB_TYPE_TRIPLET_WIRE
@ SLB_TYPE_TRIPLET_WIRE
Definition: TgcRawData.h:34
Muon::TgcSlbData::SLB_LPT_D_W
@ SLB_LPT_D_W
Definition: TgcSlbData.h:36
Muon::TgcSlbDataHelper::isValid_HPT
static bool isValid_HPT(bool hit, bool strip, uint16_t chip, uint16_t index, bool hipt, uint16_t hitId, uint16_t pos, int16_t delta)
Check if it is valid high-pT coincidence or not.
Definition: TgcSlbDataHelper.cxx:1194
TgcRawData::rodId
uint16_t rodId() const
Definition: TgcRawData.h:268
TgcRawData::subMatrix
uint16_t subMatrix() const
Definition: TgcRawData.h:329
Muon::TgcSlbDataHelper::getHPT_E
void getHPT_E(const bool *bitArray, bool hit[], bool strip[], uint16_t chip[], uint16_t index[], bool hipt[], uint16_t hitId[], uint16_t sub[], int16_t delta[]) const
Decode high-pT coincidence information for endcap region from bit array.
Definition: TgcSlbDataHelper.cxx:980
Muon::TgcSlbData::SLB_LPT_I_S
@ SLB_LPT_I_S
Definition: TgcSlbData.h:41
AthMessaging::AthMessaging
AthMessaging()
Default constructor:
Muon::TgcSlbData::SLB_LPT_T_S
@ SLB_LPT_T_S
Definition: TgcSlbData.h:39
TrigConf::MSGTC::Level
Level
Definition: Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStream.h:21
xAOD::uint16_t
setWord1 uint16_t
Definition: eFexEMRoI_v1.cxx:88
TgcRawData::SLB_TYPE_UNKNOWN
@ SLB_TYPE_UNKNOWN
Definition: TgcRawData.h:38
lumiFormat.i
int i
Definition: lumiFormat.py:85
Muon::TgcSlbData::SLB_LPT_T_W
@ SLB_LPT_T_W
Definition: TgcSlbData.h:38
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TauGNNUtils::Variables::Track::dPhi
bool dPhi(const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:538
Muon::TgcSlbData::SLB_SL_E
@ SLB_SL_E
Definition: TgcSlbData.h:43
sign
int sign(int a)
Definition: TRT_StrawNeighbourSvc.h:107
Muon::TgcSlbDataHelper::N_LPT_TS
@ N_LPT_TS
Definition: TgcSlbDataHelper.h:87
TgcRawData::sswId
uint16_t sswId() const
Definition: TgcRawData.h:272
AthMessaging::msg
MsgStream & msg() const
The standard message stream.
Definition: AthMessaging.h:164
Muon::TgcSlbData::SLB_LPT_I_W
@ SLB_LPT_I_W
Definition: TgcSlbData.h:40
TgcRawData::position
uint16_t position() const
Definition: TgcRawData.h:313
Muon::TgcSlbDataHelper::N_SL
@ N_SL
Definition: TgcSlbDataHelper.h:91
Muon::TgcSlbDataHelper::SLB_ST
@ SLB_ST
Definition: TgcSlbDataHelper.h:40
Muon::TgcSlbDataHelper::getSector
static uint16_t getSector(bool forward, uint16_t subDetectorId, uint16_t rodId, const TgcSlbData *slb)
Set sector for HpT/SL based on slbId.
Definition: TgcSlbDataHelper.cxx:547
TgcRawData::segment
uint16_t segment() const
Definition: TgcRawData.h:325
Muon::TgcSlbData::N_BC
@ N_BC
Definition: TgcSlbData.h:30
threshold
Definition: chainparser.cxx:74
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
TgcRawData::bcTag
uint16_t bcTag() const
Definition: TgcRawData.h:251
TgcRawData::slbId
uint16_t slbId() const
Definition: TgcRawData.h:276
Muon::TgcSlbData::SLB_LPT_D_S
@ SLB_LPT_D_S
Definition: TgcSlbData.h:37
Muon::TgcSlbDataHelper::getSL_F
void getSL_F(const bool *bitArray, bool &cand3plus, bool hit[], bool muplus[], uint16_t pt[], bool overlap[], uint16_t roi[]) const
Decode Sector Logic coincidence information for forward region from bit array.
Definition: TgcSlbDataHelper.cxx:669
Base_Fragment.width
width
Definition: Sherpa_i/share/common/Base_Fragment.py:59
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
TgcRawData
An unit object of TGC ROD output.
Definition: TgcRawData.h:23
AthMessaging::m_nm
std::string m_nm
Message source name.
Definition: AthMessaging.h:129
TgcRawData::slbType
SlbType slbType() const
Definition: TgcRawData.h:285
TgcRawData::SLB_TYPE_INNER_STRIP
@ SLB_TYPE_INNER_STRIP
Definition: TgcRawData.h:37
Muon::TgcSlbDataHelper::getLPTforDoublet
void getLPTforDoublet(const bool *bitArray, bool hit[], int delta[], int pos[]) const
Decode low-pT coincidence (tracklet) information for doublet from bit array.
Definition: TgcSlbDataHelper.cxx:562
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
Muon::TgcSlbDataHelper::getLPTforTripletWire
void getLPTforTripletWire(const bool *bitArray, bool hit[], int pos[]) const
Decode low-pT coincidence (tracklet) information for triplet wire from bit array.
Definition: TgcSlbDataHelper.cxx:593
Muon::TgcSlbDataHelper::getLPTforTripletStrip
void getLPTforTripletStrip(const bool *bitArray, bool hit[], int pos[]) const
Decode low-pT coincidence (tracklet) information for triplet strip from bit array.
Definition: TgcSlbDataHelper.cxx:636
Muon::TgcSlbDataHelper::N_HPT_E
@ N_HPT_E
Definition: TgcSlbDataHelper.h:90
TgcRawData::SLB_TYPE_INNER_WIRE
@ SLB_TYPE_INNER_WIRE
Definition: TgcRawData.h:36
veto
std::vector< std::string > veto
these patterns are anded
Definition: listroot.cxx:191
TgcRawData
Athena::TPCnvVers::Old Athena::TPCnvVers::Current Athena::TPCnvVers::Old Athena::TPCnvVers::Current Athena::TPCnvVers::Old Athena::TPCnvVers::Current Athena::TPCnvVers::Current Athena::TPCnvVers::Current Athena::TPCnvVers::Current Athena::TPCnvVers::Current TgcRawData
Definition: MuonEventAthenaPoolTPCnv.cxx:168
AthMessaging::initMessaging
void initMessaging() const
Initialize our message level and MessageSvc.
Definition: AthMessaging.cxx:39
Muon::TgcSlbDataHelper::SLB_WT
@ SLB_WT
Definition: TgcSlbDataHelper.h:39
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
TgcRawData::SLB_TYPE_TRIPLET_STRIP
@ SLB_TYPE_TRIPLET_STRIP
Definition: TgcRawData.h:35
Muon::TgcSlbDataHelper::getHPT_F
void getHPT_F(const bool *bitArray, bool hit[], bool strip[], uint16_t chip[], uint16_t index[], bool hipt[], uint16_t hitId[], uint16_t sub[], int16_t delta[]) const
Decode high-pT coincidence information for forward region from bit array.
Definition: TgcSlbDataHelper.cxx:805
Muon::TgcSlbDataHelper::SLB_WD
@ SLB_WD
Definition: TgcSlbDataHelper.h:37
TgcRawData::SLB_TYPE_DOUBLET_WIRE
@ SLB_TYPE_DOUBLET_WIRE
Definition: TgcRawData.h:32
Muon::TgcSlbDataHelper::N_HPT_F
@ N_HPT_F
Definition: TgcSlbDataHelper.h:89
hipt
bool hipt
Definition: globals.cxx:29
Muon::TgcSlbDataHelper::getLPTforInner
void getLPTforInner(const bool *bitArray, bool hit[]) const
Decode low-pT coincidence (tracklet) information for inner from bit array.
Definition: TgcSlbDataHelper.cxx:654
TgcRawData::SlbType
SlbType
Definition: TgcRawData.h:31
Generated on Thu Nov 7 2024 22:21:13 for ATLAS Offline Software by   doxygen 1.8.18