new RAW DATA (TOF) format uncompatible with PDC06 data
authoralla <alla@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 18 Aug 2006 09:56:59 +0000 (09:56 +0000)
committeralla <alla@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 18 Aug 2006 09:56:59 +0000 (09:56 +0000)
START/AliSTARTRawData.cxx
START/AliSTARTRawData.h
START/AliSTARTRawReader.cxx
START/AliSTARTRawReader.h

index efa508d..0706dd0 100644 (file)
 #include "AliSTARTdigit.h"
 #include "AliBitPacking.h"
 #include "AliRawDataHeader.h"
+#include "AliRawDataHeaderSim.h"
 #include "AliBitPacking.h"
-#include "AliDAQ.h"
+#include "AliFstream.h"
+#include "AliRunLoader.h"
 
 ClassImp(AliSTARTRawData)
 
@@ -59,11 +61,23 @@ uncertances
   fDigits = NULL;
 
   fTimeCFD = new TArrayI(24);
-  fADC = new TArrayI(24);
+  fADC1 = new TArrayI(24);
   fTimeLED = new TArrayI(24);
   fADC0 = new TArrayI(24);
-   //   this->Dump();
-  
+  fFile = NULL;
+  fDataHeaderPos = 0;
+  fDRMDataHeaderPos = 0; 
+  memset(fBuffer,0,512*sizeof(UInt_t));
+
+  //open the output file
+  char fileName[15];
+  sprintf(fileName,"START_%d.ddl", 0xd00);
+  fFile = new AliFstream(fileName);
+  //get event number 
+  AliRunLoader *runloader = AliRunLoader::GetRunLoader();
+  if (runloader) {
+    fEventNumber = runloader->GetEventNumber();
+  }
 }
 
 //_____________________________________________________________________________
@@ -88,7 +102,7 @@ AliSTARTRawData::~AliSTARTRawData()
     fDigits = NULL;
   }
   delete fTimeCFD;
-  delete fADC;
+  delete fADC1;
   delete fTimeLED;
   delete fADC0;
 }
@@ -106,7 +120,7 @@ AliSTARTRawData &AliSTARTRawData::operator=(const AliSTARTRawData &r)
 }
 
 //_____________________________________________________________________________
-void AliSTARTRawData::GetDigits(AliSTARTdigit *fDigits, UInt_t *buf)
+void AliSTARTRawData::GetDigits(AliSTARTdigit *fDigits)
 {
  
   //This method packs the START digits in a proper 32 bits structure
@@ -114,282 +128,340 @@ void AliSTARTRawData::GetDigits(AliSTARTdigit *fDigits, UInt_t *buf)
   //read START digits and fill TDC and ADC arrays
 
 
-  UInt_t word;
-  UInt_t baseWord=0;
-  Int_t error=0;
+  //  Int_t error=0;
+  Int_t time,  positionOfTRMHeader;
 
     // Get the digits array
 
   fDigits->GetTime(*fTimeCFD);
-  fDigits->GetADC(*fADC);
+  fDigits->GetADC(*fADC1);
   fDigits->GetTimeAmp(*fTimeLED);
   fDigits->GetADCAmp(*fADC0);
-     
-  // Loop through all PMT
-  for (Int_t det = 0; det < 24; det++) {
-    Int_t timeLED=fTimeLED->At(det);
-    //   if( timeLED > 0){
-      // DDL 1 0-5 -#PMT, 6-31 - empty
-      //LED
-      word=det;;
-      PackWord(baseWord,word, 0, 8); 
-      fIndex++;
-      buf[fIndex]=baseWord;
-      
-      word=0;
-      baseWord=0;
-      word=error;
-      PackWord(baseWord,word,0, 7); // Error flag
-      word=timeLED;
-      PackWord(baseWord,word,8,31); // time-of-flight
-      fIndex++;
-      buf[fIndex]=baseWord;
-      word=0;
-      baseWord=0;
-      //  }
+  Int_t meantime = fDigits->MeanTime(); cout<<"meantime "<< meantime<<endl;
+  Int_t timediff = fDigits->TimeDiff(); cout<<" vertex "<<timediff<<endl;
+  Int_t mult0=fDigits->SumMult();
+  Int_t mult1=fDigits->SumMult();
+  Int_t timeA = fDigits->BestTimeLeft();
+  Int_t timeC = fDigits->BestTimeRight();
+
+
+  TArrayI  *allData = new TArrayI(107);
+  Int_t i=0;
+  for (i=0; i<24; i++) {
+    allData->AddAt(fTimeLED->At(i),i);
+    allData->AddAt(fTimeCFD->At(i),i+24);
+    allData->AddAt(fADC0->At(i),i+54);
+    allData->AddAt(fADC1->At(i),i+78);
   }
-   for (Int_t det = 0; det < 24; det++) {
-    //CDF
-     Int_t timeCFD=fTimeCFD->At(det);
-     //   if ( timeCFD >0 ) {
-       // DDL2 2 0-5 -#PMT, 6-31 - empty
-       word=0;
-       baseWord=0;
-       word=det+24;
-       PackWord(baseWord,word, 0, 8); // number of PMT on the right side
-       fIndex++;
-       buf[fIndex]=baseWord;
-       word=0;
-       baseWord=0;
-       word=error;
-       PackWord(baseWord,word,0, 7); // Error flag
-       word=timeCFD;
-       PackWord(baseWord,word,8,31); // time-of-flight
-       fIndex++;
-       buf[fIndex]=baseWord;
-        word=0;
-       baseWord=0;
-       //  }
-   }
-  for (Int_t det = 0; det < 24; det++) {
-    //conver ADC to time (preliminary algorithm)
-    Int_t qtc=fADC->At(det);
-    //    if ( qtc > 0 )
-    //  {
-       word=det+48;
-       PackWord(baseWord,word, 0, 8); // number of PMT on the right side
-       fIndex++;
-       buf[fIndex]=baseWord;
-       baseWord=0;
-       word=error;
-       PackWord(baseWord,word,0, 7); // Error flag
-       word=qtc;
-       PackWord(baseWord,word,8,31); // Q->Time
-       fIndex++;
-       buf[fIndex]=baseWord;
-       word=0;
-       baseWord=0;
-       //     }
+    allData->AddAt(meantime,48);
+    allData->AddAt(timediff,49);
+    allData->AddAt(timediff,102); //trigger vertex
+    allData->AddAt(timeA,50);
+    allData->AddAt(timeA,103); //trigger T0A
+    allData->AddAt(timeC,51);
+    allData->AddAt(timeC,104); //trigger T0C
+    allData->AddAt(mult0,52);
+    allData->AddAt(mult1,105); //trigger central
+    allData->AddAt(mult1,53);
+    allData->AddAt(mult1,106); //trigger semi-central
+  //space for DRM header
+  fIndex += 4;
+
+  //space for 1st TRM header
+  fIndex ++;
+  positionOfTRMHeader= fIndex;
+
+  //space for chain  header
+  fIndex ++;
+
+  // Loop through all PMT
+  Int_t chain=0; 
+  Int_t iTDC = 0;
+  Int_t channel=0;
+  Int_t trm1words=0;
+  Int_t fWordsIn1stTRM=0;
+  //LED
+  for (Int_t det = 0; det < 54; det++) {
+    time = allData->At(det);
+
+    if (time >0) { 
+      FillTime(channel,  iTDC,  time); 
+      trm1words++;   
+     }
+    if (channel < 6) channel +=2;
+    else {
+      channel = 0; 
+      iTDC++;
+      if (iTDC>15) { chain++; iTDC=0;}
+    }
   }
   
-  for (Int_t det = 0; det < 24; det++) {
-    Int_t qtcAmp=fADC0->At(det);
-    
-    // DDL 4 amplified QTC charge * 10
-    
-     //Amplified  ADC -> TDC 
-    
-    word=det+72;
-    PackWord(baseWord,word, 0, 8); // number of PMT on the right side
-    fIndex++;
-    buf[fIndex]=baseWord;
-    baseWord=0;
-    word=error;
-    PackWord(baseWord,word,0, 7); // Error flag
-    word=qtcAmp;
-    PackWord(baseWord,word,8,31); // Q->T amplified
-    fIndex++;
-    buf[fIndex]=baseWord;
-    
-    word=0;
-    baseWord=0;
+  WriteTrailer(0,0,fEventNumber,1); // 1st chain trailer
+  WriteTrailer(15,0,fEventNumber,5); // 1st TRM trailer
+  fWordsIn1stTRM = trm1words + 4;
+  WriteTRMDataHeader(3, trm1words , positionOfTRMHeader);
+
+
+  //space for 2st TRM header
+  fIndex ++;
+  positionOfTRMHeader= fIndex;
+
+  //space for chain  header
+  fIndex ++;
+
+
+  chain=0; 
+  iTDC = 0;
+  channel=0;
+  Int_t trm2words=0;
+  for (Int_t det = 54; det < 107; det++) {
+    time = allData->At(det);
+
+    if (time >0) { 
+      FillTime(channel,  iTDC,  time); 
+      trm2words++;}
+    if (channel < 6) channel +=2;
+    else {
+      channel = 0; 
+      iTDC++;
+      if (iTDC>15) { chain++; iTDC=0;}
+    }
   }
 
+  WriteTrailer(0,0,fEventNumber,1); // 1st chain trailer
+  WriteTrailer(15,0,fEventNumber,5); // 1st TRM trailer
+  WriteTRMDataHeader(5,trm2words,positionOfTRMHeader);
 
-  word=0;
-  baseWord=0;
-  fIndex++;
-  word=97;
-  PackWord(baseWord,word, 0, 8); // ?????????????????
-  buf[fIndex]=baseWord;
-  baseWord=0;
-  word=error;
-  PackWord(baseWord,word,0, 7); // Error flag
-  word=fDigits->MeanTime();
-  PackWord(baseWord,word,8,31); // MEANER
-  fIndex++;
-  buf[fIndex]=baseWord;
-
+  WriteTrailer(1,fEventNumber,0,5); //DRM trailer
+  WriteDRMDataHeader();
 
-  // besttime right & left
-  word=98;
-  PackWord(baseWord,word, 0, 8); // T0-A sign
-  fIndex++;
-  buf[fIndex]=baseWord;
+}
+//------------------------------------------------------------------------------
+void AliSTARTRawData::PackWord(UInt_t &BaseWord, UInt_t Word, Int_t StartBit, Int_t StopBit)
+{
+  
+  // Build mask
+  Int_t len=StopBit-StartBit+1;
+  UInt_t mask=0;
+  for(Int_t jb=0; jb<len; mask|=1<<jb++);
+  // Check consistency
+  if(Word > mask){
+    Error("PackWord", "Word to be filled is not within desired length\n"
+          "Word:%d Start bit:%d Stop Bit:%d",Word,StartBit,StopBit);
+    return;
+  }
+  BaseWord=(BaseWord&~(mask<<StartBit))|Word<<StartBit;
 
-  baseWord=0;
-  word=error;
-  PackWord(baseWord,word,0, 7); // Error flag
-  word=fDigits->BestTimeRight();
-  PackWord(baseWord,word,8,31); // time-of-flight T0-A
-  fIndex++;
-  buf[fIndex]=baseWord;
+}
 
-  word=99;
-  PackWord(baseWord,word, 0, 8); // T0-C sign
-  fIndex++;
-  buf[fIndex]=baseWord;
 
-  baseWord=0;
-  word=error;
-  PackWord(baseWord,word,0, 7); // Error flag
-  word=fDigits->BestTimeLeft();
-  PackWord(baseWord,word,8,31); // time-of-flight T0-C 
-  fIndex++;
-  buf[fIndex]=baseWord;
+//_____________________________________________________________________________
 
-  // time difference
-  word=100;
-  PackWord(baseWord,word, 0, 8); // TVDS sign
-  fIndex++;
-  buf[fIndex]=baseWord;
+void  AliSTARTRawData::WriteDRMDataHeader()
+{
+//Write a (dummy or real) DDL DRM  data header, 
+//set the compression bit if compressed
+//  UInt_t drmheader[4];  
+  UInt_t word;
+  UInt_t baseWord=0;
+  //fill DRM headers
+  //DRM Global Header
+  word = 1;
+  PackWord(baseWord,word,0, 3); // 0001 
+  word = fIndex ;
+
+  PackWord(baseWord,word,4, 20); // event words 
+  word=124;
+  PackWord(baseWord,word,21,27); // DRM ID for T0 - 124
+  word=4;
+  PackWord(baseWord,word,28,31); // 0100 marks header
+  fBuffer[0]=  baseWord;
+
+  //DRM status header 1
+  word = 1;
+  PackWord(baseWord,word,0, 3); // 0001 
+  word = 1;
+  PackWord(baseWord,word,4, 14); // slotID now 0000000001
+  word = 1;
+  PackWord(baseWord,word,15, 15); //if 1  LHC clock is coorectly recieved from CPDM 
+  word=0;
+  PackWord(baseWord,word,16,27); // reserve for future use
+  word=4;
+  PackWord(baseWord,word,28,31); // 0100 marks header
+   fBuffer[1] = baseWord;
 
+  word=0;
   baseWord=0;
 
-  word=error;
-  PackWord(baseWord,word,0, 7); // Error flag
-  word=fDigits->TimeDiff();
-  PackWord(baseWord,word,8,31); // T0verex
-  fIndex++;
-  buf[fIndex]=baseWord;
-
+    //DRM status header 2
+    word = 1;
+    PackWord(baseWord,word, 0, 3); // 0001 
+    word = 3;
+    PackWord(baseWord,word, 4, 14); //enable slotID now 00000000011
+    word = 0;
+    PackWord(baseWord,word, 15, 15); // something
+    word=0;
+    PackWord(baseWord,word, 16, 27); // fault ID for simulation 0
+    word=4;
+    PackWord(baseWord,word,28,31); // 0100 marks header
+    fBuffer[2]=  baseWord;
 
-  // multiplicity 
-  
-  Int_t mult=fDigits->SumMult();
-  word=101;
-  PackWord(baseWord,word, 0, 8); 
-  fIndex++;
-  buf[fIndex]=baseWord;
-  
-  baseWord=0;
-  word=error;
-  PackWord(baseWord,word,0, 7); // Error flag
-  word=mult;
-  PackWord(baseWord,word,8,31); // time amplitude
-  fIndex++;
-  buf[fIndex]=baseWord;
-  
+    
+    word=0;
+    baseWord=0;
+    //DRM status header 3
+    word = 1;
+    PackWord(baseWord,word,0, 3); // 0001 
+    word = 0;
+    PackWord(baseWord,word,4, 27); // TTC event counter
+    word=4;
+    PackWord(baseWord,word,28,31); // 0100 marks header
+    fBuffer[3]=  baseWord;
 
-  // trigger channels
-   // besttime right & left
-  word=102;
-  PackWord(baseWord,word, 0, 8); // T0-A sign
-  fIndex++;
-  buf[fIndex]=baseWord;
 
-  baseWord=0;
-  word=error;
-  PackWord(baseWord,word,0, 7); // Error flag
-  word=fDigits->BestTimeRight();
-  PackWord(baseWord,word,8,31); // time-of-flight T0-A
-  fIndex++;
-  buf[fIndex]=baseWord;
-  word=103;
-  PackWord(baseWord,word, 0, 8); // T0-C sign
-  fIndex++;
-  buf[fIndex]=baseWord;
+    word=0;
+    baseWord=0;
+    
+}
+  
+//_____________________________________________________________________________
 
+void  AliSTARTRawData::WriteTRMDataHeader(UInt_t slotID, Int_t nWordsInTRM,
+                                         Int_t  positionOfTRMHeader)
+{
+//Write a (dummy or real) DDL TRM  data header, 
+//set the compression bit if compressed
+//  UInt_t trmheader;  
+  UInt_t word;
+  UInt_t baseWord=0;
+  //fill TRM headers
+  //TRM Global Header
+  word = slotID;
+  PackWord(baseWord,word,0, 3); // slotID
+  word = nWordsInTRM;
+ //+this word - DRM header 
+
+  PackWord(baseWord,word,4, 16); // event words 
+  word=0;
+  PackWord(baseWord,word,17,18); // ACQ
+  word=0;
+  PackWord(baseWord,word,19,19); //  L SEY inside LUT
+  word=0;
+  PackWord(baseWord,word,20,27); //  MBZ
+  word=4;
+  PackWord(baseWord,word,28,31); // 0100 marks header
+  fBuffer[positionOfTRMHeader] =  baseWord;
+   
+  word=0; 
   baseWord=0;
+     
+}
 
-  word=error;
-  PackWord(baseWord,word,0, 7); // Error flag
-  word=fDigits->BestTimeLeft();
-  PackWord(baseWord,word,8,31); // time-of-flight T0-C 
-  fIndex++;
-  buf[fIndex]=baseWord;
+//_____________________________________________________________________________
 
-  // time difference
-  word=104;
-  PackWord(baseWord,word, 0, 8); // TVDS sign
-  fIndex++;
-  buf[fIndex]=baseWord;
+void  AliSTARTRawData::WriteChainDataHeader(UInt_t chainNumber,UInt_t slotID)
+{
+//Write a (dummy or real) DDL Chain  data header, 
+//set the compression bit if compressed
+//  chainNumber 00 or 10
+  UInt_t word;
+  UInt_t baseWord=0;
+  //fill TRM headers
+  //TRM Global Header
+  word = slotID; // ask Tatiana 7 or 9 
+  PackWord(baseWord,word,0, 3); // slotID
+  word = 0;
+  PackWord(baseWord,word,4, 15); // bunchID
+  word=0;
+  PackWord(baseWord,word,16,23); // PB24 temperature
+  word=0;
+  PackWord(baseWord,word,24,26); //  PB24 ID
+  word=0;
+  PackWord(baseWord,word,27,27); //  TS
+  word=chainNumber;
+  PackWord(baseWord,word,28,31); // 0100 marks header
+  fBuffer[4] =  baseWord;
 
-  baseWord=0;
+  word=0;
+  baseWord=0;     
+  
+}
+//_____________________________________________________________________________
 
-  word=error;
-  PackWord(baseWord,word,0, 7); // Error flag
-  word=fDigits->TimeDiff();
-  PackWord(baseWord,word,8,31); // T0verex
-  fIndex++;
-  buf[fIndex]=baseWord;
+void  AliSTARTRawData::WriteDataHeader(Bool_t dummy, Bool_t compressed)
+{
+//Write a (dummy or real) DDL data header, 
+//set the compression bit if compressed
 
-  // multiplicity 
-  
-  mult=fDigits->SumMult();
-  word=105;
-  PackWord(baseWord,word, 0, 8); 
-  fIndex++;
-  buf[fIndex]=baseWord;
-  
-  baseWord=0;
-  word=error;
-  PackWord(baseWord,word,0, 7); // Error flag
-  word=mult;
-  PackWord(baseWord,word,8,31); // time amplitude
-  fIndex++;
-  buf[fIndex]=baseWord;
+  AliRawDataHeaderSim header;
   
-  // multiplicity 
+  if (dummy) {
+    //if size=0 it means that this data header is a dummy data header
+    fDataHeaderPos = fFile->Tellp();
+    fFile->WriteBuffer((char*)(&header), sizeof(header));
+  } else {
+    UInt_t currentFilePos = fFile->Tellp();
+    fFile->Seekp(fDataHeaderPos);
+    header.fSize = currentFilePos-fDataHeaderPos;
+    header.SetAttribute(0);  // valid data
+    if (compressed) header.SetAttribute(1); 
+    fFile->WriteBuffer((char*)(&header), sizeof(header));
+    fFile->Seekp(currentFilePos);
+  }
   
-  mult=fDigits->SumMult();
-  word=106;
-  PackWord(baseWord,word, 0, 8); 
+}
+
+//___ __________________________________________________________________________
+
+
+void  AliSTARTRawData::WriteTrailer(UInt_t slot, Int_t word1, UInt_t word2, UInt_t word3)
+{
+
+  UInt_t word;
+  UInt_t baseWord=0;
+  word = slot;
+  PackWord(baseWord,word,0, 3); // 0001 
+  word=word1;
+  PackWord(baseWord,word,4, 15); // CRC ?
+  word = word2;
+  PackWord(baseWord,word,16,27); // event counter
+  word=word3;
+  PackWord(baseWord,word,28,31); //  marks trailer
   fIndex++;
-  buf[fIndex]=baseWord;
+  fBuffer[fIndex] =  baseWord;
   
+  word=0;
   baseWord=0;
-  word=error;
-  PackWord(baseWord,word,0, 7); // Error flag
-  word=mult;
-  PackWord(baseWord,word,8,31); // time amplitude
-  fIndex++;
-  buf[fIndex]=baseWord;
 
 }
 
-//-----------------------------------------------------------------------------------
-
-void AliSTARTRawData::PackWord(UInt_t &BaseWord, UInt_t Word, Int_t StartBit, Int_t StopBit)
+//---------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------
+void  AliSTARTRawData::FillTime(Int_t ch, Int_t iTDC, Int_t time)
 {
+  UInt_t word;
+  UInt_t baseWord=0;
 
-  // Build mask
-  Int_t len=StopBit-StartBit+1;
-  UInt_t mask=0;
-  for(Int_t jb=0; jb<len; mask|=1<<jb++);
-  // Check consistency
-  if(Word > mask){
-    Error("PackWord", "Word to be filled is not within desired length\n"
-          "Word:%d Start bit:%d Stop Bit:%d",Word,StartBit,StopBit);
-    return;
-  }
-  BaseWord=(BaseWord&~(mask<<StartBit))|Word<<StartBit;
+  word=time;
+  PackWord(baseWord,word, 0, 20); // Time 
 
-}
+  word=ch;
+  PackWord(baseWord,word, 21, 23); // number of channel 
+  word=iTDC;
+  PackWord(baseWord,word, 24, 27); // TDC ID
 
+  word=0;
+  PackWord(baseWord,word, 28, 28); // E = 0 in simulation
+  word=0;
+  PackWord(baseWord,word, 29, 30); // PS bit data 00
+  word=1;
+  PackWord(baseWord,word, 31, 31); // 1
+  fIndex++;
+  fBuffer[fIndex]=baseWord;
+  word=0;
+  baseWord=0;
+       
+}
 //---------------------------------------------------------------------------------------
 
 Int_t AliSTARTRawData::RawDataSTART(AliSTARTdigit *fDigits)
@@ -397,50 +469,27 @@ Int_t AliSTARTRawData::RawDataSTART(AliSTARTdigit *fDigits)
    //This method creates the Raw data files for START detector
 
 
-  const Int_t kSize=512; //2*AliTOFGeometry::NpadXSector() 
+  // const Int_t kSize=512; //2*AliTOFGeometry::NpadXSector() 
                           //max number of digits per DDL file times 2
-  UInt_t buf[kSize];
-  UInt_t baseWord;
-  UInt_t word;
+  //  UInt_t fBuffer[kSize];
+  //  UInt_t baseWord;
+  // UInt_t word;
 
   fIndex=-1;
-
-  char fileName[15];
-  ofstream outfile;         // logical name of the output file 
-  AliRawDataHeader header;
+  AliRawDataHeaderSim header;
   //loop over TOF DDL files
-  strcpy(fileName,AliDAQ::DdlFileName("START",0)); //The name of the output file
-#ifndef __DECCXX
-    outfile.open(fileName,ios::binary);
-#else
-    outfile.open(fileName);
-#endif
     //write Dummy DATA HEADER
-    UInt_t dataHeaderPosition=outfile.tellp();
-    outfile.write((char*)(&header),sizeof(header));
-
-    baseWord=0;
-    word=0;
-    PackWord(baseWord,word,0, 31); // Number of DDL file
-
-    fIndex++;
-    buf[fIndex]=baseWord;
-    GetDigits(fDigits,buf);
-
-    outfile.write((char *)buf,((fIndex+1)*sizeof(UInt_t)));
-    for(Int_t ii=0;ii<(fIndex+1);ii++) buf[ii]=0;
-    fIndex=-1;
-    
-    //Write REAL DATA HEADER
-    UInt_t currentFilePosition=outfile.tellp();
-    outfile.seekp(dataHeaderPosition);
-    header.fSize=currentFilePosition-dataHeaderPosition;
-    header.SetAttribute(0);  // valid data
-    outfile.write((char*)(&header),sizeof(header));
-    outfile.close();
-
- //end for
-   
+   WriteDataHeader(kTRUE, kFALSE);
+  GetDigits(fDigits);
+  //write packing digits
+  fFile->WriteBuffer((char*) fBuffer,((fIndex+1)*sizeof(UInt_t)));
+  //write real data header on its place
+   WriteDataHeader(kFALSE, kFALSE);
+  
+  
+  //end for
+  
   return 0;  
   
 }
index 48db767..07e7f89 100644 (file)
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "TObject.h"
+
 class AliSTART;
 class AliSTARTdigit;
-//class TTRee;
+class AliFstream;
+class TFile;
 //class TBranch;
-//class AliRawDataHeader;
+class AliRawDataHeaderSim;
 class AliSTARTRawData : public TObject {
 
  public:
@@ -30,19 +32,26 @@ class AliSTARTRawData : public TObject {
   // This method generates the files with the TOF detector data
   void SetVerbose(Int_t Verbose){fVerbose=Verbose;}
   // To set the verbose level
-  void  GetDigits(AliSTARTdigit *fDigits, UInt_t *buf);
+  void  GetDigits(AliSTARTdigit *fDigits);
   //This method formats and stores in buf all the digits of a TOF module
 
    void  PackWord(UInt_t &BaseWord, UInt_t Word, Int_t StartBit, Int_t StopBit);
   //This method stores the value of the variable Word of StopBit-StartBit+1 bits 
   //in BaseWord, starting from the bit StartBit
 
+   void  WriteDataHeader(Bool_t dummy, Bool_t compressed);
+   void  WriteDRMDataHeader();
+   void  WriteTRMDataHeader(UInt_t slotID, Int_t nWords, Int_t positionOfTRMHeader);
+   //this method is used to write the data header
+   void  WriteTrailer(UInt_t slot, Int_t word1, UInt_t word2, UInt_t word3); 
+   void  WriteChainDataHeader(UInt_t chainNumber,UInt_t slotID);
+   void  FillTime(Int_t ch, Int_t iTDC, Int_t time);
 
  //START digits arrays
 
 
   TArrayI *TimeLED() {return fTimeLED;}
-  TArrayI *ADC() {return fADC;}
+  TArrayI *ADC1() {return fADC1;}
   TArrayI *TimeCFD() {return fTimeCFD;}
   TArrayI *ADC0() {return fADC0;}
 
@@ -51,7 +60,9 @@ class AliSTARTRawData : public TObject {
  protected:
 
   Int_t fVerbose;            //Verbose level (0:no msg, 1:msg, 2:digits in txt files)
+  UInt_t fBuffer[512];       // buffer for writing rawdata
   Int_t fIndex;              //number of 32 words to be stored into the output file
+  Int_t fEventNumber;        // current event number
 
   Int_t fTimeDiff     ; //time difference 
   Int_t fMeanTime      ; // average time - ALICE start signal 
@@ -59,10 +70,14 @@ class AliSTARTRawData : public TObject {
   Int_t fBestTimeRight;  //first particle on the right
   Int_t fSumMult;        // sum multiplicity
   TArrayI * fTimeCFD;        //TDC on the each PMT
-  TArrayI *  fADC;           //QTC (ADC) on the each PMT
+  TArrayI *  fADC1;           //QTC (ADC) on the each PMT
   TArrayI * fTimeLED;    // TDC with amplified signal
   TArrayI *  fADC0;        //QTC amplified
-
+  AliFstream* fFile;    //logical name of the I/O file
+ UInt_t fDataHeaderPos;//Data header position
+ UInt_t fDRMDataHeaderPos;//Data DRM header position
+ UInt_t fTRMDataHeaderPos;//Data TRM header position
+ Int_t fWordsIn1stTRM; // Number of word in 1st TRM
   AliSTARTdigit *fDigits;  //! The START digits manager
 
   ClassDef(AliSTARTRawData,1)             //  START raw data class
index 29734f4..e1c68c1 100644 (file)
@@ -38,224 +38,131 @@ Bool_t  AliSTARTRawReader::Next()
 {
 // read the next raw digit
 // returns kFALSE if there is no digit left
+//"LookUpTable":
+// Amplitude LED TRM=0; chain=0; TDC 0 -5        channel 0,2,4,6
+// Time CFD      TRM=0; chain=0; TDC 6 - 11      channel 0,2,4,6
+// mean time     TRM=0; chain=0; TDC 12          channel 0
+// T0A           TRM=0; chain=0; TDC 12          channel 2
+// T0C           TRM=0; chain=0; TDC 12          channel 4
+// vertex        TRM=0; chain=0; TDC 12          channel 6
+// mult QTC0        TRM=0; chain=0; TDC 13          channel 0
+// mult QTC1        TRM=0; chain=0; TDC 13          channel 2
+
+// Charge QTC0   TRM=1; chain=0; TDC 0 -5        channel 0,2,4,6
+// Charge QTC1   TRM=1; chain=0; TDC 6 - 11      channel 0,2,4,6
+// T0A trigger          TRM=1; chain=0; TDC 12          channel 0
+// T0C trigger          TRM=1; chain=0; TDC 12          channel 2
+// vertex trigger       TRM=1; chain=0; TDC 12          channel 4
+// trigger central      TRM=1; chain=0; TDC 13          channel 0
+// tigger semicenral    TRM=1; chain=0; TDC 13          channel 2
+
+
+  UInt_t word;
+  Int_t time=0,  itdc=0, ichannel=0; 
+  Int_t numberOfWordsInTRM=0, iTRM=0;
+  Int_t tdcTime, koef ;
+  Int_t allData[107];
 
-  UInt_t word, unpackword;
-  Int_t time,  pmt;
   TArrayI *timeTDC1 = new TArrayI(24);
   TArrayI * chargeTDC1 = new TArrayI(24);
   TArrayI *timeTDC2 = new TArrayI(24);
   TArrayI *chargeTDC2 = new TArrayI(24);
-
+   
+  for ( Int_t k=0; k<107; k++)  allData[k]=0;
   do {
     if (!fRawReader->ReadNextData(fData)) return kFALSE;
   } while (fRawReader->GetDataSize() == 0);
   
-  fPosition = GetPosition();
- //  trigger 
-   word=0;
-   unpackword=0;
-   word = GetNextWord();
-   unpackword=AliBitPacking::UnpackWord(word,8,31);
-   time=unpackword;
-   word=0;
-   unpackword=0;
-   word = GetNextWord();
-   unpackword=AliBitPacking::UnpackWord(word,0,8);
-   pmt=unpackword;
-
-   word=0;
-   unpackword=0;
-   word = GetNextWord();
-   unpackword=AliBitPacking::UnpackWord(word,8,31);
-   time=unpackword;
-   word=0;
-   unpackword=0;
-   word = GetNextWord();
-   unpackword=AliBitPacking::UnpackWord(word,0,8);
-   pmt=unpackword;
-
-   word=0;
-   unpackword=0;
-   word = GetNextWord();
-   unpackword=AliBitPacking::UnpackWord(word,8,31);
-   time=unpackword;
-   word=0;
-   unpackword=0;
-   word = GetNextWord();
-    unpackword=AliBitPacking::UnpackWord(word,0,8);
-   pmt=unpackword;
-
-   word=0;
-   unpackword=0;
-   word = GetNextWord();
-   unpackword=AliBitPacking::UnpackWord(word,8,31);
-   time=unpackword;
-   word=0;
-   unpackword=0;
-   word = GetNextWord();
-   unpackword=AliBitPacking::UnpackWord(word,0,8);
-   pmt=unpackword;
-
-   word=0;
-   unpackword=0;
-   word = GetNextWord();
-   unpackword=AliBitPacking::UnpackWord(word,8,31);
-   time=unpackword;
-   word=0;
-   unpackword=0;
-   word = GetNextWord();
-   unpackword=AliBitPacking::UnpackWord(word,0,8);
-   pmt=unpackword;
+  //  fPosition = GetPosition();
+  fPosition = 0;
 
-
-//multiplicity
-   word=0;
-   unpackword=0;
-   word = GetNextWord();
-   unpackword=AliBitPacking::UnpackWord(word,8,31);
-   time=unpackword;
-   word=0;
-   unpackword=0;
+  //DRM header
+  for (Int_t i=0; i<4; i++) {
+    word = GetNextWord();
+  }
+  //TRMheader  
    word = GetNextWord();
-   unpackword=AliBitPacking::UnpackWord(word,0,8);
-   pmt=unpackword;
-   fDigits->SetSumMult(time);   
+   numberOfWordsInTRM=AliBitPacking::UnpackWord(word,4,16);
+   iTRM=AliBitPacking::UnpackWord(word,0,3);
 
-   // best time differece  
-   word=0;
-   unpackword=0;
+   //chain header
    word = GetNextWord();
-   unpackword=AliBitPacking::UnpackWord(word,8,31);
-   time=unpackword;
-
-   word=0;
-   unpackword=0;
+  
+   for (Int_t i=0; i<numberOfWordsInTRM; i++) {
+     word = GetNextWord();
+     tdcTime =  AliBitPacking::UnpackWord(word,31,31);   
+
+     if ( tdcTime == 1)
+       {
+        itdc=AliBitPacking::UnpackWord(word,24,27);
+        ichannel=AliBitPacking::UnpackWord(word,21,23);
+        time=AliBitPacking::UnpackWord(word,0,20);
+        koef = itdc*4 + ichannel/2;
+        allData[koef]=time;
+       }
+   }
+   word = GetNextWord(); //chain trailer
+   word = GetNextWord(); //TRM trailer
+     
+  //TRMheader  
+   word = GetNextWord();
+   numberOfWordsInTRM=AliBitPacking::UnpackWord(word,4,16);
+   iTRM=AliBitPacking::UnpackWord(word,0,3);
+   //chain header
    word = GetNextWord();
-   unpackword=AliBitPacking::UnpackWord(word,0,8);
-   pmt=unpackword;
-   fDigits->SetDiffTime(time);   
-  // best time left 
-   word=0;
-   unpackword=0;
+   
+   for (Int_t iword=0; iword<numberOfWordsInTRM; iword++) {
+     word = GetNextWord();
+     tdcTime =  AliBitPacking::UnpackWord(word,31,31);   
+
+     if ( tdcTime == 1)
+       {
+        itdc=AliBitPacking::UnpackWord(word,24,27);
+        ichannel=AliBitPacking::UnpackWord(word,21,23);
+        time=AliBitPacking::UnpackWord(word,0,20);
+        koef = itdc*4 + ichannel/2;
+        allData[koef+54]=time;
+       }
+   }
+      
+   for (Int_t in=0; in<24; in++)
+     {
+       timeTDC1->AddAt(allData[in],in);
+       timeTDC2->AddAt(allData[in+24],in);
+       chargeTDC1->AddAt(allData[in+54],in);
+       chargeTDC2->AddAt(allData[in+78],in);
+     }      
    word = GetNextWord();
-   unpackword=AliBitPacking::UnpackWord(word,8,31);
-   time=unpackword;
-   word=0;
-   unpackword=0;
    word = GetNextWord();
-   unpackword=AliBitPacking::UnpackWord(word,0,8);
-   pmt=unpackword;
-   fDigits->SetTimeBestLeft(time);   
    
-  // Best time right &left  
-   word=0;
-   unpackword=0;
-   word = GetNextWord();
-   unpackword=AliBitPacking::UnpackWord(word,8,31);
-   time=unpackword;
-   word=0;
-   unpackword=0;
+   fDigits->SetTime(*timeTDC2);
+   fDigits->SetADC(*chargeTDC1);
    
-   word = GetNextWord();
-   unpackword=AliBitPacking::UnpackWord(word,0,8);
-   pmt=unpackword;
-   fDigits->SetTimeBestRight(time);  
-  // mean 
-   word=0;
-   unpackword=0;
-   word = GetNextWord();
-   unpackword=AliBitPacking::UnpackWord(word,8,31);
-   time=unpackword;
-   word=0;
-   unpackword=0;
+   fDigits->SetTimeAmp(*timeTDC1);
+   fDigits->SetADCAmp(*chargeTDC2);
+   fTree->Fill();
    
-   word = GetNextWord();
-   unpackword=AliBitPacking::UnpackWord(word,0,8);
-   pmt=unpackword;
-   fDigits->SetMeanTime(time);  
-
-   for (Int_t i=0; i<24; i++)   //QTC amplified
-     {
-      word=0;
-      unpackword=0;
+   delete timeTDC1 ;
+   delete chargeTDC1;
+   delete timeTDC2 ;
+   delete chargeTDC2;
+   
+   return kTRUE;
+}
+//_____________________________________________________________________________
+/*
+void AliSTARTRawReader::UnpackTime(Int_t outTime, Int_t outCh)
+{
+      UInt_t word=0;
+      UInt_t unpackword=0;
     
       word = GetNextWord();
-      unpackword=AliBitPacking::UnpackWord(word,8,31);
-      time=unpackword;
-      word=0;
-      unpackword=0;
-      word = GetNextWord();
-      unpackword= AliBitPacking::UnpackWord(word,0,8);
-      pmt=unpackword;  
-      chargeTDC2->AddAt(time,pmt-72);
-     }
-
-  for (Int_t i=0; i<24; i++)
-    {
-      //  QTC
-      word=0;
-      unpackword=0;
-      word = GetNextWord();
-      unpackword=AliBitPacking::UnpackWord(word,8,31);
-      time=unpackword;
-      word=0;
-      unpackword=0;
-      word = GetNextWord();
-      unpackword= AliBitPacking::UnpackWord(word,0,8);
-      pmt=unpackword; //
-      chargeTDC1->AddAt(time,pmt-48);
-    }
-  
-  for (Int_t i=0; i<24; i++) //time CFD
-    {
-      word=0;
-      unpackword=0;
-      word = GetNextWord();
-      unpackword=AliBitPacking::UnpackWord(word,8,31);
-      time=unpackword;
-      word=0;
-      unpackword=0;
-      word = GetNextWord();
-       unpackword=AliBitPacking::UnpackWord(word,0,8);
-      pmt=unpackword;
-      timeTDC2->AddAt(time,pmt-24);
-    } 
-
-  
-  for (Int_t i=0; i<24; i++) //time LED
-    {
-      word=0;
-      unpackword=0;
-      word = GetNextWord();
-      unpackword=AliBitPacking::UnpackWord(word,8,31);
-      time=unpackword; 
-      
-      word=0;
-      unpackword=0;
-      word = GetNextWord();
-      unpackword=AliBitPacking::UnpackWord(word,0,8);
-      pmt=unpackword;
-      timeTDC1->AddAt(time,pmt);
-    }
-  
-  fDigits->SetTime(*timeTDC2);
-  fDigits->SetADC(*chargeTDC1);
-  
-  fDigits->SetTimeAmp(*timeTDC1);
-  fDigits->SetADCAmp(*chargeTDC2);
-    fTree->Fill();
-
-    delete timeTDC1 ;
-    delete chargeTDC1;
-    delete timeTDC2 ;
-    delete chargeTDC2;
-  
-    return kTRUE;
-}
+      unpackword=AliBitPacking::UnpackWord(word,0,12);
+      outTime=unpackword;
+      unpackword= AliBitPacking::UnpackWord(word,21,27);
+      outCh=unpackword;  
+ }
+ */
 //_____________________________________________________________________________
 Int_t AliSTARTRawReader::GetPosition()
 {
@@ -271,7 +178,8 @@ UInt_t AliSTARTRawReader::GetNextWord()
   // Read the next 32 bit word in backward direction
   // The input stream access is given by fData and fPosition
 
-   fPosition--;
+
+  //   fPosition--;
   Int_t iBit = fPosition * 32;
   Int_t iByte = iBit / 8;
 
@@ -280,7 +188,8 @@ UInt_t AliSTARTRawReader::GetNextWord()
   word |= fData[iByte+2]<<16;
   word |= fData[iByte+1]<<8;
   word |= fData[iByte];
-// fPosition--;
+   fPosition++;
+
   return word;
 
 }
index 50eb678..f7d1f91 100644 (file)
@@ -17,6 +17,7 @@ class AliSTARTRawReader : public TTask {
 
   Bool_t  Next(); //read next raw digit
   Int_t            GetPosition();
+  // void UnpackTime(Int_t outTime, Int_t outCh);
   UInt_t         GetNextWord();
   
   protected :