START/AliSTARTRawData.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 //  START raw data conversion class                                            //
  21 //                                                                           //
  22 ///////////////////////////////////////////////////////////////////////////////
  23
  24 #include <Riostream.h>
  25 #include <TTree.h>
  26
  27 #include "AliSTART.h"
  28 #include "AliSTARTRawData.h"
  29 #include "AliSTARTdigit.h"
  30 #include "AliBitPacking.h"
  31 #include "AliRawDataHeader.h"
  32 #include "AliBitPacking.h"
  33
  34 ClassImp(AliSTARTRawData)
  35
  36 //_____________________________________________________________________________
  37 AliSTARTRawData::AliSTARTRawData():TObject()
  38 {
  39   /*
  40 -  48 channels (2 words each as in TOF DDL) for :
  41 word 1 :0-5bit number of PMT; word 2: 0-7 error sign, 8-31 TDC
  42 and the same but for amplified signal. Now I wrote the same time because
  43 CDF are not ready and differences didn't measured yet.
  44
  45 -  48 channel for amplitude: very preliminary, QTC features are not
  46 known now, preliminary i put as T1 time signal for this PMT in first
  47 channel and T1+A in second, where A=Log(Amplitude);
  48 and the same for amplified but A=Log(10*Amplitude).
  49
  50 - T0-A and T0-C 2 channels
  51 - T0A-T0C vertex information
  52 - Time Meaner where T0C TOF increase to the T0A TOF distance
  53 - 6 multiplicity signals the same way as amplitude and with the same
  54 uncertances
  55   */
  56
  57   fIndex=-1;
  58   fDigits = NULL;
  59
  60   fTimeCFD = new TArrayI(24);
  61   fADC = new TArrayI(24);
  62   fTimeLED = new TArrayI(24);
  63   fADC0 = new TArrayI(24);
  64    //   this->Dump();
  65
  66 }
  67
  68 //_____________________________________________________________________________
  69 AliSTARTRawData::AliSTARTRawData(const AliSTARTRawData &r):TObject()
  70 {
  71   //
  72   // AliSTARTrawData copy constructor
  73   //
  74
  75   ((AliSTARTRawData &) r).Copy(*this);
  76
  77 }
  78
  79 //_____________________________________________________________________________
  80 AliSTARTRawData::~AliSTARTRawData()
  81 {
  82   //
  83   // Destructor
  84   //
  85   if (fDigits) {
  86     delete fDigits;
  87     fDigits = NULL;
  88   }
  89   delete fTimeCFD;
  90   delete fADC;
  91   delete fTimeLED;
  92   delete fADC0;
  93 }
  94
  95 //_____________________________________________________________________________
  96 AliSTARTRawData &AliSTARTRawData::operator=(const AliSTARTRawData &r)
  97 {
  98   //
  99   // Assignment operator
 100   //
 101
 102   if (this != &r) ((AliSTARTRawData &) r).Copy(*this);
 103   return *this;
 104
 105 }
 106
 107 //_____________________________________________________________________________
 108 void AliSTARTRawData::GetDigits(AliSTARTdigit *fDigits, UInt_t *buf)
 109 {
 110
 111   //This method packs the START digits in a proper 32 bits structure
 112
 113   //read START digits and fill TDC and ADC arrays
 114
 115
 116   UInt_t word;
 117   UInt_t baseWord=0;
 118   Int_t error=0;
 119
 120     // Get the digits array
 121
 122   fDigits->GetTime(*fTimeCFD);
 123   fDigits->GetADC(*fADC);
 124   fDigits->GetTimeAmp(*fTimeLED);
 125   fDigits->GetADCAmp(*fADC0);
 126
 127   // Loop through all PMT
 128
 129   for (Int_t det = 0; det < 24; det++) {
 130     Int_t timeLED=fTimeLED->At(det);
 131     //   if( timeLED > 0){
 132       // DDL 1 0-5 -#PMT, 6-31 - empty
 133       //LED
 134       word=det;;
 135       PackWord(baseWord,word, 0, 8);
 136       fIndex++;
 137       buf[fIndex]=baseWord;
 138
 139       word=0;
 140       baseWord=0;
 141       word=error;
 142       PackWord(baseWord,word,0, 7); // Error flag
 143       word=timeLED;
 144       PackWord(baseWord,word,8,31); // time-of-flight
 145       fIndex++;
 146       buf[fIndex]=baseWord;
 147       word=0;
 148       baseWord=0;
 149       //  }
 150   }
 151    for (Int_t det = 0; det < 24; det++) {
 152     //CDF
 153      Int_t timeCFD=fTimeCFD->At(det);
 154      //   if ( timeCFD >0 ) {
 155        // DDL2 2 0-5 -#PMT, 6-31 - empty
 156        word=0;
 157        baseWord=0;
 158        word=det+24;
 159        PackWord(baseWord,word, 0, 8); // number of PMT on the right side
 160        fIndex++;
 161        buf[fIndex]=baseWord;
 162        word=0;
 163        baseWord=0;
 164        word=error;
 165        PackWord(baseWord,word,0, 7); // Error flag
 166        word=timeCFD;
 167        PackWord(baseWord,word,8,31); // time-of-flight
 168        fIndex++;
 169        buf[fIndex]=baseWord;
 170         word=0;
 171        baseWord=0;
 172        //  }
 173    }
 174   for (Int_t det = 0; det < 24; det++) {
 175     //conver ADC to time (preliminary algorithm)
 176     Int_t qtc=fADC->At(det);
 177     //    if ( qtc > 0 )
 178     //  {
 179         word=det+48;
 180         PackWord(baseWord,word, 0, 8); // number of PMT on the right side
 181         fIndex++;
 182         buf[fIndex]=baseWord;
 183         baseWord=0;
 184         word=error;
 185         PackWord(baseWord,word,0, 7); // Error flag
 186         word=qtc;
 187         PackWord(baseWord,word,8,31); // Q->Time
 188         fIndex++;
 189         buf[fIndex]=baseWord;
 190         word=0;
 191         baseWord=0;
 192         //     }
 193   }
 194
 195   for (Int_t det = 0; det < 24; det++) {
 196     Int_t qtcAmp=fADC0->At(det);
 197
 198     // DDL 4 amplified QTC charge * 10
 199
 200      //Amplified  ADC -> TDC
 201
 202     word=det+72;
 203     PackWord(baseWord,word, 0, 8); // number of PMT on the right side
 204     fIndex++;
 205     buf[fIndex]=baseWord;
 206     baseWord=0;
 207     word=error;
 208     PackWord(baseWord,word,0, 7); // Error flag
 209     word=qtcAmp;
 210     PackWord(baseWord,word,8,31); // Q->T amplified
 211     fIndex++;
 212     buf[fIndex]=baseWord;
 213
 214     word=0;
 215     baseWord=0;
 216   }
 217
 218
 219   word=0;
 220   baseWord=0;
 221   fIndex++;
 222   word=97;
 223   PackWord(baseWord,word, 0, 8); // ?????????????????
 224   buf[fIndex]=baseWord;
 225   baseWord=0;
 226   word=error;
 227   PackWord(baseWord,word,0, 7); // Error flag
 228   word=fDigits->MeanTime();
 229   PackWord(baseWord,word,8,31); // MEANER
 230
 231   fIndex++;
 232   buf[fIndex]=baseWord;
 233
 234
 235   // besttime right & left
 236   word=98;
 237   PackWord(baseWord,word, 0, 8); // T0-A sign
 238   fIndex++;
 239   buf[fIndex]=baseWord;
 240
 241   baseWord=0;
 242   word=error;
 243   PackWord(baseWord,word,0, 7); // Error flag
 244   word=fDigits->BestTimeRight();
 245   PackWord(baseWord,word,8,31); // time-of-flight T0-A
 246   fIndex++;
 247   buf[fIndex]=baseWord;
 248
 249   word=99;
 250   PackWord(baseWord,word, 0, 8); // T0-C sign
 251   fIndex++;
 252   buf[fIndex]=baseWord;
 253
 254   baseWord=0;
 255   word=error;
 256   PackWord(baseWord,word,0, 7); // Error flag
 257   word=fDigits->BestTimeLeft();
 258   PackWord(baseWord,word,8,31); // time-of-flight T0-C
 259   fIndex++;
 260   buf[fIndex]=baseWord;
 261
 262   // time difference
 263   word=100;
 264   PackWord(baseWord,word, 0, 8); // TVDS sign
 265   fIndex++;
 266   buf[fIndex]=baseWord;
 267
 268   baseWord=0;
 269
 270   word=error;
 271   PackWord(baseWord,word,0, 7); // Error flag
 272   word=fDigits->TimeDiff();
 273   PackWord(baseWord,word,8,31); // T0verex
 274   fIndex++;
 275   buf[fIndex]=baseWord;
 276
 277
 278   // multiplicity
 279
 280   Int_t mult=fDigits->SumMult();
 281   word=101;
 282   PackWord(baseWord,word, 0, 8);
 283   fIndex++;
 284   buf[fIndex]=baseWord;
 285
 286   baseWord=0;
 287   word=error;
 288   PackWord(baseWord,word,0, 7); // Error flag
 289   word=mult;
 290   PackWord(baseWord,word,8,31); // time amplitude
 291   fIndex++;
 292   buf[fIndex]=baseWord;
 293
 294
 295   // trigger channels
 296    // besttime right & left
 297   word=102;
 298   PackWord(baseWord,word, 0, 8); // T0-A sign
 299   fIndex++;
 300   buf[fIndex]=baseWord;
 301
 302   baseWord=0;
 303   word=error;
 304   PackWord(baseWord,word,0, 7); // Error flag
 305   word=fDigits->BestTimeRight();
 306   PackWord(baseWord,word,8,31); // time-of-flight T0-A
 307   fIndex++;
 308   buf[fIndex]=baseWord;
 309
 310   word=103;
 311   PackWord(baseWord,word, 0, 8); // T0-C sign
 312   fIndex++;
 313   buf[fIndex]=baseWord;
 314
 315   baseWord=0;
 316
 317   word=error;
 318   PackWord(baseWord,word,0, 7); // Error flag
 319   word=fDigits->BestTimeLeft();
 320   PackWord(baseWord,word,8,31); // time-of-flight T0-C
 321   fIndex++;
 322   buf[fIndex]=baseWord;
 323
 324   // time difference
 325   word=104;
 326   PackWord(baseWord,word, 0, 8); // TVDS sign
 327   fIndex++;
 328   buf[fIndex]=baseWord;
 329
 330   baseWord=0;
 331
 332   word=error;
 333   PackWord(baseWord,word,0, 7); // Error flag
 334   word=fDigits->TimeDiff();
 335   PackWord(baseWord,word,8,31); // T0verex
 336   fIndex++;
 337   buf[fIndex]=baseWord;
 338
 339   // multiplicity
 340
 341   mult=fDigits->SumMult();
 342   word=105;
 343   PackWord(baseWord,word, 0, 8);
 344   fIndex++;
 345   buf[fIndex]=baseWord;
 346
 347   baseWord=0;
 348   word=error;
 349   PackWord(baseWord,word,0, 7); // Error flag
 350   word=mult;
 351   PackWord(baseWord,word,8,31); // time amplitude
 352   fIndex++;
 353   buf[fIndex]=baseWord;
 354
 355   // multiplicity
 356
 357   mult=fDigits->SumMult();
 358   word=106;
 359   PackWord(baseWord,word, 0, 8);
 360   fIndex++;
 361   buf[fIndex]=baseWord;
 362
 363   baseWord=0;
 364   word=error;
 365   PackWord(baseWord,word,0, 7); // Error flag
 366   word=mult;
 367   PackWord(baseWord,word,8,31); // time amplitude
 368   fIndex++;
 369   buf[fIndex]=baseWord;
 370
 371 }
 372
 373 //-----------------------------------------------------------------------------------
 374
 375 void AliSTARTRawData::PackWord(UInt_t &BaseWord, UInt_t Word, Int_t StartBit, Int_t StopBit)
 376 {
 377
 378   // Build mask
 379   Int_t len=StopBit-StartBit+1;
 380   UInt_t mask=0;
 381   for(Int_t jb=0; jb<len; mask|=1<<jb++);
 382   // Check consistency
 383   if(Word > mask){
 384     Error("PackWord", "Word to be filled is not within desired length\n"
 385           "Word:%d Start bit:%d Stop Bit:%d",Word,StartBit,StopBit);
 386     return;
 387   }
 388   BaseWord=(BaseWord&~(mask<<StartBit))|Word<<StartBit;
 389
 390 }
 391
 392 //---------------------------------------------------------------------------------------
 393
 394 Int_t AliSTARTRawData::RawDataSTART(AliSTARTdigit *fDigits)
 395 {
 396    //This method creates the Raw data files for START detector
 397
 398
 399   const Int_t kSize=512; //2*AliTOFGeometry::NpadXSector()
 400                           //max number of digits per DDL file times 2
 401   UInt_t buf[kSize];
 402   UInt_t baseWord;
 403   UInt_t word;
 404
 405   fIndex=-1;
 406
 407   char fileName[15];
 408   ofstream outfile;         // logical name of the output file
 409   AliRawDataHeader header;
 410   //loop over TOF DDL files
 411   sprintf(fileName,"START_%d.ddl", 0xd00);
 412   //   sprintf(fileName,"START_0xd00.ddl"); //The name of the output file
 413 #ifndef __DECCXX
 414     outfile.open(fileName,ios::binary);
 415 #else
 416     outfile.open(fileName);
 417 #endif
 418     //write Dummy DATA HEADER
 419     UInt_t dataHeaderPosition=outfile.tellp();
 420     outfile.write((char*)(&header),sizeof(header));
 421
 422     baseWord=0;
 423     word=0;
 424     PackWord(baseWord,word,0, 31); // Number of DDL file
 425
 426     fIndex++;
 427     buf[fIndex]=baseWord;
 428     GetDigits(fDigits,buf);
 429
 430     outfile.write((char *)buf,((fIndex+1)*sizeof(UInt_t)));
 431     for(Int_t ii=0;ii<(fIndex+1);ii++) buf[ii]=0;
 432     fIndex=-1;
 433
 434     //Write REAL DATA HEADER
 435     UInt_t currentFilePosition=outfile.tellp();
 436     outfile.seekp(dataHeaderPosition);
 437     header.fSize=currentFilePosition-dataHeaderPosition;
 438     header.SetAttribute(0);  // valid data
 439     outfile.write((char*)(&header),sizeof(header));
 440     outfile.close();
 441
 442  //end for
 443
 444   return 0;
 445
 446 }