]>
Commit | Line | Data |
---|---|---|
48265b32 | 1 | /************************************************************************** |
2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
3 | * * | |
4 | * Author: The ALICE Off-line Project. * | |
5 | * Contributors are mentioned in the code where appropriate. * | |
6 | * * | |
7 | * Permission to use, copy, modify and distribute this software and its * | |
8 | * documentation strictly for non-commercial purposes is hereby granted * | |
9 | * without fee, provided that the above copyright notice appears in all * | |
10 | * copies and that both the copyright notice and this permission notice * | |
11 | * appear in the supporting documentation. The authors make no claims * | |
12 | * about the suitability of this software for any purpose. It is * | |
13 | * provided "as is" without express or implied warranty. * | |
14 | **************************************************************************/ | |
15 | ||
16 | /* | |
17 | $Log$ | |
fb3305d1 | 18 | Revision 1.2 2007/10/12 13:36:27 cvetan |
19 | Coding convention fixes from Stefan | |
20 | ||
ca7b8371 | 21 | Revision 1.1 2007/09/17 10:23:31 cvetan |
22 | New TPC monitoring package from Stefan Kniege. The monitoring package can be started by running TPCMonitor.C macro located in macros folder. | |
23 | ||
48265b32 | 24 | */ |
25 | ||
ca7b8371 | 26 | //////////////////////////////////////////////////////////////////////// |
fb3305d1 | 27 | //// |
28 | //// AliTPCMonitorMappingHandler class | |
29 | //// | |
30 | //// Class for handling mapping information TPC | |
31 | //// | |
32 | //// The mapping information for the TPC front end electornics (pads, front end cards) | |
33 | //// are handled by this class. | |
34 | //// The information from the design mapping and from the hardware address can be | |
35 | //// cross checked in the TPCMonitor.C. | |
36 | //// Malfunctioning front end cards can be identified by looking at single channels | |
37 | //// displayed with the TPCMonitor. | |
38 | //// | |
39 | //// | |
40 | //// Authors: Roland Bramm, | |
41 | //// Stefan Kniege, IKF, Frankfurt | |
42 | //// | |
ca7b8371 | 43 | ///////////////////////////////////////////////////////////////////////// |
44 | ||
45 | ||
48265b32 | 46 | #include "AliTPCMonitorMappingHandler.h" |
ca7b8371 | 47 | #include "TH1.h" |
48 | #include "TLegend.h" | |
49 | #include "AliLog.h" | |
50 | #include <Riostream.h> | |
51 | ||
48265b32 | 52 | ClassImp(AliTPCMonitorMappingHandler) |
53 | ||
54 | //_____________________________________________________________________________________________ | |
ca7b8371 | 55 | AliTPCMonitorMappingHandler::AliTPCMonitorMappingHandler(Char_t* name, Char_t* title): |
56 | TNamed(name,title), | |
57 | fnumofChannels(0), | |
58 | fmaxHWAdress(0), | |
59 | fsizeofArray(0), | |
60 | fmapping(new Short_t*[24000]), | |
61 | fmappingChannelinRow(new Int_t*[160]), | |
62 | fu2ftestmapping(new Short_t*[7000]), | |
63 | fMapHwFECglobal(new Int_t*[24000]), | |
64 | fecGainMap(new Float_t*[7000]) | |
48265b32 | 65 | { |
66 | // Constructor : Initialize mapping arrays | |
67 | ||
48265b32 | 68 | for(Int_t in = 0; in<160; in++) |
69 | { | |
70 | Int_t* hold = new Int_t[150]; | |
71 | for(Int_t jn = 0; jn<150;jn++) hold[jn]=0; | |
72 | fmappingChannelinRow[in]= hold; | |
73 | } | |
74 | ||
48265b32 | 75 | for(Int_t i = 0; i<7000; i++) |
76 | { | |
77 | Short_t* hold = new Short_t[8]; | |
78 | for(Int_t j = 0; j<8;j++) hold[j]=0; | |
79 | fu2ftestmapping[i]= hold; | |
80 | } | |
ca7b8371 | 81 | |
48265b32 | 82 | for(Int_t i = 0; i<24000; i++) |
83 | { | |
84 | Int_t* hold = new Int_t[2]; | |
85 | for(Int_t j = 0; j<2;j++) hold[j]=0; | |
86 | fMapHwFECglobal[i]= hold; | |
87 | } | |
88 | ||
ca7b8371 | 89 | |
48265b32 | 90 | for(Int_t i = 0; i<7000; i++) |
91 | { | |
92 | Float_t* hold = new Float_t[128]; | |
93 | for(Int_t j = 0; j<128;j++) hold[j]=0; | |
94 | fecGainMap[i]= hold; | |
95 | } | |
96 | } | |
97 | ||
ca7b8371 | 98 | //____________________________________________________________________________ |
99 | AliTPCMonitorMappingHandler::AliTPCMonitorMappingHandler(const AliTPCMonitorMappingHandler &maphand) : | |
100 | TNamed(maphand.GetName(),maphand.GetTitle()), | |
101 | fnumofChannels(maphand.fnumofChannels), | |
102 | fmaxHWAdress(maphand.fmaxHWAdress), | |
103 | fsizeofArray(maphand.fsizeofArray), | |
104 | fmapping(new Short_t*[24000]), | |
105 | fmappingChannelinRow(new Int_t*[160]), | |
106 | fu2ftestmapping(new Short_t*[7000]), | |
107 | fMapHwFECglobal(new Int_t*[24000]), | |
108 | fecGainMap(new Float_t*[7000]) | |
109 | { | |
110 | // copy constructor | |
111 | ||
112 | ||
113 | for(Int_t in = 0; in<160; in++) | |
114 | { | |
115 | Int_t* hold = new Int_t[150]; | |
116 | for(Int_t jn = 0; jn<150;jn++) hold[jn]=maphand.fmappingChannelinRow[in][jn]; | |
117 | fmappingChannelinRow[in]= hold; | |
118 | } | |
119 | ||
120 | for(Int_t i = 0; i<7000; i++) | |
121 | { | |
122 | Short_t* hold = new Short_t[8]; | |
123 | for(Int_t j = 0; j<8;j++) hold[j]=maphand.fu2ftestmapping[i][j]; | |
124 | fu2ftestmapping[i]= hold; | |
125 | } | |
126 | ||
127 | for(Int_t i = 0; i<24000; i++) | |
128 | { | |
129 | Int_t* hold = new Int_t[2]; | |
130 | for(Int_t j = 0; j<2;j++) hold[j]=maphand.fMapHwFECglobal[i][j]; | |
131 | fMapHwFECglobal[i]= hold; | |
132 | } | |
133 | ||
134 | for(Int_t i = 0; i<7000; i++) | |
135 | { | |
136 | Float_t* hold = new Float_t[128]; | |
137 | for(Int_t j = 0; j<128;j++) hold[j]=maphand.fecGainMap[i][j]; | |
138 | fecGainMap[i]= hold; | |
139 | } | |
140 | ||
141 | } | |
142 | ||
143 | ||
144 | //____________________________________________________________________________ | |
145 | AliTPCMonitorMappingHandler &AliTPCMonitorMappingHandler:: operator= (const AliTPCMonitorMappingHandler& maphand) | |
146 | { | |
147 | // assignment operator | |
148 | if(this!=&maphand) | |
149 | { | |
150 | fnumofChannels=maphand.fnumofChannels; | |
151 | fmaxHWAdress=maphand.fmaxHWAdress; | |
152 | fsizeofArray=maphand.fsizeofArray; | |
153 | ||
154 | fmapping = new Short_t*[24000]; // empty | |
155 | ||
156 | ||
157 | fmappingChannelinRow = new Int_t*[160]; | |
158 | for(Int_t in = 0; in<160; in++) | |
159 | { | |
160 | Int_t* hold = new Int_t[150]; | |
161 | for(Int_t jn = 0; jn<150;jn++) hold[jn]=maphand.fmappingChannelinRow[in][jn]; | |
162 | fmappingChannelinRow[in]= hold; | |
163 | } | |
164 | ||
165 | fu2ftestmapping = new Short_t*[7000]; | |
166 | for(Int_t i = 0; i<7000; i++) | |
167 | { | |
168 | Short_t* hold = new Short_t[8]; | |
169 | for(Int_t j = 0; j<8;j++) hold[j]=maphand.fu2ftestmapping[i][j]; | |
170 | fu2ftestmapping[i]= hold; | |
171 | } | |
172 | ||
173 | fMapHwFECglobal = new Int_t*[24000]; | |
174 | for(Int_t i = 0; i<24000; i++) | |
175 | { | |
176 | Int_t* hold = new Int_t[2]; | |
177 | for(Int_t j = 0; j<2;j++) hold[j]=maphand.fMapHwFECglobal[i][j]; | |
178 | fMapHwFECglobal[i]= hold; | |
179 | } | |
180 | ||
181 | fecGainMap = new Float_t*[7000]; | |
182 | for(Int_t i = 0; i<7000; i++) | |
183 | { | |
184 | Float_t* hold = new Float_t[128]; | |
185 | for(Int_t j = 0; j<128;j++) hold[j]=maphand.fecGainMap[i][j]; | |
186 | fecGainMap[i]= hold; | |
187 | } | |
188 | ||
189 | ||
190 | } | |
191 | return *this; | |
192 | } | |
193 | ||
194 | ||
48265b32 | 195 | //_____________________________________________________________________________________________ |
196 | AliTPCMonitorMappingHandler::~AliTPCMonitorMappingHandler() | |
197 | { | |
198 | // Destructor | |
199 | Short_t* temp; | |
200 | for(Int_t i = 0; i < 24000 ; i++) { | |
201 | temp = (Short_t *) fmapping[i]; | |
202 | if(temp[1] != -1) | |
203 | delete temp; | |
204 | } | |
205 | temp = (Short_t *) fmapping; | |
206 | delete temp; | |
207 | ||
208 | ||
209 | Int_t* temp1; | |
210 | for(Int_t i = 0; i < 24000 ; i++) { | |
211 | temp1 = (Int_t *) fMapHwFECglobal[i]; | |
212 | delete temp1; | |
213 | } | |
214 | temp1 = (Int_t *) fMapHwFECglobal; | |
215 | delete temp1; | |
216 | ||
217 | for(Int_t i = 0; i < 7000 ; i++) { | |
218 | temp = (Short_t *) fu2ftestmapping[i]; | |
219 | delete temp; | |
220 | } | |
221 | ||
222 | temp = (Short_t *) fu2ftestmapping; | |
223 | delete temp; | |
224 | ||
225 | for(Int_t i = 0; i < 150 ; i++) { | |
226 | temp1= (Int_t *) fmappingChannelinRow[i]; | |
227 | delete temp1; | |
228 | } | |
229 | temp1 = (Int_t *) fmappingChannelinRow; | |
230 | delete temp1; | |
231 | ||
232 | Float_t* temp2; | |
233 | for(Int_t i = 0; i<7000; i++) | |
234 | { | |
235 | temp2= (Float_t *) fecGainMap[i]; | |
236 | delete temp2; | |
237 | } | |
238 | temp2 = (Float_t *) fecGainMap; | |
239 | delete temp2; | |
240 | ||
241 | ||
242 | } | |
243 | ||
244 | //_____________________________________________________________________________________________ | |
245 | void AliTPCMonitorMappingHandler::ReadMapping(char* mapfile) | |
246 | { | |
247 | // Read global Mapping file | |
248 | // Format of data in mapping file: | |
249 | // column 0: hadrware address | |
250 | // column 1: readout index in IROC/OROC | |
251 | // column 2: global pad row number (0-158) | |
252 | // column 3 pad number in row | |
253 | // column 4: connector | |
254 | // column 5: pin | |
255 | // column 6: fec number in IROC/OROC | |
256 | // column 7: fec channel | |
257 | // column 8: fec connector | |
258 | // column 9: altro channel | |
259 | // column 10: altro chip | |
260 | ||
261 | // Mapping data for a given hardware address are placed at the | |
262 | // index corresponding to the value of the hardware address in | |
263 | // the fmapping array.. | |
264 | // The mapping information for the hardware address 'hwaddr' | |
265 | // can hence be found in fmapping[hwaddr] | |
266 | ||
267 | ||
ca7b8371 | 268 | Short_t* mappingRow; |
48265b32 | 269 | char readcarry[255]; |
270 | Int_t version = -1; | |
271 | Int_t actPos = 0; | |
272 | Int_t oldPos = 0; | |
273 | ||
274 | ifstream *in = new ifstream(); | |
275 | in->open(mapfile); | |
276 | *in >> readcarry; | |
277 | version = atoi(readcarry); | |
278 | ||
279 | *in >> readcarry; | |
280 | fnumofChannels = atoi(readcarry); | |
281 | *in >> readcarry; | |
282 | fmaxHWAdress = atoi(readcarry); | |
283 | fsizeofArray = fmaxHWAdress; | |
284 | ||
285 | Short_t *fmappingEmptyRow = new Short_t[11]; | |
286 | for(Int_t i = 0; i < 11 ; i++) { | |
287 | fmappingEmptyRow[i] = 0; | |
288 | } | |
289 | fmappingEmptyRow[1] = -1; | |
290 | for(Int_t i = 0; i < fnumofChannels ; i++) { | |
ca7b8371 | 291 | mappingRow = new Short_t[11]; |
48265b32 | 292 | for(Int_t j = 0 ; j < 11 ; j++) { |
293 | *in >> readcarry; | |
ca7b8371 | 294 | mappingRow[j] = atoi(readcarry); |
48265b32 | 295 | } |
ca7b8371 | 296 | actPos = mappingRow[0]; |
297 | fmapping[actPos] = mappingRow; | |
48265b32 | 298 | if( (actPos - oldPos) > 1) { |
299 | for(Int_t j = (oldPos+1); j < actPos; j++) { | |
300 | fmapping[j] = fmappingEmptyRow; | |
301 | } | |
302 | } | |
303 | oldPos = actPos; | |
304 | fmapping[actPos][0] = i; | |
305 | } | |
306 | ||
307 | in->close(); | |
308 | delete in; | |
309 | } | |
310 | ||
311 | //_____________________________________________________________________________________________ | |
312 | Int_t AliTPCMonitorMappingHandler::ReadFECMapping(char* u2ftestfile) | |
313 | { | |
314 | // Read in Mapping of global FEC numbers to branches, rcu patches etc. | |
315 | // Format in Mapping file | |
316 | // column 0: global card number (set to 0 if card number does not exist) | |
317 | // column 1: side of the TPC | |
318 | // column 2: sector on the side (0-17) | |
319 | // column 3: rcu in the sector (0-5) | |
320 | // column 4: fec number in rcu (0-24) | |
321 | // column 5: fec number in branch (0-12) | |
322 | // column 6: branch number (0,1) | |
323 | // column 7: local hardware address of first channel (not used) | |
324 | ||
325 | // Order of data is kept in fu2ftestmapping | |
326 | ||
327 | ifstream datin(u2ftestfile); | |
328 | ||
329 | Int_t carry = 0; | |
330 | Int_t ncards = 0; | |
331 | ||
332 | for(Int_t ind = 0; ind<7000; ind++) | |
333 | { | |
334 | for(Int_t entr = 0; entr<8; entr++) | |
335 | { | |
336 | datin >> carry ; | |
337 | fu2ftestmapping[ind][entr] = carry ; | |
338 | ||
339 | if(entr==0 && carry!=0) ncards++; | |
340 | } | |
341 | } | |
342 | return ncards ; | |
343 | } | |
344 | ||
345 | ||
346 | ||
347 | //_____________________________________________________________________________________________ | |
348 | void AliTPCMonitorMappingHandler::ReadfecHwMap(Int_t sector) | |
349 | { | |
350 | // Create mapping of global FEC numbers to hardware addresses for a given sector | |
351 | ||
352 | Int_t fside =0; | |
353 | Int_t fsector = 0; | |
354 | Int_t fec = 0; | |
355 | Int_t branch = 0; | |
fb3305d1 | 356 | Int_t rcupatch = 0; |
48265b32 | 357 | Int_t altrchann = 0; |
358 | Int_t altrchip = 0; | |
359 | Int_t nextHwAddress = 0; | |
360 | Int_t nfecs = 0; | |
361 | ||
362 | if(sector/18==0) fside =65; | |
363 | else fside =67; | |
364 | ||
365 | if(sector>18) fsector= sector-18; | |
366 | else fsector= sector ; | |
367 | ||
368 | for(Int_t ind = 0; ind<7000; ind++) | |
369 | { | |
370 | if((Int_t)U2fGetSide(ind)==fside && U2fGetSector(ind)==fsector) | |
371 | { | |
372 | nfecs++; | |
373 | fec = U2fGetFECinBranch(ind); | |
374 | branch = U2fGetBranch(ind); | |
fb3305d1 | 375 | rcupatch = U2fGetRCU(ind); |
48265b32 | 376 | |
377 | for(Int_t ch = 0; ch<128; ch++) | |
378 | { | |
379 | altrchann = ch%16; | |
380 | altrchip = ch/16; | |
381 | ||
fb3305d1 | 382 | nextHwAddress = ( ((branch&1)<<11) + (fec<<7) + (altrchip<<4) + (altrchann) + ((rcupatch-1)<<12) ); |
48265b32 | 383 | |
384 | fMapHwFECglobal[nextHwAddress][0] = ind; | |
385 | fMapHwFECglobal[nextHwAddress][1] = ch ; | |
386 | } | |
387 | } | |
388 | } | |
389 | } | |
390 | //_____________________________________________________________________________________________ | |
391 | void AliTPCMonitorMappingHandler::ReadfecGainMap(char* fecgainmap) | |
392 | { | |
393 | // Read global gain calibration pap | |
394 | // Format in file : | |
395 | // colummn 0 : FEC number | |
396 | // colums 1-128 : gain calibration factors | |
397 | ifstream datin(fecgainmap); | |
398 | ||
399 | Int_t fecnr = 0; | |
400 | Float_t val = 0.0 ; | |
401 | ||
402 | while(!datin.eof()) | |
403 | { | |
404 | datin >> fecnr ; | |
405 | for(Int_t in = 0; in<128; in++) | |
406 | { | |
407 | datin >> val ; | |
408 | fecGainMap[fecnr][in] = val; | |
409 | } | |
410 | } | |
411 | } | |
412 | ||
413 | //_____________________________________________________________________________________________ | |
414 | void AliTPCMonitorMappingHandler::ReadRowMappingGlob(char* fpathtoMappingRowfile) | |
415 | { | |
416 | // Read mapping of hardware addresses in rows | |
417 | // Format of file: | |
418 | // column 0: global row number (0-158) | |
419 | // column 1: number of pads in this row (npads) | |
420 | // column 2-npads: hardware addresses for these pads | |
421 | ||
422 | char readcarry[256]; | |
423 | char readcarry2[256]; | |
424 | ifstream *in = new ifstream(); | |
425 | in->open(fpathtoMappingRowfile); | |
426 | ||
427 | for(Int_t i = 0; i < 159 ; i++) { | |
428 | *in >> readcarry; // row number | |
429 | *in >> readcarry2; // numof pads | |
430 | fmappingChannelinRow[i][0] = atoi(readcarry2); | |
431 | fmappingChannelinRow[i][1] = atoi(readcarry); | |
432 | ||
433 | for(Int_t j = 2 ; j < fmappingChannelinRow[i][0]+2 ; j++) { | |
434 | *in >> readcarry; | |
435 | fmappingChannelinRow[i][j] = atoi(readcarry); | |
436 | } | |
437 | } | |
438 | in->close(); | |
439 | } | |
440 | ||
441 | ||
442 | ||
443 | //_____________________________________________________________________________________________ | |
fb3305d1 | 444 | Int_t AliTPCMonitorMappingHandler::GetNumOfChannels() const |
48265b32 | 445 | { |
446 | // Return number of channels | |
447 | return fnumofChannels; | |
448 | } | |
449 | ||
450 | //_____________________________________________________________________________________________ | |
fb3305d1 | 451 | Int_t AliTPCMonitorMappingHandler::GetSizeofArray() const |
48265b32 | 452 | { |
453 | // Return sise of global mapping fmapping array. | |
454 | // Value orresponds to max value of hardware addresses | |
455 | return fsizeofArray; | |
456 | } | |
457 | ||
458 | ||
459 | //_____________________________________________________________________________________________ | |
fb3305d1 | 460 | Short_t* AliTPCMonitorMappingHandler::GetLine(Int_t hwaddr)const |
48265b32 | 461 | { |
462 | // Return pointer to mapping array for the hardware address hwaddr | |
463 | Short_t* retval; | |
464 | if(hwaddr <= fsizeofArray) | |
465 | retval = fmapping[hwaddr]; | |
466 | else | |
467 | retval = 0; | |
468 | return retval; | |
469 | } | |
470 | ||
471 | //_____________________________________________________________________________________________ | |
fb3305d1 | 472 | Int_t AliTPCMonitorMappingHandler::GetIndex(Int_t hwaddr) const |
48265b32 | 473 | { |
474 | // Return readout index for the hardware address hwaddr | |
475 | Int_t retval; | |
476 | if(hwaddr <= fsizeofArray) | |
477 | retval = fmapping[hwaddr][1]; | |
478 | else | |
479 | retval = 0; | |
480 | return retval; | |
481 | } | |
482 | ||
483 | //_____________________________________________________________________________________________ | |
fb3305d1 | 484 | Int_t AliTPCMonitorMappingHandler::GetPadRow(Int_t hwaddr) const |
48265b32 | 485 | { |
486 | // Return global pad row for the hardware address hwaddr | |
487 | Int_t retval; | |
488 | if(hwaddr <= fsizeofArray) | |
489 | retval = fmapping[hwaddr][2]; | |
490 | else | |
491 | retval = 0; | |
492 | return retval; | |
493 | } | |
494 | ||
495 | //_____________________________________________________________________________________________ | |
fb3305d1 | 496 | Int_t AliTPCMonitorMappingHandler::GetPad(Int_t hwaddr) const |
48265b32 | 497 | { |
498 | // Return pad number in row for the hardware address hwaddr | |
499 | Int_t retval; | |
500 | if(hwaddr < fsizeofArray) | |
501 | retval = fmapping[hwaddr][3]; | |
502 | else | |
503 | retval = 0; | |
504 | return retval; | |
505 | } | |
506 | ||
507 | //_____________________________________________________________________________________________ | |
fb3305d1 | 508 | Int_t AliTPCMonitorMappingHandler::GetConnector(Int_t hwaddr) const |
48265b32 | 509 | { |
510 | // Return connector for the hardware address hwaddr | |
511 | Int_t retval; | |
512 | if(hwaddr <= fsizeofArray) | |
513 | retval = fmapping[hwaddr][4]; | |
514 | else | |
515 | retval = 0; | |
516 | return retval; | |
517 | } | |
518 | ||
519 | //_____________________________________________________________________________________________ | |
fb3305d1 | 520 | Int_t AliTPCMonitorMappingHandler::GetPin(Int_t hwaddr) const |
48265b32 | 521 | { |
522 | // Return pin for the hardware address hwaddr | |
523 | Int_t retval; | |
524 | if(hwaddr <= fsizeofArray) | |
525 | retval = fmapping[hwaddr][5]; | |
526 | else | |
527 | retval = 0; | |
528 | return retval; | |
529 | } | |
530 | ||
531 | //_____________________________________________________________________________________________ | |
fb3305d1 | 532 | Int_t AliTPCMonitorMappingHandler::GetFEC(Int_t hwaddr) const |
48265b32 | 533 | { |
534 | // Return fec number in IROC/OROC for the hardware address hwaddr | |
535 | Int_t retval; | |
536 | if(hwaddr <= fsizeofArray) | |
537 | retval = fmapping[hwaddr][6]; | |
538 | else | |
539 | retval = 0; | |
540 | return retval; | |
541 | } | |
542 | ||
543 | //_____________________________________________________________________________________________ | |
fb3305d1 | 544 | Int_t AliTPCMonitorMappingHandler::GetFECchannel(Int_t hwaddr) const |
48265b32 | 545 | { |
546 | // Return FEC channel for the hardware address hwaddr | |
547 | Int_t retval; | |
548 | if(hwaddr < fsizeofArray) | |
549 | retval = fmapping[hwaddr][7]; | |
550 | else | |
551 | retval = 0; | |
552 | return retval; | |
553 | } | |
554 | ||
555 | //_____________________________________________________________________________________________ | |
fb3305d1 | 556 | Int_t AliTPCMonitorMappingHandler::GetFECconnector(Int_t hwaddr) const |
48265b32 | 557 | { |
558 | // Return FEC connector for the hardware address hwaddr | |
559 | Int_t retval; | |
560 | if(hwaddr <= fsizeofArray) | |
561 | retval = fmapping[hwaddr][8]; | |
562 | else | |
563 | retval = 0; | |
564 | return retval; | |
565 | } | |
566 | ||
567 | //_____________________________________________________________________________________________ | |
fb3305d1 | 568 | Int_t AliTPCMonitorMappingHandler::GetAltroChannel(Int_t hwaddr) const |
48265b32 | 569 | { |
570 | // Return Altro channel for the hardware address hwaddr | |
571 | Int_t retval; | |
572 | if(hwaddr <= fsizeofArray) | |
573 | retval = fmapping[hwaddr][9]; | |
574 | else | |
575 | retval = 0; | |
576 | return retval; | |
577 | } | |
578 | ||
579 | //_____________________________________________________________________________________________ | |
fb3305d1 | 580 | Int_t AliTPCMonitorMappingHandler::GetAltro(Int_t hwaddr) const |
48265b32 | 581 | { |
582 | // Return Altro chip number in FEC for the hardware address hwaddr | |
583 | Int_t retval; | |
584 | if(hwaddr <= fsizeofArray) | |
585 | retval = fmapping[hwaddr][10]; | |
586 | else | |
587 | retval = 0; | |
588 | return retval; | |
589 | } | |
590 | ||
591 | ||
592 | //_____________________________________________________________________________________________ | |
fb3305d1 | 593 | Int_t AliTPCMonitorMappingHandler::GetNumofPads(Int_t row) |
48265b32 | 594 | { |
595 | // Return number of pads in row | |
596 | if(row<159) | |
597 | return fmappingChannelinRow[row][0]; | |
598 | else { | |
599 | AliError("Row number to high"); | |
600 | return 0; | |
601 | } | |
602 | } | |
603 | ||
604 | //_____________________________________________________________________________________________ | |
605 | Int_t AliTPCMonitorMappingHandler::GetPadAddInRow(Int_t row,Int_t pad ) | |
606 | { | |
607 | // Return hardware address for given pad in row | |
608 | if(row<159) | |
609 | return fmappingChannelinRow[row][pad+2]; | |
610 | else { | |
611 | AliError("Row number to high"); | |
612 | return 0; | |
613 | } | |
614 | } | |
615 | ||
616 | ||
617 | ||
618 | //_____________________________________________________________________________________________ | |
fb3305d1 | 619 | Int_t AliTPCMonitorMappingHandler::U2fGetFECnr(Int_t index) const |
48265b32 | 620 | { |
621 | // Return FEC number for index (FEC number should be equal to index) | |
622 | return fu2ftestmapping[index][0]; | |
623 | } | |
624 | ||
625 | //_____________________________________________________________________________________________ | |
fb3305d1 | 626 | Int_t AliTPCMonitorMappingHandler::U2fGetSide(Int_t fecnr) const |
48265b32 | 627 | { |
628 | // Return side on which FEC is installed | |
629 | return fu2ftestmapping[fecnr][1]; | |
630 | } | |
631 | ||
632 | //_____________________________________________________________________________________________ | |
fb3305d1 | 633 | Int_t AliTPCMonitorMappingHandler::U2fGetSector(Int_t fecnr) const |
48265b32 | 634 | { |
635 | // Return sector in which FEC is installed | |
636 | return fu2ftestmapping[fecnr][2]; | |
637 | } | |
638 | ||
639 | //_____________________________________________________________________________________________ | |
fb3305d1 | 640 | Int_t AliTPCMonitorMappingHandler::U2fGetRCU(Int_t fecnr) const |
48265b32 | 641 | { |
642 | // Rerurn rcu patch in which FEC is installed | |
643 | return fu2ftestmapping[fecnr][3]; | |
644 | } | |
645 | ||
646 | //_____________________________________________________________________________________________ | |
fb3305d1 | 647 | Int_t AliTPCMonitorMappingHandler::U2fGetFECinRCU(Int_t fecnr) const |
48265b32 | 648 | { |
649 | // Return index of FEC in RCU (0-25) | |
650 | return fu2ftestmapping[fecnr][4]; | |
651 | } | |
652 | ||
653 | //_____________________________________________________________________________________________ | |
fb3305d1 | 654 | Int_t AliTPCMonitorMappingHandler::U2fGetFECinBranch(Int_t fecnr) const |
48265b32 | 655 | { |
656 | // Return index of FEC in branch (0-12) | |
657 | return fu2ftestmapping[fecnr][5]; | |
658 | } | |
659 | ||
660 | //_____________________________________________________________________________________________ | |
fb3305d1 | 661 | Int_t AliTPCMonitorMappingHandler::U2fGetBranch(Int_t fecnr) const |
48265b32 | 662 | { |
663 | // Return branch in which FEC is installed (0,1) | |
664 | return fu2ftestmapping[fecnr][6]; | |
665 | ||
666 | } |