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 "AliRawDataHeader.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
  35 ClassImp(AliPMDDDLRawData)
  36
  37 AliPMDDDLRawData::AliPMDDDLRawData():
  38   fDigits(new TClonesArray("AliPMDdigit", 1000))
  39 {
  40   // Default Constructor
  41   //
  42
  43 }
  44 //____________________________________________________________________________
  45 AliPMDDDLRawData::AliPMDDDLRawData(const AliPMDDDLRawData& ddlraw):
  46   TObject(ddlraw),
  47   fDigits(ddlraw.fDigits)
  48 {
  49   //Copy Constructor
  50 }
  51 //____________________________________________________________________________
  52 AliPMDDDLRawData & AliPMDDDLRawData::operator=(const AliPMDDDLRawData& ddlraw)
  53 {
  54   //Assignment operator
  55   if(this != &ddlraw)
  56     {
  57       fDigits = ddlraw.fDigits;
  58     }
  59   return *this;
  60 }
  61 //____________________________________________________________________________
  62
  63 AliPMDDDLRawData::~AliPMDDDLRawData()
  64 {
  65   // Default Destructor
  66   //
  67
  68 }
  69
  70 //____________________________________________________________________________
  71 void AliPMDDDLRawData::WritePMDRawData(TTree *treeD)
  72 {
  73   // write digits into raw data format
  74
  75   ofstream outfile;
  76
  77   TBranch *branch = treeD->GetBranch("PMDDigit");
  78   if (!branch)
  79     {
  80       AliError("PMD Digit branch not found");
  81       return;
  82     }
  83   branch->SetAddress(&fDigits);
  84
  85   Int_t   nmodules = (Int_t) treeD->GetEntries();
  86   AliDebug(1,Form("Number of modules inside treeD = %d",nmodules));
  87
  88   const Int_t kDDL          = AliDAQ::NumberOfDdls("PMD");
  89   Int_t modulePerDDL        = 0;
  90
  91
  92   AliRawDataHeader header;
  93   UInt_t sizeRawData = 0;
  94
  95   const Int_t kSize = 1536;
  96   UInt_t buffer[kSize];
  97
  98   UInt_t busPatch[50][1536];
  99
 100   Int_t contentsBus[50];
 101
 102   Char_t filename[80];
 103
 104
 105   Int_t mmodule = 0;
 106   for(Int_t iddl = 0; iddl < kDDL; iddl++)
 107     {
 108       strcpy(filename,AliDAQ::DdlFileName("PMD",iddl));
 109 #ifndef __DECCXX
 110       outfile.open(filename,ios::binary);
 111 #else
 112       outfile.open(filename);
 113 #endif
 114
 115       if (iddl < 4)
 116         {
 117           modulePerDDL = 6;
 118           mmodule = 6*iddl;
 119         }
 120       else if (iddl == 4)
 121         {
 122           modulePerDDL = 12;
 123           mmodule = 24;
 124         }
 125       else if (iddl == 5)
 126         {
 127           modulePerDDL = 12;
 128           mmodule = 30;
 129         }
 130
 131
 132
 133       // Write the Dummy Data Header into the file
 134       Int_t bHPosition = outfile.tellp();
 135       outfile.write((char*)(&header),sizeof(header));
 136
 137       for (Int_t ibus = 0; ibus < 50; ibus++)
 138         {
 139           contentsBus[ibus] = 0;
 140           for (Int_t ich = 0; ich < 1536; ich++)
 141             {
 142               busPatch[ibus][ich] = 0;
 143             }
 144         }
 145
 146       for(Int_t ium = 0; ium < modulePerDDL; ium++)
 147         {
 148           if (iddl == 4 && ium == 6) mmodule = 42;
 149
 150           // Extract energy deposition per cell and pack it
 151           // in a 32-bit word and returns all the total words
 152           // per one unit-module
 153
 154           GetUMDigitsData(treeD, mmodule, iddl, contentsBus, busPatch);
 155           mmodule++;
 156         }
 157
 158
 159
 160       Int_t ij = 0;
 161       Int_t dsp[10];
 162       Int_t dspBus[10];
 163       for (Int_t i = 0; i < 10; i++)
 164         {
 165           dsp[i] = 0;
 166           dspBus[i] = 0;
 167           for (Int_t ibus=0; ibus < 5; ibus++)
 168             {
 169               if (contentsBus[ij] > 0)
 170                 {
 171                   dsp[i] += contentsBus[ij];
 172                   dspBus[i]++;
 173                 }
 174               ij++;
 175             }
 176           // Add the patch Bus header to the DSP contents
 177           dsp[i] += 4*dspBus[i];
 178         }
 179
 180       Int_t dspBlockARDL    = 0;
 181       Int_t dspBlockBRDL    = 0;
 182
 183       for (Int_t i = 0; i < 5; i++)
 184         {
 185           Int_t ieven = 2*i;
 186           Int_t iodd  = 2*i + 1;
 187           if (dsp[ieven] > 0)
 188             {
 189               dspBlockARDL += dsp[ieven];
 190               Int_t remainder = dsp[ieven]%2;
 191               if (remainder == 1)
 192                 {
 193                   dspBlockARDL++;
 194                 }
 195             }
 196           if (dsp[iodd] > 0)
 197             {
 198               dspBlockBRDL += dsp[iodd];
 199               Int_t remainder = dsp[ieven]%2;
 200               if (remainder == 1)
 201                 {
 202                   dspBlockARDL++;
 203                 }
 204             }
 205         }
 206
 207       // Start writing the DDL file
 208
 209       AliPMDBlockHeader blHeader;
 210       AliPMDDspHeader   dspHeader;
 211       AliPMDPatchBusHeader pbusHeader;
 212
 213       const Int_t kblHLen   = blHeader.GetHeaderLength();
 214       const Int_t kdspHLen  = dspHeader.GetHeaderLength();
 215       const Int_t kpbusHLen = pbusHeader.GetHeaderLength();
 216
 217       UInt_t dspRDL = 0;
 218       UInt_t dspBlockHeaderWord[8];
 219       UInt_t dspHeaderWord[10];
 220       UInt_t patchBusHeaderWord[4];
 221       Int_t iskip[5];
 222
 223
 224       for (Int_t iblock = 0; iblock < 2; iblock++)
 225         {
 226           // DSP Block Header
 227
 228           for (Int_t i=0; i<kblHLen; i++)
 229             {
 230               dspBlockHeaderWord[i] = 0;
 231             }
 232           if (iblock == 0)
 233             {
 234               dspBlockHeaderWord[1] = (UInt_t) (dspBlockARDL + kblHLen);
 235               dspBlockHeaderWord[2] = (UInt_t) dspBlockARDL;
 236             }
 237           else if (iblock == 1)
 238             {
 239               dspBlockHeaderWord[1] = (UInt_t) (dspBlockBRDL + kblHLen);
 240               dspBlockHeaderWord[2] = (UInt_t) dspBlockBRDL;
 241             }
 242
 243           outfile.write((char*)dspBlockHeaderWord,kblHLen*sizeof(UInt_t));
 244
 245           if (iblock == 0)
 246             {
 247               iskip[0] = 0;
 248               iskip[1] = 10;
 249               iskip[2] = 20;
 250               iskip[3] = 30;
 251               iskip[4] = 40;
 252             }
 253           else if (iblock == 1)
 254             {
 255               iskip[0] = 5;
 256               iskip[1] = 15;
 257               iskip[2] = 25;
 258               iskip[3] = 35;
 259               iskip[4] = 45;
 260             }
 261
 262           for (Int_t idsp = 0; idsp < 5; idsp++)
 263             {
 264               // DSP Header
 265               Int_t dspno = 0;
 266               if (iblock == 0)
 267                 {
 268                   dspno = 2*idsp;
 269                   dspRDL = (UInt_t) dsp[dspno];
 270                 }
 271               else if (iblock == 1)
 272                 {
 273                   dspno = 2*idsp + 1;
 274                   dspRDL = (UInt_t) dsp[dspno];
 275                 }
 276
 277               for (Int_t i=0; i<kdspHLen; i++)
 278                 {
 279                   dspHeaderWord[i] = 0;
 280                 }
 281               Int_t remainder = dspRDL%2;
 282               if (remainder == 1) dspRDL++;
 283
 284               dspHeaderWord[1] = dspRDL + kdspHLen;
 285               dspHeaderWord[2] = dspRDL;
 286               dspHeaderWord[3] = dspno;
 287               if (remainder == 1) dspHeaderWord[8] = 1; // setting the padding word
 288               outfile.write((char*)dspHeaderWord,kdspHLen*sizeof(UInt_t));
 289
 290               for (Int_t ibus = 0; ibus < 5; ibus++)
 291                 {
 292                   // Patch Bus Header
 293                   Int_t busno = iskip[idsp] + ibus;
 294                   Int_t patchbusRDL = contentsBus[busno];
 295
 296                   if (patchbusRDL > 0)
 297                     {
 298                       patchBusHeaderWord[0] = 0;
 299                       patchBusHeaderWord[1] = (UInt_t) (patchbusRDL + kpbusHLen);
 300                       patchBusHeaderWord[2] = (UInt_t) patchbusRDL;
 301                       patchBusHeaderWord[3] = (UInt_t) busno;
 302                     }
 303                   else if (patchbusRDL == 0)
 304                     {
 305                       patchBusHeaderWord[0] = 0;
 306                       patchBusHeaderWord[1] = (UInt_t) kpbusHLen;
 307                       patchBusHeaderWord[2] = (UInt_t) 0;
 308                       patchBusHeaderWord[3] = (UInt_t) busno;
 309                     }
 310
 311
 312                   outfile.write((char*)patchBusHeaderWord,4*sizeof(UInt_t));
 313
 314
 315                   for (Int_t iword = 0; iword < patchbusRDL; iword++)
 316                     {
 317                       buffer[iword] = busPatch[busno][iword];
 318                     }
 319
 320                   outfile.write((char*)buffer,patchbusRDL*sizeof(UInt_t));
 321
 322                 } // End of patch bus loop
 323
 324
 325               // Adding a padding word if the total words odd
 326               if (remainder == 1)
 327                 {
 328                   UInt_t paddingWord = dspHeader.GetDefaultPaddingWord();
 329                   outfile.write((char*)(&paddingWord),sizeof(UInt_t));
 330                 }
 331             }
 332         }
 333
 334       // Write real data header
 335       // take the pointer to the beginning of the data header
 336       // write the total number of words per ddl and bring the
 337       // pointer to the current file position and close it
 338       UInt_t cFPosition = outfile.tellp();
 339       sizeRawData = cFPosition - bHPosition - sizeof(header);
 340
 341       header.fSize = cFPosition - bHPosition;
 342       header.SetAttribute(0);  // valid data
 343       outfile.seekp(bHPosition);
 344       outfile.write((char*)(&header),sizeof(header));
 345       outfile.seekp(cFPosition);
 346
 347       outfile.close();
 348     } // DDL Loop over
 349
 350
 351 }
 352 //____________________________________________________________________________
 353 void AliPMDDDLRawData::GetUMDigitsData(TTree *treeD, Int_t imodule,
 354                                        Int_t ddlno, Int_t *contentsBus,
 355                                        UInt_t busPatch[][1536])
 356 {
 357   // Retrives digits data UnitModule by UnitModule
 358
 359   UInt_t baseword;
 360   UInt_t mcmno, chno;
 361   UInt_t adc;
 362   Int_t  det, smn, irow, icol;
 363   Int_t  parity;
 364
 365   const Int_t kMaxBus = 50;
 366   Int_t totPatchBus, bPatchBus, ePatchBus;
 367   Int_t ibus, totmcm, rows, cols, rowe, cole;
 368   Int_t moduleno;
 369   Int_t busno = 0;
 370   Int_t patchBusNo[kMaxBus], mcmperBus[kMaxBus];
 371   Int_t startRowBus[kMaxBus], startColBus[kMaxBus];
 372   Int_t endRowBus[kMaxBus], endColBus[kMaxBus];
 373
 374   Int_t beginPatchBus = -1;
 375   Int_t endPatchBus   = -1;
 376   for(Int_t i = 0; i < kMaxBus; i++)
 377     {
 378       patchBusNo[i]  = -1;
 379       mcmperBus[i]   = -1;
 380       startRowBus[i] = -1;
 381       startColBus[i] = -1;
 382       endRowBus[i]   = -1;
 383       endColBus[i]   = -1;
 384     }
 385   Int_t modulePerDDL = 0;
 386   if (ddlno < 4)
 387     {
 388       modulePerDDL = 6;
 389     }
 390   else if (ddlno == 4 || ddlno == 5)
 391     {
 392       modulePerDDL = 12;
 393     }
 394
 395   TString fileName(gSystem->Getenv("ALICE_ROOT"));
 396
 397   if(ddlno == 0)
 398     {
 399       fileName += "/PMD/PMD_Mapping_ddl0.dat";
 400     }
 401   else if(ddlno == 1)
 402     {
 403       fileName += "/PMD/PMD_Mapping_ddl1.dat";
 404     }
 405   else if(ddlno == 2)
 406     {
 407       fileName += "/PMD/PMD_Mapping_ddl2.dat";
 408     }
 409   else if(ddlno == 3)
 410     {
 411       fileName += "/PMD/PMD_Mapping_ddl3.dat";
 412     }
 413   else if(ddlno == 4)
 414     {
 415       fileName += "/PMD/PMD_Mapping_ddl4.dat";
 416     }
 417   else if(ddlno == 5)
 418     {
 419       fileName += "/PMD/PMD_Mapping_ddl5.dat";
 420     }
 421
 422   ifstream infile;
 423   infile.open(fileName.Data(), ios::in); // ascii file
 424   if(!infile)
 425     AliError(Form("Could not read the mapping file for DDL No = %d",ddlno));
 426
 427   for (Int_t im = 0; im < modulePerDDL; im++)
 428     {
 429       infile >> moduleno;
 430       infile >> totPatchBus >> bPatchBus >> ePatchBus;
 431
 432       if (moduleno == imodule)
 433         {
 434           beginPatchBus = bPatchBus;
 435           endPatchBus   = ePatchBus;
 436         }
 437
 438       for(Int_t i=0; i<totPatchBus; i++)
 439         {
 440           infile >> ibus >> totmcm >> rows >> rowe >> cols >> cole;
 441
 442           if (moduleno == imodule)
 443             {
 444               patchBusNo[ibus]   = ibus;
 445               mcmperBus[ibus]    = totmcm;
 446               startRowBus[ibus]  = rows;
 447               startColBus[ibus]  = cols;
 448               endRowBus[ibus]    = rowe;
 449               endColBus[ibus]    = cole;
 450             }
 451         }
 452
 453     }
 454
 455   infile.close();
 456
 457   treeD->GetEntry(imodule);
 458   Int_t nentries = fDigits->GetLast();
 459   Int_t totword = nentries+1;
 460
 461   AliPMDdigit *pmddigit;
 462
 463   for (Int_t ient = 0; ient < totword; ient++)
 464     {
 465       pmddigit = (AliPMDdigit*)fDigits->UncheckedAt(ient);
 466
 467       det    = pmddigit->GetDetector();
 468       smn    = pmddigit->GetSMNumber();
 469       irow   = pmddigit->GetRow();
 470       icol   = pmddigit->GetColumn();
 471       adc    = (UInt_t) pmddigit->GetADC();
 472
 473       TransformS2H(smn,irow,icol);
 474
 475       GetMCMCh(ddlno, irow, icol, beginPatchBus, endPatchBus,
 476                mcmperBus, startRowBus, startColBus,
 477                endRowBus, endColBus, busno, mcmno, chno);
 478
 479       baseword = 0;
 480       AliBitPacking::PackWord(adc,baseword,0,11);
 481       AliBitPacking::PackWord(chno,baseword,12,17);
 482       AliBitPacking::PackWord(mcmno,baseword,18,28);
 483       AliBitPacking::PackWord(0,baseword,29,30);
 484       parity = ComputeParity(baseword);      // generate the parity bit
 485       AliBitPacking::PackWord(parity,baseword,31,31);
 486
 487       Int_t jj = contentsBus[busno];
 488       busPatch[busno][jj] = baseword;
 489
 490       contentsBus[busno]++;
 491     }
 492
 493 }
 494
 495 //____________________________________________________________________________
 496 void AliPMDDDLRawData::TransformS2H(Int_t smn, Int_t &irow, Int_t &icol)
 497 {
 498   // Does the Software to Hardware coordinate transformation
 499   //
 500
 501   Int_t  irownew = 0;
 502   Int_t  icolnew = 0;
 503
 504   // First in digits we have all dimension 48x96
 505   // Transform into the realistic one, i.e, For SM 0&1 96(row)x48(col)
 506   // and for SM 2&3 48(row)x96(col)
 507   //
 508   if(smn < 12)
 509     {
 510       irownew = icol;
 511       icolnew = irow;
 512     }
 513   else if( smn >= 12 && smn < 24)
 514     {
 515       irownew = irow;
 516       icolnew = icol;
 517     }
 518
 519   irow = irownew;
 520   icol = icolnew;
 521
 522 }
 523
 524
 525 //____________________________________________________________________________
 526
 527 void AliPMDDDLRawData::GetMCMCh(Int_t ddlno, Int_t row, Int_t col,
 528                                 Int_t beginPatchBus, Int_t endPatchBus,
 529                                 Int_t *mcmperBus,
 530                                 Int_t *startRowBus, Int_t *startColBus,
 531                                 Int_t *endRowBus, Int_t *endColBus,
 532                                 Int_t & busno, UInt_t &mcmno, UInt_t &chno)
 533 {
 534   // This converts row col to hardware channel number
 535   // This is the final version of mapping supplied by Mriganka
 536
 537   static const UInt_t kCh[16][4] = { {56, 58, 59, 57},
 538                                      {54, 62, 61, 53},
 539                                      {52, 60, 63, 51},
 540                                      {48, 50, 55, 49},
 541                                      {46, 40, 45, 47},
 542                                      {44, 32, 35, 43},
 543                                      {42, 34, 33, 41},
 544                                      {38, 36, 37, 39},
 545                                      {24, 26, 27, 25},
 546                                      {22, 30, 29, 21},
 547                                      {20, 28, 31, 19},
 548                                      {16, 18, 23, 17},
 549                                      {14, 8, 13, 15},
 550                                      {12, 0, 3, 11},
 551                                      {10, 2, 1, 9},
 552                                      {6, 4, 5, 7} };
 553
 554   Int_t irownew = row%16;
 555   Int_t icolnew = col%4;
 556
 557   chno  = kCh[irownew][icolnew];
 558
 559
 560   for (Int_t ibus = beginPatchBus; ibus <= endPatchBus; ibus++)
 561     {
 562       Int_t srow = startRowBus[ibus];
 563       Int_t erow = endRowBus[ibus];
 564       Int_t scol = startColBus[ibus];
 565       Int_t ecol = endColBus[ibus];
 566       Int_t tmcm = mcmperBus[ibus];
 567       if ((row >= srow && row <= erow) && (col >= scol && col <= ecol))
 568         {
 569           busno = ibus;
 570
 571           // Find out the MCM Number
 572           //
 573
 574           if (ddlno == 0 || ddlno == 1)
 575             {
 576               // PRE plane, SU Mod = 0, 1
 577               mcmno = (col-scol)/4;
 578
 579             }
 580           else if (ddlno == 2 || ddlno == 3)
 581             {
 582               // PRE plane,  SU Mod = 2, 3
 583               Int_t icolnew = (col - scol)/4;
 584               mcmno = tmcm - 1 - icolnew;
 585             }
 586           else if (ddlno == 4 )
 587             {
 588               // CPV plane,  SU Mod = 0, 3 : ddl = 4
 589
 590               if(ibus <= 17)
 591                 {
 592                   Int_t midrow = srow + 16;
 593                   if(row >= srow && row < midrow)
 594                     {
 595                       mcmno = 12 + (col-scol)/4;
 596                     }
 597                   else if(row >= midrow && row <= erow)
 598
 599                     {
 600                       mcmno = (col-scol)/4;
 601                     }
 602                 }
 603
 604               else if (ibus > 17)
 605                 {
 606                   Int_t rowdiff = endRowBus[ibus] - startRowBus[ibus];
 607                   if(rowdiff > 16)
 608                     {
 609                       Int_t midrow = srow + 16;
 610                       if (row >= midrow && row <= erow)
 611                         {
 612                           mcmno = 12 + (ecol -col)/4;
 613                         }
 614                       else if (row >= srow && row < midrow)
 615                         {
 616                           mcmno = (ecol - col)/4;
 617                         }
 618                     }
 619                   else if (rowdiff < 16)
 620                     {
 621                       mcmno = (ecol - col)/4;
 622                     }
 623                 }
 624             }
 625           else if ( ddlno == 5)
 626             {
 627               // CPV plane,  SU Mod = 0, 3 : ddl = 4
 628
 629               if(ibus <= 17)
 630                 {
 631                   Int_t midrow = srow + 16;
 632                   if(row >= srow && row < midrow)
 633                     {
 634                       mcmno = 12 + (col-scol)/4;
 635                     }
 636                   else if(row >= midrow && row <= erow)
 637                     {
 638                       mcmno = (col-scol)/4;
 639                     }
 640                 }
 641
 642               else if (ibus > 17)
 643                 {
 644                   Int_t rowdiff = endRowBus[ibus] - startRowBus[ibus];
 645                   if(rowdiff > 16)
 646                     {
 647                       Int_t midrow = srow + 16;
 648                       if (row >= midrow && row <= erow)
 649                         {
 650                           mcmno = 12 + (ecol -col)/4;
 651                         }
 652                       else if (row >= srow && row < midrow)
 653                         {
 654                           mcmno = (ecol - col)/4;
 655                         }
 656                     }
 657                   else if (rowdiff < 16)
 658                     {
 659                       mcmno = (ecol - col)/4;
 660                     }
 661                 }
 662             }
 663         }
 664     }
 665 }
 666
 667 //____________________________________________________________________________
 668
 669 Int_t AliPMDDDLRawData::ComputeParity(UInt_t baseword)
 670 {
 671   // Generate the parity bit
 672
 673   Int_t count = 0;
 674   for(Int_t j=0; j<29; j++)
 675     {
 676       if (baseword & 0x01 ) count++;
 677       baseword >>= 1;
 678     }
 679   Int_t parity = count%2;
 680   return parity;
 681 }
 682
 683 //____________________________________________________________________________