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