ATLAS Offline Software
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 16 of file Pad.cxx.

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

◆ ~Pad()

Pad::~Pad ( )

Definition at line 59 of file Pad.cxx.

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

Member Function Documentation

◆ display()

void Pad::display ( int  flag)

Definition at line 307 of file Pad.cxx.

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

◆ execute()

void Pad::execute ( )

Definition at line 141 of file Pad.cxx.

141  {
142  const ubit16 df = 3;
143  if (padDebug & 1 << df) cout << " execute PAD " << endl;
144  if (m_lowhigh) {
145  threshold();
146  overlap();
147  makeOut();
148  if (m_feet_on) makeFeet();
149  if (padDebug & 1 << df) display(0);
150  } // end-of-if(m_lowhigh
151 } // end-of-Pad::execute

◆ get_PADID()

int Pad::get_PADID ( )

Definition at line 396 of file Pad.cxx.

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

◆ getBCIDCounter()

ubit16 Pad::getBCIDCounter ( ubit16  bunch)

Definition at line 460 of file Pad.cxx.

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

◆ getOPL()

ubit16 Pad::getOPL ( ubit16  bunch)

Definition at line 420 of file Pad.cxx.

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

◆ getOverlapEta()

ubit16 Pad::getOverlapEta ( ubit16  bunch)

Definition at line 440 of file Pad.cxx.

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

◆ getOverlapPhi()

ubit16 Pad::getOverlapPhi ( ubit16  bunch)

Definition at line 430 of file Pad.cxx.

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

◆ getPTCoding()

ubit16 Pad::getPTCoding ( ubit16  bunch)

Definition at line 410 of file Pad.cxx.

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

◆ getRoI()

ubit16 Pad::getRoI ( ubit16  bunch)

Definition at line 400 of file Pad.cxx.

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

◆ getRoIAmbiguity()

ubit16 Pad::getRoIAmbiguity ( ubit16  bunch)

Definition at line 450 of file Pad.cxx.

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

◆ isOldSimulation()

bool Pad::isOldSimulation ( )

Definition at line 470 of file Pad.cxx.

470 { return m_oldSimulation; }

◆ load()

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

Definition at line 121 of file Pad.cxx.

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

◆ makeFeet()

void Pad::makeFeet ( )
private

Definition at line 300 of file Pad.cxx.

300  {
301  ubit16 l;
302  for (l = 0; l < m_nBunMax; l++) {
303  if (m_padOut[l][1] > 0) m_padOut[l][1] = m_feet_thresholds[m_padOut[l][1] - 1] + 1;
304  }
305 }

◆ makeOut()

void Pad::makeOut ( )
private

Definition at line 209 of file Pad.cxx.

209  {
210  // const ubit16 df=6;
211  switch (m_projectionLogic) {
212  case 0: makeOutEta(); break;
213  case 1: makeOutPhi(); break;
214  case 2: makeOutEtaAndPhi(); break;
215  case 3: makeOutEtaOrPhi(); break;
216  default: cout << " Pad: problems with projectionLogic= " << m_projectionLogic << endl;
217  } // end-of-switch
218 
219 } // end-of-Pad::makeOut()

◆ makeOutEta()

void Pad::makeOutEta ( )
private

Definition at line 221 of file Pad.cxx.

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

◆ makeOutEtaAndPhi()

void Pad::makeOutEtaAndPhi ( )
private

Definition at line 259 of file Pad.cxx.

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

◆ makeOutEtaOrPhi()

void Pad::makeOutEtaOrPhi ( )
private

Definition at line 284 of file Pad.cxx.

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

◆ makeOutPhi()

void Pad::makeOutPhi ( )
private

Definition at line 240 of file Pad.cxx.

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

◆ overlap()

void Pad::overlap ( )
private

Definition at line 194 of file Pad.cxx.

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

◆ reset()

void Pad::reset ( )

Definition at line 64 of file Pad.cxx.

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

◆ setDefaultConfiguration()

void Pad::setDefaultConfiguration ( )

Definition at line 93 of file Pad.cxx.

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

◆ 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 473 of file Pad.cxx.

473 { m_oldSimulation = value; }

◆ setProjectionLogic()

void Pad::setProjectionLogic ( ubit16  prologic)

Definition at line 112 of file Pad.cxx.

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

◆ threshold()

void Pad::threshold ( )
private

Definition at line 153 of file Pad.cxx.

153  {
154  const ubit16 df = 4;
155  //
156  // reminder: m_padIn[m][i][j][k][l] is 0 no trigger
157  // 1,2,3
158  //
159  ubit16 i, j, l, m;
160  ubit16 thisThreshold;
161  for (m = 0; m < 2; m++) { // Low- High-Pt
162  for (j = 0; j < 2; j++) { // eta-phi matrix address
163  for (i = 0; i < 2; i++) { // local matrix address
164  for (l = 0; l < m_nBunMax; l++) { // loop on m_nBunMax bunches
165  if (m_padIn[m][j][i][l][0]) {
166  if (m && m_hitInOuterPlane[m_padIn[m][j][i][l][0] - 1]) {
167  m_padStep2[l][i][6] = 1;
168  } else {
169  // define absolute threshold
170  thisThreshold = 3 * m + m_padIn[m][j][i][l][0];
171  // find highest threshold
172  if (thisThreshold > m_padStep2[l][j][i]) {
173  if (m_padStep2[l][j][i] == 0) m_padStep2[l][j][7]++; // num of RoI with threshold
174  m_padStep2[l][j][i] = thisThreshold;
175  } // end-of-if
176  // if( !j && (thisThreshold > m_padStep2[l][j][2]) ) {
177  if (thisThreshold > m_padStep2[l][j][2]) {
178  m_padStep2[l][j][2] = thisThreshold; // highest threshold
179  m_padStep2[l][j][3] = i; // CM with the highest thres.
180  if (padDebug & 1 << df) {
181  cout << " Pad::threshold; padStep2 eta-phi " << j << " localAdd " << i << " Bunch " << l
182  << " threshold " << m_padStep2[l][j][2] << endl;
183  } // end-of-if(padDebug&1<<df)
184  } // end-of-if(m_padStep2
185  m_padStep2[l][j][4]++; // number of CMs with thresh.
186  } // end-of-if( m && m_hitInOuterPlane
187  } // end-of-if(m_padIn
188  } // end-of-for(l
189  } // end-of-for(i
190  } // end-of-for(j
191  } // end-of-for(m
192 } // 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:
Pad::m_nBunMax
ubit16 m_nBunMax
Definition: Pad.h:52
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
Pad::m_run
int m_run
Definition: Pad.h:38
Pad::m_oldSimulation
bool m_oldSimulation
Definition: Pad.h:43
Pad::m_projectionLogic
ubit16 m_projectionLogic
Definition: Pad.h:70
run
int run(int argc, char *argv[])
Definition: ttree2hdf5.cxx:28
Pad::setDefaultConfiguration
void setDefaultConfiguration()
Definition: Pad.cxx:93
athena.value
value
Definition: athena.py:124
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
Pad::m_lowhigh
ubit16 m_lowhigh
Definition: Pad.h:68
Pad::makeOutPhi
void makeOutPhi()
Definition: Pad.cxx:240
Pad::makeOut
void makeOut()
Definition: Pad.cxx:209
Pad::threshold
void threshold()
Definition: Pad.cxx:153
Pad::makeOutEtaOrPhi
void makeOutEtaOrPhi()
Definition: Pad.cxx:284
Pad::m_hitInOuterPlane
ubit16 m_hitInOuterPlane[3]
Definition: Pad.h:59
Pad::m_feet_on
bool m_feet_on
Definition: Pad.h:44
python.TriggerHandler.th
th
Definition: TriggerHandler.py:296
Pad::display
void display(int flag)
Definition: Pad.cxx:307
event
POOL::TEvent event(POOL::TEvent::kClassAccess)
lumiFormat.i
int i
Definition: lumiFormat.py:85
Pad::makeOutEtaAndPhi
void makeOutEtaAndPhi()
Definition: Pad.cxx:259
Pad::m_padIn
ubit16 m_padIn[2][2][2][8][2]
Definition: Pad.h:113
Pad::m_thHitOuterPlane
ubit16 m_thHitOuterPlane
Definition: Pad.h:53
master.flag
bool flag
Definition: master.py:29
Pad::m_subsystem
ubit16 m_subsystem
Definition: Pad.h:65
merge.output
output
Definition: merge.py:17
Pad::m_event
int m_event
Definition: Pad.h:42
debug
const bool debug
Definition: MakeUncertaintyPlots.cxx:53
Pad::m_padadd
ubit16 m_padadd
Definition: Pad.h:67
Pad::reset
void reset()
Definition: Pad.cxx:64
Pad::m_feet_thresholds
unsigned short int m_feet_thresholds[3]
Definition: Pad.h:45
Pad::padDebug
CMAword padDebug
Definition: Pad.h:25
Pad::m_sector
ubit16 m_sector
Definition: Pad.h:66
Pad::m_padOut
ubit16 m_padOut[8][7]
Definition: Pad.h:156
ubit16
unsigned short int ubit16
Definition: RpcByteStreamEncoder.h:20
Pad::overlap
void overlap()
Definition: Pad.cxx:194
Pad::makeFeet
void makeFeet()
Definition: Pad.cxx:300
Pad::m_padStep2
ubit16 m_padStep2[8][2][8]
Definition: Pad.h:134
Pad::makeOutEta
void makeOutEta()
Definition: Pad.cxx:221
python.TriggerAPI.TriggerAPISession.df
df
Definition: TriggerAPISession.py:432
fitman.k
k
Definition: fitman.py:528
Generated on Sun Dec 22 2024 21:41:48 for ATLAS Offline Software by   doxygen 1.8.18