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