1. Leading time was not decoded properly (there are coarse and fine gains in the...
authorcvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 3 Sep 2009 11:46:07 +0000 (11:46 +0000)
committercvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 3 Sep 2009 11:46:07 +0000 (11:46 +0000)
14 files changed:
STEER/AliESDVZERO.cxx
STEER/AliESDVZERO.h
STEER/AliESDVZEROfriend.cxx
STEER/AliESDVZEROfriend.h
VZERO/AliVZERO.cxx
VZERO/AliVZEROBuffer.cxx
VZERO/AliVZEROBuffer.h
VZERO/AliVZERODigitizer.cxx
VZERO/AliVZERODigitizer.h
VZERO/AliVZERORawStream.cxx
VZERO/AliVZERORawStream.h
VZERO/AliVZEROReconstructor.cxx
VZERO/AliVZEROdigit.cxx
VZERO/AliVZEROdigit.h

index 450ef53..5a77f33 100644 (file)
@@ -14,9 +14,9 @@ AliESDVZERO::AliESDVZERO()
    // Default constructor 
    for(Int_t j=0; j<64; j++){ 
       fMultiplicity[j] = 0.0;   
-      fAdc[j]   = 0;   
-      fTime[j]  = 0; 
-      fWidth[j] = 0; 
+      fAdc[j]   = 0.0;   
+      fTime[j]  = 0.0; 
+      fWidth[j] = 0.0; 
       fBBFlag[j]= kFALSE;
       fBGFlag[j]= kFALSE;  
    }
@@ -44,8 +44,8 @@ AliESDVZERO::AliESDVZERO(const AliESDVZERO &o)
 //__________________________________________________________________________
 AliESDVZERO::AliESDVZERO(UInt_t BBtriggerV0A, UInt_t BGtriggerV0A,
              UInt_t BBtriggerV0C, UInt_t BGtriggerV0C,
-             Float_t *Multiplicity, Short_t *Adc, 
-             Short_t *Time, Short_t *Width, Bool_t *BBFlag, Bool_t *BGFlag)
+             Float_t *Multiplicity, Float_t *Adc, 
+             Float_t *Time, Float_t *Width, Bool_t *BBFlag, Bool_t *BGFlag)
   :TObject(),
    fBBtriggerV0A(BBtriggerV0A),
    fBGtriggerV0A(BGtriggerV0A),
@@ -109,7 +109,7 @@ Float_t AliESDVZERO::GetMTotV0A()
 {
   Float_t mul=0.0;
   for(Int_t i=32;i<64;i++) 
-    mul+= (Float_t) fMultiplicity[i];
+    mul+=  fMultiplicity[i];
   return mul;
 }
 
@@ -118,7 +118,7 @@ Float_t AliESDVZERO::GetMTotV0C()
 {
   Float_t mul=0.0;
   for(Int_t i=0;i<32;i++) 
-    mul+= (Float_t) fMultiplicity[i];
+    mul+=  fMultiplicity[i];
   return mul;
 }
 
@@ -148,10 +148,10 @@ Float_t AliESDVZERO::GetMRingV0A(Int_t ring)
   if (OutOfRange(ring, "AliESDVZERO:::GetMRingV0A",4)) return -1;
   Float_t mul =0.0;
 
-  if (ring == 0) for(Int_t i=32;i<40;i++) mul += (Float_t) fMultiplicity[i];
-  if (ring == 1) for(Int_t i=40;i<48;i++) mul += (Float_t) fMultiplicity[i];
-  if (ring == 2) for(Int_t i=48;i<56;i++) mul += (Float_t) fMultiplicity[i];
-  if (ring == 3) for(Int_t i=56;i<64;i++) mul += (Float_t) fMultiplicity[i];
+  if (ring == 0) for(Int_t i=32;i<40;i++) mul +=  fMultiplicity[i];
+  if (ring == 1) for(Int_t i=40;i<48;i++) mul +=  fMultiplicity[i];
+  if (ring == 2) for(Int_t i=48;i<56;i++) mul +=  fMultiplicity[i];
+  if (ring == 3) for(Int_t i=56;i<64;i++) mul +=  fMultiplicity[i];
   return mul ;
 }
 
@@ -161,10 +161,10 @@ Float_t AliESDVZERO::GetMRingV0C(Int_t ring)
   if (OutOfRange(ring, "AliESDVZERO:::GetMRingV0C",4)) return -1;
   Float_t mul =0.0;
 
-  if (ring == 0) for(Int_t i=0;i<8;i++)   mul += (Float_t) fMultiplicity[i];
-  if (ring == 1) for(Int_t i=8;i<16;i++)  mul += (Float_t) fMultiplicity[i];
-  if (ring == 2) for(Int_t i=16;i<24;i++) mul += (Float_t) fMultiplicity[i];
-  if (ring == 3) for(Int_t i=24;i<32;i++) mul += (Float_t) fMultiplicity[i];
+  if (ring == 0) for(Int_t i=0;i<8;i++)   mul +=  fMultiplicity[i];
+  if (ring == 1) for(Int_t i=8;i<16;i++)  mul +=  fMultiplicity[i];
+  if (ring == 2) for(Int_t i=16;i<24;i++) mul +=  fMultiplicity[i];
+  if (ring == 3) for(Int_t i=24;i<32;i++) mul +=  fMultiplicity[i];
   return mul ;
 }
 
@@ -193,7 +193,7 @@ Float_t AliESDVZERO::GetMultiplicityV0C(Int_t i)
 }
 
 //__________________________________________________________________________
-Int_t AliESDVZERO::GetAdc(Int_t i)
+Float_t AliESDVZERO::GetAdc(Int_t i)
 
 {
   if (OutOfRange(i, "AliESDVZERO::GetAdc:",64)) return -1;
@@ -201,7 +201,7 @@ Int_t AliESDVZERO::GetAdc(Int_t i)
 }
 
 //__________________________________________________________________________
-Int_t AliESDVZERO::GetAdcV0A(Int_t i)
+Float_t AliESDVZERO::GetAdcV0A(Int_t i)
 
 {
   if (OutOfRange(i, "AliESDVZERO::GetAdcV0A:",32)) return -1;
@@ -209,7 +209,7 @@ Int_t AliESDVZERO::GetAdcV0A(Int_t i)
 }
 
 //__________________________________________________________________________
-Int_t AliESDVZERO::GetAdcV0C(Int_t i)
+Float_t AliESDVZERO::GetAdcV0C(Int_t i)
 
 {
   if (OutOfRange(i, "AliESDVZERO::GetAdcV0C:",32)) return -1;
@@ -217,7 +217,7 @@ Int_t AliESDVZERO::GetAdcV0C(Int_t i)
 }
 
 //__________________________________________________________________________
-Int_t AliESDVZERO::GetTime(Int_t i)
+Float_t AliESDVZERO::GetTime(Int_t i)
 
 {
   if (OutOfRange(i, "AliESDVZERO::GetTime:",64)) return -1;
@@ -225,7 +225,7 @@ Int_t AliESDVZERO::GetTime(Int_t i)
 }
 
 //__________________________________________________________________________
-Int_t AliESDVZERO::GetTimeV0A(Int_t i)
+Float_t AliESDVZERO::GetTimeV0A(Int_t i)
 
 {
   if (OutOfRange(i, "AliESDVZERO::GetTimeV0A:",32)) return -1;
@@ -233,7 +233,7 @@ Int_t AliESDVZERO::GetTimeV0A(Int_t i)
 }
 
 //__________________________________________________________________________
-Int_t AliESDVZERO::GetTimeV0C(Int_t i)
+Float_t AliESDVZERO::GetTimeV0C(Int_t i)
 
 {
   if (OutOfRange(i, "AliESDVZERO::GetTimeV0C:",32)) return -1;
@@ -241,7 +241,7 @@ Int_t AliESDVZERO::GetTimeV0C(Int_t i)
 }
 
 //__________________________________________________________________________
-Int_t AliESDVZERO::GetWidth(Int_t i)
+Float_t AliESDVZERO::GetWidth(Int_t i)
 
 {
   if (OutOfRange(i, "AliESDVZERO::GetWidth:",64)) return -1;
@@ -249,7 +249,7 @@ Int_t AliESDVZERO::GetWidth(Int_t i)
 }
 
 //__________________________________________________________________________
-Int_t AliESDVZERO::GetWidthV0A(Int_t i)
+Float_t AliESDVZERO::GetWidthV0A(Int_t i)
 
 {
   if (OutOfRange(i, "AliESDVZERO::GetWidthV0A:",32)) return -1;
@@ -257,7 +257,7 @@ Int_t AliESDVZERO::GetWidthV0A(Int_t i)
 }
 
 //__________________________________________________________________________
-Int_t AliESDVZERO::GetWidthV0C(Int_t i)
+Float_t AliESDVZERO::GetWidthV0C(Int_t i)
 
 {
   if (OutOfRange(i, "AliESDVZERO::GetWidthV0C:",32)) return -1;
index fcdc03b..43e6927 100644 (file)
@@ -10,8 +10,8 @@ public:
   AliESDVZERO(const AliESDVZERO&);
   AliESDVZERO(UInt_t BBtriggerV0A,   UInt_t BGtriggerV0A,
              UInt_t BBtriggerV0C,   UInt_t BGtriggerV0C,
-             Float_t *Multiplicity, Short_t *Adc, 
-             Short_t *Time, Short_t *Width, Bool_t *BBFlag, Bool_t *BGFlag);
+             Float_t *Multiplicity, Float_t *Adc, 
+             Float_t *Time, Float_t *Width, Bool_t *BBFlag, Bool_t *BGFlag);
 
   virtual ~AliESDVZERO() {};
   
@@ -22,11 +22,11 @@ public:
   virtual void SetBGtriggerV0C(UInt_t BGtrigger) {fBGtriggerV0C=BGtrigger;}
   virtual void SetMultiplicity(Float_t Multiplicity[64])
     {for(Int_t i=0;i<64;i++) fMultiplicity[i]=Multiplicity[i];}
-  virtual void SetADC(Short_t adc[64])
+  virtual void SetADC(Float_t adc[64])
     {for(Int_t i=0;i<64;i++) fAdc[i]=adc[i];}
-  virtual void SetTime(Short_t time[64])
+  virtual void SetTime(Float_t time[64])
     {for(Int_t i=0;i<64;i++) fTime[i]=time[i];}
-  virtual void SetWidth(Short_t width[64])
+  virtual void SetWidth(Float_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];} 
@@ -46,15 +46,15 @@ public:
   Float_t  GetMultiplicity(Int_t i);
   Float_t  GetMultiplicityV0A(Int_t i);
   Float_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);
+  Float_t  GetAdc(Int_t i);
+  Float_t  GetAdcV0A(Int_t i); 
+  Float_t  GetAdcV0C(Int_t i);   
+  Float_t  GetTime(Int_t i);
+  Float_t  GetTimeV0A(Int_t i);   
+  Float_t  GetTimeV0C(Int_t i);    
+  Float_t  GetWidth(Int_t i);
+  Float_t  GetWidthV0A(Int_t i);
+  Float_t  GetWidthV0C(Int_t i);
   Bool_t   BBTriggerV0A(Int_t i);
   Bool_t   BGTriggerV0A(Int_t i);
   Bool_t   BBTriggerV0C(Int_t i);
@@ -73,13 +73,13 @@ protected:
   UInt_t  fBGtriggerV0C;     // bit mask for Beam-Gas trigger in V0C
 
   Float_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
+  Float_t fAdc[64];          //  adc for each channel
+  Float_t fTime[64];         //  time for each channel
+  Float_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,6)
+  ClassDef(AliESDVZERO,7)
 };
 
 #endif
index a242bb4..65a8f2c 100644 (file)
@@ -42,18 +42,18 @@ AliESDVZEROfriend::AliESDVZEROfriend():
     fBGScalers[iChannel] = 0;
     for (Int_t iBunch = 0; iBunch < kNBunches; iBunch++) {
       fChargeMB[iChannel][iBunch] = 0;
-      fIsIntMB[iChannel][iBunch] = kFALSE;
-      fIsBBMB[iChannel][iBunch] = kFALSE;
-      fIsBGMB[iChannel][iBunch] = kFALSE;
+      fIsIntMB[iChannel][iBunch]  = kFALSE;
+      fIsBBMB[iChannel][iBunch]   = kFALSE;
+      fIsBGMB[iChannel][iBunch]   = kFALSE;
     }
     for (Int_t iEv = 0; iEv < kNEvOfInt; iEv++) {
-      fADC[iChannel][iEv] = 0;
+      fADC[iChannel][iEv]   = 0.0;
       fIsInt[iChannel][iEv] = kFALSE;
-      fIsBB[iChannel][iEv] = kFALSE;
-      fIsBG[iChannel][iEv] = kFALSE;
+      fIsBB[iChannel][iEv]  = kFALSE;
+      fIsBG[iChannel][iEv]  = kFALSE;
     }
-    fTime[iChannel] = 0;
-    fWidth[iChannel] = 0;
+    fTime[iChannel]  = 0.0;
+    fWidth[iChannel] = 0.0;
   }
 }
 
@@ -81,17 +81,17 @@ AliESDVZEROfriend::AliESDVZEROfriend(const AliESDVZEROfriend& vzerofriend):
     fBGScalers[iChannel] = vzerofriend.fBGScalers[iChannel];
     for (Int_t iBunch = 0; iBunch < kNBunches; iBunch++) {
       fChargeMB[iChannel][iBunch] = vzerofriend.fChargeMB[iChannel][iBunch];
-      fIsIntMB[iChannel][iBunch] = vzerofriend.fIsIntMB[iChannel][iBunch];
-      fIsBBMB[iChannel][iBunch] = vzerofriend.fIsBBMB[iChannel][iBunch];
-      fIsBGMB[iChannel][iBunch] = vzerofriend.fIsBGMB[iChannel][iBunch];
+      fIsIntMB[iChannel][iBunch]  = vzerofriend.fIsIntMB[iChannel][iBunch];
+      fIsBBMB[iChannel][iBunch]   = vzerofriend.fIsBBMB[iChannel][iBunch];
+      fIsBGMB[iChannel][iBunch]   = vzerofriend.fIsBGMB[iChannel][iBunch];
     }
     for (Int_t iEv = 0; iEv < kNEvOfInt; iEv++) {
-      fADC[iChannel][iEv] = vzerofriend.fADC[iChannel][iEv];
+      fADC[iChannel][iEv]   = vzerofriend.fADC[iChannel][iEv];
       fIsInt[iChannel][iEv] = vzerofriend.fIsInt[iChannel][iEv];
-      fIsBB[iChannel][iEv] = vzerofriend.fIsBB[iChannel][iEv];
-      fIsBG[iChannel][iEv] = vzerofriend.fIsBG[iChannel][iEv];
+      fIsBB[iChannel][iEv]  = vzerofriend.fIsBB[iChannel][iEv];
+      fIsBG[iChannel][iEv]  = vzerofriend.fIsBG[iChannel][iEv];
     }
-    fTime[iChannel] = vzerofriend.fTime[iChannel];
+    fTime[iChannel]  = vzerofriend.fTime[iChannel];
     fWidth[iChannel] = vzerofriend.fWidth[iChannel];
   }
 }
@@ -117,17 +117,17 @@ AliESDVZEROfriend& AliESDVZEROfriend::operator = (const AliESDVZEROfriend& vzero
     fBGScalers[iChannel] = vzerofriend.fBGScalers[iChannel];
     for (Int_t iBunch = 0; iBunch < kNBunches; iBunch++) {
       fChargeMB[iChannel][iBunch] = vzerofriend.fChargeMB[iChannel][iBunch];
-      fIsIntMB[iChannel][iBunch] = vzerofriend.fIsIntMB[iChannel][iBunch];
-      fIsBBMB[iChannel][iBunch] = vzerofriend.fIsBBMB[iChannel][iBunch];
-      fIsBGMB[iChannel][iBunch] = vzerofriend.fIsBGMB[iChannel][iBunch];
+      fIsIntMB[iChannel][iBunch]  = vzerofriend.fIsIntMB[iChannel][iBunch];
+      fIsBBMB[iChannel][iBunch]   = vzerofriend.fIsBBMB[iChannel][iBunch];
+      fIsBGMB[iChannel][iBunch]   = vzerofriend.fIsBGMB[iChannel][iBunch];
     }
     for (Int_t iEv = 0; iEv < kNEvOfInt; iEv++) {
-      fADC[iChannel][iEv] = vzerofriend.fADC[iChannel][iEv];
+      fADC[iChannel][iEv]   = vzerofriend.fADC[iChannel][iEv];
       fIsInt[iChannel][iEv] = vzerofriend.fIsInt[iChannel][iEv];
-      fIsBB[iChannel][iEv] = vzerofriend.fIsBB[iChannel][iEv];
-      fIsBG[iChannel][iEv] = vzerofriend.fIsBG[iChannel][iEv];
+      fIsBB[iChannel][iEv]  = vzerofriend.fIsBB[iChannel][iEv];
+      fIsBG[iChannel][iEv]  = vzerofriend.fIsBG[iChannel][iEv];
     }
-    fTime[iChannel] = vzerofriend.fTime[iChannel];
+    fTime[iChannel]  = vzerofriend.fTime[iChannel];
     fWidth[iChannel] = vzerofriend.fWidth[iChannel];
   }
 
@@ -151,18 +151,18 @@ void AliESDVZEROfriend::Reset()
     fBGScalers[iChannel] = 0;
     for (Int_t iBunch = 0; iBunch < kNBunches; iBunch++) {
       fChargeMB[iChannel][iBunch] = 0;
-      fIsIntMB[iChannel][iBunch] = kFALSE;
-      fIsBBMB[iChannel][iBunch] = kFALSE;
-      fIsBGMB[iChannel][iBunch] = kFALSE;
+      fIsIntMB[iChannel][iBunch]  = kFALSE;
+      fIsBBMB[iChannel][iBunch]   = kFALSE;
+      fIsBGMB[iChannel][iBunch]   = kFALSE;
     }
     for (Int_t iEv = 0; iEv < kNEvOfInt; iEv++) {
-      fADC[iChannel][iEv] = 0;
+      fADC[iChannel][iEv]   = 0.0;
       fIsInt[iChannel][iEv] = kFALSE;
-      fIsBB[iChannel][iEv] = kFALSE;
-      fIsBG[iChannel][iEv] = kFALSE;
+      fIsBB[iChannel][iEv]  = kFALSE;
+      fIsBG[iChannel][iEv]  = kFALSE;
     }
-    fTime[iChannel] = 0;
-    fWidth[iChannel] = 0;
+    fTime[iChannel]  = 0.0;
+    fWidth[iChannel] = 0.0;
   }
   
 }
index 77499e9..73bf836 100644 (file)
@@ -43,9 +43,9 @@ class AliESDVZEROfriend: public TObject {
        
 // Getters of ADC signals, ADC pedestals, time information and corresponding flags :
 
-    UShort_t          GetADC(Int_t channel) const
+    Float_t           GetADC(Int_t channel) const
       { return fADC[channel][kNEvOfInt/2]; }
-    UShort_t          GetPedestal(Int_t channel, Int_t event) const
+    Float_t           GetPedestal(Int_t channel, Int_t event) const
       { return fADC[channel][event]; }
     Bool_t            GetIntegratorFlag(Int_t channel, Int_t event) const
       { return fIsInt[channel][event]; }
@@ -53,9 +53,9 @@ class AliESDVZEROfriend: public TObject {
       { return fIsBB[channel][event]; } 
     Bool_t            GetBGFlag(Int_t channel, Int_t event) const
       { return fIsBG[channel][event]; }   
-    UInt_t            GetTime(Int_t channel) const
+    Float_t            GetTime(Int_t channel) const
       { return fTime[channel]; }
-    UInt_t            GetWidth(Int_t channel) const
+    Float_t            GetWidth(Int_t channel) const
       { return fWidth[channel]; }
 
     // Setters
@@ -76,7 +76,7 @@ class AliESDVZEROfriend: public TObject {
     void              SetBGMBFlag(Int_t channel,Int_t num_bunch, Bool_t flag)
       { fIsBGMB[channel][num_bunch] = flag; }
 
-    void              SetPedestal(Int_t channel, Int_t event, UShort_t adc)
+    void              SetPedestal(Int_t channel, Int_t event, Float_t adc)
       { fADC[channel][event] = adc; }
     void              SetIntegratorFlag(Int_t channel, Int_t event, Bool_t flag)
       { fIsInt[channel][event] = flag; }
@@ -84,9 +84,9 @@ class AliESDVZEROfriend: public TObject {
       { fIsBB[channel][event] = flag; }
     void              SetBGFlag(Int_t channel, Int_t event, Bool_t flag)
       { fIsBB[channel][event] = flag; }
-    void              SetTime(Int_t channel, UInt_t time)
+    void              SetTime(Int_t channel, Float_t time)
       { fTime[channel] = time; }
-    void              SetWidth(Int_t channel, UInt_t width)
+    void              SetWidth(Int_t channel, Float_t width)
       { fWidth[channel] = width; }
 
     UShort_t          GetTriggerInputs() const
@@ -116,17 +116,17 @@ class AliESDVZEROfriend: public TObject {
     Bool_t        fIsBBMB[kNChannels][kNBunches];   // 'Beam-Beam' flag for all channels for the previous 10 MB events
     Bool_t        fIsBGMB[kNChannels][kNBunches];   // 'Beam-Gas' for all channels for the previous 10 MB events
 
-    UShort_t      fADC[kNChannels][kNEvOfInt];   // ADC counts for all channels and all events of interest
+    Float_t       fADC[kNChannels][kNEvOfInt];   // ADC counts for all channels and all events of interest
     Bool_t        fIsInt[kNChannels][kNEvOfInt]; // 'Integrator' flag for all channels 
     Bool_t        fIsBB[kNChannels][kNEvOfInt];  // 'Beam-Beam' flag for all channels
     Bool_t        fIsBG[kNChannels][kNEvOfInt];  // 'Beam-Gas' flag for all channels
-    Int_t         fTime[kNChannels];             // leading time for all channels - from HPTDC
-    Int_t         fWidth[kNChannels];            // pulse width for all channels - from HPTDC
+    Float_t       fTime[kNChannels];             // leading time for all channels - from HPTDC - in nanoseconds
+    Float_t       fWidth[kNChannels];            // pulse width for all channels - from HPTDC - in nanoseconds
 
     UShort_t      fTrigger;        // VZERO trigger inputs
     UShort_t      fTriggerMask;    // VZERO trigger inputs mask
 
-    ClassDef(AliESDVZEROfriend, 1) // container class for VZERO DDL raw data
+    ClassDef(AliESDVZEROfriend, 2) // container class for VZERO DDL raw data
 };
 
 #endif
index a6adecc..947d88f 100755 (executable)
@@ -300,9 +300,9 @@ void AliVZERO::Digits2Raw()
    // digits!!
 
    Int_t nEntries = Int_t(digits->GetEntries());
-   UInt_t ADC[64];
+   Float_t ADC[64];
    Int_t PMNumber[64];
-   UInt_t Time[64];
+   Float_t Time[64];
    Bool_t Integrator[64];
   
    for (Int_t i = 0; i < nEntries; i++) {
@@ -315,17 +315,17 @@ void AliVZERO::Digits2Raw()
      for(Int_t k=0; k<ndig; k++){
          AliVZEROdigit* fVZERODigit = (AliVZEROdigit*) VZEROdigits->At(k);
          // Convert aliroot channel k into FEE channel iChannel before writing data
-        Int_t iChannel = buffer->GetOnlineChannel(k);          
-        ADC[iChannel]       = (UInt_t) fVZERODigit->ADC();
+        Int_t iChannel      = buffer->GetOnlineChannel(k);             
+        ADC[iChannel]       = fVZERODigit->ADC();
         PMNumber[iChannel]  = fVZERODigit->PMNumber();
-        Time[iChannel]      = (UInt_t) fVZERODigit->Time();
+        Time[iChannel]      = fVZERODigit->Time();
         Integrator[iChannel]= fVZERODigit->Integrator(); 
          if(verbose == 1) { cout <<"DDL: "<<fileName<< "\tdigit number: "<< k<<"\tPM number: "
                            <<PMNumber[k]<<"\tADC: "<< ADC[k] << "\tTime: "<< Time[k] << endl;} 
         if(verbose == 2) {
              ftxt<<"DDL: "<<fileName<< "\tdigit number: "<< k<<"\tPM number: "
                           <<PMNumber[k]<<"\tADC: "<< ADC[k] << "\tTime: "<< Time[k] << endl;}        
-//      printf("DDL: %s, channel: %d, PM: %d, ADC: %d, Time: %d \n", 
+//      printf("DDL: %s, channel: %d, PM: %d, ADC: %f, Time: %f \n", 
 //                 fileName,k,PMNumber[k],ADC[k],Time[k]); 
      }        
    if(verbose==2) ftxt.close();
@@ -339,15 +339,16 @@ void AliVZERO::Digits2Raw()
   
       for(Int_t iChannel_Offset = iCIU*8; iChannel_Offset < (iCIU*8)+8; iChannel_Offset=iChannel_Offset+4) { 
          for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {
-             buffer->WriteChannel(iChannel, ADC[iChannel], Time[iChannel], Integrator[iChannel]);       
+             buffer->WriteChannel(iChannel, (Int_t) ADC[iChannel], Time[iChannel], Integrator[iChannel]);       
          }
          buffer->WriteBeamFlags(); 
          buffer->WriteMBInfo(); 
          buffer->WriteMBFlags();   
          buffer->WriteBeamScalers(); 
       } 
-      for(Int_t iChannel=0; iChannel < 8; iChannel++) {
-          buffer->WriteTiming(iChannel, ADC[iChannel], Time[iChannel]); 
+//      for(Int_t iChannel=0; iChannel < 8; iChannel++) {
+      for(Int_t iChannel=7; iChannel >= 0; iChannel--) {
+          buffer->WriteTiming(iChannel, (Int_t) ADC[iChannel], Time[iChannel]); 
       }
 
     // End of decoding of one CIU card
@@ -387,14 +388,14 @@ Bool_t AliVZERO::Raw2SDigits(AliRawReader* rawReader){
   if (!rawStream->Next()) return kFALSE; // No VZERO data found
   
   for(Int_t i=0; i<64; i++) {
-      new(pdigit) AliVZEROdigit(i, (Int_t)rawStream->GetADC(i), (Int_t)rawStream->GetTime(i)); 
+      new(pdigit) AliVZEROdigit(i, rawStream->GetADC(i), rawStream->GetTime(i)); 
       treeD->Fill();
   }
  
 // Checks if everything is OK by printing results 
 
 //   for(int i=0;i<64;i++) {
-//     printf("Channel %d : %d %d \n",i,rawStream->GetADC(i),rawStream->GetTime(i)); }
+//     printf("Channel %d : %f %f \n",i,rawStream->GetADC(i),rawStream->GetTime(i)); }
 //   treeD->Print(); printf(" \n"); 
        
   fLoader->WriteDigits("OVERWRITE");
index 05c414b..ea68b6c 100644 (file)
@@ -131,7 +131,7 @@ void AliVZEROBuffer::WriteBunchNumbers() {
 }
 
 //_____________________________________________________________________________
-void AliVZEROBuffer::WriteChannel(Int_t cell, UInt_t ADC, UInt_t /*Time*/, Bool_t integrator){
+void AliVZEROBuffer::WriteChannel(Int_t cell, UInt_t ADC, Float_t /*Time*/, Bool_t integrator){
   // It writes VZERO charge information into a raw data file. 
   // Being called by Digits2Raw
   
@@ -229,14 +229,24 @@ void AliVZEROBuffer::WriteBeamScalers() {
 }
 
 //_____________________________________________________________________________
-void AliVZEROBuffer::WriteTiming(Int_t /*cell*/, UInt_t /* ADC*/, UInt_t Time){
+void AliVZEROBuffer::WriteTiming(Int_t /*cell*/, UInt_t /* ADC*/, Float_t Time){
   // It writes the timing information into a raw data file. 
   // Being called by Digits2Raw
 
   UInt_t data = 0;
+  Int_t  coarse1, coarse2, fine;
 
   // Writes the timing information
-  data = Time & 0xfff;
+//  data = Time & 0xfff;
+  
+  coarse1 = int( Time/25.0 );
+  coarse2 = int( (Time - 25*coarse1)/(25.0/8.0) );
+  fine    = int( (Time - 25*coarse1 -(25.0/8.0)*coarse2)/(25.0/256.0) );
+  
+  data  = (coarse1 & 0xf) << 8;
+  data |= (coarse2 & 0x7) << 5;  
+  data |= (fine & 0x1f);   
+  
   // The signal width is not available the digits!
   // To be added soon
   // data |= (width & 0x7f) << 12;
index 69ba4ad..63b8138 100644 (file)
@@ -26,12 +26,12 @@ public:
   void    WriteTriggerInfo(UInt_t trigger);
   void    WriteTriggerScalers();
   void    WriteBunchNumbers();  
-  void    WriteChannel(Int_t cell,UInt_t ADC, UInt_t Time, Bool_t integrator);
+  void    WriteChannel(Int_t cell,UInt_t ADC, Float_t Time, Bool_t integrator);
   void    WriteBeamFlags();
   void    WriteMBInfo();
   void    WriteMBFlags();  
   void    WriteBeamScalers();
-  void    WriteTiming(Int_t cell,UInt_t ADC, UInt_t Time);
+  void    WriteTiming(Int_t cell,UInt_t ADC, Float_t Time);
 
   void    SetVerbose(Int_t val){fVerbose=val;}
   Int_t   GetVerbose() const{return  fVerbose;} 
index 6ccee07..9553269 100644 (file)
@@ -133,9 +133,9 @@ void AliVZERODigitizer::Exec(Option_t* /*option*/)
 {   
   // Creates digits from hits
      
-  Int_t       map[80];    // 48 values on V0C + 32 on V0A
+  Float_t     map[80];    // 48 values on V0C + 32 on V0A
 //  Int_t       pmNumber[80];
-  Int_t       adc[64];    // 32 PMs on V0C + 32 PMs on V0A
+  Float_t     adc[64];    // 32 PMs on V0C + 32 PMs on V0A
   Float_t     time[80], time_ref[80], time2[64];
   Float_t     adc_gain[80]; 
   Float_t     adc_pedestal[64],adc_sigma[64];    
@@ -170,7 +170,7 @@ void AliVZERODigitizer::Exec(Option_t* /*option*/)
   }
            
   for(Int_t i=48; i<80; i++){ 
-         adc_gain[i] = fCalibData->GetGain(i-16); 
+       adc_gain[i] = fCalibData->GetGain(i-16); 
        cPM[i]      = fPhotoCathodeEfficiency * pmGain_smeared[i-16];
   };
   
@@ -244,7 +244,7 @@ void AliVZERODigitizer::Exec(Option_t* /*option*/)
                         AliVZEROhit* hit = (AliVZEROhit *)hits->UncheckedAt(iHit);
                         Int_t nPhot = hit->Nphot();
                         Int_t cell  = hit->Cell();                          
-                        map[cell] += nPhot;
+                        map[cell] += Float_t(nPhot);
                         Float_t dt_scintillator = gRandom->Gaus(0,0.7);
                         Float_t t = dt_scintillator + 1e9*hit->Tof();
                         if (t > 0.0) {
@@ -266,29 +266,27 @@ void AliVZERODigitizer::Exec(Option_t* /*option*/)
         Float_t pmResponse  =  q1/kC*TMath::Power(ktheta/kthau,1/(1-ktheta/kthau)) 
         + noise*1e-3;  
        if(fCollisionMode >0) adc_gain[i] = adc_gain[i]/70.0; // reduce dynamics in Ion Collision Mode
-        map[i] = Int_t( pmResponse * adc_gain[i]);
+        map[i] =  pmResponse * adc_gain[i];
         Float_t MIP = 1.0/fCalibData->GetMIPperADC(GetPMNumber(i));
        if(fCollisionMode >0) MIP=2.0;
 //     printf("cell = %d,  ADC = %d, TDC = %f \n",i,map[i], time[i]*10.0 );
-        if(map[i] > (int(( MIP/2 ) + 0.5)) )
-                 {map[i] = Int_t(gRandom->Gaus(map[i], (int(( MIP/6 ) + 0.5)) ));}
+        if(map[i] > (MIP/2.) )
+                 {map[i] = gRandom->Gaus(map[i], (MIP/6.) );}
    }
       
 // Now transforms 80 cell responses into 64 photomultiplier responses
 // Also adds the ADC pedestals taken out of the calibration data base
        
    for (Int_t j=0; j<16; j++){
-        adc[j]  = static_cast<Int_t>(map [j] + gRandom->Gaus(adc_pedestal[j], adc_sigma[j]));
+        adc[j]  = map [j] + gRandom->Gaus(adc_pedestal[j], adc_sigma[j]);
        time2[j]= time[j];}
        
    for (Int_t j=48; j<80; j++){
-        adc[j-16]  = static_cast<Int_t>(map [j] 
-                                       + gRandom->Gaus(adc_pedestal[j-16],adc_sigma[j-16]));
+        adc[j-16]  = map [j] + gRandom->Gaus(adc_pedestal[j-16],adc_sigma[j-16]);
        time2[j-16]= time[j]; }
        
    for (Int_t j=0; j<16; j++){
-        adc[16+j] = static_cast<Int_t>(map [16+2*j]+ map [16+2*j+1] 
-                                      + gRandom->Gaus(adc_pedestal[16+j], adc_sigma[16+j]));
+        adc[16+j] = map [16+2*j]+ map [16+2*j+1] + gRandom->Gaus(adc_pedestal[16+j], adc_sigma[16+j]);
        Float_t min_time = TMath::Min(time [16+2*j],time [16+2*j+1]);
        time2[16+j] = min_time;
        if(min_time==0.0){time2[16+j]=TMath::Max(time[16+2*j],time[16+2*j+1]);}
@@ -303,7 +301,7 @@ void AliVZERODigitizer::Exec(Option_t* /*option*/)
 //                    outRunLoader->GetEventNumber(),i, adc[i], Int_t((time2[i]*10.0) +0.5));
 //           multiply by 10 to have 100 ps per channel :
                  
-                 AddDigit(i, adc[i], Int_t((time2[i]*10.0) +0.5)) ;
+                 AddDigit(i, adc[i], (time2[i]*10.0) ) ;
          }      
    }
   treeD->Fill();
@@ -313,7 +311,7 @@ void AliVZERODigitizer::Exec(Option_t* /*option*/)
 }
 
 //____________________________________________________________________________
-void AliVZERODigitizer::AddDigit(Int_t PMnumber, Int_t adc, Int_t time) 
+void AliVZERODigitizer::AddDigit(Int_t PMnumber, Float_t adc, Float_t time) 
  { 
  
 // Adds Digit 
index d29523d..7d89827 100644 (file)
@@ -32,7 +32,7 @@ class AliVZERODigitizer: public AliDigitizer {
    virtual Bool_t Init();
    virtual void   Exec(Option_t* option=0);
 
-   void AddDigit(Int_t PMnumber, Int_t adc, Int_t time);
+   void AddDigit(Int_t PMnumber, Float_t adc, Float_t time);
    void ResetDigit();
    void GetCollisionMode();
    void GetCollisionMode(Int_t collisionMode, Float_t beamEnergy) 
index e576564..0c13c1c 100644 (file)
@@ -46,9 +46,9 @@ AliVZERORawStream::AliVZERORawStream(AliRawReader* rawReader) :
 
   // Initalize the containers
   for(Int_t i = 0; i < kNChannels; i++) {
-    fTime[i] = fWidth[i] = 0;
+    fTime[i] = fWidth[i] = 0.;
     for(Int_t j = 0; j < kNEvOfInt; j++) {
-      fADC[i][j] = 0;
+      fADC[i][j] = 0.;
       fIsInt[i][j] = fIsBB[i][j] = fIsBG[i][j] = kFALSE;
     }
     fBBScalers[i] = fBGScalers[i] = 0;
@@ -74,9 +74,9 @@ void AliVZERORawStream::Reset()
 
   // Reinitalize the containers
   for(Int_t i = 0; i < kNChannels; i++) {
-    fTime[i] = fWidth[i] = 0;
+    fTime[i] = fWidth[i] = 0.;
     for(Int_t j = 0; j < kNEvOfInt; j++) {
-      fADC[i][j] = 0;
+      fADC[i][j] = 0.;
       fIsInt[i][j] = fIsBB[i][j] = fIsBG[i][j] = kFALSE;
     }
     fBBScalers[i] = fBGScalers[i] = 0;
@@ -131,7 +131,7 @@ Bool_t AliVZERORawStream::Next()
       for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {
         for(Int_t iEvOfInt = 0; iEvOfInt < kNEvOfInt; iEvOfInt++) {
           UShort_t data = GetNextShort();
-          fADC[iChannel][iEvOfInt] = data & 0x3ff;
+          fADC[iChannel][iEvOfInt] = Float_t (data & 0x3ff);
           fIsInt[iChannel][iEvOfInt] = (data >> 10) & 0x1;
         }
       }
@@ -180,10 +180,16 @@ Bool_t AliVZERORawStream::Next()
 
     } 
 
-    for(Int_t iChannel = iCIU*8; iChannel < (iCIU*8) + 8; iChannel++) { 
-      UInt_t time = GetNextWord();
-      fTime[iChannel] = time & 0xfff;
-      fWidth[iChannel] = (time >> 12) & 0x7f;   // HPTDC used in pairing mode
+//    for(Int_t iChannel = iCIU*8; iChannel < (iCIU*8) + 8; iChannel++) { 
+//    In fact times are stored the other way around in raw data...
+      for(Int_t iChannel = (iCIU*8) + 7; iChannel >= iCIU*8; iChannel--) { 
+        UInt_t time = GetNextWord();
+       Float_t coarse1  = 25. * ((time >> 8) & 0xf );
+       Float_t coarse2  = 25. / 8. * ((time >> 5) & 0x7 );
+       Float_t fine     = 25. / 256. * (time & 0x1f);
+       // fTime[iChannel] = time & 0xfff;
+       fTime[iChannel]  = coarse1 + coarse2 + fine;
+       fWidth[iChannel] = 3.2 * ( (time >> 12) & 0x7f);   // HPTDC used in pairing mode
     }
     
     // End of decoding of one CIU card
index db5dd61..6909d9f 100644 (file)
@@ -18,6 +18,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #include <TObject.h>
+#include <TMath.h>
 
 class AliRawReader;
 
@@ -50,9 +51,11 @@ class AliVZERORawStream: public TObject {
        
 // Getters of ADC signals, ADC pedestals, time information and corresponding flags :
 
-    UShort_t          GetADC(Int_t channel) const
-      { return fADC[channel][kNEvOfInt/2]; }
-    UShort_t          GetPedestal(Int_t channel, Int_t event) const
+    Float_t           GetADC(Int_t channel) const
+      { return TMath::MaxElement(kNEvOfInt, fADC[channel]); }    // maximum value instead of central clock
+//    { return fADC[channel][kNEvOfInt/2]; }
+            
+    Float_t           GetPedestal(Int_t channel, Int_t event) const
       { return fADC[channel][event]; }
     Bool_t            GetIntegratorFlag(Int_t channel, Int_t event) const
       { return fIsInt[channel][event]; }
@@ -60,9 +63,9 @@ class AliVZERORawStream: public TObject {
       { return fIsBB[channel][event]; } 
     Bool_t            GetBGFlag(Int_t channel, Int_t event) const
       { return fIsBG[channel][event]; }   
-    UInt_t            GetTime(Int_t channel) const
+    Float_t           GetTime(Int_t channel) const
       { return fTime[channel]; }
-    UInt_t            GetWidth(Int_t channel) const
+    Float_t           GetWidth(Int_t channel) const
       { return fWidth[channel]; }
 
     UShort_t          GetTriggerInputs() const
@@ -113,12 +116,12 @@ class AliVZERORawStream: public TObject {
     Bool_t        fIsBBMB[kNChannels][kNBunches];   // 'Beam-Beam' flag for all channels for the previous 10 MB events
     Bool_t        fIsBGMB[kNChannels][kNBunches];   // 'Beam-Gas' for all channels for the previous 10 MB events
 
-    UShort_t      fADC[kNChannels][kNEvOfInt];   // ADC counts for all channels and all events of interest
+    Float_t       fADC[kNChannels][kNEvOfInt];   // ADC counts for all channels and all events of interest
     Bool_t        fIsInt[kNChannels][kNEvOfInt]; // 'Integrator' flag for all channels 
     Bool_t        fIsBB[kNChannels][kNEvOfInt];  // 'Beam-Beam' flag for all channels
     Bool_t        fIsBG[kNChannels][kNEvOfInt];  // 'Beam-Gas' flag for all channels
-    Int_t         fTime[kNChannels];             // leading time for all channels - from HPTDC
-    Int_t         fWidth[kNChannels];            // pulse width for all channels - from HPTDC
+    Float_t       fTime[kNChannels];             // leading time for all channels - from HPTDC - in nanoseconds
+    Float_t       fWidth[kNChannels];            // pulse width for all channels - from HPTDC - in nanoseconds
 
     UShort_t      fTrigger;        // VZERO trigger inputs
     UShort_t      fTriggerMask;    // VZERO trigger inputs mask
index f056b6e..15be949 100644 (file)
@@ -102,40 +102,42 @@ void AliVZEROReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digits
   rawReader->Reset();
   AliVZERORawStream rawStream(rawReader);
   if (rawStream.Next()) {  
-     Int_t ADC_max[64], adc[64], time[64], width[64], BBFlag[64], BGFlag[64], integrator[64];   
+     Float_t ADC_max[64], adc[64]; 
+     Bool_t BBFlag[64], BGFlag[64], integrator[64]; 
+     Float_t time[64], width[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;
+         ADC_max[i] = 0.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);
+             if(rawStream.GetPedestal(i,iClock) > ADC_max[i])  
+               {ADC_max[i]= 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);
-        width[j]  =  rawStream.GetWidth(i);
-        BBFlag[j] =  rawStream.GetBBFlag(i,imax);
-        BGFlag[j] =  rawStream.GetBGFlag(i,imax); 
+        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); 
         integrator[j] =  rawStream.GetIntegratorFlag(i,imax); 
 
         // Filling the esd friend object
         fESDVZEROfriend->SetBBScalers(j,rawStream.GetBBScalers(i));
         fESDVZEROfriend->SetBGScalers(j,rawStream.GetBGScalers(i));
         for (Int_t iBunch = 0; iBunch < AliESDVZEROfriend::kNBunches; iBunch++) {
-          fESDVZEROfriend->SetChargeMB(j,iBunch,rawStream.GetChargeMB(i,iBunch));
-          fESDVZEROfriend->SetIntMBFlag(j,iBunch,rawStream.GetIntMBFlag(i,iBunch));
-          fESDVZEROfriend->SetBBMBFlag(j,iBunch,rawStream.GetBBMBFlag(i,iBunch));
-          fESDVZEROfriend->SetBGMBFlag(j,iBunch,rawStream.GetBGMBFlag(i,iBunch));
+            fESDVZEROfriend->SetChargeMB(j,iBunch,rawStream.GetChargeMB(i,iBunch));
+            fESDVZEROfriend->SetIntMBFlag(j,iBunch,rawStream.GetIntMBFlag(i,iBunch));
+            fESDVZEROfriend->SetBBMBFlag(j,iBunch,rawStream.GetBBMBFlag(i,iBunch));
+            fESDVZEROfriend->SetBGMBFlag(j,iBunch,rawStream.GetBGMBFlag(i,iBunch));
         }
         for (Int_t iEv = 0; iEv < AliESDVZEROfriend::kNEvOfInt; iEv++) {
-          fESDVZEROfriend->SetPedestal(j,iEv,rawStream.GetPedestal(i,iEv));
-          fESDVZEROfriend->SetIntegratorFlag(j,iEv,rawStream.GetIntegratorFlag(i,iEv));
-          fESDVZEROfriend->SetBBFlag(j,iEv,rawStream.GetBBFlag(i,iEv));
-          fESDVZEROfriend->SetBGFlag(j,iEv,rawStream.GetBGFlag(i,iEv));
+            fESDVZEROfriend->SetPedestal(j,iEv,rawStream.GetPedestal(i,iEv));
+            fESDVZEROfriend->SetIntegratorFlag(j,iEv,rawStream.GetIntegratorFlag(i,iEv));
+            fESDVZEROfriend->SetBBFlag(j,iEv,rawStream.GetBBFlag(i,iEv));
+            fESDVZEROfriend->SetBGFlag(j,iEv,rawStream.GetBGFlag(i,iEv));
         }
         fESDVZEROfriend->SetTime(j,rawStream.GetTime(i));
         fESDVZEROfriend->SetWidth(j,rawStream.GetWidth(i));
@@ -146,10 +148,10 @@ void AliVZEROReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digits
      fESDVZEROfriend->SetTriggerInputsMask(rawStream.GetTriggerInputsMask());
 
      for(Int_t iScaler = 0; iScaler < AliESDVZEROfriend::kNScalers; iScaler++)
-       fESDVZEROfriend->SetTriggerScalers(iScaler,rawStream.GetTriggerScalers(iScaler));
+         fESDVZEROfriend->SetTriggerScalers(iScaler,rawStream.GetTriggerScalers(iScaler));
 
-     for (Int_t iBunch = 0; iBunch < AliESDVZEROfriend::kNBunches; iBunch++)
-       fESDVZEROfriend->SetBunchNumbersMB(iBunch,rawStream.GetBunchNumbersMB(iBunch));
+     for(Int_t iBunch = 0; iBunch < AliESDVZEROfriend::kNBunches; iBunch++)
+         fESDVZEROfriend->SetBunchNumbersMB(iBunch,rawStream.GetBunchNumbersMB(iBunch));
      
 
      // Channels(aliroot numbering) will be ordered in the tree
@@ -179,17 +181,17 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,
   digitBranch->SetAddress(&digitsArray);
 
   Float_t   mult[64];  
-  Short_t    adc[64]; 
-  Short_t   time[64]; 
-  Short_t  width[64];
+  Float_t    adc[64]; 
+  Float_t   time[64]; 
+  Float_t  width[64];
   Bool_t  BBFlag[64];
   Bool_t  BGFlag[64];
    
   for (Int_t i=0; i<64; i++){
-       adc[i]    = 0;
+       adc[i]    = 0.0;
        mult[i]   = 0.0;
-       time[i]   = 0;
-       width[i]  = 0;
+       time[i]   = 0.0;
+       width[i]  = 0.0;
        BBFlag[i] = kFALSE;
        BGFlag[i] = kFALSE;
   }
@@ -205,22 +207,22 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,
         AliVZEROdigit* digit = (AliVZEROdigit*)digitsArray->At(d);      
         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();
-       width[pmNumber] = (Short_t) digit->Width();
-       BBFlag[pmNumber]= digit->BBFlag();
-       BGFlag[pmNumber]= digit->BGFlag();
+        Float_t  pedestal      = fCalibData->GetPedestal(d);
+        adc[pmNumber]   =  digit->ADC() - pedestal; 
+        time[pmNumber]  =  digit->Time();
+       width[pmNumber] =  digit->Width();
+       BBFlag[pmNumber]=  digit->BBFlag();
+       BGFlag[pmNumber]=  digit->BGFlag();
         // printf("PM = %d,  MIP per ADC channel = %f \n",pmNumber, fCalibData->GetMIPperADC(pmNumber));
-               //AliInfo(Form("PM = %d,  ADC = %d TDC %d",pmNumber, digit->ADC(),digit->Time()));
+               //AliInfo(Form("PM = %d,  ADC = %f TDC %f",pmNumber, digit->ADC(),digit->Time()));
         // cut of ADC at 1MIP/2 
        if(fCollisionMode >0) { 
           Float_t MIP = 2.0;  
-           if (adc[pmNumber] > (int(MIP) /2) ) mult[pmNumber] += float(adc[pmNumber])*(1.0/MIP) ;
+           if (adc[pmNumber] > (MIP/2.) ) mult[pmNumber] += adc[pmNumber]*(1.0/MIP) ;
           }
            else{    
-           if (adc[pmNumber] > (int(1.0/fCalibData->GetMIPperADC(pmNumber)) /2) ) 
-              mult[pmNumber] += float(adc[pmNumber])*fCalibData->GetMIPperADC(pmNumber);
+           if (adc[pmNumber] > (1.0/fCalibData->GetMIPperADC(pmNumber) /2.) ) 
+              mult[pmNumber] += adc[pmNumber]*fCalibData->GetMIPperADC(pmNumber);
         }          
     } // end of loop over digits
   } // end of loop over events in digits tree
index 6b0da7e..24596ca 100644 (file)
@@ -23,12 +23,12 @@ AliVZEROdigit::AliVZEROdigit()
     fTrack(0),
     fEvent(0),
     fPMNumber(0),
-    fADC(0),
-    fTime(0),
-    fWidth(0),
+    fADC(0.),
+    fTime(0.),
+    fWidth(0.),
     fBBFlag(0),
     fBGFlag(0),
-       fIntegrator(0)
+    fIntegrator(0)
 
 {
   // Standard default constructor 
@@ -40,9 +40,9 @@ AliVZEROdigit::AliVZEROdigit(Int_t* tracks, Int_t *digits)
    fTrack(0),
    fEvent(0),
    fPMNumber(0),
-   fADC(0),
-   fTime(0),
-   fWidth(0),
+   fADC(0.),
+   fTime(0.),
+   fWidth(0.),
    fBBFlag(0),
    fBGFlag(0),
    fIntegrator(0)
@@ -56,17 +56,17 @@ AliVZEROdigit::AliVZEROdigit(Int_t* tracks, Int_t *digits)
 }
 
 //__________________________________________________________________________
-AliVZEROdigit::AliVZEROdigit(Int_t PMnumber, Int_t adc, Int_t time)
+AliVZEROdigit::AliVZEROdigit(Int_t PMnumber, Float_t adc, Float_t time)
    :AliDigit(),
    fTrack(0),
    fEvent(0),
    fPMNumber(0),
-   fADC(0),
-   fTime(0),
-   fWidth(0),
+   fADC(0.),
+   fTime(0.),
+   fWidth(0.),
    fBBFlag(0),
    fBGFlag(0),
-       fIntegrator(0)
+   fIntegrator(0)
 {  
    fPMNumber   = PMnumber;
    fADC        = adc;
@@ -74,8 +74,8 @@ AliVZEROdigit::AliVZEROdigit(Int_t PMnumber, Int_t adc, Int_t time)
 }
 
 //__________________________________________________________________________
-AliVZEROdigit::AliVZEROdigit(Int_t PMnumber, Int_t adc, Int_t time, 
-                             Int_t width, Bool_t BeamBeamFlag, Bool_t BeamGasFlag)
+AliVZEROdigit::AliVZEROdigit(Int_t  PMnumber, Float_t adc, Float_t time, 
+                             Float_t width, Bool_t BeamBeamFlag, Bool_t BeamGasFlag)
    :AliDigit(),
    fTrack(0),
    fEvent(0),
@@ -84,14 +84,14 @@ AliVZEROdigit::AliVZEROdigit(Int_t PMnumber, Int_t adc, Int_t time,
    fTime(time),
    fWidth(width),
    fBBFlag(BeamBeamFlag),
-       fBGFlag(BeamGasFlag),
-       fIntegrator(0)
+   fBGFlag(BeamGasFlag),
+   fIntegrator(0)
 {  
 
 }
 //__________________________________________________________________________
-AliVZEROdigit::AliVZEROdigit(Int_t PMnumber, Int_t adc, Int_t time, 
-                             Int_t width, Bool_t BeamBeamFlag, Bool_t BeamGasFlag, Bool_t integrator)
+AliVZEROdigit::AliVZEROdigit(Int_t   PMnumber, Float_t adc, Float_t time, 
+                             Float_t width, Bool_t BeamBeamFlag, Bool_t BeamGasFlag, Bool_t integrator)
 :AliDigit(),
 fTrack(0),
 fEvent(0),
index 62b60ff..cd13bc2 100644 (file)
@@ -13,34 +13,34 @@ 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 */, 
-                  Int_t /* TimeWidth*/, Bool_t /* BBFlag */, Bool_t /* BGFlag */);
-    AliVZEROdigit(Int_t /* PMnumber */, Int_t  /* ADC */, Int_t /* Time */, 
-                  Int_t /* TimeWidth*/, Bool_t /* BBFlag */, Bool_t /* BGFlag */, Bool_t /* Integrator */);
+    AliVZEROdigit(Int_t   /* PMnumber */, Float_t  /* ADC */, Float_t /* Time */);
+    AliVZEROdigit(Int_t   /* PMnumber */, Float_t  /* ADC */, Float_t /* Time */, 
+                  Float_t /* TimeWidth*/, Bool_t /* BBFlag */, Bool_t /* BGFlag */);
+    AliVZEROdigit(Int_t   /* PMnumber */, Float_t  /* ADC */, Float_t /* Time */, 
+                  Float_t /* TimeWidth*/, Bool_t /* BBFlag */, Bool_t /* BGFlag */, Bool_t /* Integrator */);
     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   Width()    const {return fWidth;} 
-    Bool_t  BBFlag()   const {return fBBFlag;} 
-    Bool_t  BGFlag()   const {return fBGFlag;}
-    Bool_t  Integrator()   const {return fIntegrator;}
+    Int_t   PMNumber()   const {return fPMNumber;}    
+    Float_t ADC()        const {return fADC;}
+    Float_t Time()       const {return fTime;}
+    Float_t Width()      const {return fWidth;} 
+    Bool_t  BBFlag()     const {return fBBFlag;} 
+    Bool_t  BGFlag()     const {return fBGFlag;}
+    Bool_t  Integrator() const {return fIntegrator;}
        
   private:
     Int_t  fTrack;         // Track number
     
   protected:
-    Int_t  fEvent;         // Event number  
-    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
-       Bool_t fIntegrator;        // Integrator used
+    Int_t   fEvent;         // Event number  
+    Int_t   fPMNumber;      // PhotoMultiplier number (0 to 63)
+    Float_t fADC;           // ADC response
+    Float_t fTime;          // Time of Flight
+    Float_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
+    Bool_t  fIntegrator;    // Integrator used
     
     ClassDef(AliVZEROdigit,3)  //Digit (Header) object for set : VZERO
 };