Adding ADC and TDC values to AliESDVZERO

diff --git a/STEER/AliESDVZERO.cxx b/STEER/AliESDVZERO.cxx
index a264b5a11d82780f0ac4ba21d36e5ee2a8502ce1..8d3d2928931b3245f0d1e2bbd7b851c0fdcedb8a 100644 (file)
--- a/STEER/AliESDVZERO.cxx
+++ b/STEER/AliESDVZERO.cxx
@@ -1,5 +1,5 @@
-#include <Riostream.h>
 #include "AliESDVZERO.h"
+#include "AliLog.h"
 
 ClassImp(AliESDVZERO)
 
@@ -13,6 +13,8 @@ AliESDVZERO::AliESDVZERO()
    // Default constructor 
    for(Int_t j=0; j<64; j++){ 
       fMultiplicity[j] = 0;   
+      fAdc[j] = 0;   
+      fTime[j] = 0;   
    }
 }
 
@@ -24,13 +26,16 @@ AliESDVZERO::AliESDVZERO(const AliESDVZERO &o)
    fBGtriggerV0C(o.fBGtriggerV0C)
 {   
    // Default constructor 
-   for(Int_t j=0; j<64; j++)
+   for(Int_t j=0; j<64; j++) {
        fMultiplicity[j] = o.fMultiplicity[j];
+       fAdc[j] = o.fAdc[j];
+       fTime[j] = o.fTime[j];
+   }
 }
 
 AliESDVZERO::AliESDVZERO(UInt_t BBtriggerV0A, UInt_t BGtriggerV0A,
              UInt_t BBtriggerV0C, UInt_t BGtriggerV0C,
-             Short_t *Multiplicity)
+             Short_t *Multiplicity, Short_t *Adc, Short_t *Time)
   :TObject(),
    fBBtriggerV0A(BBtriggerV0A),
    fBGtriggerV0A(BGtriggerV0A),
@@ -39,8 +44,11 @@ AliESDVZERO::AliESDVZERO(UInt_t BBtriggerV0A, UInt_t BGtriggerV0A,
 
 {
    // Constructor
-   for(Int_t j=0; j<64; j++)
+   for(Int_t j=0; j<64; j++) {
        fMultiplicity[j] = Multiplicity[j];
+       fAdc[j] = Adc[j];
+       fTime[j] = Time[j];
+   }
 }
 
 
@@ -54,8 +62,11 @@ AliESDVZERO& AliESDVZERO::operator=(const AliESDVZERO& o)
   fBGtriggerV0A=o.fBGtriggerV0A;
   fBBtriggerV0C=o.fBBtriggerV0C;
   fBGtriggerV0C=o.fBGtriggerV0C;
-   for(Int_t j=0; j<64; j++)
+   for(Int_t j=0; j<64; j++) {
        fMultiplicity[j] = o.fMultiplicity[j];
+       fAdc[j] = o.fAdc[j];
+       fTime[j] = o.fTime[j];
+   }
   return *this;
 }
 
@@ -94,15 +105,19 @@ Int_t AliESDVZERO::GetMTotV0C()
 
 Int_t* AliESDVZERO::GetMRingV0A()
 {
-  cout << "AliESDVZERO::GetMRingV0C() not supported any more" << endl;
-  cout << "use Int_t AliESDVZERO::GetMRingV0C(Int_t ring)" << endl;
+//  cout << "AliESDVZERO::GetMRingV0C() not supported any more" << endl;
+//  cout << "use Int_t AliESDVZERO::GetMRingV0C(Int_t ring)" << endl;
+  AliInfo("AliESDVZERO::GetMRingV0C() not supported any more");
+  AliInfo("use Int_t AliESDVZERO::GetMRingV0C(Int_t ring)");
   return 0x0;
 }
 
 Int_t* AliESDVZERO::GetMRingV0C()
 {
-  cout << "AliESDVZERO::GetMRingV0C() not supported any more" << endl;
-  cout << "use Int_t AliESDVZERO::GetMRingV0C(Int_t ring)" << endl;
+//  cout << "AliESDVZERO::GetMRingV0C() not supported any more" << endl;
+//  cout << "use Int_t AliESDVZERO::GetMRingV0C(Int_t ring)" << endl;
+  AliInfo("AliESDVZERO::GetMRingV0C() not supported any more");
+  AliInfo("use Int_t AliESDVZERO::GetMRingV0C(Int_t ring)"); 
   return 0x0;
 }
 
@@ -137,6 +152,62 @@ Int_t AliESDVZERO::GetMultiplicity(Int_t i)
   return fMultiplicity[i];
 }
 
+Int_t AliESDVZERO::GetMultiplicityV0A(Int_t i)
+
+{
+  if (OutOfRange(i, "AliESDVZERO::GetMultiplicityV0A:",32)) return -1;
+  return fMultiplicity[32+i];
+}
+
+Int_t AliESDVZERO::GetMultiplicityV0C(Int_t i)
+
+{
+  if (OutOfRange(i, "AliESDVZERO::GetMultiplicityV0C:",32)) return -1;
+  return fMultiplicity[i];
+}
+
+Int_t AliESDVZERO::GetAdc(Int_t i)
+
+{
+  if (OutOfRange(i, "AliESDVZERO::GetAdc:",64)) return -1;
+  return fAdc[i];
+}
+
+Int_t AliESDVZERO::GetAdcV0C(Int_t i)
+
+{
+  if (OutOfRange(i, "AliESDVZERO::GetAdcV0C:",32)) return -1;
+  return fAdc[i];
+}
+
+Int_t AliESDVZERO::GetAdcV0A(Int_t i)
+
+{
+  if (OutOfRange(i, "AliESDVZERO::GetAdcV0A:",32)) return -1;
+  return fAdc[32+i];
+}
+
+Int_t AliESDVZERO::GetTime(Int_t i)
+
+{
+  if (OutOfRange(i, "AliESDVZERO::GetTime:",64)) return -1;
+  return fTime[i];
+}
+
+Int_t AliESDVZERO::GetTimeV0C(Int_t i)
+
+{
+  if (OutOfRange(i, "AliESDVZERO::GetTimeV0C:",32)) return -1;
+  return fTime[i];
+}
+
+Int_t AliESDVZERO::GetTimeV0A(Int_t i)
+
+{
+  if (OutOfRange(i, "AliESDVZERO::GetTimeV0A:",32)) return -1;
+  return fTime[32+i];
+}
+
 Bool_t AliESDVZERO::BBTriggerV0A(Int_t i)
 {
   if (OutOfRange(i, "AliESDVZERO:::BBTriggerV0A",32)) return kFALSE;
@@ -169,8 +240,9 @@ 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
   if (i > upper || i < 0) {
-    cout << s << " Index " << i << " out of range" << endl;
-    return kTRUE;
+//    cout << s << " Index " << i << " out of range" << endl;
+     AliInfo(Form("Index %d out of range",i));
+     return kTRUE;
   }
   return kFALSE;
 }

diff --git a/STEER/AliESDVZERO.h b/STEER/AliESDVZERO.h
index 0cae17c247ea1c53e300ba99b65843b0edf2e046..4b59e65f4959d9fee4bd1c4f3dd175766e8d8a4b 100644 (file)
--- a/STEER/AliESDVZERO.h
+++ b/STEER/AliESDVZERO.h
@@ -10,7 +10,7 @@ public:
   AliESDVZERO(const AliESDVZERO&);
   AliESDVZERO(UInt_t BBtriggerV0A, UInt_t BGtriggerV0A,
              UInt_t BBtriggerV0C, UInt_t BGtriggerV0C,
-             Short_t *Multiplicity);
+             Short_t *Multiplicity,Short_t *Adc, Short_t *Time);
 
   virtual ~AliESDVZERO() {};
   
@@ -20,36 +20,50 @@ public:
   virtual void SetBGtriggerV0C(UInt_t BGtrigger) {fBGtriggerV0C=BGtrigger;}
   virtual void SetMultiplicity(Short_t Multiplicity[64])
     {for(Int_t i=0;i<64;i++) fMultiplicity[i]=Multiplicity[i];}
+  virtual void SetADC(Short_t adc[64])
+    {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];}
 
   // 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);
-  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  OutOfRange(Int_t i, const char *s, Int_t upper) const;
+  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);
+
+  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
 
-  UShort_t fMultiplicity[64]; // multiplicity per PMT
+  Short_t fMultiplicity[64]; // multiplicity per PMT
+  Short_t fAdc[64]; //  adc per PMT
+  Short_t fTime[64]; // time per PMT
 
-  ClassDef(AliESDVZERO,3)
+  ClassDef(AliESDVZERO,4)
 };
 
 #endif

diff --git a/VZERO/AliVZEROQADataMakerRec.cxx b/VZERO/AliVZEROQADataMakerRec.cxx
index f5b98dc3ac55d1ac22502bc3cc1807e33f2acbd5..6c3e69bb6a816a117369219a51a9e5cf99e69362 100644 (file)
--- a/VZERO/AliVZEROQADataMakerRec.cxx
+++ b/VZERO/AliVZEROQADataMakerRec.cxx
@@ -76,7 +76,7 @@ void AliVZEROQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArr
 //____________________________________________________________________________ 
 void AliVZEROQADataMakerRec::InitESDs()
 {
-  //Create histograms to control ESD
+  //Create histograms to controll ESD
  
   TH1I * h1 = new TH1I("hVZERONbPMA", "Number of PMs fired in V0A", 80, 0, 79); 
   h1->Sumw2() ;
@@ -95,7 +95,7 @@ void AliVZEROQADataMakerRec::InitESDs()
   Add2ESDsList(h4, 3) ;
 
   TH2F * h5 = new TH2F("fVzeroMult", "Vzero multiplicity",
-                        64, -0.5, 63.5,100, -0.5, 99.5);
+                        64, -0.5, 63.5,1000, -0.5, 99.5);
   h5->GetXaxis()->SetTitle("Vzero PMT");
   h5->GetYaxis()->SetTitle("Multiplicity");
   h5->Sumw2() ;
@@ -112,9 +112,22 @@ void AliVZEROQADataMakerRec::InitESDs()
   TH1F * h9 = new TH1F("fBGC","BG Vzero C", 32, -0.5,31.5);
   h9->Sumw2();
   Add2ESDsList(h9, 8) ;
-       
-}
 
+  TH2F *h10 = new TH2F("fVzeroAdc", "Vzero Adc",
+                        64, -0.5, 63.5,1024, -0.5, 1023.5);
+  h10->GetXaxis()->SetTitle("Vzero PMT");
+  h10->GetYaxis()->SetTitle("Adc counts");
+  h10->Sumw2() ;
+  Add2ESDsList(h10, 9);
+
+  TH2F *h11 = new TH2F("fVzeroTime", "Vzero Time",
+                        64, -0.5, 63.5,300, -0.5, 149.5);
+  h11->GetXaxis()->SetTitle("Vzero PMT");
+  h11->GetYaxis()->SetTitle("Time [100 ps]");
+  h11->Sumw2() ;
+  Add2ESDsList(h11,10);
+
+}
 
 //____________________________________________________________________________ 
  void AliVZEROQADataMakerRec::InitRaws()
@@ -147,7 +160,6 @@ void AliVZEROQADataMakerRec::InitESDs()
      }  
  }
 
-
 //____________________________________________________________________________
 void AliVZEROQADataMakerRec::MakeESDs(AliESDEvent * esd)
 {
@@ -160,8 +172,11 @@ void AliVZEROQADataMakerRec::MakeESDs(AliESDEvent * esd)
       GetESDsData(1)->Fill(esdVZERO->GetNbPMV0C());  
       GetESDsData(2)->Fill(esdVZERO->GetMTotV0A());
       GetESDsData(3)->Fill(esdVZERO->GetMTotV0C());  
-      for(Int_t i=0;i<64;i++) 
+      for(Int_t i=0;i<64;i++) {
        GetESDsData(4)->Fill((Float_t) i,(Float_t) esdVZERO->GetMultiplicity(i));
+       GetESDsData(9)->Fill((Float_t) i,(Float_t) esdVZERO->GetAdc(i));
+       GetESDsData(10)->Fill((Float_t) i,(Float_t) esdVZERO->GetTime(i));
+      }
       for(Int_t i=0;i<32;i++) { 
        if (esdVZERO->BBTriggerV0A(i)) 
          GetESDsData(5)->Fill((Float_t) i);
@@ -173,7 +188,7 @@ void AliVZEROQADataMakerRec::MakeESDs(AliESDEvent * esd)
          GetESDsData(8)->Fill((Float_t) i);
       }
   }
-
+  
 }
 
 //____________________________________________________________________________
@@ -197,7 +212,6 @@ void AliVZEROQADataMakerRec::MakeESDs(AliESDEvent * esd)
            GetRawsData(1)->Fill(i,rawStream->GetADC(i)) ; 
            GetRawsData(i+2+64)->Fill(rawStream->GetADC(i)) ; }         
       }          
-  delete rawStream;
  }
 
 //____________________________________________________________________________ 

diff --git a/VZERO/AliVZEROReconstructor.cxx b/VZERO/AliVZEROReconstructor.cxx
index 9643f8b092d6dade4e6f904ef047be40c12ca6a5..bcfdf45b857d11de88dfba79fe39d19c62592d65 100644 (file)
--- a/VZERO/AliVZEROReconstructor.cxx
+++ b/VZERO/AliVZEROReconstructor.cxx
@@ -114,7 +114,8 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,
   const Float_t mip0=110.0;
   Short_t Multiplicity[64];
   Float_t mult[64];  
-  Int_t   adc[64]; 
+  Short_t   adc[64]; 
+  Short_t   time[64]; 
   Float_t mip[64];
   for (Int_t i=0; i<64; i++){
        adc[i] = 0;
@@ -132,7 +133,8 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,
     for (Int_t d=0; d<nDigits; d++) {    
       AliVZEROdigit* digit = (AliVZEROdigit*)digitsArray->At(d);      
       Int_t  pmNumber      = digit->PMNumber();  
-      adc[pmNumber] = digit->ADC(); 
+      adc[pmNumber] = (Short_t) digit->ADC(); 
+      time[pmNumber] = (Short_t) digit->Time();
       // cut of ADC at MIP/2
       if  (adc[pmNumber] > (mip[pmNumber]/2)) 
        mult[pmNumber] += float(adc[pmNumber])/mip[pmNumber];
@@ -141,6 +143,8 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,
   
   for (Int_t j=0; j<64; j++) Multiplicity[j] = short(mult[j]+0.5);       
   fESDVZERO->SetMultiplicity(Multiplicity);
+  fESDVZERO->SetADC(adc);
+  fESDVZERO->SetTime(time);
 
   // now get the trigger mask