TPC/AliTPCMonitorMappingHandler.cxx

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