New light yields following the results from the first HI run in 2011, some aging...
[u/mrichter/AliRoot.git] / VZERO / AliVZEROBuffer.cxx
index c314633..03243df 100644 (file)
 
 #include <Riostream.h>
 #include <TObjArray.h>
+#include <TMath.h>
+
 #include "AliLog.h"
-#include "AliRawDataHeader.h"
+#include "AliRawDataHeaderSim.h"
 #include "AliVZEROBuffer.h"
-
-//#include "TFile.h"
-//#include "TTree.h"
+#include "AliVZEROdigit.h"
 
 ClassImp(AliVZEROBuffer)
 
 //_____________________________________________________________________________
 AliVZEROBuffer::AliVZEROBuffer():TObject(),
-    fVerbose(0),
+    fRemainingWord(0),
     f()
 {
   //
@@ -42,14 +42,14 @@ AliVZEROBuffer::AliVZEROBuffer():TObject(),
 }
 //_____________________________________________________________________________
 AliVZEROBuffer::AliVZEROBuffer(const char* fileName):TObject(),
-    fVerbose(0),
+    fRemainingWord(0),
     f()
 {
   // Constructor
   f = new AliFstream(fileName);
   // fout=new TFile(fileName,"recreate");
   // tree=new TTree("tree","Values");
-  AliRawDataHeader header;
+  AliRawDataHeaderSim header;
   f->WriteBuffer((char*)(&header), sizeof(header));
 
 }
@@ -57,7 +57,7 @@ AliVZEROBuffer::AliVZEROBuffer(const char* fileName):TObject(),
 //_____________________________________________________________________________
 AliVZEROBuffer::~AliVZEROBuffer(){
   // Destructor, it closes the IO stream
-  AliRawDataHeader header;
+  AliRawDataHeaderSim header;
   header.fSize = f->Tellp();
   header.SetAttribute(0);  // valid data
   f->Seekp(0);
@@ -68,26 +68,6 @@ AliVZEROBuffer::~AliVZEROBuffer(){
 }
 
 //_____________________________________________________________________________
-AliVZEROBuffer::AliVZEROBuffer(const AliVZEROBuffer &source):TObject(source),
-   fVerbose(0),
-   f()
-
-{
-  // Copy Constructor
-  this->fVerbose=source.fVerbose;
-  return;
-}
-
-//_____________________________________________________________________________
-AliVZEROBuffer& AliVZEROBuffer::operator=(const AliVZEROBuffer &source)
-
-{
-  //Assigment operator
-  this->fVerbose=source.fVerbose;
-  return *this;
-}
-
-//_____________________________________________________________________________
 void AliVZEROBuffer::WriteTriggerInfo(UInt_t trigger) {
   // The method writes VZERO trigger information
   // This info is contained in the first two
@@ -101,74 +81,164 @@ void AliVZEROBuffer::WriteTriggerInfo(UInt_t trigger) {
 }
 
 //_____________________________________________________________________________
-void AliVZEROBuffer::WriteChannel(Int_t cell,Int_t ADC, Int_t Time){
-  // It writes VZERO digits as a raw data file. 
-  // Being called by AliVZERODDL.C
+void AliVZEROBuffer::WriteTriggerScalers() {
+  // The method writes the VZERO trigger scalers
+  // For the moment there is no way to simulate
+  // this, so we fill the necessary 16 words with 0
 
-  UInt_t data = 0;
-  // Information about previous 10 interaction
-  // Not available in the simulation...
-  for(Int_t i = 0; i < 5; i++)
-    f->WriteBuffer((char*)&data,sizeof(data));
+  // First the general trigger scalers (16 of them)
+  for(Int_t i = 0; i < 16; i++) {
+      UInt_t data = 0;
+      f->WriteBuffer((char*)&data,sizeof(data));
+  }
+}
+
+//_____________________________________________________________________________
+void AliVZEROBuffer::WriteBunchNumbers() {
+  // The method writes the Bunch Numbers corresponding 
+  // to the 10 Minimum Bias events
+  // For the moment there is no way to simulate
+  // this, so we fill the necessary 10 words with 0
 
-  // Now write the ADC charge for this channel
-  if (ADC < 0 || ADC > 1023) {
-    AliInfo(Form("ADC saturated: %d. Truncating to 1023",ADC));
-    ADC = 1023;
+  // First the bunch crossing numbers
+  // for these 10 events
+  
+  for(Int_t i = 0; i < 10; i++) {
+      UInt_t data = 0;
+      f->WriteBuffer((char*)&data,sizeof(data));
   }
-  data = ADC | 0x400; // 'Interaction' flag
-  f->WriteBuffer((char*)&data,sizeof(data));
 
-  data = 0;
-  // Information about following 10 interaction
-  // Not available in the simulation...
-  for(Int_t i = 0; i < 5; i++)
+}
+
+//_____________________________________________________________________________
+void AliVZEROBuffer::WriteChannel(Int_t channel, Short_t *adc, Bool_t integrator){
+  // It writes VZERO charge information into a raw data file. 
+  // Being called by Digits2Raw
+  
+  UInt_t data = 0;
+  for(Int_t i = 0; i < AliVZEROdigit::kNClocks; ++i) {
+    if (adc[i] > 1023) {
+      AliWarning(Form("ADC (channel=%d) saturated: %d. Truncating to 1023",channel,adc[i]));
+      adc[i] = 1023;
+    }
+  }
+  
+  if(channel%2 == 0) {
+    for(Int_t i = 0; i < (AliVZEROdigit::kNClocks/2); ++i) {
+      data =   (adc[2*i] & 0x3ff);
+      data |= ((integrator & 0x1) << 10);
+
+      data |= ((adc[2*i+1] & 0x3ff) << 16);
+      data |= ((!integrator & 0x1) << 26);
+
+      f->WriteBuffer((char*)&data,sizeof(data));
+    }
+    fRemainingWord = (adc[AliVZEROdigit::kNClocks-1] & 0x3ff);
+    fRemainingWord |= ((integrator & 0x1) << 10);
+  }
+  else {
+    data = fRemainingWord;
+    data |= ((adc[0] & 0x3ff) << 16);
+    data |= ((integrator & 0x1) << 26);
     f->WriteBuffer((char*)&data,sizeof(data));
 
-  // Now write the timing information
-  data = Time & 0xfff;
-  // The signal width is not available the digits!
-  // To be added soon
-  // data |= (width & 0x7f) << 12;
-  f->WriteBuffer((char*)&data,sizeof(data));
+    for(Int_t i = 1; i <= (AliVZEROdigit::kNClocks/2); ++i) {
+      data =   (adc[2*i-1] & 0x3ff);
+      data |= ((!integrator & 0x1) << 10);
+
+      data |= ((adc[2*i] & 0x3ff) << 16);
+      data |= ((integrator & 0x1) << 26);
+
+      f->WriteBuffer((char*)&data,sizeof(data));
+    }
+  }
+    
 }
 
 //_____________________________________________________________________________
-void AliVZEROBuffer::WriteScalers() {
-  // The method writes the VZERO trigger scalers
-  // For the moment there is no way to simulate
-  // this, so we fill the necessary words with 0
-
-  // First the general trigger scalers (16 of them)
-  for(Int_t i = 0; i < 16; i++) {
+void AliVZEROBuffer::WriteBeamFlags(Bool_t *bbFlag, Bool_t *bgFlag) {
+  // The method writes information about
+  // the Beam-Beam and Beam-Gas flags i.e. 
+  // 6  words for the 4 channels 
+  // of half a CIU card
+
+  // Beam-beam and beam-gas flags are available
+  // only for the triggered event-of-interest (sample index = 10)
+  // As soon as trigger simulation would become more complex
+  // and would allow to simulate neighbouring samples, this code
+  // should be extended in order to fill all (or fraction) of the
+  // flags
+  for(Int_t i = 0; i < 2; i++) {
     UInt_t data = 0;
     f->WriteBuffer((char*)&data,sizeof(data));
   }
-
-  // Then beam-beam and beam-gas scalers for
-  // each individual channel (4x64 words)
-  for(Int_t i = 0; i < 256; i++) {
+  {
+    UInt_t data = 0;
+    for(Int_t iChannel = 0; iChannel < 4; ++iChannel) {
+      if (bbFlag[iChannel]) data |= (1 << (2*iChannel + 16));
+      if (bgFlag[iChannel]) data |= (1 << (2*iChannel + 17));
+    }
+    f->WriteBuffer((char*)&data,sizeof(data));
+  }  
+  for(Int_t i = 0; i < 3; i++) {
     UInt_t data = 0;
     f->WriteBuffer((char*)&data,sizeof(data));
   }
+
 }
 
+
 //_____________________________________________________________________________
 void AliVZEROBuffer::WriteMBInfo() {
   // The method writes information about
   // the 10 previous minimum-bias events
+  // i.e. channels charge for each of these
+  // 10 events (20 words for the 4 channels 
+  // of half a CIU card)
+    
+  for(Int_t i = 0; i < 20; i++) {
+    UInt_t data = 0;
+    f->WriteBuffer((char*)&data,sizeof(data));
+  }
+}
 
-  // First the bunch crossing numbers
-  // for these 10 events
-  for(Int_t i = 0; i < 10; i++) {
+
+//_____________________________________________________________________________
+void AliVZEROBuffer::WriteMBFlags() {
+  // The method writes information about
+  // the Minimum Bias flags
+  // 3 32-bits words for the 4 channels 
+  // of half a CIU card
+
+
+  for(Int_t i = 0; i < 3; i++) {
     UInt_t data = 0;
     f->WriteBuffer((char*)&data,sizeof(data));
   }
+}
+
+//_____________________________________________________________________________
+void AliVZEROBuffer::WriteBeamScalers() {
+  // The method writes the VZERO beam scalers
+  // For the moment there is no way to simulate
+  // this, so we fill the necessary words with 0
 
-  // Then channels charge for each of these
-  // 10 events (5 words/channel)
-  for(Int_t i = 0; i < 320; i++) {
+  // Beam-beam and beam-gas scalers for
+  // 4 individual channel (4x4 words)
+  
+  for(Int_t i = 0; i < 16; i++) {
     UInt_t data = 0;
     f->WriteBuffer((char*)&data,sizeof(data));
   }
 }
+
+//_____________________________________________________________________________
+void AliVZEROBuffer::WriteTiming(Float_t time, Float_t width) {
+  // It writes the timing information into a raw data file. 
+  // Being called by Digits2Raw
+
+  // Writes the timing information
+  UInt_t data = TMath::Nint(time/(25.0/256.0)) & 0xfff;
+  data |= (TMath::Nint(width/(25./64.)) & 0x7f) << 12;
+  f->WriteBuffer((char*)&data,sizeof(data));
+}