#include <TClonesArray.h>
#include <TH1F.h>
#include <TH2F.h>
+#include <TH3F.h>
#include <TList.h>
#include <TLorentzVector.h>
#include <TRandom3.h>
#include "AliEmcalJet.h"
#include "AliRhoParameter.h"
#include "AliLog.h"
+#include "AliJetContainer.h"
+#include "AliParticleContainer.h"
+#include "AliClusterContainer.h"
#include "AliAnalysisTaskDeltaPt.h"
AliAnalysisTaskEmcalJet("AliAnalysisTaskDeltaPt", kTRUE),
fMCJetPtThreshold(1),
fMinRC2LJ(-1),
- fEmbJetsName(""),
- fEmbTracksName(""),
- fEmbCaloName(""),
- fRandTracksName("TracksRandomized"),
- fRandCaloName("CaloClustersRandomized"),
fRCperEvent(-1),
- fEmbJets(0),
- fEmbTracks(0),
- fEmbCaloClusters(0),
- fRandTracks(0),
- fRandCaloClusters(0),
- fEmbeddedClusterNIds(0),
- fEmbeddedTrackNIds(0),
- fHistRCPhiEta(0),
+ fConeRadius(0.2),
+ fConeMinEta(-0.9),
+ fConeMaxEta(0.9),
+ fConeMinPhi(0),
+ fConeMaxPhi(TMath::Pi()*2),
+ fJetsCont(0),
+ fTracksCont(0),
+ fCaloClustersCont(0),
+ fEmbJetsCont(0),
+ fEmbTracksCont(0),
+ fEmbCaloClustersCont(0),
+ fRandTracksCont(0),
+ fRandCaloClustersCont(0),
+ fHistRCPhiEta(0),
+ fHistRCPt(0),
+ fHistRCPtExLJ(0),
+ fHistRCPtExPartialLJ(0),
+ fHistRCPtRand(0),
+ fHistRhoVSRCPt(0),
+ fHistDeltaPtRCvsEP(0),
+ fHistDeltaPtRCExLJ(0),
+ fHistDeltaPtRCExPartialLJ(0),
+ fHistDeltaPtRCRand(0),
+ fHistEmbJetsPtArea(0),
+ fHistEmbJetsCorrPtArea(0),
+ fHistEmbPartPtvsJetPt(0),
+ fHistEmbPartPtvsJetCorrPt(0),
+ fHistJetPtvsJetCorrPt(0),
+ fHistDistLeadPart2JetAxis(0),
+ fHistEmbBkgArea(0),
+ fHistRhoVSEmbBkg(0),
+ fHistDeltaPtEmbArea(0),
+ fHistDeltaPtEmbvsEP(0),
fHistRCPtExLJVSDPhiLJ(0),
+ fHistRCPtExPartialLJVSDPhiLJ(0),
fHistEmbJetsPhiEta(0),
fHistLeadPartPhiEta(0)
{
// Default constructor.
- for (Int_t i = 0; i < 4; i++) {
- fHistRCPt[i] = 0;
- fHistRCPtExLJ[i] = 0;
- fHistRCPtRand[i] = 0;
- fHistRhoVSRCPt[i] = 0;
- fHistDeltaPtRC[i] = 0;
- fHistDeltaPtRCExLJ[i] = 0;
- fHistDeltaPtRCRand[i] = 0;
- fHistEmbNotFoundPt[i] = 0;
- fHistEmbNotFoundPhiEta[i] = 0;
- fHistEmbJetsPtArea[i] = 0;
- fHistEmbJetsCorrPtArea[i] = 0;
- fHistEmbPartPtvsJetPt[i] = 0;
- fHistLeadPartPtvsArea[i] = 0;
- fHistDistLeadPart2JetAxis[i] = 0;
- fHistEmbBkgArea[i] = 0;
- fHistRhoVSEmbBkg[i] = 0;
- fHistDeltaPtEmbArea[i] = 0;
- }
+ fHistRCPt = 0;
+ fHistRCPtExLJ = 0;
+ fHistRCPtExPartialLJ = 0;
+ fHistRCPtRand = 0;
+ fHistRhoVSRCPt = 0;
+ fHistDeltaPtRCvsEP = 0;
+ fHistDeltaPtRCExLJ = 0;
+ fHistDeltaPtRCExPartialLJ = 0;
+ fHistDeltaPtRCRand = 0;
+ fHistEmbJetsPtArea = 0;
+ fHistEmbJetsCorrPtArea = 0;
+ fHistEmbPartPtvsJetPt = 0;
+ fHistEmbPartPtvsJetCorrPt = 0;
+ fHistJetPtvsJetCorrPt = 0;
+ fHistDistLeadPart2JetAxis = 0;
+ fHistEmbBkgArea = 0;
+ fHistRhoVSEmbBkg = 0;
+ fHistDeltaPtEmbArea = 0;
+ fHistDeltaPtEmbvsEP = 0;
SetMakeGeneralHistograms(kTRUE);
}
AliAnalysisTaskEmcalJet(name, kTRUE),
fMCJetPtThreshold(1),
fMinRC2LJ(-1),
- fEmbJetsName(""),
- fEmbTracksName(""),
- fEmbCaloName(""),
- fRandTracksName("TracksRandomized"),
- fRandCaloName("CaloClustersRandomized"),
fRCperEvent(-1),
- fEmbJets(0),
- fEmbTracks(0),
- fEmbCaloClusters(0),
- fRandTracks(0),
- fRandCaloClusters(0),
- fEmbeddedClusterNIds(0),
- fEmbeddedTrackNIds(0),
- fHistRCPhiEta(0),
+ fConeRadius(0.2),
+ fConeMinEta(-0.9),
+ fConeMaxEta(0.9),
+ fConeMinPhi(0),
+ fConeMaxPhi(TMath::Pi()*2),
+ fJetsCont(0),
+ fTracksCont(0),
+ fCaloClustersCont(0),
+ fEmbJetsCont(0),
+ fEmbTracksCont(0),
+ fEmbCaloClustersCont(0),
+ fRandTracksCont(0),
+ fRandCaloClustersCont(0),
+ fHistRCPhiEta(0),
+ fHistRCPt(0),
+ fHistRCPtExLJ(0),
+ fHistRCPtExPartialLJ(0),
+ fHistRCPtRand(0),
+ fHistRhoVSRCPt(0),
+ fHistDeltaPtRCvsEP(0),
+ fHistDeltaPtRCExLJ(0),
+ fHistDeltaPtRCExPartialLJ(0),
+ fHistDeltaPtRCRand(0),
+ fHistEmbJetsPtArea(0),
+ fHistEmbJetsCorrPtArea(0),
+ fHistEmbPartPtvsJetPt(0),
+ fHistEmbPartPtvsJetCorrPt(0),
+ fHistJetPtvsJetCorrPt(0),
+ fHistDistLeadPart2JetAxis(0),
+ fHistEmbBkgArea(0),
+ fHistRhoVSEmbBkg(0),
+ fHistDeltaPtEmbArea(0),
+ fHistDeltaPtEmbvsEP(0),
fHistRCPtExLJVSDPhiLJ(0),
+ fHistRCPtExPartialLJVSDPhiLJ(0),
fHistEmbJetsPhiEta(0),
fHistLeadPartPhiEta(0)
{
// Standard constructor.
- for (Int_t i = 0; i < 4; i++) {
+ fHistRCPt = 0;
+ fHistRCPtExLJ = 0;
+ fHistRCPtExPartialLJ = 0;
+ fHistRCPtRand = 0;
+ fHistRhoVSRCPt = 0;
+ fHistDeltaPtRCvsEP = 0;
+ fHistDeltaPtRCExLJ = 0;
+ fHistDeltaPtRCExPartialLJ = 0;
+ fHistDeltaPtRCRand = 0;
+ fHistEmbJetsPtArea = 0;
+ fHistEmbJetsCorrPtArea = 0;
+ fHistEmbPartPtvsJetPt = 0;
+ fHistEmbPartPtvsJetCorrPt = 0;
+ fHistJetPtvsJetCorrPt = 0;
+ fHistDistLeadPart2JetAxis = 0;
+ fHistEmbBkgArea = 0;
+ fHistRhoVSEmbBkg = 0;
+ fHistDeltaPtEmbArea = 0;
+ fHistDeltaPtEmbvsEP = 0;
+
+ SetMakeGeneralHistograms(kTRUE);
+}
+
+//________________________________________________________________________
+void AliAnalysisTaskDeltaPt::AllocateHistogramArrays()
+{
+ fHistRCPt = new TH1*[fNcentBins];
+ fHistRCPtExLJ = new TH1*[fNcentBins];
+ fHistRCPtExPartialLJ = new TH1*[fNcentBins];
+ fHistRCPtRand = new TH1*[fNcentBins];
+ fHistRhoVSRCPt = new TH2*[fNcentBins];
+ fHistDeltaPtRCvsEP = new TH2*[fNcentBins];
+ fHistDeltaPtRCExLJ = new TH1*[fNcentBins];
+ fHistDeltaPtRCExPartialLJ = new TH1*[fNcentBins];
+ fHistDeltaPtRCRand = new TH1*[fNcentBins];
+ fHistEmbJetsPtArea = new TH3*[fNcentBins];
+ fHistEmbJetsCorrPtArea = new TH3*[fNcentBins];
+ fHistEmbPartPtvsJetPt = new TH2*[fNcentBins];
+ fHistEmbPartPtvsJetCorrPt = new TH2*[fNcentBins];
+ fHistJetPtvsJetCorrPt = new TH2*[fNcentBins];
+ fHistDistLeadPart2JetAxis = new TH1*[fNcentBins];
+ fHistEmbBkgArea = new TH2*[fNcentBins];
+ fHistRhoVSEmbBkg = new TH2*[fNcentBins];
+ fHistDeltaPtEmbArea = new TH2*[fNcentBins];
+ fHistDeltaPtEmbvsEP = new TH2*[fNcentBins];
+
+ for (Int_t i = 0; i < fNcentBins; i++) {
fHistRCPt[i] = 0;
fHistRCPtExLJ[i] = 0;
- fHistRCPtRand[i] = 0;
+ fHistRCPtExPartialLJ[i] = 0;
+ fHistRCPtRand[i] = 0;
fHistRhoVSRCPt[i] = 0;
- fHistDeltaPtRC[i] = 0;
+ fHistDeltaPtRCvsEP[i] = 0;
fHistDeltaPtRCExLJ[i] = 0;
+ fHistDeltaPtRCExPartialLJ[i] = 0;
fHistDeltaPtRCRand[i] = 0;
- fHistEmbNotFoundPt[i] = 0;
- fHistEmbNotFoundPhiEta[i] = 0;
fHistEmbJetsPtArea[i] = 0;
fHistEmbJetsCorrPtArea[i] = 0;
fHistEmbPartPtvsJetPt[i] = 0;
- fHistLeadPartPtvsArea[i] = 0;
+ fHistEmbPartPtvsJetCorrPt[i] = 0;
+ fHistJetPtvsJetCorrPt[i] = 0;
fHistDistLeadPart2JetAxis[i] = 0;
fHistEmbBkgArea[i] = 0;
fHistRhoVSEmbBkg[i] = 0;
fHistDeltaPtEmbArea[i] = 0;
+ fHistDeltaPtEmbvsEP[i] = 0;
}
-
- SetMakeGeneralHistograms(kTRUE);
-}
-
-//________________________________________________________________________
-AliAnalysisTaskDeltaPt::~AliAnalysisTaskDeltaPt()
-{
- // Destructor.
}
//________________________________________________________________________
AliAnalysisTaskEmcalJet::UserCreateOutputObjects();
- if (!fTracksName.IsNull() || !fCaloName.IsNull()) {
- fHistRCPhiEta = new TH2F("fHistRCPhiEta","fHistRCPhiEta", 50, -1, 1, 101, 0, TMath::Pi() * 2.02);
+ AllocateHistogramArrays();
+
+ fJetsCont = GetJetContainer("Jets");
+ fTracksCont = GetParticleContainer("Tracks");
+ fCaloClustersCont = GetClusterContainer("CaloClusters");
+ fEmbJetsCont = GetJetContainer("EmbJets");
+ fEmbTracksCont = GetParticleContainer("EmbTracks");
+ fEmbCaloClustersCont = GetClusterContainer("EmbCaloClusters");
+ fRandTracksCont = GetParticleContainer("RandTracks");
+ fRandCaloClustersCont = GetClusterContainer("RandCaloClusters");
+
+ if (fTracksCont || fCaloClustersCont) {
+ fHistRCPhiEta = new TH2F("fHistRCPhiEta","fHistRCPhiEta", 100, -1, 1, 201, 0, TMath::Pi() * 2.01);
fHistRCPhiEta->GetXaxis()->SetTitle("#eta");
fHistRCPhiEta->GetYaxis()->SetTitle("#phi");
fOutput->Add(fHistRCPhiEta);
- if (!fJetsName.IsNull()) {
+ if (fJetsCont) {
fHistRCPtExLJVSDPhiLJ = new TH2F("fHistRCPtExLJVSDPhiLJ","fHistRCPtExLJVSDPhiLJ", fNbins, fMinBinPt, fMaxBinPt, 128, -1.6, 4.8);
fHistRCPtExLJVSDPhiLJ->GetXaxis()->SetTitle("#it{p}_{T} (GeV/#it{c})");
fHistRCPtExLJVSDPhiLJ->GetYaxis()->SetTitle("#Delta#phi");
fOutput->Add(fHistRCPtExLJVSDPhiLJ);
+
+ fHistRCPtExPartialLJVSDPhiLJ = new TH2F("fHistRCPtExPartialLJVSDPhiLJ","fHistRCPtExPartialLJVSDPhiLJ", fNbins, fMinBinPt, fMaxBinPt, 128, -1.6, 4.8);
+ fHistRCPtExPartialLJVSDPhiLJ->GetXaxis()->SetTitle("#it{p}_{T} (GeV/#it{c})");
+ fHistRCPtExPartialLJVSDPhiLJ->GetYaxis()->SetTitle("#Delta#phi");
+ fOutput->Add(fHistRCPtExPartialLJVSDPhiLJ);
}
}
- if (!fEmbJetsName.IsNull()) {
- fHistEmbJetsPhiEta = new TH2F("fHistEmbJetsPhiEta","fHistEmbJetsPhiEta", 50, -1, 1, 101, 0, TMath::Pi() * 2.02);
+ if (fEmbJetsCont) {
+ fHistEmbJetsPhiEta = new TH2F("fHistEmbJetsPhiEta","fHistEmbJetsPhiEta", 100, -1, 1, 201, 0, TMath::Pi() * 2.01);
fHistEmbJetsPhiEta->GetXaxis()->SetTitle("#eta");
fHistEmbJetsPhiEta->GetYaxis()->SetTitle("#phi");
fOutput->Add(fHistEmbJetsPhiEta);
- fHistLeadPartPhiEta = new TH2F("fHistLeadPartPhiEta","fHistLeadPartPhiEta", 50, -1, 1, 101, 0, TMath::Pi() * 2.02);
+ fHistLeadPartPhiEta = new TH2F("fHistLeadPartPhiEta","fHistLeadPartPhiEta", 100, -1, 1, 201, 0, TMath::Pi() * 2.01);
fHistLeadPartPhiEta->GetXaxis()->SetTitle("#eta");
fHistLeadPartPhiEta->GetYaxis()->SetTitle("#phi");
fOutput->Add(fHistLeadPartPhiEta);
TString histname;
+ const Int_t nbinsZ = 12;
+ Double_t binsZ[nbinsZ+1] = {0,1,2,3,4,5,6,7,8,9,10,20,1000};
+
+ Double_t *binsPt = GenerateFixedBinArray(fNbins, fMinBinPt, fMaxBinPt);
+ Double_t *binsCorrPt = GenerateFixedBinArray(fNbins*2, -fMaxBinPt, fMaxBinPt);
+ Double_t *binsArea = GenerateFixedBinArray(50, 0, 2);
+
for (Int_t i = 0; i < fNcentBins; i++) {
- if (!fTracksName.IsNull() || !fCaloName.IsNull()) {
+ if (fTracksCont || fCaloClustersCont) {
histname = "fHistRCPt_";
histname += i;
fHistRCPt[i] = new TH1F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt * 2);
fHistRhoVSRCPt[i]->GetYaxis()->SetTitle("#it{p}_{T} (GeV/#it{c})");
fOutput->Add(fHistRhoVSRCPt[i]);
- histname = "fHistDeltaPtRC_";
+ histname = "fHistDeltaPtRCvsEP_";
histname += i;
- fHistDeltaPtRC[i] = new TH1F(histname.Data(), histname.Data(), fNbins * 2, -fMaxBinPt, fMaxBinPt);
- fHistDeltaPtRC[i]->GetXaxis()->SetTitle("#delta#it{p}_{T}^{RC} (GeV/#it{c})");
- fHistDeltaPtRC[i]->GetYaxis()->SetTitle("counts");
- fOutput->Add(fHistDeltaPtRC[i]);
+ fHistDeltaPtRCvsEP[i] = new TH2F(histname.Data(), histname.Data(), 101, 0, TMath::Pi()*1.01, fNbins * 2, -fMaxBinPt, fMaxBinPt);
+ fHistDeltaPtRCvsEP[i]->GetXaxis()->SetTitle("#phi_{RC} - #psi_{RP}");
+ fHistDeltaPtRCvsEP[i]->GetYaxis()->SetTitle("#delta#it{p}_{T}^{RC} (GeV/#it{c})");
+ fHistDeltaPtRCvsEP[i]->GetZaxis()->SetTitle("counts");
+ fOutput->Add(fHistDeltaPtRCvsEP[i]);
- if (!fJetsName.IsNull()) {
+ if (fJetsCont) {
histname = "fHistRCPtExLJ_";
histname += i;
fHistRCPtExLJ[i] = new TH1F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt * 2);
fHistDeltaPtRCExLJ[i]->GetXaxis()->SetTitle("#delta#it{p}_{T}^{RC} (GeV/#it{c})");
fHistDeltaPtRCExLJ[i]->GetYaxis()->SetTitle("counts");
fOutput->Add(fHistDeltaPtRCExLJ[i]);
+
+ histname = "fHistRCPtExPartialLJ_";
+ histname += i;
+ fHistRCPtExPartialLJ[i] = new TH1F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt * 2);
+ fHistRCPtExPartialLJ[i]->GetXaxis()->SetTitle("#it{p}_{T}^{RC} (GeV/#it{c})");
+ fHistRCPtExPartialLJ[i]->GetYaxis()->SetTitle("counts");
+ fOutput->Add(fHistRCPtExPartialLJ[i]);
+
+ histname = "fHistDeltaPtRCExPartialLJ_";
+ histname += i;
+ fHistDeltaPtRCExPartialLJ[i] = new TH1F(histname.Data(), histname.Data(), fNbins * 2, -fMaxBinPt, fMaxBinPt);
+ fHistDeltaPtRCExPartialLJ[i]->GetXaxis()->SetTitle("#delta#it{p}_{T}^{RC} (GeV/#it{c})");
+ fHistDeltaPtRCExPartialLJ[i]->GetYaxis()->SetTitle("counts");
+ fOutput->Add(fHistDeltaPtRCExPartialLJ[i]);
}
}
- if (!fRandTracksName.IsNull() || !fRandCaloName.IsNull()) {
+ if (fRandTracksCont || fRandCaloClustersCont) {
histname = "fHistRCPtRand_";
histname += i;
fHistRCPtRand[i] = new TH1F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt * 2);
fOutput->Add(fHistDeltaPtRCRand[i]);
}
-
- if (!fEmbJetsName.IsNull()) {
+ if (fEmbJetsCont) {
histname = "fHistEmbJetsPtArea_";
histname += i;
- fHistEmbJetsPtArea[i] = new TH2F(histname.Data(), histname.Data(), 40, 0, fJetRadius * fJetRadius * TMath::Pi() * 3, fNbins, fMinBinPt, fMaxBinPt);
+ fHistEmbJetsPtArea[i] = new TH3F(histname.Data(), histname.Data(), 50, binsArea, fNbins, binsPt, nbinsZ, binsZ);
fHistEmbJetsPtArea[i]->GetXaxis()->SetTitle("area");
fHistEmbJetsPtArea[i]->GetYaxis()->SetTitle("#it{p}_{T,jet}^{emb,raw} (GeV/#it{c})");
fOutput->Add(fHistEmbJetsPtArea[i]);
histname = "fHistEmbJetsCorrPtArea_";
histname += i;
- fHistEmbJetsCorrPtArea[i] = new TH2F(histname.Data(), histname.Data(), 40, 0, fJetRadius * fJetRadius * TMath::Pi() * 3, fNbins * 2, -fMaxBinPt, fMaxBinPt);
+ fHistEmbJetsCorrPtArea[i] = new TH3F(histname.Data(), histname.Data(), 50, binsArea, fNbins * 2, binsCorrPt, nbinsZ, binsZ);
fHistEmbJetsCorrPtArea[i]->GetXaxis()->SetTitle("area");
fHistEmbJetsCorrPtArea[i]->GetYaxis()->SetTitle("#it{p}_{T,jet}^{emb,corr} (GeV/#it{c})");
fOutput->Add(fHistEmbJetsCorrPtArea[i]);
fHistEmbPartPtvsJetPt[i]->GetZaxis()->SetTitle("counts");
fOutput->Add(fHistEmbPartPtvsJetPt[i]);
- histname = "fHistLeadPartPtvsArea_";
+ histname = "fHistEmbPartPtvsJetCorrPt_";
+ histname += i;
+ fHistEmbPartPtvsJetCorrPt[i] = new TH2F(histname.Data(), histname.Data(),
+ fNbins, fMinBinPt, fMaxBinPt, fNbins*2, -fMaxBinPt, fMaxBinPt);
+ fHistEmbPartPtvsJetCorrPt[i]->GetXaxis()->SetTitle("#sum#it{p}_{T,const}^{emb} (GeV/#it{c})");
+ fHistEmbPartPtvsJetCorrPt[i]->GetYaxis()->SetTitle("#it{p}_{T,jet}^{emb} - A#rho (GeV/#it{c})");
+ fHistEmbPartPtvsJetCorrPt[i]->GetZaxis()->SetTitle("counts");
+ fOutput->Add(fHistEmbPartPtvsJetCorrPt[i]);
+
+ histname = "fHistJetPtvsJetCorrPt_";
histname += i;
- fHistLeadPartPtvsArea[i] = new TH2F(histname.Data(), histname.Data(), 40, 0, fJetRadius * fJetRadius * TMath::Pi() * 3, fNbins, fMinBinPt, fMaxBinPt);
- fHistLeadPartPtvsArea[i]->GetXaxis()->SetTitle("area");
- fHistLeadPartPtvsArea[i]->GetYaxis()->SetTitle("#it{p}_{T,const}^{leading} (GeV/#it{c})");
- fOutput->Add(fHistLeadPartPtvsArea[i]);
+ fHistJetPtvsJetCorrPt[i] = new TH2F(histname.Data(), histname.Data(),
+ fNbins, fMinBinPt, fMaxBinPt, fNbins*2, -fMaxBinPt, fMaxBinPt);
+ fHistJetPtvsJetCorrPt[i]->GetXaxis()->SetTitle("#it{p}_{T,jet}^{emb} (GeV/#it{c})");
+ fHistJetPtvsJetCorrPt[i]->GetYaxis()->SetTitle("#it{p}_{T,jet}^{emb} - A#rho (GeV/#it{c})");
+ fHistJetPtvsJetCorrPt[i]->GetZaxis()->SetTitle("counts");
+ fOutput->Add(fHistJetPtvsJetCorrPt[i]);
histname = "fHistDistLeadPart2JetAxis_";
histname += i;
fHistDistLeadPart2JetAxis[i]->GetYaxis()->SetTitle("counts");
fOutput->Add(fHistDistLeadPart2JetAxis[i]);
- histname = "fHistEmbNotFoundPhiEta_";
- histname += i;
- fHistEmbNotFoundPhiEta[i] = new TH2F(histname.Data(), histname.Data(), 40, -2, 2, 64, 0, 6.4);
- fHistEmbNotFoundPhiEta[i]->GetXaxis()->SetTitle("#eta");
- fHistEmbNotFoundPhiEta[i]->GetYaxis()->SetTitle("#phi");
- fOutput->Add(fHistEmbNotFoundPhiEta[i]);
-
- histname = "fHistEmbNotFoundPt_";
- histname += i;
- fHistEmbNotFoundPt[i] = new TH1F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt);
- fHistEmbNotFoundPt[i]->GetXaxis()->SetTitle("#it{p}_{T,const}^{emb} (GeV/#it{c})");
- fHistEmbNotFoundPt[i]->GetYaxis()->SetTitle("counts");
- fOutput->Add(fHistEmbNotFoundPt[i]);
-
histname = "fHistEmbBkgArea_";
histname += i;
- fHistEmbBkgArea[i] = new TH2F(histname.Data(), histname.Data(), 40, 0, fJetRadius * fJetRadius * TMath::Pi() * 3, fNbins, fMinBinPt, fMaxBinPt);
+ fHistEmbBkgArea[i] = new TH2F(histname.Data(), histname.Data(), 50, 0, 2, fNbins, fMinBinPt, fMaxBinPt);
fHistEmbBkgArea[i]->GetXaxis()->SetTitle("area");
fHistEmbBkgArea[i]->GetYaxis()->SetTitle("#it{p}_{T,jet}^{emb} - #sum#it{p}_{T,const}^{emb} (GeV/#it{c})");
fOutput->Add(fHistEmbBkgArea[i]);
histname = "fHistDeltaPtEmbArea_";
histname += i;
- fHistDeltaPtEmbArea[i] = new TH2F(histname.Data(), histname.Data(), 40, 0, fJetRadius * fJetRadius * TMath::Pi() * 3, fNbins * 2, -fMaxBinPt, fMaxBinPt);
+ fHistDeltaPtEmbArea[i] = new TH2F(histname.Data(), histname.Data(),
+ 50, 0, 2, fNbins * 2, -fMaxBinPt, fMaxBinPt);
fHistDeltaPtEmbArea[i]->GetXaxis()->SetTitle("area");
fHistDeltaPtEmbArea[i]->GetYaxis()->SetTitle("#delta#it{p}_{T}^{emb} (GeV/#it{c})");
+ fHistDeltaPtEmbArea[i]->GetZaxis()->SetTitle("counts");
fOutput->Add(fHistDeltaPtEmbArea[i]);
+
+ histname = "fHistDeltaPtEmbvsEP_";
+ histname += i;
+ fHistDeltaPtEmbvsEP[i] = new TH2F(histname.Data(), histname.Data(), 101, 0, TMath::Pi()*1.01, fNbins * 2, -fMaxBinPt, fMaxBinPt);
+ fHistDeltaPtEmbvsEP[i]->GetXaxis()->SetTitle("#phi_{jet} - #Psi_{EP}");
+ fHistDeltaPtEmbvsEP[i]->GetYaxis()->SetTitle("#delta#it{p}_{T}^{emb} (GeV/#it{c})");
+ fHistDeltaPtEmbvsEP[i]->GetZaxis()->SetTitle("counts");
+ fOutput->Add(fHistDeltaPtEmbvsEP[i]);
}
}
+ delete[] binsPt;
+ delete[] binsCorrPt;
+ delete[] binsArea;
+
PostData(1, fOutput); // Post data for ALL output slots >0 here, to get at least an empty histogram
}
// Random cones
// _________________________________
- const Float_t rcArea = fJetRadius * fJetRadius * TMath::Pi();
+ const Float_t rcArea = fConeRadius * fConeRadius * TMath::Pi();
Float_t RCpt = 0;
Float_t RCeta = 0;
Float_t RCphi = 0;
- if (fTracks || fCaloClusters) {
+ if (fTracksCont || fCaloClustersCont) {
for (Int_t i = 0; i < fRCperEvent; i++) {
// Simple random cones
RCpt = 0;
RCeta = 0;
RCphi = 0;
- GetRandomCone(RCpt, RCeta, RCphi, 0);
+ GetRandomCone(RCpt, RCeta, RCphi, fTracksCont, fCaloClustersCont, 0);
if (RCpt > 0) {
fHistRCPhiEta->Fill(RCeta, RCphi);
fHistRhoVSRCPt[fCentBin]->Fill(fRhoVal * rcArea, RCpt);
fHistRCPt[fCentBin]->Fill(RCpt);
- fHistDeltaPtRC[fCentBin]->Fill(RCpt - rcArea * fRhoVal);
+
+ Double_t ep = RCphi - fEPV0;
+ while (ep < 0) ep += TMath::Pi();
+ while (ep >= TMath::Pi()) ep -= TMath::Pi();
+
+ fHistDeltaPtRCvsEP[fCentBin]->Fill(ep, RCpt - rcArea * fRhoVal);
}
-
- if (fJets) {
+
+ if (fJetsCont) {
// Random cones far from leading jet
- Int_t *sortedJets = GetSortedArray(fJets);
-
- AliEmcalJet* jet = 0;
-
- if (sortedJets && sortedJets[0] > 0)
- jet = static_cast<AliEmcalJet*>(fJets->At(sortedJets[0]));
+ AliEmcalJet* jet = fJetsCont->GetLeadingJet("rho");
RCpt = 0;
RCeta = 0;
RCphi = 0;
- GetRandomCone(RCpt, RCeta, RCphi, jet);
+ GetRandomCone(RCpt, RCeta, RCphi, fTracksCont, fCaloClustersCont, jet);
if (RCpt > 0) {
if (jet) {
Float_t dphi = RCphi - jet->Phi();
fHistRCPtExLJ[fCentBin]->Fill(RCpt);
fHistDeltaPtRCExLJ[fCentBin]->Fill(RCpt - rcArea * fRhoVal);
}
+
+ //partial exclusion
+ if(fBeamType == kpA) {
+
+ RCpt = 0;
+ RCeta = 0;
+ RCphi = 0;
+ GetRandomCone(RCpt, RCeta, RCphi, fTracksCont, fCaloClustersCont, jet, kTRUE);
+
+ if (RCpt > 0) {
+ if (jet) {
+ Float_t dphi = RCphi - jet->Phi();
+ if (dphi > 4.8) dphi -= TMath::Pi() * 2;
+ if (dphi < -1.6) dphi += TMath::Pi() * 2;
+ fHistRCPtExPartialLJVSDPhiLJ->Fill(RCpt, dphi);
+ }
+ fHistRCPtExPartialLJ[fCentBin]->Fill(RCpt);
+ fHistDeltaPtRCExPartialLJ[fCentBin]->Fill(RCpt - rcArea * fRhoVal);
+ }
+ }
}
}
}
// Random cones with randomized particles
- if (fRandTracks || fRandCaloClusters) {
+ if (fRandTracksCont || fRandCaloClustersCont) {
RCpt = 0;
RCeta = 0;
RCphi = 0;
- GetRandomCone(RCpt, RCeta, RCphi, 0, fRandTracks, fRandCaloClusters);
+ GetRandomCone(RCpt, RCeta, RCphi, fRandTracksCont, fRandCaloClustersCont, 0);
if (RCpt > 0) {
fHistRCPtRand[fCentBin]->Fill(RCpt);
fHistDeltaPtRCRand[fCentBin]->Fill(RCpt - rcArea * fRhoVal);
// Embedding
// _________________________________
- if (fEmbJets) {
-
- AliEmcalJet *embJet = NextEmbeddedJet(0);
+ if (fEmbJetsCont) {
- Int_t countEmbJets = 0;
+ AliEmcalJet *embJet = NextEmbeddedJet(kTRUE);
while (embJet != 0) {
+ TLorentzVector mom;
+ fEmbJetsCont->GetLeadingHadronMomentum(mom,embJet);
- countEmbJets++;
-
- Double_t maxClusterPt = 0;
- Double_t maxClusterEta = 0;
- Double_t maxClusterPhi = 0;
-
- Double_t maxTrackPt = 0;
- Double_t maxTrackEta = 0;
- Double_t maxTrackPhi = 0;
-
- Double_t maxPartPt = 0;
- Double_t maxPartEta = 0;
- Double_t maxPartPhi = 0;
-
- AliVCluster *cluster = embJet->GetLeadingCluster(fEmbCaloClusters);
- if (cluster) {
- TLorentzVector nPart;
- cluster->GetMomentum(nPart, fVertex);
-
- maxClusterEta = nPart.Eta();
- maxClusterPhi = nPart.Phi();
- maxClusterPt = nPart.Pt();
- }
-
- AliVParticle *track = embJet->GetLeadingTrack(fEmbTracks);
- if (track) {
- maxTrackEta = track->Eta();
- maxTrackPhi = track->Phi();
- maxTrackPt = track->Pt();
- }
-
- if (!track && !cluster) {
- AliWarning(Form("%s - Embedded jet found but no leading particle was found (?) !", GetName()));
- return kTRUE;
- }
-
- if (maxTrackPt > maxClusterPt) {
- maxPartPt = maxTrackPt;
- maxPartEta = maxTrackEta;
- maxPartPhi = maxTrackPhi;
- }
- else {
- maxPartPt = maxClusterPt;
- maxPartEta = maxClusterEta;
- maxPartPhi = maxClusterPhi;
- }
-
- Double_t distLeading2Jet = TMath::Sqrt((embJet->Eta() - maxPartEta) * (embJet->Eta() - maxPartEta) + (embJet->Phi() - maxPartPhi) * (embJet->Phi() - maxPartPhi));
+ Double_t distLeading2Jet = TMath::Sqrt((embJet->Eta() - mom.Eta()) * (embJet->Eta() - mom.Eta()) + (embJet->Phi() - mom.Phi()) * (embJet->Phi() - mom.Phi()));
fHistEmbPartPtvsJetPt[fCentBin]->Fill(embJet->MCPt(), embJet->Pt());
- fHistLeadPartPhiEta->Fill(maxPartEta, maxPartPhi);
- fHistLeadPartPtvsArea[fCentBin]->Fill(maxPartPt, embJet->Area());
+ fHistEmbPartPtvsJetCorrPt[fCentBin]->Fill(embJet->MCPt(), embJet->Pt() - embJet->Area() * fRhoVal);
+ fHistLeadPartPhiEta->Fill(mom.Eta(), mom.Phi());
fHistDistLeadPart2JetAxis[fCentBin]->Fill(distLeading2Jet);
- fHistEmbJetsPtArea[fCentBin]->Fill(embJet->Area(), embJet->Pt());
- fHistEmbJetsCorrPtArea[fCentBin]->Fill(embJet->Area(), embJet->Pt() - fRhoVal * embJet->Area());
+ fHistEmbJetsPtArea[fCentBin]->Fill(embJet->Area(), embJet->Pt(), mom.Pt());
+ fHistEmbJetsCorrPtArea[fCentBin]->Fill(embJet->Area(), embJet->Pt() - fRhoVal * embJet->Area(), mom.Pt());
fHistEmbJetsPhiEta->Fill(embJet->Eta(), embJet->Phi());
+ fHistJetPtvsJetCorrPt[fCentBin]->Fill(embJet->Pt(), embJet->Pt() - fRhoVal * embJet->Area());
fHistEmbBkgArea[fCentBin]->Fill(embJet->Area(), embJet->Pt() - embJet->MCPt());
fHistRhoVSEmbBkg[fCentBin]->Fill(fRhoVal * embJet->Area(), embJet->Pt() - embJet->MCPt());
fHistDeltaPtEmbArea[fCentBin]->Fill(embJet->Area(), embJet->Pt() - embJet->Area() * fRhoVal - embJet->MCPt());
- embJet = NextEmbeddedJet();
- }
-
- if (countEmbJets==0) {
- if (fEmbTracks) {
- DoEmbTrackLoop();
- for (Int_t i = 0; i < fEmbeddedTrackNIds; i++) {
- AliVParticle *track2 = static_cast<AliVParticle*>(fEmbTracks->At(fEmbeddedTrackIds[i]));
- if (!track2) continue;
- fHistEmbNotFoundPhiEta[fCentBin]->Fill(track2->Eta(), track2->Phi());
- fHistEmbNotFoundPt[fCentBin]->Fill(track2->Pt());
- }
- }
-
- if (fEmbCaloClusters) {
- DoEmbClusterLoop();
- for (Int_t i = 0; i < fEmbeddedClusterNIds; i++) {
- AliVCluster *cluster2 = static_cast<AliVCluster*>(fEmbCaloClusters->At(fEmbeddedClusterIds[i]));
- TLorentzVector nPart;
- cluster2->GetMomentum(nPart, fVertex);
- fHistEmbNotFoundPhiEta[fCentBin]->Fill(nPart.Eta(), nPart.Phi());
- fHistEmbNotFoundPt[fCentBin]->Fill(nPart.Pt());
- }
- }
- }
- }
-
- return kTRUE;
-}
-
-//________________________________________________________________________
-void AliAnalysisTaskDeltaPt::DoEmbTrackLoop()
-{
- // Do track loop.
-
- fEmbeddedTrackNIds = 0;
-
- if (!fEmbTracks)
- return;
-
- Int_t ntracks = fEmbTracks->GetEntriesFast();
+ Double_t ep = embJet->Phi() - fEPV0;
+ while (ep < 0) ep += TMath::Pi();
+ while (ep >= TMath::Pi()) ep -= TMath::Pi();
- for (Int_t i = 0; i < ntracks; i++) {
+ fHistDeltaPtEmbvsEP[fCentBin]->Fill(ep, embJet->Pt() - embJet->Area() * fRhoVal - embJet->MCPt());
- AliVParticle* track = static_cast<AliVParticle*>(fEmbTracks->At(i)); // pointer to reconstructed to track
-
- if (!track) {
- AliError(Form("Could not retrieve track %d",i));
- continue;
- }
-
- AliVTrack* vtrack = dynamic_cast<AliVTrack*>(track);
-
- if (vtrack && !AcceptTrack(vtrack))
- continue;
-
- if (track->GetLabel() > 0) {
- fEmbeddedTrackIds[fEmbeddedTrackNIds] = i;
- fEmbeddedTrackNIds++;
+ embJet = NextEmbeddedJet();
}
}
-}
-
-//________________________________________________________________________
-void AliAnalysisTaskDeltaPt::DoEmbClusterLoop()
-{
- // Do cluster loop.
-
- fEmbeddedClusterNIds = 0;
- if (!fEmbCaloClusters)
- return;
-
- Int_t nclusters = fEmbCaloClusters->GetEntriesFast();
-
- for (Int_t iClusters = 0; iClusters < nclusters; iClusters++) {
- AliVCluster* cluster = static_cast<AliVCluster*>(fEmbCaloClusters->At(iClusters));
- if (!cluster) {
- AliError(Form("Could not receive cluster %d", iClusters));
- continue;
- }
-
- if (!AcceptCluster(cluster))
- continue;
-
- if (cluster->GetLabel() > 0) {
- fEmbeddedClusterIds[fEmbeddedClusterNIds] = iClusters;
- fEmbeddedClusterNIds++;
- }
- }
+ return kTRUE;
}
//________________________________________________________________________
-AliEmcalJet* AliAnalysisTaskDeltaPt::NextEmbeddedJet(Int_t i)
+AliEmcalJet* AliAnalysisTaskDeltaPt::NextEmbeddedJet(Bool_t reset)
{
- // Do the embedded jet loop.
-
- static Int_t iJet = 0;
-
- if (i >= 0)
- iJet = i;
- else
- iJet++;
+ // Get the next accepted embedded jet.
- if (!fEmbJets)
- return 0;
-
- TLorentzVector maxClusVect;
-
- const Int_t nembjets = fEmbJets->GetEntriesFast();
-
- for (; iJet < nembjets; iJet++) {
+ Int_t i = reset ? 0 : -1;
- AliEmcalJet* jet = static_cast<AliEmcalJet*>(fEmbJets->At(iJet));
-
- if (!jet) {
- AliError(Form("Could not receive jet %d", iJet));
- continue;
- }
-
- if (!AcceptJet(jet))
- continue;
+ AliEmcalJet* jet = fEmbJetsCont->GetNextAcceptJet(i);
+ while (jet && jet->MCPt() < fMCJetPtThreshold) jet = fEmbJetsCont->GetNextAcceptJet();
- if (jet->MCPt() >= fMCJetPtThreshold)
- return jet;
- }
-
- return 0;
+ return jet;
}
//________________________________________________________________________
void AliAnalysisTaskDeltaPt::GetRandomCone(Float_t &pt, Float_t &eta, Float_t &phi,
- AliEmcalJet *jet, TClonesArray* tracks, TClonesArray* clusters) const
+ AliParticleContainer* tracks, AliClusterContainer* clusters,
+ AliEmcalJet *jet, Bool_t bPartialExclusion) const
{
// Get rigid cone.
- if (!tracks)
- tracks = fTracks;
-
- if (!clusters)
- clusters = fCaloClusters;
-
- eta = 0;
- phi = 0;
+ eta = -999;
+ phi = -999;
pt = 0;
if (!tracks && !clusters)
LJphi = jet->Phi();
}
- Float_t maxEta = fJetMaxEta;
- Float_t minEta = fJetMinEta;
- Float_t maxPhi = fJetMaxPhi;
- Float_t minPhi = fJetMinPhi;
+ Float_t maxEta = fConeMaxEta;
+ Float_t minEta = fConeMinEta;
+ Float_t maxPhi = fConeMaxPhi;
+ Float_t minPhi = fConeMinPhi;
if (maxPhi > TMath::Pi() * 2) maxPhi = TMath::Pi() * 2;
if (minPhi < 0) minPhi = 0;
Float_t dLJ = 0;
Int_t repeats = 0;
+ Bool_t reject = kTRUE;
do {
eta = gRandom->Rndm() * (maxEta - minEta) + minEta;
phi = gRandom->Rndm() * (maxPhi - minPhi) + minPhi;
dLJ = TMath::Sqrt((LJeta - eta) * (LJeta - eta) + (LJphi - phi) * (LJphi - phi));
+
+ if(bPartialExclusion) {
+ reject = kFALSE;
+
+ TRandom3 rnd;
+ rnd.SetSeed(0);
+
+ Double_t ncoll = GetNColl();
+
+ Double_t prob = 0.;
+ if(ncoll>0)
+ prob = 1./ncoll;
+
+ if(rnd.Rndm()<=prob) reject = kTRUE; //reject cone
+ }
+
repeats++;
- } while (dLJ < fMinRC2LJ && repeats < 999);
+ } while (dLJ < fMinRC2LJ && repeats < 999 && reject);
if (repeats == 999) {
AliWarning(Form("%s: Could not get random cone!", GetName()));
}
if (clusters) {
- Int_t nclusters = clusters->GetEntriesFast();
- for (Int_t iClusters = 0; iClusters < nclusters; iClusters++) {
- AliVCluster* cluster = static_cast<AliVCluster*>(clusters->At(iClusters));
- if (!cluster) {
- AliError(Form("Could not receive cluster %d", iClusters));
- continue;
- }
-
- if (!AcceptCluster(cluster))
- continue;
-
+ AliVCluster* cluster = clusters->GetNextAcceptCluster(0);
+ while (cluster) {
TLorentzVector nPart;
cluster->GetMomentum(nPart, const_cast<Double_t*>(fVertex));
-
- Float_t d = TMath::Sqrt((nPart.Eta() - eta) * (nPart.Eta() - eta) + (nPart.Phi() - phi) * (nPart.Phi() - phi));
- if (d <= fJetRadius)
+ Float_t cluseta = nPart.Eta();
+ Float_t clusphi = nPart.Phi();
+
+ if (TMath::Abs(clusphi - phi) > TMath::Abs(clusphi - phi + 2 * TMath::Pi()))
+ clusphi += 2 * TMath::Pi();
+ if (TMath::Abs(clusphi - phi) > TMath::Abs(clusphi - phi - 2 * TMath::Pi()))
+ clusphi -= 2 * TMath::Pi();
+
+ Float_t d = TMath::Sqrt((cluseta - eta) * (cluseta - eta) + (clusphi - phi) * (clusphi - phi));
+ if (d <= fConeRadius)
pt += nPart.Pt();
+
+ cluster = clusters->GetNextAcceptCluster();
}
}
if (tracks) {
- Int_t ntracks = tracks->GetEntriesFast();
- for(Int_t iTracks = 0; iTracks < ntracks; iTracks++) {
- AliVTrack* track = static_cast<AliVTrack*>(tracks->At(iTracks));
- if(!track) {
- AliError(Form("Could not retrieve track %d",iTracks));
- continue;
- }
-
- if (!AcceptTrack(track))
- continue;
-
+ AliVParticle* track = tracks->GetNextAcceptParticle(0);
+ while(track) {
Float_t tracketa = track->Eta();
Float_t trackphi = track->Phi();
trackphi -= 2 * TMath::Pi();
Float_t d = TMath::Sqrt((tracketa - eta) * (tracketa - eta) + (trackphi - phi) * (trackphi - phi));
- if (d <= fJetRadius)
+ if (d <= fConeRadius)
pt += track->Pt();
+
+ track = tracks->GetNextAcceptParticle();
}
}
}
//________________________________________________________________________
-void AliAnalysisTaskDeltaPt::ExecOnce()
+void AliAnalysisTaskDeltaPt::SetConeEtaPhiEMCAL()
{
- // Initialize the analysis.
-
- if (!fEmbJetsName.IsNull() && !fEmbJets) {
- fEmbJets = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fEmbJetsName));
- if (!fEmbJets) {
- AliError(Form("%s: Could not retrieve embedded jets %s!", GetName(), fEmbJetsName.Data()));
- return;
- }
- else if (!fEmbJets->GetClass()->GetBaseClass("AliEmcalJet")) {
- AliError(Form("%s: Collection %s does not contain AliEmcalJet objects!", GetName(), fEmbJetsName.Data()));
- fEmbJets = 0;
- return;
- }
- }
+ // Set default cuts for full cones
- if (!fEmbCaloName.IsNull() && !fEmbCaloClusters) {
- fEmbCaloClusters = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fEmbCaloName));
- if (!fEmbCaloClusters) {
- AliError(Form("%s: Could not retrieve embedded clusters %s!", GetName(), fEmbCaloName.Data()));
- return;
- }
- else if (!fEmbCaloClusters->GetClass()->GetBaseClass("AliVCluster") && !fEmbCaloClusters->GetClass()->GetBaseClass("AliEmcalParticle")) {
- AliError(Form("%s: Collection %s does not contain AliVCluster nor AliEmcalParticle objects!", GetName(), fEmbCaloName.Data()));
- fEmbCaloClusters = 0;
- return;
- }
- }
+ SetConeEtaLimits(-0.7+fConeRadius,0.7-fConeRadius);
+ SetConePhiLimits(1.4+fConeRadius,TMath::Pi()-fConeRadius);
+}
- if (!fEmbTracksName.IsNull() && !fEmbTracks) {
- fEmbTracks = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fEmbTracksName));
- if (!fEmbTracks) {
- AliError(Form("%s: Could not retrieve embedded tracks %s!", GetName(), fEmbTracksName.Data()));
- return;
- }
- else if (!fEmbTracks->GetClass()->GetBaseClass("AliVParticle") && !fEmbTracks->GetClass()->GetBaseClass("AliEmcalParticle")) {
- AliError(Form("%s: Collection %s does not contain AliVParticle nor AliEmcalParticle objects!", GetName(), fEmbTracksName.Data()));
- fEmbTracks = 0;
- return;
- }
- }
+//________________________________________________________________________
+void AliAnalysisTaskDeltaPt::SetConeEtaPhiTPC()
+{
+ // Set default cuts for charged cones
- if (!fRandCaloName.IsNull() && !fRandCaloClusters) {
- fRandCaloClusters = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fRandCaloName));
- if (!fRandCaloClusters) {
- AliError(Form("%s: Could not retrieve randomized clusters %s!", GetName(), fRandCaloName.Data()));
- return;
- }
- else if (!fRandCaloClusters->GetClass()->GetBaseClass("AliVCluster") && !fRandCaloClusters->GetClass()->GetBaseClass("AliEmcalParticle")) {
- AliError(Form("%s: Collection %s does not contain AliVCluster nor AliEmcalParticle objects!", GetName(), fRandCaloName.Data()));
- fRandCaloClusters = 0;
- return;
- }
- }
+ SetConeEtaLimits(-0.9+fConeRadius, 0.9-fConeRadius);
+ SetConePhiLimits(-10, 10);
+}
- if (!fRandTracksName.IsNull() && !fRandTracks) {
- fRandTracks = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fRandTracksName));
- if (!fRandTracks) {
- AliError(Form("%s: Could not retrieve randomized tracks %s!", GetName(), fRandTracksName.Data()));
- return;
- }
- else if (!fRandTracks->GetClass()->GetBaseClass("AliVParticle") && !fRandTracks->GetClass()->GetBaseClass("AliEmcalParticle")) {
- AliError(Form("%s: Collection %s does not contain AliVParticle nor AliEmcalParticle objects!", GetName(), fRandTracksName.Data()));
- fRandTracks = 0;
- return;
- }
- }
+//________________________________________________________________________
+void AliAnalysisTaskDeltaPt::ExecOnce()
+{
+ // Initialize the analysis.
AliAnalysisTaskEmcalJet::ExecOnce();
+ if (fTracksCont && fTracksCont->GetArray() == 0) fTracksCont = 0;
+ if (fCaloClustersCont && fCaloClustersCont->GetArray() == 0) fCaloClustersCont = 0;
+ if (fEmbTracksCont && fEmbTracksCont->GetArray() == 0) fEmbTracksCont = 0;
+ if (fEmbCaloClustersCont && fEmbCaloClustersCont->GetArray() == 0) fEmbCaloClustersCont = 0;
+ if (fRandTracksCont && fRandTracksCont->GetArray() == 0) fRandTracksCont = 0;
+ if (fRandCaloClustersCont && fRandCaloClustersCont->GetArray() == 0) fRandCaloClustersCont = 0;
+ if (fJetsCont && fJetsCont->GetArray() == 0) fJetsCont = 0;
+ if (fEmbJetsCont && fEmbJetsCont->GetArray() == 0) fEmbJetsCont = 0;
+
if (fRCperEvent < 0) {
- Double_t area = (fJetMaxEta - fJetMinEta) * (fJetMaxPhi - fJetMinPhi);
- Double_t jetArea = TMath::Pi() * fJetRadius * fJetRadius;
- fRCperEvent = TMath::FloorNint(area / jetArea - 0.5);
+ Double_t area = (fConeMaxEta - fConeMinEta) * (fConeMaxPhi - fConeMinPhi);
+ Double_t rcArea = TMath::Pi() * fConeRadius * fConeRadius;
+ fRCperEvent = TMath::FloorNint(area / rcArea - 0.5);
if (fRCperEvent == 0)
fRCperEvent = 1;
}
if (fMinRC2LJ < 0)
- fMinRC2LJ = fJetRadius * 1.5;
+ fMinRC2LJ = fConeRadius * 1.5;
- const Float_t maxDist = TMath::Max(fJetMaxPhi - fJetMinPhi, fJetMaxEta - fJetMinEta) / 2;
+ const Float_t maxDist = TMath::Max(fConeMaxPhi - fConeMinPhi, fConeMaxEta - fConeMinEta) / 2;
if (fMinRC2LJ > maxDist) {
AliWarning(Form("The parameter fMinRC2LJ = %f is too large for the considered acceptance. "
"Will use fMinRC2LJ = %f", fMinRC2LJ, maxDist));
}
//________________________________________________________________________
-void AliAnalysisTaskDeltaPt::Terminate(Option_t *)
-{
- // Called once at the end of the analysis.
+Double_t AliAnalysisTaskDeltaPt::GetNColl() const {
+ // Get NColl - returns value of corresponding bin
+ // only works for pA
+ // values taken from V0A slicing https://twiki.cern.ch/twiki/bin/viewauth/ALICE/PACentStudies#Tables_with_centrality_bins_from
+
+ if(fBeamType == kpA) {
+
+ const Int_t nNCollBins = 7;
+
+ Double_t centMin[nNCollBins] = {0.,5.,10.,20.,40.,60.,80.};
+ Double_t centMax[nNCollBins] = {5.,10.,20.,40.,60.,80.,100.};
+
+ Double_t nColl[nNCollBins] = {14.7,13.,11.7,9.38,6.49,3.96,1.52};
+
+ for(Int_t i = 0; i<nNCollBins; i++) {
+ if(fCent>=centMin[i] && fCent<centMax[i])
+ return nColl[i];
+ }
+
+ return -1.;
+ }
+ else {
+ AliWarning(Form("%s: Only works for pA analysis. Returning -1",GetName()));
+ return -1.;
+ }
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff