PMD/AliPMDRawStream.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 /* $Id$ */
  17
  18 ///////////////////////////////////////////////////////////////////////////////
  19 ///
  20 /// This class provides access to PMD digits in raw data.
  21 ///
  22 /// It loops over all PMD digits in the raw data given by the AliRawReader.
  23 /// The Next method goes to the next digit. If there are no digits left
  24 /// it returns kFALSE.
  25 /// Several getters provide information about the current digit.
  26 ///
  27 ///////////////////////////////////////////////////////////////////////////////
  28
  29 #include <Riostream.h>
  30 #include <TObjArray.h>
  31 #include <TString.h>
  32 #include <TSystem.h>
  33
  34 #include "AliLog.h"
  35 #include "AliPMDBlockHeader.h"
  36 #include "AliPMDDspHeader.h"
  37 #include "AliPMDPatchBusHeader.h"
  38 #include "AliPMDddldata.h"
  39 #include "AliPMDRawStream.h"
  40 #include "AliPMDMappingData.h"
  41 #include "AliRawReader.h"
  42 #include "AliCDBManager.h"
  43 #include "AliCDBStorage.h"
  44 #include "AliCDBEntry.h"
  45
  46 ClassImp(AliPMDRawStream)
  47
  48
  49 //_____________________________________________________________________________
  50 AliPMDRawStream::AliPMDRawStream(AliRawReader* rawReader) :
  51     fRawReader(rawReader),
  52     fData(NULL),
  53     fPosition(-1),
  54     fMapData(GetMappingData())
  55 {
  56 // create an object to read PMD raw digits
  57
  58   fRawReader->Reset();
  59   fRawReader->Select("PMD");
  60 }
  61
  62 //_____________________________________________________________________________
  63 AliPMDRawStream::AliPMDRawStream(const AliPMDRawStream& stream) :
  64   TObject(stream),
  65   fRawReader(NULL),
  66   fData(NULL),
  67   fPosition(-1),
  68   fMapData(GetMappingData())
  69 {
  70 // copy constructor
  71
  72   AliFatal("Copy constructor not implemented");
  73 }
  74
  75 //_____________________________________________________________________________
  76 AliPMDRawStream& AliPMDRawStream::operator = (const AliPMDRawStream&
  77                                               /* stream */)
  78 {
  79 // assignment operator
  80
  81   AliFatal("operator = assignment operator not implemented");
  82   return *this;
  83 }
  84
  85 //_____________________________________________________________________________
  86 AliPMDRawStream::~AliPMDRawStream()
  87 {
  88 // destructor
  89
  90 }
  91
  92
  93 //_____________________________________________________________________________
  94
  95 Int_t AliPMDRawStream::DdlData(TObjArray *pmdddlcont)
  96 {
  97   // read the next raw digit
  98   // returns kFALSE if there is no digit left
  99
 100   Int_t iddl = -1;
 101
 102   AliPMDddldata *pmdddldata;
 103
 104   if (!fRawReader->ReadHeader()) return -1;
 105
 106   iddl           = fRawReader->GetDDLID();
 107   Int_t dataSize = fRawReader->GetDataSize();
 108   Int_t totaldataword = dataSize/4;
 109
 110   if (dataSize <= 0) return -1;
 111
 112   UInt_t data = 0;
 113
 114  // PMD raw data does not contain CDH
 115
 116   if (!fRawReader->ReadNextData(fData))
 117     {
 118       return kFALSE;
 119     }
 120
 121
 122   fPosition = 0;
 123
 124   Int_t ibus = 0;
 125
 126   const Int_t kNPatchBus = 51;
 127
 128   Int_t moduleNo[kNPatchBus], mcmperBus[kNPatchBus];
 129   Int_t startRowBus[kNPatchBus], endRowBus[kNPatchBus];
 130   Int_t startColBus[kNPatchBus], endColBus[kNPatchBus];
 131
 132   for (ibus = 0; ibus < kNPatchBus; ibus++)
 133     {
 134       moduleNo[ibus]    = -1;
 135       mcmperBus[ibus]   = -1;
 136       startRowBus[ibus] = -1;
 137       endRowBus[ibus]   = -1;
 138       startColBus[ibus] = -1;
 139       endColBus[ibus]   = -1;
 140     }
 141
 142   if (iddl == 0)
 143     {
 144       Ddl0Mapping(moduleNo, mcmperBus, startRowBus,
 145                   endRowBus, startColBus, endColBus);
 146
 147     }
 148   else if (iddl == 1)
 149     {
 150       Ddl1Mapping(moduleNo, mcmperBus, startRowBus,
 151                   endRowBus, startColBus, endColBus);
 152
 153     }
 154   else if (iddl == 2)
 155     {
 156       Ddl2Mapping(moduleNo, mcmperBus, startRowBus,
 157                   endRowBus, startColBus, endColBus);
 158     }
 159   else if (iddl == 3)
 160     {
 161       Ddl3Mapping(moduleNo, mcmperBus, startRowBus,
 162                   endRowBus, startColBus, endColBus);
 163     }
 164   else if (iddl == 4)
 165     {
 166       Ddl4Mapping(moduleNo, mcmperBus, startRowBus,
 167                   endRowBus, startColBus, endColBus);
 168     }
 169   else if (iddl == 5)
 170     {
 171       Ddl5Mapping(moduleNo, mcmperBus, startRowBus,
 172                   endRowBus, startColBus, endColBus);
 173   }
 174
 175
 176   AliPMDBlockHeader    blockHeader;
 177   AliPMDDspHeader      dspHeader;
 178   AliPMDPatchBusHeader pbusHeader;
 179
 180   const Int_t kblHLen   = blockHeader.GetHeaderLength();
 181   const Int_t kdspHLen  = dspHeader.GetHeaderLength();
 182   const Int_t kpbusHLen = pbusHeader.GetHeaderLength();
 183
 184   Int_t parity = 0;
 185   Int_t idet = 0, ismn = 0;
 186   Int_t irow = -1;
 187   Int_t icol = -1;
 188
 189   Int_t blHeaderWord[8]={0};
 190   Int_t dspHeaderWord[10]={0};
 191   Int_t pbusHeaderWord[4]={0};
 192
 193   Int_t blRawDataLength  = 0;
 194   Int_t dspRawDataLength = 0;
 195   Int_t iwordddl         = 2;
 196
 197
 198
 199   for (Int_t iblock = 0; iblock < 2; iblock++)
 200     {
 201       for (Int_t i = 0; i < kblHLen; i++)
 202         {
 203             iwordddl++;
 204             blHeaderWord[i] = (Int_t) GetNextWord();
 205         }
 206
 207       blockHeader.SetHeader(blHeaderWord);
 208       blRawDataLength = blockHeader.GetRawDataLength();
 209
 210       if (iwordddl == totaldataword) break;
 211
 212       Int_t iwordblk = 0;
 213
 214       for (Int_t idsp = 0; idsp < 5; idsp++)
 215         {
 216           for (Int_t i = 0; i < kdspHLen; i++)
 217             {
 218                 iwordddl++;
 219                 iwordblk++;
 220                 dspHeaderWord[i] = (Int_t) GetNextWord();
 221             }
 222           dspHeader.SetHeader(dspHeaderWord);
 223           dspRawDataLength = dspHeader.GetRawDataLength();
 224
 225           if (iwordddl == totaldataword) break;
 226
 227           Int_t iworddsp = 0;
 228
 229           for (ibus = 0; ibus < 5; ibus++)
 230             {
 231               for (Int_t i = 0; i < kpbusHLen; i++)
 232                 {
 233                     iwordddl++;
 234                     iwordblk++;
 235                     iworddsp++;
 236                     pbusHeaderWord[i] = (Int_t) GetNextWord();
 237                 }
 238
 239               pbusHeader.SetHeader(pbusHeaderWord);
 240               Int_t rawdatalength = pbusHeader.GetRawDataLength();
 241               Int_t pbusid = pbusHeader.GetPatchBusId();
 242
 243               if (pbusid < 0 || pbusid > 50) return -1;
 244
 245               Int_t imodule = moduleNo[pbusid];
 246
 247               if (iwordddl == totaldataword) break;
 248
 249               for (Int_t iword = 0; iword < rawdatalength; iword++)
 250                 {
 251                     iwordddl++;
 252                     iwordblk++;
 253                     iworddsp++;
 254                     data = 0;
 255                     data = GetNextWord();
 256
 257                   Int_t isig =  data & 0x0FFF;
 258                   Int_t ich  = (data >> 12) & 0x003F;
 259                   Int_t imcm = (data >> 18) & 0x07FF;
 260                   Int_t ibit = (data >> 31) & 0x0001;
 261                   if (imcm == 0)
 262                     {
 263                       AliWarning(Form("FEE address WRONG:: Module %d Patch Bus %d MCM %d",imodule,pbusid,imcm));
 264                       return -1;
 265                     }
 266
 267                   parity = ComputeParity(data);
 268
 269                   if (ibit != parity)
 270                     {
 271                       AliWarning(Form("Parity Error:: Patch Bus %d Module %d",pbusid,imodule));
 272                       fRawReader->AddMajorErrorLog(kParityError);
 273                       return -1;
 274                     }
 275
 276                   ConvertDDL2SMN(iddl, imodule, ismn, idet);
 277
 278                   GetRowCol(imodule, pbusid, imcm, ich,
 279                             startRowBus, endRowBus,
 280                             startColBus, endColBus,
 281                             irow, icol);
 282
 283
 284                   TransformH2S(ismn, irow, icol);
 285
 286                   pmdddldata = new AliPMDddldata();
 287
 288                   pmdddldata->SetDetector(idet);
 289                   pmdddldata->SetSMN(ismn);
 290                   pmdddldata->SetModule(imodule);
 291                   pmdddldata->SetPatchBusId(pbusid);
 292                   pmdddldata->SetMCM(imcm);
 293                   pmdddldata->SetChannel(ich);
 294                   pmdddldata->SetRow(irow);
 295                   pmdddldata->SetColumn(icol);
 296                   pmdddldata->SetSignal(isig);
 297                   pmdddldata->SetParityBit(ibit);
 298
 299                   pmdddlcont->Add(pmdddldata);
 300
 301                 } // data word loop
 302
 303
 304               if (iwordddl == totaldataword) break;
 305
 306               if (dspHeader.GetPaddingWord() == 1)
 307               {
 308                   if (iworddsp == dspRawDataLength-1) break; // raw data
 309               }
 310               else
 311               {
 312                   if (iworddsp == dspRawDataLength) break; // raw data
 313               }
 314
 315
 316             } // patch bus loop
 317
 318 //SKP added break next line (Reqd. if only one patch Bus)
 319           if (iwordddl == totaldataword) break;
 320
 321           if (dspHeader.GetPaddingWord() == 1)
 322           {
 323               iwordddl++;
 324               iwordblk++;
 325               iworddsp++;
 326               data = GetNextWord();
 327           }
 328           if (iwordddl == totaldataword) break;
 329
 330           if (iwordblk == blRawDataLength) break; // for raw data
 331
 332
 333         } // end of DSP
 334 //SKP added break next line (Reqd. if only one patch Bus)
 335           if (iwordddl == totaldataword) break;
 336
 337     } // end of BLOCK
 338
 339  return iddl;
 340 }
 341 //_____________________________________________________________________________
 342 void AliPMDRawStream::GetRowCol(Int_t imodule, Int_t pbusid,
 343                                 UInt_t mcmno, UInt_t chno,
 344                                 Int_t startRowBus[], Int_t endRowBus[],
 345                                 Int_t startColBus[], Int_t endColBus[],
 346                                 Int_t &row, Int_t &col) const
 347 {
 348   // decode: ddlno, patchbusid, mcmno, chno -> um, row, col
 349
 350   UInt_t iCh[64];
 351
 352   static const UInt_t kChDdl01[64] = { 9, 6, 5, 10, 1, 2, 0, 3,
 353                                        13, 7, 4, 11, 8, 14, 12, 15,
 354                                        16, 19, 17, 23, 20, 27, 24, 18,
 355                                        28, 31, 29, 30, 21, 26, 25, 22,
 356                                        41, 38, 37, 42, 33, 34, 32, 35,
 357                                        45, 39, 36, 43, 40, 46, 44, 47,
 358                                        48, 51, 49, 55, 52, 59, 56, 50,
 359                                        60, 63, 61, 62, 53, 58, 57, 54 };
 360
 361   static const UInt_t kChDdl23[64] = { 54, 57, 58, 53, 62, 61, 63, 60,
 362                                        50, 56, 59, 52, 55, 49, 51, 48,
 363                                        47, 44, 46, 40, 43, 36, 39, 45,
 364                                        35, 32, 34, 33, 42, 37, 38, 41,
 365                                        22, 25, 26, 21, 30, 29, 31, 28,
 366                                        18, 24, 27, 20, 23, 17, 19, 16,
 367                                        15, 12, 14, 8, 11, 4, 7, 13,
 368                                        3, 0, 2, 1, 10, 5, 6, 9 };
 369
 370   static const UInt_t kChDdl41[64] = { 53, 58, 57, 54, 61, 62, 60, 63,
 371                                        49, 59, 56, 55, 52, 50, 48, 51,
 372                                        44, 47, 45, 43, 40, 39, 36, 46,
 373                                        32, 35, 33, 34, 41, 38, 37, 42,
 374                                        21, 26, 25, 22, 29, 30, 28, 31,
 375                                        17, 27, 24, 23, 20, 18, 16, 19,
 376                                        12, 15, 13, 11, 8, 7, 4, 14,
 377                                        0, 3, 1, 2, 9, 6, 5, 10 };
 378
 379   static const UInt_t kChDdl42[64] = { 10, 5, 6, 9, 2, 1, 3, 0,
 380                                        14, 4, 7, 8, 11, 13, 15, 12,
 381                                        19, 16, 18, 20, 23, 24, 27, 17,
 382                                        31, 28, 30, 29, 22, 25, 26, 21,
 383                                        42, 37, 38, 41, 34, 33, 35, 32,
 384                                        46, 36, 39, 40, 43, 45, 47, 44,
 385                                        51, 48, 50, 52, 55, 56, 59, 49,
 386                                        63, 60, 62, 61, 54, 57, 58, 53 };
 387
 388   static const UInt_t kChDdl51[64] = { 10, 5, 6, 9, 2, 1, 3, 0,
 389                                        14, 4, 7, 8, 11, 13, 15, 12,
 390                                        19, 16, 18, 20, 23, 24, 27, 17,
 391                                        31, 28, 30, 29, 22, 25, 26, 21,
 392                                        42, 37, 38, 41, 34, 33, 35, 32,
 393                                        46, 36, 39, 40, 43, 45, 47, 44,
 394                                        51, 48, 50, 52, 55, 56, 59, 49,
 395                                        63, 60, 62, 61, 54, 57, 58, 53 };
 396
 397   static const UInt_t kChDdl52[64] = { 53, 58, 57, 54, 61, 62, 60, 63,
 398                                        49, 59, 56, 55, 52, 50, 48, 51,
 399                                        44, 47, 45, 43, 40, 39, 36, 46,
 400                                        32, 35, 33, 34, 41, 38, 37, 42,
 401                                        21, 26, 25, 22, 29, 30, 28, 31,
 402                                        17, 27, 24, 23, 20, 18, 16, 19,
 403                                        12, 15, 13, 11, 8, 7, 4, 14,
 404                                        0, 3, 1, 2, 9, 6, 5, 10 };
 405
 406   for (Int_t i = 0; i < 64; i++)
 407     {
 408       if(imodule < 6)                    iCh[i] = kChDdl01[i];
 409       if(imodule >= 6 && imodule <= 11)  iCh[i] = kChDdl01[i];
 410       if(imodule >= 12 && imodule <= 17) iCh[i] = kChDdl23[i];
 411       if(imodule >= 18 && imodule <= 23) iCh[i] = kChDdl23[i];
 412       if(imodule >= 24 && imodule <= 29) iCh[i] = kChDdl41[i];
 413       if(imodule >= 42 && imodule <= 47) iCh[i] = kChDdl42[i];
 414       if(imodule >= 36 && imodule <= 41) iCh[i] = kChDdl51[i];
 415       if(imodule >= 30 && imodule <= 35) iCh[i] = kChDdl52[i];
 416     }
 417
 418
 419   Int_t rowcol  = iCh[chno];
 420   Int_t irownew = rowcol/4;
 421   Int_t icolnew = rowcol%4;
 422
 423
 424   if (imodule < 6 )
 425     {
 426       row = startRowBus[pbusid] + irownew;
 427       col = startColBus[pbusid] + (mcmno-1)*4 + icolnew;
 428     }
 429   else if (imodule >= 6 && imodule < 12)
 430     {
 431       row = endRowBus[pbusid] - (15 - irownew);
 432       col = startColBus[pbusid] + (mcmno-1)*4 + icolnew;
 433
 434     }
 435   else if (imodule >= 12 && imodule < 18 )
 436     {
 437       row = startRowBus[pbusid] + irownew;
 438       col = endColBus[pbusid] - (mcmno-1)*4 - (3 - icolnew);
 439     }
 440   else if (imodule >= 18 && imodule < 24)
 441     {
 442       row = endRowBus[pbusid] - (15 - irownew);
 443       col = endColBus[pbusid] - (mcmno-1)*4 - (3 - icolnew);
 444     }
 445   else if (imodule >= 24 && imodule < 30)
 446     {
 447       Int_t rowdiff = endRowBus[pbusid] - startRowBus[pbusid];
 448       if(rowdiff > 16)
 449         {
 450           if (mcmno <= 12)
 451             {
 452               // Add 16 to skip the 1st 15 rows
 453               row = startRowBus[pbusid] + irownew + 16;
 454               col = startColBus[pbusid] + (mcmno-1)*4 + icolnew;
 455             }
 456           else if(mcmno > 12)
 457             {
 458               row = startRowBus[pbusid] + irownew;
 459               col = startColBus[pbusid] + (mcmno-12-1)*4 + icolnew;
 460             }
 461         }
 462       else if (rowdiff < 16)
 463         {
 464           row = startRowBus[pbusid] + irownew;
 465           col = startColBus[pbusid] + (mcmno-1)*4 + icolnew;
 466         }
 467     }
 468   else if (imodule >= 42 && imodule < 48)
 469     {
 470       Int_t rowdiff = endRowBus[pbusid] - startRowBus[pbusid];
 471
 472       if (mcmno <= 12)
 473         {
 474           col = endColBus[pbusid] - (mcmno-1)*4 - (3 - icolnew);
 475
 476           if(rowdiff > 16)
 477             row = endRowBus[pbusid] - (15 - irownew) - 16 ;
 478           else
 479             row = endRowBus[pbusid] - (15 - irownew) ;
 480         }
 481       else if(mcmno > 12)
 482         {
 483           row = endRowBus[pbusid] - (15 - irownew)  ;
 484           col = endColBus[pbusid] - (mcmno - 12 - 1)*4 - (3 - icolnew);
 485         }
 486     }
 487
 488
 489
 490   else if (imodule >= 30 && imodule < 36)
 491     {
 492       if (mcmno > 12)
 493         {
 494           // Subtract 16 to skip the 1st 15 rows
 495           row = endRowBus[pbusid] - 16 -(15 - irownew);
 496           col = startColBus[pbusid] + (mcmno-12 -1)*4 + icolnew;
 497         }
 498       else
 499         {
 500           row = endRowBus[pbusid]  - (15 - irownew) ;
 501           col = startColBus[pbusid] + (mcmno -1)*4 + icolnew;
 502         }
 503
 504     }
 505
 506   else if (imodule >= 36 && imodule < 42)
 507     {
 508       if(mcmno > 12)
 509         {
 510           // Add 16 to skip the 1st 15 rows
 511           row = startRowBus[pbusid] + irownew + 16;
 512           col = endColBus[pbusid] - (mcmno - 12 - 1)*4 - (3 - icolnew);
 513         }
 514       else
 515         {
 516           row = startRowBus[pbusid] + irownew ;
 517           col = endColBus[pbusid] - (mcmno - 1)*4 - (3 - icolnew);
 518         }
 519     }
 520
 521
 522 }
 523 //_____________________________________________________________________________
 524 void AliPMDRawStream::ConvertDDL2SMN(Int_t iddl, Int_t imodule,
 525                                      Int_t &smn, Int_t &detector) const
 526 {
 527   // This converts the DDL number (0 to 5), Module Number (0-47)
 528   // to Serial module number in one detector (SMN : 0-23) and
 529   // detector number (0:PRE plane, 1:CPV plane)
 530   if (iddl < 4)
 531     {
 532       smn = imodule;
 533       detector = 0;
 534     }
 535   else
 536     {
 537       smn = imodule - 24;
 538       detector = 1;
 539     }
 540 }
 541 //_____________________________________________________________________________
 542
 543 void AliPMDRawStream::TransformH2S(Int_t smn, Int_t &row, Int_t &col) const
 544 {
 545   // This does the transformation of the hardware coordinate to
 546   // software
 547   // i.e., For SuperModule 0 &1, instead of 96x48(hardware),
 548   // it is 48x96 (software)
 549   // For Supermodule 3 & 4, 48x96
 550
 551   Int_t irownew  = 0;
 552   Int_t icolnew  = 0;
 553
 554   if(smn < 12)
 555     {
 556       irownew = col;
 557       icolnew = row;
 558     }
 559   else if(smn >= 12 && smn < 24)
 560     {
 561       irownew = row;
 562       icolnew = col;
 563     }
 564
 565   row = irownew;
 566   col = icolnew;
 567 }
 568 //_____________________________________________________________________________
 569 Int_t AliPMDRawStream::ComputeParity(UInt_t data)
 570 {
 571 // Calculate the parity bit
 572
 573   Int_t count = 0;
 574   for(Int_t j = 0; j<29; j++)
 575     {
 576       if (data & 0x01 ) count++;
 577       data >>= 1;
 578     }
 579
 580   Int_t parity = count%2;
 581
 582   return parity;
 583 }
 584
 585 //_____________________________________________________________________________
 586 UInt_t AliPMDRawStream::GetNextWord()
 587 {
 588     // Returns the next 32 bit word
 589     // inside the raw data payload.
 590
 591     if (!fData || fPosition < 0) AliFatal("Raw data payload buffer is not yet initialized !");
 592
 593     UInt_t word = 0;
 594     word |= fData[fPosition++];
 595     word |= fData[fPosition++] << 8;
 596     word |= fData[fPosition++] << 16;
 597     word |= fData[fPosition++] << 24;
 598
 599     return word;
 600 }
 601
 602 //_____________________________________________________________________________
 603 void AliPMDRawStream::Ddl0Mapping(Int_t moduleNo[],    Int_t mcmperBus[],
 604                                   Int_t startRowBus[], Int_t endRowBus[],
 605                                   Int_t startColBus[], Int_t endColBus[])
 606 {
 607   // DDL0 Mapping
 608
 609   Int_t iddl = 0;
 610
 611   for(Int_t ibus = 1; ibus < 51; ibus++)
 612     {
 613       moduleNo[ibus]     = fMapData->GetModuleNo(iddl,ibus);
 614       mcmperBus[ibus]    = fMapData->GetMcmperBus(iddl,ibus);
 615       startRowBus[ibus]  = fMapData->GetStartRowBus(iddl,ibus);
 616       startColBus[ibus]  = fMapData->GetStartColBus(iddl,ibus);
 617       endRowBus[ibus]    = fMapData->GetEndRowBus(iddl,ibus);
 618       endColBus[ibus]    = fMapData->GetEndColBus(iddl,ibus);
 619     }
 620
 621 }
 622
 623 //_____________________________________________________________________________
 624 void AliPMDRawStream::Ddl1Mapping(Int_t moduleNo[],    Int_t mcmperBus[],
 625                                   Int_t startRowBus[], Int_t endRowBus[],
 626                                   Int_t startColBus[], Int_t endColBus[])
 627 {
 628   // DDL1 Mapping
 629
 630   Int_t iddl = 1;
 631
 632   for(Int_t ibus = 1; ibus < 51; ibus++)
 633     {
 634       moduleNo[ibus]     = fMapData->GetModuleNo(iddl,ibus);
 635       mcmperBus[ibus]    = fMapData->GetMcmperBus(iddl,ibus);
 636       startRowBus[ibus]  = fMapData->GetStartRowBus(iddl,ibus);
 637       startColBus[ibus]  = fMapData->GetStartColBus(iddl,ibus);
 638       endRowBus[ibus]    = fMapData->GetEndRowBus(iddl,ibus);
 639       endColBus[ibus]    = fMapData->GetEndColBus(iddl,ibus);
 640
 641     }
 642
 643
 644 }
 645
 646 //_____________________________________________________________________________
 647 void AliPMDRawStream::Ddl2Mapping(Int_t moduleNo[],    Int_t mcmperBus[],
 648                                   Int_t startRowBus[], Int_t endRowBus[],
 649                                   Int_t startColBus[], Int_t endColBus[])
 650 {
 651   // DDL2 Mapping
 652
 653   Int_t iddl = 2;
 654
 655   for(Int_t ibus = 1; ibus < 51; ibus++)
 656     {
 657       moduleNo[ibus]     = fMapData->GetModuleNo(iddl,ibus);
 658       mcmperBus[ibus]    = fMapData->GetMcmperBus(iddl,ibus);
 659       startRowBus[ibus]  = fMapData->GetStartRowBus(iddl,ibus);
 660       startColBus[ibus]  = fMapData->GetStartColBus(iddl,ibus);
 661       endRowBus[ibus]    = fMapData->GetEndRowBus(iddl,ibus);
 662       endColBus[ibus]    = fMapData->GetEndColBus(iddl,ibus);
 663
 664     }
 665
 666 }
 667
 668 //_____________________________________________________________________________
 669 void AliPMDRawStream::Ddl3Mapping(Int_t moduleNo[],    Int_t mcmperBus[],
 670                                   Int_t startRowBus[], Int_t endRowBus[],
 671                                   Int_t startColBus[], Int_t endColBus[])
 672 {
 673   // DDL3 Mapping
 674
 675   Int_t iddl = 3;
 676
 677   for(Int_t ibus = 1; ibus < 51; ibus++)
 678     {
 679       moduleNo[ibus]     = fMapData->GetModuleNo(iddl,ibus);
 680       mcmperBus[ibus]    = fMapData->GetMcmperBus(iddl,ibus);
 681       startRowBus[ibus]  = fMapData->GetStartRowBus(iddl,ibus);
 682       startColBus[ibus]  = fMapData->GetStartColBus(iddl,ibus);
 683       endRowBus[ibus]    = fMapData->GetEndRowBus(iddl,ibus);
 684       endColBus[ibus]    = fMapData->GetEndColBus(iddl,ibus);
 685
 686     }
 687
 688 }
 689
 690 //_____________________________________________________________________________
 691 void AliPMDRawStream::Ddl4Mapping(Int_t moduleNo[],    Int_t mcmperBus[],
 692                                   Int_t startRowBus[], Int_t endRowBus[],
 693                                   Int_t startColBus[], Int_t endColBus[])
 694 {
 695   // DDL4 Mapping
 696
 697   Int_t iddl = 4;
 698
 699   for(Int_t ibus = 1; ibus < 51; ibus++)
 700     {
 701       moduleNo[ibus]     = fMapData->GetModuleNo(iddl,ibus);
 702       mcmperBus[ibus]    = fMapData->GetMcmperBus(iddl,ibus);
 703       startRowBus[ibus]  = fMapData->GetStartRowBus(iddl,ibus);
 704       startColBus[ibus]  = fMapData->GetStartColBus(iddl,ibus);
 705       endRowBus[ibus]    = fMapData->GetEndRowBus(iddl,ibus);
 706       endColBus[ibus]    = fMapData->GetEndColBus(iddl,ibus);
 707
 708     }
 709
 710
 711 }
 712
 713 //_____________________________________________________________________________
 714 void AliPMDRawStream::Ddl5Mapping(Int_t moduleNo[],    Int_t mcmperBus[],
 715                                   Int_t startRowBus[], Int_t endRowBus[],
 716                                   Int_t startColBus[], Int_t endColBus[])
 717 {
 718   // DDL5 Mapping
 719
 720   Int_t iddl = 5;
 721
 722   for(Int_t ibus = 1; ibus < 51; ibus++)
 723     {
 724       moduleNo[ibus]     = fMapData->GetModuleNo(iddl,ibus);
 725       mcmperBus[ibus]    = fMapData->GetMcmperBus(iddl,ibus);
 726       startRowBus[ibus]  = fMapData->GetStartRowBus(iddl,ibus);
 727       startColBus[ibus]  = fMapData->GetStartColBus(iddl,ibus);
 728       endRowBus[ibus]    = fMapData->GetEndRowBus(iddl,ibus);
 729       endColBus[ibus]    = fMapData->GetEndColBus(iddl,ibus);
 730
 731     }
 732
 733 }
 734 //_____________________________________________________________________________
 735
 736 AliPMDMappingData* AliPMDRawStream::GetMappingData() const
 737 {
 738   // Fetching the mapping data from CDB
 739
 740   AliCDBEntry  *entry = AliCDBManager::Instance()->Get("PMD/Calib/Mapping");
 741
 742   if(!entry) AliFatal("Mapping object retrieval failed!");
 743
 744   AliPMDMappingData *mapdata=0;
 745   if (entry) mapdata = (AliPMDMappingData*) entry->GetObject();
 746
 747   if (!mapdata)  AliFatal("No Mapping data from CDB !");
 748
 749   return mapdata;
 750 }
 751
 752
 753
 754 //_____________________________________________________________________________
 755