From: kleinb Date: Wed, 30 Mar 2011 07:14:49 +0000 (+0000) Subject: updates to FF task (Oliver) Minor bug fixes and reduced hisograms for spectrum task X-Git-Url: http://git.uio.no/git/?a=commitdiff_plain;h=742ee86c0c0ebc1aeb5528e80dc6a1e06e43e84a;p=u%2Fmrichter%2FAliRoot.git updates to FF task (Oliver) Minor bug fixes and reduced hisograms for spectrum task --- diff --git a/PWG4/JetTasks/AliAnalysisTaskFragmentationFunction.cxx b/PWG4/JetTasks/AliAnalysisTaskFragmentationFunction.cxx index cdbf4df6a36..4548693ad3e 100644 --- a/PWG4/JetTasks/AliAnalysisTaskFragmentationFunction.cxx +++ b/PWG4/JetTasks/AliAnalysisTaskFragmentationFunction.cxx @@ -51,7 +51,6 @@ #include "AliAnalysisTaskFragmentationFunction.h" - ClassImp(AliAnalysisTaskFragmentationFunction) //____________________________________________________________________________ @@ -61,6 +60,7 @@ AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction() ,fAOD(0) ,fBranchRecJets("jets") ,fBranchRecBackJets("") + ,fBranchRecBckgClusters("") ,fBranchGenJets("") ,fTrackTypeGen(0) ,fJetTypeGen(0) @@ -93,7 +93,8 @@ AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction() ,fDJMode(0) ,fEffMode(0) ,fPhiCorrMode(0) - ,fUseRecEffRecJetPtBins(1) + ,fUseRecEffRecJetPtBins(0) + ,fUseResponseRecJetPtBins(1) ,fAvgTrials(0) ,fTracksRec(0) ,fTracksRecCuts(0) @@ -256,18 +257,23 @@ AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction() ,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) @@ -280,6 +286,10 @@ AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction() ,fFFBckgHisto2RecLeading(0) ,fFFBckgHisto2Gen(0) ,fFFBckgHisto2GenLeading(0) + ,fFFBckgHisto3RecCuts(0) + ,fFFBckgHisto3RecLeading(0) + ,fFFBckgHisto3Gen(0) + ,fFFBckgHisto3GenLeading(0) ,fIJBckgHisto0RecCuts(0) ,fIJBckgHisto0RecLeading(0) ,fIJBckgHisto0Gen(0) @@ -292,6 +302,10 @@ AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction() ,fIJBckgHisto2RecLeading(0) ,fIJBckgHisto2Gen(0) ,fIJBckgHisto2GenLeading(0) + ,fIJBckgHisto3RecCuts(0) + ,fIJBckgHisto3RecLeading(0) + ,fIJBckgHisto3Gen(0) + ,fIJBckgHisto3GenLeading(0) ,fRandom(0) ,fBckgSubMethod(0) { @@ -299,6 +313,7 @@ AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction() fBckgType[0] = 0; fBckgType[1] = 0; fBckgType[2] = 0; + fBckgType[3] = 0; } //__________________________________________________________________________________________ @@ -308,6 +323,7 @@ AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction(const ,fAOD(0) ,fBranchRecJets("jets") ,fBranchRecBackJets("") + ,fBranchRecBckgClusters("") ,fBranchGenJets("") ,fTrackTypeGen(0) ,fJetTypeGen(0) @@ -340,7 +356,8 @@ AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction(const ,fDJMode(0) ,fEffMode(0) ,fPhiCorrMode(0) - ,fUseRecEffRecJetPtBins(1) + ,fUseRecEffRecJetPtBins(0) + ,fUseResponseRecJetPtBins(1) ,fAvgTrials(0) ,fTracksRec(0) ,fTracksRecCuts(0) @@ -503,18 +520,23 @@ AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction(const ,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) @@ -527,6 +549,10 @@ AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction(const ,fFFBckgHisto2RecLeading(0) ,fFFBckgHisto2Gen(0) ,fFFBckgHisto2GenLeading(0) + ,fFFBckgHisto3RecCuts(0) + ,fFFBckgHisto3RecLeading(0) + ,fFFBckgHisto3Gen(0) + ,fFFBckgHisto3GenLeading(0) ,fIJBckgHisto0RecCuts(0) ,fIJBckgHisto0RecLeading(0) ,fIJBckgHisto0Gen(0) @@ -539,6 +565,10 @@ AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction(const ,fIJBckgHisto2RecLeading(0) ,fIJBckgHisto2Gen(0) ,fIJBckgHisto2GenLeading(0) + ,fIJBckgHisto3RecCuts(0) + ,fIJBckgHisto3RecLeading(0) + ,fIJBckgHisto3Gen(0) + ,fIJBckgHisto3GenLeading(0) ,fRandom(0) ,fBckgSubMethod(0) { @@ -546,6 +576,7 @@ AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction(const fBckgType[0] = 0; fBckgType[1] = 0; fBckgType[2] = 0; + fBckgType[3] = 0; DefineOutput(1,TList::Class()); @@ -559,6 +590,7 @@ AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction(const ,fAOD(copy.fAOD) ,fBranchRecJets(copy.fBranchRecJets) ,fBranchRecBackJets(copy.fBranchRecBackJets) + ,fBranchRecBckgClusters(copy.fBranchRecBckgClusters) ,fBranchGenJets(copy.fBranchGenJets) ,fTrackTypeGen(copy.fTrackTypeGen) ,fJetTypeGen(copy.fJetTypeGen) @@ -592,6 +624,7 @@ AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction(const ,fEffMode(copy.fEffMode) ,fPhiCorrMode(copy.fPhiCorrMode) ,fUseRecEffRecJetPtBins(copy.fUseRecEffRecJetPtBins) + ,fUseResponseRecJetPtBins(copy.fUseResponseRecJetPtBins) ,fAvgTrials(copy.fAvgTrials) ,fTracksRec(copy.fTracksRec) ,fTracksRecCuts(copy.fTracksRecCuts) @@ -754,18 +787,23 @@ AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction(const ,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) @@ -778,6 +816,10 @@ AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction(const ,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) @@ -790,6 +832,10 @@ AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction(const ,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) { @@ -797,6 +843,7 @@ AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction(const fBckgType[0] = copy.fBckgType[0]; fBckgType[1] = copy.fBckgType[1]; fBckgType[2] = copy.fBckgType[2]; + fBckgType[3] = copy.fBckgType[3]; } // _________________________________________________________________________________________________________________________________ @@ -811,6 +858,7 @@ AliAnalysisTaskFragmentationFunction& AliAnalysisTaskFragmentationFunction::oper fAOD = o.fAOD; fBranchRecJets = o.fBranchRecJets; fBranchRecBackJets = o.fBranchRecBackJets; + fBranchRecBckgClusters = o.fBranchRecBckgClusters; fBranchGenJets = o.fBranchGenJets; fTrackTypeGen = o.fTrackTypeGen; fJetTypeGen = o.fJetTypeGen; @@ -846,7 +894,9 @@ AliAnalysisTaskFragmentationFunction& AliAnalysisTaskFragmentationFunction::oper 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; @@ -1007,18 +1057,23 @@ AliAnalysisTaskFragmentationFunction& AliAnalysisTaskFragmentationFunction::oper 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; @@ -1031,6 +1086,10 @@ AliAnalysisTaskFragmentationFunction& AliAnalysisTaskFragmentationFunction::oper 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; @@ -1043,6 +1102,8 @@ AliAnalysisTaskFragmentationFunction& AliAnalysisTaskFragmentationFunction::oper fIJBckgHisto2RecLeading = o.fIJBckgHisto2RecLeading; fIJBckgHisto2Gen = o.fIJBckgHisto2Gen; fIJBckgHisto2GenLeading = o.fIJBckgHisto2GenLeading; + fIJBckgHisto3Gen = o.fIJBckgHisto3Gen; + fIJBckgHisto3GenLeading = o.fIJBckgHisto3GenLeading; fRandom = o.fRandom; fBckgSubMethod = o.fBckgSubMethod; } @@ -1064,7 +1125,11 @@ AliAnalysisTaskFragmentationFunction::~AliAnalysisTaskFragmentationFunction() 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; @@ -1421,7 +1486,7 @@ void AliAnalysisTaskFragmentationFunction::AliFragFuncQATrackHistos::DefineHisto 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"); @@ -2204,7 +2269,11 @@ void AliAnalysisTaskFragmentationFunction::UserCreateOutputObjects() // 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); @@ -2235,7 +2304,7 @@ void AliAnalysisTaskFragmentationFunction::UserCreateOutputObjects() 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.); @@ -2253,26 +2322,36 @@ void AliAnalysisTaskFragmentationFunction::UserCreateOutputObjects() // 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, @@ -2509,8 +2588,8 @@ void AliAnalysisTaskFragmentationFunction::UserCreateOutputObjects() // 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"; @@ -2523,7 +2602,8 @@ void AliAnalysisTaskFragmentationFunction::UserCreateOutputObjects() 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); } @@ -2552,6 +2632,14 @@ void AliAnalysisTaskFragmentationFunction::UserCreateOutputObjects() 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){ @@ -2606,6 +2694,22 @@ void AliAnalysisTaskFragmentationFunction::UserCreateOutputObjects() 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){ @@ -2784,6 +2888,10 @@ void AliAnalysisTaskFragmentationFunction::UserCreateOutputObjects() fFFBckgHisto2RecLeading->DefineHistos(); fFFBckgHisto2Gen->DefineHistos(); fFFBckgHisto2GenLeading->DefineHistos(); + fFFBckgHisto3RecCuts->DefineHistos(); + fFFBckgHisto3RecLeading->DefineHistos(); + fFFBckgHisto3Gen->DefineHistos(); + fFFBckgHisto3GenLeading->DefineHistos(); } if(fIJMode){ @@ -2808,6 +2916,8 @@ void AliAnalysisTaskFragmentationFunction::UserCreateOutputObjects() fQABckgHisto1Gen->DefineHistos(); fQABckgHisto2RecCuts->DefineHistos(); fQABckgHisto2Gen->DefineHistos(); + fQABckgHisto3RecCuts->DefineHistos(); + fQABckgHisto3Gen->DefineHistos(); } } // end: background @@ -2862,6 +2972,8 @@ void AliAnalysisTaskFragmentationFunction::UserCreateOutputObjects() fFFBckgHisto1RecLeading->AddToOutput(fCommonHistList); fFFBckgHisto2RecCuts->AddToOutput(fCommonHistList); fFFBckgHisto2RecLeading->AddToOutput(fCommonHistList); + fFFBckgHisto3RecCuts->AddToOutput(fCommonHistList); + fFFBckgHisto3RecLeading->AddToOutput(fCommonHistList); if(genJets && genTracks){ fFFBckgHisto0Gen->AddToOutput(fCommonHistList); fFFBckgHisto0GenLeading->AddToOutput(fCommonHistList); @@ -2869,6 +2981,8 @@ void AliAnalysisTaskFragmentationFunction::UserCreateOutputObjects() fFFBckgHisto1GenLeading->AddToOutput(fCommonHistList); fFFBckgHisto2Gen->AddToOutput(fCommonHistList); fFFBckgHisto2GenLeading->AddToOutput(fCommonHistList); + fFFBckgHisto3Gen->AddToOutput(fCommonHistList); + fFFBckgHisto3GenLeading->AddToOutput(fCommonHistList); } } @@ -2876,27 +2990,35 @@ void AliAnalysisTaskFragmentationFunction::UserCreateOutputObjects() 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 @@ -2919,16 +3041,19 @@ void AliAnalysisTaskFragmentationFunction::UserCreateOutputObjects() } } - 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 @@ -3204,27 +3329,33 @@ void AliAnalysisTaskFragmentationFunction::UserExec(Option_t *) 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); + } } @@ -3330,7 +3461,7 @@ void AliAnalysisTaskFragmentationFunction::UserExec(Option_t *) 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, @@ -3347,6 +3478,11 @@ void AliAnalysisTaskFragmentationFunction::UserExec(Option_t *) 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; @@ -3747,8 +3883,8 @@ void AliAnalysisTaskFragmentationFunction::UserExec(Option_t *) 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; } @@ -3768,7 +3904,7 @@ void AliAnalysisTaskFragmentationFunction::UserExec(Option_t *) 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, @@ -3811,7 +3947,11 @@ void AliAnalysisTaskFragmentationFunction::UserExec(Option_t *) 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(); @@ -3819,7 +3959,6 @@ void AliAnalysisTaskFragmentationFunction::UserExec(Option_t *) //Post output data. PostData(1, fCommonHistList); - } //________________________________________________________________________________________ @@ -4156,17 +4295,60 @@ Int_t AliAnalysisTaskFragmentationFunction::GetListOfJets(TList *list, Int_t typ } } -// _______________________________________________________________________________ -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(fAOD->FindListObject(fBranchRecBckgClusters.Data())); + if(!aodRecJets) aodRecJets = dynamic_cast(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; ijGetEntries(); ++ij){ + + AliAODJet *tmp = dynamic_cast(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; } // _________________________________________________________________________________________________________ @@ -4509,7 +4691,7 @@ void AliAnalysisTaskFragmentationFunction::FillJetTrackResponse(THnSparse* hnRes 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); @@ -4521,7 +4703,7 @@ void AliAnalysisTaskFragmentationFunction::FillJetTrackResponse(THnSparse* hnRes 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); @@ -4852,6 +5034,149 @@ Float_t AliAnalysisTaskFragmentationFunction::CalcJetArea(const Float_t etaJet, } +// ___________________________________________________________________________________________________________________________ +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; ijGetEntries(); ++ij){ + + AliAODJet* bgrCluster = (AliAODJet*)(fBckgJetsRec->At(ij)); // not 'recCuts': use all clusters in full eta range + + Double_t dR = jet->DeltaR(bgrCluster); + + if(dRPt(); + Double_t area = bgrCluster->EffectiveAreaCharged(); + areaTotal += area; + sumPtTotal += clusterPt; + + Int_t nTracksJet = bgrCluster->GetRefTracks()->GetEntries(); + + for(Int_t it = 0; it(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; ijAt(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(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, @@ -4947,6 +5272,7 @@ void AliAnalysisTaskFragmentationFunction::FillBckgHistos(Int_t type, TList* inp Double_t normFactorLeading = 0.; GetTracksOutOfNJetsStat(1,inputtracklist, tracklistoutleadingStat, inputjetlist, sumPtOutLeadingStat, normFactorLeading); + if(type==kBckgOutLJStat) fh1OutLeadingStatMult->Fill(tracklistoutleadingStat->GetSize()); for(Int_t it=0; itGetSize(); ++it){ @@ -4967,7 +5293,7 @@ void AliAnalysisTaskFragmentationFunction::FillBckgHistos(Int_t type, TList* inp 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 @@ -4978,6 +5304,9 @@ void AliAnalysisTaskFragmentationFunction::FillBckgHistos(Int_t type, TList* inp 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; } @@ -5240,6 +5569,9 @@ void AliAnalysisTaskFragmentationFunction::FillBckgHistos(Int_t type, TList* inp 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; } @@ -5347,7 +5679,10 @@ void AliAnalysisTaskFragmentationFunction::FillBckgHistos(Int_t type, TList* inp 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; } @@ -5370,16 +5705,66 @@ void AliAnalysisTaskFragmentationFunction::FillBckgHistos(Int_t type, TList* inp } - 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; itGetSize(); ++it){ + + AliVParticle* trackVP = dynamic_cast(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; itGetSize(); ++it){ + + AliVParticle* trackVP = dynamic_cast(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; - + } // ______________________________________________________________________________________________________________________________________________________ diff --git a/PWG4/JetTasks/AliAnalysisTaskFragmentationFunction.h b/PWG4/JetTasks/AliAnalysisTaskFragmentationFunction.h index 6be2855c40e..3a323e21769 100644 --- a/PWG4/JetTasks/AliAnalysisTaskFragmentationFunction.h +++ b/PWG4/JetTasks/AliAnalysisTaskFragmentationFunction.h @@ -335,6 +335,7 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE { virtual void SetJetTypeRecEff(Int_t i){fJetTypeRecEff = i;} virtual void SetBranchRecBackJets(const char* c){fBranchRecBackJets = c;} + virtual void SetBranchRecBackClusters(const char* c){fBranchRecBckgClusters = c;} virtual void SetBranchGenJets(const char* c){fBranchGenJets = c;} virtual void SetBranchRecJets(const char* c){fBranchRecJets = c;} @@ -359,8 +360,8 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE { virtual void SetFFRadius(Float_t r = 0.4) { fFFRadius = r; } virtual void SetFFBckgRadius(Float_t r = 0.7) { fFFBckgRadius = r; } virtual void SetBckgMode(Bool_t bg = 1) { fBckgMode = bg; } - virtual void SetBckgType(Int_t bg0 = 0, Int_t bg1 = 1,Int_t bg2 = 2) - { fBckgType[0] = bg0; fBckgType[1] = bg1; fBckgType[2] = bg2;} + virtual void SetBckgType(Int_t bg0 = 0, Int_t bg1 = 1,Int_t bg2 = 2, Int_t bg3 = 3) + { fBckgType[0] = bg0; fBckgType[1] = bg1; fBckgType[2] = bg2; fBckgType[3] = bg3; } virtual void SetIJMode(Int_t ij = 1) {fIJMode = ij;} virtual void SetQAMode(Int_t qa = 3) {fQAMode = qa;} virtual void SetFFMode(Int_t ff = 1) {fFFMode = ff;} @@ -369,7 +370,8 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE { virtual void SetPhiCorrMode(Int_t pc = 1) {fPhiCorrMode = pc;} virtual void SetBckgSubMethod(Int_t bg = 0) {fBckgSubMethod = bg;} - virtual void UseRecEffRecJetPtBins(Bool_t useRec = kTRUE) { fUseRecEffRecJetPtBins = useRec; } + virtual void UseRecEffRecJetPtBins(Bool_t useRec = kFALSE) { fUseRecEffRecJetPtBins = useRec; } + virtual void UseResponseRecJetPtBins(Bool_t useRec = kTRUE) { fUseResponseRecJetPtBins = useRec; } static void SetProperties(TH1* h,const char* x, const char* y); static void SetProperties(TH1* h,const char* x, const char* y,const char* z); @@ -460,6 +462,9 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE { Float_t CalcJetArea(const Float_t etaJet, const Float_t rc) const; + void GetClusterTracksOutOf1Jet(AliAODJet* jet, TList* outputlist, Double_t &normFactor); + void GetClusterTracksMedian(TList* outputlist, Double_t &normFactor); + void FillBckgHistos(Int_t type, TList* inputtracklist, TList* inputjetlist, AliAODJet* jet, Float_t leadTrackPt, TLorentzVector* leadTrackV, AliFragFuncHistos* ffbckghistocuts, AliFragFuncHistos* ffbckghistoleading,AliFragFuncIntraJetHistos* ijbckghistocuts, @@ -471,22 +476,24 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE { enum {kTrackUndef=0, kTrackAOD, kTrackAODQualityCuts, kTrackAODCuts, kTrackKineAll, kTrackKineCharged, kTrackKineChargedAcceptance, kTrackAODMCAll, kTrackAODMCCharged, kTrackAODMCChargedAcceptance}; enum {kJetsUndef=0, kJetsRec, kJetsRecAcceptance, kJetsGen, kJetsGenAcceptance, kJetsKine, kJetsKineAcceptance}; - enum {kBckgPerp=0, kBckgOutLJ, kBckgOut2J, kBckgOut3J, kBckgOutAJ, kBckgOutLJStat, kBckgOut2JStat, kBckgOut3JStat, kBckgOutAJStat, kBckgClusters, kBckgASide, kBckgASideWindow, kBckgPerpWindow}; + enum {kBckgPerp=0, kBckgOutLJ, kBckgOut2J, kBckgOut3J, kBckgOutAJ, kBckgOutLJStat, kBckgOut2JStat, kBckgOut3JStat, kBckgOutAJStat, kBckgClusters, + kBckgClustersOutLeading, kBckgASide, kBckgASideWindow, kBckgPerpWindow}; private: Int_t GetListOfTracks(TList* list, Int_t type); Int_t GetListOfJets(TList* list, Int_t type); - Int_t GetListOfBckgJets(/*TList *list, Int_t type*/); + Int_t GetListOfBckgJets(TList *list, Int_t type); AliESDEvent* fESD; // ESD event AliAODEvent* fAOD; // AOD event //AliMCEvent* fMCEvent; // MC event - TString fBranchRecJets; // branch name for reconstructed jets - TString fBranchRecBackJets; // branch name for reconstructed background jets - TString fBranchGenJets; // branch name for generated jets + TString fBranchRecJets; // branch name for reconstructed jets + TString fBranchRecBackJets; // branch name for reconstructed background jets + TString fBranchRecBckgClusters; // branch name for reconstructed background clusters + TString fBranchGenJets; // branch name for generated jets Int_t fTrackTypeGen; // type of generated tracks Int_t fJetTypeGen; // type of generated jets @@ -523,7 +530,7 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE { Float_t fFFRadius; // if radius > 0 construct FF from tracks within cone around jet axis, otherwise use trackRefs Float_t fFFBckgRadius; // compute background outside cone of this radius around jet axes Bool_t fBckgMode; // Set background subtraction mode - Int_t fBckgType[3]; // Set background subtraction mode + Int_t fBckgType[4]; // Set background subtraction mode Int_t fIJMode; // Set intrajet mode Int_t fQAMode; // QA mode: 0x00=0 none, 0x01=1 track qa, 0x10=2 track qa, 0x11=3 both Int_t fFFMode; // fragmentation function mode @@ -531,7 +538,8 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE { Int_t fEffMode; // efficiency mode Int_t fPhiCorrMode; // track phi correlation mode - Bool_t fUseRecEffRecJetPtBins; // bin track reconstruction efficiency in reconstructed/generated jet pt bins + Bool_t fUseRecEffRecJetPtBins; // bin track reconstruction efficiency in reconstructed/generated jet pt bins + Bool_t fUseResponseRecJetPtBins; // bin track response matrix in reconstructed/generated jet pt bins Float_t fAvgTrials; // average number of trials per event @@ -753,12 +761,15 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE { // Background TH1F *fh1OutLeadingMult; //! background multiplicity outside leading jet + TH1F *fh1OutLeadingStatMult; //! background multiplicity outside leading jet (stat) TH1F *fh1PerpMult; //! background multiplicity perpendicular to the leading jet TH1F *fh1ASideMult; //! background multiplicity perpendicular to the leading jet TH1F *fh1ASideWindowMult; //! background multiplicity perpendicular to the leading jet TH1F *fh1PerpWindowMult; //! background multiplicity perpendicular to the leading jet TH1F *fh1Out2JetsMult; //! background multiplicity outside 2 jets TH1F *fh1Out3JetsMult; //! background multiplicity outside 3 jets + TH1F *fh1MedianClustersMult; //! background multiplicity median cluster + TH1F *fh1OutClustersMult; //! background multiplicity clusters outside leading jet AliFragFuncQATrackHistos* fQABckgHisto0RecCuts; //! track QA: reconstructed tracks after cuts AliFragFuncQATrackHistos* fQABckgHisto0Gen; //! track QA: generated tracks @@ -766,6 +777,8 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE { AliFragFuncQATrackHistos* fQABckgHisto1Gen; //! track QA: generated tracks AliFragFuncQATrackHistos* fQABckgHisto2RecCuts; //! track QA: reconstructed tracks after cuts AliFragFuncQATrackHistos* fQABckgHisto2Gen; //! track QA: generated tracks + AliFragFuncQATrackHistos* fQABckgHisto3RecCuts; //! track QA: reconstructed tracks after cuts + AliFragFuncQATrackHistos* fQABckgHisto3Gen; //! track QA: generated tracks AliFragFuncHistos* fFFBckgHisto0RecCuts; //! Bckg (outside leading jet or 2 jets or more) FF reconstructed tracks after cuts AliFragFuncHistos* fFFBckgHisto0RecLeading; //! Bckg (outside leading jet or 2 jets or more) FF reconstructed tracks after cuts: all reconstructed tracks pt / leading track pt @@ -779,6 +792,11 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE { AliFragFuncHistos* fFFBckgHisto2RecLeading; //! Bckg (outside leading jet or 2 jets or more) FF reconstructed tracks after cuts: all reconstructed tracks pt / leading track pt AliFragFuncHistos* fFFBckgHisto2Gen; //! Bckg (outside leading jet or 2 jets or more) FF generated tracks after cuts AliFragFuncHistos* fFFBckgHisto2GenLeading; //! Bckg (outside leading jet or 2 jets or more) FF reconstructed tracks after cuts: all reconstructed tracks pt / leading track pt + AliFragFuncHistos* fFFBckgHisto3RecCuts; //! Bckg (outside leading jet or 3 jets or more) FF reconstructed tracks after cuts + AliFragFuncHistos* fFFBckgHisto3RecLeading; //! Bckg (outside leading jet or 3 jets or more) FF reconstructed tracks after cuts: all reconstructed tracks pt / leading track pt + AliFragFuncHistos* fFFBckgHisto3Gen; //! Bckg (outside leading jet or 3 jets or more) FF generated tracks after cuts + AliFragFuncHistos* fFFBckgHisto3GenLeading; //! Bckg (outside leading jet or 3 jets or more) FF reconstructed tracks after cuts: all reconstructed tracks pt / leading track pt + AliFragFuncIntraJetHistos* fIJBckgHisto0RecCuts; //! AliFragFuncIntraJetHistos* fIJBckgHisto0RecLeading; //! @@ -792,11 +810,16 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE { AliFragFuncIntraJetHistos* fIJBckgHisto2RecLeading; //! AliFragFuncIntraJetHistos* fIJBckgHisto2Gen; //! AliFragFuncIntraJetHistos* fIJBckgHisto2GenLeading; //! + AliFragFuncIntraJetHistos* fIJBckgHisto3RecCuts; //! + AliFragFuncIntraJetHistos* fIJBckgHisto3RecLeading; //! + AliFragFuncIntraJetHistos* fIJBckgHisto3Gen; //! + AliFragFuncIntraJetHistos* fIJBckgHisto3GenLeading; //! + TRandom3* fRandom; // TRandom3 for background estimation Int_t fBckgSubMethod; // Bckg method: 1 = leading jet excluded, 2 = 2 most energetic jets excluded - ClassDef(AliAnalysisTaskFragmentationFunction, 9); + ClassDef(AliAnalysisTaskFragmentationFunction, 10); }; #endif diff --git a/PWG4/JetTasks/AliAnalysisTaskJetServices.cxx b/PWG4/JetTasks/AliAnalysisTaskJetServices.cxx index 1066f3acc84..da221e053af 100644 --- a/PWG4/JetTasks/AliAnalysisTaskJetServices.cxx +++ b/PWG4/JetTasks/AliAnalysisTaskJetServices.cxx @@ -94,6 +94,8 @@ AliAnalysisTaskJetServices::AliAnalysisTaskJetServices(): AliAnalysisTaskSE(), fh1PtHardTrials(0x0), fh1SelectionInfoESD(0x0), fh1EventCutInfoESD(0), + fh1CentralityESD(0), + fh1Centrality(0), fh2TriggerCount(0x0), fh2ESDTriggerCount(0x0), fh2TriggerVtx(0x0), @@ -132,6 +134,8 @@ AliAnalysisTaskJetServices::AliAnalysisTaskJetServices(const char* name): fh1PtHardTrials(0x0), fh1SelectionInfoESD(0x0), fh1EventCutInfoESD(0), + fh1CentralityESD(0), + fh1Centrality(0), fh2TriggerCount(0x0), fh2ESDTriggerCount(0x0), fh2TriggerVtx(0x0), @@ -215,6 +219,13 @@ void AliAnalysisTaskJetServices::UserCreateOutputObjects() } } + + fh1CentralityESD = new TH1F("fh1CentralityESD","cent",102,-0.5,101.5); + fHistList->Add(fh1CentralityESD); + + fh1Centrality = new TH1F("fh1Centrality","cent",102,-0.5,101.5); + fHistList->Add(fh1Centrality); + fh2TriggerCount = new TH2F("fh2TriggerCount",";Trigger No.;constrained;Count",AliAnalysisHelperJetTasks::kTrigger,-0.5,AliAnalysisHelperJetTasks::kTrigger-0.5,kConstraints,-0.5,kConstraints-0.5); fHistList->Add(fh2TriggerCount); @@ -398,12 +409,14 @@ void AliAnalysisTaskJetServices::UserExec(Option_t */*option*/) // loop over all possible triggers for esd + Float_t cent = 100; + if(aod)cent = aod->GetHeader()->GetCentrality(); + if(cent<0)cent = 101; if(esd){ const AliESDVertex *vtxESD = esd->GetPrimaryVertex(); esdVtxValid = IsVertexValid(vtxESD); esdVtxIn = IsVertexIn(vtxESD); if(aodH&&physicsSelection&&fFilterAODCollisions&&aod){ - Float_t cent = aod->GetHeader()->GetCentrality(); if(fDebug)Printf("%s:%d Centrality %3.3f vtxin %d",(char*)__FILE__,__LINE__,cent,esdVtxIn); if(cent<=80&&esdVtxIn){ aodH->SetFillAOD(kTRUE); @@ -441,6 +454,7 @@ void AliAnalysisTaskJetServices::UserExec(Option_t */*option*/) fh2ESDTriggerVtx->Fill(kSelectedALICEVertexValid*(iCl+1),zvtx); } } + if(cand&&esdVtxIn){ fh2ESDTriggerCount->Fill(0.,kSelectedALICEVertexIn); fh2ESDTriggerCount->Fill(iCl,kSelectedALICEVertexIn); @@ -449,6 +463,12 @@ void AliAnalysisTaskJetServices::UserExec(Option_t */*option*/) fh2ESDTriggerCount->Fill(iCl,kSelected); fh2ESDTriggerCount->Fill(0.,kSelected); AliAnalysisHelperJetTasks::Selected(kTRUE,kTRUE);// select this event + if(esd->GetCentrality()){ + Float_t tmpCent = 100; + tmpCent = esd->GetCentrality()->GetCentralityPercentile("V0M"); + if(tmpCent<0)tmpCent = 101; + fh1CentralityESD->Fill(tmpCent); + } } } @@ -492,17 +512,13 @@ void AliAnalysisTaskJetServices::UserExec(Option_t */*option*/) fh2TriggerVtx->Fill(kSelected*(iCl+1),zvtx); fh2TriggerCount->Fill(iCl,kSelected); fh2TriggerCount->Fill(0.,kSelected); - if(fUseAODInput){ - AliAnalysisHelperJetTasks::Selected(kTRUE,kTRUE);// select this event + fh1Centrality->Fill(cent); + AliAnalysisHelperJetTasks::Selected(kTRUE,kTRUE);// select this event + if(fUseAODInput&¢<=80){ if(fFilterAODCollisions&&aod){ - Float_t cent = aod->GetHeader()->GetCentrality(); - if(cent<=80){ - aodH->SetFillAOD(kTRUE); - } + aodH->SetFillAOD(kTRUE); } } - - } } @@ -793,7 +809,7 @@ Int_t AliAnalysisTaskJetServices::GetEventClass(AliESDEvent *esd){ if(esd->GetCentrality()){ cent = esd->GetCentrality()->GetCentralityPercentile("V0M"); } - if(cent>80)return 5; + if(cent>80||cent<0)return 5; if(cent>50)return 4; if(cent>30)return 3; if(cent>10)return 2; @@ -805,7 +821,7 @@ Int_t AliAnalysisTaskJetServices::GetEventClass(AliESDEvent *esd){ Int_t AliAnalysisTaskJetServices::GetEventClass(AliAODEvent *aod){ Float_t cent = aod->GetHeader()->GetCentrality(); - if(cent>80)return 5; + if(cent>80||cent<0)return 5; if(cent>50)return 4; if(cent>30)return 3; if(cent>10)return 2; diff --git a/PWG4/JetTasks/AliAnalysisTaskJetServices.h b/PWG4/JetTasks/AliAnalysisTaskJetServices.h index 1c70aea03f2..82b99820403 100644 --- a/PWG4/JetTasks/AliAnalysisTaskJetServices.h +++ b/PWG4/JetTasks/AliAnalysisTaskJetServices.h @@ -118,6 +118,8 @@ class AliAnalysisTaskJetServices : public AliAnalysisTaskSE TH1F* fh1PtHardTrials; //! Number of trials TH1F* fh1SelectionInfoESD; //! Masks that satisfy fSelectionInfo TH1F* fh1EventCutInfoESD; //! Masks that satisfy fSelectionInfo + TH1F* fh1CentralityESD; //! centrality + TH1F* fh1Centrality; //! centrality TH2F* fh2TriggerCount; //! number of fire triggers in each case TH2F* fh2ESDTriggerCount; //! number of fire triggers in each case TH2F* fh2TriggerVtx; //! vtx. position vs. trigger decision diff --git a/PWG4/JetTasks/AliAnalysisTaskJetSpectrum2.cxx b/PWG4/JetTasks/AliAnalysisTaskJetSpectrum2.cxx index 2557759d072..eefd2587c1f 100644 --- a/PWG4/JetTasks/AliAnalysisTaskJetSpectrum2.cxx +++ b/PWG4/JetTasks/AliAnalysisTaskJetSpectrum2.cxx @@ -22,6 +22,7 @@ #include #include +#include #include #include #include @@ -79,6 +80,7 @@ AliAnalysisTaskJetSpectrum2::AliAnalysisTaskJetSpectrum2(): fBranchBkgRec(""), fBranchBkgGen(""), fNonStdFile(""), + fRandomizer(0x0), fUseAODJetInput(kFALSE), fUseAODTrackInput(kFALSE), fUseAODMCInput(kFALSE), @@ -93,6 +95,7 @@ AliAnalysisTaskJetSpectrum2::AliAnalysisTaskJetSpectrum2(): fTrackTypeRec(kTrackUndef), fTrackTypeGen(kTrackUndef), fEventClass(0), + fRPSubeventMethod(0), fAvgTrials(1), fExternalWeight(1), fJetRecEtaWindow(0.5), @@ -100,6 +103,7 @@ AliAnalysisTaskJetSpectrum2::AliAnalysisTaskJetSpectrum2(): fMinJetPt(0), fMinTrackPt(0.15), fDeltaPhiWindow(90./180.*TMath::Pi()), + fCentrality(100), fRPAngle(0), fMultRec(0), fMultGen(0), @@ -110,11 +114,18 @@ AliAnalysisTaskJetSpectrum2::AliAnalysisTaskJetSpectrum2(): 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){ @@ -122,6 +133,7 @@ AliAnalysisTaskJetSpectrum2::AliAnalysisTaskJetSpectrum2(): } for(int ij = 0;ij 1) printf("AnalysisTaskJetSpectrum2::UserCreateOutputObjects() \n"); @@ -314,26 +337,28 @@ void AliAnalysisTaskJetSpectrum2::UserCreateOutputObjects() 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;iAdd(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; @@ -378,66 +403,91 @@ void AliAnalysisTaskJetSpectrum2::UserCreateOutputObjects() 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 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 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]); @@ -657,6 +707,7 @@ void AliAnalysisTaskJetSpectrum2::UserExec(Option_t */*option*/){ // 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 @@ -676,6 +727,11 @@ void AliAnalysisTaskJetSpectrum2::UserExec(Option_t */*option*/){ 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(); @@ -711,6 +767,8 @@ void AliAnalysisTaskJetSpectrum2::UserExec(Option_t */*option*/){ 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); @@ -726,8 +784,8 @@ void AliAnalysisTaskJetSpectrum2::UserExec(Option_t */*option*/){ 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); @@ -765,6 +823,7 @@ void AliAnalysisTaskJetSpectrum2::FillJetHistos(TList &jetsList,TList &particles if(iType>=kJetTypes){ return; } + if(!fFlagJetType[iType])return; Int_t refMult = fMultRec; if(iType==kJetGen||iType==kJetGenFull){ @@ -824,6 +883,7 @@ void AliAnalysisTaskJetSpectrum2::FillJetHistos(TList &jetsList,TList &particles // fill leading jets... AliVParticle *leadTrack = LeadingTrackFromJetRefs(jet); // AliVParticle *leadTrack = LeadingTrackInCone(jet,&particlesList); + Int_t phiBin = GetPhiBin(phiJet-fRPAngle); if(ptJet>10){ if(ijFill(phiJet,etaJet); @@ -835,12 +895,12 @@ void AliAnalysisTaskJetSpectrum2::FillJetHistos(TList &jetsList,TList &particles fh2EtaArea[iType][kMaxJets]->Fill(etaJet,jet->EffectiveAreaCharged()); } if(ijFill(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); @@ -925,9 +985,11 @@ void AliAnalysisTaskJetSpectrum2::FillJetHistos(TList &jetsList,TList &particles 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(); @@ -958,10 +1020,13 @@ void AliAnalysisTaskJetSpectrum2::FillTrackHistos(TList &particlesList,int iType 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); @@ -1111,7 +1176,7 @@ void AliAnalysisTaskJetSpectrum2::MakeJetContainer(){ //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 @@ -1149,6 +1214,12 @@ void AliAnalysisTaskJetSpectrum2::MakeJetContainer(){ } fhnCorrelation->Sumw2(); + + for(Int_t ivar = 0; ivar < kNvar; ivar++) + delete [] binEdges[ivar]; + + + // for second correlation histogram @@ -1160,6 +1231,8 @@ void AliAnalysisTaskJetSpectrum2::MakeJetContainer(){ 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++) @@ -1176,12 +1249,6 @@ void AliAnalysisTaskJetSpectrum2::MakeJetContainer(){ } 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]; @@ -1284,6 +1351,17 @@ Int_t AliAnalysisTaskJetSpectrum2::GetListOfTracks(TList *list,Int_t type){ } +Float_t AliAnalysisTaskJetSpectrum2::GetCentrality(){ + AliAODEvent *aod = 0; + if(fUseAODTrackInput)aod = dynamic_cast(InputEvent()); + else aod = AODEvent(); + if(!aod){ + return 100; + } + return aod->GetHeader()->GetCentrality(); +} + + Bool_t AliAnalysisTaskJetSpectrum2::JetSelected(AliAODJet *jet){ Bool_t selected = false; @@ -1381,3 +1459,140 @@ AliVParticle *AliAnalysisTaskJetSpectrum2::LeadingTrackInCone(AliAODJet* jet,TLi } 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;iterGetEntries();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"<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; +} + + //________________________________________________________________________ diff --git a/PWG4/JetTasks/AliAnalysisTaskJetSpectrum2.h b/PWG4/JetTasks/AliAnalysisTaskJetSpectrum2.h index f96c920ace7..f916e9fe0bd 100644 --- a/PWG4/JetTasks/AliAnalysisTaskJetSpectrum2.h +++ b/PWG4/JetTasks/AliAnalysisTaskJetSpectrum2.h @@ -28,6 +28,7 @@ class TChain; class TH1F; class TH2F; class TH3F; +class TRandom3; class TProfile; class TSTring; @@ -59,6 +60,7 @@ class AliAnalysisTaskJetSpectrum2 : public AliAnalysisTaskSE virtual void SetNMatchJets(Short_t f){fNMatchJets = f;} virtual void SetMinJetPt(Float_t f){fMinJetPt = f;} virtual void SetNRPBins(Short_t i){fNRPBins = i;} + virtual void SetFlagJetType(Int_t iType,Int_t iF){fFlagJetType[iType] = iF;} virtual void SetMinTrackPt(Float_t f){fMinTrackPt = f;} virtual void SetDeltaPhiWindow(Float_t f){fDeltaPhiWindow = f;} virtual void SetAnalysisType(Int_t i){fAnalysisType = i;} @@ -103,7 +105,9 @@ class AliAnalysisTaskJetSpectrum2 : public AliAnalysisTaskSE void MakeJetContainer(); Int_t GetListOfTracks(TList *list,Int_t type); void FillTrackHistos(TList &particlesList,int iType); - + Float_t GetCentrality(); + Bool_t CalculateReactionPlaneAngle(const TList *trackList); + Int_t GetPhiBin(Double_t phi); Int_t GetListOfJets(TList *list,TClonesArray* jarray,Int_t type); void FillJetHistos(TList &jetsList,TList &particlesList,Int_t iType); @@ -132,6 +136,8 @@ class AliAnalysisTaskJetSpectrum2 : public AliAnalysisTaskSE TString fBranchBkgGen; //AOD branch for background TString fNonStdFile; // name of delta aod file to catch the extension + TRandom3* fRandomizer; //! randomizer + Bool_t fUseAODJetInput; // take jet from input AOD not from ouptu AOD Bool_t fUseAODTrackInput; // take track from input AOD not from ouptu AOD Bool_t fUseAODMCInput; // take MC from input AOD not from ouptu AOD @@ -145,7 +151,9 @@ class AliAnalysisTaskJetSpectrum2 : public AliAnalysisTaskSE Int_t fAnalysisType; // Analysis type Int_t fTrackTypeRec; // type of tracks used for FF Int_t fTrackTypeGen; // type of tracks used for FF + Int_t fFlagJetType[kJetTypes]; // disable the filling and booking of certain JetType histos Int_t fEventClass; // event class to be looked at for this instance of the task + Int_t fRPSubeventMethod; // method for subevent calculation Float_t fAvgTrials; // Average nimber of trials Float_t fExternalWeight; // external weight Float_t fJetRecEtaWindow; // eta window for rec jets @@ -153,7 +161,8 @@ class AliAnalysisTaskJetSpectrum2 : public AliAnalysisTaskSE Float_t fMinJetPt; // limits the jet p_T in addition to what already is done in the jet finder, this is important for jet matching for JF with lo threshold Float_t fMinTrackPt; // limits the track p_T Float_t fDeltaPhiWindow; // minium angle between dijets - Float_t fRPAngle; // ! angle of the reaction plane + Float_t fCentrality; // ! centrality + Float_t fRPAngle; // ! RP angle of the reaction plane Int_t fMultRec; // ! reconstructed track multiplicity Int_t fMultGen; // ! generated track multiplicity @@ -165,12 +174,20 @@ class AliAnalysisTaskJetSpectrum2 : public AliAnalysisTaskSE TH1F* fh1PtHardTrials; //! Number of trials TH1F* fh1ZVtx; //! z-vtx distribution TH1F* fh1RP; //! RP distribution + TH1F* fh1Centrality; //! centrality distribution TH1F* fh1TmpRho; //! just temporary histo for calculation TH2F* fh2MultRec; //! reconstructed track multiplicity TH2F* fh2MultGen; //! generated track multiplicity + TH2F* fh2RPSubevents; //! subevent RP + TH2F* fh2RPCentrality; //! RP vs centrality + TH2F* fh2RPDeltaRP; //! centrality vs. RP dela + TH2F* fh2RPQxQy; //! QX QY moments + TH2F* fh2RPCosDeltaRP; //! RP resolution TH2F* fh2PtFGen; //! found vs generated TH2F* fh2RelPtFGen; //! relative difference between generated and found + + TH3F* fh3RPPhiTracks; //! RP angle // Jet histos second go @@ -212,7 +229,7 @@ class AliAnalysisTaskJetSpectrum2 : public AliAnalysisTaskSE TList *fHistList; //! Output list - ClassDef(AliAnalysisTaskJetSpectrum2, 13) // Analysis task for standard jet analysis + ClassDef(AliAnalysisTaskJetSpectrum2, 14) // Analysis task for standard jet analysis }; #endif diff --git a/PWG4/JetTasks/AliPWG4HighPtTrackQA.cxx b/PWG4/JetTasks/AliPWG4HighPtTrackQA.cxx index 4bbd5997a4e..b47a394a917 100644 --- a/PWG4/JetTasks/AliPWG4HighPtTrackQA.cxx +++ b/PWG4/JetTasks/AliPWG4HighPtTrackQA.cxx @@ -765,7 +765,6 @@ void AliPWG4HighPtTrackQA::DoAnalysisESD() { track = esdtrack; if(!track) { - if(fTrackType==1 || fTrackType==2) delete track; continue; }