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 = new TMapIter(lookup);
  98
  99   for( Int_t iline=0; iline<106; iline++)
 100     {
 101       lookvalue = ( AliT0LookUpValue*) iter->Next();
 102       lookkey = (AliT0LookUpKey*) lookup->GetValue((TObject*)lookvalue);
 103       fLookUp.Add((TObject*)lookkey,(TObject*)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
 229
 230   for (Int_t det = 0; det < 105; det++) {
 231     time = allData->At(det);
 232      if (time >0) {
 233
 234       AliT0LookUpKey * lookkey = new AliT0LookUpKey();
 235       AliT0LookUpValue * lookvalue ;//= new AliT0LookUpValue(trm,tdc,chain,channel);
 236       lookkey->SetKey(det);
 237       lookvalue = (AliT0LookUpValue*) fLookUp.GetValue((TObject*)lookkey);
 238       if (lookvalue )
 239         {
 240           itrm= lookvalue->GetTRM();
 241           if (itrm != oldtrm ) {
 242             WriteChainDataTrailer(1); // 1st chain trailer
 243             fIndex++;
 244             WriteChainDataHeader(2, 1); //
 245             WriteChainDataTrailer(3); // 2st chain trailer
 246             WriteTrailer(15,0,fEventNumber,5); // 1st TRM trailer
 247
 248
 249             trm1words = fIndex - startTRM;
 250             WriteTRMDataHeader(oldtrm, trm1words , positionOfTRMHeader);
 251             //space for 2st TRM header
 252             startTRM=fIndex;
 253             fIndex ++;
 254             positionOfTRMHeader= fIndex;
 255             fIndex ++;
 256             oldtrm=itrm;
 257           }
 258           chain = lookvalue->GetChain();
 259           iTDC = lookvalue->GetTDC();
 260           channel = lookvalue->GetChannel();
 261           //      cout<<det<<" "<<itrm<<" "<<chain<<" "<<iTDC<<" "<<channel<<" time "<<time<<endl;
 262           FillTime(channel,  iTDC,  time);
 263         }
 264       else
 265         {
 266           cout<<" no lookup value for key "<<det<<endl;
 267           //  break;
 268         }
 269     }
 270
 271   }
 272
 273   WriteChainDataTrailer(1); // 1st chain trailer
 274   fIndex++;
 275   WriteChainDataHeader(2, 1); //
 276   WriteChainDataTrailer(3); // 2st chain trailer
 277   WriteTrailer(15,0,fEventNumber,5); // 1st TRM trailer
 278
 279
 280  trm1words = fIndex - startTRM;
 281   //space for 2st TRM header
 282
 283   WriteTRMDataHeader(1, trm1words , positionOfTRMHeader);
 284
 285   //DRM trailer
 286   WriteTrailer(1,0,fEventNumber,5); // 1st TRM trailer
 287
 288     WriteDRMDataHeader();
 289
 290     delete allData;
 291
 292 }
 293 //------------------------------------------------------------------------------
 294 void AliT0RawData::PackWord(UInt_t &BaseWord, UInt_t Word, Int_t StartBit, Int_t StopBit)
 295 {
 296
 297   // Build mask
 298   Int_t len=StopBit-StartBit+1;
 299   UInt_t mask=0;
 300   for(Int_t jb=0; jb<len; mask|=1<<jb++);
 301   // Check consistency
 302   if(Word > mask){
 303     Error("PackWord", "Word to be filled is not within desired length\n"
 304           "Word:%d Start bit:%d Stop Bit:%d",Word,StartBit,StopBit);
 305     return;
 306   }
 307   BaseWord=(BaseWord&~(mask<<StartBit))|Word<<StartBit;
 308
 309 }
 310
 311
 312 //_____________________________________________________________________________
 313
 314 void  AliT0RawData::WriteDRMDataHeader()
 315 {
 316 //Write a (dummy or real) DDL DRM  data header,
 317 //set the compression bit if compressed
 318 //  UInt_t drmheader[4];
 319   UInt_t word;
 320   UInt_t baseWord=0;
 321   //fill DRM headers
 322   //DRM Global Header
 323   word = 1;
 324   PackWord(baseWord,word,0, 3); // 0001
 325   word = fIndex ;
 326
 327   PackWord(baseWord,word,4, 20); // event words
 328   word=124;
 329   PackWord(baseWord,word,21,27); // DRM ID for T0 - 124
 330   word=4;
 331   PackWord(baseWord,word,28,31); // 0100 marks header
 332   fBuffer[0]=  baseWord;
 333
 334
 335   //DRM status header 1
 336   word = 1;
 337   PackWord(baseWord,word,0, 3); // 0001
 338   word = 1;
 339   PackWord(baseWord,word,4, 14); // slotID now 0000000001
 340   word = 1;
 341   PackWord(baseWord,word,15, 15); //if 1  LHC clock is coorectly recieved from CPDM
 342   word=0;
 343   PackWord(baseWord,word,16,27); // reserve for future use
 344   word=4;
 345   PackWord(baseWord,word,28,31); // 0100 marks header
 346    fBuffer[1] = baseWord;
 347
 348
 349    word=0;
 350    baseWord=0;
 351
 352     //DRM status header 2
 353     word = 1;
 354     PackWord(baseWord,word, 0, 3); // 0001
 355     word = 3;
 356     PackWord(baseWord,word, 4, 14); //enable slotID now 00000000011
 357     word = 0;
 358     PackWord(baseWord,word, 15, 15); // something
 359     word=0;
 360     PackWord(baseWord,word, 16, 27); // fault ID for simulation 0
 361     word=4;
 362     PackWord(baseWord,word,28,31); // 0100 marks header
 363     fBuffer[2]=  baseWord;
 364
 365
 366
 367     word=0;
 368     baseWord=0;
 369     //DRM status header 3
 370     word = 1;
 371     PackWord(baseWord,word,0, 3); // 0001
 372     word = 0;
 373     PackWord(baseWord,word,4, 27); // TTC event counter
 374     word=4;
 375     PackWord(baseWord,word,28,31); // 0100 marks header
 376     fBuffer[3]=  baseWord;
 377
 378     // new DRM format
 379     fBuffer[4]=  baseWord;
 380     fBuffer[5]=  baseWord;
 381
 382     word=0;
 383     baseWord=0;
 384
 385 }
 386
 387 //_____________________________________________________________________________
 388
 389 void  AliT0RawData::WriteTRMDataHeader(UInt_t slotID, Int_t nWordsInTRM,
 390                                           Int_t  positionOfTRMHeader)
 391 {
 392 //Write a (dummy or real) DDL TRM  data header,
 393 //set the compression bit if compressed
 394 //  UInt_t trmheader;
 395   UInt_t word;
 396   UInt_t baseWord=0;
 397   //fill TRM headers
 398   //TRM Global Header
 399   word = slotID;
 400   PackWord(baseWord,word,0, 3); // slotID
 401   word = nWordsInTRM;
 402  //+this word - DRM header
 403
 404   PackWord(baseWord,word,4, 16); // event words
 405   word=0;
 406   PackWord(baseWord,word,17,18); // ACQ
 407   word=0;
 408   PackWord(baseWord,word,19,19); //  L SEY inside LUT
 409   word=0;
 410   PackWord(baseWord,word,20,27); //  MBZ
 411   word=4;
 412   PackWord(baseWord,word,28,31); // 0100 marks header
 413   fBuffer[positionOfTRMHeader] =  baseWord;
 414
 415   word=0;
 416   baseWord=0;
 417
 418 }
 419
 420 //_____________________________________________________________________________
 421
 422 void  AliT0RawData::WriteChainDataHeader(UInt_t chainNumber,UInt_t slotID)
 423 {
 424 //Write a (dummy or real) DDL Chain  data header,
 425 //set the compression bit if compressed
 426 //  chainNumber 00 or 10
 427   UInt_t word;
 428   UInt_t baseWord=0;
 429   //fill TRM headers
 430   //TRM Global Header
 431   word = slotID; // ask Tatiana 7 or 9
 432   PackWord(baseWord,word,0, 3); // slotID
 433   word = 0;
 434   PackWord(baseWord,word,4, 15); // bunchID
 435   word=0;
 436   PackWord(baseWord,word,16,23); // PB24 temperature
 437   word=0;
 438   PackWord(baseWord,word,24,26); //  PB24 ID
 439   word=0;
 440   PackWord(baseWord,word,27,27); //  TS
 441   word=chainNumber;
 442   PackWord(baseWord,word,28,31); // 0100 marks header
 443   fBuffer[fIndex] =  baseWord;
 444
 445   word=0;
 446   baseWord=0;
 447
 448 }
 449 //_____________________________________________________________________________
 450
 451 void  AliT0RawData::WriteChainDataTrailer(UInt_t chainNumber )
 452 {
 453 //Write a (dummy or real) DDL Chain  data trailer
 454 //set the compression bit if compressed
 455 //  chainNumber 00 or 10
 456   UInt_t word;
 457   UInt_t baseWord=0;
 458   word = 0; // ask Tatiana 7 or 9
 459   PackWord(baseWord,word,0, 3); // status
 460   word = 0;
 461   PackWord(baseWord,word,4, 15); // MBZ
 462   word=fEventNumber;
 463   PackWord(baseWord,word,16,27); // event counter
 464   word=chainNumber;
 465   PackWord(baseWord,word,28,31); // chain number
 466   fIndex++;
 467   fBuffer[fIndex] =  baseWord;
 468
 469   word=0;
 470   baseWord=0;
 471
 472 }
 473 //_____________________________________________________________________________
 474
 475 void  AliT0RawData::WriteDataHeader(Bool_t dummy, Bool_t compressed)
 476 {
 477 //Write a (dummy or real) DDL data header,
 478 //set the compression bit if compressed
 479
 480   AliRawDataHeaderSim header;
 481
 482   if (dummy) {
 483     //if size=0 it means that this data header is a dummy data header
 484     fDataHeaderPos = fFile->Tellp();
 485     fFile->WriteBuffer((char*)(&header), sizeof(header));
 486   } else {
 487     UInt_t currentFilePos = fFile->Tellp();
 488     fFile->Seekp(fDataHeaderPos);
 489     header.fSize = currentFilePos-fDataHeaderPos;
 490     header.SetAttribute(0);  // valid data
 491     if (compressed) header.SetAttribute(1);
 492     fFile->WriteBuffer((char*)(&header), sizeof(header));
 493     fFile->Seekp(currentFilePos);
 494   }
 495
 496 }
 497
 498 //___ __________________________________________________________________________
 499
 500
 501 void  AliT0RawData::WriteTrailer(UInt_t slot, Int_t word1, UInt_t word2, UInt_t word3)
 502 {
 503
 504   UInt_t word;
 505   UInt_t baseWord=0;
 506   word = slot;
 507   PackWord(baseWord,word,0, 3); // 0001
 508   word=word1;
 509   PackWord(baseWord,word,4, 15); // CRC ?
 510   word = word2;
 511   PackWord(baseWord,word,16,27); // event counter
 512   word=word3;
 513   PackWord(baseWord,word,28,31); //  marks trailer
 514   fIndex++;
 515   fBuffer[fIndex] =  baseWord;
 516   word=0;
 517   baseWord=0;
 518
 519 }
 520
 521 //---------------------------------------------------------------------------------------
 522 //---------------------------------------------------------------------------------------
 523 void  AliT0RawData::FillTime(Int_t ch, Int_t iTDC, Int_t time)
 524 {
 525   UInt_t word;
 526   UInt_t baseWord=0;
 527
 528   word=time;
 529   PackWord(baseWord,word, 0, 20); // Time
 530
 531   word=ch;
 532   PackWord(baseWord,word, 21, 23); // number of channel
 533   word=iTDC;
 534   PackWord(baseWord,word, 24, 27); // TDC ID
 535
 536   word=0;
 537   PackWord(baseWord,word, 28, 28); // E = 0 in simulation
 538   word=0;
 539   PackWord(baseWord,word, 29, 30); // PS bit data 00
 540   word=1;
 541   PackWord(baseWord,word, 31, 31); // 1
 542   fIndex++;
 543   fBuffer[fIndex]=baseWord;
 544   word=0;
 545   baseWord=0;
 546 }
 547 //---------------------------------------------------------------------------------------
 548
 549 Int_t AliT0RawData::RawDataT0(AliT0digit *fDigits)
 550 {
 551    //This method creates the Raw data files for T0 detector
 552
 553
 554   // const Int_t kSize=512; //2*AliTOFGeometry::NpadXSector()
 555                           //max number of digits per DDL file times 2
 556   //  UInt_t fBuffer[kSize];
 557   //  UInt_t baseWord;
 558   // UInt_t word;
 559
 560   fIndex=-1;
 561
 562
 563    WriteDataHeader(kTRUE, kFALSE);
 564   GetDigits(fDigits);
 565   //write packing digits
 566
 567
 568   fFile->WriteBuffer((char*) fBuffer,((fIndex+1)*sizeof(UInt_t)));
 569   //write real data header on its place
 570    WriteDataHeader(kFALSE, kFALSE);
 571
 572
 573   //end for
 574
 575   return 0;
 576
 577 }