Corrected memory leaks and go back to old vertex selection
authorkleinb <kleinb@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 24 Jun 2010 05:47:10 +0000 (05:47 +0000)
committerkleinb <kleinb@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 24 Jun 2010 05:47:10 +0000 (05:47 +0000)
PWG4/JetTasks/AliAnalyseUE.cxx
PWG4/JetTasks/AliAnalyseUE.h
PWG4/JetTasks/AliAnalysisTaskUE.cxx
PWG4/JetTasks/AliAnalysisTaskUE.h
PWG4/JetTasks/AliHistogramsUE.cxx
PWG4/JetTasks/AliHistogramsUE.h

index 0f22f20..2e6d243 100644 (file)
@@ -396,28 +396,6 @@ Bool_t AliAnalyseUE::AnaTypeSelection(TVector3 *jetVect ){
 }
 
 
-//-------------------------------------------------------------------
-TList* AliAnalyseUE::CreateHistograms(Int_t bins, Double_t min, Double_t max){
-  
-  //Initialize histograms from class AliHistogramsUE
-  fHistos = new AliHistogramsUE();
-  TList* list = new TList();
-  list = fHistos->CreateHistos(bins, min, max, fTrackEtaCut);
-
-
-  return list;
-}
-
-
-
-//-------------------------------------------------------------------
-void AliAnalyseUE::FillLeadingJet( Double_t  w){
-
- fHistos->FillHistogram("hEleadingPt",w);
-
-}
-
-
 //-------------------------------------------------------------------
 void AliAnalyseUE::FillRegions(Bool_t isNorm2Area,  TVector3 *jetVect){
   
@@ -500,27 +478,6 @@ void AliAnalyseUE::FillRegions(Bool_t isNorm2Area,  TVector3 *jetVect){
   fHistos->FillHistogram("hRegBackwardSumPtvsMult", maxPtJet1, fNTrackRegionBackward,fSumPtRegionBackward/normArea);
 }
 
-//-------------------------------------------------------------------
-void AliAnalyseUE::FillTrials(const char *namex, Double_t  w){
-
- fHistos->GetTrials()->Fill(namex,w);
-
-}
-
-//-------------------------------------------------------------------
-void AliAnalyseUE::FillVertex(Double_t  w){
-
- fHistos->FillHistogram("hVertexMult",w);
-
-}
-
-//-------------------------------------------------------------------
-void AliAnalyseUE::FillXsec(const char *namex, Double_t  w){
-
- fHistos->GetXsec()->Fill(namex,w);
-
-}
-
 
 //-------------------------------------------------------------------
 void AliAnalyseUE::FindMaxMinRegions(TVector3 *jetVect, Int_t conePosition){
@@ -590,17 +547,6 @@ void AliAnalyseUE::FindMaxMinRegions(TVector3 *jetVect, Int_t conePosition){
 
 }
 
-
-//-------------------------------------------------------------------
-TList* AliAnalyseUE::GetHistograms(){
-
-  TList *list = fHistos->GetListOfHistos();
-
-  return list;
-
-}
-
-
 //-------------------------------------------------------------------
 TVector3 AliAnalyseUE::GetOrderedClusters(TString aodBranch, Bool_t chargedJets, Double_t chJetPtMin){ 
 
@@ -667,7 +613,6 @@ TVector3 AliAnalyseUE::GetOrderedClusters(TString aodBranch, Bool_t chargedJets,
 
   // 2) ON-THE-FLY CDF ALGORITHM
   if (chargedJets){ 
-    // Printf(" ==== Run CDF algorithm on the fly  !");
        arrayJets = FindChargedParticleJets(chJetPtMin);
         if( arrayJets ) {
                nJets = arrayJets->GetEntriesFast();
@@ -712,8 +657,7 @@ TVector3 AliAnalyseUE::GetOrderedClusters(TString aodBranch, Bool_t chargedJets,
                }
 
        }
-  //fHistos->FillHistoNJets(nJets);
-  if (fHistos ) fHistos->FillHistogram("hNJets",nJets);
+  fHistos->FillHistogram("hNJets",nJets);
    
   return *jetVect;
 
@@ -738,78 +682,15 @@ void AliAnalyseUE::Initialize(AliAnalysisTaskUE& taskUE){
   fSimulateChJetPt = taskUE.GetSimulateChJetPt();
   fTrackEtaCut = taskUE.GetTrackEtaCut(); 
   fTrackPtCut = taskUE.GetTrackPtCut();
+  fHistos = taskUE.fHistosUE;
   fUseChargeHadrons = taskUE.GetUseChargeHadrons();
   fUseChPartJet = taskUE.GetUseChPartJet();
   fUsePositiveCharge = taskUE.GetUseNegativeChargeType();
   fUseSingleCharge = taskUE.GetUseSingleCharge();
   
-  //Write settings to output list
-  fSettingsTree   = new TTree("UEAnalysisSettings","Analysis Settings in UE estimation");
-  fSettingsTree->Branch("fFilterBit", &fFilterBit,"FilterBit/I");
-  fSettingsTree->Branch("fConeRadius", &fConeRadius,"Rad/D");
-  fSettingsTree->Branch("fJet1EtaCut", &fJet1EtaCut, "LeadJetEtaCut/D");
-  fSettingsTree->Branch("fJet2DeltaPhiCut", &fJet2DeltaPhiCut, "DeltaPhi/D");
-  fSettingsTree->Branch("fJet2RatioPtCut", &fJet2RatioPtCut, "Jet2Ratio/D");
-  fSettingsTree->Branch("fJet3PtCut", &fJet3PtCut, "Jet3PtCut/D");
-  fSettingsTree->Branch("fTrackPtCut", &fTrackPtCut, "TrackPtCut/D");
-  fSettingsTree->Branch("fTrackEtaCut", &fTrackEtaCut, "TrackEtaCut/D");
-  fSettingsTree->Branch("fAnaType", &fAnaType, "Ana/I");        
-  fSettingsTree->Branch("fRegionType", &fRegionType,"Reg/I");
-  fSettingsTree->Branch("fOrdering", &fOrdering,"OrderMeth/I");
-  fSettingsTree->Branch("fUseChPartJet", &fUseChPartJet,"UseChPart/O");
-  fSettingsTree->Branch("fUseChargeHadrons", &fUseChargeHadrons,"UseChHadrons/O");
-  fSettingsTree->Branch("fUseSingleCharge", &fUseSingleCharge,"UseSingleCh/O");
-  fSettingsTree->Branch("fUsePositiveCharge", &fUsePositiveCharge,"UsePositiveCh/O");
-  fSettingsTree->Fill();
-  (fHistos->GetListOfHistos())->Add(fSettingsTree);
 }
 
 //-------------------------------------------------------------------
-void AliAnalyseUE::Initialize(Int_t anaType,AliAODEvent* aod,Double_t coneRadius, Int_t debug, Int_t filterBit, Double_t jet1EtaCut, Double_t jet2DeltaPhiCut, Double_t jet2RatioPtCut, Double_t jet3PtCut, Int_t ordering, Int_t regionType,Bool_t simulateChJetPt, Double_t trackEtaCut, Double_t trackPtCut, Bool_t useChargeHadrons, Bool_t useChPartJet, Bool_t useNegativeChargeType, Bool_t useSingleCharge ){
-   
-  //Get principal settings from generic analysis-task
-  fAnaType = anaType;         
-  fkAOD = aod;           
-  fConeRadius = coneRadius;
-  fDebug = debug;
-  fFilterBit = filterBit;
-  fJet1EtaCut = jet1EtaCut;
-  fJet2DeltaPhiCut = jet2DeltaPhiCut;
-  fJet2RatioPtCut = jet2RatioPtCut;
-  fJet3PtCut = jet3PtCut;
-  fOrdering = ordering ;
-  fRegionType = regionType;
-  fSimulateChJetPt = simulateChJetPt;
-  fTrackEtaCut = trackEtaCut; 
-  fTrackPtCut = trackPtCut;
-  fUseChargeHadrons = useChargeHadrons;
-  fUseChPartJet = useChPartJet;
-  fUsePositiveCharge = useNegativeChargeType;
-  fUseSingleCharge = useSingleCharge;
-  
-  //Write settings to output list
-  fSettingsTree   = new TTree("UEAnalysisSettings","Analysis Settings in UE estimation");
-  fSettingsTree->Branch("fFilterBit", &fFilterBit,"FilterBit/I");
-  fSettingsTree->Branch("fConeRadius", &fConeRadius,"Rad/D");
-  fSettingsTree->Branch("fJet1EtaCut", &fJet1EtaCut, "LeadJetEtaCut/D");
-  fSettingsTree->Branch("fJet2DeltaPhiCut", &fJet2DeltaPhiCut, "DeltaPhi/D");
-  fSettingsTree->Branch("fJet2RatioPtCut", &fJet2RatioPtCut, "Jet2Ratio/D");
-  fSettingsTree->Branch("fJet3PtCut", &fJet3PtCut, "Jet3PtCut/D");
-  fSettingsTree->Branch("fTrackPtCut", &fTrackPtCut, "TrackPtCut/D");
-  fSettingsTree->Branch("fTrackEtaCut", &fTrackEtaCut, "TrackEtaCut/D");
-  fSettingsTree->Branch("fAnaType", &fAnaType, "Ana/I");        
-  fSettingsTree->Branch("fRegionType", &fRegionType,"Reg/I");
-  fSettingsTree->Branch("fOrdering", &fOrdering,"OrderMeth/I");
-  fSettingsTree->Branch("fUseChPartJet", &fUseChPartJet,"UseChPart/O");
-  fSettingsTree->Branch("fUseChargeHadrons", &fUseChargeHadrons,"UseChHadrons/O");
-  fSettingsTree->Branch("fUseSingleCharge", &fUseSingleCharge,"UseSingleCh/O");
-  fSettingsTree->Branch("fUsePositiveCharge", &fUsePositiveCharge,"UsePositiveCh/O");
-  fSettingsTree->Fill();
-  (fHistos->GetListOfHistos())->Add(fSettingsTree);
-}
-
 Bool_t  AliAnalyseUE::VertexSelection(AliAODEvent *aod, Int_t tracks, Double_t zed ){
 
   //Require 1 vertex (no TPC stand-alone) with a minimum number of tracks and z-coordinate in a limited range
@@ -833,6 +714,21 @@ Bool_t  AliAnalyseUE::VertexSelection(AliAODEvent *aod, Int_t tracks, Double_t z
   return kTRUE;
 }
 
+//-------------------------------------------------------------------
+Bool_t  AliAnalyseUE::VertexSelectionOld(AliAODEvent *aod ){
+
+  AliKFVertex primVtx(*(aod->GetPrimaryVertex()));
+  Int_t nTracksPrim=primVtx.GetNContributors();
+    if (fDebug > 1) AliInfo(Form(" Primary-vertex Selection: %d",nTracksPrim));
+    if(!nTracksPrim){
+       if (fDebug > 1) AliInfo(" Primary-vertex Selection: event REJECTED ...");
+       return kFALSE;
+       }
+    if (fDebug > 1) AliInfo(" Primary-vertex Selection: event ACCEPTED ...");
+
+  return kTRUE;
+}
+
 // PRIVATE METHODS **************************************************
 
 TObjArray*  AliAnalyseUE::FindChargedParticleJets( Double_t chJetPtMin )
@@ -1193,13 +1089,3 @@ const Bool_t AliAnalyseUE::TrackSelected(AliAODTrack* part){
 }
 
 
-//____________________________________________________________________
-void AliAnalyseUE::WriteSettings(){
-
-  // Print analysis settings
-  if (fDebug>5){
-       AliInfo("All Analysis Settings in Saved Tree");
-       fSettingsTree->Scan();
-       }
-
-}
index c1f6a70..fd6ddb5 100644 (file)
 // --- ROOT system ---
 #include <TObject.h> 
 
-#if __GNUC__ >= 3
-using namespace std;
-#endif
-
 class AliAnalysisTaskUE;
 class AliAODEvent;
 class AliAODTrack;
@@ -36,30 +32,19 @@ class AliAnalyseUE : public TObject {
 
   void                 AnalyseMC(TVector3 *jetVect, AliMCEvent *mcEvent, AliGenPythiaEventHeader  *pythiaGenHeader, Int_t conePosition, Bool_t useAliStack, Bool_t constrainDistance, Double_t minDistance);
   Bool_t       AnaTypeSelection(TVector3 *jetVect);
-
-  TList*       CreateHistograms(Int_t bins, Double_t min, Double_t max);
-
-  void          FillLeadingJet( Double_t  w);
  
   void          FillRegions(Bool_t isNorm2Area, TVector3 *jetVect);
 
-  void          FillTrials(const char *namex, Double_t  w);
-  
-  void          FillVertex(Double_t  w);
-  
-  void          FillXsec(const char *namex, Double_t  w);
-
   void                 FindMaxMinRegions(TVector3 *jetVect, Int_t conePosition);
   
-  TList*        GetHistograms();
-  
   TVector3     GetOrderedClusters(TString aodBranch, Bool_t chargedJets, Double_t chJetPtMin);
 
   void          Initialize(AliAnalysisTaskUE& tmp);
-  void          Initialize(Int_t anaType, AliAODEvent* aod,Double_t coneRadius, Int_t debug, Int_t filterBit, Double_t 
-  jet1EtaCut, Double_t jet2DeltaPhiCut, Double_t jet2RatioPtCut, Double_t jet3PtCut, Int_t ordering, Int_t regionType,Bool_t simulateChJetPt, Double_t trackEtaCut, Double_t trackPtCut, Bool_t useChargeHadrons, Bool_t useChPartJet, Bool_t usePositiveCharge, Bool_t useSingleCharge);
 
   Bool_t        VertexSelection(AliAODEvent *value, Int_t tracks, Double_t zed);
+
+  Bool_t        VertexSelectionOld(AliAODEvent *value);
+
   void         WriteSettings();
 
   // Various setters when you do not want to initialize members from AliAnalysisTaskUE
@@ -145,6 +130,6 @@ class AliAnalyseUE : public TObject {
     //Store analysis settings
     TTree*       fSettingsTree;        // To store analysis settings
     
-    ClassDef(AliAnalyseUE,1)
+    ClassDef(AliAnalyseUE,0)
 };
 #endif
index 5e07c4b..a469338 100644 (file)
 #include <TFile.h>
 #include <TList.h>
 #include <TMath.h>
+#include <TProfile.h>
 #include <TTree.h>
 #include <TVector3.h>
 #include <TH1F.h>
 
 #include "AliAnalyseUE.h"
+#include "AliHistogramsUE.h"
 #include "AliAnalysisTaskUE.h"
 #include "AliHistogramsUE.h"
 
@@ -43,6 +45,7 @@
 #include "AliLog.h"
 #include "AliInputEventHandler.h"
 
+
 ////////////////////////////////////////////////////////////////////////
 //
 // Analysis class for Underlying Event studies
 //
 //    Arian.Abrahantes.Quintana@cern.ch 
 //    Ernesto.Lopez.Torres@cern.ch
+//    vallero@physi.uni-heidelberg.de
 // 
 ////////////////////////////////////////////////////////////////////////
 
-
 ClassImp( AliAnalysisTaskUE)
 
 // Define global pointer
@@ -74,11 +77,13 @@ AliAnalysisTaskUE* AliAnalysisTaskUE::fgTaskUE=NULL;
 //____________________________________________________________________
 AliAnalysisTaskUE:: AliAnalysisTaskUE(const char* name):
 AliAnalysisTask(name,""),
+fHistosUE(0x0),
 fAnaUE(0x0),
 fAOD(0x0),            
 fAODBranch("jets"),
 fDebug(0),
-fListOfHistos(0x0),  
+fListOfHistos(0x0), 
+//Configuration
 fBinsPtInHist(30),     
 fIsNorm2Area(kTRUE),
 fMaxJetPtInHist(300.), 
@@ -108,7 +113,44 @@ fJet2RatioPtCut(0.8),
 fJet3PtCut(15.),
 fTrackEtaCut(0.9),
 fTrackPtCut(0.),
+//For MC
 fAvgTrials(1)
+/*//Histograms
+fhNJets(0x0),
+fhEleadingPt(0x0),
+fhMinRegPtDist(0x0),
+fhRegionMultMin(0x0),
+fhMinRegAvePt(0x0),
+fhMinRegSumPt(0x0),
+fhMinRegMaxPtPart(0x0),
+fhMinRegSumPtvsMult(0x0),
+fhdNdEtaPhiDist(0x0),
+fhFullRegPartPtDistVsEt(0x0),
+fhTransRegPartPtDistVsEt(0x0),
+fhRegionSumPtMaxVsEt(0x0),
+fhRegionMultMax(0x0),
+fhRegionMultMaxVsEt(0x0),
+fhRegionSumPtMinVsEt(0x0),
+fhRegionMultMinVsEt(0x0),
+fhRegionAveSumPtVsEt(0x0),
+fhRegionDiffSumPtVsEt(0x0),
+fhRegionAvePartPtMaxVsEt(0x0),
+fhRegionAvePartPtMinVsEt(0x0),
+fhRegionMaxPartPtMaxVsEt(0x0),    
+fhRegForwardMult(0x0),
+fhRegForwardSumPtvsMult(0x0),
+fhRegBackwardMult(0x0),
+fhRegBackwardSumPtvsMult(0x0),
+fhRegForwardPartPtDistVsEt(0x0),
+fhRegBackwardPartPtDistVsEt(0x0),
+fhRegTransMult(0x0),
+fhRegTransSumPtVsMult(0x0),
+fhMinRegSumPtJetPtBin(0x0),
+fhMaxRegSumPtJetPtBin(0x0),
+fhVertexMult(0x0),
+fh1Xsec(0x0),  
+fh1Trials(0x0)
+*/
 {
   // Default constructor
   // Define input and output slots here
@@ -122,11 +164,13 @@ fAvgTrials(1)
 //____________________________________________________________________
 AliAnalysisTaskUE:: AliAnalysisTaskUE(const AliAnalysisTaskUE & original):
 AliAnalysisTask(),
+fHistosUE(original.fHistosUE),
 fAnaUE(original.fAnaUE),
 fAOD(original.fAOD),            
 fAODBranch(original.fAODBranch),
 fDebug(original.fDebug),
 fListOfHistos(original.fListOfHistos),  
+//Configuration
 fBinsPtInHist(original.fBinsPtInHist),     
 fIsNorm2Area(original.fIsNorm2Area),
 fMaxJetPtInHist(original.fMaxJetPtInHist), 
@@ -156,7 +200,44 @@ fJet2RatioPtCut(original.fJet2RatioPtCut),
 fJet3PtCut(original.fJet3PtCut),
 fTrackEtaCut(original.fTrackEtaCut),
 fTrackPtCut(original.fTrackPtCut),
+//For MC
 fAvgTrials(original.fAvgTrials)
+/*//Histograms
+fhNJets(original.fhNJets),
+fhEleadingPt(original.fhEleadingPt),
+fhMinRegPtDist(original.fhMinRegPtDist),
+fhRegionMultMin(original.fhRegionMultMin),
+fhMinRegAvePt(original.fhMinRegAvePt),
+fhMinRegSumPt(original.fhMinRegSumPt),
+fhMinRegMaxPtPart(original.fhMinRegMaxPtPart),
+fhMinRegSumPtvsMult(original.fhMinRegSumPtvsMult),
+fhdNdEtaPhiDist(original.fhdNdEtaPhiDist),
+fhFullRegPartPtDistVsEt(original.fhFullRegPartPtDistVsEt),
+fhTransRegPartPtDistVsEt(original.fhTransRegPartPtDistVsEt),
+fhRegionSumPtMaxVsEt(original.fhRegionSumPtMaxVsEt),
+fhRegionMultMax(original.fhRegionMultMax),
+fhRegionMultMaxVsEt(original.fhRegionMultMaxVsEt),
+fhRegionSumPtMinVsEt(original.fhRegionSumPtMinVsEt),
+fhRegionMultMinVsEt(original.fhRegionMultMinVsEt),
+fhRegionAveSumPtVsEt(original.fhRegionAveSumPtVsEt),
+fhRegionDiffSumPtVsEt(original.fhRegionDiffSumPtVsEt),
+fhRegionAvePartPtMaxVsEt(original.fhRegionAvePartPtMaxVsEt),
+fhRegionAvePartPtMinVsEt(original.fhRegionAvePartPtMinVsEt),
+fhRegionMaxPartPtMaxVsEt(original.fhRegionMaxPartPtMaxVsEt),
+fhRegForwardMult(original.fhRegForwardMult),
+fhRegForwardSumPtvsMult(original.fhRegForwardSumPtvsMult),
+fhRegBackwardMult(original.fhRegBackwardMult),
+fhRegBackwardSumPtvsMult(original.fhRegBackwardSumPtvsMult),
+fhRegForwardPartPtDistVsEt(original.fhRegForwardPartPtDistVsEt),
+fhRegBackwardPartPtDistVsEt(original.fhRegBackwardPartPtDistVsEt),
+fhRegTransMult(original.fhRegTransMult),
+fhRegTransSumPtVsMult(original.fhRegTransSumPtVsMult),
+fhMinRegSumPtJetPtBin(original.fhMinRegSumPtJetPtBin),
+fhMaxRegSumPtJetPtBin(original.fhMaxRegSumPtJetPtBin),
+fhVertexMult(original.fhVertexMult),
+fh1Xsec(original.fh1Xsec),     
+fh1Trials(original.fh1Trials)
+*/
 {
   // Copy constructor
 }
@@ -189,7 +270,7 @@ Bool_t AliAnalysisTaskUE::Notify()
        
        AliAnalysisHelperJetTasks::PythiaInfoFromFile(curfile->GetName(),xsection,trials); 
         
-       fAnaUE->FillXsec("<#sigma>",xsection);
+        fHistosUE->GetXsec()->Fill("<#sigma>",xsection);
 
        // construct average trials
        Float_t nEntries = (Float_t)tree->GetTree()->GetEntries();
@@ -221,7 +302,7 @@ void AliAnalysisTaskUE::ConnectInputData(Option_t* /*option*/)
        if(!fJetsOnFly){
                if (fDebug > 1) AliInfo(" ==== Tracks and Jets from AliAODInputHandler");
                }else{
-               AliInfo(" ==== Tracks from AliAODInputHandler / Jets on-the-fly");
+               if (fDebug > 1) AliInfo(" ==== Tracks from AliAODInputHandler / Jets on-the-fly");
                }
        } else {  //output AOD
        handler = AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler();
@@ -239,6 +320,7 @@ void AliAnalysisTaskUE::ConnectInputData(Option_t* /*option*/)
        }       
 
    fAnaUE->Initialize( *this );
+   
 }
 
 //____________________________________________________________________
@@ -250,13 +332,22 @@ void  AliAnalysisTaskUE::CreateOutputObjects()
    
   //Initialize AliAnalysisUE, a class implementing the main analysis algorithms
   fAnaUE = new AliAnalyseUE();
+  fHistosUE = new AliHistogramsUE();
+  if (fListOfHistos != NULL){
+       delete fListOfHistos;
+        fListOfHistos = NULL;
+       }
+  if (!fListOfHistos){
+       fListOfHistos = new TList();
+       fListOfHistos->SetOwner(kTRUE); 
+       }
   
   //Initialize output histograms
-  fAnaUE->CreateHistograms(fBinsPtInHist, fMinJetPtInHist, fMaxJetPtInHist);
-  fListOfHistos = (TList*)fAnaUE->GetHistograms()->Clone();
-  fListOfHistos->SetOwner(kTRUE); 
-  PostData(0,fListOfHistos);
+  fHistosUE->CreateHistograms(fListOfHistos,fBinsPtInHist, fMinJetPtInHist, fMaxJetPtInHist, fTrackEtaCut);
+  AddSettingsTree();
 
+  PostData(0,fListOfHistos);
 }
 
 //____________________________________________________________________
@@ -275,7 +366,8 @@ void  AliAnalysisTaskUE::Exec(Option_t */*option*/)
         }                                
   // Event selection (vertex) *****************************************
    
-  if(!fAnaUE->VertexSelection(fAOD,fnTracksVertex,fZVertex)) return;
+  //if(!fAnaUE->VertexSelection(fAOD,fnTracksVertex,fZVertex)) return;
+  if(!fAnaUE->VertexSelectionOld(fAOD)) return; // temporary to compare with old task and to have same cuts for MC !!!
   
   // Execute analysis for current event ******************************
   
@@ -293,14 +385,38 @@ void  AliAnalysisTaskUE::Exec(Option_t */*option*/)
                        }
                }
        }
-  fAnaUE->FillTrials("#sum{ntrials}",fAvgTrials);
+  fHistosUE->GetTrials()->Fill("#sum{ntrials}",fAvgTrials);
   
   //analyse the event
   AnalyseUE();
-  fListOfHistos = (TList*)fAnaUE->GetHistograms()->Clone();
 PostData(0,fListOfHistos);
+ PostData(0,fListOfHistos);
 }
 
+//____________________________________________________________________
+void  AliAnalysisTaskUE::AddSettingsTree()
+{
+  //Write settings to output list
+  TTree *settingsTree   = new TTree("UEAnalysisSettings","Analysis Settings in UE estimation");
+  settingsTree->Branch("fFilterBit", &fFilterBit,"FilterBit/I");
+  settingsTree->Branch("fConeRadius", &fConeRadius,"Rad/D");
+  settingsTree->Branch("fJet1EtaCut", &fJet1EtaCut, "LeadJetEtaCut/D");
+  settingsTree->Branch("fJet2DeltaPhiCut", &fJet2DeltaPhiCut, "DeltaPhi/D");
+  settingsTree->Branch("fJet2RatioPtCut", &fJet2RatioPtCut, "Jet2Ratio/D");
+  settingsTree->Branch("fJet3PtCut", &fJet3PtCut, "Jet3PtCut/D");
+  settingsTree->Branch("fTrackPtCut", &fTrackPtCut, "TrackPtCut/D");
+  settingsTree->Branch("fTrackEtaCut", &fTrackEtaCut, "TrackEtaCut/D");
+  settingsTree->Branch("fAnaType", &fAnaType, "Ana/I");        
+  settingsTree->Branch("fRegionType", &fRegionType,"Reg/I");
+  settingsTree->Branch("fOrdering", &fOrdering,"OrderMeth/I");
+  settingsTree->Branch("fUseChPartJet", &fUseChPartJet,"UseChPart/O");
+  settingsTree->Branch("fUseChargeHadrons", &fUseChargeHadrons,"UseChHadrons/O");
+  settingsTree->Branch("fUseSingleCharge", &fUseSingleCharge,"UseSingleCh/O");
+  settingsTree->Branch("fUsePositiveCharge", &fUsePositiveCharge,"UsePositiveCh/O");
+  settingsTree->Fill();
+  fListOfHistos->Add(settingsTree);
+}  
+
 //____________________________________________________________________
 void  AliAnalysisTaskUE::AnalyseUE()
 {
@@ -308,7 +424,7 @@ void  AliAnalysisTaskUE::AnalyseUE()
   
    // Get jets and order by pT
    TVector3 jetVect[3];
-   *jetVect = fAnaUE->GetOrderedClusters(fAODBranch, fUseChPartJet, fChJetPtMin);
+   *jetVect = fAnaUE->GetOrderedClusters(fAODBranch, fUseChPartJet, fChJetPtMin );
   
    if( jetVect[0].Pt() < 0. ) {
        if( fDebug > 1 ) AliInfo("\n   Skipping Event, not jet found...");
@@ -324,10 +440,10 @@ void  AliAnalysisTaskUE::AnalyseUE()
   if (!fUseMCParticleBranch){
        // Primary vertex distribution
        AliAODVertex* vertex = (AliAODVertex*)fAOD->GetPrimaryVertex();
-       fAnaUE->FillVertex(vertex->GetNContributors());
+       fHistosUE->FillHistogram("hVertexMult",vertex->GetNContributors());
        
        // Fill leading "jet" histogram
-       fAnaUE->FillLeadingJet(jetVect[0].Pt());
+       fHistosUE->FillHistogram("hEleadingPt",jetVect[0].Pt());
 
        fAnaUE->FindMaxMinRegions( jetVect,  fConePosition );
 
@@ -376,6 +492,7 @@ AliAnalysisTaskUE* AliAnalysisTaskUE::Instance()
        }
 }
 
+
 //____________________________________________________________________
 void  AliAnalysisTaskUE::Terminate(Option_t */*option*/)
 {
@@ -406,6 +523,12 @@ void  AliAnalysisTaskUE::WriteSettings()
   //Print analysis settings on screen
   if (fDebug > 5){
     AliInfo(" All Analysis Settings in Saved Tree");
-    fAnaUE->WriteSettings();
-  }
+    fListOfHistos = dynamic_cast<TList*> (GetOutputData(0));
+    if (!fListOfHistos){
+       AliError("Histogram List is not available");
+       return;
+        }
+     TTree *tree = (TTree*)(fListOfHistos->FindObject("UEAnalysisSettings"));
+     tree->Scan();
+     }
 }
index 24cd64e..fab914d 100644 (file)
 //
 //    Arian.Abrahantes.Quintana@cern.ch 
 //    Ernesto.Lopez.Torres@cern.ch
+//    vallero@physi.uni-heidelberg.de
 // 
 ////////////////////////////////////////////////////////////////////////
 
 #include "AliAnalysisTask.h"
 
 class AliAnalyseUE;
+class AliHistogramsUE;
 class AliAODEvent;
-//class AliAODHandler;
 class AliAODInputHandler;
 class AliESDEvent;
-//class AliLog;
 class TH1F;
 class TH2F;
 class TH1I;
 class TProfile;
-//class TROOT;
 class TTree;
 class TVector3;
 
@@ -137,12 +136,14 @@ class  AliAnalysisTaskUE : public AliAnalysisTask
 
     virtual const Double_t   GetTrackEtaCut()           { return fTrackEtaCut; }
     virtual const Double_t   GetTrackPtCut()            { return fTrackPtCut; }
+    
 
+    AliHistogramsUE*    fHistosUE;        //! points to AliHistogramsUE class   
   protected:
   static AliAnalysisTaskUE*     fgTaskUE;        // Pointer to single instance
 
   private:
-    
+    void         AddSettingsTree();    
     void         AnalyseUE();
     void         FillAvePartPtRegion( Double_t leadingE, Double_t ptMax, Double_t ptMin );
     void         FillMultRegion( Double_t leadingE, Double_t nTrackPtmax, Double_t nTrackPtmin, Double_t ptMin );
@@ -154,108 +155,149 @@ class  AliAnalysisTaskUE : public AliAnalysisTask
     TObjArray*   SortChargedParticles();
     void         WriteSettings();
     
-    AliAnalyseUE*  fAnaUE;           //! points to AliAnalyseUE class
-    AliAODEvent*   fAOD;             //! AOD Event 
-    TString        fAODBranch;       //  Jet branch name from standard AOD
-    Int_t          fDebug;           //  Debug flag
-
-    TList*         fListOfHistos;    //  Output list of histograms
+    AliAnalyseUE*       fAnaUE;           //! points to AliAnalyseUE class
+    AliAODEvent*        fAOD;             //! AOD Event 
+    TString             fAODBranch;       //  Jet branch name from standard AOD
+    Int_t               fDebug;           //  Debug flag
+    TList*              fListOfHistos;    //  Output list of histograms
     
     // Config
-    Int_t          fBinsPtInHist;     //  # bins for Pt histos range
-    Bool_t         fIsNorm2Area;      // Apply Area Normalization to collected observables
-    Double_t       fMaxJetPtInHist;   //  max Jet Pt value for histo range
-    Double_t       fMinJetPtInHist;   //  min Jet Pt value for histo range
+    Int_t              fBinsPtInHist;     //  # bins for Pt histos range
+    Bool_t             fIsNorm2Area;      // Apply Area Normalization to collected observables
+    Double_t           fMaxJetPtInHist;   //  max Jet Pt value for histo range
+    Double_t           fMinJetPtInHist;   //  min Jet Pt value for histo range
     
     // For MC
-    Bool_t        fConstrainDistance;    // Constrain Distance between rec jet and pyth
-    Double_t       fMinDistance;          // Minimum distance between rec jet and pyth
-    Bool_t         fSimulateChJetPt;      // Naive simulation of charged jet Pt from original Jet in MC Header
-    Bool_t         fUseAliStack;          // Use AliSatck for particle info otherwise "mcparticles" branch in AOD
-    Bool_t         fUseMCParticleBranch;  // Run Over mcparticles branch in AOD
+    Bool_t             fConstrainDistance;    // Constrain Distance between rec jet and pyth
+    Double_t           fMinDistance;          // Minimum distance between rec jet and pyth
+    Bool_t             fSimulateChJetPt;      // Naive simulation of charged jet Pt from original Jet in MC Header
+    Bool_t             fUseAliStack;          // Use AliSatck for particle info otherwise "mcparticles" branch in AOD
+    Bool_t             fUseMCParticleBranch;  // Run Over mcparticles branch in AOD
     
     // Cuts Events type
-    Int_t          fnTracksVertex;        // QA tracks pointing to principal vertex (= 3 default) 
-    Double_t       fZVertex;              // Position of Vertex in Z direction
+    Int_t              fnTracksVertex;        // QA tracks pointing to principal vertex (= 3 default) 
+    Double_t           fZVertex;              // Position of Vertex in Z direction
     
     // Cuts UE analysis
-    Int_t          fAnaType;              // Analysis type on jet topology: 
-                                               //     1=inclusive  (default) 
-                                               //     2=back to back inclusive
-                                               //     3=back to back exclusive
-                                               //     4=Pt max (max Pt track in region)
-                                               //     5=gama jet (back to back) ???
-                                               //  Minimum bias
-                                               //     31 = Semi jet (charged leading particle jets)
-                                               //     32 = Random jetcone  ?
-                                               //     33 = Swiss chees   ?
+    Int_t              fAnaType;              // Analysis type on jet topology: 
+                                                 //     1=inclusive  (default) 
+                                                 //     2=back to back inclusive
+                                                 //     3=back to back exclusive
+                                                 //     4=Pt max (max Pt track in region)
+                                                 //     5=gama jet (back to back) ???
+                                                 //  Minimum bias
+                                                 //     31 = Semi jet (charged leading particle jets)
+                                                 //     32 = Random jetcone  ?
+                                                 //     33 = Swiss chees   ?
     
     
-    Int_t          fConePosition;         // This parameter set how will cone center in transversal zone will be set
-                                          //    1 : To be used in any jet topology (default value)
-                                          //        eta_cone = eta_leadingjet
-                                          //        phi_cone = phi_leadingjet + - 90
-                                          //    2 : To be used in multiple jet topology (code will cry otherwise)
-                                          //        eta_cone = (eta_leadingjet + eta_subleadingjet)/2
-                                          //        phi_cone = phi_leadingjet + - 90
+    Int_t              fConePosition;         // This parameter set how will cone center in transversal zone will be set
+                                                 //    1 : To be used in any jet topology (default value)
+                                                 //        eta_cone = eta_leadingjet
+                                                 //        phi_cone = phi_leadingjet + - 90
+                                                  //    2 : To be used in multiple jet topology (code will cry otherwise)
+                                                  //        eta_cone = (eta_leadingjet + eta_subleadingjet)/2
+                                                  //        phi_cone = phi_leadingjet + - 90
     
-    Double_t       fConeRadius;           // if selected Cone-like region type, set Radius (=0.7 default)
+    Double_t           fConeRadius;           // if selected Cone-like region type, set Radius (=0.7 default)
     
-    UInt_t         fFilterBit;            // Select tracks from an specific track cut (default 0xFF all track selected)
+    UInt_t             fFilterBit;            // Select tracks from an specific track cut (default 0xFF all track selected)
     
-    Bool_t         fJetsOnFly;            // if jets are reconstructed on the fly from AOD tracks (see ConnectInputData() )
+    Bool_t             fJetsOnFly;            // if jets are reconstructed on the fly from AOD tracks (see ConnectInputData() )
     
     // UE analysis is conducted in different type of regions
     // Transverse are those like defined in: R. Field Acta Physica Polonica B. Vol 36 No. 2 pg 167 (2005) 
     // Cone regions like defined in: Phys. Rev. D 70, 072002 (2004)
-    Int_t         fRegionType;           // 1 = transverse regions (default)
-                                          // 2 = cone regions   
+    Int_t              fRegionType;           // 1 = transverse regions (default)
+                                              // 2 = cone regions   
     
 
 
-    Bool_t         fUseChargeHadrons;     // Only use charge hadrons
-    Bool_t         fUseChPartJet;         // Use "Charged Particle Jet" instead of jets from AOD see FindChargedParticleJets()
+    Bool_t             fUseChargeHadrons;     // Only use charge hadrons
+    Bool_t             fUseChPartJet;         // Use "Charged Particle Jet" instead of jets from AOD see FindChargedParticleJets()
     
     // Theoreticians ask for tools charge-aware
     // especially those which are related to multiplicity and MC-tunings
     // see arXiv:hep-ph/0507008v3
-    Bool_t         fUsePositiveCharge;    //If Single type of charge used then set which one (=kTRUE default positive)
-    Bool_t         fUseSingleCharge;      //Make analysis for a single type of charge (=kFALSE default)
+    Bool_t             fUsePositiveCharge;    //If Single type of charge used then set which one (=kTRUE default positive)
+    Bool_t             fUseSingleCharge;      //Make analysis for a single type of charge (=kFALSE default)
     
-    Int_t          fOrdering;             //  Pt and multiplicity summation ordering:
-                   //     1=CDF-like -independent sorting according quantity to be scored: Double sorting- (default)
-                   //        if Pt summation will be scored take Pt minimum between both zones and 
-                   //        fill Pt Max. and Min. histog. accordingly
-                   //        if Multiplicity summation will be scored take Mult. minimum between both zones and 
-                   //        fill Mult Max and Min histog. accordingly
-                   //       Bib:
-                   //     2=Marchesini-like (Only Pt sorting: Single sorting)
-                   //        sort only according Pt summation scored, find minimum between both zones and
-                   //        fill Pt and Multiplicity Max and Min summation histog. following only this criterium
-                   //        Bib: Phys. Rev. D 38, 3419 (1988)
-                   //     3=Nameless pt per track single sorting
-                   //        sort according to pt per track scored in each transverse zone 
-                   //        lowest values indicates minimum zone.   
-                   //     4=User Selection sorting (NOTE: USER must implement it within cxx)
+    Int_t              fOrdering;             //  Pt and multiplicity summation ordering:
+                       //     1=CDF-like -independent sorting according quantity to be scored: Double sorting- (default)
+                       //        if Pt summation will be scored take Pt minimum between both zones and 
+                       //        fill Pt Max. and Min. histog. accordingly
+                       //        if Multiplicity summation will be scored take Mult. minimum between both zones and 
+                       //        fill Mult Max and Min histog. accordingly
+                       //       Bib:
+                       //     2=Marchesini-like (Only Pt sorting: Single sorting)
+                       //        sort only according Pt summation scored, find minimum between both zones and
+                       //        fill Pt and Multiplicity Max and Min summation histog. following only this criterium
+                       //        Bib: Phys. Rev. D 38, 3419 (1988)
+                       //     3=Nameless pt per track single sorting
+                       //        sort according to pt per track scored in each transverse zone 
+                       //        lowest values indicates minimum zone.   
+                       //     4=User Selection sorting (NOTE: USER must implement it within cxx)
    
     
     // Jet cuts 
-    Double_t      fChJetPtMin;       // Min Pt for charged Particle Jet
-    Double_t      fJet1EtaCut;       // |jet1 eta| < fJet1EtaCut   (fAnaType = 1,2,3)
-    Double_t      fJet2DeltaPhiCut;  // |Jet1.Phi - Jet2.Phi| < fJet2DeltaPhiCut (fAnaType = 2,3)
-    Double_t      fJet2RatioPtCut;   // Jet2.Pt/Jet1Pt > fJet2RatioPtCut  (fAnaType = 2,3)
-    Double_t      fJet3PtCut;        // Jet3.Pt < fJet3PtCut  (fAnaType = 3)
+    Double_t           fChJetPtMin;       // Min Pt for charged Particle Jet
+    Double_t           fJet1EtaCut;       // |jet1 eta| < fJet1EtaCut   (fAnaType = 1,2,3)
+    Double_t           fJet2DeltaPhiCut;  // |Jet1.Phi - Jet2.Phi| < fJet2DeltaPhiCut (fAnaType = 2,3)
+    Double_t           fJet2RatioPtCut;   // Jet2.Pt/Jet1Pt > fJet2RatioPtCut  (fAnaType = 2,3)
+    Double_t           fJet3PtCut;        // Jet3.Pt < fJet3PtCut  (fAnaType = 3)
 
     // track cuts
-    Double_t      fTrackEtaCut;      // Eta cut on tracks in the regions (fRegionType=1)
-    Double_t      fTrackPtCut;       // Pt cut of tracks in the regions
+    Double_t           fTrackEtaCut;      // Eta cut on tracks in the regions (fRegionType=1)
+    Double_t           fTrackPtCut;       // Pt cut of tracks in the regions
    
     // MC cross-section 
-    Double_t      fAvgTrials;        // average trials used to fill the fh1Trials histogram in case we do not have trials on a event by event basis
-    //TProfile*     fh1Xsec;           //!
-    //TH1F*         fh1Trials;         //!
+    Double_t           fAvgTrials;        // average trials used to fill the fh1Trials histogram in case we do not have trials on a event by event basis
+    
+    /*
+    // Histograms
+    TH1F*  fhNJets;                  //! number of reco. jets or leading particles
+    TH1F*  fhEleadingPt;             //! pT distribution of leading-jet (leading-particle)
+    
+    TH1F*  fhMinRegPtDist;           //! pT distribution in MIN region
+    TH1F*  fhRegionMultMin;          //! average pT in MIN region
+    TH1F*  fhMinRegAvePt;            //! sum pT in MIN region
+    TH1F*  fhMinRegSumPt;            //! maximum particle pT in MAX region
+    TH1F*  fhMinRegMaxPtPart;        //! sum pT vs. multiplicity in MIN region
+    TH1F*  fhMinRegSumPtvsMult;      //!
     
-    ClassDef( AliAnalysisTaskUE, 5); // Analysis task for Underlying Event analysis
+    TH2F*  fhdNdEtaPhiDist;          //! phi and eta correlation with leading-jet (leading particle)
+    TH2F*  fhFullRegPartPtDistVsEt;  //! particle pT distribution vs. transverse energy in FULL region
+    TH2F*  fhTransRegPartPtDistVsEt; //! particle pT distribution vs. transverse energy in TRANSVERSE (MIN+MAX) region 
+    
+    TH1F*  fhRegionSumPtMaxVsEt;     //! sum pT vs. transverse energy in MAX region
+    TH1I*  fhRegionMultMax;          //! multiplicity in MAX region 
+    TH1F*  fhRegionMultMaxVsEt;      //! multiplicity vs. transverse energy in MAX region
+    TH1F*  fhRegionSumPtMinVsEt;     //! sum pT vs. transverse energy in MIN region
+    TH1F*  fhRegionMultMinVsEt;      //! multiplicity vs. transverse energy in MIN region
+    TH1F*  fhRegionAveSumPtVsEt;     //! average sum pT in 2 regions
+    TH1F*  fhRegionDiffSumPtVsEt;    //! difference sum pT in 2 regions
+    
+    TH1F*  fhRegionAvePartPtMaxVsEt; //! average particle pT vs. transverse energy in MAX region
+    TH1F*  fhRegionAvePartPtMinVsEt; //! average particle pT vs. transverse energy in MIN region
+    TH1F*  fhRegionMaxPartPtMaxVsEt; //! maximum particle pT vs. transverse energy in MAX region
+    
+    TH2F*  fhRegForwardMult;         //! multiplicity in FORWARD region
+    TH2F*  fhRegForwardSumPtvsMult;  //! sum pT vs. multiplicity in FORWARD region
+    TH2F*  fhRegBackwardMult;        //! multiplicity in BACKWARD region
+    TH2F*  fhRegBackwardSumPtvsMult; //! sum pT vs. multiplicity in BACKWARD region
+    TH2F*  fhRegForwardPartPtDistVsEt; //! particle pT distribution vs. transverse energy in FORWARD region
+    TH2F*  fhRegBackwardPartPtDistVsEt; //! particle pT distribution vs. transverse energy in BACKWARD
+    TH2F*  fhRegTransMult;         //! multiplicity in TRANSVERSE (MIN+MAX) region
+    TH2F*  fhRegTransSumPtVsMult;    //! sum pT vs. multiplicity in TRANSVERSE (MIN+MAX) region
+    TH2F*  fhMinRegSumPtJetPtBin;    //!
+    TH2F*  fhMaxRegSumPtJetPtBin;    //!
+    TH1F*  fhVertexMult;             //! vertex multiplicity
+    TProfile*  fh1Xsec;                    //! cross-section from MC   
+    TH1F*  fh1Trials;               //! number of trials from MC
+    */
+
+    ClassDef( AliAnalysisTaskUE, 6); // Analysis task for Underlying Event analysis
   };
 
 #endif
index 307df56..841a4e7 100644 (file)
@@ -39,6 +39,7 @@
 #include <TVector3.h>
 
 #include "AliHistogramsUE.h"
+#include "AliAnalysisTaskUE.h"
 #include "AliAnalyseUE.h"
 #include "AliLog.h"
 
@@ -248,7 +249,7 @@ return arr;
 }
 
 //____________________________________________________________________
-TList*  AliHistogramsUE::CreateHistos(Int_t bins, Double_t min, Double_t max, Double_t etacut)
+void  AliHistogramsUE::CreateHistograms(TList *list,Int_t bins, Double_t min, Double_t max, Double_t etacut)
 {
 
   // Create all histograms necessary for UE analysis 
@@ -257,226 +258,225 @@ TList*  AliHistogramsUE::CreateHistos(Int_t bins, Double_t min, Double_t max, Do
   fMaxJetPtInHist = max;
   fTrackEtaCut= etacut;
 
-  fListOfHistos = new TList();
-
   //Number of reconstructed clusters  
   fhNJets = new TH1F("hNJets", "Number of clusters",  20, 0, 20);
   fhNJets->SetXTitle("Number of reconstructed clusters");
   fhNJets->SetYTitle("#");
   fhNJets->Sumw2();
-  fListOfHistos->Add( fhNJets );                 // At(0) 
+  list->Add( fhNJets );                 // At(0) 
   
   //pT distribution of leading clusters
   fhEleadingPt  = new TH1F("hEleadingPt",   "Leading cluster p_{T}",  bins, min,   max);
   fhEleadingPt->SetXTitle("p_{T} of  cluster (GeV/c)");
   fhEleadingPt->SetYTitle("1/N_{ev} dN/dp_{T} (|#eta|<0.5)");
   fhEleadingPt->Sumw2();
-  fListOfHistos->Add( fhEleadingPt );            // At(1)
+  list->Add( fhEleadingPt );            // At(1)
   
   //Track pT distribution in MIN zone
   fhMinRegPtDist = new TH1F("hMinRegPtDist",   "p_{T} distribution in MIN zone",  50,0.,20.);
   fhMinRegPtDist->SetXTitle("Track p_{T} (GeV/c)");
   fhMinRegPtDist->SetYTitle("dN/dp_{T}");
   fhMinRegPtDist->Sumw2();
-  fListOfHistos->Add( fhMinRegPtDist );          // At(2)
+  list->Add( fhMinRegPtDist );          // At(2)
   
   //Multiplicity in MIN zone
   fhRegionMultMin = new TH1F("hRegionMultMin",      "N_{ch}^{90, min}",  21, -0.5,   20.5);
   fhRegionMultMin->SetXTitle("N_{ch tracks}");
   fhRegionMultMin->Sumw2();
-  fListOfHistos->Add( fhRegionMultMin );         // At(3)            
+  list->Add( fhRegionMultMin );         // At(3)            
   
   //Average pT in MIN region
   fhMinRegAvePt = new TH1F("hMinRegAvePt", "#LTp_{T}#GT",  50, 0.,   20.);
   fhMinRegAvePt->SetXTitle("p_{T} (GeV/c)");
   fhMinRegAvePt->Sumw2();
-  fListOfHistos->Add( fhMinRegAvePt );           // At(4)
+  list->Add( fhMinRegAvePt );           // At(4)
   
   //Sum pT in MIN region
   fhMinRegSumPt = new TH1F("hMinRegSumPt", "#Sigma p_{T} ",  50, 0.,   20.);
   fhMinRegSumPt->SetYTitle("Ed^{3}N_{tracks}/dp^{3} (c^{3}/GeV^{2})");  
   fhMinRegSumPt->SetXTitle("#Sigma p_{T} (GeV/c)");
   fhMinRegSumPt->Sumw2();
-  fListOfHistos->Add( fhMinRegSumPt );           // At(5)
+  list->Add( fhMinRegSumPt );           // At(5)
   
   //Track with maximum pT in MIN region
   fhMinRegMaxPtPart = new TH1F("hMinRegMaxPtPart", "max(p_{T})|_{event} ",  50, 0.,   20.);
   fhMinRegMaxPtPart->SetYTitle("Ed^{3}N_{tracks}/dp^{3} (c^{3}/GeV^{2})");  
   fhMinRegMaxPtPart->SetXTitle("p_{T} (GeV/c)");
   fhMinRegMaxPtPart->Sumw2();
-  fListOfHistos->Add( fhMinRegMaxPtPart );       // At(6)
+  list->Add( fhMinRegMaxPtPart );       // At(6)
   
   //Sum pT vs. multiplicity in MIN region
   fhMinRegSumPtvsMult = new TH1F("hMinRegSumPtvsMult", "#Sigma p_{T} vs. Multiplicity ",  21, -0.5,   20.5);
   fhMinRegSumPtvsMult->SetYTitle("#Sigma p_{T} (GeV/c)");  
   fhMinRegSumPtvsMult->SetXTitle("N_{charge}");
   fhMinRegSumPtvsMult->Sumw2();
-  fListOfHistos->Add( fhMinRegSumPtvsMult );     // At(7);
+  list->Add( fhMinRegSumPtvsMult );     // At(7);
   
   //Phi correlation track-cluster vs. leading cluster pT 
   fhdNdEtaPhiDist  = new TH2F("hdNdEtaPhiDist", Form("Charge particle density |#eta|<%3.1f vs #Delta#phi", fTrackEtaCut),62, 0.,   2.*TMath::Pi(), bins, min, max);
   fhdNdEtaPhiDist->SetXTitle("#Delta#phi");
   fhdNdEtaPhiDist->SetYTitle("Leading cluster p_{T}");
   fhdNdEtaPhiDist->Sumw2();
-  fListOfHistos->Add( fhdNdEtaPhiDist );        // At(8)
+  list->Add( fhdNdEtaPhiDist );        // At(8)
   
   //Can be used to get track pT distribution for different cluster pT bins (full region)
   fhFullRegPartPtDistVsEt = new TH2F("hFullRegPartPtDistVsEt", Form( "dN/dp_{T} |#eta|<%3.1f vs Leading cluster p_{T}", fTrackEtaCut),100,0.,50., bins, min, max);
   fhFullRegPartPtDistVsEt->SetYTitle("Leading cluster p_{T}");
   fhFullRegPartPtDistVsEt->SetXTitle("p_{T}");
   fhFullRegPartPtDistVsEt->Sumw2();
-  fListOfHistos->Add( fhFullRegPartPtDistVsEt );  // At(9) 
+  list->Add( fhFullRegPartPtDistVsEt );  // At(9) 
   
   //Can be used to get part pT distribution for different cluster pT bins (transverse region)
   fhTransRegPartPtDistVsEt = new TH2F("hTransRegPartPtDistVsEt", Form( "dN/dp_{T} in tranvese regions |#eta|<%3.1f vs Leading cluster p_{T}", fTrackEtaCut),100,0.,50., bins, min,   max);
   fhTransRegPartPtDistVsEt->SetYTitle("Leading cluster p_{T}");
   fhTransRegPartPtDistVsEt->SetXTitle("p_{T}");
   fhTransRegPartPtDistVsEt->Sumw2();
-  fListOfHistos->Add( fhTransRegPartPtDistVsEt );  // At(10)
+  list->Add( fhTransRegPartPtDistVsEt );  // At(10)
   
   //Sum pT in MAX region vs. leading-cluster pT
   fhRegionSumPtMaxVsEt = new TH1F("hRegionSumPtMaxVsEt",  "P_{T}^{90, max} vs Leading cluster p_{T}",  bins, min,   max);
   fhRegionSumPtMaxVsEt->SetXTitle("p_{T} (GeV/c)");
   fhRegionSumPtMaxVsEt->Sumw2();
-  fListOfHistos->Add( fhRegionSumPtMaxVsEt );      // At(11)
+  list->Add( fhRegionSumPtMaxVsEt );      // At(11)
   
 
   //Sum pT in MIN region vs. leading-cluster pT
   fhRegionSumPtMinVsEt = new TH1F("hRegionSumPtMinVsEt",   "P_{T}^{90, min} vs Leading cluster p_{T}",  bins, min,   max);
   fhRegionSumPtMinVsEt->SetXTitle("p_{T} (GeV/c)");
   fhRegionSumPtMinVsEt->Sumw2();
-  fListOfHistos->Add( fhRegionSumPtMinVsEt );      // At(12)
+  list->Add( fhRegionSumPtMinVsEt );      // At(12)
  
   //Multiplicity in MAX region
   fhRegionMultMax = new TH1I("hRegionMultMax",      "N_{ch}^{90, max}",  21, -0.5,   20.5);
   fhRegionMultMax->SetXTitle("N_{ch tracks}");
   fhRegionMultMax->Sumw2();
-  fListOfHistos->Add( fhRegionMultMax );           // At(13)
+  list->Add( fhRegionMultMax );           // At(13)
   
   //Multiplicity in MAX region vs. leading-cluster pT
   fhRegionMultMaxVsEt = new TH1F("hRegionMultMaxVsEt",  "N_{ch}^{90, max} vs Leading cluster p_{T}",  bins, min,   max);
   fhRegionMultMaxVsEt->SetXTitle("p_{T} (GeV/c)");
   fhRegionMultMaxVsEt->Sumw2();
-  fListOfHistos->Add( fhRegionMultMaxVsEt );       // At(14)
+  list->Add( fhRegionMultMaxVsEt );       // At(14)
   
   //Multiplicity in MIN region vs. leading-cluster pT
   fhRegionMultMinVsEt = new TH1F("hRegionMultMinVsEt",  "N_{ch}^{90, min} vs Leading cluster p_{T}",  bins, min,   max);
   fhRegionMultMinVsEt->SetXTitle("p_{T} (GeV/c)");
   fhRegionMultMinVsEt->Sumw2();
-  fListOfHistos->Add( fhRegionMultMinVsEt );      // At(15)
+  list->Add( fhRegionMultMinVsEt );      // At(15)
  
   //Average sum pT in TRANSVERSE(MIN+MAX) region vs. leading-cluster pT 
   fhRegionAveSumPtVsEt = new TH1F("hRegionAveSumPtVsEt", "(P_{T}^{90, max} + P_{T}^{90, min})/2 vs Leading cluster p_{T}",  bins, min,   max);
   fhRegionAveSumPtVsEt->SetXTitle("p_{T} (GeV/c)");
   fhRegionAveSumPtVsEt->Sumw2();
-  fListOfHistos->Add( fhRegionAveSumPtVsEt );     // At(16)
+  list->Add( fhRegionAveSumPtVsEt );     // At(16)
   
   //Difference sum pT (MAX-MIN) vs.  leading-cluster pT
   fhRegionDiffSumPtVsEt= new TH1F("hRegionDiffSumPtVsEt", "(P_{T}^{90, max} - P_{T}^{90, min}) vs Leading cluster p_{T}",  bins, min,   max);
   fhRegionDiffSumPtVsEt->SetXTitle("P_{T} (GeV/c)");
   fhRegionDiffSumPtVsEt->Sumw2();
-  fListOfHistos->Add( fhRegionDiffSumPtVsEt );    // At(17)
+  list->Add( fhRegionDiffSumPtVsEt );    // At(17)
   
   //Average track pT in MAX region vs. leading-cluster pT
   fhRegionAvePartPtMaxVsEt = new TH1F("hRegionAvePartPtMaxVsEt", "#LTp_{T}#GT^{90, max} vs Leading cluster p_{T}",  bins, min,   max);
   fhRegionAvePartPtMaxVsEt->SetXTitle("p_{T} (GeV/c)");
   fhRegionAvePartPtMaxVsEt->Sumw2();
-  fListOfHistos->Add( fhRegionAvePartPtMaxVsEt );  // At(18)
+  list->Add( fhRegionAvePartPtMaxVsEt );  // At(18)
   
   //Average track pT in MIN region vs. leading-cluster pT
   fhRegionAvePartPtMinVsEt = new TH1F("hRegionAvePartPtMinVsEt", "#LTp_{T}#GT^{90, min} vs Leading cluster p_{T}",  bins, min,   max);
   fhRegionAvePartPtMinVsEt->SetXTitle("p_{T} (GeV/c)");
   fhRegionAvePartPtMinVsEt->Sumw2();
-  fListOfHistos->Add( fhRegionAvePartPtMinVsEt );   // At(19)
+  list->Add( fhRegionAvePartPtMinVsEt );   // At(19)
   
   //Maximum track pT in MAX region vs. leading-cluster pT
   fhRegionMaxPartPtMaxVsEt = new TH1F("hRegionMaxPartPtMaxVsEt", "max(p_{T})^{90} vs Leading cluster p_{T}",  bins, min,   max);
   fhRegionMaxPartPtMaxVsEt->SetXTitle("p_{T} (GeV/c)");
   fhRegionMaxPartPtMaxVsEt->Sumw2();
-  fListOfHistos->Add( fhRegionMaxPartPtMaxVsEt );    // At(20)
+  list->Add( fhRegionMaxPartPtMaxVsEt );    // At(20)
   
   //Multiplicity in FORWARD region
   fhRegForwardMult = new TH2F("hRegForwardMult", "N_{ch}^{forward}", bins, min, max, 21, -0.5,   20.5);
   fhRegForwardMult->SetXTitle("N_{ch tracks}");
   fhRegForwardMult->Sumw2();
-  fListOfHistos->Add( fhRegForwardMult );           // At(25)
+  list->Add( fhRegForwardMult );           // At(25)
   
   //Sum pT in FORWARD region vs. multiplicity
   fhRegForwardSumPtvsMult = new TH2F("hRegForwardSumPtvsMult", "Forward #Sigma p_{T} vs. Multiplicity ", bins, min, max, 21, -0.5,   20.5);
   fhRegForwardSumPtvsMult->SetYTitle("#Sigma p_{T} (GeV/c)");  
   fhRegForwardSumPtvsMult->SetXTitle("N_{charge}");
   fhRegForwardSumPtvsMult->Sumw2();
-  fListOfHistos->Add( fhRegForwardSumPtvsMult );     // At(26);
+  list->Add( fhRegForwardSumPtvsMult );     // At(26);
   
   //Multiplicity in BACKWARD region
   fhRegBackwardMult = new TH2F("hRegBackwardMult", "N_{ch}^{backward}", bins, min, max, 21, -0.5,   20.5);
   fhRegBackwardMult->SetXTitle("N_{ch tracks}");
   fhRegBackwardMult->Sumw2();
-  fListOfHistos->Add( fhRegBackwardMult );           // At(27)
+  list->Add( fhRegBackwardMult );           // At(27)
  
   //Sum pT in BACKWARD region vs. multiplicity
   fhRegBackwardSumPtvsMult = new TH2F("hRegBackwardSumPtvsMult", "Backward #Sigma p_{T} vs. Multiplicity ", bins, min, max, 21, -0.5,   20.5);
   fhRegBackwardSumPtvsMult->SetYTitle("#Sigma p_{T} (GeV/c)");  
   fhRegBackwardSumPtvsMult->SetXTitle("N_{charge}");
   fhRegBackwardSumPtvsMult->Sumw2();
-  fListOfHistos->Add( fhRegBackwardSumPtvsMult );     // At(28);
+  list->Add( fhRegBackwardSumPtvsMult );     // At(28);
   
   //Track pT distribution in FORWARD region vs. leading-cluster pT 
   fhRegForwardPartPtDistVsEt = new TH2F("hRegForwardPartPtDistVsEt", Form( "dN/dP_{T} |#eta|<%3.1f vs Leading cluster p_{T}", fTrackEtaCut), 100,0.,50., bins, min, max);
   fhRegForwardPartPtDistVsEt->SetYTitle("Leading cluster p_{T}");
   fhRegForwardPartPtDistVsEt->SetXTitle("p_{T} (GeV/c)");
   fhRegForwardPartPtDistVsEt->Sumw2();
-  fListOfHistos->Add( fhRegForwardPartPtDistVsEt );  // At(29) 
+  list->Add( fhRegForwardPartPtDistVsEt );  // At(29) 
   
   //Track pT distribution in BACKWARD region vs. leading-cluster pT 
   fhRegBackwardPartPtDistVsEt = new TH2F("hRegBackwardPartPtDistVsEt", Form( "dN/dP_{T} |#eta|<%3.1f vs Leading cluster p_{T}", fTrackEtaCut), 100,0.,50., bins, min, max);
   fhRegBackwardPartPtDistVsEt->SetYTitle("Leading cluster p_{T}");
   fhRegBackwardPartPtDistVsEt->SetXTitle("p_{T}");
   fhRegBackwardPartPtDistVsEt->Sumw2();
-  fListOfHistos->Add( fhRegBackwardPartPtDistVsEt );  // At(30) 
+  list->Add( fhRegBackwardPartPtDistVsEt );  // At(30) 
   
   //Multiplicity in TRANSVERSE (MIN+MAX) region
   fhRegTransMult  = new TH2F("hRegTransMult", "N_{ch}^{transv}", bins, min, max, 21, -0.5,   20.5);
   fhRegTransMult->SetXTitle("N_{ch tracks}");
   fhRegTransMult->Sumw2();
-  fListOfHistos->Add( fhRegTransMult );           // At(31)
+  list->Add( fhRegTransMult );           // At(31)
   
   //Sum pT in TRANSVERSE (MIN+MAX) region vs. multiplicity
   fhRegTransSumPtVsMult = new TH2F("hRegTransSumPtVsMult", "Transverse #Sigma p_{T} vs. Multiplicity ",bins, min, max, 21, -0.5,   20.5);
   fhRegTransSumPtVsMult->SetYTitle("#Sigma p_{T} (GeV/c)");  
   fhRegTransSumPtVsMult->SetXTitle("N_{charge}");
   fhRegTransSumPtVsMult->Sumw2();
-  fListOfHistos->Add( fhRegTransSumPtVsMult );     // At(32);
+  list->Add( fhRegTransSumPtVsMult );     // At(32);
   
   //Sum pT in MIN region per cluster pT bin
   fhMinRegSumPtJetPtBin = new TH2F("hMinRegSumPtJetPtBin", "Transverse Min Reg #Sigma p_{T} per cluster pT bin",bins, min, max, 50, 0.,   20.);
   fhMinRegSumPtJetPtBin->SetXTitle("Leading cluster p_{T}");
   fhMinRegSumPtJetPtBin->Sumw2();
-  fListOfHistos->Add( fhMinRegSumPtJetPtBin );           // At(33)
+  list->Add( fhMinRegSumPtJetPtBin );           // At(33)
   
   //Sum pT in MAX region per cluster pT bin
   fhMaxRegSumPtJetPtBin = new TH2F("hMaxRegSumPtJetPtBin",      "Transverse Max Reg #Sigma p_{T} per cluster pT bin", bins, min, max, 50, 0.,   20.);
   fhMaxRegSumPtJetPtBin->SetXTitle("Leading cluster p_{T}");
   fhMaxRegSumPtJetPtBin->Sumw2();
-  fListOfHistos->Add( fhMaxRegSumPtJetPtBin );           // At(34)
+  list->Add( fhMaxRegSumPtJetPtBin );           // At(34)
   
   //Multiplicity in main vertex
   fhVertexMult = new TH1F("hVertexMult",      "Multiplicity in Main Vertex", 81, -0.5 , 80.5);
   fhVertexMult->SetXTitle("Main Vertex Multiplicity");
   fhVertexMult->Sumw2();
-  fListOfHistos->Add( fhVertexMult ); //At(35)
+  list->Add( fhVertexMult ); //At(35)
   
   fh1Xsec = new TProfile("h1Xsec","xsec from pyxsec.root",1,0,1); 
   fh1Xsec->GetXaxis()->SetBinLabel(1,"<#sigma>");
   fh1Xsec->Sumw2();
-  fListOfHistos->Add( fh1Xsec );            //At(36)
+  list->Add( fh1Xsec );            //At(36)
   
   fh1Trials = new TH1F("h1Trials","trials from pyxsec.root",1,0,1);
   fh1Trials->GetXaxis()->SetBinLabel(1,"#sum{ntrials}");
   fh1Trials->Sumw2();
-  fListOfHistos->Add( fh1Trials ); //At(37)
-
-  return fListOfHistos;
+  list->Add( fh1Trials ); //At(37)
+  
+  
+  fListOfHistos=list; 
 }
 
 
@@ -829,7 +829,7 @@ void AliHistogramsUE::SetStyle(){
 
 
 //____________________________________________________________________
-TList* AliHistogramsUE::GetListOfHistos(){
+TList* AliHistogramsUE::GetHistograms(){
 
   // Return list of relevant histograms 
   return fListOfHistos;
index 3fdc1c9..50e1865 100644 (file)
@@ -17,6 +17,7 @@ class TObjArray;
 class TProfile;
 class TTree;
 class TVector3;
+class AliAnalysisTaskUE;
 
 class  AliHistogramsUE : public TObject
   {
@@ -29,16 +30,16 @@ class  AliHistogramsUE : public TObject
     
     TObjArray*     CreateCanvas(const Int_t ncanv);
     TObjArray*     GetHistosForPlotting(TString file, TString branches);
-    TList*        CreateHistos(Int_t bins, Double_t min, Double_t max, Double_t etacut);
+    void          CreateHistograms(TList* list,Int_t bins, Double_t min, Double_t max, Double_t etacut);
     void           DrawUE(Int_t debug);  //to draw final plots (normalized)
     void           FillHistogram(const char* name,Double_t fillX); //One dimensional
     void           FillHistogram(const char* name,Int_t fillX); //One dimensional
     void           FillHistogram(const char* name,Double_t fillX, Double_t fillY); //Two dimensional
     void           FillHistogram(const char* name,Double_t fillX, Double_t fillY, Double_t weight); //Two dimensional
     void           FillHistogram(const char* name,Double_t fillX, Int_t fillY, Double_t weight); //Two dimensional
-    TList*        GetListOfHistos();
-    TH1F*            GetTrials()       {return fh1Trials;}
-    TProfile*        GetXsec()         {return fh1Xsec;}
+    TList*        GetHistograms();
+    TH1F*          GetTrials()       {return fh1Trials;}
+    TProfile*      GetXsec()         {return fh1Xsec;}
     void           PlotBranchesUE(TString file, TString branches, Double_t minJetProjection);  //TO BE CALLED BY EXTERNAL MACRO !!!             
     void           SetStyle(); 
   protected:
@@ -94,7 +95,7 @@ class  AliHistogramsUE : public TObject
     TProfile*  fh1Xsec;                    //!         
     TH1F*  fh1Trials;               //!
 
-    ClassDef( AliHistogramsUE, 1 ); // Class to manage histograms in UE analysis
+    ClassDef( AliHistogramsUE, 0 ); // Class to manage histograms in UE analysis
   };
 
 #endif