#include "TProfile.h"
#include "TMath.h" //needed as include
#include "TList.h"
+#include "TH2F.h"
#include "AliFlowVector.h"
#include "TBrowser.h"
//-----------------------------------------------------------------------
-AliFlowCommonHist::AliFlowCommonHist():TNamed(),
+AliFlowCommonHist::AliFlowCommonHist():
+ TNamed(),
fHistMultOrig(NULL),
- fHistMultInt(NULL),
- fHistMultDiff(NULL),
- fHistPtInt(NULL),
- fHistPtDiff(NULL),
- fHistPhiInt(NULL),
- fHistPhiDiff(NULL),
- fHistEtaInt(NULL),
- fHistEtaDiff(NULL),
+ fHistMultRP(NULL),
+ fHistMultPOI(NULL),
+ fHistPtRP(NULL),
+ fHistPtPOI(NULL),
+ fHistPtSub0(NULL),
+ fHistPtSub1(NULL),
+ fHistPhiRP(NULL),
+ fHistPhiPOI(NULL),
+ fHistPhiSub0(NULL),
+ fHistPhiSub1(NULL),
+ fHistEtaRP(NULL),
+ fHistEtaPOI(NULL),
+ fHistEtaSub0(NULL),
+ fHistEtaSub1(NULL),
+ fHistPhiEtaRP(NULL),
+ fHistPhiEtaPOI(NULL),
fHistProMeanPtperBin(NULL),
fHistQ(NULL),
+ fHarmonic(NULL),
fHistList(NULL)
{
AliFlowCommonHist::AliFlowCommonHist(const AliFlowCommonHist& a):
TNamed(),
fHistMultOrig(new TH1F(*a.fHistMultOrig)),
- fHistMultInt(new TH1F(*a.fHistMultInt)),
- fHistMultDiff(new TH1F(*a.fHistMultDiff)),
- fHistPtInt(new TH1F(*a.fHistPtInt)),
- fHistPtDiff(new TH1F(*a.fHistPtDiff)),
- fHistPhiInt(new TH1F(*a.fHistPhiInt)),
- fHistPhiDiff(new TH1F(*a.fHistPhiDiff)),
- fHistEtaInt(new TH1F(*a.fHistEtaInt)),
- fHistEtaDiff(new TH1F(*a.fHistEtaDiff)),
+ fHistMultRP(new TH1F(*a.fHistMultRP)),
+ fHistMultPOI(new TH1F(*a.fHistMultPOI)),
+ fHistPtRP(new TH1F(*a.fHistPtRP)),
+ fHistPtPOI(new TH1F(*a.fHistPtPOI)),
+ fHistPtSub0(new TH1F(*a.fHistPtSub0)),
+ fHistPtSub1(new TH1F(*a.fHistPtSub1)),
+ fHistPhiRP(new TH1F(*a.fHistPhiRP)),
+ fHistPhiPOI(new TH1F(*a.fHistPhiPOI)),
+ fHistPhiSub0(new TH1F(*a.fHistPhiSub0)),
+ fHistPhiSub1(new TH1F(*a.fHistPhiSub1)),
+ fHistEtaRP(new TH1F(*a.fHistEtaRP)),
+ fHistEtaPOI(new TH1F(*a.fHistEtaPOI)),
+ fHistEtaSub0(new TH1F(*a.fHistEtaSub0)),
+ fHistEtaSub1(new TH1F(*a.fHistEtaSub1)),
+ fHistPhiEtaRP(new TH2F(*a.fHistPhiEtaRP)),
+ fHistPhiEtaPOI(new TH2F(*a.fHistPhiEtaPOI)),
fHistProMeanPtperBin(new TProfile(*a.fHistProMeanPtperBin)),
fHistQ(new TH1F(*a.fHistQ)),
+ fHarmonic(new TProfile(*a.fHarmonic)),
fHistList(NULL)
{
// copy constructor
fHistList = new TList();
fHistList-> Add(fHistMultOrig);
- fHistList-> Add(fHistMultInt);
- fHistList-> Add(fHistMultDiff);
- fHistList-> Add(fHistPtInt);
- fHistList-> Add(fHistPtDiff);
- fHistList-> Add(fHistPhiInt);
- fHistList-> Add(fHistPhiDiff);
- fHistList-> Add(fHistEtaInt);
- fHistList-> Add(fHistEtaDiff);
+ fHistList-> Add(fHistMultRP);
+ fHistList-> Add(fHistMultPOI);
+ fHistList-> Add(fHistPtRP);
+ fHistList-> Add(fHistPtPOI);
+ fHistList-> Add(fHistPtSub0);
+ fHistList-> Add(fHistPtSub1);
+ fHistList-> Add(fHistPhiRP);
+ fHistList-> Add(fHistPhiPOI);
+ fHistList-> Add(fHistPhiSub0);
+ fHistList-> Add(fHistPhiSub1);
+ fHistList-> Add(fHistEtaRP);
+ fHistList-> Add(fHistEtaPOI);
+ fHistList-> Add(fHistEtaSub0);
+ fHistList-> Add(fHistEtaSub1);
+ fHistList-> Add(fHistPhiEtaRP);
+ fHistList-> Add(fHistPhiEtaPOI);
fHistList-> Add(fHistProMeanPtperBin);
+ fHistList-> Add(fHarmonic);
fHistList-> Add(fHistQ);
// TListIter next = TListIter(a.fHistList);
//-----------------------------------------------------------------------
- AliFlowCommonHist::AliFlowCommonHist(const char *anInput,const char *title):TNamed(anInput,title),
- fHistMultOrig(NULL),
- fHistMultInt(NULL),
- fHistMultDiff(NULL),
- fHistPtInt(NULL),
- fHistPtDiff(NULL),
- fHistPhiInt(NULL),
- fHistPhiDiff(NULL),
- fHistEtaInt(NULL),
- fHistEtaDiff(NULL),
- fHistProMeanPtperBin(NULL),
- fHistQ(NULL),
- fHistList(NULL)
- {
+ AliFlowCommonHist::AliFlowCommonHist(const char *anInput,const char *title):
+ TNamed(anInput,title),
+ fHistMultOrig(NULL),
+ fHistMultRP(NULL),
+ fHistMultPOI(NULL),
+ fHistPtRP(NULL),
+ fHistPtPOI(NULL),
+ fHistPtSub0(NULL),
+ fHistPtSub1(NULL),
+ fHistPhiRP(NULL),
+ fHistPhiPOI(NULL),
+ fHistPhiSub0(NULL),
+ fHistPhiSub1(NULL),
+ fHistEtaRP(NULL),
+ fHistEtaPOI(NULL),
+ fHistEtaSub0(NULL),
+ fHistEtaSub1(NULL),
+ fHistPhiEtaRP(NULL),
+ fHistPhiEtaPOI(NULL),
+ fHistProMeanPtperBin(NULL),
+ fHistQ(NULL),
+ fHarmonic(NULL),
+ fHistList(NULL)
+{
//constructor creating histograms
- Int_t iNbinsMult = AliFlowCommonConstants::GetNbinsMult();
- Int_t iNbinsPt = AliFlowCommonConstants::GetNbinsPt();
- Int_t iNbinsPhi = AliFlowCommonConstants::GetNbinsPhi();
- Int_t iNbinsEta = AliFlowCommonConstants::GetNbinsEta();
- Int_t iNbinsQ = AliFlowCommonConstants::GetNbinsQ();
+ Int_t iNbinsMult = AliFlowCommonConstants::GetMaster()->GetNbinsMult();
+ Int_t iNbinsPt = AliFlowCommonConstants::GetMaster()->GetNbinsPt();
+ Int_t iNbinsPhi = AliFlowCommonConstants::GetMaster()->GetNbinsPhi();
+ Int_t iNbinsEta = AliFlowCommonConstants::GetMaster()->GetNbinsEta();
+ Int_t iNbinsQ = AliFlowCommonConstants::GetMaster()->GetNbinsQ();
TString sName;
- Double_t dMultMin = AliFlowCommonConstants::GetMultMin();
- Double_t dMultMax = AliFlowCommonConstants::GetMultMax();
- Double_t dPtMin = AliFlowCommonConstants::GetPtMin();
- Double_t dPtMax = AliFlowCommonConstants::GetPtMax();
- Double_t dPhiMin = AliFlowCommonConstants::GetPhiMin();
- Double_t dPhiMax = AliFlowCommonConstants::GetPhiMax();
- Double_t dEtaMin = AliFlowCommonConstants::GetEtaMin();
- Double_t dEtaMax = AliFlowCommonConstants::GetEtaMax();
- Double_t dQMin = AliFlowCommonConstants::GetQMin();
- Double_t dQMax = AliFlowCommonConstants::GetQMax();
+ Double_t dMultMin = AliFlowCommonConstants::GetMaster()->GetMultMin();
+ Double_t dMultMax = AliFlowCommonConstants::GetMaster()->GetMultMax();
+ Double_t dPtMin = AliFlowCommonConstants::GetMaster()->GetPtMin();
+ Double_t dPtMax = AliFlowCommonConstants::GetMaster()->GetPtMax();
+ Double_t dPhiMin = AliFlowCommonConstants::GetMaster()->GetPhiMin();
+ Double_t dPhiMax = AliFlowCommonConstants::GetMaster()->GetPhiMax();
+ Double_t dEtaMin = AliFlowCommonConstants::GetMaster()->GetEtaMin();
+ Double_t dEtaMax = AliFlowCommonConstants::GetMaster()->GetEtaMax();
+ Double_t dQMin = AliFlowCommonConstants::GetMaster()->GetQMin();
+ Double_t dQMax = AliFlowCommonConstants::GetMaster()->GetQMax();
cout<<"The settings for the common histograms are as follows:"<<endl;
cout<<"Multiplicity: "<<iNbinsMult<<" bins between "<<dMultMin<<" and "<<dMultMax<<endl;
fHistMultOrig ->SetXTitle("Original Multiplicity");
fHistMultOrig ->SetYTitle("Counts");
- sName = "Control_Flow_MultInt_";
+ sName = "Control_Flow_MultRP_";
sName +=anInput;
- fHistMultInt = new TH1F(sName.Data(), sName.Data(),iNbinsMult, dMultMin, dMultMax);
- fHistMultInt ->SetXTitle("Multiplicity for integrated flow");
- fHistMultInt ->SetYTitle("Counts");
+ fHistMultRP = new TH1F(sName.Data(), sName.Data(),iNbinsMult, dMultMin, dMultMax);
+ fHistMultRP ->SetXTitle("Multiplicity for RP selection");
+ fHistMultRP ->SetYTitle("Counts");
- sName = "Control_Flow_MultDiff_";
+ sName = "Control_Flow_MultPOI_";
sName +=anInput;
- fHistMultDiff = new TH1F(sName.Data(), sName.Data(),iNbinsMult, dMultMin, dMultMax);
- fHistMultDiff ->SetXTitle("Multiplicity for differential flow");
- fHistMultDiff ->SetYTitle("Counts");
+ fHistMultPOI = new TH1F(sName.Data(), sName.Data(),iNbinsMult, dMultMin, dMultMax);
+ fHistMultPOI ->SetXTitle("Multiplicity for POI selection");
+ fHistMultPOI ->SetYTitle("Counts");
//Pt
- sName = "Control_Flow_PtInt_";
+ sName = "Control_Flow_PtRP_";
sName +=anInput;
- fHistPtInt = new TH1F(sName.Data(), sName.Data(),iNbinsPt, dPtMin, dPtMax);
- fHistPtInt ->SetXTitle("P_{t} (GeV/c) for integrated flow");
- fHistPtInt ->SetYTitle("Counts");
+ fHistPtRP = new TH1F(sName.Data(), sName.Data(),iNbinsPt, dPtMin, dPtMax);
+ fHistPtRP ->SetXTitle("P_{t} (GeV/c) for RP selection");
+ fHistPtRP ->SetYTitle("Counts");
- sName = "Control_Flow_PtDiff_";
+ sName = "Control_Flow_PtPOI_";
sName +=anInput;
- fHistPtDiff = new TH1F(sName.Data(), sName.Data(),iNbinsPt, dPtMin, dPtMax);
+ fHistPtPOI = new TH1F(sName.Data(), sName.Data(),iNbinsPt, dPtMin, dPtMax);
//binning has to be the same as for fHistProVPt! use to get Nprime!
- fHistPtDiff ->SetXTitle("P_{t} (GeV/c) for differential flow");
- fHistPtDiff ->SetYTitle("Counts");
+ fHistPtPOI ->SetXTitle("P_{t} (GeV/c) for POI selection");
+ fHistPtPOI ->SetYTitle("Counts");
+
+ sName = "Control_Flow_PtSub0_";
+ sName +=anInput;
+ fHistPtSub0 = new TH1F(sName.Data(), sName.Data(),iNbinsPt, dPtMin, dPtMax);
+ fHistPtSub0 ->SetXTitle("P_{t} (GeV/c) for Subevent 0 selection");
+ fHistPtSub0 ->SetYTitle("Counts");
+
+ sName = "Control_Flow_PtSub1_";
+ sName +=anInput;
+ fHistPtSub1 = new TH1F(sName.Data(), sName.Data(),iNbinsPt, dPtMin, dPtMax);
+ fHistPtSub1 ->SetXTitle("P_{t} (GeV/c) for Subevent 1 selection");
+ fHistPtSub1 ->SetYTitle("Counts");
//Phi
- sName = "Control_Flow_PhiInt_";
+ sName = "Control_Flow_PhiRP_";
sName +=anInput;
- fHistPhiInt = new TH1F(sName.Data(), sName.Data(),iNbinsPhi, dPhiMin, dPhiMax);
- fHistPhiInt ->SetXTitle("#phi for integrated flow");
- fHistPhiInt ->SetYTitle("Counts");
+ fHistPhiRP = new TH1F(sName.Data(), sName.Data(),iNbinsPhi, dPhiMin, dPhiMax);
+ fHistPhiRP ->SetXTitle("#phi for RP selection");
+ fHistPhiRP ->SetYTitle("Counts");
- sName = "Control_Flow_PhiDiff_";
+ sName = "Control_Flow_PhiPOI_";
sName +=anInput;
- fHistPhiDiff = new TH1F(sName.Data(), sName.Data(),iNbinsPhi, dPhiMin, dPhiMax);
- fHistPhiDiff ->SetXTitle("#phi for differential flow");
- fHistPhiDiff ->SetYTitle("Counts");
+ fHistPhiPOI = new TH1F(sName.Data(), sName.Data(),iNbinsPhi, dPhiMin, dPhiMax);
+ fHistPhiPOI ->SetXTitle("#phi for POI selection");
+ fHistPhiPOI ->SetYTitle("Counts");
+
+ sName = "Control_Flow_PhiSub0_";
+ sName +=anInput;
+ fHistPhiSub0 = new TH1F(sName.Data(), sName.Data(),iNbinsPhi, dPhiMin, dPhiMax);
+ fHistPhiSub0 ->SetXTitle("#phi for Subevent 0 selection");
+ fHistPhiSub0 ->SetYTitle("Counts");
+
+ sName = "Control_Flow_PhiSub1_";
+ sName +=anInput;
+ fHistPhiSub1 = new TH1F(sName.Data(), sName.Data(),iNbinsPhi, dPhiMin, dPhiMax);
+ fHistPhiSub1 ->SetXTitle("#phi for Subevent 1 selection");
+ fHistPhiSub1 ->SetYTitle("Counts");
//Eta
- sName = "Control_Flow_EtaInt_";
+ sName = "Control_Flow_EtaRP_";
+ sName +=anInput;
+ fHistEtaRP = new TH1F(sName.Data(), sName.Data(),iNbinsEta, dEtaMin, dEtaMax);
+ fHistEtaRP ->SetXTitle("#eta for RP selection");
+ fHistEtaRP ->SetYTitle("Counts");
+
+ sName = "Control_Flow_EtaPOI_";
sName +=anInput;
- fHistEtaInt = new TH1F(sName.Data(), sName.Data(),iNbinsEta, dEtaMin, dEtaMax);
- fHistEtaInt ->SetXTitle("#eta for integrated flow");
- fHistEtaInt ->SetYTitle("Counts");
+ fHistEtaPOI = new TH1F(sName.Data(), sName.Data(),iNbinsEta, dEtaMin, dEtaMax);
+ fHistEtaPOI ->SetXTitle("#eta for POI selection");
+ fHistEtaPOI ->SetYTitle("Counts");
- sName = "Control_Flow_EtaDiff_";
+ sName = "Control_Flow_EtaSub0_";
sName +=anInput;
- fHistEtaDiff = new TH1F(sName.Data(), sName.Data(),iNbinsEta, dEtaMin, dEtaMax);
- fHistEtaDiff ->SetXTitle("#eta for differential flow");
- fHistEtaDiff ->SetYTitle("Counts");
+ fHistEtaSub0 = new TH1F(sName.Data(), sName.Data(),iNbinsEta, dEtaMin, dEtaMax);
+ fHistEtaSub0 ->SetXTitle("#eta for Subevent 0 selection");
+ fHistEtaSub0 ->SetYTitle("Counts");
+
+ sName = "Control_Flow_EtaSub1_";
+ sName +=anInput;
+ fHistEtaSub1 = new TH1F(sName.Data(), sName.Data(),iNbinsEta, dEtaMin, dEtaMax);
+ fHistEtaSub1 ->SetXTitle("#eta for Subevent 1 selection");
+ fHistEtaSub1 ->SetYTitle("Counts");
+
+ //Phi vs Eta
+ sName = "Control_Flow_PhiEtaRP_";
+ sName +=anInput;
+ fHistPhiEtaRP = new TH2F(sName.Data(), sName.Data(),iNbinsEta, dEtaMin, dEtaMax, iNbinsPhi, dPhiMin, dPhiMax);
+ fHistPhiEtaRP ->SetXTitle("#eta");
+ fHistPhiEtaRP ->SetYTitle("#phi");
+
+ sName = "Control_Flow_PhiEtaPOI_";
+ sName +=anInput;
+ fHistPhiEtaPOI = new TH2F(sName.Data(), sName.Data(),iNbinsEta, dEtaMin, dEtaMax, iNbinsPhi, dPhiMin, dPhiMax);
+ fHistPhiEtaPOI ->SetXTitle("#eta");
+ fHistPhiEtaPOI ->SetYTitle("#phi");
//Mean Pt per pt bin
sName = "Control_FlowPro_MeanPtperBin_";
fHistQ = new TH1F(sName.Data(), sName.Data(),iNbinsQ, dQMin, dQMax);
fHistQ ->SetXTitle("Q_{vector}/Mult");
fHistQ ->SetYTitle("Counts");
+
+ //harmonic
+ sName = "Control_Flow_Harmonic_";
+ sName +=anInput;
+ fHarmonic = new TProfile(sName.Data(),sName.Data(),1,0,1);
+ fHarmonic ->SetYTitle("harmonic");
//list of histograms if added here also add in copy constructor
fHistList = new TList();
fHistList-> Add(fHistMultOrig);
- fHistList-> Add(fHistMultInt);
- fHistList-> Add(fHistMultDiff);
- fHistList-> Add(fHistPtInt);
- fHistList-> Add(fHistPtDiff);
- fHistList-> Add(fHistPhiInt);
- fHistList-> Add(fHistPhiDiff);
- fHistList-> Add(fHistEtaInt);
- fHistList-> Add(fHistEtaDiff);
- fHistList-> Add(fHistProMeanPtperBin);
+ fHistList-> Add(fHistMultRP);
+ fHistList-> Add(fHistMultPOI);
+ fHistList-> Add(fHistPtRP);
+ fHistList-> Add(fHistPtPOI);
+ fHistList-> Add(fHistPtSub0);
+ fHistList-> Add(fHistPtSub1);
+ fHistList-> Add(fHistPhiRP);
+ fHistList-> Add(fHistPhiPOI);
+ fHistList-> Add(fHistPhiSub0);
+ fHistList-> Add(fHistPhiSub1);
+ fHistList-> Add(fHistEtaRP);
+ fHistList-> Add(fHistEtaPOI);
+ fHistList-> Add(fHistEtaSub0);
+ fHistList-> Add(fHistEtaSub1);
+ fHistList-> Add(fHistPhiEtaRP);
+ fHistList-> Add(fHistPhiEtaPOI);
+ fHistList-> Add(fHistProMeanPtperBin);
+ fHistList-> Add(fHarmonic);
fHistList-> Add(fHistQ);
-
-
}
{
//deletes histograms
delete fHistMultOrig;
- delete fHistMultInt;
- delete fHistMultDiff;
- delete fHistPtInt;
- delete fHistPtDiff;
- delete fHistPhiInt;
- delete fHistPhiDiff;
- delete fHistEtaInt;
- delete fHistEtaDiff;
+ delete fHistMultRP;
+ delete fHistMultPOI;
+ delete fHistPtRP;
+ delete fHistPtPOI;
+ delete fHistPtSub0;
+ delete fHistPtSub1;
+ delete fHistPhiRP;
+ delete fHistPhiPOI;
+ delete fHistPhiSub0;
+ delete fHistPhiSub1;
+ delete fHistEtaRP;
+ delete fHistEtaPOI;
+ delete fHistEtaSub0;
+ delete fHistEtaSub1;
+ delete fHistPhiEtaRP;
+ delete fHistPhiEtaPOI;
delete fHistProMeanPtperBin;
delete fHistQ;
+ delete fHarmonic;
delete fHistList;
}
return kFALSE;
}
- Double_t dPt, dPhi, dEta;
+ Double_t dPt, dPhi, dEta, dWeight;
//fill the histograms
vQ.Set(dQX,dQY);
fHistQ->Fill(vQ.Mod());
- Int_t iMultInt = 0;
- Int_t iMultDiff = 0;
+ Double_t dMultRP = 0.;
+ Double_t dMultPOI = 0.;
AliFlowTrackSimple* pTrack = NULL;
for (Int_t i=0;i<iNumberOfTracks;i++) {
pTrack = anEvent->GetTrack(i);
if (pTrack ) {
- if (pTrack->UseForIntegratedFlow()){
+ dWeight = pTrack->Weight();
+ if (pTrack->InRPSelection()){
+ //pt
dPt = pTrack->Pt();
- fHistPtInt->Fill(dPt);
+ fHistPtRP->Fill(dPt,dWeight);
+ //phi
dPhi = pTrack->Phi();
if (dPhi<0.) dPhi+=2*TMath::Pi();
- fHistPhiInt->Fill(dPhi);
+ fHistPhiRP->Fill(dPhi,dWeight);
+ //eta
dEta = pTrack->Eta();
- fHistEtaInt->Fill(dEta);
- iMultInt++;
+ fHistEtaRP->Fill(dEta,dWeight);
+ //eta vs phi
+ fHistPhiEtaRP->Fill(dEta,dPhi,dWeight);
+ //count
+ dMultRP += dWeight;
+ if (pTrack->InSubevent(0)){
+ //Fill distributions for the subevent
+ fHistPtSub0 -> Fill(dPt,dWeight);
+ fHistPhiSub0 -> Fill(dPhi,dWeight);
+ fHistEtaSub0 -> Fill(dEta,dWeight);
+ }
+ else if (pTrack->InSubevent(1)){
+ //Fill distributions for the subevent
+ fHistPtSub1 -> Fill(dPt,dWeight);
+ fHistPhiSub1 -> Fill(dPhi,dWeight);
+ fHistEtaSub1 -> Fill(dEta,dWeight);
+ }
}
- if (pTrack->UseForDifferentialFlow()){
+ if (pTrack->InPOISelection()){
+ //pt
dPt = pTrack->Pt();
- fHistPtDiff->Fill(dPt);
+ fHistPtPOI->Fill(dPt,dWeight);
+ //phi
dPhi = pTrack->Phi();
if (dPhi<0.) dPhi+=2*TMath::Pi();
- fHistPhiDiff->Fill(dPhi);
+ fHistPhiPOI->Fill(dPhi,dWeight);
+ //eta
dEta = pTrack->Eta();
- fHistEtaDiff->Fill(dEta);
- fHistProMeanPtperBin->Fill(dPt,dPt);
- iMultDiff++;
+ fHistEtaPOI->Fill(dEta,dWeight);
+ //eta vs phi
+ fHistPhiEtaPOI->Fill(dEta,dPhi,dWeight);
+ //mean pt
+ fHistProMeanPtperBin->Fill(dPt,dPt,dWeight);
+ //count
+ dMultPOI += dWeight;
}
} //track
} //loop over tracks
- fHistMultInt->Fill(iMultInt);
- fHistMultDiff->Fill(iMultDiff);
+ fHistMultRP->Fill(dMultRP);
+ fHistMultPOI->Fill(dMultPOI);
return kTRUE;
}
//-----------------------------------------------------------------------
-Double_t AliFlowCommonHist::GetEntriesInPtBin(Int_t aBin)
+Double_t AliFlowCommonHist::GetEntriesInPtBinRP(Int_t aBin)
+{
+ //get entries in bin aBin from fHistPtRP
+ Double_t dEntries = fHistPtRP->GetBinContent(aBin);
+
+ return dEntries;
+
+}
+
+//-----------------------------------------------------------------------
+
+Double_t AliFlowCommonHist::GetEntriesInPtBinPOI(Int_t aBin)
+{
+ //get entries in bin aBin from fHistPtPOI
+ Double_t dEntries = fHistPtPOI->GetBinContent(aBin);
+
+ return dEntries;
+
+}
+
+//-----------------------------------------------------------------------
+
+Double_t AliFlowCommonHist::GetEntriesInEtaBinRP(Int_t aBin)
+{
+ //get entries in bin aBin from fHistPtRP
+ Double_t dEntries = fHistEtaRP->GetBinContent(aBin);
+
+ return dEntries;
+
+}
+
+//-----------------------------------------------------------------------
+
+Double_t AliFlowCommonHist::GetEntriesInEtaBinPOI(Int_t aBin)
{
- //get entries in bin aBin from fHistPtDiff
- Double_t dEntries = fHistPtDiff->GetBinContent(aBin);
+ //get entries in bin aBin from fHistPtPOI
+ Double_t dEntries = fHistEtaPOI->GetBinContent(aBin);
return dEntries;
Double_t AliFlowCommonHist::Merge(TCollection *aList)
{
//merge fuction
- cout<<"entering merge function"<<endl;
+ //cout<<"entering merge function"<<endl;
if (!aList) return 0;
if (aList->IsEmpty()) return 0; //no merging is needed
// Cleanup
delete pTemp;
- cout<<"Merged"<<endl;
+ //cout<<"Merged"<<endl;
return (double)iCount;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff