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