#include "AliAnalysisTaskFragmentationFunction.h"
-
ClassImp(AliAnalysisTaskFragmentationFunction)
//____________________________________________________________________________
,fAOD(0)
,fBranchRecJets("jets")
,fBranchRecBackJets("")
+ ,fBranchRecBckgClusters("")
,fBranchGenJets("")
,fTrackTypeGen(0)
,fJetTypeGen(0)
,fDJMode(0)
,fEffMode(0)
,fPhiCorrMode(0)
- ,fUseRecEffRecJetPtBins(1)
+ ,fUseRecEffRecJetPtBins(0)
+ ,fUseResponseRecJetPtBins(1)
,fAvgTrials(0)
,fTracksRec(0)
,fTracksRecCuts(0)
,fhnResponseJetXi(0)
// Background
,fh1OutLeadingMult(0)
+ ,fh1OutLeadingStatMult(0)
,fh1PerpMult(0)
,fh1ASideMult(0)
,fh1ASideWindowMult(0)
,fh1PerpWindowMult(0)
,fh1Out2JetsMult(0)
,fh1Out3JetsMult(0)
+ ,fh1MedianClustersMult(0)
+ ,fh1OutClustersMult(0)
,fQABckgHisto0RecCuts(0)
,fQABckgHisto0Gen(0)
,fQABckgHisto1RecCuts(0)
,fQABckgHisto1Gen(0)
,fQABckgHisto2RecCuts(0)
- ,fQABckgHisto2Gen(0)
+ ,fQABckgHisto2Gen(0)
+ ,fQABckgHisto3RecCuts(0)
+ ,fQABckgHisto3Gen(0)
,fFFBckgHisto0RecCuts(0)
,fFFBckgHisto0RecLeading(0)
,fFFBckgHisto0Gen(0)
,fFFBckgHisto2RecLeading(0)
,fFFBckgHisto2Gen(0)
,fFFBckgHisto2GenLeading(0)
+ ,fFFBckgHisto3RecCuts(0)
+ ,fFFBckgHisto3RecLeading(0)
+ ,fFFBckgHisto3Gen(0)
+ ,fFFBckgHisto3GenLeading(0)
,fIJBckgHisto0RecCuts(0)
,fIJBckgHisto0RecLeading(0)
,fIJBckgHisto0Gen(0)
,fIJBckgHisto2RecLeading(0)
,fIJBckgHisto2Gen(0)
,fIJBckgHisto2GenLeading(0)
+ ,fIJBckgHisto3RecCuts(0)
+ ,fIJBckgHisto3RecLeading(0)
+ ,fIJBckgHisto3Gen(0)
+ ,fIJBckgHisto3GenLeading(0)
,fRandom(0)
,fBckgSubMethod(0)
{
fBckgType[0] = 0;
fBckgType[1] = 0;
fBckgType[2] = 0;
+ fBckgType[3] = 0;
}
//__________________________________________________________________________________________
,fAOD(0)
,fBranchRecJets("jets")
,fBranchRecBackJets("")
+ ,fBranchRecBckgClusters("")
,fBranchGenJets("")
,fTrackTypeGen(0)
,fJetTypeGen(0)
,fDJMode(0)
,fEffMode(0)
,fPhiCorrMode(0)
- ,fUseRecEffRecJetPtBins(1)
+ ,fUseRecEffRecJetPtBins(0)
+ ,fUseResponseRecJetPtBins(1)
,fAvgTrials(0)
,fTracksRec(0)
,fTracksRecCuts(0)
,fhnResponseJetXi(0)
// Background
,fh1OutLeadingMult(0)
+ ,fh1OutLeadingStatMult(0)
,fh1PerpMult(0)
,fh1ASideMult(0)
,fh1ASideWindowMult(0)
,fh1PerpWindowMult(0)
,fh1Out2JetsMult(0)
,fh1Out3JetsMult(0)
+ ,fh1MedianClustersMult(0)
+ ,fh1OutClustersMult(0)
,fQABckgHisto0RecCuts(0)
,fQABckgHisto0Gen(0)
,fQABckgHisto1RecCuts(0)
,fQABckgHisto1Gen(0)
,fQABckgHisto2RecCuts(0)
- ,fQABckgHisto2Gen(0)
+ ,fQABckgHisto2Gen(0)
+ ,fQABckgHisto3RecCuts(0)
+ ,fQABckgHisto3Gen(0)
,fFFBckgHisto0RecCuts(0)
,fFFBckgHisto0RecLeading(0)
,fFFBckgHisto0Gen(0)
,fFFBckgHisto2RecLeading(0)
,fFFBckgHisto2Gen(0)
,fFFBckgHisto2GenLeading(0)
+ ,fFFBckgHisto3RecCuts(0)
+ ,fFFBckgHisto3RecLeading(0)
+ ,fFFBckgHisto3Gen(0)
+ ,fFFBckgHisto3GenLeading(0)
,fIJBckgHisto0RecCuts(0)
,fIJBckgHisto0RecLeading(0)
,fIJBckgHisto0Gen(0)
,fIJBckgHisto2RecLeading(0)
,fIJBckgHisto2Gen(0)
,fIJBckgHisto2GenLeading(0)
+ ,fIJBckgHisto3RecCuts(0)
+ ,fIJBckgHisto3RecLeading(0)
+ ,fIJBckgHisto3Gen(0)
+ ,fIJBckgHisto3GenLeading(0)
,fRandom(0)
,fBckgSubMethod(0)
{
fBckgType[0] = 0;
fBckgType[1] = 0;
fBckgType[2] = 0;
+ fBckgType[3] = 0;
DefineOutput(1,TList::Class());
,fAOD(copy.fAOD)
,fBranchRecJets(copy.fBranchRecJets)
,fBranchRecBackJets(copy.fBranchRecBackJets)
+ ,fBranchRecBckgClusters(copy.fBranchRecBckgClusters)
,fBranchGenJets(copy.fBranchGenJets)
,fTrackTypeGen(copy.fTrackTypeGen)
,fJetTypeGen(copy.fJetTypeGen)
,fEffMode(copy.fEffMode)
,fPhiCorrMode(copy.fPhiCorrMode)
,fUseRecEffRecJetPtBins(copy.fUseRecEffRecJetPtBins)
+ ,fUseResponseRecJetPtBins(copy.fUseResponseRecJetPtBins)
,fAvgTrials(copy.fAvgTrials)
,fTracksRec(copy.fTracksRec)
,fTracksRecCuts(copy.fTracksRecCuts)
,fhnResponseJetXi(copy.fhnResponseJetXi)
// Background
,fh1OutLeadingMult(copy.fh1OutLeadingMult)
+ ,fh1OutLeadingStatMult(copy.fh1OutLeadingStatMult)
,fh1PerpMult(copy.fh1PerpMult)
,fh1ASideMult(copy.fh1ASideMult)
,fh1ASideWindowMult(copy.fh1ASideWindowMult)
,fh1PerpWindowMult(copy.fh1PerpWindowMult)
,fh1Out2JetsMult(copy.fh1Out2JetsMult)
,fh1Out3JetsMult(copy.fh1Out3JetsMult)
+ ,fh1MedianClustersMult(copy.fh1MedianClustersMult)
+ ,fh1OutClustersMult(copy.fh1OutClustersMult)
,fQABckgHisto0RecCuts(copy.fQABckgHisto0RecCuts)
,fQABckgHisto0Gen(copy.fQABckgHisto0Gen)
,fQABckgHisto1RecCuts(copy.fQABckgHisto1RecCuts)
,fQABckgHisto1Gen(copy.fQABckgHisto1Gen)
,fQABckgHisto2RecCuts(copy.fQABckgHisto2RecCuts)
- ,fQABckgHisto2Gen(copy.fQABckgHisto2Gen)
+ ,fQABckgHisto2Gen(copy.fQABckgHisto2Gen)
+ ,fQABckgHisto3RecCuts(copy.fQABckgHisto3RecCuts)
+ ,fQABckgHisto3Gen(copy.fQABckgHisto3Gen)
,fFFBckgHisto0RecCuts(copy.fFFBckgHisto0RecCuts)
,fFFBckgHisto0RecLeading(copy.fFFBckgHisto0RecLeading)
,fFFBckgHisto0Gen(copy.fFFBckgHisto0Gen)
,fFFBckgHisto2RecLeading(copy.fFFBckgHisto2RecLeading)
,fFFBckgHisto2Gen(copy.fFFBckgHisto2Gen)
,fFFBckgHisto2GenLeading(copy.fFFBckgHisto2GenLeading)
+ ,fFFBckgHisto3RecCuts(copy.fFFBckgHisto3RecCuts)
+ ,fFFBckgHisto3RecLeading(copy.fFFBckgHisto3RecLeading)
+ ,fFFBckgHisto3Gen(copy.fFFBckgHisto3Gen)
+ ,fFFBckgHisto3GenLeading(copy.fFFBckgHisto3GenLeading)
,fIJBckgHisto0RecCuts(copy.fIJBckgHisto0RecCuts)
,fIJBckgHisto0RecLeading(copy.fIJBckgHisto0RecLeading)
,fIJBckgHisto0Gen(copy.fIJBckgHisto0Gen)
,fIJBckgHisto2RecLeading(copy.fIJBckgHisto2RecLeading)
,fIJBckgHisto2Gen(copy.fIJBckgHisto2Gen)
,fIJBckgHisto2GenLeading(copy.fIJBckgHisto2GenLeading)
+ ,fIJBckgHisto3RecCuts(copy.fIJBckgHisto3RecCuts)
+ ,fIJBckgHisto3RecLeading(copy.fIJBckgHisto3RecLeading)
+ ,fIJBckgHisto3Gen(copy.fIJBckgHisto3Gen)
+ ,fIJBckgHisto3GenLeading(copy.fIJBckgHisto3GenLeading)
,fRandom(copy.fRandom)
,fBckgSubMethod(copy.fBckgSubMethod)
{
fBckgType[0] = copy.fBckgType[0];
fBckgType[1] = copy.fBckgType[1];
fBckgType[2] = copy.fBckgType[2];
+ fBckgType[3] = copy.fBckgType[3];
}
// _________________________________________________________________________________________________________________________________
fAOD = o.fAOD;
fBranchRecJets = o.fBranchRecJets;
fBranchRecBackJets = o.fBranchRecBackJets;
+ fBranchRecBckgClusters = o.fBranchRecBckgClusters;
fBranchGenJets = o.fBranchGenJets;
fTrackTypeGen = o.fTrackTypeGen;
fJetTypeGen = o.fJetTypeGen;
fBckgType[0] = o.fBckgType[0];
fBckgType[1] = o.fBckgType[1];
fBckgType[2] = o.fBckgType[2];
+ fBckgType[3] = o.fBckgType[3];
fUseRecEffRecJetPtBins = o.fUseRecEffRecJetPtBins;
+ fUseResponseRecJetPtBins = o.fUseResponseRecJetPtBins;
fAvgTrials = o.fAvgTrials;
fTracksRec = o.fTracksRec;
fTracksRecCuts = o.fTracksRecCuts;
fhnResponseJetXi = o.fhnResponseJetXi;
// Background
fh1OutLeadingMult = o.fh1OutLeadingMult;
+ fh1OutLeadingStatMult = o.fh1OutLeadingStatMult;
fh1PerpMult = o.fh1PerpMult;
fh1ASideMult = o.fh1ASideMult;
fh1ASideWindowMult = o.fh1ASideWindowMult;
fh1PerpWindowMult = o.fh1PerpWindowMult;
fh1Out2JetsMult = o.fh1Out2JetsMult;
fh1Out3JetsMult = o.fh1Out3JetsMult;
+ fh1MedianClustersMult = o.fh1MedianClustersMult;
+ fh1OutClustersMult = o.fh1OutClustersMult;
fQABckgHisto0RecCuts = o.fQABckgHisto0RecCuts;
fQABckgHisto0Gen = o.fQABckgHisto0Gen;
fQABckgHisto1RecCuts = o.fQABckgHisto1RecCuts;
fQABckgHisto1Gen = o.fQABckgHisto1Gen;
fQABckgHisto2RecCuts = o.fQABckgHisto2RecCuts;
fQABckgHisto2Gen = o.fQABckgHisto2Gen;
+ fQABckgHisto3RecCuts = o.fQABckgHisto3RecCuts;
+ fQABckgHisto3Gen = o.fQABckgHisto3Gen;
fFFBckgHisto0RecCuts = o.fFFBckgHisto0RecCuts;
fFFBckgHisto0RecLeading = o.fFFBckgHisto0RecLeading;
fFFBckgHisto0Gen = o.fFFBckgHisto0Gen;
fFFBckgHisto2RecLeading = o.fFFBckgHisto2RecLeading;
fFFBckgHisto2Gen = o.fFFBckgHisto2Gen;
fFFBckgHisto2GenLeading = o.fFFBckgHisto2GenLeading;
+ fFFBckgHisto3RecCuts = o.fFFBckgHisto3RecCuts;
+ fFFBckgHisto3RecLeading = o.fFFBckgHisto3RecLeading;
+ fFFBckgHisto3Gen = o.fFFBckgHisto3Gen;
+ fFFBckgHisto3GenLeading = o.fFFBckgHisto3GenLeading;
fIJBckgHisto0RecCuts = o.fIJBckgHisto0RecCuts;
fIJBckgHisto0RecLeading = o.fIJBckgHisto0RecLeading;
fIJBckgHisto0Gen = o.fIJBckgHisto0Gen;
fIJBckgHisto2RecLeading = o.fIJBckgHisto2RecLeading;
fIJBckgHisto2Gen = o.fIJBckgHisto2Gen;
fIJBckgHisto2GenLeading = o.fIJBckgHisto2GenLeading;
+ fIJBckgHisto3Gen = o.fIJBckgHisto3Gen;
+ fIJBckgHisto3GenLeading = o.fIJBckgHisto3GenLeading;
fRandom = o.fRandom;
fBckgSubMethod = o.fBckgSubMethod;
}
if(fJetsRecCuts) delete fJetsRecCuts;
if(fJetsGen) delete fJetsGen;
if(fJetsRecEff) delete fJetsRecEff;
- if(fBckgMode && (fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters)){
+ if(fBckgMode &&
+ (fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters || fBckgType[3]==kBckgClusters ||
+ fBckgType[0]==kBckgClustersOutLeading || fBckgType[1]==kBckgClustersOutLeading ||
+ fBckgType[2]==kBckgClustersOutLeading || fBckgType[3]==kBckgClustersOutLeading)){
+
if(fBckgJetsRec) delete fBckgJetsRec;
if(fBckgJetsRecCuts) delete fBckgJetsRecCuts;
if(fBckgJetsGen) delete fBckgJetsGen;
fh2EtaPhi = new TH2F(Form("fh2TrackQAEtaPhi%s", fNameQAT.Data()), Form("%s: #eta - #phi distribution", fNameQAT.Data()), fNBinsEta, fEtaMin, fEtaMax, fNBinsPhi, fPhiMin, fPhiMax);
fh2HighPtEtaPhi = new TH2F(Form("fh2TrackQAHighPtEtaPhi%s", fNameQAT.Data()), Form("%s: #eta - #phi distribution for high-p_{T}", fNameQAT.Data()), fNBinsEta, fEtaMin, fEtaMax, fNBinsPhi, fPhiMin, fPhiMax);
fh1Pt = new TH1F(Form("fh1TrackQAPt%s", fNameQAT.Data()), Form("%s: p_{T} distribution", fNameQAT.Data()), fNBinsPt, fPtMin, fPtMax);
- fh2PhiPt = new TH2F(Form("fh2TrackQAPhiPt%s", fNameQAT.Data()), Form("%s: #eta - #p_{T} distribution", fNameQAT.Data()), fNBinsPhi, fPhiMin, fPhiMax, fNBinsPt, fPtMin, fPtMax);
+ fh2PhiPt = new TH2F(Form("fh2TrackQAPhiPt%s", fNameQAT.Data()), Form("%s: #phi - #p_{T} distribution", fNameQAT.Data()), fNBinsPhi, fPhiMin, fPhiMax, fNBinsPt, fPtMin, fPtMax);
AliAnalysisTaskFragmentationFunction::SetProperties(fh2EtaPhi, "#eta", "#phi");
AliAnalysisTaskFragmentationFunction::SetProperties(fh2HighPtEtaPhi, "#eta", "#phi");
// fJetsKine = new TList();
// fJetsKine->SetOwner(kTRUE); // delete AOD jets using mom from Kine Tree via TList::Clear()
- if(fBckgMode && (fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters)){
+ if(fBckgMode &&
+ (fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters || fBckgType[3]==kBckgClusters ||
+ fBckgType[0]==kBckgClustersOutLeading || fBckgType[1]==kBckgClustersOutLeading ||
+ fBckgType[2]==kBckgClustersOutLeading || fBckgType[3]==kBckgClustersOutLeading)){
+
fBckgJetsRec = new TList();
fBckgJetsRec->SetOwner(kFALSE);
fh1EvtSelection->GetXaxis()->SetBinLabel(5,"vertex z: rejected");
fh1EvtSelection->GetXaxis()->SetBinLabel(6,"vertex type: rejected");
- fh1VertexNContributors = new TH1F("fh1VertexNContributors", "Vertex N contributors", 11,-.5, 10.5);
+ fh1VertexNContributors = new TH1F("fh1VertexNContributors", "Vertex N contributors", 2500,-.5, 2499.5);
fh1VertexZ = new TH1F("fh1VertexZ", "Vertex z distribution", 30, -15., 15.);
fh1EvtMult = new TH1F("fh1EvtMult","Event multiplicity, track pT cut > 150 MeV/c, |#eta| < 0.9",120,0.,12000.);
fh1EvtCent = new TH1F("fh1EvtCent","centrality",100,0.,100.);
// Background
if(fBckgMode) {
- if(fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters) {
+ if(fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters || fBckgType[3]==kBckgClusters ||
+ fBckgType[0]==kBckgClustersOutLeading || fBckgType[1]==kBckgClustersOutLeading ||
+ fBckgType[2]==kBckgClustersOutLeading || fBckgType[3]==kBckgClustersOutLeading){
+
fh1nRecBckgJetsCuts = new TH1F("fh1nRecBckgJetsCuts","reconstructed background jets per event",10,-0.5,9.5);
fh1nGenBckgJets = new TH1F("fh1nGenBckgJets","generated background jets per event",10,-0.5,9.5);
}
- if(fBckgType[0]==kBckgPerp || fBckgType[1]==kBckgPerp || fBckgType[2]==kBckgPerp)
- fh1PerpMult = new TH1F("fh1PerpMult","Background multiplicity - Cone perpendicular to leading jet axis",120,0.,120.);
- if(fBckgType[0]==kBckgASide || fBckgType[1]==kBckgASide || fBckgType[2]==kBckgASide)
- fh1ASideMult = new TH1F("fh1ASideMult","Background multiplicity - Cone in the away side of leading jet axis",120,0.,120.);
- if(fBckgType[0]==kBckgASideWindow || fBckgType[1]==kBckgASideWindow || fBckgType[2]==kBckgASideWindow)
- fh1ASideWindowMult = new TH1F("fh1ASideWindowMult","Background multiplicity - Cone in the away side of leading jet axis",120,0.,120.);
- if(fBckgType[0]==kBckgPerpWindow || fBckgType[1]==kBckgPerpWindow || fBckgType[2]==kBckgPerpWindow)
- fh1PerpWindowMult = new TH1F("fh1PerpWindowMult","Background multiplicity - Cone in the perp direction of leading jet axis",120,0.,120.);
- if(fBckgType[0]==kBckgOutLJ || fBckgType[1]==kBckgOutLJ || fBckgType[2]==kBckgOutLJ)
- fh1OutLeadingMult = new TH1F("fh1OutLeadingMult","Background multiplicity - Cone outside leading jet",120,0,120.);
- if(fBckgType[0]==kBckgOut2J || fBckgType[1]==kBckgOut2J || fBckgType[2]==kBckgOut2J)
- fh1Out2JetsMult = new TH1F("fh1Out2JetsMult","Background multiplicity - Cone outside 2 jets",120,0.,120.);
- if(fBckgType[0]==kBckgOut3J || fBckgType[1]==kBckgOut3J || fBckgType[2]==kBckgOut3J)
- fh1Out3JetsMult = new TH1F("fh1Out3JetsMult","Background multiplicity - Cone outside 3 jets",120,0.,120.);
- }
+ if(fBckgType[0]==kBckgPerp || fBckgType[1]==kBckgPerp || fBckgType[2]==kBckgPerp || fBckgType[3]==kBckgPerp)
+ fh1PerpMult = new TH1F("fh1PerpMult","Background multiplicity - Cone perpendicular to leading jet axis",500,0.,500.);
+ if(fBckgType[0]==kBckgASide || fBckgType[1]==kBckgASide || fBckgType[2]==kBckgASide || fBckgType[3]==kBckgASide)
+ fh1ASideMult = new TH1F("fh1ASideMult","Background multiplicity - Cone in the away side of leading jet axis",500,0.,500.);
+ if(fBckgType[0]==kBckgASideWindow || fBckgType[1]==kBckgASideWindow || fBckgType[2]==kBckgASideWindow || fBckgType[3]==kBckgASideWindow)
+ fh1ASideWindowMult = new TH1F("fh1ASideWindowMult","Background multiplicity - Cone in the away side of leading jet axis",500,0.,500.);
+ if(fBckgType[0]==kBckgPerpWindow || fBckgType[1]==kBckgPerpWindow || fBckgType[2]==kBckgPerpWindow || fBckgType[3]==kBckgPerpWindow)
+ fh1PerpWindowMult = new TH1F("fh1PerpWindowMult","Background multiplicity - Cone in the perp direction of leading jet axis",500,0.,500.);
+ if(fBckgType[0]==kBckgOutLJ || fBckgType[1]==kBckgOutLJ || fBckgType[2]==kBckgOutLJ || fBckgType[3]==kBckgOutLJ)
+ fh1OutLeadingMult = new TH1F("fh1OutLeadingMult","Background multiplicity - Cone outside leading jet",500,0,500.);
+ if(fBckgType[0]==kBckgOutLJStat || fBckgType[1]==kBckgOutLJStat || fBckgType[2]==kBckgOutLJStat || fBckgType[3]==kBckgOutLJStat)
+ fh1OutLeadingStatMult = new TH1F("fh1OutLeadingStatMult","Background multiplicity - Cone outside leading jet",3000,0,3000.);
+ if(fBckgType[0]==kBckgOut2J || fBckgType[1]==kBckgOut2J || fBckgType[2]==kBckgOut2J || fBckgType[3]==kBckgOut2J)
+ fh1Out2JetsMult = new TH1F("fh1Out2JetsMult","Background multiplicity - Cone outside 2 jets",500,0.,500.);
+ if(fBckgType[0]==kBckgOut3J || fBckgType[1]==kBckgOut3J || fBckgType[2]==kBckgOut3J || fBckgType[3]==kBckgOut3J)
+ fh1Out3JetsMult = new TH1F("fh1Out3JetsMult","Background multiplicity - Cone outside 3 jets",500,0.,500.);
+ if(fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters || fBckgType[3]==kBckgClusters)
+ fh1MedianClustersMult = new TH1F("fh1MedianClustersMult","Background multiplicity - median cluster",500,0.,500.);
+ if(fBckgType[0]==kBckgClustersOutLeading || fBckgType[1]==kBckgClustersOutLeading || fBckgType[2]==kBckgClustersOutLeading || fBckgType[3]==kBckgClustersOutLeading)
+ fh1OutClustersMult = new TH1F("fh1OutClustersMult","Background multiplicity - clusters outside leading jet",3000,0.,3000.);
+ }
+
if(fQAMode){
if(fQAMode&1){ // track QA
fQATrackHistosRec = new AliFragFuncQATrackHistos("Rec", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
// Background
if(fBckgMode){
// Track QA
- TString title[3];
- for(Int_t i=0; i<3; i++){
+ TString title[4];
+ for(Int_t i=0; i<4; i++){
if(fBckgType[i]==kBckgPerp) title[i]="Perp";
else if(fBckgType[i]==kBckgPerpWindow) title[i]="PerpW";
else if(fBckgType[i]==kBckgASide) title[i]="ASide";
else if(fBckgType[i]==kBckgOut2JStat) title[i]="Out2JetsStat";
else if(fBckgType[i]==kBckgOut3JStat) title[i]="Out3JetsStat";
else if(fBckgType[i]==kBckgOutAJStat) title[i]="AllJetsStat";
- else if(fBckgType[i]==kBckgClusters) title[i]="OutClusters";
+ else if(fBckgType[i]==kBckgClustersOutLeading) title[i]="OutClusters";
+ else if(fBckgType[i]==kBckgClusters) title[i]="MedianClusters";
else printf("Please chose background method number %d!",i);
}
fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
fQATrackHighPtThreshold);
+ fQABckgHisto3RecCuts = new AliFragFuncQATrackHistos("Bckg"+title[3]+"RecCuts", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
+ fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
+ fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
+ fQATrackHighPtThreshold);
+ fQABckgHisto3Gen = new AliFragFuncQATrackHistos("Bckg"+title[3]+"Gen", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
+ fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
+ fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
+ fQATrackHighPtThreshold);
} // end: background QA
if(fFFMode){
fFFNBinsPt, fFFPtMin, fFFPtMax,
fFFNBinsXi, fFFXiMin, fFFXiMax,
fFFNBinsZ , fFFZMin , fFFZMax);
+ fFFBckgHisto3RecCuts = new AliFragFuncHistos("Bckg"+title[3]+"RecCuts", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
+ fFFNBinsPt, fFFPtMin, fFFPtMax,
+ fFFNBinsXi, fFFXiMin, fFFXiMax,
+ fFFNBinsZ , fFFZMin , fFFZMax);
+ fFFBckgHisto3RecLeading = new AliFragFuncHistos("Bckg"+title[3]+"RecLeading", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
+ fFFNBinsPt, fFFPtMin, fFFPtMax,
+ fFFNBinsXi, fFFXiMin, fFFXiMax,
+ fFFNBinsZ , fFFZMin , fFFZMax);
+ fFFBckgHisto3Gen = new AliFragFuncHistos("Bckg"+title[3]+"Gen", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
+ fFFNBinsPt, fFFPtMin, fFFPtMax,
+ fFFNBinsXi, fFFXiMin, fFFXiMax,
+ fFFNBinsZ , fFFZMin , fFFZMax);
+ fFFBckgHisto3GenLeading = new AliFragFuncHistos("Bckg"+title[3]+"GenLeading", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
+ fFFNBinsPt, fFFPtMin, fFFPtMax,
+ fFFNBinsXi, fFFXiMin, fFFXiMax,
+ fFFNBinsZ , fFFZMin , fFFZMax);
} // end: background FF
if(fIJMode){
fFFBckgHisto2RecLeading->DefineHistos();
fFFBckgHisto2Gen->DefineHistos();
fFFBckgHisto2GenLeading->DefineHistos();
+ fFFBckgHisto3RecCuts->DefineHistos();
+ fFFBckgHisto3RecLeading->DefineHistos();
+ fFFBckgHisto3Gen->DefineHistos();
+ fFFBckgHisto3GenLeading->DefineHistos();
}
if(fIJMode){
fQABckgHisto1Gen->DefineHistos();
fQABckgHisto2RecCuts->DefineHistos();
fQABckgHisto2Gen->DefineHistos();
+ fQABckgHisto3RecCuts->DefineHistos();
+ fQABckgHisto3Gen->DefineHistos();
}
} // end: background
fFFBckgHisto1RecLeading->AddToOutput(fCommonHistList);
fFFBckgHisto2RecCuts->AddToOutput(fCommonHistList);
fFFBckgHisto2RecLeading->AddToOutput(fCommonHistList);
+ fFFBckgHisto3RecCuts->AddToOutput(fCommonHistList);
+ fFFBckgHisto3RecLeading->AddToOutput(fCommonHistList);
if(genJets && genTracks){
fFFBckgHisto0Gen->AddToOutput(fCommonHistList);
fFFBckgHisto0GenLeading->AddToOutput(fCommonHistList);
fFFBckgHisto1GenLeading->AddToOutput(fCommonHistList);
fFFBckgHisto2Gen->AddToOutput(fCommonHistList);
fFFBckgHisto2GenLeading->AddToOutput(fCommonHistList);
+ fFFBckgHisto3Gen->AddToOutput(fCommonHistList);
+ fFFBckgHisto3GenLeading->AddToOutput(fCommonHistList);
}
}
fQABckgHisto0RecCuts->AddToOutput(fCommonHistList);
fQABckgHisto1RecCuts->AddToOutput(fCommonHistList);
fQABckgHisto2RecCuts->AddToOutput(fCommonHistList);
+ fQABckgHisto3RecCuts->AddToOutput(fCommonHistList);
if(genJets && genTracks){
fQABckgHisto0Gen->AddToOutput(fCommonHistList);
fQABckgHisto1Gen->AddToOutput(fCommonHistList);
fQABckgHisto2Gen->AddToOutput(fCommonHistList);
+ fQABckgHisto3Gen->AddToOutput(fCommonHistList);
}
}
- if(fBckgType[0]==kBckgOutLJ || fBckgType[1]==kBckgOutLJ || fBckgType[2]==kBckgOutLJ)
+ if(fBckgType[0]==kBckgOutLJ || fBckgType[1]==kBckgOutLJ || fBckgType[2]==kBckgOutLJ || fBckgType[3]==kBckgOutLJ)
fCommonHistList->Add(fh1OutLeadingMult);
- if(fBckgType[0]==kBckgPerp || fBckgType[1]==kBckgPerp || fBckgType[2]==kBckgPerp)
+ if(fBckgType[0]==kBckgOutLJStat || fBckgType[1]==kBckgOutLJStat || fBckgType[2]==kBckgOutLJStat || fBckgType[3]==kBckgOutLJStat)
+ fCommonHistList->Add(fh1OutLeadingStatMult);
+ if(fBckgType[0]==kBckgPerp || fBckgType[1]==kBckgPerp || fBckgType[2]==kBckgPerp || fBckgType[3]==kBckgPerp )
fCommonHistList->Add(fh1PerpMult);
- if(fBckgType[0]==kBckgASide || fBckgType[1]==kBckgASide || fBckgType[2]==kBckgASide)
+ if(fBckgType[0]==kBckgASide || fBckgType[1]==kBckgASide || fBckgType[2]==kBckgASide || fBckgType[3]==kBckgASide)
fCommonHistList->Add(fh1ASideMult);
- if(fBckgType[0]==kBckgASideWindow || fBckgType[1]==kBckgASideWindow || fBckgType[2]==kBckgASideWindow)
+ if(fBckgType[0]==kBckgASideWindow || fBckgType[1]==kBckgASideWindow || fBckgType[2]==kBckgASideWindow || fBckgType[3]==kBckgASideWindow)
fCommonHistList->Add(fh1ASideWindowMult);
- if(fBckgType[0]==kBckgPerpWindow || fBckgType[1]==kBckgPerpWindow || fBckgType[2]==kBckgPerpWindow)
+ if(fBckgType[0]==kBckgPerpWindow || fBckgType[1]==kBckgPerpWindow || fBckgType[2]==kBckgPerpWindow || fBckgType[3]==kBckgPerpWindow)
fCommonHistList->Add(fh1PerpWindowMult);
- if(fBckgType[0]==kBckgOut2J || fBckgType[1]==kBckgOut2J || fBckgType[2]==kBckgOut2J)
+ if(fBckgType[0]==kBckgOut2J || fBckgType[1]==kBckgOut2J || fBckgType[2]==kBckgOut2J || fBckgType[3]==kBckgOut2J)
fCommonHistList->Add(fh1Out2JetsMult);
- if(fBckgType[0]==kBckgOut3J || fBckgType[1]==kBckgOut3J || fBckgType[2]==kBckgOut3J)
+ if(fBckgType[0]==kBckgOut3J || fBckgType[1]==kBckgOut3J || fBckgType[2]==kBckgOut3J || fBckgType[3]==kBckgOut3J)
fCommonHistList->Add(fh1Out3JetsMult);
+ if(fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters || fBckgType[3]==kBckgClusters)
+ fCommonHistList->Add(fh1MedianClustersMult);
+ if(fBckgType[0]==kBckgClustersOutLeading || fBckgType[1]==kBckgClustersOutLeading || fBckgType[2]==kBckgClustersOutLeading || fBckgType[3]==kBckgClustersOutLeading)
+ fCommonHistList->Add(fh1OutClustersMult);
}
// QA
}
}
- if(fBckgMode && (fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters)) {
+ if(fBckgMode &&
+ (fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters || fBckgType[3]==kBckgClusters ||
+ fBckgType[0]==kBckgClustersOutLeading || fBckgType[1]==kBckgClustersOutLeading ||
+ fBckgType[2]==kBckgClustersOutLeading || fBckgType[3]==kBckgClustersOutLeading)) {
fCommonHistList->Add(fh1nRecBckgJetsCuts);
if(genJets) fCommonHistList->Add(fh1nGenBckgJets);
}
// phi correlation
if(fPhiCorrMode){
- fPhiCorrHistosJetArea->AddToOutput(fCommonHistList);
- fPhiCorrHistosTransverseArea->AddToOutput(fCommonHistList);
- fPhiCorrHistosAwayArea->AddToOutput(fCommonHistList);
+ fPhiCorrHistosJetArea->AddToOutput(fCommonHistList);
+ fPhiCorrHistosTransverseArea->AddToOutput(fCommonHistList);
+ fPhiCorrHistosAwayArea->AddToOutput(fCommonHistList);
}
// intra-jet
fh1nRecEffJets->Fill(nRecEffJets);
//____ fetch background jets ___________________________________________________
- if(fBckgMode && (fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters)){
- Int_t nBJ = GetListOfBckgJets(/*fBckgJetsRec, kJetsRec*/);
+ if(fBckgMode &&
+ (fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters || fBckgType[3]==kBckgClusters ||
+ fBckgType[0]==kBckgClustersOutLeading || fBckgType[1]==kBckgClustersOutLeading ||
+ fBckgType[2]==kBckgClustersOutLeading || fBckgType[3]==kBckgClustersOutLeading)){
+
+ Int_t nBJ = GetListOfBckgJets(fBckgJetsRec, kJetsRec);
Int_t nRecBckgJets = 0;
if(nBJ>=0) nRecBckgJets = fBckgJetsRec->GetEntries();
if(fDebug>2)Printf("%s:%d Selected Rec background jets: %d %d",(char*)__FILE__,__LINE__,nBJ,nRecBckgJets);
if(nBJ != nRecBckgJets) Printf("%s:%d Mismatch Selected Rec background jets: %d %d",(char*)__FILE__,__LINE__,nBJ,nRecBckgJets);
- Int_t nBJCuts = GetListOfBckgJets(/*fBckgJetsRecCuts, kJetsRecAcceptance*/);
+ Int_t nBJCuts = GetListOfBckgJets(fBckgJetsRecCuts, kJetsRecAcceptance);
Int_t nRecBckgJetsCuts = 0;
if(nBJCuts>=0) nRecBckgJetsCuts = fBckgJetsRecCuts->GetEntries();
if(fDebug>2)Printf("%s:%d Selected Rec background jets after cuts: %d %d",(char*)__FILE__,__LINE__,nJCuts,nRecJetsCuts);
if(nRecBckgJetsCuts != nBJCuts) Printf("%s:%d Mismatch selected Rec background jets after cuts: %d %d",(char*)__FILE__,__LINE__,nBJCuts,nRecBckgJetsCuts);
fh1nRecBckgJetsCuts->Fill(nRecBckgJetsCuts);
- if(fJetTypeGen==kJetsKine || fJetTypeGen == kJetsKineAcceptance) fBckgJetsGen->SetOwner(kTRUE); // kine aod jets allocated on heap, delete them with TList::Clear()
- Int_t nBJGen = GetListOfBckgJets(/*fBckgJetsGen, fJetTypeGen*/);
- Int_t nGenBckgJets = 0;
- if(nBJGen>=0) nGenBckgJets = fBckgJetsGen->GetEntries();
- if(fDebug>2)Printf("%s:%d Selected Gen background jets: %d %d",(char*)__FILE__,__LINE__,nBJGen,nGenBckgJets);
- if(nBJGen != nGenBckgJets) Printf("%s:%d Mismatch selected Gen background jets: %d %d",(char*)__FILE__,__LINE__,nBJGen,nGenBckgJets);
- fh1nGenBckgJets->Fill(nGenBckgJets);
+ if(0){ // protection OB - not yet implemented
+ if(fJetTypeGen==kJetsKine || fJetTypeGen == kJetsKineAcceptance) fBckgJetsGen->SetOwner(kTRUE); // kine aod jets allocated on heap, delete them with TList::Clear()
+ Int_t nBJGen = GetListOfBckgJets(fBckgJetsGen, fJetTypeGen);
+ Int_t nGenBckgJets = 0;
+ if(nBJGen>=0) nGenBckgJets = fBckgJetsGen->GetEntries();
+ if(fDebug>2)Printf("%s:%d Selected Gen background jets: %d %d",(char*)__FILE__,__LINE__,nBJGen,nGenBckgJets);
+ if(nBJGen != nGenBckgJets) Printf("%s:%d Mismatch selected Gen background jets: %d %d",(char*)__FILE__,__LINE__,nBJGen,nGenBckgJets);
+ fh1nGenBckgJets->Fill(nGenBckgJets);
+ }
}
delete trackV;
}
- // ff and ij for background study
+ // ff and ij for background study
if(fBckgMode){
if(fBckgType[0]!=-1)
FillBckgHistos(fBckgType[0], fTracksRecCuts, fJetsRecCuts, jet, leadTrackPt, leadTrackV,
fFFBckgHisto2RecCuts, fFFBckgHisto2RecLeading,
fIJBckgHisto2RecCuts, fIJBckgHisto2RecLeading,
fQABckgHisto2RecCuts);
+ if(fBckgType[3]!=-1)
+ FillBckgHistos(fBckgType[3], fTracksRecCuts, fJetsRecCuts, jet, leadTrackPt, leadTrackV,
+ fFFBckgHisto3RecCuts, fFFBckgHisto3RecLeading,
+ fIJBckgHisto3RecCuts, fIJBckgHisto3RecLeading,
+ fQABckgHisto3RecCuts);
} // end if(fBckgMode)
delete leadTrackV;
jettracklistGen,fTracksAODMCCharged,indexAODTr,isGenPrim,fUseRecEffRecJetPtBins);
if(fFFMode) FillJetTrackResponse(fhnResponseJetTrackPt,fhnResponseJetZ,fhnResponseJetXi,sumPtGenLeadingJetRecEff,sumPtRecLeadingJetRecEff,
- jettracklistGen,fTracksAODMCCharged,fTracksRecQualityCuts,indexAODTr,isGenPrim,fUseRecEffRecJetPtBins);
-
+ jettracklistGen,fTracksAODMCCharged,fTracksRecQualityCuts,indexAODTr,isGenPrim,fUseResponseRecJetPtBins);
+
delete jettracklistGen;
delete jettracklistRec;
}
TList* perpjettracklistGen = new TList();
Double_t sumPtGen = 0.;
- GetTracksTiltedwrpJetAxis(TMath::Pi()/2.,fTracksGen, perpjettracklistGen, jet, GetFFBckgRadius() , sumPtGen); // for efficiency: gen tracks perp to gen/rec jet
+ GetTracksTiltedwrpJetAxis(TMath::Pi()/2.,fTracksGen, perpjettracklistGen, jet, GetFFRadius() , sumPtGen); // for efficiency: gen tracks perp to gen/rec jet
// here could be your histos !!!
// FillJetTrackRecEffHisto(fFFBckgrPerpHistosRecEffGen,fFFBckgrPerpHistosRecEffRec,sumPtGenLeadingJetRecEff,sumPtRecLeadingJetRecEff,perpjettracklistGen,
fJetsGen->Clear();
fJetsRecEff->Clear();
- if(fBckgMode && (fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters)){
+ if(fBckgMode &&
+ (fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters || fBckgType[3]==kBckgClusters ||
+ fBckgType[0]==kBckgClustersOutLeading || fBckgType[1]==kBckgClustersOutLeading ||
+ fBckgType[2]==kBckgClustersOutLeading || fBckgType[3]==kBckgClustersOutLeading)){
+
fBckgJetsRec->Clear();
fBckgJetsRecCuts->Clear();
fBckgJetsGen->Clear();
//Post output data.
PostData(1, fCommonHistList);
-
}
//________________________________________________________________________________________
}
}
-// _______________________________________________________________________________
-Int_t AliAnalysisTaskFragmentationFunction::GetListOfBckgJets(/*TList *list, Int_t type*/)
+// ___________________________________________________________________________________
+Int_t AliAnalysisTaskFragmentationFunction::GetListOfBckgJets(TList *list, Int_t type)
{
- // fill list of jets selected according to type
+ // fill list of bgr clusters selected according to type
-// /*
-// Under construction
-// */
+ if(type == kJetsRec || type == kJetsRecAcceptance){ // reconstructed jets
- return 0;
+ if(fBranchRecBckgClusters.Length()==0){
+ Printf("%s:%d no rec jet branch specified", (char*)__FILE__,__LINE__);
+ if(fDebug>1)fAOD->Print();
+ return 0;
+ }
+
+ TClonesArray *aodRecJets = 0;
+ if(fBranchRecBckgClusters.Length()) aodRecJets = dynamic_cast<TClonesArray*>(fAOD->FindListObject(fBranchRecBckgClusters.Data()));
+ if(!aodRecJets) aodRecJets = dynamic_cast<TClonesArray*>(fAOD->GetList()->FindObject(fBranchRecBckgClusters.Data()));
+
+ if(!aodRecJets){
+ if(fBranchRecBckgClusters.Length()) Printf("%s:%d no reconstructed jet array with name %s in AOD", (char*)__FILE__,__LINE__,fBranchRecBckgClusters.Data());
+ if(fDebug>1)fAOD->Print();
+ return 0;
+ }
+
+ // Reorder jet pt and fill new temporary AliAODJet objects
+ Int_t nRecJets = 0;
+
+ for(Int_t ij=0; ij<aodRecJets->GetEntries(); ++ij){
+
+ AliAODJet *tmp = dynamic_cast<AliAODJet*>(aodRecJets->At(ij));
+ if(!tmp) continue;
+
+ // if( tmp->Pt() < fJetPtCut ) continue; // no pt cut on bckg clusters !
+ if( type == kJetsRecAcceptance &&
+ ( tmp->Eta() < fJetEtaMin
+ || tmp->Eta() > fJetEtaMax
+ || tmp->Phi() < fJetPhiMin
+ || tmp->Phi() > fJetPhiMax )) continue;
+
+ list->Add(tmp);
+
+ nRecJets++;
+
+ }
+
+ list->Sort();
+
+ return nRecJets;
+ }
+ // /*
+ // MC clusters still Under construction
+ // */
+
+ return 0;
}
// _________________________________________________________________________________________________________
if(phiGen < fTrackPhiMin || phiGen > fTrackPhiMax) continue;
if(ptGen < fTrackPtCut) continue;
- Double_t zGen = ptGen / jetPtGen;
+ Double_t zGen = ptGen / jetPtRec;
Double_t xiGen = 0;
if(zGen>0) xiGen = TMath::Log(1/zGen);
if(rectrack){
Double_t ptRec = rectrack->Pt();
- Double_t zRec = ptRec / jetPtGen;
+ Double_t zRec = ptRec / jetPtRec;
Double_t xiRec = 0;
if(zRec>0) xiRec = TMath::Log(1/zRec);
}
+// ___________________________________________________________________________________________________________________________
+void AliAnalysisTaskFragmentationFunction::GetClusterTracksOutOf1Jet(AliAODJet* jet, TList* outputlist, Double_t &normFactor)
+{
+ // fill tracks from bckgCluster branch in list,
+ // for all clusters outside jet cone
+ // sum up total area of clusters
+
+ Double_t rc = GetFFRadius();
+ Double_t rcl = GetFFBckgRadius();
+
+ Double_t areaTotal = 0;
+ Double_t sumPtTotal = 0;
+
+ for(Int_t ij=0; ij<fBckgJetsRec->GetEntries(); ++ij){
+
+ AliAODJet* bgrCluster = (AliAODJet*)(fBckgJetsRec->At(ij)); // not 'recCuts': use all clusters in full eta range
+
+ Double_t dR = jet->DeltaR(bgrCluster);
+
+ if(dR<rcl) continue;
+
+ Double_t clusterPt = bgrCluster->Pt();
+ Double_t area = bgrCluster->EffectiveAreaCharged();
+ areaTotal += area;
+ sumPtTotal += clusterPt;
+
+ Int_t nTracksJet = bgrCluster->GetRefTracks()->GetEntries();
+
+ for(Int_t it = 0; it<nTracksJet; it++){
+
+ AliVParticle* track = dynamic_cast<AliVParticle*>(bgrCluster->GetTrack(it));
+
+ Float_t trackPt = track->Pt();
+ Float_t trackEta = track->Eta();
+ Float_t trackPhi = TVector2::Phi_0_2pi(track->Phi());
+
+ if(trackEta < fTrackEtaMin || trackEta > fTrackEtaMax) continue;
+ if(trackPhi < fTrackPhiMin || trackPhi > fTrackPhiMax) continue;
+ if(trackPt < fTrackPtCut) continue;
+
+ outputlist->Add(track);
+ }
+ }
+
+ Double_t areaJet = TMath::Pi()*rc*rc;
+ if(areaTotal) normFactor = (Float_t) 1./(areaJet / areaTotal);
+
+ outputlist->Sort();
+}
+
+// _______________________________________________________________________________________________________________________
+void AliAnalysisTaskFragmentationFunction::GetClusterTracksMedian(TList* outputlist, Double_t &normFactor)
+{
+ // fill tracks from bckgCluster branch,
+ // using cluster with median density (odd number of clusters)
+ // or picking randomly one of the two closest to median (even number)
+
+ Int_t nBckgClusters = fBckgJetsRec->GetEntries(); // not 'recCuts': use all clusters in full eta range
+
+ Double_t* bgrDensity = new Double_t[nBckgClusters];
+ Int_t* indices = new Int_t[nBckgClusters];
+
+ for(Int_t ij=0; ij<nBckgClusters; ++ij){
+
+ AliAODJet* bgrCluster = (AliAODJet*)(fBckgJetsRec->At(ij));
+ Double_t clusterPt = bgrCluster->Pt();
+ Double_t area = bgrCluster->EffectiveAreaCharged();
+
+ Double_t density = 0;
+ if(area>0) density = clusterPt/area;
+
+ bgrDensity[ij] = density;
+ indices[ij] = ij;
+ }
+
+ TMath::Sort(nBckgClusters, bgrDensity, indices);
+
+ // get median cluster
+
+ AliAODJet* medianCluster = 0;
+ Double_t medianDensity = 0;
+
+ if(TMath::Odd(nBckgClusters)){
+
+ Int_t medianIndex = indices[(Int_t) (0.5*(nBckgClusters-1))];
+ medianCluster = (AliAODJet*)(fBckgJetsRec->At(medianIndex));
+
+ Double_t clusterPt = medianCluster->Pt();
+ Double_t area = medianCluster->EffectiveAreaCharged();
+
+ if(area>0) medianDensity = clusterPt/area;
+ }
+ else{
+
+ Int_t medianIndex1 = indices[(Int_t) (0.5*nBckgClusters-1)];
+ Int_t medianIndex2 = indices[(Int_t) (0.5*nBckgClusters)];
+
+ AliAODJet* medianCluster1 = (AliAODJet*)(fBckgJetsRec->At(medianIndex1));
+ AliAODJet* medianCluster2 = (AliAODJet*)(fBckgJetsRec->At(medianIndex2));
+
+ Double_t density1 = 0;
+ Double_t clusterPt1 = medianCluster1->Pt();
+ Double_t area1 = medianCluster1->EffectiveAreaCharged();
+ if(area1>0) density1 = clusterPt1/area1;
+
+ Double_t density2 = 0;
+ Double_t clusterPt2 = medianCluster2->Pt();
+ Double_t area2 = medianCluster2->EffectiveAreaCharged();
+ if(area2>0) density2 = clusterPt2/area2;
+
+ medianDensity = 0.5*(density1+density2);
+
+ medianCluster = ( (fRandom->Rndm()>0.5) ? medianCluster1 : medianCluster2 ); // select one randomly to avoid adding areas
+ }
+
+ Int_t nTracksJet = medianCluster->GetRefTracks()->GetEntries();
+
+ for(Int_t it = 0; it<nTracksJet; it++){
+
+ AliVParticle* track = dynamic_cast<AliVParticle*>(medianCluster->GetTrack(it));
+
+ Float_t trackPt = track->Pt();
+ Float_t trackEta = track->Eta();
+ Float_t trackPhi = TVector2::Phi_0_2pi(track->Phi());
+
+ if(trackEta < fTrackEtaMin || trackEta > fTrackEtaMax) continue;
+ if(trackPhi < fTrackPhiMin || trackPhi > fTrackPhiMax) continue;
+ if(trackPt < fTrackPtCut) continue;
+
+ outputlist->Add(track);
+ }
+
+ Double_t areaMedian = medianCluster->EffectiveAreaCharged();
+ Double_t areaJet = TMath::Pi()*GetFFRadius()*GetFFRadius();
+
+ if(areaMedian) normFactor = (Float_t) 1./(areaJet / areaMedian);
+
+ outputlist->Sort();
+
+ delete[] bgrDensity;
+ delete[] indices;
+}
+
// ______________________________________________________________________________________________________________________________________________________
void AliAnalysisTaskFragmentationFunction::FillBckgHistos(Int_t type, TList* inputtracklist, TList* inputjetlist, AliAODJet* jet, Float_t leadTrackPt, TLorentzVector* leadTrackV,
AliFragFuncHistos* ffbckghistocuts, AliFragFuncHistos* ffbckghistoleading,
Double_t normFactorLeading = 0.;
GetTracksOutOfNJetsStat(1,inputtracklist, tracklistoutleadingStat, inputjetlist, sumPtOutLeadingStat, normFactorLeading);
+ if(type==kBckgOutLJStat) fh1OutLeadingStatMult->Fill(tracklistoutleadingStat->GetSize());
for(Int_t it=0; it<tracklistoutleadingStat->GetSize(); ++it){
if(fIJMode) ijbckghistoleading->FillIntraJet( trackV, leadTrackV, normFactorLeading);
// Fill track QA for background
- //if(fQAMode&1) qabckghistocuts->FillTrackQA( trackEta, TVector2::Phi_0_2pi(trackPhi), trackPt);
+ if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt); // OB added bgr QA
}
// All cases included
if(fFFMode) ffbckghistoleading->FillFF( trackPt, leadTrackPt , incrementJetPt, normFactorLeading);
if(fIJMode) ijbckghistoleading->FillIntraJet( trackV, leadTrackV, normFactorLeading );
+
+ if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt ); // OB added bgr QA
+
}
delete trackV;
}
if(fFFMode) ffbckghistoleading->FillFF( trackPt, leadTrackPt , incrementJetPt, normFactor2Jets);
if(fIJMode) ijbckghistoleading->FillIntraJet( trackV, leadTrackV, normFactor2Jets );
+
+ if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt ); // OB added bgr QA
+
}
delete trackV;
}
if(fIJMode) ijbckghistocuts->FillIntraJet( trackV, jet->MomentumVector(), normFactor3Jets);
if(fFFMode) ffbckghistoleading->FillFF( trackPt, leadTrackPt , incrementJetPt, normFactor3Jets );
- if(fIJMode) ijbckghistoleading->FillIntraJet( trackV, leadTrackV,normFactor3Jets );
+ if(fIJMode) ijbckghistoleading->FillIntraJet( trackV, leadTrackV, normFactor3Jets );
+
+ if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt ); // OB added bgr QA
+
}
delete trackV;
}
}
- if(type==kBckgClusters)
- {
- // To be implemented
- }
+ if(type==kBckgClustersOutLeading){ // clusters bgr: all tracks in clusters out of leading jet
+
+ TList* tracklistClustersOutLeading = new TList();
+ Double_t normFactorClusters = 0;
+ Float_t jetPt = jet->Pt();
+
+ GetClusterTracksOutOf1Jet(jet, tracklistClustersOutLeading, normFactorClusters);
+ fh1OutClustersMult->Fill(tracklistClustersOutLeading->GetSize());
+
+ for(Int_t it=0; it<tracklistClustersOutLeading->GetSize(); ++it){
+
+ AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistClustersOutLeading->At(it));
+ TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
+
+ Float_t trackPt = trackVP->Pt();
+
+ Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
+
+ if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactorClusters );
+ if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt );
+ delete trackV;
+ }
+
+ delete tracklistClustersOutLeading;
+
+ }
+
+ if(type == kBckgClusters){ // clusters bgr: all tracks in 'median cluster'
+
+ TList* tracklistClustersMedian = new TList();
+ Double_t normFactorClusters = 0;
+ Float_t jetPt = jet->Pt();
+
+ GetClusterTracksMedian(tracklistClustersMedian, normFactorClusters);
+ fh1MedianClustersMult->Fill(tracklistClustersMedian->GetSize());
+
+ for(Int_t it=0; it<tracklistClustersMedian->GetSize(); ++it){
+
+ AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistClustersMedian->At(it));
+ TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
+
+ Float_t trackPt = trackVP->Pt();
+
+ Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
+
+ if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactorClusters );
+ if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt );
+
+ delete trackV;
+ }
+
+ delete tracklistClustersMedian;
+ }
+
delete tracklistout2jets;
delete tracklistout3jets;
delete tracklistout2jetsStat;
delete tracklistout3jetsStat;
-
+
}
// ______________________________________________________________________________________________________________________________________________________
#include <TROOT.h>
#include <TRandom.h>
+#include <TRandom3.h>
#include <TSystem.h>
#include <TInterpreter.h>
#include <TChain.h>
fBranchBkgRec(""),
fBranchBkgGen(""),
fNonStdFile(""),
+ fRandomizer(0x0),
fUseAODJetInput(kFALSE),
fUseAODTrackInput(kFALSE),
fUseAODMCInput(kFALSE),
fTrackTypeRec(kTrackUndef),
fTrackTypeGen(kTrackUndef),
fEventClass(0),
+ fRPSubeventMethod(0),
fAvgTrials(1),
fExternalWeight(1),
fJetRecEtaWindow(0.5),
fMinJetPt(0),
fMinTrackPt(0.15),
fDeltaPhiWindow(90./180.*TMath::Pi()),
+ fCentrality(100),
fRPAngle(0),
fMultRec(0),
fMultGen(0),
fh1PtHardTrials(0x0),
fh1ZVtx(0x0),
fh1RP(0x0),
+ fh1Centrality(0x0),
fh1TmpRho(0x0),
fh2MultRec(0x0),
fh2MultGen(0x0),
+ fh2RPSubevents(0x0),
+ fh2RPCentrality(0x0),
+ fh2RPDeltaRP(0x0),
+ fh2RPQxQy(0x0),
+ fh2RPCosDeltaRP(0x0),
fh2PtFGen(0x0),
fh2RelPtFGen(0x0),
+ fh3RPPhiTracks(0x0),
fHistList(0x0)
{
for(int i = 0;i < kMaxStep*2;++i){
}
for(int ij = 0;ij <kJetTypes;++ij){
+ fFlagJetType[ij] = 1; // default = on
fh1NJets[ij] = 0;
fh1SumPtTrack[ij] = 0;
fh1PtJetsIn[ij] = 0;
fBranchBkgRec(""),
fBranchBkgGen(""),
fNonStdFile(""),
+ fRandomizer(0x0),
fUseAODJetInput(kFALSE),
fUseAODTrackInput(kFALSE),
fUseAODMCInput(kFALSE),
fTrackTypeRec(kTrackUndef),
fTrackTypeGen(kTrackUndef),
fEventClass(0),
+ fRPSubeventMethod(0),
fAvgTrials(1),
fExternalWeight(1),
fJetRecEtaWindow(0.5),
fMinJetPt(0),
fMinTrackPt(0.15),
fDeltaPhiWindow(90./180.*TMath::Pi()),
+ fCentrality(100),
fRPAngle(0),
fMultRec(0),
fMultGen(0),
fh1PtHardTrials(0x0),
fh1ZVtx(0x0),
fh1RP(0x0),
+ fh1Centrality(0x0),
fh1TmpRho(0x0),
fh2MultRec(0x0),
fh2MultGen(0x0),
+ fh2RPSubevents(0x0),
+ fh2RPCentrality(0x0),
+ fh2RPDeltaRP(0x0),
+ fh2RPQxQy(0x0),
+ fh2RPCosDeltaRP(0x0),
fh2PtFGen(0x0),
fh2RelPtFGen(0x0),
+ fh3RPPhiTracks(0x0),
fHistList(0x0)
{
}
for(int ij = 0;ij <kJetTypes;++ij){
+ fFlagJetType[ij] = 1; // default = on
fh1NJets[ij] = 0;
fh1SumPtTrack[ij] = 0;
fh1PtJetsIn[ij] = 0;
void AliAnalysisTaskJetSpectrum2::UserCreateOutputObjects()
{
-
+
// Connect the AOD
if (fDebug > 1) printf("AnalysisTaskJetSpectrum2::UserCreateOutputObjects() \n");
if(!fHistList)fHistList = new TList();
PostData(1, fHistList); // post data in any case once
+ if(!fRandomizer)fRandomizer = new TRandom3(0);
+
fHistList->SetOwner(kTRUE);
Bool_t oldStatus = TH1::AddDirectoryStatus();
TH1::AddDirectory(kFALSE);
MakeJetContainer();
fHistList->Add(fhnCorrelation);
- fHistList->Add(fhnCorrelationPhiZRec);
+ if(fhnCorrelationPhiZRec)fHistList->Add(fhnCorrelationPhiZRec);
for(int i = 0;i<kMaxStep*2;++i)fHistList->Add(fhnJetContainer[i]);
//
// Histogram
- const Int_t nBinPt = 320;
+ const Int_t nBinPt = 160;
Double_t binLimitsPt[nBinPt+1];
for(Int_t iPt = 0;iPt <= nBinPt;iPt++){
if(iPt == 0){
binLimitsPt[iPt] = 0.0;
}
else {// 1.0
- binLimitsPt[iPt] = binLimitsPt[iPt-1] + 1.0;
+ binLimitsPt[iPt] = binLimitsPt[iPt-1] + 2.0;
}
}
const Int_t nBinPhi = 90;
fh1RP = new TH1F("fh1RP","RP;#Psi",480,-180,360);
fHistList->Add(fh1RP);
+ fh1Centrality = new TH1F("fh1Centrality","cent;cent (%)",101,-0.5,100.5);
+ fHistList->Add(fh1Centrality);
+
fh2MultRec = new TH2F("fh2MultRec","multiplicity rec;# tracks;# jetrefs",400,-0.5,4000,400,0.,4000);
fHistList->Add(fh2MultRec);
fh2MultGen = new TH2F("fh2MultGen","multiplicity gen;# tracks;# jetrefs",400,-0.5,4000,400,0.,4000);
fHistList->Add(fh2MultGen);
- fh2PtFGen = new TH2F("fh2PtFGen",Form("%s vs. %s;p_{T,gen};p_{T,rec}",fBranchRec.Data(),fBranchGen.Data()),nBinPt,binLimitsPt,nBinPt,binLimitsPt);
- fHistList->Add(fh2PtFGen);
-
- fh2RelPtFGen = new TH2F("fh2RelPtFGen",";p_{T,gen};p_{T,rec}-p_{T,gen}/p_{T,Gen}",nBinPt,binLimitsPt,241,-2.41,2.41);
- fHistList->Add(fh2RelPtFGen);
-
- for(int ij = 0;ij <kJetTypes;++ij){
- TString cAdd = "";
- TString cJetBranch = "";
- if(ij==kJetRec){
- cAdd = "Rec";
- cJetBranch = fBranchRec.Data();
- }
- else if (ij==kJetGen){
- cAdd = "Gen";
- cJetBranch = fBranchGen.Data();
- }
- else if (ij==kJetRecFull){
- cAdd = "RecFull";
- cJetBranch = fBranchRec.Data();
- }
- else if (ij==kJetGenFull){
- cAdd = "GenFull";
- cJetBranch = fBranchGen.Data();
- }
+ fh2RPSubevents = new TH2F("fh2RPSubevents" ,"Reaction Plane Angle" , 180, 0, TMath::Pi(), 180, 0, TMath::Pi());
+ fHistList->Add( fh2RPSubevents);
- fh1NJets[ij] =new TH1F(Form("fh1N%sJets",cAdd.Data()),Form("N %s jets",cAdd.Data()),50,-0.5,49.5);
- fHistList->Add(fh1NJets[ij]);
+ fh2RPCentrality = new TH2F("fh2RPCentrality" ,"Reaction Plane Angle" , 20, 0.,100., 180, 0, TMath::Pi());
+ fHistList->Add(fh2RPCentrality);
- fh1PtJetsIn[ij] = new TH1F(Form("fh1PtJets%sIn",cAdd.Data()),Form("%s jets p_T;p_{T} (GeV/c)",cAdd.Data()),nBinPt,binLimitsPt);
- fHistList->Add(fh1PtJetsIn[ij]);
+ fh2RPDeltaRP = new TH2F("fh2DeltaRP" ,"Delta Reaction Plane Angle" , 100, -TMath::Pi()/2, TMath::Pi()/2,20,0.,100.0);
+ fHistList->Add(fh2RPDeltaRP);
- fh1PtTracksIn[ij] = new TH1F(Form("fh1PtTracks%sIn",cAdd.Data()),Form("%s track p_T;p_{T} (GeV/c)",cAdd.Data()),nBinPt,binLimitsPt);
- fHistList->Add(fh1PtTracksIn[ij]);
+ fh2RPQxQy = new TH2F("fh2RPQxQy" ,"" , 100, -100,100,100,-100,100);
+ fHistList->Add(fh2RPQxQy);
- fh1PtTracksInLow[ij] = new TH1F(Form("fh1PtTracks%sInLow",cAdd.Data()),Form("%s track p_T;p_{T} (GeV/c)",cAdd.Data()),100,0.,10.);
- fHistList->Add(fh1PtTracksInLow[ij]);
+ fh2RPCosDeltaRP = new TH2F("fh2RPCosDeltaRP" ,"" , 20, 0.001,100.001,100,-1,1);
+ fHistList->Add(fh2RPCosDeltaRP);
- fh1PtTracksLeadingIn[ij] = new TH1F(Form("fh1PtTracksLeading%sIn",cAdd.Data()),Form("%s track p_T;p_{T} (GeV/c)",cAdd.Data()),nBinPt,binLimitsPt);
- fHistList->Add(fh1PtTracksLeadingIn[ij]);
- fh1SumPtTrack[ij] = new TH1F(Form("fh1SumPtTrack%s",cAdd.Data()),Form("Sum %s track p_T;p_{T} (GeV/c)",cAdd.Data()),900,0.,900.);
- fHistList->Add(fh1SumPtTrack[ij]);
+ fh2PtFGen = new TH2F("fh2PtFGen",Form("%s vs. %s;p_{T,gen};p_{T,rec}",fBranchRec.Data(),fBranchGen.Data()),nBinPt,binLimitsPt,nBinPt,binLimitsPt);
+ fHistList->Add(fh2PtFGen);
- fh2NJetsPt[ij] = new TH2F(Form("fh2N%sJetsPt",cAdd.Data()),Form("Number of %s jets above threshhold;p_{T,cut} (GeV/c);N_{jets}",cAdd.Data()),nBinPt,binLimitsPt,50,-0.5,49.5);
- fHistList->Add(fh2NJetsPt[ij]);
+ fh2RelPtFGen = new TH2F("fh2RelPtFGen",";p_{T,gen};p_{T,rec}-p_{T,gen}/p_{T,Gen}",nBinPt,binLimitsPt,241,-2.41,2.41);
+ fHistList->Add(fh2RelPtFGen);
- fh2NTracksPt[ij] = new TH2F(Form("fh2N%sTracksPt",cAdd.Data()),Form("Number of %s tracks above threshhold;p_{T,cut} (GeV/c);N_{tracks}",cAdd.Data()),nBinPt,binLimitsPt,1000,0.,4000);
- fHistList->Add(fh2NTracksPt[ij]);
+ fh3RPPhiTracks = new TH3F("fh3RPPhiTracks","Phi Tracks Pt Centrality", 10, 0.,100.,20,-5,5,180, 0, 2*TMath::Pi());
+ fHistList->Add(fh3RPPhiTracks);
+
+ for(int ij = 0;ij <kJetTypes;++ij){
+ TString cAdd = "";
+ TString cJetBranch = "";
+ if(ij==kJetRec){
+ cAdd = "Rec";
+ cJetBranch = fBranchRec.Data();
+ }
+ else if (ij==kJetGen){
+ cAdd = "Gen";
+ cJetBranch = fBranchGen.Data();
+ }
+ else if (ij==kJetRecFull){
+ cAdd = "RecFull";
+ cJetBranch = fBranchRec.Data();
+ }
+ else if (ij==kJetGenFull){
+ cAdd = "GenFull";
+ cJetBranch = fBranchGen.Data();
+ }
- fh3MultTrackPtRP[ij] = new TH3F(Form("fh3MultTrackPtRP%s",
- cAdd.Data()),Form("%s track p_T;# tracks;;p_{T} (GeV/c)",cAdd.Data()),400,0,4000,nBinPt,0,300,(Int_t)fNRPBins,-0.5,fNRPBins-0.5);
- fHistList->Add(fh3MultTrackPtRP[ij]);
+ if(cJetBranch.Length()==0)fFlagJetType[ij] = 0;
+ if(!fFlagJetType[ij])continue;
- fh2LeadingTrackPtTrackPhi[ij] = new TH2F(Form("fh2Leading%sTrackPtTrackPhi",cAdd.Data()),Form("phi of leading %s track;p_{T};#phi;",cAdd.Data()),
+ fh1NJets[ij] =new TH1F(Form("fh1N%sJets",cAdd.Data()),Form("N %s jets",cAdd.Data()),50,-0.5,49.5);
+ fHistList->Add(fh1NJets[ij]);
+
+ fh1PtJetsIn[ij] = new TH1F(Form("fh1PtJets%sIn",cAdd.Data()),Form("%s jets p_T;p_{T} (GeV/c)",cAdd.Data()),nBinPt,binLimitsPt);
+ fHistList->Add(fh1PtJetsIn[ij]);
+
+ fh1PtTracksIn[ij] = new TH1F(Form("fh1PtTracks%sIn",cAdd.Data()),Form("%s track p_T;p_{T} (GeV/c)",cAdd.Data()),nBinPt,binLimitsPt);
+ fHistList->Add(fh1PtTracksIn[ij]);
+
+ fh1PtTracksInLow[ij] = new TH1F(Form("fh1PtTracks%sInLow",cAdd.Data()),Form("%s track p_T;p_{T} (GeV/c)",cAdd.Data()),100,0.,10.);
+ fHistList->Add(fh1PtTracksInLow[ij]);
+
+ fh1PtTracksLeadingIn[ij] = new TH1F(Form("fh1PtTracksLeading%sIn",cAdd.Data()),Form("%s track p_T;p_{T} (GeV/c)",cAdd.Data()),nBinPt,binLimitsPt);
+ fHistList->Add(fh1PtTracksLeadingIn[ij]);
+
+ fh1SumPtTrack[ij] = new TH1F(Form("fh1SumPtTrack%s",cAdd.Data()),Form("Sum %s track p_T;p_{T} (GeV/c)",cAdd.Data()),900,0.,900.);
+ fHistList->Add(fh1SumPtTrack[ij]);
+
+ fh2NJetsPt[ij] = new TH2F(Form("fh2N%sJetsPt",cAdd.Data()),Form("Number of %s jets above threshhold;p_{T,cut} (GeV/c);N_{jets}",cAdd.Data()),nBinPt,binLimitsPt,50,-0.5,49.5);
+ fHistList->Add(fh2NJetsPt[ij]);
+
+ fh2NTracksPt[ij] = new TH2F(Form("fh2N%sTracksPt",cAdd.Data()),Form("Number of %s tracks above threshhold;p_{T,cut} (GeV/c);N_{tracks}",cAdd.Data()),nBinPt,binLimitsPt,1000,0.,4000);
+ fHistList->Add(fh2NTracksPt[ij]);
+
+ fh3MultTrackPtRP[ij] = new TH3F(Form("fh3MultTrackPtRP%s",
+ cAdd.Data()),Form("%s track p_T;# tracks;;p_{T} (GeV/c)",cAdd.Data()),400,0,4000,nBinPt,0,300,(Int_t)fNRPBins,-0.5,fNRPBins-0.5);
+ fHistList->Add(fh3MultTrackPtRP[ij]);
+
+ fh2LeadingTrackPtTrackPhi[ij] = new TH2F(Form("fh2Leading%sTrackPtTrackPhi",cAdd.Data()),Form("phi of leading %s track;p_{T};#phi;",cAdd.Data()),
nBinPt,binLimitsPt,nBinPhi,binLimitsPhi);
fHistList->Add(fh2LeadingTrackPtTrackPhi[ij]);
// second fill the correlation histograms, here we limit to the n-th leading jet in case of the reconstructed
+
TList genJetsList; // full acceptance
TList genJetsListCut; // acceptance cut
TList recJetsList; // full acceptance
Double_t nTrials = 1; // Trials for MC trigger
fh1Trials->Fill("#sum{ntrials}",fAvgTrials);
+ // Getting some global properties
+ fCentrality = GetCentrality();
+ fh1Centrality->Fill(fCentrality);
+
+
if((fAnalysisType&kAnaMCESD)==kAnaMCESD){
// this is the part we only use when we have MC information
AliMCEvent* mcEvent = MCEvent();
nT = GetListOfTracks(&genParticles,fTrackTypeGen);
if(fDebug>2)Printf("%s:%d Selected Gen tracks: %d %d",(char*)__FILE__,__LINE__,nT,genParticles.GetEntries());
+ CalculateReactionPlaneAngle(&recParticles);
+
// Event control and counting ...
// MC
fh1PtHard->Fill(ptHard,eventW);
Int_t recMult1 = recParticles.GetEntries();
Int_t genMult1 = genParticles.GetEntries();
- Int_t recMult2 = MultFromJetRefs(aodRecJets);
- Int_t genMult2 = MultFromJetRefs(aodGenJets);
+ Int_t recMult2 = MultFromJetRefs(aodBackRecJets);
+ Int_t genMult2 = MultFromJetRefs(aodBackGenJets);
fh2MultRec->Fill(recMult1,recMult2);
fh2MultGen->Fill(genMult1,genMult2);
if(iType>=kJetTypes){
return;
}
+ if(!fFlagJetType[iType])return;
Int_t refMult = fMultRec;
if(iType==kJetGen||iType==kJetGenFull){
// fill leading jets...
AliVParticle *leadTrack = LeadingTrackFromJetRefs(jet);
// AliVParticle *leadTrack = LeadingTrackInCone(jet,&particlesList);
+ Int_t phiBin = GetPhiBin(phiJet-fRPAngle);
if(ptJet>10){
if(ij<kMaxJets){
fh2PhiEta[iType][ij]->Fill(phiJet,etaJet);
fh2EtaArea[iType][kMaxJets]->Fill(etaJet,jet->EffectiveAreaCharged());
}
if(ij<kMaxJets){
- fh3MultPtRP[iType][ij]->Fill(refMult,ptJet,0);
+ fh3MultPtRP[iType][ij]->Fill(refMult,ptJet,phiBin);
fh2PhiPt[iType][ij]->Fill(phiJet,ptJet);
fh2EtaPt[iType][ij]->Fill(etaJet,ptJet);
if(leadTrack)fh2LTrackPtJetPt[iType][ij]->Fill(leadTrack->Pt(),ptJet);
}
- fh3MultPtRP[iType][kMaxJets]->Fill(refMult,ptJet,0);
+ fh3MultPtRP[iType][kMaxJets]->Fill(refMult,ptJet,phiBin);
fh2PhiPt[iType][kMaxJets]->Fill(phiJet,ptJet);
fh2EtaPt[iType][kMaxJets]->Fill(etaJet,ptJet);
if(leadTrack)fh2LTrackPtJetPt[iType][kMaxJets]->Fill(leadTrack->Pt(),ptJet);
void AliAnalysisTaskJetSpectrum2::FillTrackHistos(TList &particlesList,int iType){
+ if(!fFlagJetType[iType])return;
Int_t refMult = fMultRec;
if(iType==kJetGen||iType==kJetGenFull){
refMult = fMultGen;
+
}
Int_t nTrackOver = particlesList.GetSize();
Float_t tmpPt = tmpTrack->Pt();
fh1PtTracksIn[iType]->Fill(tmpPt);
fh1PtTracksInLow[iType]->Fill(tmpPt);
- fh3MultTrackPtRP[iType]->Fill(refMult,tmpPt,0);
+
sumPt += tmpPt;
Float_t tmpPhi = tmpTrack->Phi();
if(tmpPhi<0)tmpPhi+=TMath::Pi()*2.;
+ Int_t phiBin = GetPhiBin(tmpPhi-fRPAngle);
+ fh3MultTrackPtRP[iType]->Fill(refMult,tmpPt,phiBin);
+
if(tmpTrack==leading){
fh1PtTracksLeadingIn[iType]->Fill(tmpPt);
fh2LeadingTrackPtTrackPhi[iType]->Fill(tmpPt,tmpPhi);
//arrays for the number of bins in each dimension
Int_t iBin[kNvar];
- iBin[0] = 320; //bins in pt
+ iBin[0] = 160; //bins in pt
iBin[1] = 1; //bins in eta
iBin[2] = 1; // bins in phi
}
fhnCorrelation->Sumw2();
+
+ for(Int_t ivar = 0; ivar < kNvar; ivar++)
+ delete [] binEdges[ivar];
+
+
+
// for second correlation histogram
iBinPhiZ[2] = 20; // bins in Z
iBinPhiZ[3] = 80; //bins in ptgen
+
+ return;
//arrays for lower bounds :
Double_t* binEdgesPhiZ[kNvarPhiZ];
for(Int_t ivar = 0; ivar < kNvarPhiZ; ivar++)
}
fhnCorrelationPhiZRec->Sumw2();
-
- // Add a histogram for Fake jets
-
- for(Int_t ivar = 0; ivar < kNvar; ivar++)
- delete [] binEdges[ivar];
-
for(Int_t ivar = 0; ivar < kNvarPhiZ; ivar++)
delete [] binEdgesPhiZ[ivar];
}
+Float_t AliAnalysisTaskJetSpectrum2::GetCentrality(){
+ AliAODEvent *aod = 0;
+ if(fUseAODTrackInput)aod = dynamic_cast<AliAODEvent*>(InputEvent());
+ else aod = AODEvent();
+ if(!aod){
+ return 100;
+ }
+ return aod->GetHeader()->GetCentrality();
+}
+
+
Bool_t AliAnalysisTaskJetSpectrum2::JetSelected(AliAODJet *jet){
Bool_t selected = false;
}
return leading;
}
+
+Bool_t AliAnalysisTaskJetSpectrum2::CalculateReactionPlaneAngle(const TList *trackList)
+{
+
+ if(!trackList)return kFALSE;
+ fRPAngle=0;
+
+ // need to get this info from elsewhere??
+ Double_t fFlatA[2] = {1,1};
+ Double_t fFlatB[2] = {1,1};
+
+
+ Double_t fPsiRP =0,fDeltaPsiRP = 0;
+
+
+
+ TVector2 mQ,mQ1,mQ2;
+ Float_t mQx=0, mQy=0;
+
+ Float_t mQx1=0, mQy1=0;
+ Float_t mQx2=0, mQy2=0;
+
+ AliVParticle *track=0x0;
+ Int_t count[3]={0,0,0};
+
+
+ for (Int_t iter=0;iter<trackList->GetEntries();iter++){
+
+ track=(AliVParticle*)trackList->At(iter);
+
+ //cuts already applied before
+ // Comment DCA not correctly implemented yet for AOD tracks
+
+ Double_t momentum;
+ if(track->Charge()>0){momentum=track->Pt();}
+ else{momentum=-track->Pt();}
+
+
+
+ // For Weighting
+ fh3RPPhiTracks->Fill(fCentrality,momentum,track->Phi());
+ count[0]++;
+
+ // Double_t phiweight=GetPhiWeight(track->Phi(),momentum);
+ Double_t phiweight=1;
+ Double_t weight=2;
+ if(track->Pt()<2){weight=track->Pt();}
+
+
+ mQx += (cos(2*track->Phi()))*weight*phiweight;
+ mQy += (sin(2*track->Phi()))*weight*phiweight;
+
+ // Make random Subevents
+
+ if(fRPSubeventMethod==0){
+ if(fRandomizer->Binomial(1,0.5)){
+ mQx1 += (cos(2*track->Phi()))*weight*phiweight;
+ mQy1 += (sin(2*track->Phi()))*weight*phiweight;
+ count[1]++;}
+ else{
+ mQx2 += (cos(2*track->Phi()))*weight*phiweight;
+ mQy2 += (sin(2*track->Phi()))*weight*phiweight;
+ count[2]++;}
+ }
+ else if(fRPSubeventMethod==1){
+ // Make eta dependent subevents
+ if(track->Eta()>0){
+ mQx1 += (cos(2*track->Phi()))*weight*phiweight;
+ mQy1 += (sin(2*track->Phi()))*weight*phiweight;
+ count[1]++;}
+ else{
+ mQx2 += (cos(2*track->Phi()))*weight*phiweight;
+ mQy2 += (sin(2*track->Phi()))*weight*phiweight;
+ count[2]++;}
+ }
+
+ }
+
+
+
+ //If no track passes the cuts, the ,Q.Phi() will return Pi and a peak at Pi/2 in the RP Angular Distribution will appear
+ if(count[0]==0||count[1]==0||count[2]==0){
+ return kFALSE;
+ }
+
+ mQ.Set(mQx,mQy);
+ mQ1.Set(mQx1,mQy1);
+ mQ2.Set(mQx2,mQy2);
+
+ // cout<<"MQ"<<mQx<<" " <<mQy<<" psi"<<endl;
+
+ fPsiRP=mQ.Phi()/2;
+
+ //Correction
+ fPsiRP+=fFlatA[0]*TMath::Cos(2*fPsiRP)+fFlatB[0]*TMath::Sin(2*fPsiRP)+fFlatA[1]*TMath::Cos(4*fPsiRP)+fFlatB[1]*TMath::Sin(4*fPsiRP);
+
+ Double_t fPsiRP1=mQ1.Phi()/2;
+ fPsiRP1+=fFlatA[0]*TMath::Cos(2*fPsiRP1)+fFlatB[0]*TMath::Sin(2*fPsiRP1)+fFlatA[1]*TMath::Cos(4*fPsiRP1)+fFlatB[1]*TMath::Sin(4*fPsiRP1);
+ Double_t fPsiRP2=mQ2.Phi()/2;
+ fPsiRP2+=fFlatA[0]*TMath::Cos(2*fPsiRP2)+fFlatB[0]*TMath::Sin(2*fPsiRP2)+fFlatA[1]*TMath::Cos(4*fPsiRP2)+fFlatB[1]*TMath::Sin(4*fPsiRP2);
+ fDeltaPsiRP=fPsiRP1-fPsiRP2;
+
+ if(fPsiRP>TMath::Pi()){fPsiRP-=TMath::Pi();}
+ if(fPsiRP<0){fPsiRP+=TMath::Pi();}
+
+ // reactionplaneangle + Pi() is the same angle
+ if(TMath::Abs(fDeltaPsiRP)>TMath::Pi()/2){
+ if(fDeltaPsiRP>0)fDeltaPsiRP-=TMath::Pi();
+ else fDeltaPsiRP+=TMath::Pi();
+ }
+
+ Double_t cos2deltaRP=TMath::Cos(2*fDeltaPsiRP);
+
+ // FillHistograms
+ fh2RPSubevents->Fill(fPsiRP1,fPsiRP2);
+ fh1RP->Fill(fPsiRP);
+ fh2RPCentrality->Fill(fCentrality,fPsiRP);
+ fh2RPDeltaRP->Fill(fDeltaPsiRP,fCentrality);
+ fh2RPQxQy->Fill(mQx,mQy);
+ fh2RPCosDeltaRP->Fill(fCentrality,cos2deltaRP);
+
+ fRPAngle=fPsiRP;
+
+ return kTRUE;
+}
+
+Int_t AliAnalysisTaskJetSpectrum2::GetPhiBin(Double_t phi)
+{
+ Int_t phibin=-1;
+ if(!(TMath::Abs(phi)<=2*TMath::Pi())){AliError("phi w.r.t. RP out of defined range");return -1;}
+ Double_t phiwrtrp=TMath::ACos(TMath::Abs(TMath::Cos(phi)));
+ phibin=Int_t(fNRPBins*phiwrtrp/(0.5*TMath::Pi()));
+ if(phibin<0||phibin>=fNRPBins){AliError("Phi Bin not defined");}
+ return phibin;
+}
+
+ //________________________________________________________________________
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff