PMD/AliPMDDDLRawData.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 #include <Riostream.h>
  17 #include <TClonesArray.h>
  18 #include <TTree.h>
  19 #include <TBranch.h>
  20 #include <TMath.h>
  21 #include <TString.h>
  22 #include <TSystem.h>
  23
  24 #include "AliLog.h"
  25 #include "AliRawDataHeaderSim.h"
  26 #include "AliBitPacking.h"
  27 #include "AliPMDdigit.h"
  28 #include "AliPMDBlockHeader.h"
  29 #include "AliPMDDspHeader.h"
  30 #include "AliPMDPatchBusHeader.h"
  31 #include "AliPMDRawStream.h"
  32 #include "AliPMDDDLRawData.h"
  33 #include "AliDAQ.h"
  34 #include "AliFstream.h"
  35
  36 ClassImp(AliPMDDDLRawData)
  37
  38 AliPMDDDLRawData::AliPMDDDLRawData():
  39   fDigits(new TClonesArray("AliPMDdigit", 1000))
  40 {
  41   // Default Constructor
  42   //
  43
  44 }
  45 //____________________________________________________________________________
  46 AliPMDDDLRawData::AliPMDDDLRawData(const AliPMDDDLRawData& ddlraw):
  47   TObject(ddlraw),
  48   fDigits(ddlraw.fDigits)
  49 {
  50   //Copy Constructor
  51 }
  52 //____________________________________________________________________________
  53 AliPMDDDLRawData & AliPMDDDLRawData::operator=(const AliPMDDDLRawData& ddlraw)
  54 {
  55   //Assignment operator
  56   if(this != &ddlraw)
  57     {
  58       fDigits = ddlraw.fDigits;
  59     }
  60   return *this;
  61 }
  62 //____________________________________________________________________________
  63
  64 AliPMDDDLRawData::~AliPMDDDLRawData()
  65 {
  66   // Default Destructor
  67   //
  68
  69 }
  70
  71 //____________________________________________________________________________
  72 void AliPMDDDLRawData::WritePMDRawData(TTree *treeD)
  73 {
  74   // write digits into raw data format
  75
  76   AliFstream *outfile;
  77
  78   TBranch *branch = treeD->GetBranch("PMDDigit");
  79   if (!branch)
  80     {
  81       AliError("PMD Digit branch not found");
  82       return;
  83     }
  84   branch->SetAddress(&fDigits);
  85
  86   Int_t   nmodules = (Int_t) treeD->GetEntries();
  87   AliDebug(1,Form("Number of modules inside treeD = %d",nmodules));
  88
  89   const Int_t kDDL          = AliDAQ::NumberOfDdls("PMD");
  90   Int_t modulePerDDL        = 0;
  91
  92
  93   AliRawDataHeaderSim header;
  94   UInt_t sizeRawData = 0;
  95
  96   const Int_t kbusSize = 51;
  97   const Int_t kSize = 1536;
  98   UInt_t buffer[kSize];
  99
 100   UInt_t busPatch[kbusSize][1536];
 101
 102   Int_t contentsBus[kbusSize];
 103
 104   Char_t filename[80];
 105
 106   // open the ddl file info to know the modules per DDL
 107   TString ddlinfofileName(gSystem->Getenv("ALICE_ROOT"));
 108   ddlinfofileName += "/PMD/PMD_ddl_info.dat";
 109
 110   ifstream infileddl;
 111   infileddl.open(ddlinfofileName.Data(), ios::in); // ascii file
 112   if(!infileddl) AliError("Could not read the ddl info file");
 113
 114
 115
 116   Int_t mmodule = 0;
 117   Int_t ddlno;
 118   Int_t modno;
 119   Int_t *modulenoddl = 0x0;
 120
 121   for(Int_t iddl = 0; iddl < kDDL; iddl++)
 122     {
 123       if (infileddl.eof()) break;
 124       infileddl >> ddlno >> modulePerDDL;
 125
 126       if (modulePerDDL == 0) continue;
 127
 128       modulenoddl = new Int_t [modulePerDDL];
 129       for (Int_t im = 0; im < modulePerDDL; im++)
 130         {
 131           infileddl >> modno;
 132           modulenoddl[im] = modno;
 133         }
 134
 135       strcpy(filename,AliDAQ::DdlFileName("PMD",iddl));
 136
 137       outfile = new AliFstream(filename);
 138
 139       // Write the Dummy Data Header into the file
 140       Int_t bHPosition = outfile->Tellp();
 141       outfile->WriteBuffer((char*)(&header),sizeof(header));
 142
 143       for (Int_t ibus = 0; ibus < kbusSize; ibus++)
 144         {
 145           contentsBus[ibus] = 0;
 146           for (Int_t ich = 0; ich < kSize; ich++)
 147             {
 148               busPatch[ibus][ich] = 0;
 149             }
 150         }
 151
 152       for(Int_t ium = 0; ium < modulePerDDL; ium++)
 153         {
 154           //if (iddl == 4 && ium == 6) mmodule = 42;
 155
 156           // Extract energy deposition per cell and pack it
 157           // in a 32-bit word and returns all the total words
 158           // per one unit-module
 159
 160           mmodule = modulenoddl[ium];
 161           GetUMDigitsData(treeD, mmodule, iddl, modulePerDDL, contentsBus, busPatch);
 162         }
 163
 164       Int_t ij = 0;
 165       Int_t dsp[10];
 166       Int_t dspBus[10];
 167       for (Int_t i = 0; i < 10; i++)
 168         {
 169           dsp[i] = 0;
 170           dspBus[i] = 0;
 171           for (Int_t ibus=0; ibus < 5; ibus++)
 172             {
 173               ij++;
 174               if (contentsBus[ij] > 0)
 175                 {
 176                   dsp[i] += contentsBus[ij];
 177                 }
 178               dspBus[i]++;
 179             }
 180           // Add the patch Bus header to the DSP contents
 181           dsp[i] += 4*dspBus[i];
 182         }
 183
 184       Int_t dspBlockARDL    = 0;
 185       Int_t dspBlockBRDL    = 0;
 186       Int_t remainder       = 0;
 187
 188
 189       for (Int_t i = 0; i < 5; i++)
 190         {
 191           Int_t ieven = 2*i;
 192           Int_t iodd  = 2*i + 1;
 193           if (dsp[ieven] > 0)
 194             {
 195               dspBlockARDL += dsp[ieven];
 196               remainder = dsp[ieven]%2;
 197               if (remainder == 1)
 198                 {
 199                   dspBlockARDL++;
 200                 }
 201             }
 202           if (dsp[iodd] > 0)
 203             {
 204               dspBlockBRDL += dsp[iodd];
 205               remainder = dsp[iodd]%2;
 206               if (remainder == 1)
 207                 {
 208                   dspBlockBRDL++;
 209                 }
 210             }
 211         }
 212
 213       dspBlockARDL += 50;
 214       dspBlockBRDL += 50;
 215
 216       // Start writing the DDL file
 217
 218       AliPMDBlockHeader blHeader;
 219       AliPMDDspHeader   dspHeader;
 220       AliPMDPatchBusHeader pbusHeader;
 221
 222       const Int_t kblHLen   = blHeader.GetHeaderLength();
 223       const Int_t kdspHLen  = dspHeader.GetHeaderLength();
 224       const Int_t kpbusHLen = pbusHeader.GetHeaderLength();
 225
 226       UInt_t dspRDL = 0;
 227       UInt_t dspBlockHeaderWord[8];
 228       UInt_t dspHeaderWord[10];
 229       UInt_t patchBusHeaderWord[4];
 230       Int_t  iskip[5];
 231       UInt_t ddlEndWord[2] = {0xDEADFACE, 0xDEADFACE};
 232
 233       Int_t bknJunk = 0;
 234
 235
 236       for (Int_t iblock = 0; iblock < 2; iblock++)
 237         {
 238           // DSP Block Header
 239
 240           for (Int_t i=0; i<kblHLen; i++)
 241             {
 242               dspBlockHeaderWord[i] = 0;
 243             }
 244           if (iblock == 0)
 245             {
 246               dspBlockHeaderWord[1] = (UInt_t) (dspBlockARDL + kblHLen);
 247               dspBlockHeaderWord[2] = (UInt_t) dspBlockARDL;
 248             }
 249           else if (iblock == 1)
 250             {
 251               dspBlockHeaderWord[1] = (UInt_t) (dspBlockBRDL + kblHLen);
 252               dspBlockHeaderWord[2] = (UInt_t) dspBlockBRDL;
 253             }
 254
 255           outfile->WriteBuffer((char*)dspBlockHeaderWord,kblHLen*sizeof(UInt_t));
 256
 257           if (iblock == 0)
 258             {
 259               iskip[0] = 0;
 260               iskip[1] = 10;
 261               iskip[2] = 20;
 262               iskip[3] = 30;
 263               iskip[4] = 40;
 264             }
 265           else if (iblock == 1)
 266             {
 267               iskip[0] = 5;
 268               iskip[1] = 15;
 269               iskip[2] = 25;
 270               iskip[3] = 35;
 271               iskip[4] = 45;
 272             }
 273
 274           for (Int_t idsp = 0; idsp < 5; idsp++)
 275             {
 276               // DSP Header
 277               Int_t dspno = 0;
 278               if (iblock == 0)
 279                 {
 280                   dspno = 2*idsp;
 281                   dspRDL = (UInt_t) dsp[dspno];
 282                 }
 283               else if (iblock == 1)
 284                 {
 285                   dspno = 2*idsp + 1;
 286                   dspRDL = (UInt_t) dsp[dspno];
 287                 }
 288
 289               for (Int_t i=0; i<kdspHLen; i++)
 290                 {
 291                   dspHeaderWord[i] = 0;
 292                 }
 293               remainder = dspRDL%2;
 294               if (remainder == 1) dspRDL++;
 295
 296               dspHeaderWord[1] = dspRDL + kdspHLen;
 297               dspHeaderWord[2] = dspRDL;
 298               dspHeaderWord[3] = dspno;
 299               if (remainder == 1) dspHeaderWord[8] = 1; // setting the padding word
 300
 301
 302               outfile->WriteBuffer((char*)dspHeaderWord,kdspHLen*sizeof(UInt_t));
 303
 304               for (Int_t ibus = 0; ibus < 5; ibus++)
 305                 {
 306                   // Patch Bus Header
 307
 308                   Int_t busno = iskip[idsp] + ibus + 1;
 309                   Int_t patchbusRDL = contentsBus[busno];
 310
 311                   if (patchbusRDL > 0)
 312                     {
 313                       patchBusHeaderWord[0] = 0;
 314                       patchBusHeaderWord[1] = (UInt_t) (patchbusRDL + kpbusHLen);
 315                       patchBusHeaderWord[2] = (UInt_t) patchbusRDL;
 316                       patchBusHeaderWord[3] = (UInt_t) busno;
 317                     }
 318                   else if (patchbusRDL == 0)
 319                     {
 320                       patchBusHeaderWord[0] = 0;
 321                       patchBusHeaderWord[1] = (UInt_t) kpbusHLen;
 322                       patchBusHeaderWord[2] = (UInt_t) 0;
 323                       patchBusHeaderWord[3] = (UInt_t) busno;
 324                     }
 325
 326
 327                   outfile->WriteBuffer((char*)patchBusHeaderWord,4*sizeof(UInt_t));
 328
 329                   bknJunk += patchbusRDL;
 330
 331                   for (Int_t iword = 0; iword < patchbusRDL; iword++)
 332                     {
 333                       buffer[iword] = busPatch[busno][iword];
 334                     }
 335
 336                   outfile->WriteBuffer((char*)buffer,patchbusRDL*sizeof(UInt_t));
 337
 338                 } // End of patch bus loop
 339
 340
 341               // Adding a padding word if the total words odd
 342               if (remainder == 1)
 343                 {
 344                   UInt_t paddingWord = dspHeader.GetDefaultPaddingWord();
 345                   outfile->WriteBuffer((char*)(&paddingWord),sizeof(UInt_t));
 346                 }
 347             }
 348         }
 349
 350       // Write two extra word at the end of each DDL file
 351       outfile->WriteBuffer((char*)ddlEndWord,2*sizeof(UInt_t));
 352
 353       // Write real data header
 354       // take the pointer to the beginning of the data header
 355       // write the total number of words per ddl and bring the
 356       // pointer to the current file position and close it
 357       UInt_t cFPosition = outfile->Tellp();
 358       sizeRawData = cFPosition - bHPosition - sizeof(header);
 359
 360       header.fSize = cFPosition - bHPosition;
 361       header.SetAttribute(0);  // valid data
 362       outfile->Seekp(bHPosition);
 363       outfile->WriteBuffer((char*)(&header),sizeof(header));
 364       outfile->Seekp(cFPosition);
 365
 366       delete outfile;
 367     } // DDL Loop over
 368
 369   delete [] modulenoddl;
 370   infileddl.close();
 371 }
 372 //____________________________________________________________________________
 373 void AliPMDDDLRawData::GetUMDigitsData(TTree *treeD, Int_t imodule,
 374                                        Int_t ddlno, Int_t modulePerDDL,
 375                                        Int_t *contentsBus,
 376                                        UInt_t busPatch[][1536])
 377 {
 378   // Retrieves digits data UnitModule by UnitModule
 379
 380   const Int_t kMaxBus = 51;
 381
 382   UInt_t baseword = 0;
 383   UInt_t mcmno = 0, chno = 0;
 384   UInt_t adc = 0;
 385   Int_t  det = 0, smn = 0, irow = 0, icol = 0;
 386   Int_t  parity = 0;
 387
 388   Int_t totPatchBus = 0, bPatchBus = 0, ePatchBus = 0;
 389   Int_t ibus = 0, totmcm = 0, rows = 0, cols = 0, rowe = 0, cole = 0;
 390   Int_t moduleno = 0;
 391   Int_t busno = 0;
 392   Int_t patchBusNo[kMaxBus], mcmperBus[kMaxBus];
 393   Int_t startRowBus[kMaxBus], startColBus[kMaxBus];
 394   Int_t endRowBus[kMaxBus], endColBus[kMaxBus];
 395
 396   Int_t beginPatchBus = -1;
 397   Int_t endPatchBus   = -1;
 398   for(Int_t i = 0; i < kMaxBus; i++)
 399     {
 400       patchBusNo[i]  = -1;
 401       mcmperBus[i]   = -1;
 402       startRowBus[i] = -1;
 403       startColBus[i] = -1;
 404       endRowBus[i]   = -1;
 405       endColBus[i]   = -1;
 406     }
 407
 408
 409   TString fileName(gSystem->Getenv("ALICE_ROOT"));
 410
 411   if(ddlno == 0)
 412     {
 413       fileName += "/PMD/PMD_Mapping_ddl0.dat";
 414     }
 415   else if(ddlno == 1)
 416     {
 417       fileName += "/PMD/PMD_Mapping_ddl1.dat";
 418     }
 419   else if(ddlno == 2)
 420     {
 421       fileName += "/PMD/PMD_Mapping_ddl2.dat";
 422     }
 423   else if(ddlno == 3)
 424     {
 425       fileName += "/PMD/PMD_Mapping_ddl3.dat";
 426     }
 427   else if(ddlno == 4)
 428     {
 429       fileName += "/PMD/PMD_Mapping_ddl4.dat";
 430     }
 431   else if(ddlno == 5)
 432     {
 433       fileName += "/PMD/PMD_Mapping_ddl5.dat";
 434     }
 435
 436   ifstream infile;
 437   infile.open(fileName.Data(), ios::in); // ascii file
 438   if(!infile)
 439     AliError(Form("Could not read the mapping file for DDL No = %d",ddlno));
 440
 441   for (Int_t im = 0; im < modulePerDDL; im++)
 442     {
 443       infile >> moduleno;
 444       infile >> totPatchBus >> bPatchBus >> ePatchBus;
 445
 446       if (totPatchBus == 0) continue;    // BKN
 447
 448       if (moduleno == imodule)
 449         {
 450           beginPatchBus = bPatchBus;
 451           endPatchBus   = ePatchBus;
 452         }
 453
 454       for(Int_t i=0; i<totPatchBus; i++)
 455         {
 456           infile >> ibus >> totmcm >> rows >> rowe >> cols >> cole;
 457
 458           if (moduleno == imodule)
 459             {
 460               patchBusNo[ibus]   = ibus;
 461               mcmperBus[ibus]    = totmcm;
 462               startRowBus[ibus]  = rows;
 463               startColBus[ibus]  = cols;
 464               endRowBus[ibus]    = rowe;
 465               endColBus[ibus]    = cole;
 466             }
 467         }
 468
 469     }
 470
 471   infile.close();
 472
 473   // Read if some chains are off
 474   TString rchainName(gSystem->Getenv("ALICE_ROOT"));
 475   rchainName += "/PMD/PMD_removed_chains.dat";
 476
 477   ifstream rchainfile;
 478   rchainfile.open(rchainName.Data(), ios::in); // ascii file
 479   if(!rchainfile)AliError("Could not read the removed cahins file");
 480
 481   Int_t srowoff1[2][24], erowoff1[2][24];
 482   Int_t scoloff1[2][24], ecoloff1[2][24];
 483   Int_t srowoff2[2][24], erowoff2[2][24];
 484   Int_t scoloff2[2][24], ecoloff2[2][24];
 485
 486   Int_t rows1 = 0, rowe1 = 0, cols1 = 0, cole1 = 0;
 487   Int_t rows2 = 0, rowe2 = 0, cols2 = 0, cole2 = 0;
 488
 489   for (Int_t im = 0; im < 48; im++)
 490     {
 491       rchainfile >> det >> smn >> rows1 >> rowe1 >> cols1 >> cole1
 492                  >> rows2 >> rowe2 >> cols2 >> cole2;
 493
 494       srowoff1[det][smn] = rows1;
 495       erowoff1[det][smn] = rowe1;
 496       scoloff1[det][smn] = cols1;
 497       ecoloff1[det][smn] = cole1;
 498       srowoff2[det][smn] = rows2;
 499       erowoff2[det][smn] = rowe2;
 500       scoloff2[det][smn] = cols2;
 501       ecoloff2[det][smn] = cole2;
 502     }
 503
 504   rchainfile.close();
 505
 506   treeD->GetEntry(imodule);
 507   Int_t nentries = fDigits->GetLast();
 508   Int_t totword = nentries+1;
 509
 510   AliPMDdigit *pmddigit = 0x0;
 511
 512   for (Int_t ient = 0; ient < totword; ient++)
 513     {
 514       pmddigit = (AliPMDdigit*)fDigits->UncheckedAt(ient);
 515
 516       det    = pmddigit->GetDetector();
 517       smn    = pmddigit->GetSMNumber();
 518       irow   = pmddigit->GetRow();
 519       icol   = pmddigit->GetColumn();
 520       adc    = (UInt_t) pmddigit->GetADC();
 521
 522       TransformS2H(smn,irow,icol);
 523
 524       // remove the non-existence channels
 525
 526       //printf("%d %d %d %d\n",det,smn,irow,icol);
 527       //printf("--- %d   %d   %d   %d\n",srowoff[det][smn],erowoff[det][smn],
 528       //     scoloff[det][smn],ecoloff[det][smn]);
 529
 530       if (irow >= srowoff1[det][smn] && irow <= erowoff1[det][smn])
 531         {
 532           if (icol >= scoloff1[det][smn] && icol <= ecoloff1[det][smn])
 533             {
 534               continue;
 535             }
 536         }
 537       if (irow >= srowoff2[det][smn] && irow <= erowoff2[det][smn])
 538         {
 539           if (icol >= scoloff2[det][smn] && icol <= ecoloff2[det][smn])
 540             {
 541               continue;
 542             }
 543         }
 544
 545
 546       GetMCMCh(imodule, irow, icol, beginPatchBus, endPatchBus,
 547                mcmperBus, startRowBus, startColBus,
 548                endRowBus, endColBus, busno, mcmno, chno);
 549
 550       baseword = 0;
 551       AliBitPacking::PackWord(adc,baseword,0,11);
 552       AliBitPacking::PackWord(chno,baseword,12,17);
 553       AliBitPacking::PackWord(mcmno,baseword,18,28);
 554       AliBitPacking::PackWord(0,baseword,29,30);
 555       parity = ComputeParity(baseword);      // generate the parity bit
 556       AliBitPacking::PackWord(parity,baseword,31,31);
 557
 558       Int_t jj = contentsBus[busno];
 559       busPatch[busno][jj] = baseword;
 560
 561       contentsBus[busno]++;
 562     }
 563
 564 }
 565
 566 //____________________________________________________________________________
 567 void AliPMDDDLRawData::TransformS2H(Int_t smn, Int_t &irow, Int_t &icol)
 568 {
 569   // Does the Software to Hardware coordinate transformation
 570   //
 571
 572   Int_t  irownew = 0;
 573   Int_t  icolnew = 0;
 574
 575   // First in digits we have all dimension 48x96
 576   // Transform into the realistic one, i.e, For SM 0&1 96(row)x48(col)
 577   // and for SM 2&3 48(row)x96(col)
 578   //
 579   if(smn < 12)
 580     {
 581       irownew = icol;
 582       icolnew = irow;
 583     }
 584   else if( smn >= 12 && smn < 24)
 585     {
 586       irownew = irow;
 587       icolnew = icol;
 588     }
 589
 590   irow = irownew;
 591   icol = icolnew;
 592
 593 }
 594
 595
 596 //____________________________________________________________________________
 597
 598 void AliPMDDDLRawData::GetMCMCh(Int_t imodule, Int_t row, Int_t col,
 599                                 Int_t beginPatchBus, Int_t endPatchBus,
 600                                 Int_t *mcmperBus,
 601                                 Int_t *startRowBus, Int_t *startColBus,
 602                                 Int_t *endRowBus, Int_t *endColBus,
 603                                 Int_t & busno, UInt_t &mcmno, UInt_t &chno)
 604 {
 605   // This converts row col to hardware channel number
 606   // This is the final version of mapping supplied by Mriganka
 607
 608     UInt_t iCh[16][4];
 609
 610     static const UInt_t kChDdl01[16][4] = { {6, 4, 5, 7},
 611                                            {10, 2, 1, 9},
 612                                            {12, 0, 3, 11},
 613                                            {14, 8, 13, 15},
 614                                            {16, 18, 23, 17},
 615                                            {20, 28, 31, 19},
 616                                            {22, 30, 29, 21},
 617                                            {24, 26, 27, 25},
 618                                            {38, 36, 37, 39},
 619                                            {42, 34, 33, 41},
 620                                            {44, 32, 35, 43},
 621                                            {46, 40, 45, 47},
 622                                            {48, 50, 55, 49},
 623                                            {52, 60, 63, 51},
 624                                            {54, 62, 61, 53},
 625                                            {56, 58, 59, 57} };
 626
 627
 628     static const UInt_t kChDdl23[16][4] = { {57, 59, 58, 56},
 629                                             {53, 61, 62, 54},
 630                                             {51, 63, 60, 52},
 631                                             {49, 55, 50, 48},
 632                                             {47, 45, 40, 46},
 633                                             {43, 35, 32, 44},
 634                                             {41, 33, 34, 42},
 635                                             {39, 37, 36, 38},
 636                                             {25, 27, 26, 24},
 637                                             {21, 29, 30, 22},
 638                                             {19, 31, 28, 20},
 639                                             {17, 23, 18, 16},
 640                                             {15, 13, 8, 14},
 641                                             {11, 3, 0, 12},
 642                                             {9, 1, 2, 10},
 643                                             {7, 5, 4, 6} };
 644
 645
 646     static const UInt_t kChDdl41[16][4] = { {56, 58, 59, 57},
 647                                            {54, 62, 61, 53},
 648                                            {52, 60, 63, 51},
 649                                            {48, 50, 55, 49},
 650                                            {46, 40, 45, 47},
 651                                            {44, 32, 35, 43},
 652                                            {42, 34, 33, 41},
 653                                            {38, 36, 37, 39},
 654                                            {24, 26, 27, 25},
 655                                            {22, 30, 29, 21},
 656                                            {20, 28, 31, 19},
 657                                            {16, 18, 23, 17},
 658                                            {14, 8, 13, 15},
 659                                            {12, 0, 3, 11},
 660                                            {10, 2, 1, 9},
 661                                            {6, 4, 5, 7} };
 662
 663
 664     static const UInt_t kChDdl42[16][4] = { {7, 5, 4, 6},
 665                                             {9, 1, 2, 10},
 666                                             {11, 3, 0, 12},
 667                                             {15, 13, 8, 14},
 668                                             {17, 23, 18, 16},
 669                                             {19, 31, 28, 20},
 670                                             {21, 29, 30, 22},
 671                                             {25, 27, 26, 24},
 672                                             {39, 37, 36, 38},
 673                                             {41, 33, 34, 42},
 674                                             {43, 35, 32, 44},
 675                                             {47, 45, 40, 46},
 676                                             {49, 55, 50, 48},
 677                                             {51, 63, 60, 52},
 678                                             {53, 61, 62, 54},
 679                                             {57, 59, 58, 56} };
 680
 681
 682     static const UInt_t kChDdl51[16][4] = { {7, 5, 4, 6},
 683                                             {9, 1, 2, 10},
 684                                             {11, 3, 0, 12},
 685                                             {15, 13, 8, 14},
 686                                             {17, 23, 18, 16},
 687                                             {19, 31, 28, 20},
 688                                             {21, 29, 30, 22},
 689                                             {25, 27, 26, 24},
 690                                             {39, 37, 36, 38},
 691                                             {41, 33, 34, 42},
 692                                             {43, 35, 32, 44},
 693                                             {47, 45, 40, 46},
 694                                             {49, 55, 50, 48},
 695                                             {51, 63, 60, 52},
 696                                             {53, 61, 62, 54},
 697                                             {57, 59, 58, 56} };
 698
 699
 700
 701     static const UInt_t kChDdl52[16][4] = { {56, 58, 59, 57},
 702                                             {54, 62, 61, 53},
 703                                             {52, 60, 63, 51},
 704                                             {48, 50, 55, 49},
 705                                             {46, 40, 45, 47},
 706                                             {44, 32, 35, 43},
 707                                             {42, 34, 33, 41},
 708                                             {38, 36, 37, 39},
 709                                             {24, 26, 27, 25},
 710                                             {22, 30, 29, 21},
 711                                             {20, 28, 31, 19},
 712                                             {16, 18, 23, 17},
 713                                             {14, 8, 13, 15},
 714                                             {12, 0, 3, 11},
 715                                             {10, 2, 1, 9},
 716                                             {6, 4, 5, 7} };
 717
 718
 719     for (Int_t i = 0; i < 16; i++)
 720       {
 721         for (Int_t j = 0; j < 4; j++)
 722           {
 723
 724             if(imodule < 6)                    iCh[i][j] = kChDdl01[i][j];
 725             if(imodule >= 6 && imodule <= 11)  iCh[i][j] = kChDdl01[i][j];
 726             if(imodule >= 12 && imodule <= 17) iCh[i][j] = kChDdl23[i][j];
 727             if(imodule >= 18 && imodule <= 23) iCh[i][j] = kChDdl23[i][j];
 728
 729             if(imodule >= 24 && imodule <= 29) iCh[i][j] = kChDdl41[i][j];
 730             if(imodule >= 42 && imodule <= 47) iCh[i][j] = kChDdl42[i][j];
 731             if(imodule >= 36 && imodule <= 41) iCh[i][j] = kChDdl51[i][j];
 732             if(imodule >= 30 && imodule <= 35) iCh[i][j] = kChDdl52[i][j];
 733
 734           }
 735       }
 736
 737
 738   Int_t irownew = row%16;
 739   Int_t icolnew = col%4;
 740
 741   chno  = iCh[irownew][icolnew];
 742
 743
 744   for (Int_t ibus = beginPatchBus; ibus <= endPatchBus; ibus++)
 745     {
 746       Int_t srow = startRowBus[ibus];
 747       Int_t erow = endRowBus[ibus];
 748       Int_t scol = startColBus[ibus];
 749       Int_t ecol = endColBus[ibus];
 750       Int_t tmcm = mcmperBus[ibus];
 751
 752       if ((row >= srow && row <= erow) && (col >= scol && col <= ecol))
 753         {
 754           busno = ibus;
 755
 756           // Find out the MCM Number
 757           //
 758
 759           if (imodule < 6)                  mcmno = (col-scol)/4 + 1;
 760           if (imodule >= 6 && imodule < 12) mcmno = (col-scol)/4 + 1;
 761
 762           if (imodule >= 12 && imodule < 18)
 763             {
 764               icolnew = (col - scol)/4;
 765               mcmno = tmcm - icolnew;
 766             }
 767           if (imodule >= 18 && imodule < 24)
 768             {
 769               icolnew = (col - scol)/4;
 770               mcmno = tmcm - icolnew;
 771             }
 772
 773           // DDL = 4
 774           if (imodule >= 24 && imodule < 30)
 775             {
 776
 777               //if (tmcm == 24)
 778               Int_t rowdiff = endRowBus[ibus] - startRowBus[ibus];
 779               if(rowdiff > 16)
 780                 {
 781                   Int_t midrow = srow + 16;
 782                   if(row >= srow && row < midrow)
 783                     {
 784                       mcmno = 12 + (col-scol)/4 + 1;
 785                     }
 786                   else if(row >= midrow && row <= erow)
 787
 788                     {
 789                       mcmno = (col-scol)/4 + 1;
 790                     }
 791                 }
 792               else if (rowdiff < 16)
 793                 {
 794                   mcmno = (col-scol)/4 + 1;
 795                 }
 796
 797             }
 798           if (imodule >= 42 && imodule < 48)
 799             {
 800               Int_t rowdiff = endRowBus[ibus] - startRowBus[ibus];
 801               if(rowdiff > 16)
 802                 {
 803                   Int_t midrow = srow + 16;
 804                   if (row >= midrow && row <= erow)
 805                     {
 806                       mcmno = 12 + (ecol -col)/4 + 1;
 807                     }
 808                   else if (row >= srow && row < midrow)
 809                     {
 810                       mcmno = (ecol - col)/4 + 1;
 811                     }
 812                 }
 813               else if (rowdiff < 16)
 814                 {
 815                   mcmno = (ecol - col)/4 + 1;
 816                 }
 817             }
 818
 819           // DDL = 5
 820           if (imodule >= 30 && imodule < 36)
 821             {
 822               // CPV plane,  SU Mod = 1, 2 : ddl = 5
 823
 824               //if(tmcm == 24)
 825               Int_t rowdiff = endRowBus[ibus] - startRowBus[ibus];
 826               if(rowdiff > 16)
 827                 {
 828                   Int_t midrow = srow + 16;
 829                   if(row >= srow && row < midrow)
 830                     {
 831                       mcmno = 12 + (col-scol)/4 + 1;
 832                     }
 833                   else if(row >= midrow && row <= erow)
 834                     {
 835                       mcmno = (col-scol)/4 + 1;
 836                     }
 837                 }
 838               else if(rowdiff < 16)
 839                 {
 840                   mcmno = (col-scol)/4 + 1;
 841                 }
 842
 843             }
 844           if (imodule >= 36 && imodule < 42)
 845             {
 846               Int_t rowdiff = endRowBus[ibus] - startRowBus[ibus];
 847               if(rowdiff > 16)
 848                 {
 849                   Int_t midrow = srow + 16;
 850                   if (row >= midrow && row <= erow)
 851                     {
 852                       mcmno = 12 + (ecol - col)/4 + 1;
 853                     }
 854                   else if (row >= srow && row < midrow)
 855                     {
 856                       mcmno = (ecol - col)/4 + 1;
 857                     }
 858                 }
 859               else if (rowdiff < 16)
 860                 {
 861                   mcmno = (ecol - col)/4 + 1;
 862                 }
 863             }
 864
 865         }
 866     }
 867 }
 868
 869 //____________________________________________________________________________
 870
 871 Int_t AliPMDDDLRawData::ComputeParity(UInt_t baseword)
 872 {
 873   // Generate the parity bit
 874
 875   Int_t count = 0;
 876   for(Int_t j=0; j<29; j++)
 877     {
 878       if (baseword & 0x01 ) count++;
 879       baseword >>= 1;
 880     }
 881   Int_t parity = count%2;
 882   return parity;
 883 }
 884
 885 //____________________________________________________________________________