ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Public Attributes | Private Member Functions | Private Attributes | List of all members
Pad Class Reference

#include <Pad.h>

Collaboration diagram for Pad:

Public Member Functions

 Pad (int run, int event, CMAword debug, ubit16 subsys, ubit16 sect, ubit16 padad, ubit16 lowhig, bool oldSimulation, int NOBXS)
 ~Pad ()
void reset ()
void setDefaultConfiguration ()
void setProjectionLogic (ubit16 prologic)
void load (ubit16 lowhig, ubit16 etaphi, ubit16 CMadd, ubit16 BX, ubit16 thres, ubit16 overl)
void execute ()
void display (int flag)
int get_PADID ()
ubit16 getRoI (ubit16 bunch)
ubit16 getPTCoding (ubit16 bunch)
ubit16 getOPL (ubit16 bunch)
ubit16 getOverlapPhi (ubit16 bunch)
ubit16 getOverlapEta (ubit16 bunch)
ubit16 getRoIAmbiguity (ubit16 bunch)
ubit16 getBCIDCounter (ubit16 bunch)
bool isOldSimulation ()
void setOldSimulation (bool value)
void setFeetOn (bool feet)
void setFeetThresholds (unsigned short int ith, unsigned short int th)

Public Attributes

CMAword padDebug

Private Member Functions

void threshold ()
void overlap ()
void makeOut ()
void makeOutEta ()
void makeOutPhi ()
void makeOutEtaAndPhi ()
void makeOutEtaOrPhi ()
void makeFeet ()

Private Attributes

int m_run
int m_event
bool m_oldSimulation
bool m_feet_on
unsigned short int m_feet_thresholds [3]
ubit16 m_nBunMax
ubit16 m_thHitOuterPlane
ubit16 m_hitInOuterPlane [3]
ubit16 m_subsystem
ubit16 m_sector
ubit16 m_padadd
ubit16 m_lowhigh
ubit16 m_projectionLogic
ubit16 m_padIn [2][2][2][8][2]
ubit16 m_padStep2 [8][2][8]
ubit16 m_padOut [8][7]

Detailed Description

Definition at line 10 of file Pad.h.

Constructor & Destructor Documentation

◆ Pad()

Pad::Pad ( int run,
int event,
CMAword debug,
ubit16 subsys,
ubit16 sect,
ubit16 padad,
ubit16 lowhig,
bool oldSimulation,
int NOBXS )

Definition at line 17 of file Pad.cxx.

17 {
18 //
19 // input parameters: run run number
20 // event event number
21 // subsys subsystem address (0=eta<0; 1=eta>0)
22 // sect address of the sector of this pad
23 // padad local address of this pad
24 // lowhig type of pad: lowpt or highpt pad
25 // OldSimulation true means using RPCcablingSim, false for MuonRPC_Cabling (M.Corradi 2/3/2010)
26 //
27 // CMA data are loaded in the PAD with the method "load"
28 //
29 padDebug = debug;
30 // padDebug=0x3f; all debug ON
31
32 const ubit16 df = 0;
33 m_run = run;
34 m_event = event;
35 m_oldSimulation = oldSimulation;
36 m_subsystem = subsys;
37 m_sector = sect;
38 m_padadd = padad;
39 m_lowhigh = lowhig;
40 //
41 m_nBunMax = NOBXS;
42 m_feet_on = false;
43 m_feet_thresholds[0] = 0;
44 m_feet_thresholds[1] = 1;
45 m_feet_thresholds[2] = 2;
46 //
47 if (padDebug & 1 << df) {
48 cout << " ==================== " << endl;
49 cout << " = Pad::Pad = " << endl;
50 cout << " ==================== " << endl;
51 cout << " m_run= " << m_run << " m_event= " << m_event << " padDebug= " << hex << padDebug << dec << endl;
52 cout << " Pad parameters: Subsystem: " << m_subsystem << " Sector: " << m_sector << " Pad address: " << m_padadd
53 << " LowHigh: " << m_lowhigh << " m_oldSimulation: " << m_oldSimulation << endl;
54 } // end-of-if(*(lvl1dbg
55 //
56 reset();
57 setDefaultConfiguration();
58} // end-of-pad::pad
debug
const bool debug
Definition MakeUncertaintyPlots.cxx:53
ubit16
unsigned short int ubit16
Definition RpcByteStreamEncoder.h:20
Pad::m_oldSimulation
bool m_oldSimulation
Definition Pad.h:43
Pad::m_feet_on
bool m_feet_on
Definition Pad.h:44
Pad::m_nBunMax
ubit16 m_nBunMax
Definition Pad.h:52
Pad::setDefaultConfiguration
void setDefaultConfiguration()
Definition Pad.cxx:94
Pad::reset
void reset()
Definition Pad.cxx:65
Pad::m_lowhigh
ubit16 m_lowhigh
Definition Pad.h:68
Pad::m_padadd
ubit16 m_padadd
Definition Pad.h:67
Pad::m_sector
ubit16 m_sector
Definition Pad.h:66
Pad::m_run
int m_run
Definition Pad.h:41
Pad::m_subsystem
ubit16 m_subsystem
Definition Pad.h:65
Pad::m_event
int m_event
Definition Pad.h:42
Pad::m_feet_thresholds
unsigned short int m_feet_thresholds[3]
Definition Pad.h:45
Pad::padDebug
CMAword padDebug
Definition Pad.h:25
PrintTrkAnaSummary.df
df
Printing table to screen.
Definition PrintTrkAnaSummary.py:340
run
int run(int argc, char *argv[])
Definition ttree2hdf5.cxx:28

◆ ~Pad()

Pad::~Pad ( )

Definition at line 60 of file Pad.cxx.

60 {
61 const ubit16 df = 1;
62 if (padDebug & 1 << df) cout << "Distructor of Pad called " << endl;
63} // end-of-Pad::~Pad

Member Function Documentation

◆ display()

void Pad::display ( int flag)

Definition at line 308 of file Pad.cxx.

308 {
309 //
310 // first dump the m_padStep2 registers
311 //
312 ubit16 i, j;
313 char padOutText[7][6];
314 strcpy(padOutText[0], "RoI");
315 strcpy(padOutText[1], "Ptcod");
316 strcpy(padOutText[2], "OPL");
317 strcpy(padOutText[3], "OvPhi");
318 strcpy(padOutText[4], "OvEta");
319 strcpy(padOutText[5], "RoIAm");
320 strcpy(padOutText[6], "BCDcn");
321 if (flag) {
322 cout << endl;
323 cout << " ************************************* " << endl;
324 cout << " * * " << endl;
325 cout << " * P A D D I S P L A Y * " << endl;
326 cout << " * * " << endl;
327 cout << " ************************************* " << endl;
328 cout << endl;
329 cout << " P A R A M E T E R S: " << endl;
330 cout << " Subsystem " << m_subsystem << endl;
331 cout << " Sector " << m_sector << endl;
332 cout << " PAD addr " << m_padadd << endl;
333 cout << " Low-High " << m_lowhigh << endl;
334 cout << "m_oldSimulation:" << m_oldSimulation << endl;
335 cout << " feet_on:" << m_feet_on;
336 if (m_feet_on)
337 cout << " feet_thresholds:" << m_feet_thresholds[0] << "," << m_feet_thresholds[1] << "," << m_feet_thresholds[2] << endl;
338 cout << endl;
339 }
340 if (flag - 1) {
341 cout << " D U M P padStep2 " << endl;
342 cout << " ";
343 cout << "Projection Eta ";
344 cout << " ";
345 cout << "Projection Phi " << endl;
346 cout << " ";
347 cout << "---------------";
348 cout << " ";
349 cout << "---------------" << endl;
350 cout << " ";
351 cout << "C C t a n o O A";
352 cout << " ";
353 cout << "C C t a n o O A" << endl;
354 cout << " ";
355 cout << "M M h d u v P m";
356 cout << " ";
357 cout << "M M h d u v P m" << endl;
358 cout << " ";
359 cout << "0 1 r d m e L b";
360 cout << " ";
361 cout << "0 1 r d m e L b" << endl;
362 cout << " ";
363 cout << " e r r i";
364 cout << " ";
365 cout << " e r r i" << endl;
366 //
367
368 for (j = 0; j < m_nBunMax; j++) {
369 cout << " Bunch Crossing Number " << j << " ";
370 for (i = 0; i < 2; i++) { // Eta-Phi system
371 cout << " " << m_padStep2[j][i][0] << " " << m_padStep2[j][i][1] << " " << m_padStep2[j][i][2] << " " << m_padStep2[j][i][3]
372 << " " << m_padStep2[j][i][4] << " " << m_padStep2[j][i][5] << " " << m_padStep2[j][i][6] << " "
373 << m_padStep2[j][i][7];
374 if (i == 0) cout << " ";
375 } // end-of-for(i
376 cout << endl;
377 } // end-of-for(j
378 cout << endl;
379 } // end-of-if
380 if (flag) {
381 //
382 // dump m_padOut
383 //
384 cout << " D U M P PadOut " << endl;
385 for (i = 0; i < m_nBunMax; i++) {
386 cout << " Pad: padOut Bunch=" << i << ":";
387 for (j = 0; j < 7; j++) { cout << " " << padOutText[j] << " " << m_padOut[i][j]; } // end-of-for(j
388 cout << endl;
389 } // end-of-for(i
390 cout << endl;
391 } // end-of-if(flag
392} // end-of-Pad::display
Pad::m_padStep2
ubit16 m_padStep2[8][2][8]
Definition Pad.h:134
Pad::m_padOut
ubit16 m_padOut[8][7]
Definition Pad.h:156
TauHitVars::j
float j(const xAOD::IParticle &, const xAOD::TrackMeasurementValidation &hit, const Eigen::Matrix3d &jab_inv)
Definition ConstituentLoaderTauHit.cxx:102

◆ execute()

void Pad::execute ( )

Definition at line 142 of file Pad.cxx.

142 {
143 const ubit16 df = 3;
144 if (padDebug & 1 << df) cout << " execute PAD " << endl;
145 if (m_lowhigh) {
146 threshold();
147 overlap();
148 makeOut();
149 if (m_feet_on) makeFeet();
150 if (padDebug & 1 << df) display(0);
151 } // end-of-if(m_lowhigh
152} // end-of-Pad::execute
Pad::display
void display(int flag)
Definition Pad.cxx:308
Pad::makeFeet
void makeFeet()
Definition Pad.cxx:301
Pad::overlap
void overlap()
Definition Pad.cxx:195
Pad::threshold
void threshold()
Definition Pad.cxx:154
Pad::makeOut
void makeOut()
Definition Pad.cxx:210

◆ get_PADID()

int Pad::get_PADID ( )

Definition at line 397 of file Pad.cxx.

397 { // f
398 return m_padadd; // f
399} // f

◆ getBCIDCounter()

ubit16 Pad::getBCIDCounter ( ubit16 bunch)

Definition at line 461 of file Pad.cxx.

461 {
462 ubit16 output = 0;
463 if (bunch < m_nBunMax) {
464 output = m_padOut[bunch][6];
465 } else {
466 cout << " getBCIDCounter; Error: bunch address " << bunch << " not consistent with m_nBunMax= " << m_nBunMax << endl;
467 }
468 return output;
469} // end-of-getBCIDCounter
merge.output
output
Definition merge.py:16

◆ getOPL()

ubit16 Pad::getOPL ( ubit16 bunch)

Definition at line 421 of file Pad.cxx.

421 {
422 ubit16 output = 0;
423 if (bunch < m_nBunMax) {
424 output = m_padOut[bunch][2];
425 } else {
426 cout << " getOPL; Error: bunch address " << bunch << " not consistent with m_nBunMax= " << m_nBunMax << endl;
427 }
428 return output;
429} // end-of-getOPL

◆ getOverlapEta()

ubit16 Pad::getOverlapEta ( ubit16 bunch)

Definition at line 441 of file Pad.cxx.

441 {
442 ubit16 output = 0;
443 if (bunch < m_nBunMax) {
444 output = m_padOut[bunch][4];
445 } else {
446 cout << " getOverlapEta; Error: bunch address " << bunch << " not consistent with m_nBunMax= " << m_nBunMax << endl;
447 }
448 return output;
449} // end-of-getOverlapEta

◆ getOverlapPhi()

ubit16 Pad::getOverlapPhi ( ubit16 bunch)

Definition at line 431 of file Pad.cxx.

431 {
432 ubit16 output = 0;
433 if (bunch < m_nBunMax) {
434 output = m_padOut[bunch][3];
435 } else {
436 cout << " getOverlapPhi; Error: bunch address " << bunch << " not consistent with m_nBunMax= " << m_nBunMax << endl;
437 }
438 return output;
439} // end-of-getOverlapPhi

◆ getPTCoding()

ubit16 Pad::getPTCoding ( ubit16 bunch)

Definition at line 411 of file Pad.cxx.

411 {
412 ubit16 output = 0;
413 if (bunch < m_nBunMax) {
414 output = m_padOut[bunch][1];
415 } else {
416 cout << " getPTCoding; Error: bunch address " << bunch << " not consistent with m_nBunMax= " << m_nBunMax << endl;
417 }
418 return output;
419} // end-of-getPTCoding

◆ getRoI()

ubit16 Pad::getRoI ( ubit16 bunch)

Definition at line 401 of file Pad.cxx.

401 {
402 ubit16 output = 0;
403 if (bunch < m_nBunMax) {
404 output = m_padOut[bunch][0];
405 } else {
406 cout << " getRoI; Error: bunch address " << bunch << " not consistent with m_nBunMax= " << m_nBunMax << endl;
407 }
408 return output;
409} // end-of-getRoI

◆ getRoIAmbiguity()

ubit16 Pad::getRoIAmbiguity ( ubit16 bunch)

Definition at line 451 of file Pad.cxx.

451 {
452 ubit16 output = 0;
453 if (bunch < m_nBunMax) {
454 output = m_padOut[bunch][5];
455 } else {
456 cout << " getRoIAmbiguity; Error: bunch address " << bunch << " not consistent with m_nBunMax= " << m_nBunMax << endl;
457 }
458 return output;
459} // end-of-getRoIAmbiguity

◆ isOldSimulation()

bool Pad::isOldSimulation ( )

Definition at line 471 of file Pad.cxx.

471{ return m_oldSimulation; }

◆ load()

void Pad::load ( ubit16 lowhig,
ubit16 etaphi,
ubit16 CMadd,
ubit16 BX,
ubit16 thres,
ubit16 overl )

Definition at line 122 of file Pad.cxx.

122 {
123 //
124 // input data from Coincidence Matrix:
125 // lowhig = type of Matrix (low/high pt);
126 // etaphi = projection: eta=0, phi=1;
127 // locCMadd= local CM address (0,1)
128 // BX = "address" of this bunch
129 // thresOver= type of data: threshold or overlap
130 // thres = highest threshold
131 // over = overlap
132 //
133 if (lowhig > 1 || etaphi > 1 || locCMadd > 1 || BX >= m_nBunMax) {
134 cout << " Pad::load : lowhig=" << lowhig << " etaphi=" << etaphi << " locCMadd=" << locCMadd << " BX=" << BX << " not valid"
135 << endl;
136 } else {
137 m_padIn[lowhig][etaphi][locCMadd][BX][0] = thres;
138 m_padIn[lowhig][etaphi][locCMadd][BX][1] = overl;
139 } // end-of-if(lowhig
140} // end-of-Pad::load
Pad::m_padIn
ubit16 m_padIn[2][2][2][8][2]
Definition Pad.h:113

◆ makeFeet()

void Pad::makeFeet ( )
private

Definition at line 301 of file Pad.cxx.

301 {
302 ubit16 l;
303 for (l = 0; l < m_nBunMax; l++) {
304 if (m_padOut[l][1] > 0) m_padOut[l][1] = m_feet_thresholds[m_padOut[l][1] - 1] + 1;
305 }
306}
PrintTrkAnaSummary.l
l
Printing final latex table to .tex output file.
Definition PrintTrkAnaSummary.py:370

◆ makeOut()

void Pad::makeOut ( )
private

Definition at line 210 of file Pad.cxx.

210 {
211 // const ubit16 df=6;
212 switch (m_projectionLogic) {
213 case 0: makeOutEta(); break;
214 case 1: makeOutPhi(); break;
215 case 2: makeOutEtaAndPhi(); break;
216 case 3: makeOutEtaOrPhi(); break;
217 default: cout << " Pad: problems with projectionLogic= " << m_projectionLogic << endl;
218 } // end-of-switch
219
220} // end-of-Pad::makeOut()
Pad::makeOutPhi
void makeOutPhi()
Definition Pad.cxx:241
Pad::makeOutEtaAndPhi
void makeOutEtaAndPhi()
Definition Pad.cxx:260
Pad::m_projectionLogic
ubit16 m_projectionLogic
Definition Pad.h:70
Pad::makeOutEtaOrPhi
void makeOutEtaOrPhi()
Definition Pad.cxx:285
Pad::makeOutEta
void makeOutEta()
Definition Pad.cxx:222

◆ makeOutEta()

void Pad::makeOutEta ( )
private

Definition at line 222 of file Pad.cxx.

222 {
223 // const ubit16 df=6;
224 ubit16 l;
225 for (l = 0; l < m_nBunMax; l++) { // loop on Bunches
226 if (m_padStep2[l][0][2]) {
227 // RoI definition
228 if (m_oldSimulation) {
229 m_padOut[l][0] = 2 * m_padStep2[l][0][3];
230 } else {
231 m_padOut[l][0] = m_padStep2[l][0][3];
232 }
233 m_padOut[l][1] = m_padStep2[l][0][2];
234 m_padOut[l][2] = m_padStep2[l][0][6];
235 if (m_padStep2[l][0][5]) m_padOut[l][4] = 1;
236 m_padOut[l][5] = 1;
237 } // end-of-if(m_padStep2[l][0][2]) {
238 } // end-of-for(l
239} // end-of-makeOutEta()

◆ makeOutEtaAndPhi()

void Pad::makeOutEtaAndPhi ( )
private

Definition at line 260 of file Pad.cxx.

260 {
261 // const ubit16 df=6;
262 ubit16 l;
263 for (l = 0; l < m_nBunMax; l++) { // loop on Bunches
264 if (m_padStep2[l][0][2] && m_padStep2[l][1][2]) {
265 // RoI definition
266 if (m_oldSimulation) {
267 m_padOut[l][0] = m_padStep2[l][1][3] + 2 * m_padStep2[l][0][3]; // th
268 } else {
269 m_padOut[l][0] = m_padStep2[l][0][3] + 2 * m_padStep2[l][1][3];
270 }
271 if (m_padStep2[l][0][2] < m_padStep2[l][1][2]) {
272 m_padOut[l][1] = m_padStep2[l][0][2]; // th
273 m_padOut[l][2] = m_padStep2[l][0][6]; // OPL
274 } else {
275 m_padOut[l][1] = m_padStep2[l][1][2];
276 m_padOut[l][2] = m_padStep2[l][1][6];
277 }
278 if (m_padStep2[l][1][5]) m_padOut[l][3] = 1; // ovl phi
279 if (m_padStep2[l][0][5]) m_padOut[l][4] = 1; // ovl eta
280 if (m_padStep2[l][0][7] + m_padStep2[l][1][7] > 2) m_padOut[l][5] = 1; // roi ambiguity
281 } // end-of-if
282 } // end-of-for(l
283} // end-of-Pad::makeOutEtaAndPhi()

◆ makeOutEtaOrPhi()

void Pad::makeOutEtaOrPhi ( )
private

Definition at line 285 of file Pad.cxx.

285 {
286 // const ubit16 df=6;
287 ubit16 l;
288 for (l = 0; l < m_nBunMax; l++) { // loop on Bunches
289 if (m_padStep2[l][0][2] || m_padStep2[l][1][2]) {
290 if (m_padStep2[l][0][2] && !m_padStep2[l][1][2]) {
291 makeOutEta();
292 } else if (m_padStep2[l][1][2] && !m_padStep2[l][0][2]) {
293 makeOutPhi();
294 } else {
295 makeOutEtaAndPhi();
296 } // end-of-if( &&! )
297 } // end-of-if(m_padStep2[l][0][2] || m_padStep2[l][1][2])
298 } // end-of-for(l
299} // end-of-makeOuttaEOrPhi()

◆ makeOutPhi()

void Pad::makeOutPhi ( )
private

Definition at line 241 of file Pad.cxx.

241 {
242 // const ubit16 df=6;
243 ubit16 l;
244 for (l = 0; l < m_nBunMax; l++) { // loop on Bunches
245 if (m_padStep2[l][1][2]) {
246 // RoI definition
247 if (m_oldSimulation) {
248 m_padOut[l][0] = m_padStep2[l][1][3];
249 } else {
250 m_padOut[l][0] = 2 * m_padStep2[l][1][3];
251 }
252 m_padOut[l][1] = m_padStep2[l][1][2];
253 m_padOut[l][2] = m_padStep2[l][1][6];
254 if (m_padStep2[l][1][5]) m_padOut[l][3] = 1;
255 m_padOut[l][5] = 1;
256 } // end-of-if(m_padStep2[l][1][2]) {
257 } // end-of-for(l
258} // end-of-makeOutPhi()

◆ overlap()

void Pad::overlap ( )
private

Definition at line 195 of file Pad.cxx.

195 {
196 // const ubit16 df=5;
197 ubit16 i, j, l;
198 for (l = 0; l < m_nBunMax; l++) { // loop on m_nBunMax bunches
199 for (j = 0; j < 2; j++) { // loop on Low- High-Pt systems
200 for (i = 0; i < 2; i++) { // eta-phi matrix address: eta=0; phi=1
201 // "external" overlapping strips
202 //
203 if (m_padIn[j][i][1][l][1] & 2) m_padStep2[l][i][5] = 1; // c1 ovl_sx
204 if (m_padIn[j][i][0][l][1] & 1) m_padStep2[l][i][5] = 1; // c0 ovl_dx
205 } // end-of-for(i
206 } // end-of-for(j
207 } // end-of-for(l
208} // end-of-Pad::overlap()

◆ reset()

void Pad::reset ( )

Definition at line 65 of file Pad.cxx.

65 {
66 ubit16 i, j, k, l, m;
67
68 //
69 // input to the PAD logic: initialize m_padIn
70 //
71 for (m = 0; m < 2; m++) {
72 for (k = 0; k < 2; k++) { // eta-phi matrix
73 for (j = 0; j < 2; j++) { // matrix local address
74 for (l = 0; l < m_nBunMax; l++) { // loop on NOBXS bunches
75 for (i = 0; i < 2; i++) { // type of input: i=0 => threshold; i=1 => overlap
76 m_padIn[m][k][j][l][i] = 0;
77 } // end-of-for(i
78 } // end-of-for(l
79 } // end-of-for(j
80 } // end-of-for(k
81 } // end-of-for(m
82 //
83 for (l = 0; l < m_nBunMax; l++) {
84 for (k = 0; k < 8; k++) { // reset m_padStep2 data per each bunch crossing
85 m_padStep2[l][0][k] = 0;
86 m_padStep2[l][1][k] = 0;
87 } // end-of-for(k
88 for (k = 0; k < 7; k++) { // reset m_padOut data per each bunch crossing
89 m_padOut[l][k] = 0;
90 } // end-of-for(k
91 } // end-of-for(l
92} // end-of-Pad::reset

◆ setDefaultConfiguration()

void Pad::setDefaultConfiguration ( )

Definition at line 94 of file Pad.cxx.

94 {
95 const ubit16 df = 2;
96 m_projectionLogic = 2;
97 //
98 // load "hitOuterPlane"
99 //
100 m_thHitOuterPlane = 0;
101 // put this in m_hitInOuterPlane
102 m_hitInOuterPlane[0] = 0;
103 m_hitInOuterPlane[1] = 0;
104 m_hitInOuterPlane[2] = 0;
105 if (m_thHitOuterPlane) m_hitInOuterPlane[m_thHitOuterPlane - 1] = 1;
106 if (padDebug & 1 << df) {
107 cout << " Pad: m_hitInOuterPlane= " << m_hitInOuterPlane[0] << " " << m_hitInOuterPlane[1] << " " << m_hitInOuterPlane[2] << " "
108 << endl;
109 cout << " Pad: projectionLogic= " << m_projectionLogic << endl;
110 } // end-of-if(padDebug&1<<df)
111} // end-of-Pad::setDefaultConfiguration
Pad::m_hitInOuterPlane
ubit16 m_hitInOuterPlane[3]
Definition Pad.h:59
Pad::m_thHitOuterPlane
ubit16 m_thHitOuterPlane
Definition Pad.h:53

◆ setFeetOn()

void Pad::setFeetOn ( bool feet)
inline

Definition at line 37 of file Pad.h.

37{ m_feet_on = feet; };

◆ setFeetThresholds()

void Pad::setFeetThresholds ( unsigned short int ith,
unsigned short int th )
inline

Definition at line 38 of file Pad.h.

38{ m_feet_thresholds[ith] = th; };

◆ setOldSimulation()

void Pad::setOldSimulation ( bool value)

Definition at line 474 of file Pad.cxx.

474{ m_oldSimulation = value; }

◆ setProjectionLogic()

void Pad::setProjectionLogic ( ubit16 prologic)

Definition at line 113 of file Pad.cxx.

113 {
114 if (prologic < 4) {
115 m_projectionLogic = prologic;
116 } else {
117 cout << " Pad.setProjectionLogic; prologic= " << prologic << " not allowed; default value " << m_projectionLogic << " is retained "
118 << endl;
119 } // end-of-if
120} // end-of- Pad::setProjectionLogic(ubit16 prologic)

◆ threshold()

void Pad::threshold ( )
private

Definition at line 154 of file Pad.cxx.

154 {
155 const ubit16 df = 4;
156 //
157 // reminder: m_padIn[m][i][j][k][l] is 0 no trigger
158 // 1,2,3
159 //
160 ubit16 i, j, l, m;
161 ubit16 thisThreshold;
162 for (m = 0; m < 2; m++) { // Low- High-Pt
163 for (j = 0; j < 2; j++) { // eta-phi matrix address
164 for (i = 0; i < 2; i++) { // local matrix address
165 for (l = 0; l < m_nBunMax; l++) { // loop on m_nBunMax bunches
166 if (m_padIn[m][j][i][l][0]) {
167 if (m && m_hitInOuterPlane[m_padIn[m][j][i][l][0] - 1]) {
168 m_padStep2[l][i][6] = 1;
169 } else {
170 // define absolute threshold
171 thisThreshold = 3 * m + m_padIn[m][j][i][l][0];
172 // find highest threshold
173 if (thisThreshold > m_padStep2[l][j][i]) {
174 if (m_padStep2[l][j][i] == 0) m_padStep2[l][j][7]++; // num of RoI with threshold
175 m_padStep2[l][j][i] = thisThreshold;
176 } // end-of-if
177 // if( !j && (thisThreshold > m_padStep2[l][j][2]) ) {
178 if (thisThreshold > m_padStep2[l][j][2]) {
179 m_padStep2[l][j][2] = thisThreshold; // highest threshold
180 m_padStep2[l][j][3] = i; // CM with the highest thres.
181 if (padDebug & 1 << df) {
182 cout << " Pad::threshold; padStep2 eta-phi " << j << " localAdd " << i << " Bunch " << l
183 << " threshold " << m_padStep2[l][j][2] << endl;
184 } // end-of-if(padDebug&1<<df)
185 } // end-of-if(m_padStep2
186 m_padStep2[l][j][4]++; // number of CMs with thresh.
187 } // end-of-if( m && m_hitInOuterPlane
188 } // end-of-if(m_padIn
189 } // end-of-for(l
190 } // end-of-for(i
191 } // end-of-for(j
192 } // end-of-for(m
193} // end-of-Pad::threshold

Member Data Documentation

◆ m_event

int Pad::m_event
private

Definition at line 42 of file Pad.h.

◆ m_feet_on

bool Pad::m_feet_on
private

Definition at line 44 of file Pad.h.

◆ m_feet_thresholds

unsigned short int Pad::m_feet_thresholds[3]
private

Definition at line 45 of file Pad.h.

◆ m_hitInOuterPlane

ubit16 Pad::m_hitInOuterPlane[3]
private

Definition at line 59 of file Pad.h.

◆ m_lowhigh

ubit16 Pad::m_lowhigh
private

Definition at line 68 of file Pad.h.

◆ m_nBunMax

ubit16 Pad::m_nBunMax
private

Definition at line 52 of file Pad.h.

◆ m_oldSimulation

bool Pad::m_oldSimulation
private

Definition at line 43 of file Pad.h.

◆ m_padadd

ubit16 Pad::m_padadd
private

Definition at line 67 of file Pad.h.

◆ m_padIn

ubit16 Pad::m_padIn[2][2][2][8][2]
private

Definition at line 113 of file Pad.h.

◆ m_padOut

ubit16 Pad::m_padOut[8][7]
private

Definition at line 156 of file Pad.h.

◆ m_padStep2

ubit16 Pad::m_padStep2[8][2][8]
private

Definition at line 134 of file Pad.h.

◆ m_projectionLogic

ubit16 Pad::m_projectionLogic
private

Definition at line 70 of file Pad.h.

◆ m_run

int Pad::m_run
private

Definition at line 41 of file Pad.h.

◆ m_sector

ubit16 Pad::m_sector
private

Definition at line 66 of file Pad.h.

◆ m_subsystem

ubit16 Pad::m_subsystem
private

Definition at line 65 of file Pad.h.

◆ m_thHitOuterPlane

ubit16 Pad::m_thHitOuterPlane
private

Definition at line 53 of file Pad.h.

◆ padDebug

CMAword Pad::padDebug

Definition at line 25 of file Pad.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0