ATLAS Offline Software
Loading...
Searching...
No Matches
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

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

#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.
virtual ~TgcSlbDataHelper (void)
 Destructor.
 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.
void convertToCoincidences (uint16_t subDetectorId, uint16_t rodId, const TgcSlbData *slb, std::vector< TgcRawData * > &vChannel) const
 Convert to coincidences.
bool msgLvl (const MSG::Level lvl) const
 Test the output level.
MsgStream & msg () const
 The standard message stream.
MsgStream & msg (const MSG::Level lvl) const
 The standard message stream.
void setLevel (MSG::Level lvl)
 Change the current logging level.

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.
static bool isAdjacent (int ibit)
 Adjacent or not.
static uint16_t getSector (bool forward, uint16_t subDetectorId, uint16_t rodId, const TgcSlbData *slb)
 Set sector for HpT/SL based on slbId.

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.
void getLPTforTripletWire (const bool *bitArray, bool hit[], int pos[]) const
 Decode low-pT coincidence (tracklet) information for triplet wire from bit array.
void getLPTforTripletStrip (const bool *bitArray, bool hit[], int pos[]) const
 Decode low-pT coincidence (tracklet) information for triplet strip from bit array.
void getLPTforInner (const bool *bitArray, bool hit[]) const
 Decode low-pT coincidence (tracklet) information for inner from bit array.
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.
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.
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.
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.

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.

Private Member Functions

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

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.

Private Attributes

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

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}
AthMessaging::AthMessaging
AthMessaging()
Default constructor:

◆ ~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}
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
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
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
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
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::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::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
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::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::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::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
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
TgcRawData::sswId
uint16_t sswId() const
Definition TgcRawData.h:272
TgcRawData::SLB_TYPE_TRIPLET_WIRE
@ SLB_TYPE_TRIPLET_WIRE
Definition TgcRawData.h:34
TgcRawData::SLB_TYPE_INNER_WIRE
@ SLB_TYPE_INNER_WIRE
Definition TgcRawData.h:36
TgcRawData::SLB_TYPE_TRIPLET_STRIP
@ SLB_TYPE_TRIPLET_STRIP
Definition TgcRawData.h:35
TgcRawData::SLB_TYPE_INNER_STRIP
@ SLB_TYPE_INNER_STRIP
Definition TgcRawData.h:37
TgcRawData::SLB_TYPE_DOUBLET_STRIP
@ SLB_TYPE_DOUBLET_STRIP
Definition TgcRawData.h:33
TgcRawData::SLB_TYPE_DOUBLET_WIRE
@ SLB_TYPE_DOUBLET_WIRE
Definition TgcRawData.h:32
TgcRawData::position
uint16_t position() const
Definition TgcRawData.h:313
TgcRawData::subMatrix
uint16_t subMatrix() const
Definition TgcRawData.h:329
TgcRawData::slbType
SlbType slbType() const
Definition TgcRawData.h:285
TgcRawData::segment
uint16_t segment() const
Definition TgcRawData.h:325
TgcRawData::bcTag
uint16_t bcTag() const
Definition TgcRawData.h:251
TgcRawData::subDetectorId
uint16_t subDetectorId() const
Definition TgcRawData.h:264
TgcRawData::slbId
uint16_t slbId() const
Definition TgcRawData.h:276
TgcRawData::rodId
uint16_t rodId() const
Definition TgcRawData.h:268
hipt
bool hipt
Definition globals.cxx:29
veto
std::vector< std::string > veto
these patterns are anded
Definition listroot.cxx:191
DeMoScan.index
str index
Definition DeMoScan.py:362
xAOD::int16_t
setScaleOne setStatusOne setSaturated int16_t
Definition gFexGlobalRoI_v1.cxx:55
xAOD::uint16_t
setWord1 uint16_t
Definition eFexEMRoI_v1.cxx:93

◆ 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}
Muon::TgcSlbDataHelper::isAdjacent
static bool isAdjacent(int ibit)
Adjacent or not.
Definition TgcSlbDataHelper.cxx:534
TgcRawData::SLB_TYPE_UNKNOWN
@ SLB_TYPE_UNKNOWN
Definition TgcRawData.h:38

◆ 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}
sign
int sign(int a)
Definition TRT_StrawNeighbourSvc.h:108
width
const double width
Definition TTileTripReader.cxx:24
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
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition LArNewCalib_DelayDump_OFC_Cali.py:69
TauClusterVars::dPhi
bool dPhi(const xAOD::TauJet &tau, const xAOD::CaloVertexedTopoCluster &cluster, float &out)
Definition ConstituentLoaderTauCluster.cxx:119

◆ 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}
xAOD::uint32_t
setEventNumber uint32_t
Definition EventInfo_v1.cxx:127

◆ 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}
test_pyathena.pt
pt
Definition test_pyathena.py:11

◆ 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 // If user did not set an explicit level, set a default
43 if (m_lvl == MSG::NIL) {
44 m_lvl = m_imsg ?
45 static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
46 MSG::INFO;
47 }
48}
AthMessaging::m_nm
std::string m_nm
Message source name.
Definition AthMessaging.h:129
AthMessaging::m_imsg
std::atomic< IMessageSvc * > m_imsg
MessageSvc pointer.
Definition AthMessaging.h:135
AthMessaging::m_lvl
std::atomic< MSG::Level > m_lvl
Current logging level.
Definition AthMessaging.h:138
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition getMessageSvc.cxx:20

◆ 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 163 of file AthMessaging.h.

164{
165 MsgStream* ms = m_msg_tls.get();
166 if (!ms) {
167 if (!m_initialized.test_and_set()) initMessaging();
168 ms = new MsgStream(m_imsg,m_nm);
169 m_msg_tls.reset( ms );
170 }
171
172 ms->setLevel (m_lvl);
173 return *ms;
174}
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
AthMessaging::initMessaging
void initMessaging() const
Initialize our message level and MessageSvc.
Definition AthMessaging.cxx:39

◆ 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 178 of file AthMessaging.h.

179{ return msg() << lvl; }
AthMessaging::msg
MsgStream & msg() const
The standard message stream.
Definition AthMessaging.h:163

◆ 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_lvl <= lvl) {
154 msg() << lvl;
155 return true;
156 } else {
157 return false;
158 }
159}

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

135{ nullptr };

◆ m_lvl

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

Current logging level.

Definition at line 138 of file AthMessaging.h.

138{ MSG::NIL };

◆ 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:
Generated on for ATLAS Offline Software by doxygen 1.14.0