Type of trigger (beam-gas, beam-beam), only for RAW, is put in ESD

diff --git a/STEER/AliESDVZERO.cxx b/STEER/AliESDVZERO.cxx
index 8d3d2928931b3245f0d1e2bbd7b851c0fdcedb8a..cbe05a9d6386f2e94d24ce75592b4e8fd8971952 100644 (file)
--- a/STEER/AliESDVZERO.cxx
+++ b/STEER/AliESDVZERO.cxx
@@ -3,6 +3,7 @@
 
 ClassImp(AliESDVZERO)
 
+//__________________________________________________________________________
 AliESDVZERO::AliESDVZERO()
   :TObject(),
    fBBtriggerV0A(0),
@@ -13,11 +14,15 @@ AliESDVZERO::AliESDVZERO()
    // Default constructor 
    for(Int_t j=0; j<64; j++){ 
       fMultiplicity[j] = 0;   
-      fAdc[j] = 0;   
-      fTime[j] = 0;   
+      fAdc[j]   = 0;   
+      fTime[j]  = 0; 
+      fWidth[j] = 0; 
+      fBBFlag[j]= kFALSE;
+      fBGFlag[j]= kFALSE;  
    }
 }
 
+//__________________________________________________________________________
 AliESDVZERO::AliESDVZERO(const AliESDVZERO &o)
   :TObject(o),
    fBBtriggerV0A(o.fBBtriggerV0A),
@@ -28,14 +33,19 @@ AliESDVZERO::AliESDVZERO(const AliESDVZERO &o)
    // Default constructor 
    for(Int_t j=0; j<64; j++) {
        fMultiplicity[j] = o.fMultiplicity[j];
-       fAdc[j] = o.fAdc[j];
-       fTime[j] = o.fTime[j];
+       fAdc[j]    = o.fAdc[j];
+       fTime[j]   = o.fTime[j];
+       fWidth[j]  = o.fWidth[j];
+       fBBFlag[j] = o.fBBFlag[j];
+       fBGFlag[j] = o.fBGFlag[j];
    }
 }
 
+//__________________________________________________________________________
 AliESDVZERO::AliESDVZERO(UInt_t BBtriggerV0A, UInt_t BGtriggerV0A,
              UInt_t BBtriggerV0C, UInt_t BGtriggerV0C,
-             Short_t *Multiplicity, Short_t *Adc, Short_t *Time)
+             Short_t *Multiplicity, Short_t *Adc, 
+             Short_t *Time, Short_t *Width, Bool_t *BBFlag, Bool_t *BGFlag)
   :TObject(),
    fBBtriggerV0A(BBtriggerV0A),
    fBGtriggerV0A(BGtriggerV0A),
@@ -46,12 +56,15 @@ AliESDVZERO::AliESDVZERO(UInt_t BBtriggerV0A, UInt_t BGtriggerV0A,
    // Constructor
    for(Int_t j=0; j<64; j++) {
        fMultiplicity[j] = Multiplicity[j];
-       fAdc[j] = Adc[j];
-       fTime[j] = Time[j];
+       fAdc[j]    = Adc[j];
+       fTime[j]   = Time[j];
+       fWidth[j]  = Width[j];
+       fBBFlag[j] = BBFlag[j];
+       fBGFlag[j] = BGFlag[j];
    }
 }
 
-
+//__________________________________________________________________________
 AliESDVZERO& AliESDVZERO::operator=(const AliESDVZERO& o)
 {
 
@@ -64,12 +77,16 @@ AliESDVZERO& AliESDVZERO::operator=(const AliESDVZERO& o)
   fBGtriggerV0C=o.fBGtriggerV0C;
    for(Int_t j=0; j<64; j++) {
        fMultiplicity[j] = o.fMultiplicity[j];
-       fAdc[j] = o.fAdc[j];
-       fTime[j] = o.fTime[j];
+       fAdc[j]    = o.fAdc[j];
+       fTime[j]   = o.fTime[j];
+       fWidth[j]  = o.fWidth[j];
+       fBBFlag[j] = o.fBBFlag[j];
+       fBGFlag[j] = o.fBGFlag[j];
    }
   return *this;
 }
 
+//__________________________________________________________________________
 Short_t AliESDVZERO::GetNbPMV0A()
 {
   Short_t n=0;
@@ -78,6 +95,7 @@ Short_t AliESDVZERO::GetNbPMV0A()
   return n;
 }
 
+//__________________________________________________________________________
 Short_t AliESDVZERO::GetNbPMV0C()
 {
   Short_t n=0;
@@ -86,6 +104,7 @@ Short_t AliESDVZERO::GetNbPMV0C()
   return n;
 }
 
+//__________________________________________________________________________
 Int_t AliESDVZERO::GetMTotV0A()
 {
   Int_t n=0;
@@ -94,6 +113,7 @@ Int_t AliESDVZERO::GetMTotV0A()
   return n;
 }
 
+//__________________________________________________________________________
 Int_t AliESDVZERO::GetMTotV0C()
 {
   Int_t n=0;
@@ -102,7 +122,7 @@ Int_t AliESDVZERO::GetMTotV0C()
   return n;
 }
 
-
+//__________________________________________________________________________
 Int_t* AliESDVZERO::GetMRingV0A()
 {
 //  cout << "AliESDVZERO::GetMRingV0C() not supported any more" << endl;
@@ -112,6 +132,7 @@ Int_t* AliESDVZERO::GetMRingV0A()
   return 0x0;
 }
 
+//__________________________________________________________________________
 Int_t* AliESDVZERO::GetMRingV0C()
 {
 //  cout << "AliESDVZERO::GetMRingV0C() not supported any more" << endl;
@@ -121,6 +142,7 @@ Int_t* AliESDVZERO::GetMRingV0C()
   return 0x0;
 }
 
+//__________________________________________________________________________
 Int_t AliESDVZERO::GetMRingV0A(Int_t ring)
 { 
   if (OutOfRange(ring, "AliESDVZERO:::GetMRingV0A",4)) return -1;
@@ -133,18 +155,20 @@ Int_t AliESDVZERO::GetMRingV0A(Int_t ring)
   return n ;
 }
 
+//__________________________________________________________________________
 Int_t AliESDVZERO::GetMRingV0C(Int_t ring)
 { 
   if (OutOfRange(ring, "AliESDVZERO:::GetMRingV0C",4)) return -1;
   Int_t n=0;
 
-  if (ring == 0) for(Int_t i=0;i<8;i++) n += (Int_t) fMultiplicity[i];
-  if (ring == 1) for(Int_t i=8;i<16;i++) n += (Int_t) fMultiplicity[i];
+  if (ring == 0) for(Int_t i=0;i<8;i++)   n += (Int_t) fMultiplicity[i];
+  if (ring == 1) for(Int_t i=8;i<16;i++)  n += (Int_t) fMultiplicity[i];
   if (ring == 2) for(Int_t i=16;i<24;i++) n += (Int_t) fMultiplicity[i];
   if (ring == 3) for(Int_t i=24;i<32;i++) n += (Int_t) fMultiplicity[i];
   return n ;
 }
 
+//__________________________________________________________________________
 Int_t AliESDVZERO::GetMultiplicity(Int_t i)
 
 {
@@ -152,6 +176,7 @@ Int_t AliESDVZERO::GetMultiplicity(Int_t i)
   return fMultiplicity[i];
 }
 
+//__________________________________________________________________________
 Int_t AliESDVZERO::GetMultiplicityV0A(Int_t i)
 
 {
@@ -159,6 +184,7 @@ Int_t AliESDVZERO::GetMultiplicityV0A(Int_t i)
   return fMultiplicity[32+i];
 }
 
+//__________________________________________________________________________
 Int_t AliESDVZERO::GetMultiplicityV0C(Int_t i)
 
 {
@@ -166,6 +192,7 @@ Int_t AliESDVZERO::GetMultiplicityV0C(Int_t i)
   return fMultiplicity[i];
 }
 
+//__________________________________________________________________________
 Int_t AliESDVZERO::GetAdc(Int_t i)
 
 {
@@ -173,20 +200,23 @@ Int_t AliESDVZERO::GetAdc(Int_t i)
   return fAdc[i];
 }
 
-Int_t AliESDVZERO::GetAdcV0C(Int_t i)
+//__________________________________________________________________________
+Int_t AliESDVZERO::GetAdcV0A(Int_t i)
 
 {
-  if (OutOfRange(i, "AliESDVZERO::GetAdcV0C:",32)) return -1;
-  return fAdc[i];
+  if (OutOfRange(i, "AliESDVZERO::GetAdcV0A:",32)) return -1;
+  return fAdc[32+i];
 }
 
-Int_t AliESDVZERO::GetAdcV0A(Int_t i)
+//__________________________________________________________________________
+Int_t AliESDVZERO::GetAdcV0C(Int_t i)
 
 {
-  if (OutOfRange(i, "AliESDVZERO::GetAdcV0A:",32)) return -1;
-  return fAdc[32+i];
+  if (OutOfRange(i, "AliESDVZERO::GetAdcV0C:",32)) return -1;
+  return fAdc[i];
 }
 
+//__________________________________________________________________________
 Int_t AliESDVZERO::GetTime(Int_t i)
 
 {
@@ -194,6 +224,15 @@ Int_t AliESDVZERO::GetTime(Int_t i)
   return fTime[i];
 }
 
+//__________________________________________________________________________
+Int_t AliESDVZERO::GetTimeV0A(Int_t i)
+
+{
+  if (OutOfRange(i, "AliESDVZERO::GetTimeV0A:",32)) return -1;
+  return fTime[32+i];
+}
+
+//__________________________________________________________________________
 Int_t AliESDVZERO::GetTimeV0C(Int_t i)
 
 {
@@ -201,13 +240,31 @@ Int_t AliESDVZERO::GetTimeV0C(Int_t i)
   return fTime[i];
 }
 
-Int_t AliESDVZERO::GetTimeV0A(Int_t i)
+//__________________________________________________________________________
+Int_t AliESDVZERO::GetWidth(Int_t i)
 
 {
-  if (OutOfRange(i, "AliESDVZERO::GetTimeV0A:",32)) return -1;
-  return fTime[32+i];
+  if (OutOfRange(i, "AliESDVZERO::GetWidth:",64)) return -1;
+  return fWidth[i];
+}
+
+//__________________________________________________________________________
+Int_t AliESDVZERO::GetWidthV0A(Int_t i)
+
+{
+  if (OutOfRange(i, "AliESDVZERO::GetWidthV0A:",32)) return -1;
+  return fWidth[32+i];
+}
+
+//__________________________________________________________________________
+Int_t AliESDVZERO::GetWidthV0C(Int_t i)
+
+{
+  if (OutOfRange(i, "AliESDVZERO::GetWidthV0C:",32)) return -1;
+  return fWidth[i];
 }
 
+//__________________________________________________________________________
 Bool_t AliESDVZERO::BBTriggerV0A(Int_t i)
 {
   if (OutOfRange(i, "AliESDVZERO:::BBTriggerV0A",32)) return kFALSE;
@@ -215,6 +272,7 @@ Bool_t AliESDVZERO::BBTriggerV0A(Int_t i)
   return ( fBBtriggerV0A & (test << i) ? kTRUE : kFALSE );
 }
 
+//__________________________________________________________________________
 Bool_t AliESDVZERO::BGTriggerV0A(Int_t i)
 {
   if (OutOfRange(i, "AliESDVZERO:::BGTriggerV0A",32)) return kFALSE;
@@ -222,6 +280,7 @@ Bool_t AliESDVZERO::BGTriggerV0A(Int_t i)
   return ( fBGtriggerV0A & (test << i) ? kTRUE : kFALSE );
 }
 
+//__________________________________________________________________________
 Bool_t AliESDVZERO::BBTriggerV0C(Int_t i)
 {
   if (OutOfRange(i, "AliESDVZERO:::BBTriggerV0C",32)) return kFALSE;
@@ -229,6 +288,7 @@ Bool_t AliESDVZERO::BBTriggerV0C(Int_t i)
   return ( fBBtriggerV0C & (test << i) ? kTRUE : kFALSE );
 }
 
+//__________________________________________________________________________
 Bool_t AliESDVZERO::BGTriggerV0C(Int_t i)
 {
   if (OutOfRange(i, "AliESDVZERO:::BGTriggerV0C",32)) return kFALSE;
@@ -236,6 +296,23 @@ Bool_t AliESDVZERO::BGTriggerV0C(Int_t i)
   return ( fBGtriggerV0C & (test << i) ? kTRUE : kFALSE );
 }
 
+//__________________________________________________________________________
+Bool_t AliESDVZERO::GetBBFlag(Int_t i)
+
+{
+  if (OutOfRange(i, "AliESDVZERO::GetBBFlag:",64)) return kFALSE;
+  return fBBFlag[i];
+}
+
+//__________________________________________________________________________
+Bool_t AliESDVZERO::GetBGFlag(Int_t i)
+
+{
+  if (OutOfRange(i, "AliESDVZERO::GetBGFlag:",64)) return kFALSE;
+  return fBGFlag[i];
+}
+
+//__________________________________________________________________________
 Bool_t AliESDVZERO::OutOfRange(Int_t i, const char *s, Int_t upper) const
 {
   // checks if i is a valid index. s = name of calling method

diff --git a/STEER/AliESDVZERO.h b/STEER/AliESDVZERO.h
index 4b59e65f4959d9fee4bd1c4f3dd175766e8d8a4b..c817e862e074d3d5fc38c8ef3ead96cf1f68571b 100644 (file)
--- a/STEER/AliESDVZERO.h
+++ b/STEER/AliESDVZERO.h
@@ -8,12 +8,14 @@ class AliESDVZERO : public TObject
 public:
   AliESDVZERO();
   AliESDVZERO(const AliESDVZERO&);
-  AliESDVZERO(UInt_t BBtriggerV0A, UInt_t BGtriggerV0A,
-             UInt_t BBtriggerV0C, UInt_t BGtriggerV0C,
-             Short_t *Multiplicity,Short_t *Adc, Short_t *Time);
+  AliESDVZERO(UInt_t BBtriggerV0A,   UInt_t BGtriggerV0A,
+             UInt_t BBtriggerV0C,   UInt_t BGtriggerV0C,
+             Short_t *Multiplicity, Short_t *Adc, 
+             Short_t *Time, Short_t *Width, Bool_t *BBFlag, Bool_t *BGFlag);
 
   virtual ~AliESDVZERO() {};
   
+  // Setters
   virtual void SetBBtriggerV0A(UInt_t BBtrigger) {fBBtriggerV0A=BBtrigger;}
   virtual void SetBGtriggerV0A(UInt_t BGtrigger) {fBGtriggerV0A=BGtrigger;}
   virtual void SetBBtriggerV0C(UInt_t BBtrigger) {fBBtriggerV0C=BBtrigger;}
@@ -24,46 +26,60 @@ public:
     {for(Int_t i=0;i<64;i++) fAdc[i]=adc[i];}
   virtual void SetTime(Short_t time[64])
     {for(Int_t i=0;i<64;i++) fTime[i]=time[i];}
-
+  virtual void SetWidth(Short_t width[64])
+    {for(Int_t i=0;i<64;i++) fWidth[i]=width[i];}    
+  virtual void SetBBFlag(Bool_t BBFlag[64])
+    {for(Int_t i=0;i<64;i++) fBBFlag[i]=BBFlag[i];} 
+  virtual void SetBGFlag(Bool_t BGFlag[64])
+    {for(Int_t i=0;i<64;i++) fBGFlag[i]=BGFlag[i];}   
+         
   // Getters  
   Short_t GetNbPMV0A();
   Short_t GetNbPMV0C();
-  Int_t GetMTotV0A();
-  Int_t GetMTotV0C(); 
-  Int_t* GetMRingV0A();
-  Int_t* GetMRingV0C();
-  Int_t GetMRingV0A(Int_t ring);
-  Int_t GetMRingV0C(Int_t ring);
-
-  Int_t GetMultiplicity(Int_t i);
-  Int_t GetAdc(Int_t i);
-  Int_t GetTime(Int_t i);
-  Int_t GetMultiplicityV0A(Int_t i);
-  Int_t GetAdcV0A(Int_t i);
-  Int_t GetTimeV0A(Int_t i);
-  Int_t GetMultiplicityV0C(Int_t i);
-  Int_t GetAdcV0C(Int_t i);
-  Int_t GetTimeV0C(Int_t i);
-  Bool_t BBTriggerV0A(Int_t i);
-  Bool_t BGTriggerV0A(Int_t i);
-  Bool_t BBTriggerV0C(Int_t i);
-  Bool_t BGTriggerV0C(Int_t i);
+  Int_t   GetMTotV0A();
+  Int_t   GetMTotV0C(); 
+  Int_t*  GetMRingV0A();
+  Int_t*  GetMRingV0C();
+  Int_t   GetMRingV0A(Int_t ring);
+  Int_t   GetMRingV0C(Int_t ring);
 
+  Int_t   GetMultiplicity(Int_t i);
+  Int_t   GetMultiplicityV0A(Int_t i);
+  Int_t   GetMultiplicityV0C(Int_t i);    
+  Int_t   GetAdc(Int_t i);
+  Int_t   GetAdcV0A(Int_t i); 
+  Int_t   GetAdcV0C(Int_t i);   
+  Int_t   GetTime(Int_t i);
+  Int_t   GetTimeV0A(Int_t i);   
+  Int_t   GetTimeV0C(Int_t i);    
+  Int_t   GetWidth(Int_t i);
+  Int_t   GetWidthV0A(Int_t i);
+  Int_t   GetWidthV0C(Int_t i);
+  Bool_t  BBTriggerV0A(Int_t i);
+  Bool_t  BGTriggerV0A(Int_t i);
+  Bool_t  BBTriggerV0C(Int_t i);
+  Bool_t  BGTriggerV0C(Int_t i);  
+  Bool_t  GetBBFlag(Int_t i);
+  Bool_t  GetBGFlag(Int_t i);
+  
   Bool_t OutOfRange(Int_t i, const char *s, Int_t upper) const;
   AliESDVZERO &operator=(const AliESDVZERO& source);
     
 protected:
 
-  UInt_t fBBtriggerV0A; // bit mask for Beam-Beam trigger in V0A
-  UInt_t fBGtriggerV0A; // bit mask for Beam-Gas trigger in V0A
-  UInt_t fBBtriggerV0C; // bit mask for Beam-Beam trigger in V0C
-  UInt_t fBGtriggerV0C; // bit mask for Beam-Gas trigger in V0C
+  UInt_t  fBBtriggerV0A;     // bit mask for Beam-Beam trigger in V0A
+  UInt_t  fBGtriggerV0A;     // bit mask for Beam-Gas trigger in V0A
+  UInt_t  fBBtriggerV0C;     // bit mask for Beam-Beam trigger in V0C
+  UInt_t  fBGtriggerV0C;     // bit mask for Beam-Gas trigger in V0C
 
-  Short_t fMultiplicity[64]; // multiplicity per PMT
-  Short_t fAdc[64]; //  adc per PMT
-  Short_t fTime[64]; // time per PMT
-
-  ClassDef(AliESDVZERO,4)
+  Short_t fMultiplicity[64]; //  multiplicity for each channel
+  Short_t fAdc[64];          //  adc for each channel
+  Short_t fTime[64];         //  time for each channel
+  Short_t fWidth[64];        //  time width for each channel
+  Bool_t  fBBFlag[64];       //  BB Flags from Online V0 Electronics
+  Bool_t  fBGFlag[64];       //  BG Flags from Online V0 Electronics
+  
+  ClassDef(AliESDVZERO,5)
 };
 
 #endif

diff --git a/VZERO/AliVZEROReconstructor.cxx b/VZERO/AliVZEROReconstructor.cxx
index f250ee65740b33b1db19c643048bf17af69b5841..38292164a999b6ddb7b83e98b9d834cbb4a2385d 100644 (file)
--- a/VZERO/AliVZEROReconstructor.cxx
+++ b/VZERO/AliVZEROReconstructor.cxx
@@ -86,24 +86,30 @@ void AliVZEROReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digits
   rawReader->Reset();
   AliVZERORawStream rawStream(rawReader);
   if (rawStream.Next()) {  
-     Int_t ADC_max[64], adc[64], time[64];   
+     Int_t ADC_max[64], adc[64], time[64], width[64], BBFlag[64], BGFlag[64];   
      for(Int_t i=0; i<64; i++) {
          // Search for the maximum charge in the train of 21 LHC clocks 
          // regardless of the integrator which has been operated:
          ADC_max[i] = 0;
+        Int_t imax = 0;
          for(Int_t iClock=0; iClock<21; iClock++){
              if((Int_t)rawStream.GetPedestal(i,iClock) > ADC_max[i])  
-               {ADC_max[i]=(Int_t)rawStream.GetPedestal(i,iClock);}
+               {ADC_max[i]=(Int_t)rawStream.GetPedestal(i,iClock);
+                imax      = iClock;}
          }
         // Convert i (FEE channel numbering) to j (aliroot channel numbering)
-        Int_t j =  rawStream.GetOfflineChannel(i);
-        adc[j]  =  ADC_max[i];
-        time[j] =  rawStream.GetTime(i); 
+        Int_t j   =  rawStream.GetOfflineChannel(i);
+        adc[j]    =  ADC_max[i];
+        time[j]   =  rawStream.GetTime(i);
+        width[j]  =  rawStream.GetWidth(i);
+        BBFlag[j] =  rawStream.GetBBFlag(i,imax);
+        BGFlag[j] =  rawStream.GetBGFlag(i,imax); 
      }  
      // Channels(aliroot numbering) will be ordered in the tree
      for(Int_t iChannel = 0; iChannel < 64; iChannel++) {
          new ((*digitsArray)[digitsArray->GetEntriesFast()])
-             AliVZEROdigit(iChannel,adc[iChannel],time[iChannel]);
+             AliVZEROdigit(iChannel, adc[iChannel], time[iChannel],
+                          width[iChannel], BBFlag[iChannel], BGFlag[iChannel]);
      }
   }
 
@@ -129,9 +135,17 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,
   Float_t   mult[64];  
   Short_t    adc[64]; 
   Short_t   time[64]; 
+  Short_t  width[64];
+  Bool_t  BBFlag[64];
+  Bool_t  BGFlag[64];
+   
   for (Int_t i=0; i<64; i++){
-       adc[i] = 0;
-       mult[i]= 0.0;
+       adc[i]    = 0;
+       mult[i]   = 0.0;
+       time[i]   = 0;
+       width[i]  = 0;
+       BBFlag[i] = kFALSE;
+       BGFlag[i] = kFALSE;
   }
      
   // loop over VZERO entries to get multiplicity
@@ -146,8 +160,11 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,
         Int_t  pmNumber      = digit->PMNumber(); 
         // Pedestal retrieval and suppression: 
         Int_t  pedestal      = int(fCalibData->GetPedestal(d));
-        adc[pmNumber]  = (Short_t) digit->ADC() - pedestal; 
-        time[pmNumber] = (Short_t) digit->Time();
+        adc[pmNumber]   = (Short_t) digit->ADC() - pedestal; 
+        time[pmNumber]  = (Short_t) digit->Time();
+       width[pmNumber] = (Short_t) digit->Width();
+       BBFlag[pmNumber]= digit->BBFlag();
+       BGFlag[pmNumber]= digit->BGFlag();
         // printf("PM = %d,  MIP per ADC channel = %f \n",pmNumber, GetMIP(pmNumber));
         // cut of ADC at 1MIP/2 
         if (adc[pmNumber] > (int(1.0/GetMIP(pmNumber)) /2) ) 
@@ -155,10 +172,14 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,
     } // end of loop over digits
   } // end of loop over events in digits tree
   
-  for (Int_t j=0; j<64; j++) Multiplicity[j] = short(mult[j]+0.5);       
+  for (Int_t j=0; j<64; j++) Multiplicity[j] = short(mult[j]+0.5); 
+        
   fESDVZERO->SetMultiplicity(Multiplicity);
   fESDVZERO->SetADC(adc);
   fESDVZERO->SetTime(time);
+  fESDVZERO->SetWidth(width);
+  fESDVZERO->SetBBFlag(BBFlag);
+  fESDVZERO->SetBGFlag(BGFlag);
 
   // now get the trigger mask
 

diff --git a/VZERO/AliVZEROdigit.cxx b/VZERO/AliVZEROdigit.cxx
index 537876dcbeffcd5b1d187d22a905cae303d49ea8..5ff5b30e43727d33139c21e6f1089fe06584228b 100644 (file)
--- a/VZERO/AliVZEROdigit.cxx
+++ b/VZERO/AliVZEROdigit.cxx
@@ -17,6 +17,7 @@
 
 ClassImp(AliVZEROdigit)
 
+//__________________________________________________________________________
 AliVZEROdigit::AliVZEROdigit()
    :AliDigit(),
     fTrack(0),
@@ -29,6 +30,7 @@ AliVZEROdigit::AliVZEROdigit()
   // Standard default constructor 
 }
 
+//__________________________________________________________________________
 AliVZEROdigit::AliVZEROdigit(Int_t* tracks, Int_t *digits):
    AliDigit(tracks),
    fTrack(0),
@@ -38,7 +40,6 @@ AliVZEROdigit::AliVZEROdigit(Int_t* tracks, Int_t *digits):
    fTime(0)
   
 {
-  
   // Creates VZERO digits  
   // Fills the AliVZEROdigit data members from the array digits. 
     
@@ -46,6 +47,7 @@ AliVZEROdigit::AliVZEROdigit(Int_t* tracks, Int_t *digits):
   fEvent      =  digits[0];  
 }
 
+//__________________________________________________________________________
 AliVZEROdigit::AliVZEROdigit(Int_t PMnumber, Int_t adc, Int_t time)
    :AliDigit(),
    fTrack(0),
@@ -59,8 +61,33 @@ AliVZEROdigit::AliVZEROdigit(Int_t PMnumber, Int_t adc, Int_t time)
    fTime       = time;
 }
 
+//__________________________________________________________________________
+AliVZEROdigit::AliVZEROdigit(Int_t PMnumber, Int_t adc, Int_t time, 
+                             Int_t width, Bool_t BBFlag, Bool_t BGFlag)
+   :AliDigit(),
+   fTrack(0),
+   fEvent(0),
+   fPMNumber(0),
+   fTime(0),
+   fWidth(0),
+   fBBFlag(0),
+   fBGFlag(0)
+{  
+
+   fPMNumber   = PMnumber;    // PM number
+   fADC        = adc;         // ADC value
+   fTime       = time;        // Leading time 
+   fWidth      = width;       // Time Width
+   fBBFlag     = BBFlag;      // Beam Beam Flag
+   fBGFlag     = BGFlag;      // Beam Gas  Flag
+
+}
+
+//__________________________________________________________________________
 void AliVZEROdigit::Print(const Option_t*) const
 {
+    // Dumps digit object
+    
     Dump();
 }
 

diff --git a/VZERO/AliVZEROdigit.h b/VZERO/AliVZEROdigit.h
index d6b6f0cd65afa3f0ca7f2a5d13839a83960a59b0..ac87b4b2c0a746e996d8dc835fe59c52f8e267b1 100644 (file)
--- a/VZERO/AliVZEROdigit.h
+++ b/VZERO/AliVZEROdigit.h
@@ -13,24 +13,32 @@ class AliVZEROdigit: public AliDigit  {
  public:
     AliVZEROdigit();
     AliVZEROdigit(Int_t* tracks, Int_t* digits);
-    AliVZEROdigit(Int_t /* PMnumber */, Int_t /* ADC */, Int_t /* Time */);
+    AliVZEROdigit(Int_t /* PMnumber */, Int_t  /* ADC */, Int_t /* Time */);
+    AliVZEROdigit(Int_t /* PMnumber */, Int_t  /* ADC */, Int_t /* Time */, 
+                  Int_t /* TimeWidth*/, Bool_t /* BBFlag */, Bool_t /* BGFlag */);
     virtual ~AliVZEROdigit() {};
     virtual void Print(const Option_t* option="") const;
     
-    Int_t   PMNumber()  const {return fPMNumber;}    
-    Int_t   ADC()  const {return fADC;}
-    Int_t   Time() const {return fTime;}
-     
+    Int_t   PMNumber() const {return fPMNumber;}    
+    Int_t   ADC()      const {return fADC;}
+    Int_t   Time()     const {return fTime;}
+    Int_t   Width()    const {return fWidth;} 
+    Bool_t  BBFlag()   const {return fBBFlag;} 
+    Bool_t  BGFlag()   const {return fBGFlag;}
+       
   private:
     Int_t  fTrack;         // Track number
     
   protected:
     Int_t  fEvent;         // Event number  
-    Int_t  fPMNumber;      // Photomultiplier number (0 to 63)
+    Int_t  fPMNumber;      // PhotoMultiplier number (0 to 63)
     Int_t  fADC;           // ADC response
     Int_t  fTime;          // Time of Flight
+    Int_t  fWidth;         // Width of the time distribution
+    Bool_t fBBFlag;        // Beam-Beam Flag given by Yannick in Raw Data only
+    Bool_t fBGFlag;        // Beam-Gas  Flag given by Yannick in Raw Data only
     
-    ClassDef(AliVZEROdigit,1)  //Digit (Header) object for set : VZERO
+    ClassDef(AliVZEROdigit,2)  //Digit (Header) object for set : VZERO
 };
 
 #endif