AliAnaElectron: Correct warning
authorgconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 8 Jul 2009 09:46:25 +0000 (09:46 +0000)
committergconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 8 Jul 2009 09:46:25 +0000 (09:46 +0000)
AliAnaParticleJetLeadingConeCorrelation: Added histograms to plot delta phi vs pt / pt trigger for the leading jet particle
AliAnaParticleHadronCorrelation: Modify for underlying event studies.
AliCaloTrackESDReader: modification of debug message.

PWG4/PartCorrBase/AliCaloTrackESDReader.cxx
PWG4/PartCorrDep/AliAnaElectron.cxx
PWG4/PartCorrDep/AliAnaParticleHadronCorrelation.cxx
PWG4/PartCorrDep/AliAnaParticleHadronCorrelation.h
PWG4/PartCorrDep/AliAnaParticleJetLeadingConeCorrelation.cxx
PWG4/PartCorrDep/AliAnaParticleJetLeadingConeCorrelation.h

index 8fdf97e..d731482 100755 (executable)
@@ -294,7 +294,7 @@ void AliCaloTrackESDReader::FillInputPHOS() {
     AliAODCaloCluster * clus =  (AliAODCaloCluster*) (fOutputEvent->GetCaloClusters())->At(iclus);     
     fAODPHOS->Add(clus);                               
   }    
-  if(fDebug > 1) printf("FillInputPHOS():: aod entries %d\n", fAODPHOS->GetEntriesFast());
+  if(fDebug > 1) printf("AliCaloTrackESDReader::FillInputPHOS() - aod entries %d\n", fAODPHOS->GetEntriesFast());
   
 }
 
index 6e00ca2..4ab094f 100755 (executable)
@@ -718,9 +718,9 @@ void  AliAnaElectron::Terminate(TList* outputList)
   //Do some plots to end\r
   //Recover histograms from output histograms list, needed for\r
   //distributed analysis.                \r
-  //  ReadHistograms(outputList);\r
+  //ReadHistograms(outputList);\r
 \r
-  printf(" AliAnaElectron::Terminate()  *** %s Report:", GetName()) ;\r
+  printf(" AliAnaElectron::Terminate()  *** %s Report: %d outputs", GetName(), outputList->GetEntries()) ;\r
 \r
 }\r
 \r
index 28df77a..9d691ef 100755 (executable)
@@ -43,14 +43,18 @@ ClassImp(AliAnaParticleHadronCorrelation)
 
 
 //____________________________________________________________________________
-  AliAnaParticleHadronCorrelation::AliAnaParticleHadronCorrelation() : 
+  AliAnaParticleHadronCorrelation::AliAnaParticleHadronCorrelation(): 
     AliAnaPartCorrBaseClass(),
-    fDeltaPhiMaxCut(0.), fDeltaPhiMinCut(0.), fSelectIsolated(0),  
+    fDeltaPhiMaxCut(0.), fDeltaPhiMinCut(0.), fSelectIsolated(0),
+    fMakeSeveralUE(0),  fUeDeltaPhiMaxCut(0.), fUeDeltaPhiMinCut(0.), 
     fhPhiCharged(0), fhPhiNeutral(0), fhEtaCharged(0), fhEtaNeutral(0), 
     fhDeltaPhiCharged(0), fhDeltaPhiNeutral(0), 
     fhDeltaEtaCharged(0), fhDeltaEtaNeutral(0),
-    fhDeltaPhiChargedPt(0), fhDeltaPhiNeutralPt(0), 
-    fhPtImbalanceNeutral(0), fhPtImbalanceCharged(0)
+    fhDeltaPhiChargedPt(0), fhDeltaPhiNeutralPt(0), fhDeltaPhiUeChargedPt(0), 
+    fhPtImbalanceNeutral(0), fhPtImbalanceCharged(0), 
+    fhPtImbalanceUeCharged(0),
+    fhDeltaPhiUeLeft(0),fhDeltaPhiUeRight(0),
+    fhPtImbalanceUeLeftCharged(0),fhPtImbalanceUeRightCharged(0)
 {
   //Default Ctor
   
@@ -59,20 +63,27 @@ ClassImp(AliAnaParticleHadronCorrelation)
 }
 
 //____________________________________________________________________________
-AliAnaParticleHadronCorrelation::AliAnaParticleHadronCorrelation(const AliAnaParticleHadronCorrelation & g) :   
+AliAnaParticleHadronCorrelation::AliAnaParticleHadronCorrelation(const AliAnaParticleHadronCorrelation & g):   
   AliAnaPartCorrBaseClass(g),
   fDeltaPhiMaxCut(g.fDeltaPhiMaxCut), fDeltaPhiMinCut(g.fDeltaPhiMinCut), 
   fSelectIsolated(g.fSelectIsolated),
+  fMakeSeveralUE(g.fMakeSeveralUE),  fUeDeltaPhiMaxCut(g.fUeDeltaPhiMaxCut), 
+  fUeDeltaPhiMinCut(g.fUeDeltaPhiMinCut), 
   fhPhiCharged(g.fhPhiCharged), fhPhiNeutral(g.fhPhiNeutral), 
   fhEtaCharged(g.fhEtaCharged), fhEtaNeutral(g.fhEtaNeutral), 
   fhDeltaPhiCharged(g.fhDeltaPhiCharged),  
   fhDeltaPhiNeutral(g.fhDeltaPhiNeutral), 
   fhDeltaEtaCharged(g.fhDeltaEtaCharged), 
   fhDeltaEtaNeutral(g.fhDeltaEtaNeutral), 
-  fhDeltaPhiChargedPt(g.fhDeltaPhiChargedPt), 
+  fhDeltaPhiChargedPt(g.fhDeltaPhiChargedPt),
   fhDeltaPhiNeutralPt(g.fhDeltaPhiNeutralPt), 
+  fhDeltaPhiUeChargedPt(g.fhDeltaPhiUeChargedPt), 
   fhPtImbalanceNeutral(g.fhPtImbalanceNeutral), 
-  fhPtImbalanceCharged(g.fhPtImbalanceCharged)
+  fhPtImbalanceCharged(g.fhPtImbalanceCharged),
+  fhPtImbalanceUeCharged(g.fhPtImbalanceUeCharged),
+  fhDeltaPhiUeLeft(g.fhDeltaPhiUeLeft),fhDeltaPhiUeRight(g.fhDeltaPhiUeRight),
+  fhPtImbalanceUeLeftCharged(g.fhPtImbalanceUeLeftCharged),
+  fhPtImbalanceUeRightCharged(g.fhPtImbalanceUeRightCharged)
 {
   // cpy ctor
   
@@ -89,19 +100,25 @@ AliAnaParticleHadronCorrelation & AliAnaParticleHadronCorrelation::operator = (c
   fDeltaPhiMaxCut = source.fDeltaPhiMaxCut ; 
   fDeltaPhiMinCut = source.fDeltaPhiMinCut ; 
   fSelectIsolated = source.fSelectIsolated ;
-  
+  fMakeSeveralUE = source.fMakeSeveralUE ;
+  fUeDeltaPhiMaxCut = source.fUeDeltaPhiMaxCut ; 
+  fUeDeltaPhiMinCut = source.fUeDeltaPhiMinCut ;   
   fhPhiCharged = source.fhPhiCharged ; fhPhiNeutral = source.fhPhiNeutral ; 
   fhEtaCharged = source.fhEtaCharged ; fhEtaNeutral = source.fhEtaNeutral ; 
   fhDeltaPhiCharged = source.fhDeltaPhiCharged ;  
   fhDeltaPhiNeutral = source.fhDeltaPhiNeutral ; 
-  fhDeltaPhiNeutralPt = source.fhDeltaPhiNeutralPt ; 
   fhDeltaEtaCharged = source.fhDeltaEtaCharged ; 
   fhDeltaEtaNeutral = source.fhDeltaEtaNeutral ; 
   fhDeltaPhiChargedPt = source.fhDeltaPhiChargedPt ;
-  
+  fhDeltaPhiNeutralPt = source.fhDeltaPhiNeutralPt ; 
+  fhDeltaPhiUeChargedPt = source.fhDeltaPhiUeChargedPt ; 
   fhPtImbalanceNeutral = source.fhPtImbalanceNeutral ; 
   fhPtImbalanceCharged = source.fhPtImbalanceCharged ; 
-
+  fhPtImbalanceUeCharged = source.fhPtImbalanceUeCharged ; 
+  fhDeltaPhiUeLeft = source.fhDeltaPhiUeLeft ;
+  fhDeltaPhiUeRight = source.fhDeltaPhiUeRight ;
+  fhPtImbalanceUeLeftCharged = source.fhPtImbalanceUeLeftCharged ;
+  fhPtImbalanceUeRightCharged = source.fhPtImbalanceUeRightCharged ;
   return *this;
 
 }
@@ -141,15 +158,21 @@ TList *  AliAnaParticleHadronCorrelation::GetCreateOutputObjects()
     
     fhDeltaPhiCharged  = new TH2F
       ("DeltaPhiCharged","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}",
-       nptbins,ptmin,ptmax,200,0,6.4); 
+       nptbins,ptmin,ptmax,700,-2.,5.); 
     fhDeltaPhiCharged->SetYTitle("#Delta #phi");
     fhDeltaPhiCharged->SetXTitle("p_{T trigger} (GeV/c)");
     
     fhDeltaPhiChargedPt  = new TH2F
       ("DeltaPhiChargedPt","#phi_{trigger} - #phi_{#h^{#pm}} vs p_{T h^{#pm}}",
-       nptbins,ptmin,ptmax,200,0,6.4);
+       nptbins,ptmin,ptmax,700,-2.,5.);
     fhDeltaPhiChargedPt->SetYTitle("#Delta #phi");
     fhDeltaPhiChargedPt->SetXTitle("p_{T h^{#pm}} (GeV/c)");
+
+    fhDeltaPhiUeChargedPt  = new TH2F
+      ("DeltaPhiUeChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}}",
+       nptbins,ptmin,ptmax,700,-2.,5.);
+    fhDeltaPhiUeChargedPt->SetYTitle("#Delta #phi");
+    fhDeltaPhiUeChargedPt->SetXTitle("p_{T h^{#pm}} (GeV/c)");
     
     fhDeltaEtaCharged  = new TH2F
       ("DeltaEtaCharged","#eta_{trigger} - #eta_{h^{#pm}} vs p_{T trigger}",
@@ -159,16 +182,54 @@ TList *  AliAnaParticleHadronCorrelation::GetCreateOutputObjects()
     
     fhPtImbalanceCharged  = 
       new TH2F("CorrelationCharged","z_{trigger h^{#pm}} = p_{T h^{#pm}} / p_{T trigger}",
-              nptbins,ptmin,ptmax,1000,0.,1.2); 
+              nptbins,ptmin,ptmax,1000,0.,2.); 
     fhPtImbalanceCharged->SetYTitle("z_{trigger h^{#pm}}");
     fhPtImbalanceCharged->SetXTitle("p_{T trigger}");
     
+    fhPtImbalanceUeCharged  = 
+      new TH2F("CorrelationUeCharged","z_{trigger h^{#pm}} = p_{T Ueh^{#pm}} / p_{T trigger}",
+              nptbins,ptmin,ptmax,1000,0.,2.); 
+    fhPtImbalanceUeCharged->SetYTitle("z_{trigger Ueh^{#pm}}");
+    fhPtImbalanceUeCharged->SetXTitle("p_{T trigger}");
+
     outputContainer->Add(fhPhiCharged) ;
     outputContainer->Add(fhEtaCharged) ;
     outputContainer->Add(fhDeltaPhiCharged) ; 
     outputContainer->Add(fhDeltaEtaCharged) ;
-    outputContainer->Add(fhPtImbalanceCharged) ;
     outputContainer->Add(fhDeltaPhiChargedPt) ;
+    outputContainer->Add(fhDeltaPhiUeChargedPt) ;
+    outputContainer->Add(fhPtImbalanceCharged) ;
+    outputContainer->Add(fhPtImbalanceUeCharged) ;
+
+    if(fMakeSeveralUE){ 
+      fhDeltaPhiUeLeft  = new TH2F
+       ("DeltaPhiUeLeftChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}} with UE left side range of trigger particles",
+        nptbins,ptmin,ptmax,700,-2.,5.);
+      fhDeltaPhiUeLeft->SetYTitle("#Delta #phi");
+      fhDeltaPhiUeLeft->SetXTitle("p_{T h^{#pm}} (GeV/c)");
+      outputContainer->Add(fhDeltaPhiUeLeft) ;
+
+      fhDeltaPhiUeRight  = new TH2F
+       ("DeltaPhiUeRightChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}} with UE right side range of trigger particles",
+        nptbins,ptmin,ptmax,700,-2.,5.);
+      fhDeltaPhiUeRight->SetYTitle("#Delta #phi");
+      fhDeltaPhiUeRight->SetXTitle("p_{T h^{#pm}} (GeV/c)");
+      outputContainer->Add(fhDeltaPhiUeRight) ;
+      
+      fhPtImbalanceUeLeftCharged  = 
+       new TH2F("CorrelationUeChargedLeft","z_{trigger h^{#pm}} = p_{T Ueh^{#pm}} / p_{T trigger} with UE left side of trigger",
+                nptbins,ptmin,ptmax,1000,0.,2.); 
+      fhPtImbalanceUeLeftCharged->SetYTitle("z_{trigger Ueh^{#pm}}");
+      fhPtImbalanceUeLeftCharged->SetXTitle("p_{T trigger}");
+      outputContainer->Add(fhPtImbalanceUeLeftCharged) ;
+      
+      fhPtImbalanceUeRightCharged  = 
+       new TH2F("CorrelationUeChargedRight","z_{trigger h^{#pm}} = p_{T Ueh^{#pm}} / p_{T trigger} with UE right side of trigger",
+                nptbins,ptmin,ptmax,1000,0.,2.); 
+      fhPtImbalanceUeRightCharged->SetYTitle("z_{trigger Ueh^{#pm}}");
+      fhPtImbalanceUeRightCharged->SetXTitle("p_{T trigger}");
+      outputContainer->Add(fhPtImbalanceUeRightCharged) ;
+    }  
   }  //Correlation with charged hadrons
   
   //Correlation with neutral hadrons
@@ -194,7 +255,7 @@ TList *  AliAnaParticleHadronCorrelation::GetCreateOutputObjects()
     
     fhDeltaPhiNeutralPt  = new TH2F
       ("DeltaPhiNeutralPt","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T #pi^{0}}}",
-       nptbins,ptmin,ptmax,200,0,6.4); 
+       nptbins,ptmin,ptmax,700,-2.,5.); 
     fhDeltaPhiNeutralPt->SetYTitle("#Delta #phi");
     fhDeltaPhiNeutralPt->SetXTitle("p_{T trigger} (GeV/c)");
     
@@ -206,7 +267,7 @@ TList *  AliAnaParticleHadronCorrelation::GetCreateOutputObjects()
     
     fhPtImbalanceNeutral  = 
       new TH2F("CorrelationNeutral","z_{trigger #pi} = p_{T #pi^{0}} / p_{T trigger}",
-              nptbins,ptmin,ptmax,1000,0.,1.2); 
+              nptbins,ptmin,ptmax,1000,0.,2.); 
     fhPtImbalanceNeutral->SetYTitle("z_{trigger #pi^{0}}");
     fhPtImbalanceNeutral->SetXTitle("p_{T trigger}");
     
@@ -244,10 +305,13 @@ void AliAnaParticleHadronCorrelation::InitParameters()
   //SetOutputAODClassName("AliAODPWG4Particle");
   //SetOutputAODName("Pi0Correlated");
        
-  SetPtCutRange(2,300);
+  SetPtCutRange(0.,300);
   fDeltaPhiMinCut = 1.5 ;
   fDeltaPhiMaxCut = 4.5 ;
   fSelectIsolated = kFALSE;
+  fMakeSeveralUE = kFALSE;
+  fUeDeltaPhiMinCut = 1. ;
+  fUeDeltaPhiMaxCut = 1.5 ;
 }
 
 //__________________________________________________________________
@@ -264,6 +328,9 @@ void AliAnaParticleHadronCorrelation::Print(const Option_t * opt) const
   printf("Phi trigger particle-Hadron      <     %3.2f\n", fDeltaPhiMaxCut) ; 
   printf("Phi trigger particle-Hadron      >     %3.2f\n", fDeltaPhiMinCut) ;
   printf("Isolated Trigger?  %d\n", fSelectIsolated) ;
+  printf("Phi trigger particle-UeHadron    <    %3.2f\n", fUeDeltaPhiMaxCut) ; 
+  printf("Phi trigger particle-UeHadron    >    %3.2f\n", fUeDeltaPhiMinCut) ;
+  printf("Several UE?  %d\n", fMakeSeveralUE) ;
 } 
 
 //____________________________________________________________________________
@@ -365,78 +432,99 @@ void  AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms()
 //____________________________________________________________________________
 void  AliAnaParticleHadronCorrelation::MakeChargedCorrelation(AliAODPWG4ParticleCorrelation *aodParticle, TRefArray* pl, const Bool_t bFillHisto)
 {  
-  // Charged Hadron Correlation Analysis
-  if(GetDebug() > 1)printf("AliAnaParticleHadronCorrelation::MakeChargedCorrelation() - Make trigger particle - charged hadron correlation \n");
-  
-  Double_t ptTrig  = aodParticle->Pt();
-  Double_t phiTrig = aodParticle->Phi();
-  Double_t pt   = -100.;
-  Double_t rat  = -100.; 
-  Double_t phi  = -100. ;
-  Double_t eta  = -100. ;
-  Double_t p[3];
-  Bool_t   first=kTRUE;
-  
-  TRefArray * reftracks    =0x0;
-  if(!bFillHisto) 
-    reftracks    = new TRefArray;
-  
-
-  //Track loop, select tracks with good pt, phi and fill AODs or histograms
-  for(Int_t ipr = 0;ipr < pl->GetEntries() ; ipr ++ ){
-    AliAODTrack * track = (AliAODTrack *) (pl->At(ipr)) ;
-    track->GetPxPyPz(p) ;
-    TLorentzVector mom(p[0],p[1],p[2],0);
-    pt   = mom.Pt();
-    eta  = mom.Eta();
-    phi  = mom.Phi() ;
-    if(phi < 0) phi+=TMath::TwoPi();
-    rat   = pt/ptTrig ;
-    
-    if(IsFidutialCutOn()){
-      Bool_t in = GetFidutialCut()->IsInFidutialCut(mom,"CTS") ;
-      if(! in ) continue ;
-    }    
-
-    //Select only hadrons in pt range
-    if(pt < GetMinPt() || pt > GetMaxPt()) continue ;
-    
-    //Selection within angular range
-    Float_t deltaphi = TMath::Abs(phiTrig-phi);
-    if( (deltaphi < fDeltaPhiMinCut) || ( deltaphi > fDeltaPhiMaxCut) ) continue ;    
-    
-    if(GetDebug() > 2)
-      printf("AliAnaParticleHadronCorrelation::MakeChargedCorrelation() - Charged hadron: pt %f, phi %f, phi trigger %f. Cuts:  delta phi  %2.2f < %2.2f < %2.2f, pT min %2.2f \n",
-            pt,phi, phiTrig,fDeltaPhiMinCut, deltaphi, fDeltaPhiMaxCut, GetMinPt());
-    
-    if(bFillHisto){
-      // Fill Histograms
-      fhEtaCharged->Fill(ptTrig,eta);
-      fhPhiCharged->Fill(ptTrig,phi);
-      fhDeltaEtaCharged->Fill(ptTrig,aodParticle->Eta()-eta);
-      fhDeltaPhiCharged->Fill(ptTrig, deltaphi);
-      fhDeltaPhiChargedPt->Fill(pt,deltaphi);
-      if(GetDebug() > 2 ) printf("AliAnaParticleHadronCorrelation::MakeChargedCorrelation() - Selected charge for momentum imbalance: pt %2.2f, phi %2.2f, eta %2.2f \n",pt,phi,eta);
-      fhPtImbalanceCharged->Fill(ptTrig,rat);
-    }
-    else{
-      //Fill AODs
+   // Charged Hadron Correlation Analysis
+   if(GetDebug() > 1)printf("AliAnaParticleHadronCorrelation::MakeChargedCorrelation() - Make trigger particle - charged hadron correlation \n");
+  
+   Double_t ptTrig  = aodParticle->Pt();
+   Double_t phiTrig = aodParticle->Phi();
+   Double_t pt   = -100.;
+   Double_t rat  = -100.; 
+   Double_t phi  = -100. ;
+   Double_t eta  = -100. ;
+   Double_t p[3];
+   Bool_t   first=kTRUE;
+  
+    TRefArray * reftracks    =0x0;
+   if(!bFillHisto) 
+     reftracks    = new TRefArray;
+  
+   //Track loop, select tracks with good pt, phi and fill AODs or histograms
+   for(Int_t ipr = 0;ipr < pl->GetEntries() ; ipr ++ ){
+     AliAODTrack * track = (AliAODTrack *) (pl->At(ipr)) ;
+     track->GetPxPyPz(p) ;
+     TLorentzVector mom(p[0],p[1],p[2],0);
+     pt   = mom.Pt();
+     eta  = mom.Eta();
+     phi  = mom.Phi() ;
+     if(phi < 0) phi+=TMath::TwoPi();
+     rat   = pt/ptTrig ;
+    
+     if(IsFidutialCutOn()){
+       Bool_t in = GetFidutialCut()->IsInFidutialCut(mom,"CTS") ;
+       if(! in ) continue ;
+     }    
+
+     //Select only hadrons in pt range
+     if(pt < GetMinPt() || pt > GetMaxPt()) continue ;
+    
+     //Selection within angular range
+     Float_t deltaphi = phiTrig-phi;
+     if(deltaphi<-TMath::PiOver2()) deltaphi+=TMath::TwoPi();
+     if(deltaphi>3*TMath::PiOver2()) deltaphi-=TMath::TwoPi();
+    
+     if(GetDebug() > 2)
+       printf("AliAnaParticleHadronCorrelation::MakeChargedCorrelation() - Charged hadron: pt %f, phi %f, phi trigger %f. Cuts:  delta phi  %2.2f < %2.2f < %2.2f, pT min %2.2f \n",
+            pt,phi, phiTrig,fDeltaPhiMinCut, deltaphi, fDeltaPhiMaxCut, GetMinPt());
+    
+     if(bFillHisto){
+       // Fill Histograms
+       fhEtaCharged->Fill(ptTrig,eta);
+       fhPhiCharged->Fill(ptTrig,phi);
+       fhDeltaEtaCharged->Fill(ptTrig,aodParticle->Eta()-eta);
+       fhDeltaPhiCharged->Fill(ptTrig, deltaphi);
+
+       if(GetDebug() > 2 ) printf("AliAnaParticleHadronCorrelation::MakeChargedCorrelation() - Selected charge for momentum imbalance: pt %2.2f, phi %2.2f, eta %2.2f \n",pt,phi,eta);
+
+       //several UE calculation 
+      if(fMakeSeveralUE){
+        if((deltaphi<-fUeDeltaPhiMinCut) && (deltaphi >-fUeDeltaPhiMaxCut)){  
+          fhDeltaPhiUeLeft->Fill(pt,deltaphi);
+          fhPtImbalanceUeLeftCharged->Fill(ptTrig,rat);
+       }
+        if((deltaphi>fUeDeltaPhiMinCut) && (deltaphi <fUeDeltaPhiMaxCut)){  
+          fhDeltaPhiUeRight->Fill(pt,deltaphi);
+          fhPtImbalanceUeRightCharged->Fill(ptTrig,rat);
+        }
+      } //several UE calculation
+
+       if( (deltaphi < fDeltaPhiMinCut) || ( deltaphi > fDeltaPhiMaxCut) ) {
+      fhDeltaPhiUeChargedPt->Fill(pt,deltaphi);
+      fhPtImbalanceUeCharged->Fill(ptTrig,rat);
+
+       }
+       else {
+       fhDeltaPhiChargedPt->Fill(pt,deltaphi);
+       fhPtImbalanceCharged->Fill(ptTrig,rat);
+       }
+     }
+     else{
+       //Fill AODs
       
-      if(first) {
-       new (reftracks) TRefArray(TProcessID::GetProcessWithUID(track)); 
-       first = kFALSE;
-      }
+       if(first) {
+       new (reftracks) TRefArray(TProcessID::GetProcessWithUID(track)); 
+       first = kFALSE;
+       }
       
-      reftracks->Add(track);
+       reftracks->Add(track);
       
-    }//aod particle loop
-  }// track loop
+     }//aod particle loop
+   }// track loop
   
-  //Fill AOD with reference tracks, if not filling histograms
-  if(!bFillHisto && reftracks->GetEntriesFast() > 0) {
-    reftracks->SetName(GetAODRefArrayName()+"Tracks");
-    aodParticle->AddRefArray(reftracks);
-  }
+   //Fill AOD with reference tracks, if not filling histograms
+   if(!bFillHisto && reftracks->GetEntriesFast() > 0) {
+     reftracks->SetName(GetAODRefArrayName()+"Tracks");
+     aodParticle->AddRefArray(reftracks);
+   }
   
 }  
 
@@ -482,8 +570,8 @@ void  AliAnaParticleHadronCorrelation::MakeNeutralCorrelationFillAOD(AliAODPWG4P
       //Selection within angular range
       Float_t phi = gammai.Phi();
       if(phi < 0) phi+=TMath::TwoPi();
-      Float_t deltaphi = TMath::Abs(phiTrig-phi);
-      if( (deltaphi < fDeltaPhiMinCut) || ( deltaphi > fDeltaPhiMaxCut) ) continue ;
+      //Float_t deltaphi = TMath::Abs(phiTrig-phi);
+      //if( (deltaphi < fDeltaPhiMinCut) || ( deltaphi > fDeltaPhiMaxCut) ) continue ;
       
       AliAODPWG4Particle pi0 = AliAODPWG4Particle(gammai);
       //pi0.SetLabel(calo->GetLabel(0));
@@ -521,8 +609,8 @@ void  AliAnaParticleHadronCorrelation::MakeNeutralCorrelationFillAOD(AliAODPWG4P
          //Selection within angular range
          Float_t phi = (gammai+gammaj).Phi();
          if(phi < 0) phi+=TMath::TwoPi();
-         Float_t deltaphi = TMath::Abs(phiTrig-phi);
-         if( (deltaphi < fDeltaPhiMinCut) || ( deltaphi > fDeltaPhiMaxCut) ) continue ;
+         //Float_t deltaphi = TMath::Abs(phiTrig-phi);
+         //if( (deltaphi < fDeltaPhiMinCut) || ( deltaphi > fDeltaPhiMaxCut) ) continue ;
          
          //Select good pair (aperture and invariant mass)
          if(GetNeutralMesonSelection()->SelectPair(gammai, gammaj)){
@@ -608,9 +696,12 @@ void  AliAnaParticleHadronCorrelation::MakeNeutralCorrelationFillHistograms(AliA
     
     //Selection within angular range
     phi = pi0->Phi();
-    Float_t deltaphi = TMath::Abs(phiTrig-phi);
-    if( (deltaphi < fDeltaPhiMinCut) || ( deltaphi > fDeltaPhiMaxCut) ) continue ;
-    
+    //Float_t deltaphi = TMath::Abs(phiTrig-phi);
+    //if( (deltaphi < fDeltaPhiMinCut) || ( deltaphi > fDeltaPhiMaxCut) ) continue ;
+    Float_t deltaphi = phiTrig-phi;
+    if(deltaphi<-TMath::PiOver2()) deltaphi+=TMath::TwoPi();
+    if(deltaphi>3*TMath::PiOver2()) deltaphi-=TMath::TwoPi();
+         
     rat = pt/ptTrig ;
     phi = pi0->Phi() ;
     eta = pi0->Eta() ;
@@ -619,9 +710,12 @@ void  AliAnaParticleHadronCorrelation::MakeNeutralCorrelationFillHistograms(AliA
     fhPhiNeutral->Fill(ptTrig,phi);
     fhDeltaEtaNeutral->Fill(ptTrig,etaTrig-eta);
     fhDeltaPhiNeutral->Fill(ptTrig,deltaphi);
-    fhDeltaPhiNeutralPt->Fill(pt,deltaphi);
-    fhPtImbalanceNeutral->Fill(ptTrig,rat);
-    
+         
+       if( (deltaphi > fDeltaPhiMinCut) && ( deltaphi < fDeltaPhiMaxCut) ) {
+               fhDeltaPhiNeutralPt->Fill(pt,deltaphi);
+               fhPtImbalanceNeutral->Fill(ptTrig,rat);
+       }
+         
     if(GetDebug() > 2 ) printf("AliAnaParticleHadronCorrelation::MakeNeutralCorrelation() - Selected neutral for momentum imbalance: pt %2.2f, phi %2.2f, eta %2.2f \n",pt,phi,eta);
     
   }//loop
index 2b4893f..ca4abf7 100755 (executable)
@@ -31,7 +31,15 @@ class AliAnaParticleHadronCorrelation : public AliAnaPartCorrBaseClass {
   Double_t GetDeltaPhiMinCut() const {return fDeltaPhiMinCut ; }
   void SetDeltaPhiCutRange(Double_t phimin, Double_t phimax)
   {fDeltaPhiMaxCut =phimax;  fDeltaPhiMinCut =phimin;}
-  
+
+  Double_t GetUeDeltaPhiMaxCut() const {return fUeDeltaPhiMaxCut ; }
+  Double_t GetUeDeltaPhiMinCut() const {return fUeDeltaPhiMinCut ; }
+  void SetUeDeltaPhiCutRange(Double_t uephimin, Double_t uephimax)
+  {fUeDeltaPhiMaxCut =uephimax;  fUeDeltaPhiMinCut =uephimin;}
+  Bool_t IsSeveralUEOn() const {return fMakeSeveralUE ; }
+  void SwitchOnSeveralUECalculation()  { fMakeSeveralUE = kTRUE;}
+  void SwitchOffSeveralUECalculation() { fMakeSeveralUE = kFALSE;}
+
   Bool_t OnlyIsolated() const {return fSelectIsolated ; }
   void SelectIsolated(Bool_t select) {fSelectIsolated = select ; }
   
@@ -53,6 +61,10 @@ class AliAnaParticleHadronCorrelation : public AliAnaPartCorrBaseClass {
   Double_t   fDeltaPhiMaxCut ;      // Minimum Delta Phi Gamma-Hadron
   Double_t   fDeltaPhiMinCut ;      // Maximum Delta Phi Gamma-Hadron
   Bool_t     fSelectIsolated ;      // Select only trigger particles isolated
+  Bool_t   fMakeSeveralUE ; // Do analysis for several underlying events contribution
+  Double_t   fUeDeltaPhiMaxCut ;      // Minimum Delta Phi Gamma-Underlying Hadron
+  Double_t   fUeDeltaPhiMinCut ;      // Maximum Delta Phi Gamma-Underlying Hadron
+
   
   //Histograms
   TH2F * fhPhiCharged  ; //! Phi distribution of selected charged particles
@@ -65,10 +77,18 @@ class AliAnaParticleHadronCorrelation : public AliAnaPartCorrBaseClass {
   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 * fhDeltaPhiUeChargedPt  ;  //! Difference of charged particle from underlying events phi and trigger particle  phi as function of charged particle pT
 
   TH2F * fhPtImbalanceNeutral  ; //! Trigger particle - neutral hadron momentum imbalance histogram 
   TH2F * fhPtImbalanceCharged  ; //! Trigger particle -charged hadron momentim imbalance histogram
-  
+  TH2F * fhPtImbalanceUeCharged  ; //! Trigger particle -underlying charged hadron momentim imbalance histogram  
+
+//if several UE calculation is on, most useful for jet-jet events contribution
+  TH2F * fhDeltaPhiUeLeft  ;  //! Difference of charged particle from underlying events phi and trigger particle  phi as function of charged particle pT
+  TH2F * fhDeltaPhiUeRight  ;  //! Difference of charged particle from underlying events phi and trigger particle  phi as function of charged particle pT
+  TH2F * fhPtImbalanceUeLeftCharged  ; //! Trigger particle -underlying charged hadron momentim imbalance histogram 
+  TH2F * fhPtImbalanceUeRightCharged  ; //! Trigger particle -underlying charged hadron momentim imbalance histogram  
+
   ClassDef(AliAnaParticleHadronCorrelation,1)
 } ;
  
index 2ce67a4..6ebf5e4 100755 (executable)
@@ -63,12 +63,16 @@ ClassImp(AliAnaParticleJetLeadingConeCorrelation)
     fSelectIsolated(0),        
     //Histograms
     fOutCont(0x0),
+    //Leading
     fhChargedLeadingPt(0),fhChargedLeadingPhi(0),fhChargedLeadingEta(0),
     fhChargedLeadingDeltaPt(0),fhChargedLeadingDeltaPhi(0),fhChargedLeadingDeltaEta(0),
     fhChargedLeadingRatioPt(0),
     fhNeutralLeadingPt(0),fhNeutralLeadingPhi(0),fhNeutralLeadingEta(0),
     fhNeutralLeadingDeltaPt(0),fhNeutralLeadingDeltaPhi(0),fhNeutralLeadingDeltaEta(0),
     fhNeutralLeadingRatioPt(0),fhChargedLeadingXi(0), fhNeutralLeadingXi(0),
+       fhChargedLeadingDeltaPhiRatioPt30(0), fhNeutralLeadingDeltaPhiRatioPt30(0),
+       fhChargedLeadingDeltaPhiRatioPt50(0), fhNeutralLeadingDeltaPhiRatioPt50(0),
+    //Jet
     fhJetPt(0),fhJetRatioPt(0),fhJetDeltaPhi(0), fhJetDeltaEta(0),
     fhJetLeadingRatioPt(0),fhJetLeadingDeltaPhi(0),fhJetLeadingDeltaEta(0),
     fhJetFFz(0),fhJetFFxi(0),fhJetFFpt(0),fhJetNTracksInCone(0),
@@ -153,6 +157,7 @@ AliAnaParticleJetLeadingConeCorrelation::AliAnaParticleJetLeadingConeCorrelation
   fSelectIsolated(jetlc.fSelectIsolated),    
   //Histograms
   fOutCont(jetlc. fOutCont),
+  //Leading
   fhChargedLeadingPt(jetlc.fhChargedLeadingPt), fhChargedLeadingPhi(jetlc.fhChargedLeadingPhi),
   fhChargedLeadingEta(jetlc.fhChargedLeadingEta), fhChargedLeadingDeltaPt(jetlc.fhChargedLeadingDeltaPt),
   fhChargedLeadingDeltaPhi(jetlc.fhChargedLeadingDeltaPhi),fhChargedLeadingDeltaEta(jetlc.fhChargedLeadingDeltaEta),
@@ -162,6 +167,9 @@ AliAnaParticleJetLeadingConeCorrelation::AliAnaParticleJetLeadingConeCorrelation
   fhNeutralLeadingDeltaPhi(jetlc.fhNeutralLeadingDeltaPhi),fhNeutralLeadingDeltaEta(jetlc.fhNeutralLeadingDeltaEta),
   fhNeutralLeadingRatioPt(jetlc.fhNeutralLeadingRatioPt),
   fhChargedLeadingXi(jetlc.fhChargedLeadingXi), fhNeutralLeadingXi(jetlc.fhNeutralLeadingXi),
+  fhChargedLeadingDeltaPhiRatioPt30(jetlc.fhChargedLeadingDeltaPhiRatioPt30), fhNeutralLeadingDeltaPhiRatioPt30(jetlc.fhNeutralLeadingDeltaPhiRatioPt30),
+  fhChargedLeadingDeltaPhiRatioPt50(jetlc.fhChargedLeadingDeltaPhiRatioPt50), fhNeutralLeadingDeltaPhiRatioPt50(jetlc.fhNeutralLeadingDeltaPhiRatioPt50),
+  //Jet
   fhJetPt(jetlc.fhJetPt),fhJetRatioPt(jetlc.fhJetRatioPt),fhJetDeltaPhi(jetlc.fhJetDeltaPhi), 
   fhJetDeltaEta(jetlc.fhJetDeltaEta), fhJetLeadingRatioPt(jetlc.fhJetLeadingRatioPt),
   fhJetLeadingDeltaPhi(jetlc.fhJetLeadingDeltaPhi),fhJetLeadingDeltaEta(jetlc.fhJetLeadingDeltaEta),
@@ -289,6 +297,10 @@ AliAnaParticleJetLeadingConeCorrelation & AliAnaParticleJetLeadingConeCorrelatio
   fhChargedLeadingXi = jetlc.fhChargedLeadingXi; 
   fhNeutralLeadingXi = jetlc.fhNeutralLeadingXi;
 
+  fhChargedLeadingDeltaPhiRatioPt30 = jetlc.fhChargedLeadingDeltaPhiRatioPt30; 
+  fhNeutralLeadingDeltaPhiRatioPt30 = jetlc.fhNeutralLeadingDeltaPhiRatioPt30;
+  fhChargedLeadingDeltaPhiRatioPt50 = jetlc.fhChargedLeadingDeltaPhiRatioPt50; 
+  fhNeutralLeadingDeltaPhiRatioPt50 = jetlc.fhNeutralLeadingDeltaPhiRatioPt50; 
        
   fhJetPt = jetlc.fhJetPt;fhJetRatioPt = jetlc.fhJetRatioPt;fhJetDeltaPhi = jetlc.fhJetDeltaPhi; 
   fhJetDeltaEta = jetlc.fhJetDeltaEta; fhJetLeadingRatioPt = jetlc.fhJetLeadingRatioPt;
@@ -514,6 +526,17 @@ TList *  AliAnaParticleJetLeadingConeCorrelation::GetCreateOutputObjects()
   fOutCont->Add(fhChargedLeadingRatioPt) ;
   fOutCont->Add(fhChargedLeadingXi) ;
        
+  fhChargedLeadingDeltaPhiRatioPt30  = new TH2F("ChargedLeadingDeltaPhiRatioPt30","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T leading}/p_{T trigger}, charged leading, p_{T trigger} > 30 GeV/c",120,0,TMath::TwoPi(),nptbins,0,1); 
+  fhChargedLeadingDeltaPhiRatioPt30->SetXTitle("#Delta #phi (rad)");
+  fhChargedLeadingDeltaPhiRatioPt30->SetYTitle("p_{T leading} / p_{T trigger}");       
+       
+  fhChargedLeadingDeltaPhiRatioPt50  = new TH2F("ChargedLeadingDeltaPhiRatioPt50","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T leading}/p_{T trigger}, charged leading, p_{T trigger} > 50 GeV/c",120,0,TMath::TwoPi(),nptbins,0,1); 
+  fhChargedLeadingDeltaPhiRatioPt50->SetXTitle("#Delta #phi (rad)");
+  fhChargedLeadingDeltaPhiRatioPt50->SetYTitle("p_{T leading} / p_{T trigger}");         
+       
+  fOutCont->Add(fhChargedLeadingDeltaPhiRatioPt30) ; 
+  fOutCont->Add(fhChargedLeadingDeltaPhiRatioPt50) ; 
+       
   if(!fJetsOnlyInCTS){
     
     fhNeutralLeadingPt  = new TH2F("NeutralLeadingPt","p_{T leading #pi^{0}} vs p_{T trigger}",nptbins,ptmin,ptmax,nptbins,ptmin,ptmax); 
@@ -556,6 +579,17 @@ TList *  AliAnaParticleJetLeadingConeCorrelation::GetCreateOutputObjects()
     fOutCont->Add(fhNeutralLeadingDeltaEta) ; 
     fOutCont->Add(fhNeutralLeadingRatioPt) ;
     fOutCont->Add(fhNeutralLeadingXi) ;
+         
+       fhNeutralLeadingDeltaPhiRatioPt30  = new TH2F("NeutralLeadingDeltaPhiRatioPt30","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T leading}/p_{T trigger}, neutral leading, p_{T trigger} > 30 GeV/c",120,0,TMath::TwoPi(),nptbins,0,1); 
+       fhNeutralLeadingDeltaPhiRatioPt30->SetXTitle("#Delta #phi (rad)");
+       fhNeutralLeadingDeltaPhiRatioPt30->SetYTitle("p_{T leading} / p_{T trigger}");
+         
+       fhNeutralLeadingDeltaPhiRatioPt50  = new TH2F("NeutralLeadingDeltaPhiRatioPt50","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T leading}/p_{T trigger}, neutral leading, p_{T trigger} > 50 GeV/c",120,0,TMath::TwoPi(),nptbins,0,1); 
+       fhNeutralLeadingDeltaPhiRatioPt50->SetXTitle("#Delta #phi (rad)");
+       fhNeutralLeadingDeltaPhiRatioPt50->SetYTitle("p_{T leading} / p_{T trigger}");
+       fOutCont->Add(fhNeutralLeadingDeltaPhiRatioPt30) ; 
+       fOutCont->Add(fhNeutralLeadingDeltaPhiRatioPt50) ; 
+
   }
   
   if(!fSeveralConeAndPtCuts){// not several cones
@@ -1322,6 +1356,8 @@ void  AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillHistograms()
        fhChargedLeadingDeltaEta->Fill(pt,eta-etaL);
        fhChargedLeadingRatioPt->Fill(pt,ptL/pt);
        fhChargedLeadingXi->Fill(pt,TMath::Log(pt/ptL));
+       if(pt > 30) fhChargedLeadingDeltaPhiRatioPt30->Fill(TMath::Abs(phi-phiL),ptL/pt);
+       if(pt > 50) fhChargedLeadingDeltaPhiRatioPt50->Fill(TMath::Abs(phi-phiL),ptL/pt);
       }
       else if(det== "EMCAL"){
        fhNeutralLeadingPt->Fill(pt,ptL);
@@ -1332,6 +1368,9 @@ void  AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillHistograms()
        fhNeutralLeadingDeltaEta->Fill(pt,eta-etaL);
        fhNeutralLeadingRatioPt->Fill(pt,ptL/pt);
        fhNeutralLeadingXi->Fill(pt,TMath::Log(pt/ptL));
+       if(pt > 30) fhNeutralLeadingDeltaPhiRatioPt30->Fill(TMath::Abs(phi-phiL),ptL/pt);
+       if(pt > 50) fhNeutralLeadingDeltaPhiRatioPt50->Fill(TMath::Abs(phi-phiL),ptL/pt);
+
       }
       
       //Fill Jet histograms
index 722a50a..3a27ad0 100755 (executable)
@@ -192,7 +192,11 @@ public:
        
   TH2F * fhChargedLeadingXi  ;   //! Ln (pt leading charge / pt trigger)
   TH2F * fhNeutralLeadingXi  ;   //! Ln (pt leading neutral / pt trigger)
-
+       
+  TH2F * fhChargedLeadingDeltaPhiRatioPt30  ;  //! Difference of charged hadron and trigger  phi as function of pT leading / trigger pT, pT Trigger > 30 GeV
+  TH2F * fhNeutralLeadingDeltaPhiRatioPt30  ;  //! Difference of neutral hadron and trigger  phi as function of pT leading / trigger pT, pT Trigger > 30 GeV
+  TH2F * fhChargedLeadingDeltaPhiRatioPt50  ;  //! Difference of charged hadron and trigger  phi as function of pT leading / trigger pT, pT Trigger > 50 GeV
+  TH2F * fhNeutralLeadingDeltaPhiRatioPt50  ;  //! Difference of neutral hadron and trigger  phi as function of pT leading / trigger pT, pT Trigger > 50 GeV
        
   // Jet distributions
   // Fixed cone and pt threshold