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
  39 ClassImp(AliT0RawData)
  40
  41 //_____________________________________________________________________________
  42   AliT0RawData::AliT0RawData():TObject(),
  43                                fVerbose(0),
  44                                fIndex(-1) ,
  45                                fEventNumber(0),
  46                                fTimeCFD(new TArrayI(24)),
  47                                fADC1( new TArrayI(24)),
  48                                fTimeLED( new TArrayI(24)),
  49                                fADC0( new TArrayI(24)),
  50                                fFile(0x0),
  51                                fDataHeaderPos(0),
  52                                fDRMDataHeaderPos(0),
  53                                fTRMDataHeaderPos(0),
  54                                fDigits(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::GetRunLoader();
  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                                                   fDigits(0)  ,
 125                                                   fParam(0),
 126                                                   fLookUp(0)
 127
 128 {
 129   //
 130   // AliT0rawData copy constructor
 131   //
 132
 133   ((AliT0RawData &) r).Copy(*this);
 134
 135 }
 136
 137 //_____________________________________________________________________________
 138 AliT0RawData::~AliT0RawData()
 139 {
 140   //
 141   // Destructor
 142   //
 143   if (fDigits) {
 144     delete fDigits;
 145     fDigits = NULL;
 146   }
 147   delete fTimeCFD;
 148   delete fADC1;
 149   delete fTimeLED;
 150   delete fADC0;
 151 }
 152
 153 //_____________________________________________________________________________
 154 AliT0RawData &AliT0RawData::operator=(const AliT0RawData &r)
 155 {
 156   //
 157   // Assignment operator
 158   //
 159
 160   if (this != &r) ((AliT0RawData &) r).Copy(*this);
 161   return *this;
 162
 163 }
 164
 165 //_____________________________________________________________________________
 166 void AliT0RawData::GetDigits(AliT0digit *fDigits)
 167 {
 168
 169   //This method packs the T0 digits in a proper 32 bits structure
 170
 171   //read T0 digits and fill TDC and ADC arrays
 172
 173
 174   //  Int_t error=0;
 175   Int_t time,  positionOfTRMHeader;
 176
 177   // Get the digits array
 178
 179   fDigits->GetTimeCFD(*fTimeCFD);
 180   fDigits->GetQT0(*fADC1);
 181   fDigits->GetTimeLED(*fTimeLED);
 182   fDigits->GetQT1(*fADC0);
 183   Int_t meantime = fDigits->MeanTime();
 184   Int_t timediff = fDigits->TimeDiff();
 185   Int_t mult0=fDigits->SumMult();
 186   Int_t mult1=fDigits->SumMult();
 187   Int_t timeA = fDigits->BestTimeC();
 188   Int_t timeC = fDigits->BestTimeA();
 189
 190
 191   TArrayI  *allData = new TArrayI(110);
 192   Int_t i=0;
 193   allData->AddAt(0,0);
 194   for (i=1; i<25; i++) {
 195     allData->AddAt(fTimeLED->At(i-1),i);
 196     allData->AddAt(fTimeCFD->At(i-1),i+24);
 197     allData->AddAt(fADC0->At(i-1),i+56);
 198     allData->AddAt(fADC1->At(i-1),i+80);
 199
 200   }
 201   allData->AddAt(meantime,49);
 202   allData->AddAt(timediff,50);
 203   allData->AddAt(timeA,51);
 204   allData->AddAt(timeC,52);
 205   allData->AddAt(mult0,53);
 206   allData->AddAt(mult1,54);
 207   allData->AddAt(mult0,55);
 208   allData->AddAt(mult1,56);
 209
 210   //   cout.setf( ios_base::hex, ios_base::basefield );
 211   //space for DRM header
 212   fIndex += 6;
 213
 214
 215   Int_t startTRM=fIndex;
 216   //space for 1st TRM header
 217   fIndex ++;
 218   positionOfTRMHeader= fIndex;
 219   //space for chain  header
 220   fIndex ++;
 221   WriteChainDataHeader(0, 0); //
 222   // Loop through all PMT
 223   Int_t chain=0;
 224   Int_t iTDC = 0;
 225   Int_t channel=0;
 226   Int_t trm1words=0;
 227   Int_t itrm=0, oldtrm=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) {
 233       lookkey->SetKey(det);
 234       lookvalue = (AliT0LookUpValue*) fLookUp.GetValue((TObject*)lookkey);
 235       if (lookvalue )
 236         {
 237           itrm= lookvalue->GetTRM();
 238           if (itrm != oldtrm ) {
 239             WriteChainDataTrailer(1); // 1st chain trailer
 240             fIndex++;
 241             WriteChainDataHeader(2, 1); //
 242             WriteChainDataTrailer(3); // 2st chain trailer
 243             WriteTrailer(15,0,fEventNumber,5); // 1st TRM trailer
 244
 245
 246             trm1words = fIndex - startTRM;
 247             WriteTRMDataHeader(oldtrm, trm1words , positionOfTRMHeader);
 248             //space for 2st TRM header
 249             startTRM=fIndex;
 250             fIndex ++;
 251             positionOfTRMHeader= fIndex;
 252             fIndex ++;
 253             oldtrm=itrm;
 254           }
 255           chain = lookvalue->GetChain();
 256           iTDC = lookvalue->GetTDC();
 257           channel = lookvalue->GetChannel();
 258           FillTime(channel,  iTDC,  time);
 259         }
 260       else
 261         {
 262           cout<<" no lookup value for key "<<det<<endl;
 263           //  break;
 264         }
 265     }
 266
 267   }
 268
 269   WriteChainDataTrailer(1); // 1st chain trailer
 270   fIndex++;
 271   WriteChainDataHeader(2, 1); //
 272   WriteChainDataTrailer(3); // 2st chain trailer
 273   WriteTrailer(15,0,fEventNumber,5); // 1st TRM trailer
 274
 275
 276   trm1words = fIndex - startTRM;
 277   //space for 2st TRM header
 278
 279   WriteTRMDataHeader(1, trm1words , positionOfTRMHeader);
 280
 281   //DRM trailer
 282   WriteTrailer(1,0,fEventNumber,5); // 1st TRM trailer
 283
 284     WriteDRMDataHeader();
 285
 286     delete allData;
 287
 288 }
 289 //------------------------------------------------------------------------------
 290 void AliT0RawData::PackWord(UInt_t &BaseWord, UInt_t Word, Int_t StartBit, Int_t StopBit)
 291 {
 292
 293   // Build mask
 294   Int_t len=StopBit-StartBit+1;
 295   UInt_t mask=0;
 296   for(Int_t jb=0; jb<len; mask|=1<<jb++);
 297   // Check consistency
 298   if(Word > mask){
 299     Error("PackWord", "Word to be filled is not within desired length\n"
 300           "Word:%d Start bit:%d Stop Bit:%d",Word,StartBit,StopBit);
 301     return;
 302   }
 303   BaseWord=(BaseWord&~(mask<<StartBit))|Word<<StartBit;
 304
 305 }
 306
 307
 308 //_____________________________________________________________________________
 309
 310 void  AliT0RawData::WriteDRMDataHeader()
 311 {
 312 //Write a (dummy or real) DDL DRM  data header,
 313 //set the compression bit if compressed
 314 //  UInt_t drmheader[4];
 315   UInt_t word;
 316   UInt_t baseWord=0;
 317   //fill DRM headers
 318   //DRM Global Header
 319   word = 1;
 320   PackWord(baseWord,word,0, 3); // 0001
 321   word = fIndex ;
 322
 323   PackWord(baseWord,word,4, 20); // event words
 324   word=124;
 325   PackWord(baseWord,word,21,27); // DRM ID for T0 - 124
 326   word=4;
 327   PackWord(baseWord,word,28,31); // 0100 marks header
 328   fBuffer[0]=  baseWord;
 329
 330
 331   //DRM status header 1
 332   word = 1;
 333   PackWord(baseWord,word,0, 3); // 0001
 334   word = 1;
 335   PackWord(baseWord,word,4, 14); // slotID now 0000000001
 336   word = 1;
 337   PackWord(baseWord,word,15, 15); //if 1  LHC clock is coorectly recieved from CPDM
 338   word=0;
 339   PackWord(baseWord,word,16,27); // reserve for future use
 340   word=4;
 341   PackWord(baseWord,word,28,31); // 0100 marks header
 342    fBuffer[1] = baseWord;
 343
 344
 345    word=0;
 346    baseWord=0;
 347
 348     //DRM status header 2
 349     word = 1;
 350     PackWord(baseWord,word, 0, 3); // 0001
 351     word = 3;
 352     PackWord(baseWord,word, 4, 14); //enable slotID now 00000000011
 353     word = 0;
 354     PackWord(baseWord,word, 15, 15); // something
 355     word=0;
 356     PackWord(baseWord,word, 16, 27); // fault ID for simulation 0
 357     word=4;
 358     PackWord(baseWord,word,28,31); // 0100 marks header
 359     fBuffer[2]=  baseWord;
 360
 361
 362
 363     word=0;
 364     baseWord=0;
 365     //DRM status header 3
 366     word = 1;
 367     PackWord(baseWord,word,0, 3); // 0001
 368     word = 0;
 369     PackWord(baseWord,word,4, 27); // TTC event counter
 370     word=4;
 371     PackWord(baseWord,word,28,31); // 0100 marks header
 372     fBuffer[3]=  baseWord;
 373
 374     // new DRM format
 375     fBuffer[4]=  baseWord;
 376     fBuffer[5]=  baseWord;
 377
 378     word=0;
 379     baseWord=0;
 380
 381 }
 382
 383 //_____________________________________________________________________________
 384
 385 void  AliT0RawData::WriteTRMDataHeader(UInt_t slotID, Int_t nWordsInTRM,
 386                                           Int_t  positionOfTRMHeader)
 387 {
 388 //Write a (dummy or real) DDL TRM  data header,
 389 //set the compression bit if compressed
 390 //  UInt_t trmheader;
 391   UInt_t word;
 392   UInt_t baseWord=0;
 393   //fill TRM headers
 394   //TRM Global Header
 395   word = slotID;
 396   PackWord(baseWord,word,0, 3); // slotID
 397   word = nWordsInTRM;
 398  //+this word - DRM header
 399
 400   PackWord(baseWord,word,4, 16); // event words
 401   word=0;
 402   PackWord(baseWord,word,17,18); // ACQ
 403   word=0;
 404   PackWord(baseWord,word,19,19); //  L SEY inside LUT
 405   word=0;
 406   PackWord(baseWord,word,20,27); //  MBZ
 407   word=4;
 408   PackWord(baseWord,word,28,31); // 0100 marks header
 409   fBuffer[positionOfTRMHeader] =  baseWord;
 410
 411   word=0;
 412   baseWord=0;
 413
 414 }
 415
 416 //_____________________________________________________________________________
 417
 418 void  AliT0RawData::WriteChainDataHeader(UInt_t chainNumber,UInt_t slotID)
 419 {
 420 //Write a (dummy or real) DDL Chain  data header,
 421 //set the compression bit if compressed
 422 //  chainNumber 00 or 10
 423   UInt_t word;
 424   UInt_t baseWord=0;
 425   //fill TRM headers
 426   //TRM Global Header
 427   word = slotID; // ask Tatiana 7 or 9
 428   PackWord(baseWord,word,0, 3); // slotID
 429   word = 0;
 430   PackWord(baseWord,word,4, 15); // bunchID
 431   word=0;
 432   PackWord(baseWord,word,16,23); // PB24 temperature
 433   word=0;
 434   PackWord(baseWord,word,24,26); //  PB24 ID
 435   word=0;
 436   PackWord(baseWord,word,27,27); //  TS
 437   word=chainNumber;
 438   PackWord(baseWord,word,28,31); // 0100 marks header
 439   fBuffer[fIndex] =  baseWord;
 440
 441   word=0;
 442   baseWord=0;
 443
 444 }
 445 //_____________________________________________________________________________
 446
 447 void  AliT0RawData::WriteChainDataTrailer(UInt_t chainNumber )
 448 {
 449 //Write a (dummy or real) DDL Chain  data trailer
 450 //set the compression bit if compressed
 451 //  chainNumber 00 or 10
 452   UInt_t word;
 453   UInt_t baseWord=0;
 454   word = 0; // ask Tatiana 7 or 9
 455   PackWord(baseWord,word,0, 3); // status
 456   word = 0;
 457   PackWord(baseWord,word,4, 15); // MBZ
 458   word=fEventNumber;
 459   PackWord(baseWord,word,16,27); // event counter
 460   word=chainNumber;
 461   PackWord(baseWord,word,28,31); // chain number
 462   fIndex++;
 463   fBuffer[fIndex] =  baseWord;
 464
 465   word=0;
 466   baseWord=0;
 467
 468 }
 469 //_____________________________________________________________________________
 470
 471 void  AliT0RawData::WriteDataHeader(Bool_t dummy, Bool_t compressed)
 472 {
 473 //Write a (dummy or real) DDL data header,
 474 //set the compression bit if compressed
 475
 476   AliRawDataHeaderSim header;
 477
 478   if (dummy) {
 479     //if size=0 it means that this data header is a dummy data header
 480     fDataHeaderPos = fFile->Tellp();
 481     fFile->WriteBuffer((char*)(&header), sizeof(header));
 482   } else {
 483     UInt_t currentFilePos = fFile->Tellp();
 484     fFile->Seekp(fDataHeaderPos);
 485     header.fSize = currentFilePos-fDataHeaderPos;
 486     header.SetAttribute(0);  // valid data
 487     if (compressed) header.SetAttribute(1);
 488     fFile->WriteBuffer((char*)(&header), sizeof(header));
 489     fFile->Seekp(currentFilePos);
 490   }
 491
 492 }
 493
 494 //___ __________________________________________________________________________
 495
 496
 497 void  AliT0RawData::WriteTrailer(UInt_t slot, Int_t word1, UInt_t word2, UInt_t word3)
 498 {
 499
 500   UInt_t word;
 501   UInt_t baseWord=0;
 502   word = slot;
 503   PackWord(baseWord,word,0, 3); // 0001
 504   word=word1;
 505   PackWord(baseWord,word,4, 15); // CRC ?
 506   word = word2;
 507   PackWord(baseWord,word,16,27); // event counter
 508   word=word3;
 509   PackWord(baseWord,word,28,31); //  marks trailer
 510   fIndex++;
 511   fBuffer[fIndex] =  baseWord;
 512   word=0;
 513   baseWord=0;
 514
 515 }
 516
 517 //---------------------------------------------------------------------------------------
 518 //---------------------------------------------------------------------------------------
 519 void  AliT0RawData::FillTime(Int_t ch, Int_t iTDC, Int_t time)
 520 {
 521   UInt_t word;
 522   UInt_t baseWord=0;
 523
 524   word=time;
 525   PackWord(baseWord,word, 0, 20); // Time
 526
 527   word=ch;
 528   PackWord(baseWord,word, 21, 23); // number of channel
 529   word=iTDC;
 530   PackWord(baseWord,word, 24, 27); // TDC ID
 531
 532   word=0;
 533   PackWord(baseWord,word, 28, 28); // E = 0 in simulation
 534   word=0;
 535   PackWord(baseWord,word, 29, 30); // PS bit data 00
 536   word=1;
 537   PackWord(baseWord,word, 31, 31); // 1
 538   fIndex++;
 539   fBuffer[fIndex]=baseWord;
 540   word=0;
 541   baseWord=0;
 542 }
 543 //---------------------------------------------------------------------------------------
 544
 545 Int_t AliT0RawData::RawDataT0(AliT0digit *fDigits)
 546 {
 547    //This method creates the Raw data files for T0 detector
 548
 549
 550   // const Int_t kSize=512; //2*AliTOFGeometry::NpadXSector()
 551                           //max number of digits per DDL file times 2
 552   //  UInt_t fBuffer[kSize];
 553   //  UInt_t baseWord;
 554   // UInt_t word;
 555
 556   fIndex=-1;
 557
 558
 559    WriteDataHeader(kTRUE, kFALSE);
 560   GetDigits(fDigits);
 561   //write packing digits
 562
 563
 564   fFile->WriteBuffer((char*) fBuffer,((fIndex+1)*sizeof(UInt_t)));
 565   //write real data header on its place
 566    WriteDataHeader(kFALSE, kFALSE);
 567
 568
 569   //end for
 570
 571   return 0;
 572
 573 }