From c9ae910e6d04d6cb725f7b15830d48ac82f596db Mon Sep 17 00:00:00 2001 From: jgrosseo Date: Fri, 25 Apr 2014 15:18:53 +0200 Subject: [PATCH] 2+1 correlation analysis (Markus) --- PWGCF/CMakelibPWGCFCorrelationsBase.pkg | 1 + PWGCF/CMakelibPWGCFCorrelationsDPhi.pkg | 1 + .../Base/AliTwoPlusOneContainer.cxx | 301 ++++++++++++++++++ .../Base/AliTwoPlusOneContainer.h | 65 ++++ PWGCF/Correlations/Base/AliUEHist.cxx | 99 +++++- PWGCF/Correlations/Base/AliUEHist.h | 8 +- PWGCF/Correlations/Base/AliUEHistograms.cxx | 16 +- .../DPhi/AliAnalysisTaskTwoPlusOne.cxx | 264 +++++++++++++++ .../DPhi/AliAnalysisTaskTwoPlusOne.h | 115 +++++++ .../macros/twoplusone/AddTaskTwoPlusOne.C | 37 +++ .../macros/twoplusone/output_TwoPlusOne.C | 92 ++++++ PWGCF/PWGCFCorrelationsBaseLinkDef.h | 1 + PWGCF/PWGCFCorrelationsDPhiLinkDef.h | 1 + 13 files changed, 971 insertions(+), 30 deletions(-) create mode 100644 PWGCF/Correlations/Base/AliTwoPlusOneContainer.cxx create mode 100644 PWGCF/Correlations/Base/AliTwoPlusOneContainer.h create mode 100644 PWGCF/Correlations/DPhi/AliAnalysisTaskTwoPlusOne.cxx create mode 100644 PWGCF/Correlations/DPhi/AliAnalysisTaskTwoPlusOne.h create mode 100644 PWGCF/Correlations/macros/twoplusone/AddTaskTwoPlusOne.C create mode 100644 PWGCF/Correlations/macros/twoplusone/output_TwoPlusOne.C diff --git a/PWGCF/CMakelibPWGCFCorrelationsBase.pkg b/PWGCF/CMakelibPWGCFCorrelationsBase.pkg index cb13778c9be..4ea747dfef3 100644 --- a/PWGCF/CMakelibPWGCFCorrelationsBase.pkg +++ b/PWGCF/CMakelibPWGCFCorrelationsBase.pkg @@ -32,6 +32,7 @@ set ( SRCS Correlations/Base/AliAnalyseLeadingTrackUE.cxx Correlations/Base/AliCFParticle.cxx Correlations/Base/AliAnalysisTaskCFTree.cxx + Correlations/Base/AliTwoPlusOneContainer.cxx ) string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" ) diff --git a/PWGCF/CMakelibPWGCFCorrelationsDPhi.pkg b/PWGCF/CMakelibPWGCFCorrelationsDPhi.pkg index 4347442b6ca..1628f7c18ba 100644 --- a/PWGCF/CMakelibPWGCFCorrelationsDPhi.pkg +++ b/PWGCF/CMakelibPWGCFCorrelationsDPhi.pkg @@ -31,6 +31,7 @@ set ( SRCS Correlations/DPhi/AliDptDptInMC.cxx Correlations/DPhi/AliAnalysisTask3PCorrelations.cxx Correlations/DPhi/AliAnalysisTaskPhiCorrelations.cxx + Correlations/DPhi/AliAnalysisTaskTwoPlusOne.cxx Correlations/DPhi/AliPhiCorrelationsQATask.cxx Correlations/DPhi/AliAnalysisTaskLeadingTrackUE.cxx Correlations/DPhi/AliAnalysisTaskMinijet.cxx diff --git a/PWGCF/Correlations/Base/AliTwoPlusOneContainer.cxx b/PWGCF/Correlations/Base/AliTwoPlusOneContainer.cxx new file mode 100644 index 00000000000..99b5b8396d3 --- /dev/null +++ b/PWGCF/Correlations/Base/AliTwoPlusOneContainer.cxx @@ -0,0 +1,301 @@ +/************************************************************************** + * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * * + * Author: The ALICE Off-line Project. * + * Contributors are mentioned in the code where appropriate. * + * * + * Permission to use, copy, modify and distribute this software and its * + * documentation strictly for non-commercial purposes is hereby granted * + * without fee, provided that the above copyright notice appears in all * + * copies and that both the copyright notice and this permission notice * + * appear in the supporting documentation. The authors make no claims * + * about the suitability of this software for any purpose. It is * + * provided "as is" without express or implied warranty. * + **************************************************************************/ + +// +// +// encapsulates several AliUEHist objects for a full UE analysis plus additional control histograms +// the method FillCorrelations is the only method which fills the container +// associated particles are filled once for each near side and once for each away side +// the pT 2 for the near side particles is set to the highest pT of all accepted away side pT 2 +// as consequence the pT 2 axis can only be cut for the minimum +// if the maximum of the axis should be changed the full analysis needs to rerun +// +// +// Author: Markus Zimmermann +// + + +#include "AliTwoPlusOneContainer.h" + +#include "AliCFContainer.h" +#include "AliVParticle.h" + +#include "TH1F.h" +#include "TMath.h" + +ClassImp(AliTwoPlusOneContainer) + +AliTwoPlusOneContainer::AliTwoPlusOneContainer(const char* name, const char* binning, const Double_t alpha) : + TNamed(name, name), + fTwoPlusOne(0), + fTriggerPt1Min(0), + fTriggerPt1Max(0), + fTriggerPt2Min(0), + fTriggerPt2Max(0), + fPtAssocMin(0), + fPtAssocMax(0), + fAlpha(alpha) +{ + // Constructor + // + TString defaultBinningStr; + defaultBinningStr = "eta: -1.0, 1.0\n"//needs to be defined for AliUEHist + "p_t_assoc: 0.5, 1.0, 2.0, 3.0, 4.0, 6.0, 8.0\n" + "p_t_leading: 6.0, 8.0, 10.0, 12.0, 14.0\n" + "p_t_leading_course: 4.0, 6.0, 8.0, 10.0\n" + "p_t_eff: 0.5, 8.0\n"//needs to be defined for AliUEHist + "vertex_eff: -10, 10\n"//needs to be defined for AliUEHist + "multiplicity: 0, 1, 2, 3, 4, 5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100.1\n" + "vertex: -7, -5, -3, -1, 1, 3, 5, 7\n" + "delta_phi: -1.570796, -1.396263, -1.221730, -1.047197, -0.872664, -0.698131, -0.523598, -0.349065, -0.174532, 0.0, 0.174532, 0.349065, 0.523598, 0.698131, 0.872664, 1.047197, 1.221730, 1.396263, 1.570796, 1.745329, 1.919862, 2.094395, 2.268928, 2.443460, 2.617993, 2.792526, 2.967059, 3.141592, 3.316125, 3.490658, 3.665191, 3.839724, 4.014257, 4.188790, 4.363323, 4.537856, 4.712388\n" // this binning starts at -pi/2 and it ends at +3pi/2, it has 36 bins + "delta_eta: -2.0, -1.8, -1.6, -1.4, -1.2, -1.0, -0.8, -0.6, -0.4, -0.2, 0, 0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0\n"; + + // combine customBinning with defaultBinningStr -> use customBinning where available and otherwise defaultBinningStr + TString binningStr = AliUEHist::CombineBinning(defaultBinningStr, TString(binning)); + + fTwoPlusOne = new AliUEHist("TwoPlusOne", binningStr); + + //set minimum and maximum trigger pt values + fTriggerPt1Min = fTwoPlusOne->GetTrackHist(AliUEHist::kToward)->GetGrid((AliUEHist::CFStep) AliTwoPlusOneContainer::kSameNS)->GetAxis(2)->GetXmin(); + fTriggerPt1Max = fTwoPlusOne->GetTrackHist(AliUEHist::kToward)->GetGrid((AliUEHist::CFStep) AliTwoPlusOneContainer::kSameNS)->GetAxis(2)->GetXmax(); + fTriggerPt2Min = fTwoPlusOne->GetTrackHist(AliUEHist::kToward)->GetGrid((AliUEHist::CFStep) AliTwoPlusOneContainer::kSameNS)->GetAxis(6)->GetXmin(); + fTriggerPt2Max = fTwoPlusOne->GetTrackHist(AliUEHist::kToward)->GetGrid((AliUEHist::CFStep) AliTwoPlusOneContainer::kSameNS)->GetAxis(6)->GetXmax(); + fPtAssocMin = fTwoPlusOne->GetTrackHist(AliUEHist::kToward)->GetGrid((AliUEHist::CFStep) AliTwoPlusOneContainer::kSameNS)->GetAxis(1)->GetXmin(); + fPtAssocMax = fTwoPlusOne->GetTrackHist(AliUEHist::kToward)->GetGrid((AliUEHist::CFStep) AliTwoPlusOneContainer::kSameNS)->GetAxis(1)->GetXmax(); + + TH1::AddDirectory(); +} + +//_____________________________________________________________________________ +AliTwoPlusOneContainer::AliTwoPlusOneContainer(const AliTwoPlusOneContainer &c) : + TNamed(fName, fTitle), + fTwoPlusOne(0), + fTriggerPt1Min(0), + fTriggerPt1Max(0), + fTriggerPt2Min(0), + fTriggerPt2Max(0), + fPtAssocMin(0), + fPtAssocMax(0), + fAlpha(0.2) +{ + // + // AliTwoPlusOneContainer copy constructor + // + + ((AliTwoPlusOneContainer &) c).Copy(*this); + fTriggerPt1Min = ((AliTwoPlusOneContainer &) c).getTriggerPt1Min(); + fTriggerPt1Max = ((AliTwoPlusOneContainer &) c).getTriggerPt1Max(); + fTriggerPt2Min = ((AliTwoPlusOneContainer &) c).getTriggerPt2Min(); + fTriggerPt2Max = ((AliTwoPlusOneContainer &) c).getTriggerPt2Max(); + fPtAssocMin = ((AliTwoPlusOneContainer &) c).getPtAssocMin(); + fPtAssocMax = ((AliTwoPlusOneContainer &) c).getPtAssocMax(); +} + +//____________________________________________________________________ +AliTwoPlusOneContainer::~AliTwoPlusOneContainer() +{ + // Destructor + + DeleteContainers(); +} + +//____________________________________________________________________ +void AliTwoPlusOneContainer::DeleteContainers() +{ + if (fTwoPlusOne) + { + delete fTwoPlusOne; + fTwoPlusOne = 0; + } +} + + +//____________________________________________________________________ +void AliTwoPlusOneContainer::FillCorrelations(Double_t centrality, Float_t zVtx, AliTwoPlusOneContainer::PlotKind step, TObjArray* triggerNear, TObjArray* triggerAway, TObjArray* assocNear, TObjArray* assocAway, Double_t weight) +{ + //Fill Correlations fills the UEHist fTwoPlusOne with the 2+1 correlation + //the input variables centrality and zVtx are the centrality and the z vertex of the event + //the 4 lists triggerNear, triggerAway, assocNear and assocAway are four lists of particles. For the same event analysis all for lists are identical. For the mixed event analysis assocNear and assocAway are from different events as the trigger lists and for the mixed combinatorics triggerNear and assocNear are from one event and triggerAway and assocAway are from another event. + + AliCFContainer* track_hist = fTwoPlusOne->GetTrackHist(AliUEHist::kToward); + AliCFContainer* event_hist = fTwoPlusOne->GetEventHist(); + AliUEHist::CFStep stepUEHist = static_cast(step); + + for (Int_t i=0; iGetEntriesFast(); i++){ + AliVParticle* part = (AliVParticle*) triggerNear->UncheckedAt(i); + + Double_t part_pt = part->Pt(); + if(part_ptfTriggerPt1Max) + continue; + + Double_t part_eta = part->Eta(); + Double_t part_phi = part->Phi(); + + //search for second trigger particle + //entries is the number of particles in the event, so there can only be less particles within the trigger 2 conditions + Int_t ind_found = 0; + Int_t ind_max_found_pt = -1; + Int_t triggerAway_entries = triggerAway->GetEntriesFast(); + AliVParticle* found_particle[triggerAway_entries]; + + for (Int_t j=0; jUncheckedAt(j); + + Double_t part2_pt = part2->Pt(); + //check if pT of trigger 2 is within the trigger range + //also pt of trigger 2 needs to be smaller than the pt of trigger 1 (to have an ordering if both pt are close to each other) + if(part2_ptfTriggerPt2Max || part2_pt>part_pt) + continue; + + // don't use the same particle (is in any case impossible because the Delta phi angle will be 0) + if(part==part2){ + continue; + } + + Double_t dphi_triggers = part_phi-part2->Phi(); + + if(dphi_triggers>1.5*TMath::Pi()) dphi_triggers -= TMath::TwoPi(); + else if(dphi_triggers<-0.5*TMath::Pi()) dphi_triggers += TMath::TwoPi(); + + dphi_triggers -= TMath::Pi(); + if(TMath::Abs(dphi_triggers)>fAlpha) + continue; + + found_particle[ind_found] = part2; + if(ind_max_found_pt==-1 || part2_pt>found_particle[ind_max_found_pt]->Pt()) ind_max_found_pt = ind_found; + ind_found++; + }//end loop to search for the second trigger particle + + //if no second trigger particle was found continue to search for the next first trigger particle + if(ind_found==0) + continue; + + //the energy of the second trigger particle is set for the near side to the maximum energy of all trigger 2 particles on the away side + // this leads to the fact that the number of accepted trigger combinations can be artificial smaller than the real number if there is a cut on the pT 2 energy from the top; cutting away the smallest energy of pT 2 is still save; this is the reason why it is not allowed to use a cut on the top pt of trigger particle 2 + //fill trigger particles + if(ind_found>0){ + Double_t vars[4]; + vars[0] = part_pt; + vars[1] = centrality; + vars[2] = zVtx; + vars[3] = found_particle[ind_max_found_pt]->Pt(); + + event_hist->Fill(vars, stepUEHist, weight);//near side + + for(Int_t k=0; k< ind_found; k++){ + vars[3] = found_particle[k]->Pt(); + event_hist->Fill(vars, stepUEHist+1, weight);//away side + } + } + + //add correlated particles on the near side + for (Int_t k=0; kGetEntriesFast(); k++){ + AliVParticle* part3 = (AliVParticle*) assocNear->UncheckedAt(k); + + Double_t part3_pt = part3->Pt(); + if(part3_ptfPtAssocMax) + continue; + + //do not add the trigger 1 particle + if(part==part3) + continue; + + //do not add the trigger 2 particle + if(found_particle[ind_max_found_pt]==part3) + continue; + + Double_t dphi_near = part_phi-part3->Phi(); + if(dphi_near>1.5*TMath::Pi()) dphi_near -= TMath::TwoPi(); + else if(dphi_near<-0.5*TMath::Pi()) dphi_near += TMath::TwoPi(); + + Double_t deta_near = part_eta-part3->Eta(); + + Double_t vars[7]; + vars[0] = deta_near; + vars[1] = part3_pt; + vars[2] = part_pt; + vars[3] = centrality; + vars[4] = dphi_near; + vars[5] = zVtx; + vars[6] = found_particle[ind_max_found_pt]->Pt(); + + track_hist->Fill(vars, stepUEHist, weight); + } + + //add correlated particles on the away side + for (Int_t k=0; kGetEntriesFast(); k++){ + AliVParticle* part3 = (AliVParticle*) assocAway->UncheckedAt(k); + + Double_t part3_pt = part3->Pt(); + if(part3_ptfPtAssocMax) + continue; + + //do not add the trigger 1 particle + if(part==part3) + continue; + + for(int l=0; lPhi()-part3->Phi(); + if(dphi_away>1.5*TMath::Pi()) dphi_away -= TMath::TwoPi(); + else if(dphi_away<-0.5*TMath::Pi()) dphi_away += TMath::TwoPi(); + + Double_t deta_away = found_particle[l]->Eta()-part3->Eta(); + + Double_t vars[7]; + vars[0] = deta_away; + vars[1] = part3_pt; + vars[2] = part_pt; + vars[3] = centrality; + vars[4] = dphi_away; + vars[5] = zVtx; + vars[6] = found_particle[l]->Pt(); + + track_hist->Fill(vars, stepUEHist+1, weight);//step +1 is the AS to the NS plot of step + } + } + }//end loop to search for the first trigger particle +} + + + +//____________________________________________________________________ +AliTwoPlusOneContainer &AliTwoPlusOneContainer::operator=(const AliTwoPlusOneContainer &c) +{ + // assigment operator + + DeleteContainers(); + + if (this != &c) + ((AliTwoPlusOneContainer &) c).Copy(*this); + + return *this; +} + +//____________________________________________________________________ +void AliTwoPlusOneContainer::Copy(TObject& c) const +{ + // copy function + + AliTwoPlusOneContainer& target = (AliTwoPlusOneContainer &) c; + + if (fTwoPlusOne) + target.fTwoPlusOne = dynamic_cast (fTwoPlusOne->Clone()); + +} + diff --git a/PWGCF/Correlations/Base/AliTwoPlusOneContainer.h b/PWGCF/Correlations/Base/AliTwoPlusOneContainer.h new file mode 100644 index 00000000000..4cf04f7771e --- /dev/null +++ b/PWGCF/Correlations/Base/AliTwoPlusOneContainer.h @@ -0,0 +1,65 @@ +#ifndef AliTwoPlusOneContainer_H +#define AliTwoPlusOneContainer_H + +/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +// data container for 2+1 particle analysis + +#include "TNamed.h" +#include "AliUEHist.h" +// #include "THn.h" // in cxx file causes .../THn.h:257: error: conflicting declaration ‘typedef class THnT THnF’ + +class AliVParticle; + +class TList; +class TSeqCollection; +class TObjArray; +class TH1F; +class TH2F; +class TH3F; + +class AliTwoPlusOneContainer : public TNamed +{ + public: + AliTwoPlusOneContainer(const char* name = "AliTwoPlusOneContainer", const char* binning = 0, const Double_t alpha = 0.2); + + virtual ~AliTwoPlusOneContainer(); + + enum PlotKind {kSameNS = 0, kSameAS, kMixedNS, kMixedAS, kMixedCombNS, kMixedCombAS}; + + void FillCorrelations(Double_t centrality, Float_t zVtx, AliTwoPlusOneContainer::PlotKind step, TObjArray* triggerNear, TObjArray* triggerAway, TObjArray* assocNear, TObjArray* assocAway, Double_t weight); + + AliUEHist* GetData() {return fTwoPlusOne;} + Double_t getTriggerPt1Min() {return fTriggerPt1Min;} + Double_t getTriggerPt1Max() {return fTriggerPt1Max;} + Double_t getTriggerPt2Min() {return fTriggerPt2Min;} + Double_t getTriggerPt2Max() {return fTriggerPt2Max;} + Double_t getPtAssocMin() {return fPtAssocMin;} + Double_t getPtAssocMax() {return fPtAssocMax;} + + void SetData(AliUEHist* obj) {fTwoPlusOne = obj; } + void SetAlpha(Double_t value) {fAlpha = value;} + + AliTwoPlusOneContainer(const AliTwoPlusOneContainer &c); + AliTwoPlusOneContainer& operator=(const AliTwoPlusOneContainer& c); + virtual void Copy(TObject& c) const; + +protected: + void DeleteContainers(); + + AliUEHist* fTwoPlusOne; //a 6 dim histogram which actually contains all the data + + Double_t fTriggerPt1Min; //minimum energy for the first trigger particle + Double_t fTriggerPt1Max; //maximum energy for the first trigger particle + Double_t fTriggerPt2Min; //minimum energy for the second trigger particle + Double_t fTriggerPt2Max; //maximum energy for the second trigger particle + Double_t fPtAssocMin; //minimum energy for the associated particles + Double_t fPtAssocMax; //maximum energy for the associated particle + Double_t fAlpha; //minimum energy for the first trigger particle + + ClassDef(AliTwoPlusOneContainer, 1) // underlying event histogram container +}; + + +#endif diff --git a/PWGCF/Correlations/Base/AliUEHist.cxx b/PWGCF/Correlations/Base/AliUEHist.cxx index 15a38bc070f..b30f7214724 100644 --- a/PWGCF/Correlations/Base/AliUEHist.cxx +++ b/PWGCF/Correlations/Base/AliUEHist.cxx @@ -56,6 +56,7 @@ AliUEHist::AliUEHist(const char* reqHist, const char* binning) : fCentralityMax(0), fZVtxMin(0), fZVtxMax(0), + fPt2Min(0), fContaminationEnhancement(0), fCombineMinMax(0), fTrackEtaCut(0), @@ -83,9 +84,9 @@ AliUEHist::AliUEHist(const char* reqHist, const char* binning) : // track level Int_t nTrackVars = 4; // eta vs pT vs pT,lead (vs delta phi) vs multiplicity - Int_t iTrackBin[6]; - Double_t* trackBins[6]; - const char* trackAxisTitle[6]; + Int_t iTrackBin[7]; + Double_t* trackBins[7]; + const char* trackAxisTitle[7]; // eta Int_t nEtaBins = -1; @@ -163,6 +164,15 @@ AliUEHist::AliUEHist(const char* reqHist, const char* binning) : axis = 0; title = "d^{2}#Sigma p_{T}/d#varphid#eta"; } + else if (TString(reqHist).BeginsWith("TwoPlusOne")) + { + useVtxAxis = 1; + + reqHist = "TwoPlusOne"; + fHistogramType = reqHist; + axis = 3; + title = "d^{2}N_{ch}/d#varphid#eta"; + } else AliFatal(Form("Invalid histogram requested: %s", reqHist)); @@ -215,10 +225,37 @@ AliUEHist::AliUEHist(const char* reqHist, const char* binning) : trackAxisTitle[5] = vertexTitle; } } + else if (axis == 3) + { + nTrackVars = 7; + initRegions = 1; + + iTrackBin[0] = nDeltaEtaBins; + trackBins[0] = deltaEtaBins; + trackAxisTitle[0] = "#Delta#eta"; + + iTrackBin[2] = nLeadingpTBins; + trackBins[2] = leadingpTBins; + trackAxisTitle[2] = "Trigger 1 p_{T} (GeV/c)"; + + trackAxisTitle[3] = "centrality"; + + iTrackBin[4] = nLeadingPhiBins; + trackBins[4] = leadingPhiBins; + trackAxisTitle[4] = "#Delta#varphi (rad)"; + + iTrackBin[5] = nVertexBins; + trackBins[5] = vertexBins; + trackAxisTitle[5] = vertexTitle; + + iTrackBin[6] = nLeadingpTBins2; + trackBins[6] = leadingpTBins2; + trackAxisTitle[6] = "Trigger 2 p_{T} (GeV/c)"; + } for (UInt_t i=0; i= 2) fTrackHist[i] = new AliTHn(Form("fTrackHist_%d", i), title, fgkCFSteps, nTrackVars, iTrackBin); else fTrackHist[i] = new AliCFContainer(Form("fTrackHist_%d", i), title, fgkCFSteps, nTrackVars, iTrackBin); @@ -234,19 +271,23 @@ AliUEHist::AliUEHist(const char* reqHist, const char* binning) : // event level Int_t nEventVars = 2; - Int_t iEventBin[3]; + Int_t iEventBin[4]; // track 3rd and 4th axis --> event 1st and 2nd axis iEventBin[0] = iTrackBin[2]; iEventBin[1] = iTrackBin[3]; // plus track 5th axis (in certain cases) - if (axis == 2 && useVtxAxis) + if (axis >= 2 && useVtxAxis) { nEventVars = 3; iEventBin[2] = iTrackBin[5]; } - + if (axis >= 3) + { + nEventVars = 4; + iEventBin[3] = iTrackBin[6]; + } fEventHist = new AliCFContainer("fEventHist", title, fgkCFSteps, nEventVars, iEventBin); fEventHist->SetBinLimits(0, trackBins[2]); @@ -255,11 +296,16 @@ AliUEHist::AliUEHist(const char* reqHist, const char* binning) : fEventHist->SetBinLimits(1, trackBins[3]); fEventHist->SetVarTitle(1, trackAxisTitle[3]); - if (axis == 2 && useVtxAxis) + if (axis >= 2 && useVtxAxis) { fEventHist->SetBinLimits(2, trackBins[5]); fEventHist->SetVarTitle(2, trackAxisTitle[5]); } + if (axis >= 3) + { + fEventHist->SetBinLimits(3, trackBins[6]); + fEventHist->SetVarTitle(3, trackAxisTitle[6]); + } SetStepNames(fEventHist); @@ -290,7 +336,30 @@ AliUEHist::AliUEHist(const char* reqHist, const char* binning) : delete[] vertexBins; delete[] vertexBinsEff; } + +TString AliUEHist::CombineBinning(TString defaultBinning, TString customBinning) +{ + // combine default binning with custom binning + // replaces binnings in default binning if it is defined in custom binning + + TString binningStr; + TObjArray* lines = defaultBinning.Tokenize("\n"); + for (Int_t i=0; iGetEntriesFast(); i++) + { + TString line(lines->At(i)->GetName()); + TString tag = line(0, line.Index(":")+1); + if (!customBinning.BeginsWith(tag) && !customBinning.Contains(TString("\n") + tag)) + binningStr += line + "\n"; + else + Printf("Using custom binning for %s", tag.Data()); + } + delete lines; + binningStr += customBinning; + + return binningStr; +} + Double_t* AliUEHist::GetBinning(const char* configuration, const char* tag, Int_t& nBins) { // takes the binning from identified by @@ -343,6 +412,7 @@ AliUEHist::AliUEHist(const AliUEHist &c) : fCentralityMax(0), fZVtxMin(0), fZVtxMax(0), + fPt2Min(0), fContaminationEnhancement(0), fCombineMinMax(0), fTrackEtaCut(0), @@ -448,6 +518,7 @@ void AliUEHist::Copy(TObject& c) const target.fCentralityMax = fCentralityMax; target.fZVtxMin = fZVtxMin; target.fZVtxMax = fZVtxMax; + target.fPt2Min = fPt2Min; if (fContaminationEnhancement) target.fContaminationEnhancement = dynamic_cast (fContaminationEnhancement->Clone()); @@ -526,6 +597,8 @@ void AliUEHist::SetBinLimits(THnBase* grid) grid->GetAxis(0)->SetRangeUser(fEtaMin, fEtaMax); if (fPtMax > fPtMin) grid->GetAxis(1)->SetRangeUser(fPtMin, fPtMax); + if (fPt2Min > 0) + grid->GetAxis(6)->SetRangeUser(fPt2Min, grid->GetAxis(6)->GetXmax() - 0.01); } //____________________________________________________________________ @@ -864,7 +937,7 @@ void AliUEHist::GetHistsZVtxMult(AliUEHist::CFStep step, AliUEHist::Region regio } //____________________________________________________________________ -TH2* AliUEHist::GetSumOfRatios2(AliUEHist* mixed, AliUEHist::CFStep step, AliUEHist::Region region, Float_t ptLeadMin, Float_t ptLeadMax, Int_t multBinBegin, Int_t multBinEnd, Bool_t normalizePerTrigger) +TH2* AliUEHist::GetSumOfRatios2(AliUEHist* mixed, AliUEHist::CFStep step, AliUEHist::Region region, Float_t ptLeadMin, Float_t ptLeadMax, Int_t multBinBegin, Int_t multBinEnd, Bool_t normalizePerTrigger, Int_t stepForMixed) { // Calls GetUEHist(...) for *each* vertex bin and multiplicity bin and performs a sum of ratios: // 1_N [ (same/mixed)_1 + (same/mixed)_2 + (same/mixed)_3 + ... ] @@ -874,14 +947,14 @@ TH2* AliUEHist::GetSumOfRatios2(AliUEHist* mixed, AliUEHist::CFStep step, AliUEH // returns a 2D histogram: deltaphi, deltaeta // // Parameters: - // mixed: AliUEHist containing mixed event corresponding to this object + // mixed: AliUEHist containing mixed event corresponding to this object (the histograms are taken from step if defined otherwise from step ) // : check documentation of AliUEHist::GetUEHist // normalizePerTrigger: divide through number of triggers // do not add this hists to the directory Bool_t oldStatus = TH1::AddDirectoryStatus(); TH1::AddDirectory(kFALSE); - + TH2* totalTracks = 0; THnBase* trackSameAll = 0; @@ -895,13 +968,13 @@ TH2* AliUEHist::GetSumOfRatios2(AliUEHist* mixed, AliUEHist::CFStep step, AliUEH Int_t nCorrelationFunctions = 0; GetHistsZVtxMult(step, region, ptLeadMin, ptLeadMax, &trackSameAll, &eventSameAll); - mixed->GetHistsZVtxMult(step, region, ptLeadMin, ptLeadMax, &trackMixedAll, &eventMixedAll); + mixed->GetHistsZVtxMult((stepForMixed == -1) ? step : (CFStep) stepForMixed, region, ptLeadMin, ptLeadMax, &trackMixedAll, &eventMixedAll); // If we ask for histograms from step8 (TTR cut applied) there is a hole at 0,0; so this cannot be used for the // mixed-event normalization. If step6 is available, the normalization factor is read out from that one. // If step6 is not available we fallback to taking the normalization along all delta phi (WARNING requires a // flat delta phi distribution) - if (step == kCFStepBiasStudy && mixed->fEventHist->GetGrid(kCFStepReconstructed)->GetEntries() > 0 && !fSkipScaleMixedEvent) + if (stepForMixed == -1 && step == kCFStepBiasStudy && mixed->fEventHist->GetGrid(kCFStepReconstructed)->GetEntries() > 0 && !fSkipScaleMixedEvent) { Printf("Using mixed-event normalization factors from step %d", kCFStepReconstructed); mixed->GetHistsZVtxMult(kCFStepReconstructed, region, ptLeadMin, ptLeadMax, &trackMixedAllStep6, &eventMixedAllStep6); diff --git a/PWGCF/Correlations/Base/AliUEHist.h b/PWGCF/Correlations/Base/AliUEHist.h index edb83065683..2aeb69ec821 100644 --- a/PWGCF/Correlations/Base/AliUEHist.h +++ b/PWGCF/Correlations/Base/AliUEHist.h @@ -58,7 +58,7 @@ class AliUEHist : public TObject void GetHistsZVtx(AliUEHist::CFStep step, AliUEHist::Region region, Float_t ptLeadMin, Float_t ptLeadMax, Int_t multBinBegin, Int_t multBinEnd, TH3** trackHist, TH1** eventHist); void GetHistsZVtxMult(AliUEHist::CFStep step, AliUEHist::Region region, Float_t ptLeadMin, Float_t ptLeadMax, THnBase** trackHist, TH2** eventHist); - TH2* GetSumOfRatios2(AliUEHist* mixed, AliUEHist::CFStep step, AliUEHist::Region region, Float_t ptLeadMin, Float_t ptLeadMax, Int_t multBinBegin, Int_t multBinEnd, Bool_t normalizePerTrigger = kTRUE); + TH2* GetSumOfRatios2(AliUEHist* mixed, AliUEHist::CFStep step, AliUEHist::Region region, Float_t ptLeadMin, Float_t ptLeadMax, Int_t multBinBegin, Int_t multBinEnd, Bool_t normalizePerTrigger = kTRUE, Int_t stepForMixed = -1); TH1* GetTriggersAsFunctionOfMultiplicity(AliUEHist::CFStep step, Float_t ptLeadMin, Float_t ptLeadMax); @@ -106,6 +106,7 @@ class AliUEHist : public TObject void SetPartSpecies(Int_t species) { fPartSpecies = species;} void SetCentralityRange(Float_t min, Float_t max) { fCentralityMin = min; fCentralityMax = max; } void SetZVtxRange(Float_t min, Float_t max) { fZVtxMin = min; fZVtxMax = max; } + void SetPt2Min(Float_t ptMin) { fPt2Min = ptMin; } Float_t GetTrackEtaCut() { return fTrackEtaCut; } void SetTrackEtaCut(Float_t value) { fTrackEtaCut = value; } @@ -137,6 +138,8 @@ class AliUEHist : public TObject void Reset(); THnBase* ChangeToThn(THnBase* sparse); + static TString CombineBinning(TString defaultBinning, TString customBinning); + protected: Double_t* GetBinning(const char* configuration, const char* tag, Int_t& nBins); void SetStepNames(AliCFContainer* container); @@ -157,6 +160,7 @@ protected: Float_t fCentralityMax; // centrality max for projections Float_t fZVtxMin; // z vtx min for projections Float_t fZVtxMax; // z vtx max for projections + Float_t fPt2Min; // pT min for projections (for pT,2 (only 2+1 corr case)) TH1F* fContaminationEnhancement; // histogram that contains the underestimation of secondaries in the MC as function of pT @@ -172,7 +176,7 @@ protected: TString fHistogramType; // what is stored in this histogram - ClassDef(AliUEHist, 14) // underlying event histogram container + ClassDef(AliUEHist, 15) // underlying event histogram container }; #endif diff --git a/PWGCF/Correlations/Base/AliUEHistograms.cxx b/PWGCF/Correlations/Base/AliUEHistograms.cxx index 61b896f22f9..a78ed4edbfd 100644 --- a/PWGCF/Correlations/Base/AliUEHistograms.cxx +++ b/PWGCF/Correlations/Base/AliUEHistograms.cxx @@ -130,21 +130,7 @@ AliUEHistograms::AliUEHistograms(const char* name, const char* histograms, const ; // combine customBinning with defaultBinningStr -> use customBinning where available and otherwise defaultBinningStr - TString customBinning(binning); - TString binningStr; - - TObjArray* lines = defaultBinningStr.Tokenize("\n"); - for (Int_t i=0; iGetEntriesFast(); i++) - { - TString line(lines->At(i)->GetName()); - TString tag = line(0, line.Index(":")+1); - if (!customBinning.BeginsWith(tag) && !customBinning.Contains(TString("\n") + tag)) - binningStr += line + "\n"; - else - Printf("Using custom binning for %s", tag.Data()); - } - delete lines; - binningStr += customBinning; + TString binningStr = AliUEHist::CombineBinning(defaultBinningStr, TString(binning)); if (histogramsStr.Contains("1")) fNumberDensitypT = new AliUEHist("NumberDensitypT", binningStr); diff --git a/PWGCF/Correlations/DPhi/AliAnalysisTaskTwoPlusOne.cxx b/PWGCF/Correlations/DPhi/AliAnalysisTaskTwoPlusOne.cxx new file mode 100644 index 00000000000..d5ef423ed61 --- /dev/null +++ b/PWGCF/Correlations/DPhi/AliAnalysisTaskTwoPlusOne.cxx @@ -0,0 +1,264 @@ +#include +#include +#include +#include +#include +#include +//#include + +#include "AliAnalysisTaskTwoPlusOne.h" +#include "AliCFParticle.h" +#include "AliAnalyseLeadingTrackUE.h" +#include "AliTwoPlusOneContainer.h" +#include "AliUEHist.h" + +#include "AliAODHandler.h" +#include "AliAODInputHandler.h" +#include "AliVParticle.h" +#include "AliCFContainer.h" + +#include "AliEventPoolManager.h" + + +ClassImp( AliAnalysisTaskTwoPlusOne ) + +//________________________________________________________________________ +AliAnalysisTaskTwoPlusOne::AliAnalysisTaskTwoPlusOne(const char *name) +: AliAnalysisTaskSE(name), + fMixingTracks(10000), + fAnalyseUE(0x0), +// pointers to UE classes + fHistos(0x0), +// handlers and events + fAOD(0x0), + fPoolMgr(0x0), +// histogram settings + fListOfHistos(0x0), +// event QA + fnTracksVertex(1), // QA tracks pointing to principal vertex (= 3 default) + fZVertex(7.), + fCentralityMethod("V0M"), +// track cuts + fTrackEtaCut(0.9), + fTrackEtaCutMin(-1.), + fPtMin(0.5), + fDCAXYCut(0), + fSharedClusterCut(-1), + fCrossedRowsCut(-1), + fFoundFractionCut(-1), + fFilterBit(0xFF), + fTrackStatus(0), + fSelectBit(AliVEvent::kMB|AliVEvent::kUserDefined), + fCustomBinning(), + fAlpha(0.2) +{ + + DefineOutput(1, TList::Class()); +} + +//________________________________________________________________________ +AliAnalysisTaskTwoPlusOne::~AliAnalysisTaskTwoPlusOne() +{ + // Destructor + +} + +//________________________________________________________________________ +void AliAnalysisTaskTwoPlusOne::UserCreateOutputObjects() +{ + // Initialize class with main algorithms, event and track selection. + fAnalyseUE = new AliAnalyseLeadingTrackUE(); + fAnalyseUE->SetParticleSelectionCriteria(fFilterBit, kFALSE, fTrackEtaCut, fTrackEtaCutMin, fPtMin); + fAnalyseUE->SetDCAXYCut(fDCAXYCut); + fAnalyseUE->SetSharedClusterCut(fSharedClusterCut); + fAnalyseUE->SetCrossedRowsCut(fCrossedRowsCut); + fAnalyseUE->SetFoundFractionCut(fFoundFractionCut); + fAnalyseUE->SetTrackStatus(fTrackStatus); + fAnalyseUE->SetDebug(fDebug); + fAnalyseUE->DefineESDCuts(fFilterBit); + fAnalyseUE->SetEventSelection(fSelectBit); + + fListOfHistos = new TList(); + fListOfHistos->SetOwner(kTRUE); + + fHistos = new AliTwoPlusOneContainer("AliTwoPlusOneContainer", fCustomBinning, fAlpha); + fHistos->GetData()->SetTrackEtaCut(fTrackEtaCut); + + fListOfHistos->Add(fHistos); + + fListOfHistos->Add(new TH1F("eventStat", ";;events", 4, -0.5, 3.5)); + + PostData(1,fListOfHistos); + + // Add task configuration to output list + AddSettingsTree(); + + // event mixing + Int_t poolsize = 1000; // Maximum number of events, ignored in the present implemention of AliEventPoolManager + + Int_t nCentralityBins = fHistos->GetData()->GetTrackHist(AliUEHist::kToward)->GetNBins(3); + + + Double_t* centralityBins = (Double_t*) fHistos->GetData()->GetTrackHist(AliUEHist::kToward)->GetAxis(3, 0)->GetXbins()->GetArray(); + + Int_t nZvtxBins = fHistos->GetData()->GetTrackHist(AliUEHist::kToward)->GetNBins(5); + + Double_t* zvtxbin = (Double_t*) fHistos->GetData()->GetTrackHist(AliUEHist::kToward)->GetAxis(5, 0)->GetXbins()->GetArray(); + + fPoolMgr = new AliEventPoolManager(poolsize, fMixingTracks, nCentralityBins, centralityBins, nZvtxBins, zvtxbin); + fPoolMgr->SetTargetValues(fMixingTracks, 0.1, 5); +} + +//________________________________________________________________________ +void AliAnalysisTaskTwoPlusOne::UserExec(Option_t *) +{ + // exec (per event) + fAnalyseUE->NextEvent(); + + ((TH1F*) fListOfHistos->FindObject("eventStat"))->Fill(0); + + // Support for AOD based analysis + fAOD = dynamic_cast (InputEvent()); + + Double_t centrality = 0; + AliCentrality *centralityObj = 0; + + centralityObj = fAOD->GetHeader()->GetCentralityP(); + + + if (centralityObj) + centrality = centralityObj->GetCentralityPercentile(fCentralityMethod); + else + centrality = -1; + + if (fAOD){ + // remove outliers + if (centrality == 0) + { + if (fAOD->GetVZEROData()) + { + Float_t multV0 = 0; + for (Int_t i=0; i<64; i++) + multV0 += fAOD->GetVZEROData()->GetMultiplicity(i); + if (multV0 < 19500) + { + centrality = -1; + AliInfo("Rejecting event due to too small V0 multiplicity"); + } + } + } + } + + + AliInfo(Form("Centrality is %f", centrality)); + + + // Vertex selection ************************************************* + if(!fAnalyseUE->VertexSelection(InputEvent(), fnTracksVertex, fZVertex)) return; + + // optimization + if (centrality < 0) + return; + + TObjArray* tracks = fAnalyseUE->GetAcceptedParticles(InputEvent(), 0, kTRUE, -1, kTRUE); + // create a list of reduced objects. This speeds up processing and reduces memory consumption for the event pool + TObjArray* tracksClone = CloneAndReduceTrackList(tracks); + delete tracks; + + const AliVVertex* vertex = InputEvent()->GetPrimaryVertex(); + Double_t zVtx = vertex->GetZ(); + + fHistos->FillCorrelations(centrality, zVtx, AliTwoPlusOneContainer::kSameNS, tracksClone, tracksClone, tracksClone, tracksClone, 1.0);//same event for near and away side + + ((TH1F*) fListOfHistos->FindObject("eventStat"))->Fill(1); + + // event mixing + + // 1. First get an event pool corresponding in mult (cent) and + // zvertex to the current event. Once initialized, the pool + // should contain nMix (reduced) events. This routine does not + // pre-scan the chain. The first several events of every chain + // will be skipped until the needed pools are filled to the + // specified depth. If the pool categories are not too rare, this + // should not be a problem. If they are rare, you could lose + // statistics. + + // 2. Collect the whole pool's content of tracks into one TObjArray + // (bgTracks), which is effectively a single background super-event. + + // 3. The reduced and bgTracks arrays must both be passed into + // FillCorrelations(). Also nMix should be passed in, so a weight + // of 1./nMix can be applied. + + AliEventPool* pool = fPoolMgr->GetEventPool(centrality, zVtx); + + if (!pool) + AliFatal(Form("No pool found for centrality = %f, zVtx = %f", centrality, zVtx)); + if (pool->IsReady()){ + Int_t nMix = pool->GetCurrentNEvents(); + + ((TH1F*) fListOfHistos->FindObject("eventStat"))->Fill(2); + + // Fill mixed-event histos here + for (Int_t jMix=0; jMixGetEvent(jMix); + + fHistos->FillCorrelations(centrality, zVtx, AliTwoPlusOneContainer::kMixedNS, tracksClone, bgTracks, tracksClone, bgTracks, 1.0 / nMix); + } + } + + // ownership is with the pool now + pool->UpdatePool(tracksClone); +} + +//________________________________________________________________________ +void AliAnalysisTaskTwoPlusOne::Terminate(Option_t*) +{ + //terminate function is called at the end + //can be used to draw histograms etc. + + +} + + +TObjArray* AliAnalysisTaskTwoPlusOne::CloneAndReduceTrackList(TObjArray* tracks) +{ + // clones a track list by using AliCFParticle which uses much less memory (used for event mixing) + + TObjArray* tracksClone = new TObjArray; + tracksClone->SetOwner(kTRUE); + + for (Int_t i=0; iGetEntriesFast(); i++) + { + AliVParticle* particle = (AliVParticle*) tracks->UncheckedAt(i); + AliCFParticle* copy = new AliCFParticle(particle->Pt(), particle->Eta(), particle->Phi(), particle->Charge(), 0); + copy->SetUniqueID(particle->GetUniqueID()); + tracksClone->Add(copy); + } + + return tracksClone; +} + + +//____________________________________________________________________ +void AliAnalysisTaskTwoPlusOne::AddSettingsTree() +{ + //Write settings to output list + TTree *settingsTree = new TTree("UEAnalysisSettings","Analysis Settings in UE estimation"); + settingsTree->Branch("fnTracksVertex", &fnTracksVertex,"nTracksVertex/I"); + settingsTree->Branch("fZVertex", &fZVertex,"ZVertex/D"); + //settingsTree->Branch("fCentralityMethod", fCentralityMethod.Data(),"CentralityMethod/C"); + settingsTree->Branch("fTrackEtaCut", &fTrackEtaCut, "TrackEtaCut/D"); + settingsTree->Branch("fTrackEtaCutMin", &fTrackEtaCutMin, "TrackEtaCutMin/D"); + settingsTree->Branch("fPtMin", &fPtMin, "PtMin/D"); + settingsTree->Branch("fFilterBit", &fFilterBit,"FilterBit/I"); + settingsTree->Branch("fSharedClusterCut", &fSharedClusterCut,"SharedClusterCut/D"); + settingsTree->Branch("fCrossedRowsCut", &fCrossedRowsCut,"CrossedRowsCut/I"); + settingsTree->Branch("fFoundFractionCut", &fFoundFractionCut,"FoundFractionCut/D"); + settingsTree->Branch("fTrackStatus", &fTrackStatus,"TrackStatus/I"); + settingsTree->Branch("fSelectBit", &fSelectBit,"EventSelectionBit/I"); + settingsTree->Branch("fMixingTracks", &fMixingTracks,"MixingTracks/I"); + + settingsTree->Fill(); + fListOfHistos->Add(settingsTree); +} diff --git a/PWGCF/Correlations/DPhi/AliAnalysisTaskTwoPlusOne.h b/PWGCF/Correlations/DPhi/AliAnalysisTaskTwoPlusOne.h new file mode 100644 index 00000000000..b2329fde3ac --- /dev/null +++ b/PWGCF/Correlations/DPhi/AliAnalysisTaskTwoPlusOne.h @@ -0,0 +1,115 @@ +#ifndef ALIANALYSISTASKTWOPLUSONE_H +#define ALIANALYSISTASKTWOPLUSONE_H + +class TList; +class TH1F; +class TH2F; +class TProfile; +class THnSparse; +class AliESDtrackCuts; + +#include "AliAnalysisTaskSE.h" +#include "AliTwoPlusOneContainer.h" +#include "TString.h" +#include "AliVParticle.h" +#include "AliLog.h" +#include "THn.h" + +class AliAODEvent; +class AliAnalyseLeadingTrackUE; +class AliInputEventHandler; +class AliMCEvent; +class AliMCEventHandler; +class AliTwoPlusOneContainer; +class AliVParticle; +class TH1; +class TObjArray; +class AliEventPoolManager; +class AliESDEvent; +class AliHelperPID; +class AliAnalysisUtils; +class TFormula; +class TMap; +class AliGenEventHeader; + +class AliAnalysisTaskTwoPlusOne : public AliAnalysisTaskSE { + public: + AliAnalysisTaskTwoPlusOne(const char *name="AliAnalysisTaskTwoPlusOne"); + virtual ~AliAnalysisTaskTwoPlusOne(); + + virtual void UserCreateOutputObjects(); + virtual void UserExec(Option_t* option); + virtual void Terminate(Option_t *); + + // Setters/Getters + // general configuration + void SetMixingTracks(Int_t tracks) { fMixingTracks = tracks; } + void SetTracksInVertex( Int_t val ){ fnTracksVertex = val; } + void SetZVertex( Double_t val ) { fZVertex = val; } + + // track cuts + void SetTrackEtaCut( Double_t val ) { fTrackEtaCut = val; } + void SetTrackEtaCutMin( Double_t val ) { fTrackEtaCutMin = val; } + void SetPtMin(Double_t val) { fPtMin = val; } + void SetFilterBit( UInt_t val ) { fFilterBit = val; } + void SetDCAXYCut(TFormula* value) { fDCAXYCut = value; } + void SetSharedClusterCut(Float_t value) { fSharedClusterCut = value; } + void SetCrossedRowsCut(Int_t value) { fCrossedRowsCut = value; } + void SetFoundFractionCut(Double_t value) { fFoundFractionCut = value; } + void SetTrackStatus(UInt_t status) { fTrackStatus = status; } + + void SetEventSelectionBit( UInt_t val ) { fSelectBit = val; } + + void SetCentralityMethod(const char* method) { fCentralityMethod = method; } + + void SetCustomBinning(const char* binningStr) { fCustomBinning = binningStr; } + + void SetAlpha(Double_t val){fAlpha = val; } + + private: + void AddSettingsTree(); // add list of settings to output list + + TObjArray* CloneAndReduceTrackList(TObjArray* tracks); + + //general configuration + Int_t fMixingTracks; // size of track buffer for event mixing + + // Pointers to external UE classes + AliAnalyseLeadingTrackUE* fAnalyseUE; //! points to class containing common analysis algorithms + AliTwoPlusOneContainer* fHistos;// Histogram class based on UEHist + + // Handlers and events + AliAODEvent* fAOD; //! AOD Event + AliEventPoolManager* fPoolMgr; //! event pool manager + + // Histogram settings + TList* fListOfHistos; // Output list of containers + + // Event QA cuts + Int_t fnTracksVertex; // QA tracks pointing to principal vertex + Double_t fZVertex; // Position of Vertex in Z direction + TString fCentralityMethod; // Method to determine centrality + + // Track cuts + Double_t fTrackEtaCut; // Maximum Eta cut on particles + Double_t fTrackEtaCutMin; // Minimum Eta cut on particles + Double_t fPtMin; // Min pT to start correlations + TFormula* fDCAXYCut; // additional pt dependent cut on DCA XY (only for AOD) + Double_t fSharedClusterCut; // cut on shared clusters (only for AOD) + Int_t fCrossedRowsCut; // cut on crossed rows (only for AOD) + Double_t fFoundFractionCut; // cut on crossed rows/findable clusters (only for AOD) + UInt_t fFilterBit; // Select tracks from an specific track cut + UInt_t fTrackStatus; // if non-0, the bits set in this variable are required for each track + UInt_t fSelectBit; // Select events according to AliAnalysisTaskJetServices bit maps + + TString fCustomBinning; // supersedes default binning if set, see AliUEHist::GetBinning or AliUEHistograms::AliUEHistograms for syntax and examples + Double_t fAlpha; //sets the alpha parameter in the container + + AliAnalysisTaskTwoPlusOne(const AliAnalysisTaskTwoPlusOne&); // not implemented + AliAnalysisTaskTwoPlusOne& operator=(const AliAnalysisTaskTwoPlusOne&); // not implemented + + + ClassDef(AliAnalysisTaskTwoPlusOne, 1); // two plus one analysis with two trigger particles and particle correlations to these triggers +}; + +#endif diff --git a/PWGCF/Correlations/macros/twoplusone/AddTaskTwoPlusOne.C b/PWGCF/Correlations/macros/twoplusone/AddTaskTwoPlusOne.C new file mode 100644 index 00000000000..625639913ca --- /dev/null +++ b/PWGCF/Correlations/macros/twoplusone/AddTaskTwoPlusOne.C @@ -0,0 +1,37 @@ +AliAnalysisTaskTwoPlusOne *AddTaskTwoPlusOne(const char* outputFileName = 0, Double_t alpha = 0.2, const char* containerName = "histosTwoPlusOne", const char* folderName = "PWGCF_TwoPlusOne") +{ + // Get the pointer to the existing analysis manager via the static access method. + //============================================================================== + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + if (!mgr) { ::Error("AddTaskTwoPlusOne", "No analysis manager to connect to."); + return NULL; + } + + // Create the task and configure it. + //=========================================================================== + AliAnalysisTaskTwoPlusOne* ana = new AliAnalysisTaskTwoPlusOne(containerName); + + Int_t bit = 32 | 64; + ana->SetFilterBit(bit); + + Printf("AddTaskTwoPlusOne:\n\n\n++++++++++ Using bit %d ++++++++++++\n\n\n", bit); + + ana->SetAlpha(alpha); + + ana->SelectCollisionCandidates(AliVEvent::kMB); + + mgr->AddTask(ana); + + // Create ONLY the output containers for the data produced by the task. + // Get and connect other common input/output containers via the manager as below + //============================================================================== + if (!outputFileName) + outputFileName = AliAnalysisManager::GetCommonFileName(); + + AliAnalysisDataContainer *coutput = mgr->CreateContainer(containerName, TList::Class(),AliAnalysisManager::kOutputContainer,Form("%s:%s", outputFileName, folderName)); + + mgr->ConnectInput (ana, 0, mgr->GetCommonInputContainer()); + mgr->ConnectOutput (ana, 1, coutput ); + + return ana; +} diff --git a/PWGCF/Correlations/macros/twoplusone/output_TwoPlusOne.C b/PWGCF/Correlations/macros/twoplusone/output_TwoPlusOne.C new file mode 100644 index 00000000000..79af9b8b222 --- /dev/null +++ b/PWGCF/Correlations/macros/twoplusone/output_TwoPlusOne.C @@ -0,0 +1,92 @@ +Float_t gpTMin_T1 = 6.0; +Float_t gpTMax_T1 = 14.0; +Float_t gpTMin_T2 = 4.0; +Float_t gpTMax_T2 = 10.0; +Float_t gpTMin_assoc = 1.0; +Float_t gpTMax_assoc = 6.0; +Float_t gZVtxRange = -1; +Float_t gAxis = 4; + +void loadlibs() +{ + gSystem->Load("libANALYSIS"); + gSystem->Load("libANALYSISalice"); + gSystem->Load("libCORRFW"); + gSystem->Load("libPWGTools"); + gSystem->Load("libPWGCFCorrelationsBase"); +} + +void* events = 0; + +void* GetTwoPlusOne(const char* fileName, TList** listRef = 0, Bool_t mixed = kFALSE, const char* tag = "") +{ + file = TFile::Open(fileName); + if (!file) + return 0; + + list = (TList*) gFile->Get("PWGCF_TwoPlusOne/histosTwoPlusOne"); + + if (!list) + return 0; + + if (listRef) + *listRef = list; + + return events = list->FindObject("AliTwoPlusOneContainer"); +} + +void PlotQA(const char* fileName, const char* tag = "") +{ + loadlibs(); + + TFile::Open(fileName); + + AliTwoPlusOneContainer* h = (AliTwoPlusOneContainer*) GetTwoPlusOne(fileName, 0, kFALSE, tag); + + if (h->GetData()->GetTrackHist(0)->GetGrid(6)->GetGrid()->GetNbins() == 0) + { + Printf("We have %d axes", ((AliTHn*) h->GetData()->GetTrackHist(0)->GetNVar())); + + ((AliTHn*) h->GetData()->GetTrackHist(0))->FillParent(); + ((AliTHn*) h->GetData()->GetTrackHist(0))->DeleteContainers(); + } + + TCanvas* c1 = new TCanvas("can1", "can1", 1200, 800); + c1->Divide(2, 1); + + c1->cd(1); + AliCFGridSparse* near_plot = h->GetData()->GetTrackHist(0)->GetGrid((AliUEHist::CFStep) AliTwoPlusOneContainer::kSameNS); + //near_plot->SetRangeUser(2, gpTMin_T1, gpTMax_T1); + //near_plot->SetRangeUser(6, gpTMin_T2, gpTMax_T2); + //near_plot->SetRangeUser(1, gpTMin_assoc, gpTMax_assoc); + TH1D* tracks_near = near_plot->Project(gAxis); + + tracks_near->DrawCopy(); + c1->cd(2); + + Printf("\n output_TwoPlusOne: entries %f \n", h->GetData()->GetTrackHist(AliUEHist::kToward)->GetGrid((AliUEHist::CFStep) AliTwoPlusOneContainer::kSameNS)->Project(1)->GetEntries()); + + AliCFGridSparse* away_plot = h->GetData()->GetTrackHist(0)->GetGrid((AliUEHist::CFStep) AliTwoPlusOneContainer::kMixedNS); + //away_plot->SetRangeUser(2, gpTMin_T1, gpTMax_T1); + //away_plot->SetRangeUser(6, gpTMin_T2, gpTMax_T2); + //away_plot->SetRangeUser(1, gpTMin_assoc, gpTMax_assoc); + TH1D* tracks_away = away_plot->Project(gAxis); + tracks_away->DrawCopy(); + + AliCFGridSparse* trigger = (AliCFGridSparse*) h->GetData()->GetEventHist()->GetGrid((AliUEHist::CFStep) AliTwoPlusOneContainer::kSameNS); + //trigger->SetRangeUser(0, gpTMin_T1, gpTMax_T1); + + TCanvas* c2 = new TCanvas("can2", "can2", 900, 600); + TH1D* trigger_hist = trigger->Project(0); + trigger_hist->DrawCopy(); + + + TCanvas* c3 = new TCanvas("can3", "can3", 900, 600); + TH2* h2_near = h->GetData()->GetSumOfRatios2(h->GetData(), (AliUEHist::CFStep) AliTwoPlusOneContainer::kSameNS, 0, 4.0, 14.0, 0, 100, kFALSE, (AliUEHist::CFStep) AliTwoPlusOneContainer::kMixedNS); + + h2_near->DrawCopy("surf1"); +} + + + + diff --git a/PWGCF/PWGCFCorrelationsBaseLinkDef.h b/PWGCF/PWGCFCorrelationsBaseLinkDef.h index 541c227a804..36207b13c1a 100644 --- a/PWGCF/PWGCFCorrelationsBaseLinkDef.h +++ b/PWGCF/PWGCFCorrelationsBaseLinkDef.h @@ -9,5 +9,6 @@ #pragma link C++ class AliAnalyseLeadingTrackUE+; #pragma link C++ class AliCFParticle+; #pragma link C++ class AliAnalysisTaskCFTree+; +#pragma link C++ class AliTwoPlusOneContainer+; #endif diff --git a/PWGCF/PWGCFCorrelationsDPhiLinkDef.h b/PWGCF/PWGCFCorrelationsDPhiLinkDef.h index bce206d4e67..25b492ada7f 100644 --- a/PWGCF/PWGCFCorrelationsDPhiLinkDef.h +++ b/PWGCF/PWGCFCorrelationsDPhiLinkDef.h @@ -9,6 +9,7 @@ #pragma link C++ class AliDptDptInMC+; #pragma link C++ class AliAnalysisTask3PCorrelations+; #pragma link C++ class AliAnalysisTaskPhiCorrelations+; +#pragma link C++ class AliAnalysisTaskTwoPlusOne+; #pragma link C++ class AliDPhiBasicParticle+; #pragma link C++ class AliPhiCorrelationsQATask+; #pragma link C++ class AliAnalysisTaskLeadingTrackUE+; -- 2.43.5