Streaming problems in CAF solved
authorgconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 9 Jun 2008 22:37:03 +0000 (22:37 +0000)
committergconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 9 Jun 2008 22:37:03 +0000 (22:37 +0000)
PWG4/AliAnaExample.h
PWG4/AliAnaGammaDirect.cxx
PWG4/AliAnaGammaDirect.h
PWG4/AliAnaParticleHadronCorrelation.h
PWG4/AliAnaParticleJetLeadingConeCorrelation.h
PWG4/AliAnaParticlePartonCorrelation.h
PWG4/AliAnalysisTaskPHOSExample.h
PWG4/AliAnalysisTaskParticleCorrelation.h

index 668756a..94943cb 100644 (file)
@@ -56,15 +56,15 @@ class AliAnaExample : public AliAnaBaseClass {
        TString fDetector ; //detector selection
        //Histograms
        //CaloClusters 
-       TH1F * fhPt; //pT distribution
-       TH1F * fhPhi; //phi distribution
-       TH1F * fhEta; //phi distribution
-       TH2F * fh2Pt; //pT distribution, reconstructed vs generated
-       TH2F * fh2Phi; //phi distribution, reconstructed vs generated
-       TH2F * fh2Eta; //phi distribution, reconstructed vs generated
+       TH1F * fhPt; //! pT distribution
+       TH1F * fhPhi; //! phi distribution
+       TH1F * fhEta; //! eta distribution
+       TH2F * fh2Pt; //!pT distribution, reconstructed vs generated
+       TH2F * fh2Phi; //! phi distribution, reconstructed vs generated
+       TH2F * fh2Eta; //! eta distribution, reconstructed vs generated
        //Calo Cells
-       TH1F * fhNCells; //Number of towers/crystals with signal
-       TH1F * fhAmplitude; //Amplitude measured in towers/crystals
+       TH1F * fhNCells; //! Number of towers/crystals with signal
+       TH1F * fhAmplitude; //! Amplitude measured in towers/crystals
        ClassDef(AliAnaExample,1)
  } ;
 
index cf53dab..a05db9c 100644 (file)
@@ -84,6 +84,44 @@ ClassImp(AliAnaGammaDirect)
   //Initialize parameters
   InitParameters();
 
+  for(Int_t i = 0; i < 5 ; i++){ 
+    fConeSizes[i] = 0 ; 
+    fhPtSumIsolated[i] = 0 ;  
+    
+    fhPtSumIsolatedPrompt[i] = 0 ;  
+    fhPtSumIsolatedFragmentation[i] = 0 ;  
+    fhPtSumIsolatedPi0Decay[i] = 0 ;  
+    fhPtSumIsolatedOtherDecay[i] = 0 ;  
+    fhPtSumIsolatedConversion[i] = 0 ;  
+    fhPtSumIsolatedUnknown[i] = 0 ;  
+    
+    for(Int_t j = 0; j < 5 ; j++){ 
+      fhPtThresIsolated[i][j] = 0 ;  
+      fhPtFracIsolated[i][j] = 0 ; 
+      
+      fhPtThresIsolatedPrompt[i][j] = 0 ;  
+      fhPtThresIsolatedFragmentation[i][j] = 0 ; 
+      fhPtThresIsolatedPi0Decay[i][j] = 0 ;  
+      fhPtThresIsolatedOtherDecay[i][j] = 0 ;  
+      fhPtThresIsolatedConversion[i][j] = 0 ;  
+      fhPtThresIsolatedUnknown[i][j] = 0 ;  
+  
+      fhPtFracIsolatedPrompt[i][j] = 0 ;  
+      fhPtFracIsolatedFragmentation[i][j] = 0 ;  
+      fhPtFracIsolatedPi0Decay[i][j] = 0 ;  
+      fhPtFracIsolatedOtherDecay[i][j] = 0 ;  
+      fhPtFracIsolatedConversion[i][j] = 0 ;
+      fhPtFracIsolatedUnknown[i][j] = 0 ;  
+    }  
+  } 
+  
+  for(Int_t i = 0; i < 5 ; i++){ 
+    fPtFractions[i]=  0 ; 
+    fPtThresholds[i]= 0 ; 
+  } 
+
+
 }
 
 //____________________________________________________________________________
index b0d03dc..3e2813f 100644 (file)
@@ -105,59 +105,59 @@ public:
   Bool_t fMakeInvMass; //Select candidate if no pair from decay
 
   //Histograms  
-  TH1F * fhPtGamma    ;  //Number of identified (isolated) gamma 
-  TH2F * fhPhiGamma  ; // Phi of identified  (isolated) gamma
-  TH2F * fhEtaGamma  ; // eta of identified  (isolated) gamma
-  TH2F * fhConeSumPt ; // Sum Pt in the cone
+  TH1F * fhPtGamma    ;  //!Number of identified (isolated) gamma 
+  TH2F * fhPhiGamma  ; //! Phi of identified  (isolated) gamma
+  TH2F * fhEtaGamma  ; //! eta of identified  (isolated) gamma
+  TH2F * fhConeSumPt ; //! Sum Pt in the cone
 
   //Prompt photon analysis data members for multiple cones and pt thresholds 
-  Int_t         fNCones   ; //Number of cone sizes to test
-  Int_t         fNPtThresFrac ; //Number of ptThres and ptFrac to test
-  Float_t     fConeSizes[5] ; // Array with cones to test
-  Float_t     fPtThresholds[5] ; // Array with pt thresholds to test
-  Float_t     fPtFractions[5] ; // Array with pt thresholds to test
+  Int_t         fNCones   ; //!Number of cone sizes to test
+  Int_t         fNPtThresFrac ; //!Number of ptThres and ptFrac to test
+  Float_t     fConeSizes[5] ; //! Array with cones to test
+  Float_t     fPtThresholds[5] ; //! Array with pt thresholds to test
+  Float_t     fPtFractions[5] ; //! Array with pt thresholds to test
 
-  TH1F* fhPtThresIsolated[5][5]; // Isolated gamma with pt threshold 
-  TH1F* fhPtFracIsolated[5][5]; // Isolated gamma with pt threshold 
-  TH2F* fhPtSumIsolated[5] ;  //  Isolated gamma with threshold on cone pt sume
+  TH1F* fhPtThresIsolated[5][5]; //! Isolated gamma with pt threshold 
+  TH1F* fhPtFracIsolated[5][5]; //! Isolated gamma with pt threshold 
+  TH2F* fhPtSumIsolated[5] ;  //!  Isolated gamma with threshold on cone pt sume
 
   //MC
-  TH1F * fhPtPrompt; //Number of identified (isolated) prompt gamma 
-  TH2F * fhPhiPrompt;  // Phi of identified  (isolated) prompt gamma
-  TH2F * fhEtaPrompt;  // eta of identified  (isolated) prompt gamma
-  TH1F * fhPtThresIsolatedPrompt[5][5];  // Isolated prompt gamma with pt threshold 
-  TH1F * fhPtFracIsolatedPrompt[5][5];    // Isolated prompt gamma with pt frac
-  TH2F * fhPtSumIsolatedPrompt[5]; //  Isolated prompt gamma with threshold on cone pt sume
-  TH1F * fhPtFragmentation; //Number of identified (isolated) fragmentation gamma 
-  TH2F * fhPhiFragmentation;  // Phi of identified  (isolated) fragmentation gamma
-  TH2F * fhEtaFragmentation;  // eta of identified  (isolated) fragmentation gamma
-  TH1F * fhPtThresIsolatedFragmentation[5][5];  // Isolated fragmentation gamma with pt threshold 
-  TH1F * fhPtFracIsolatedFragmentation[5][5];    // Isolated fragmentation gamma with pt frac
-  TH2F * fhPtSumIsolatedFragmentation[5]; //  Isolated fragmentation gamma with threshold on cone pt sume
-  TH1F * fhPtPi0Decay; //Number of identified (isolated) Pi0Decay gamma 
-  TH2F * fhPhiPi0Decay;  // Phi of identified  (isolated) Pi0Decay gamma
-  TH2F * fhEtaPi0Decay;  // eta of identified  (isolated) Pi0Decay gamma
-  TH1F * fhPtThresIsolatedPi0Decay[5][5];  // Isolated Pi0Decay gamma with pt threshold 
-  TH1F * fhPtFracIsolatedPi0Decay[5][5];    // Isolated Pi0Decay gamma with pt frac
-  TH2F * fhPtSumIsolatedPi0Decay[5]; //  Isolated Pi0Decay gamma with threshold on cone pt sume
-  TH1F * fhPtOtherDecay; //Number of identified (isolated) OtherDecay gamma 
-  TH2F * fhPhiOtherDecay;  // Phi of identified  (isolated) OtherDecay gamma
-  TH2F * fhEtaOtherDecay;  // eta of identified  (isolated) OtherDecay gamma
-  TH1F * fhPtThresIsolatedOtherDecay[5][5];  // Isolated OtherDecay gamma with pt threshold 
-  TH1F * fhPtFracIsolatedOtherDecay[5][5];    // Isolated OtherDecay gamma with pt frac
-  TH2F * fhPtSumIsolatedOtherDecay[5]; //  Isolated OtherDecay gamma with threshold on cone pt sume    
-  TH1F * fhPtConversion; //Number of identified (isolated) Conversion gamma 
-  TH2F * fhPhiConversion;  // Phi of identified  (isolated) Conversion gamma
-  TH2F * fhEtaConversion;  // eta of identified  (isolated) Conversion gamma
-  TH1F * fhPtThresIsolatedConversion[5][5];  // Isolated Conversion gamma with pt threshold 
-  TH1F * fhPtFracIsolatedConversion[5][5];    // Isolated Conversion gamma with pt frac
-  TH2F * fhPtSumIsolatedConversion[5]; //  Isolated Conversion gamma with threshold on cone pt sume
-  TH1F * fhPtUnknown; //Number of identified (isolated) Unknown gamma 
-  TH2F * fhPhiUnknown;  // Phi of identified  (isolated) Unknown gamma
-  TH2F * fhEtaUnknown;  // eta of identified  (isolated) Unknown gamma
-  TH1F * fhPtThresIsolatedUnknown[5][5];  // Isolated Unknown gamma with pt threshold 
-  TH1F * fhPtFracIsolatedUnknown[5][5];    // Isolated Unknown gamma with pt frac
-  TH2F * fhPtSumIsolatedUnknown[5]; //  Isolated Unknown gamma with threshold on cone pt sume
+  TH1F * fhPtPrompt; //!Number of identified (isolated) prompt gamma 
+  TH2F * fhPhiPrompt;  //! Phi of identified  (isolated) prompt gamma
+  TH2F * fhEtaPrompt;  //! eta of identified  (isolated) prompt gamma
+  TH1F * fhPtThresIsolatedPrompt[5][5];  //! Isolated prompt gamma with pt threshold 
+  TH1F * fhPtFracIsolatedPrompt[5][5];    //! Isolated prompt gamma with pt frac
+  TH2F * fhPtSumIsolatedPrompt[5]; //!  Isolated prompt gamma with threshold on cone pt sume
+  TH1F * fhPtFragmentation; //!Number of identified (isolated) fragmentation gamma 
+  TH2F * fhPhiFragmentation;  //! Phi of identified  (isolated) fragmentation gamma
+  TH2F * fhEtaFragmentation;  //! eta of identified  (isolated) fragmentation gamma
+  TH1F * fhPtThresIsolatedFragmentation[5][5];  //! Isolated fragmentation gamma with pt threshold 
+  TH1F * fhPtFracIsolatedFragmentation[5][5];    //! Isolated fragmentation gamma with pt frac
+  TH2F * fhPtSumIsolatedFragmentation[5]; //!  Isolated fragmentation gamma with threshold on cone pt sume
+  TH1F * fhPtPi0Decay; //!Number of identified (isolated) Pi0Decay gamma 
+  TH2F * fhPhiPi0Decay;  //! Phi of identified  (isolated) Pi0Decay gamma
+  TH2F * fhEtaPi0Decay;  //! eta of identified  (isolated) Pi0Decay gamma
+  TH1F * fhPtThresIsolatedPi0Decay[5][5];  //! Isolated Pi0Decay gamma with pt threshold 
+  TH1F * fhPtFracIsolatedPi0Decay[5][5];    //! Isolated Pi0Decay gamma with pt frac
+  TH2F * fhPtSumIsolatedPi0Decay[5]; //!  Isolated Pi0Decay gamma with threshold on cone pt sume
+  TH1F * fhPtOtherDecay; //!Number of identified (isolated) OtherDecay gamma 
+  TH2F * fhPhiOtherDecay;  //! Phi of identified  (isolated) OtherDecay gamma
+  TH2F * fhEtaOtherDecay;  //! eta of identified  (isolated) OtherDecay gamma
+  TH1F * fhPtThresIsolatedOtherDecay[5][5];  //! Isolated OtherDecay gamma with pt threshold 
+  TH1F * fhPtFracIsolatedOtherDecay[5][5];    //! Isolated OtherDecay gamma with pt frac
+  TH2F * fhPtSumIsolatedOtherDecay[5]; //!  Isolated OtherDecay gamma with threshold on cone pt sume   
+  TH1F * fhPtConversion; //!Number of identified (isolated) Conversion gamma 
+  TH2F * fhPhiConversion;  //! Phi of identified  (isolated) Conversion gamma
+  TH2F * fhEtaConversion;  //! eta of identified  (isolated) Conversion gamma
+  TH1F * fhPtThresIsolatedConversion[5][5];  //! Isolated Conversion gamma with pt threshold 
+  TH1F * fhPtFracIsolatedConversion[5][5];    //! Isolated Conversion gamma with pt frac
+  TH2F * fhPtSumIsolatedConversion[5]; //!  Isolated Conversion gamma with threshold on cone pt sume
+  TH1F * fhPtUnknown; //!Number of identified (isolated) Unknown gamma 
+  TH2F * fhPhiUnknown;  //! Phi of identified  (isolated) Unknown gamma
+  TH2F * fhEtaUnknown;  //! eta of identified  (isolated) Unknown gamma
+  TH1F * fhPtThresIsolatedUnknown[5][5];  //! Isolated Unknown gamma with pt threshold 
+  TH1F * fhPtFracIsolatedUnknown[5][5];    //! Isolated Unknown gamma with pt frac
+  TH2F * fhPtSumIsolatedUnknown[5]; //!  Isolated Unknown gamma with threshold on cone pt sume
                                                
   ClassDef(AliAnaGammaDirect,1)
 } ;
index 28a0b75..5b2457a 100644 (file)
@@ -57,19 +57,19 @@ public:
   Double_t   fDeltaPhiMinCut ;      //  Maximum Delta Phi Gamma-Hadron
 
   //Histograms
-  TH2F * fhPhiCharged  ; //Phi distribution of selected charged particles
-  TH2F * fhPhiNeutral   ;  //Phi distribution of selected neutral particles
-  TH2F * fhEtaCharged  ; //Eta distribution of selected charged particles
-  TH2F * fhEtaNeutral   ; //Eta distribution of selected neutral particles
-  TH2F * fhDeltaPhiCharged  ;  //Difference of charged particle phi and trigger particle  phi as function of  trigger particle pT
-  TH2F * fhDeltaPhiNeutral   ;  //Difference of neutral particle phi and trigger particle  phi as function of  trigger particle pT
-  TH2F * fhDeltaEtaCharged  ;  //Difference of charged particle eta and trigger particle  eta as function of  trigger particle pT
-  TH2F * fhDeltaEtaNeutral  ;  //Difference of neutral particle eta and trigger particle  eta as function of  trigger particle pT
-  TH2F * fhDeltaPhiChargedPt  ;  //Difference of charged particle phi and trigger particle  phi as function of charged particle pT
-  TH2F * fhDeltaPhiNeutralPt  ;  //Difference of neutral particle phi and trigger particle  phi as function of neutral particle particle pT
-
-  TH2F * fhPtImbalanceNeutral  ; //Trigger particle - neutral hadron momentum imbalance histogram 
-  TH2F * fhPtImbalanceCharged  ; //Trigger particle -charged hadron momentim imbalance histogram
+  TH2F * fhPhiCharged  ; //! Phi distribution of selected charged particles
+  TH2F * fhPhiNeutral   ;  //! Phi distribution of selected neutral particles
+  TH2F * fhEtaCharged  ; //! Eta distribution of selected charged particles
+  TH2F * fhEtaNeutral   ; //! Eta distribution of selected neutral particles
+  TH2F * fhDeltaPhiCharged  ;  //! Difference of charged particle phi and trigger particle  phi as function of  trigger particle pT
+  TH2F * fhDeltaPhiNeutral   ;  //! Difference of neutral particle phi and trigger particle  phi as function of  trigger particle pT
+  TH2F * fhDeltaEtaCharged  ;  //! Difference of charged particle eta and trigger particle  eta as function of  trigger particle pT
+  TH2F * fhDeltaEtaNeutral  ;  //! Difference of neutral particle eta and trigger particle  eta as function of  trigger particle pT
+  TH2F * fhDeltaPhiChargedPt  ;  //! Difference of charged particle phi and trigger particle  phi as function of charged particle pT
+  TH2F * fhDeltaPhiNeutralPt  ;  //! Difference of neutral particle phi and trigger particle  phi as function of neutral particle particle pT
+
+  TH2F * fhPtImbalanceNeutral  ; //! Trigger particle - neutral hadron momentum imbalance histogram 
+  TH2F * fhPtImbalanceCharged  ; //! Trigger particle -charged hadron momentim imbalance histogram
   
   ClassDef(AliAnaParticleHadronCorrelation,1)
 } ;
index 0b4e649..0a03789 100644 (file)
@@ -172,75 +172,75 @@ public:
   
   //Histograms
   //Leading particle distributions
-  TList *  fOutCont ; // Container for histograms
-
-  TH2F * fhChargedLeadingPt  ;    //Pt(Pt trigger) distribution of charged hadrons
-  TH2F * fhChargedLeadingPhi  ;   //Phi(Pt trigger) distribution of charged hadrons
-  TH2F * fhChargedLeadingEta  ;   //Eta(Pt trigger) distribution of charged hadrons
-  TH2F * fhChargedLeadingDeltaPt  ;   //Difference of charged hadron and trigger  pT as function of trigger p
-  TH2F * fhChargedLeadingDeltaPhi  ;  //Difference of charged hadron and trigger  phi as function of trigger pT
-  TH2F * fhChargedLeadingDeltaEta ;   //Difference of charged particle and trigger eta as function of trigger pT
-  TH2F * fhChargedLeadingRatioPt  ; //Ratio of Pt leading charge and trigger
-
-  TH2F * fhNeutralLeadingPt   ;   //Pt(Pt trigger) distribution of neutral hadrons
-  TH2F * fhNeutralLeadingPhi   ;  //Phi(Pt trigger) distribution of neutral hadrons
-  TH2F * fhNeutralLeadingEta   ;  //Eta(Pt trigger) distribution of neutral hadrons
-  TH2F * fhNeutralLeadingDeltaPt   ;  //Difference of neutral hadron and trigger pT as function of trigger pT
-  TH2F * fhNeutralLeadingDeltaPhi  ;  //Difference of neutral hadron and trigger phi as function of trigger pT
-  TH2F * fhNeutralLeadingDeltaEta ;   //Difference of charged particle and trigger eta as function of trigger pT
-  TH2F * fhNeutralLeadingRatioPt   ;  //Ratio of Pt leading neutral and trigger
-
-  //Jet distributions
-  //Fixed cone and pt threshold
-  TH2F * fhJetPt  ; //leading pt jet vs pt trigger
-  TH2F * fhJetRatioPt  ; //Ratio of pt jet and pt trigger
-  TH2F * fhJetDeltaPhi  ; //Delta phi jet-trigger
-  TH2F * fhJetDeltaEta  ; //Delta eta jet-trigger
-  TH2F * fhJetLeadingRatioPt  ; //Ratio of pt leading and pt jet
-  TH2F * fhJetLeadingDeltaPhi  ; //Delta phi jet-leading
-  TH2F * fhJetLeadingDeltaEta  ; //Delta eta jet-leading
-  TH2F * fhJetFFz; //Accepted reconstructed jet fragmentation function, z=ptjet/pttrig
-  TH2F * fhJetFFxi; //Accepted reconstructed jet fragmentation function, xsi = ln(pttrig/ptjet)
-  TH2F * fhJetFFpt; //Jet particle pt distribution in cone
-  TH2F * fhJetNTracksInCone   ; //jet multiplicity in cone
-
-  TH2F * fhBkgPt  ; //leading pt bakground vs pt trigger
-  TH2F * fhBkgRatioPt  ; //Ratio of pt background and pt trigger
-  TH2F * fhBkgDeltaPhi  ; //Delta phi background-trigger
-  TH2F * fhBkgDeltaEta  ; //Delta eta background-trigger
-  TH2F * fhBkgLeadingRatioPt  ; //Ratio of pt leading and pt background
-  TH2F * fhBkgLeadingDeltaPhi  ; //Delta phi background-leading
-  TH2F * fhBkgLeadingDeltaEta  ; //Delta eta background-leading
-  TH2F * fhBkgFFz; //Accepted reconstructed background fragmentation function, z=ptjet/pttrig
-  TH2F * fhBkgFFxi; //Accepted reconstructed background fragmentation function, xsi = ln(pttrig/ptjet)
-  TH2F * fhBkgFFpt; //Background particle pt distribution in cone
-  TH2F * fhBkgNTracksInCone   ; //Background multiplicity in cone
-
-  //Variable cone and pt threshold
-
-  TH2F * fhJetPts[5][5]; //leading pt jet vs pt trigger
-  TH2F * fhJetRatioPts[5][5]; //Ratio of pt jet and pt trigger
-  TH2F * fhJetDeltaPhis[5][5]; //Delta phi jet-trigger
-  TH2F * fhJetDeltaEtas[5][5]; //Delta eta jet-trigger
-  TH2F * fhJetLeadingRatioPts[5][5]; //Ratio of pt leading and pt jet
-  TH2F * fhJetLeadingDeltaPhis[5][5]; //Delta phi jet-leading
-  TH2F * fhJetLeadingDeltaEtas[5][5]; //Delta eta jet-leading
-  TH2F * fhJetFFzs[5][5]; //Accepted reconstructed jet fragmentation function, z=ptjet/pttrig
-  TH2F * fhJetFFxis[5][5]; //Accepted reconstructed jet fragmentation function, xsi = ln(pttrig/ptjet)
-  TH2F * fhJetFFpts[5][5]; //Jet particle pt distribution in cone
-  TH2F * fhJetNTracksInCones[5][5]; //jet multiplicity in cone
-
-  TH2F * fhBkgPts[5][5]; //leading pt bakground vs pt trigger
-  TH2F * fhBkgRatioPts[5][5]; //Ratio of pt background and pt trigger
-  TH2F * fhBkgDeltaPhis[5][5]; //Delta phi background-trigger
-  TH2F * fhBkgDeltaEtas[5][5]; //Delta eta background-trigger
-  TH2F * fhBkgLeadingRatioPts[5][5]; //Ratio of pt leading and pt background
-  TH2F * fhBkgLeadingDeltaPhis[5][5]; //Delta phi background-leading
-  TH2F * fhBkgLeadingDeltaEtas[5][5]; //Delta eta background-leading
-  TH2F * fhBkgFFzs[5][5]; //Accepted reconstructed background fragmentation function, z=ptjet/pttrig
-  TH2F * fhBkgFFxis[5][5]; //Accepted reconstructed background fragmentation function, xsi = ln(pttrig/ptjet)
-  TH2F * fhBkgFFpts[5][5]; //Background particle pt distribution in cone
-  TH2F * fhBkgNTracksInCones[5][5]; //Background multiplicity in cone
+  TList *  fOutCont ; //! Container for histograms
+
+  TH2F * fhChargedLeadingPt  ;    //! Pt(Pt trigger) distribution of charged hadrons
+  TH2F * fhChargedLeadingPhi  ;   //! Phi(Pt trigger) distribution of charged hadrons
+  TH2F * fhChargedLeadingEta  ;   //! Eta(Pt trigger) distribution of charged hadrons
+  TH2F * fhChargedLeadingDeltaPt  ;   //! Difference of charged hadron and trigger  pT as function of trigger p
+  TH2F * fhChargedLeadingDeltaPhi  ;  //! Difference of charged hadron and trigger  phi as function of trigger pT
+  TH2F * fhChargedLeadingDeltaEta ;   //! Difference of charged particle and trigger eta as function of trigger pT
+  TH2F * fhChargedLeadingRatioPt  ; //! Ratio of Pt leading charge and trigger
+
+  TH2F * fhNeutralLeadingPt   ;   //! Pt(Pt trigger) distribution of neutral hadrons
+  TH2F * fhNeutralLeadingPhi   ;  //! Phi(Pt trigger) distribution of neutral hadrons
+  TH2F * fhNeutralLeadingEta   ;  //! Eta(Pt trigger) distribution of neutral hadrons
+  TH2F * fhNeutralLeadingDeltaPt   ;  //! Difference of neutral hadron and trigger pT as function of trigger pT
+  TH2F * fhNeutralLeadingDeltaPhi  ;  //! Difference of neutral hadron and trigger phi as function of trigger pT
+  TH2F * fhNeutralLeadingDeltaEta ;   //! Difference of charged particle and trigger eta as function of trigger pT
+  TH2F * fhNeutralLeadingRatioPt   ;  //! Ratio of Pt leading neutral and trigger
+
+  // Jet distributions
+  // Fixed cone and pt threshold
+  TH2F * fhJetPt  ; //! leading pt jet vs pt trigger
+  TH2F * fhJetRatioPt  ; //! Ratio of pt jet and pt trigger
+  TH2F * fhJetDeltaPhi  ; //! Delta phi jet-trigger
+  TH2F * fhJetDeltaEta  ; //! Delta eta jet-trigger
+  TH2F * fhJetLeadingRatioPt  ; //! Ratio of pt leading and pt jet
+  TH2F * fhJetLeadingDeltaPhi  ; //! Delta phi jet-leading
+  TH2F * fhJetLeadingDeltaEta  ; //! Delta eta jet-leading
+  TH2F * fhJetFFz; //! Accepted reconstructed jet fragmentation function, z=ptjet/pttrig
+  TH2F * fhJetFFxi; //! Accepted reconstructed jet fragmentation function, xsi = ln(pttrig/ptjet)
+  TH2F * fhJetFFpt; //! Jet particle pt distribution in cone
+  TH2F * fhJetNTracksInCone   ; //! jet multiplicity in cone
+
+  TH2F * fhBkgPt  ; //! leading pt bakground vs pt trigger
+  TH2F * fhBkgRatioPt  ; //! Ratio of pt background and pt trigger
+  TH2F * fhBkgDeltaPhi  ; //! Delta phi background-trigger
+  TH2F * fhBkgDeltaEta  ; //! Delta eta background-trigger
+  TH2F * fhBkgLeadingRatioPt  ; //! Ratio of pt leading and pt background
+  TH2F * fhBkgLeadingDeltaPhi  ; //! Delta phi background-leading
+  TH2F * fhBkgLeadingDeltaEta  ; //! Delta eta background-leading
+  TH2F * fhBkgFFz; //! Accepted reconstructed background fragmentation function, z=ptjet/pttrig
+  TH2F * fhBkgFFxi; //! Accepted reconstructed background fragmentation function, xsi = ln(pttrig/ptjet)
+  TH2F * fhBkgFFpt; //! Background particle pt distribution in cone
+  TH2F * fhBkgNTracksInCone   ; //! Background multiplicity in cone
+
+  // Variable cone and pt threshold
+
+  TH2F * fhJetPts[5][5]; //! leading pt jet vs pt trigger
+  TH2F * fhJetRatioPts[5][5]; //! Ratio of pt jet and pt trigger
+  TH2F * fhJetDeltaPhis[5][5]; //! Delta phi jet-trigger
+  TH2F * fhJetDeltaEtas[5][5]; //! Delta eta jet-trigger
+  TH2F * fhJetLeadingRatioPts[5][5]; //! Ratio of pt leading and pt jet
+  TH2F * fhJetLeadingDeltaPhis[5][5]; //! Delta phi jet-leading
+  TH2F * fhJetLeadingDeltaEtas[5][5]; //! Delta eta jet-leading
+  TH2F * fhJetFFzs[5][5]; //! Accepted reconstructed jet fragmentation function, z=ptjet/pttrig
+  TH2F * fhJetFFxis[5][5]; //! Accepted reconstructed jet fragmentation function, xsi = ln(pttrig/ptjet)
+  TH2F * fhJetFFpts[5][5]; //! Jet particle pt distribution in cone
+  TH2F * fhJetNTracksInCones[5][5]; //! jet multiplicity in cone
+
+  TH2F * fhBkgPts[5][5]; //! leading pt bakground vs pt trigger
+  TH2F * fhBkgRatioPts[5][5]; //! Ratio of pt background and pt trigger
+  TH2F * fhBkgDeltaPhis[5][5]; //! Delta phi background-trigger
+  TH2F * fhBkgDeltaEtas[5][5]; //! Delta eta background-trigger
+  TH2F * fhBkgLeadingRatioPts[5][5]; //! Ratio of pt leading and pt background
+  TH2F * fhBkgLeadingDeltaPhis[5][5]; //! Delta phi background-leading
+  TH2F * fhBkgLeadingDeltaEtas[5][5]; //! Delta eta background-leading
+  TH2F * fhBkgFFzs[5][5]; //! Accepted reconstructed background fragmentation function, z=ptjet/pttrig
+  TH2F * fhBkgFFxis[5][5]; //! Accepted reconstructed background fragmentation function, xsi = ln(pttrig/ptjet)
+  TH2F * fhBkgFFpts[5][5]; //! Background particle pt distribution in cone
+  TH2F * fhBkgNTracksInCones[5][5]; //! Background multiplicity in cone
   
   
   ClassDef(AliAnaParticleJetLeadingConeCorrelation,1)
index 1fa8736..e942e50 100644 (file)
@@ -43,15 +43,15 @@ class AliAnaParticlePartonCorrelation : public AliAnaBaseClass {
        
   private:
        
-       TH2F * fhDeltaEtaNearParton; //Difference of parton eta and prompt trigger particle eta
-       TH2F * fhDeltaPhiNearParton; //Difference of parton phi and prompt trigger particle phi
-       TH2F * fhDeltaPtNearParton; //Difference of parton pT and prompt trigger particle pT
-       TH2F * fhPtRatNearParton; //Ratio of parton pT and prompt trigger particle pT
-       
-       TH2F * fhDeltaEtaAwayParton; //Difference of parton eta and prompt trigger particle eta
-       TH2F * fhDeltaPhiAwayParton; //Difference of parton phi and prompt trigger particle phi
-       TH2F * fhDeltaPtAwayParton; //Difference of parton pT and prompt trigger particle pT
-       TH2F * fhPtRatAwayParton; //Ratio of parton pT and prompt trigger particle pT
+       TH2F * fhDeltaEtaNearParton; //! Difference of parton eta and prompt trigger particle eta
+       TH2F * fhDeltaPhiNearParton; //! Difference of parton phi and prompt trigger particle phi
+       TH2F * fhDeltaPtNearParton; //! Difference of parton pT and prompt trigger particle pT
+       TH2F * fhPtRatNearParton; //! Ratio of parton pT and prompt trigger particle pT
+       
+       TH2F * fhDeltaEtaAwayParton; //! Difference of parton eta and prompt trigger particle eta
+       TH2F * fhDeltaPhiAwayParton; //! Difference of parton phi and prompt trigger particle phi
+       TH2F * fhDeltaPtAwayParton; //! Difference of parton pT and prompt trigger particle pT
+       TH2F * fhPtRatAwayParton; //! Ratio of parton pT and prompt trigger particle pT
 
        ClassDef(AliAnaParticlePartonCorrelation,1)
  } ;
index 19f3961..25ed2f0 100644 (file)
@@ -48,14 +48,14 @@ private:
 
   // Histograms
   TList   * fOutputList ;      //! output data list
-  TNtuple * fhPHOSPos ;                // PHOS (x,y)
-  TNtuple * fhPHOS ;           // all PHOS parameters
-  TH1D    * fhPHOSEnergy ;     // PHOS energy 
-  TH1I    * fhPHOSDigits ;     // PHOS numer of SDigits 
-  TH1D    * fhPHOSRecParticles ;// PHOS number of RecParticles
-  TH1I    * fhPHOSPhotons ;            // PHOS number of photons
-  TH1D    * fhPHOSInvariantMass ;// PHOS invariant mass
-  TH1I    * fhPHOSDigitsEvent ;                //PHOS numbet of Sdigits per event      
+  TNtuple * fhPHOSPos ;                //! PHOS (x,y)
+  TNtuple * fhPHOS ;           //! all PHOS parameters
+  TH1D    * fhPHOSEnergy ;     //! PHOS energy 
+  TH1I    * fhPHOSDigits ;     //! PHOS numer of SDigits 
+  TH1D    * fhPHOSRecParticles ;//! PHOS number of RecParticles
+  TH1I    * fhPHOSPhotons ;    //! PHOS number of photons
+  TH1D    * fhPHOSInvariantMass ; //! PHOS invariant mass
+  TH1I    * fhPHOSDigitsEvent ;          //! PHOS numbet of Sdigits per event  
    
   ClassDef(AliAnalysisTaskPHOSExample, 1); // a PHOS photon analysis task 
 };
index 9edebaa..50cbaa2 100644 (file)
@@ -32,8 +32,8 @@ class AliAnalysisTaskParticleCorrelation : public AliAnalysisTaskSE
     AliAnalysisTaskParticleCorrelation& operator=(const AliAnalysisTaskParticleCorrelation&); // Not implemented
 
     AliAnaMaker* fAna; //  Pointer to the jet finder 
-    TList * fOutputContainer ; // Histogram container
-    TClonesArray * fAODBranch; //AOD branch
+    TList * fOutputContainer ; //! Histogram container
+    TClonesArray * fAODBranch; //! AOD branch
     TString fConfigName ; //Configuration file name
 
     ClassDef(AliAnalysisTaskParticleCorrelation, 1); // Analysis task for standard gamma correlation analysis