T0/AliT0RawData.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 //  T0 raw data conversion class                                            //
  21 //                                                                           //
  22 ///////////////////////////////////////////////////////////////////////////////
  23
  24 #include <Riostream.h>
  25 #include <TTree.h>
  26
  27 #include "AliT0.h"
  28 #include "AliT0RawData.h"
  29 #include "AliT0digit.h"
  30 #include "AliBitPacking.h"
  31 #include "AliRawDataHeader.h"
  32 #include "AliRawDataHeaderSim.h"
  33 #include "AliBitPacking.h"
  34 #include "AliFstream.h"
  35 #include "AliRunLoader.h"
  36 #include "AliDAQ.h"
  37
  38 ClassImp(AliT0RawData)
  39
  40 //_____________________________________________________________________________
  41   AliT0RawData::AliT0RawData():TObject(),
  42  fVerbose(0),
  43  fIndex(-1) ,
  44  fEventNumber(0),
  45  fTimeCFD(new TArrayI(24)),
  46  fADC1( new TArrayI(24)),
  47  fTimeLED( new TArrayI(24)),
  48  fADC0( new TArrayI(24)),
  49  fFile(0x0),
  50  fDataHeaderPos(0),
  51  fDRMDataHeaderPos(0),
  52  fTRMDataHeaderPos(0),
  53  fDigits(0)
  54
  55 {
  56   /*
  57 -  48 channels (2 words each as in TOF DDL) for :
  58 word 1 :0-5bit number of PMT; word 2: 0-7 error sign, 8-31 TDC
  59 and the same but for amplified signal. Now I wrote the same time because
  60 CDF are not ready and differences didn't measured yet.
  61
  62 -  48 channel for amplitude: very preliminary, QTC features are not
  63 known now, preliminary i put as T1 time signal for this PMT in first
  64 channel and T1+A in second, where A=Log(Amplitude);
  65 and the same for amplified but A=Log(10*Amplitude).
  66
  67 - T0-A and T0-C 2 channels
  68 - T0A-T0C vertex information
  69 - Time Meaner where T0C TOF increase to the T0A TOF distance
  70 - 6 multiplicity signals the same way as amplitude and with the same
  71 uncertances
  72   */
  73
  74   //open the output file
  75   char fileName[15];
  76   strcpy(fileName,AliDAQ::DdlFileName("T0",0)); //The name of the output file
  77   fFile = new AliFstream(fileName);
  78   memset(fBuffer,0,512*sizeof(UInt_t));
  79
  80   //get event number
  81   AliRunLoader *runloader = AliRunLoader::GetRunLoader();
  82   if (runloader) {
  83     fEventNumber = runloader->GetEventNumber();
  84   }
  85 }
  86
  87 //_____________________________________________________________________________
  88
  89 AliT0RawData::AliT0RawData(const AliT0RawData &r):TObject(),
  90  fVerbose(0),
  91  fIndex(-1) ,
  92  fEventNumber(0),
  93  fTimeCFD(new TArrayI(24)),
  94  fADC1( new TArrayI(24)),
  95  fTimeLED( new TArrayI(24)),
  96  fADC0( new TArrayI(24)),
  97  fFile(0x0),
  98  fDataHeaderPos(0),
  99  fDRMDataHeaderPos(0),
 100  fTRMDataHeaderPos(0),
 101  fDigits(0)
 102
 103 {
 104   //
 105   // AliT0rawData copy constructor
 106   //
 107
 108   ((AliT0RawData &) r).Copy(*this);
 109
 110 }
 111
 112 //_____________________________________________________________________________
 113 AliT0RawData::~AliT0RawData()
 114 {
 115   //
 116   // Destructor
 117   //
 118   if (fDigits) {
 119     delete fDigits;
 120     fDigits = NULL;
 121   }
 122   delete fTimeCFD;
 123   delete fADC1;
 124   delete fTimeLED;
 125   delete fADC0;
 126 }
 127
 128 //_____________________________________________________________________________
 129 AliT0RawData &AliT0RawData::operator=(const AliT0RawData &r)
 130 {
 131   //
 132   // Assignment operator
 133   //
 134
 135   if (this != &r) ((AliT0RawData &) r).Copy(*this);
 136   return *this;
 137
 138 }
 139
 140 //_____________________________________________________________________________
 141 void AliT0RawData::GetDigits(AliT0digit *fDigits)
 142 {
 143
 144   //This method packs the T0 digits in a proper 32 bits structure
 145
 146   //read T0 digits and fill TDC and ADC arrays
 147
 148
 149   //  Int_t error=0;
 150   Int_t time,  positionOfTRMHeader;
 151
 152   // Get the digits array
 153
 154   fDigits->GetTimeCFD(*fTimeCFD);
 155   fDigits->GetQT0(*fADC1);
 156   fDigits->GetTimeLED(*fTimeLED);
 157   fDigits->GetQT1(*fADC0);
 158   Int_t meantime = fDigits->MeanTime();
 159   Int_t timediff = fDigits->TimeDiff();
 160   Int_t mult0=fDigits->SumMult();
 161   Int_t mult1=fDigits->SumMult();
 162   Int_t timeA = fDigits->BestTimeC();
 163   Int_t timeC = fDigits->BestTimeA();
 164
 165
 166   TArrayI  *allData = new TArrayI(110);
 167   Int_t i=0;
 168   allData->AddAt(0,0);
 169   for (i=1; i<25; i++) {
 170     allData->AddAt(fTimeLED->At(i-1),i);
 171     allData->AddAt(fTimeCFD->At(i-1),i+24);
 172     allData->AddAt(fADC0->At(i-1),i+54);
 173     allData->AddAt(fADC1->At(i-1),i+78);
 174     //    cout<<i<<" led "<<fTimeLED->At(i-1)<<" cfd "<<fTimeCFD->At(i-1)<<" qt0 "<<fADC0->At(i-1)<<" qt1 "<<fADC1->At(i-1)<<endl;
 175   }
 176   allData->AddAt(meantime,49);
 177   allData->AddAt(timediff,50);
 178   allData->AddAt(timediff,103); //trigger vertex
 179   allData->AddAt(timeA,51);
 180   allData->AddAt(timeA,104); //trigger T0A
 181   allData->AddAt(timeC,52);
 182   allData->AddAt(timeC,105); //trigger T0C
 183   allData->AddAt(mult0,53);
 184   allData->AddAt(mult1,106); //trigger central
 185   allData->AddAt(mult1,54);
 186   allData->AddAt(mult1,107); //trigger semi-central
 187
 188   // cout<<" new Event "<<endl;
 189   //   for (Int_t ia=0; ia<110; ia++) cout<<ia<<" "<<allData->At(ia)<<endl;
 190   //space for DRM header
 191   fIndex += 4;
 192
 193   //space for 1st TRM header
 194   fIndex ++;
 195   positionOfTRMHeader= fIndex;
 196
 197   //space for chain  header
 198   fIndex ++;
 199
 200   // Loop through all PMT
 201   Int_t chain=0;
 202   Int_t iTDC = 0;
 203   Int_t channel=0;
 204   Int_t trm1words=0;
 205   Int_t fWordsIn1stTRM=0;
 206   //LED
 207   for (Int_t det = 0; det < 55; det++) {
 208     time = allData->At(det);
 209
 210     if (time >0) {
 211       FillTime(channel,  iTDC,  time);
 212       trm1words++;
 213      }
 214     if (channel < 6) channel +=2;
 215     else {
 216       channel = 0;
 217       iTDC++;
 218       if (iTDC>15) { chain++; iTDC=0;}
 219     }
 220     //  cout<<det<<" "<<time<<" "<<iTDC<<" "<<channel<<" "<<endl;
 221   }
 222
 223   WriteTrailer(0,0,fEventNumber,1); // 1st chain trailer
 224   WriteTrailer(15,0,fEventNumber,5); // 1st TRM trailer
 225   fWordsIn1stTRM = trm1words + 4;
 226   //  WriteTRMDataHeader(3, trm1words , positionOfTRMHeader);
 227   WriteTRMDataHeader(0, trm1words , positionOfTRMHeader);
 228
 229
 230   //space for 2st TRM header
 231   fIndex ++;
 232   positionOfTRMHeader= fIndex;
 233
 234   //space for chain  header
 235   fIndex ++;
 236
 237
 238   chain=0;
 239   iTDC = 0;
 240   channel=0;
 241   Int_t trm2words=0;
 242   for (Int_t det = 55; det < 108; det++) {
 243     time = allData->At(det);
 244
 245     if (time >0) {
 246       FillTime(channel,  iTDC,  time);
 247       trm2words++;}
 248     if (channel < 6) channel +=2;
 249     else {
 250       channel = 0;
 251       iTDC++;
 252       if (iTDC>15) { chain++; iTDC=0;}
 253     }
 254     //    cout<<det<<" "<<time<<" "<<channel<<" "<<iTDC<<endl;
 255  }
 256
 257   WriteTrailer(0,0,fEventNumber,1); // 1st chain trailer
 258   WriteTrailer(15,0,fEventNumber,5); // 1st TRM trailer
 259   //  WriteTRMDataHeader(5,trm2words,positionOfTRMHeader);
 260   WriteTRMDataHeader(1,trm2words,positionOfTRMHeader);
 261
 262   WriteTrailer(1,fEventNumber,0,5); //DRM trailer
 263   WriteDRMDataHeader();
 264
 265 }
 266 //------------------------------------------------------------------------------
 267 void AliT0RawData::PackWord(UInt_t &BaseWord, UInt_t Word, Int_t StartBit, Int_t StopBit)
 268 {
 269
 270   // Build mask
 271   Int_t len=StopBit-StartBit+1;
 272   UInt_t mask=0;
 273   for(Int_t jb=0; jb<len; mask|=1<<jb++);
 274   // Check consistency
 275   if(Word > mask){
 276     Error("PackWord", "Word to be filled is not within desired length\n"
 277           "Word:%d Start bit:%d Stop Bit:%d",Word,StartBit,StopBit);
 278     return;
 279   }
 280   BaseWord=(BaseWord&~(mask<<StartBit))|Word<<StartBit;
 281
 282 }
 283
 284
 285 //_____________________________________________________________________________
 286
 287 void  AliT0RawData::WriteDRMDataHeader()
 288 {
 289 //Write a (dummy or real) DDL DRM  data header,
 290 //set the compression bit if compressed
 291 //  UInt_t drmheader[4];
 292   UInt_t word;
 293   UInt_t baseWord=0;
 294   //fill DRM headers
 295   //DRM Global Header
 296   word = 1;
 297   PackWord(baseWord,word,0, 3); // 0001
 298   word = fIndex ;
 299
 300   PackWord(baseWord,word,4, 20); // event words
 301   word=124;
 302   PackWord(baseWord,word,21,27); // DRM ID for T0 - 124
 303   word=4;
 304   PackWord(baseWord,word,28,31); // 0100 marks header
 305   fBuffer[0]=  baseWord;
 306
 307   //DRM status header 1
 308   word = 1;
 309   PackWord(baseWord,word,0, 3); // 0001
 310   word = 1;
 311   PackWord(baseWord,word,4, 14); // slotID now 0000000001
 312   word = 1;
 313   PackWord(baseWord,word,15, 15); //if 1  LHC clock is coorectly recieved from CPDM
 314   word=0;
 315   PackWord(baseWord,word,16,27); // reserve for future use
 316   word=4;
 317   PackWord(baseWord,word,28,31); // 0100 marks header
 318    fBuffer[1] = baseWord;
 319
 320   word=0;
 321   baseWord=0;
 322
 323     //DRM status header 2
 324     word = 1;
 325     PackWord(baseWord,word, 0, 3); // 0001
 326     word = 3;
 327     PackWord(baseWord,word, 4, 14); //enable slotID now 00000000011
 328     word = 0;
 329     PackWord(baseWord,word, 15, 15); // something
 330     word=0;
 331     PackWord(baseWord,word, 16, 27); // fault ID for simulation 0
 332     word=4;
 333     PackWord(baseWord,word,28,31); // 0100 marks header
 334     fBuffer[2]=  baseWord;
 335
 336
 337     word=0;
 338     baseWord=0;
 339     //DRM status header 3
 340     word = 1;
 341     PackWord(baseWord,word,0, 3); // 0001
 342     word = 0;
 343     PackWord(baseWord,word,4, 27); // TTC event counter
 344     word=4;
 345     PackWord(baseWord,word,28,31); // 0100 marks header
 346     fBuffer[3]=  baseWord;
 347
 348
 349     word=0;
 350     baseWord=0;
 351
 352 }
 353
 354 //_____________________________________________________________________________
 355
 356 void  AliT0RawData::WriteTRMDataHeader(UInt_t slotID, Int_t nWordsInTRM,
 357                                           Int_t  positionOfTRMHeader)
 358 {
 359 //Write a (dummy or real) DDL TRM  data header,
 360 //set the compression bit if compressed
 361 //  UInt_t trmheader;
 362   UInt_t word;
 363   UInt_t baseWord=0;
 364   //fill TRM headers
 365   //TRM Global Header
 366   word = slotID;
 367   PackWord(baseWord,word,0, 3); // slotID
 368   word = nWordsInTRM;
 369  //+this word - DRM header
 370
 371   PackWord(baseWord,word,4, 16); // event words
 372   word=0;
 373   PackWord(baseWord,word,17,18); // ACQ
 374   word=0;
 375   PackWord(baseWord,word,19,19); //  L SEY inside LUT
 376   word=0;
 377   PackWord(baseWord,word,20,27); //  MBZ
 378   word=4;
 379   PackWord(baseWord,word,28,31); // 0100 marks header
 380   fBuffer[positionOfTRMHeader] =  baseWord;
 381  cout<<" TRM header "<<baseWord<<endl;
 382   word=0;
 383   baseWord=0;
 384
 385 }
 386
 387 //_____________________________________________________________________________
 388
 389 void  AliT0RawData::WriteChainDataHeader(UInt_t chainNumber,UInt_t slotID)
 390 {
 391 //Write a (dummy or real) DDL Chain  data header,
 392 //set the compression bit if compressed
 393 //  chainNumber 00 or 10
 394   UInt_t word;
 395   UInt_t baseWord=0;
 396   //fill TRM headers
 397   //TRM Global Header
 398   word = slotID; // ask Tatiana 7 or 9
 399   PackWord(baseWord,word,0, 3); // slotID
 400   word = 0;
 401   PackWord(baseWord,word,4, 15); // bunchID
 402   word=0;
 403   PackWord(baseWord,word,16,23); // PB24 temperature
 404   word=0;
 405   PackWord(baseWord,word,24,26); //  PB24 ID
 406   word=0;
 407   PackWord(baseWord,word,27,27); //  TS
 408   word=chainNumber;
 409   PackWord(baseWord,word,28,31); // 0100 marks header
 410   fBuffer[4] =  baseWord;
 411
 412   word=0;
 413   baseWord=0;
 414
 415 }
 416 //_____________________________________________________________________________
 417
 418 void  AliT0RawData::WriteDataHeader(Bool_t dummy, Bool_t compressed)
 419 {
 420 //Write a (dummy or real) DDL data header,
 421 //set the compression bit if compressed
 422
 423   AliRawDataHeaderSim header;
 424
 425   if (dummy) {
 426     //if size=0 it means that this data header is a dummy data header
 427     fDataHeaderPos = fFile->Tellp();
 428     fFile->WriteBuffer((char*)(&header), sizeof(header));
 429   } else {
 430     UInt_t currentFilePos = fFile->Tellp();
 431     fFile->Seekp(fDataHeaderPos);
 432     header.fSize = currentFilePos-fDataHeaderPos;
 433     header.SetAttribute(0);  // valid data
 434     if (compressed) header.SetAttribute(1);
 435     fFile->WriteBuffer((char*)(&header), sizeof(header));
 436     fFile->Seekp(currentFilePos);
 437   }
 438
 439 }
 440
 441 //___ __________________________________________________________________________
 442
 443
 444 void  AliT0RawData::WriteTrailer(UInt_t slot, Int_t word1, UInt_t word2, UInt_t word3)
 445 {
 446
 447   UInt_t word;
 448   UInt_t baseWord=0;
 449   word = slot;
 450   PackWord(baseWord,word,0, 3); // 0001
 451   word=word1;
 452   PackWord(baseWord,word,4, 15); // CRC ?
 453   word = word2;
 454   PackWord(baseWord,word,16,27); // event counter
 455   word=word3;
 456   PackWord(baseWord,word,28,31); //  marks trailer
 457   fIndex++;
 458   fBuffer[fIndex] =  baseWord;
 459
 460   word=0;
 461   baseWord=0;
 462
 463 }
 464
 465 //---------------------------------------------------------------------------------------
 466 //---------------------------------------------------------------------------------------
 467 void  AliT0RawData::FillTime(Int_t ch, Int_t iTDC, Int_t time)
 468 {
 469   UInt_t word;
 470   UInt_t baseWord=0;
 471
 472   word=time;
 473   PackWord(baseWord,word, 0, 20); // Time
 474
 475   word=ch;
 476   PackWord(baseWord,word, 21, 23); // number of channel
 477   word=iTDC;
 478   PackWord(baseWord,word, 24, 27); // TDC ID
 479
 480   word=0;
 481   PackWord(baseWord,word, 28, 28); // E = 0 in simulation
 482   word=0;
 483   PackWord(baseWord,word, 29, 30); // PS bit data 00
 484   word=1;
 485   PackWord(baseWord,word, 31, 31); // 1
 486   fIndex++;
 487   fBuffer[fIndex]=baseWord;
 488   word=0;
 489   baseWord=0;
 490
 491 }
 492 //---------------------------------------------------------------------------------------
 493
 494 Int_t AliT0RawData::RawDataT0(AliT0digit *fDigits)
 495 {
 496    //This method creates the Raw data files for T0 detector
 497
 498
 499   // const Int_t kSize=512; //2*AliTOFGeometry::NpadXSector()
 500                           //max number of digits per DDL file times 2
 501   //  UInt_t fBuffer[kSize];
 502   //  UInt_t baseWord;
 503   // UInt_t word;
 504
 505   fIndex=-1;
 506
 507   AliRawDataHeaderSim header;
 508    WriteDataHeader(kTRUE, kFALSE);
 509   GetDigits(fDigits);
 510   //write packing digits
 511
 512
 513   fFile->WriteBuffer((char*) fBuffer,((fIndex+1)*sizeof(UInt_t)));
 514   //write real data header on its place
 515    WriteDataHeader(kFALSE, kFALSE);
 516
 517
 518   //end for
 519
 520   return 0;
 521
 522 }