From c554a9870aa8e71eddc734b64bad718499523e2b Mon Sep 17 00:00:00 2001 From: loizides Date: Wed, 2 May 2012 21:13:15 +0000 Subject: [PATCH] updates from Salvatore --- PWGGA/EMCALTasks/AliAnalysisTaskSAJF.cxx | 346 ++++++++++++++++++++--- PWGGA/EMCALTasks/AliAnalysisTaskSAJF.h | 22 +- PWGGA/EMCALTasks/AliAnalysisTaskSAQA.cxx | 88 +++--- PWGGA/EMCALTasks/AliAnalysisTaskSAQA.h | 2 + PWGGA/EMCALTasks/macros/AddTaskSAJF.C | 2 + 5 files changed, 378 insertions(+), 82 deletions(-) diff --git a/PWGGA/EMCALTasks/AliAnalysisTaskSAJF.cxx b/PWGGA/EMCALTasks/AliAnalysisTaskSAJF.cxx index 423f5c3a5af..85fc744535d 100644 --- a/PWGGA/EMCALTasks/AliAnalysisTaskSAJF.cxx +++ b/PWGGA/EMCALTasks/AliAnalysisTaskSAJF.cxx @@ -34,14 +34,18 @@ AliAnalysisTaskSAJF::AliAnalysisTaskSAJF() : fTracksName("Tracks"), fCaloName("CaloClusters"), fJetsName("Jets"), + fKtJetsName("KtJets"), fTrgClusName("ClustersL1GAMMAFEE"), fTracks(0), fCaloClusters(0), fJets(0), + fKtJets(0), fTrgClusters(0), fCent(0), fHistCentrality(0), fHistJetPhiEta(0), + fHistRhoClusVSleadJetE(0), + fHistRhoTracksVSleadJetE(0), Ptbins(400), Ptlow(0), Ptup(200), @@ -61,6 +65,12 @@ AliAnalysisTaskSAJF::AliAnalysisTaskSAJF() : fHistClusELJ[i] = 0; fHistTracksPtBkg[i] = 0; fHistClusEBkg[i] = 0; + fHistBkgClusPhiCorr[i] = 0; + fHistBkgTracksPhiCorr[i] = 0; + fHistBkgClusMeanRho[i] = 0; + fHistBkgTracksMeanRho[i] = 0; + fHistBkg2JetPhiCorr[i] = 0; + fHistMedianEnergyKt[i] = 0; } // Output slot #1 writes into a TH1 container @@ -75,14 +85,18 @@ AliAnalysisTaskSAJF::AliAnalysisTaskSAJF(const char *name) : fTracksName("Tracks"), fCaloName("CaloClusters"), fJetsName("Jets"), + fKtJetsName("KtJets"), fTrgClusName("ClustersL1GAMMAFEE"), fTracks(0), fCaloClusters(0), fJets(0), + fKtJets(0), fTrgClusters(0), fCent(0), fHistCentrality(0), fHistJetPhiEta(0), + fHistRhoClusVSleadJetE(0), + fHistRhoTracksVSleadJetE(0), Ptbins(400), Ptlow(0), Ptup(200), @@ -102,6 +116,12 @@ AliAnalysisTaskSAJF::AliAnalysisTaskSAJF(const char *name) : fHistClusELJ[i] = 0; fHistTracksPtBkg[i] = 0; fHistClusEBkg[i] = 0; + fHistBkgClusPhiCorr[i] = 0; + fHistBkgTracksPhiCorr[i] = 0; + fHistBkgClusMeanRho[i] = 0; + fHistBkgTracksMeanRho[i] = 0; + fHistBkg2JetPhiCorr[i] = 0; + fHistMedianEnergyKt[i] = 0; } // Output slot #1 writes into a TH1 container @@ -132,6 +152,16 @@ void AliAnalysisTaskSAJF::UserCreateOutputObjects() fHistJetPhiEta->GetYaxis()->SetTitle("Phi"); fOutput->Add(fHistJetPhiEta); + fHistRhoClusVSleadJetE = new TH2F("fHistRhoClusVSleadJetE","fHistRhoClusVSleadJetE", Ebins, Elow, Eup, Ebins, Elow, Eup); + fHistRhoClusVSleadJetE->GetXaxis()->SetTitle("#rho [GeV]"); + fHistRhoClusVSleadJetE->GetYaxis()->SetTitle("Leading jet energy [GeV]"); + fOutput->Add(fHistRhoClusVSleadJetE); + + fHistRhoTracksVSleadJetE = new TH2F("fHistRhoTracksVSleadJetE","fHistRhoTracksVSleadJetE", Ptbins, Ptlow, Ptup, Ebins, Elow, Eup); + fHistRhoTracksVSleadJetE->GetXaxis()->SetTitle("#rho [GeV/c]"); + fHistRhoTracksVSleadJetE->GetYaxis()->SetTitle("Leading jet energy"); + fOutput->Add(fHistRhoTracksVSleadJetE); + TString histname; for (Int_t i = 0; i < 4; i++) { @@ -197,6 +227,48 @@ void AliAnalysisTaskSAJF::UserCreateOutputObjects() fHistClusEBkg[i]->GetXaxis()->SetTitle("E [GeV]"); fHistClusEBkg[i]->GetYaxis()->SetTitle("counts"); fOutput->Add(fHistClusEBkg[i]); + + histname = "fHistBkgClusPhiCorr_"; + histname += i; + fHistBkgClusPhiCorr[i] = new TH1F(histname.Data(), histname.Data(), 128, -1.6, 4.8); + fHistBkgClusPhiCorr[i]->GetXaxis()->SetTitle("#Delta#phi"); + fHistBkgClusPhiCorr[i]->GetYaxis()->SetTitle("counts"); + fOutput->Add(fHistBkgClusPhiCorr[i]); + + histname = "fHistBkgTracksPhiCorr_"; + histname += i; + fHistBkgTracksPhiCorr[i] = new TH1F(histname.Data(), histname.Data(), 128, -1.6, 4.8); + fHistBkgTracksPhiCorr[i]->GetXaxis()->SetTitle("#Delta#phi"); + fHistBkgTracksPhiCorr[i]->GetYaxis()->SetTitle("counts"); + fOutput->Add(fHistBkgTracksPhiCorr[i]); + + histname = "fHistBkgClusMeanRho_"; + histname += i; + fHistBkgClusMeanRho[i] = new TH1F(histname.Data(), histname.Data(), Ebins, Elow, Eup); + fHistBkgClusMeanRho[i]->GetXaxis()->SetTitle("E [GeV]"); + fHistBkgClusMeanRho[i]->GetYaxis()->SetTitle("counts"); + fOutput->Add(fHistBkgClusMeanRho[i]); + + histname = "fHistBkgTracksMeanRho_"; + histname += i; + fHistBkgTracksMeanRho[i] = new TH1F(histname.Data(), histname.Data(), Ptbins, Ptlow, Ptup); + fHistBkgTracksMeanRho[i]->GetXaxis()->SetTitle("P_{T} [GeV/c]"); + fHistBkgTracksMeanRho[i]->GetYaxis()->SetTitle("counts"); + fOutput->Add(fHistBkgTracksMeanRho[i]); + + histname = "fHistBkg2JetPhiCorr_"; + histname += i; + fHistBkg2JetPhiCorr[i] = new TH1F(histname.Data(), histname.Data(), 128, -1.6, 4.8); + fHistBkg2JetPhiCorr[i]->GetXaxis()->SetTitle("#Delta#phi"); + fHistBkg2JetPhiCorr[i]->GetYaxis()->SetTitle("counts"); + fOutput->Add(fHistBkg2JetPhiCorr[i]); + + histname = "fHistMedianEnergyKt_"; + histname += i; + fHistMedianEnergyKt[i] = new TH1F(histname.Data(), histname.Data(), Ebins, Elow, Eup); + fHistMedianEnergyKt[i]->GetXaxis()->SetTitle("E [GeV]"); + fHistMedianEnergyKt[i]->GetYaxis()->SetTitle("counts"); + fOutput->Add(fHistMedianEnergyKt[i]); } PostData(1, fOutput); // Post data for ALL output slots >0 here, to get at least an empty histogram @@ -219,6 +291,13 @@ void AliAnalysisTaskSAJF::RetrieveEventObjects() AliWarning(Form("Could not retrieve jets!")); } + if (strcmp(fKtJetsName,"")) { + fKtJets = dynamic_cast(InputEvent()->FindListObject(fKtJetsName)); + if (!fKtJets) { + AliWarning(Form("Could not retrieve Kt jets!")); + } + } + if (strcmp(fTrgClusName,"")) { fTrgClusters = dynamic_cast(InputEvent()->FindListObject(fTrgClusName)); if (!fTrgClusters) { @@ -227,6 +306,9 @@ void AliAnalysisTaskSAJF::RetrieveEventObjects() } fCent = InputEvent()->GetCentrality(); + if (!fCent) { + AliWarning(Form("Could not retrieve centrality information!")); + } } AliVTrack* AliAnalysisTaskSAJF::GetTrack(const Int_t i) const @@ -277,6 +359,22 @@ Int_t AliAnalysisTaskSAJF::GetNumberOfJets() const return 0; } +AliEmcalJet* AliAnalysisTaskSAJF::GetKtJet(const Int_t i) const +{ + if (fKtJets) + return dynamic_cast(fKtJets->At(i)); + else + return 0; +} + +Int_t AliAnalysisTaskSAJF::GetNumberOfKtJets() const +{ + if (fKtJets) + return fKtJets->GetEntriesFast(); + else + return 0; +} + AliVCluster* AliAnalysisTaskSAJF::GetTrgCluster(const Int_t i) const { if (fTrgClusters) @@ -310,11 +408,51 @@ void AliAnalysisTaskSAJF::FillHistograms() else if(cent>=30 && cent<50) centbin=2; else if(cent>=50 && cent<=100) centbin=3; + // Kt Jet loop + Int_t nktjets = GetNumberOfKtJets(); + + if (nktjets > 0) { + + TArrayF ktJets(nktjets); + for (Int_t ij = 0; ij < nktjets; ij++) { + + AliEmcalJet* jet = GetKtJet(ij); + + if (!jet) { + printf("ERROR: Could not receive jet %d\n", ij); + continue; + } + + if (jet->E() <= 0) + continue; + + if (!AcceptJet(jet)) + continue; + + Int_t i = nktjets - 1; + while (jet->E() < ktJets[i] && i > 0) + i--; + memmove(ktJets.GetArray() + nktjets - ij - 1, ktJets.GetArray() + nktjets - ij, (ij + i - nktjets + 1) * sizeof(Float_t)); + ktJets[i] = jet->E(); + + } //kt jet loop + + Float_t ktJetsMedian; + if (nktjets % 2) + ktJetsMedian = ktJets[nktjets / 2 - 1]; + else + ktJetsMedian = (ktJets[nktjets / 2 - 1] + ktJets[nktjets / 2]) / 2; + + fHistMedianEnergyKt[centbin]->Fill(ktJetsMedian); + } + // Jet loop Int_t njets = GetNumberOfJets(); //cout << njets << " jets" << endl; Float_t maxJetEnergy = 0; Int_t maxJetIndex = -1; + Float_t max2JetEnergy = 0; + Int_t max2JetIndex = -1; for (Int_t ij = 0; ij < njets; ij++) { AliEmcalJet* jet = GetJet(ij); @@ -354,9 +492,15 @@ void AliAnalysisTaskSAJF::FillHistograms() } if (maxJetEnergy < jet->E()) { + max2JetEnergy = maxJetEnergy; + max2JetIndex = maxJetIndex; maxJetEnergy = jet->E(); maxJetIndex = ij; } + else if (max2JetEnergy < jet->E()) { + max2JetEnergy = jet->E(); + max2JetIndex = ij; + } } //jet loop @@ -368,11 +512,66 @@ void AliAnalysisTaskSAJF::FillHistograms() AliEmcalJet* jet = GetJet(maxJetIndex); if (!jet) return; - + + AliEmcalJet* jet2 = GetJet(max2JetIndex); + jet->SortConstituents(); + if (jet2) jet2->SortConstituents(); + + // Track loop + Float_t rhoTracks = 0; + Int_t ntracks = GetNumberOfTracks(); + for(Int_t iTracks = 0; iTracks < ntracks; iTracks++) { + AliVTrack* track = GetTrack(iTracks); + if(!track) { + AliError(Form("ERROR: Could not retrieve track %d",iTracks)); + continue; + } + + if (!AcceptTrack(track)) continue; + + if (IsJetTrack(jet, iTracks)) { + fHistTracksPtLJ[centbin]->Fill(track->Pt()); + } + else if (!jet2 || !IsJetTrack(jet2, iTracks)) { + fHistTracksPtBkg[centbin]->Fill(track->Pt()); + rhoTracks += track->Pt(); + + Float_t dphijet = jet->Phi() - track->Phi(); + if (dphijet < -1.6) dphijet += TMath::Pi() * 2; + if (dphijet > 4.8) dphijet -= TMath::Pi() * 2; + fHistBkg2JetPhiCorr[centbin]->Fill(dphijet); + + for(Int_t it2 = iTracks+1; it2 < ntracks; it2++) { + AliVTrack* track2 = GetTrack(it2); + if(!track2) { + AliError(Form("ERROR: Could not retrieve track %d", it2)); + continue; + } + + if (!AcceptTrack(track2)) continue; + + if (IsJetTrack(jet, it2)) continue; + + if (jet2 && IsJetTrack(jet2, it2)) continue; + + Float_t dphi = track->Phi() - track2->Phi(); + if (dphi < -1.6) dphi += TMath::Pi() * 2; + if (dphi > 4.8) dphi -= TMath::Pi() * 2; + fHistBkgTracksPhiCorr[centbin]->Fill(dphi); + } // second track loop + } + } // track loop + + rhoTracks /= GetArea(); + fHistBkgTracksMeanRho[centbin]->Fill(rhoTracks); + + fHistRhoTracksVSleadJetE->Fill(rhoTracks, maxJetEnergy); + + if (fAnaType == kFullAcceptance) return; // Cluster loop - Int_t clusJetId = 0; + Float_t rhoClus = 0; Int_t nclusters = GetNumberOfCaloClusters(); for (Int_t iClusters = 0; iClusters < nclusters; iClusters++) { AliVCluster* cluster = GetCaloCluster(iClusters); @@ -383,58 +582,99 @@ void AliAnalysisTaskSAJF::FillHistograms() if (!(cluster->IsEMCAL())) continue; - if (jet->GetNumberOfClusters() > 0) { - if (jet->ClusterAt(clusJetId) < iClusters) { - if (clusJetId < jet->GetNumberOfClusters() - 1) - clusJetId++; - } - - if (jet->ClusterAt(clusJetId) == iClusters) { - fHistClusELJ[centbin]->Fill(cluster->E()); - } - else { - fHistClusEBkg[centbin]->Fill(cluster->E()); - } + if (IsJetCluster(jet, iClusters)) { + fHistClusELJ[centbin]->Fill(cluster->E()); } - else { + else if (!jet2 || !IsJetCluster(jet2, iClusters)) { fHistClusEBkg[centbin]->Fill(cluster->E()); + rhoClus += cluster->E(); + + Float_t pos1[3]; + cluster->GetPosition(pos1); + TVector3 clusVec1(pos1); + + Float_t dphijet = jet->Phi() - clusVec1.Phi(); + if (dphijet < -1.6) dphijet += TMath::Pi() * 2; + if (dphijet > 4.8) dphijet -= TMath::Pi() * 2; + fHistBkg2JetPhiCorr[centbin]->Fill(dphijet); + + for(Int_t ic2 = iClusters+1; ic2 < nclusters; ic2++) { + AliVCluster* cluster2 = GetCaloCluster(ic2); + if (!cluster2) { + printf("ERROR: Could not receive cluster %d\n", ic2); + continue; + } + + if (!(cluster2->IsEMCAL())) continue; + + if (IsJetCluster(jet, ic2)) continue; + + if (jet2 && IsJetCluster(jet2, ic2)) continue; + + Float_t pos2[3]; + cluster2->GetPosition(pos2); + TVector3 clusVec2(pos2); + + Float_t dphi = clusVec1.Phi() - clusVec2.Phi(); + if (dphi < -1.6) dphi += TMath::Pi() * 2; + if (dphi > 4.8) dphi -= TMath::Pi() * 2; + fHistBkgClusPhiCorr[centbin]->Fill(dphi); + } } } //cluster loop - - // Track loop - Int_t trackJetId = 0; - Int_t ntracks = GetNumberOfTracks(); - for(Int_t iTracks = 0; iTracks < ntracks; iTracks++) { - AliVTrack* track = GetTrack(iTracks); - if(!track) { - AliError(Form("ERROR: Could not retrieve track %d",iTracks)); - continue; - } - - if (!AcceptTrack(track)) continue; - - if (jet->GetNumberOfTracks() > 0) { - if (jet->TrackAt(trackJetId) < iTracks) { - if (trackJetId < jet->GetNumberOfTracks() - 1) - trackJetId++; - } - - if (jet->TrackAt(trackJetId) == iTracks) { - fHistTracksPtLJ[centbin]->Fill(track->Pt()); - } - else { - fHistTracksPtBkg[centbin]->Fill(track->Pt()); - } - } - else { - fHistTracksPtBkg[centbin]->Fill(track->Pt()); - } + rhoClus /= GetArea(); + fHistBkgClusMeanRho[centbin]->Fill(rhoClus); + + fHistRhoClusVSleadJetE->Fill(rhoClus, maxJetEnergy); +} + +//________________________________________________________________________ +Float_t AliAnalysisTaskSAJF::GetArea() const +{ + if (fAnaType == kFullAcceptance) { + return 2 * TMath::Pi() * 2; + } + else if (fAnaType == kEMCAL) { + return 1.4 * 100 * TMath::DegToRad(); + } + else if (fAnaType == kEMCAL) { + return 1.4 * 100 * TMath::DegToRad(); + } + else { + AliWarning("Analysis type not recognized! Assuming kFullAcceptance..."); + return 2 * TMath::Pi() * 2; + } +} + +//________________________________________________________________________ +Bool_t AliAnalysisTaskSAJF::IsJetTrack(AliEmcalJet* jet, Int_t itrack, Bool_t sorted) const +{ + for (Int_t i = 0; i < jet->GetNumberOfTracks(); i++) { + Int_t ijettrack = jet->TrackAt(i); + if (sorted && ijettrack > itrack) + return kFALSE; + if (ijettrack == itrack) + return kTRUE; + } + return kFALSE; +} + +//________________________________________________________________________ +Bool_t AliAnalysisTaskSAJF::IsJetCluster(AliEmcalJet* jet, Int_t iclus, Bool_t sorted) const +{ + for (Int_t i = 0; i < jet->GetNumberOfClusters(); i++) { + Int_t ijetclus = jet->ClusterAt(i); + if (sorted && ijetclus > iclus) + return kFALSE; + if (ijetclus == iclus) + return kTRUE; } + return kFALSE; } //________________________________________________________________________ -Bool_t AliAnalysisTaskSAJF::AcceptJet(AliEmcalJet* jet) +Bool_t AliAnalysisTaskSAJF::AcceptJet(AliEmcalJet* jet) const { if (fAnaType == kFullAcceptance) { return kTRUE; @@ -452,9 +692,21 @@ Bool_t AliAnalysisTaskSAJF::AcceptJet(AliEmcalJet* jet) } //________________________________________________________________________ -Bool_t AliAnalysisTaskSAJF::AcceptTrack(AliVTrack* /*track*/) +Bool_t AliAnalysisTaskSAJF::AcceptTrack(AliVTrack* track) const { - return kTRUE; + if (fAnaType == kFullAcceptance) { + return kTRUE; + } + else if (fAnaType == kEMCAL) { + return (Bool_t)(TMath::Abs(track->Eta()) < 0.7 && track->Phi() * TMath::RadToDeg() > 80 && track->Phi() * TMath::RadToDeg() < 180); + } + else if (fAnaType == kEMCALFiducial) { + return (Bool_t)(TMath::Abs(track->Eta()) < 0.7 && track->Phi() * TMath::RadToDeg() > 80 && track->Phi() * TMath::RadToDeg() < 180); + } + else { + AliWarning("Analysis type not recognized! Assuming kFullAcceptance..."); + return kTRUE; + } } //________________________________________________________________________ diff --git a/PWGGA/EMCALTasks/AliAnalysisTaskSAJF.h b/PWGGA/EMCALTasks/AliAnalysisTaskSAJF.h index 27674485996..679c63b35b9 100644 --- a/PWGGA/EMCALTasks/AliAnalysisTaskSAJF.h +++ b/PWGGA/EMCALTasks/AliAnalysisTaskSAJF.h @@ -33,6 +33,7 @@ class AliAnalysisTaskSAJF : public AliAnalysisTaskSE { void SetClusName(const char *n) { fCaloName = n ; } void SetJetsName(const char *n) { fJetsName = n ; } + void SetKtJetsName(const char *n) { fKtJetsName = n ; } void SetTracksName(const char *n) { fTracksName = n ; } void SetTrgClusName(const char *n) { fTrgClusName = n ; } void SetAnaType(SAJFAnaType type) { fAnaType = type ; } @@ -45,35 +46,52 @@ class AliAnalysisTaskSAJF : public AliAnalysisTaskSE { Int_t GetNumberOfCaloClusters() const; AliEmcalJet *GetJet(const Int_t i) const; Int_t GetNumberOfJets() const; + AliEmcalJet *GetKtJet(const Int_t i) const; + Int_t GetNumberOfKtJets() const; AliVCluster *GetTrgCluster(const Int_t i) const; Int_t GetNumberOfTrgClusters() const; void FillHistograms() ; void RetrieveEventObjects() ; - Bool_t AcceptTrack(AliVTrack* /*track*/) ; - Bool_t AcceptJet(AliEmcalJet* jet) ; + Bool_t AcceptTrack(AliVTrack* track) const; + Bool_t AcceptJet(AliEmcalJet* jet) const; + Bool_t IsJetTrack(AliEmcalJet* jet, Int_t itrack, Bool_t sorted = kTRUE) const; + Bool_t IsJetCluster(AliEmcalJet* jet, Int_t iclus, Bool_t sorted = kTRUE) const; + Float_t GetArea() const; + SAJFAnaType fAnaType; // analysis type TList *fOutput; // Output list TString fTracksName; // name of track collection TString fCaloName; // name of calo cluster collection TString fJetsName; // name of jet collection + TString fKtJetsName; // name of kt jet collection TString fTrgClusName; // name of trg clus name TClonesArray *fTracks; //!Tracks TClonesArray *fCaloClusters; //!Clusters TClonesArray *fJets; //!Jets + TClonesArray *fKtJets; //!Kt Jets TClonesArray *fTrgClusters; //!Trg Clusters AliCentrality *fCent; // Event centrality TH1F *fHistCentrality; // Event centrality distribution TH2F *fHistJetPhiEta; // Phi-Eta distribution of jets + TH2F *fHistRhoClusVSleadJetE; // Background energy density of clusters vs. leading jet energy + TH2F *fHistRhoTracksVSleadJetE;// Background pt density of tracks vs. leading jet energy TH1F *fHistJetsE[4]; // Jet energy spectrum TH1F *fHistJetsNE[4]; // Jet neutral energy spectrum TH1F *fHistJetsNEF[4]; // Jet neutral energy fraction TH1F *fHistJetsZ[4]; // Constituent Pt over Jet E ratio TH1F *fHistLeadingJetE[4]; // Leading jet energy spectrum + TH1F *fHist2LeadingJetE[4]; // Second leading jet energy spectrum TH1F *fHistTracksPtLJ[4]; // Pt spectrum of tracks TH1F *fHistClusELJ[4]; // Energy spectrum of clusters TH1F *fHistTracksPtBkg[4]; // Pt spectrum of tracks TH1F *fHistClusEBkg[4]; // Energy spectrum of clusters + TH1F *fHistBkgClusPhiCorr[4]; // Background clusters phi correlations + TH1F *fHistBkgTracksPhiCorr[4];// Background tracks phi correlations + TH1F *fHistBkgClusMeanRho[4]; // Background clusters mean energy density + TH1F *fHistBkgTracksMeanRho[4];// Background tracks mean pt density + TH1F *fHistBkg2JetPhiCorr[4]; // Background tracks/cluster phi correlation with leading jet + TH1F *fHistMedianEnergyKt[4]; // Median of the energy of kt jets, excluded the 2 most energetic Int_t Ptbins; // No. of pt bins Float_t Ptlow; // Min pt Float_t Ptup; // Max pt diff --git a/PWGGA/EMCALTasks/AliAnalysisTaskSAQA.cxx b/PWGGA/EMCALTasks/AliAnalysisTaskSAQA.cxx index 7fcc2371cac..7441b251034 100644 --- a/PWGGA/EMCALTasks/AliAnalysisTaskSAQA.cxx +++ b/PWGGA/EMCALTasks/AliAnalysisTaskSAQA.cxx @@ -47,6 +47,8 @@ AliAnalysisTaskSAQA::AliAnalysisTaskSAQA() : fHistTrPhiEta(0), fHistClusPhiEta(0), fHistMaxTrgCluster(0), + fHistClusPhiCorr(0), + fHistTracksPhiCorr(0), Ptbins(100), Ptlow(0), Ptup(50), @@ -86,6 +88,8 @@ AliAnalysisTaskSAQA::AliAnalysisTaskSAQA(const char *name) : fHistTrPhiEta(0), fHistClusPhiEta(0), fHistMaxTrgCluster(0), + fHistClusPhiCorr(0), + fHistTracksPhiCorr(0), Ptbins(100), Ptlow(0), Ptup(50), @@ -162,6 +166,16 @@ void AliAnalysisTaskSAQA::UserCreateOutputObjects() fHistMaxTrgCluster->GetXaxis()->SetTitle("E [GeV]"); fHistMaxTrgCluster->GetYaxis()->SetTitle("counts"); fOutput->Add(fHistMaxTrgCluster); + + fHistTracksPhiCorr = new TH1F("fHistTracksPhiCorr", "fHistTracksPhiCorr", 128, -1.6, 4.8); + fHistTracksPhiCorr->GetXaxis()->SetTitle("#Delta#phi"); + fHistTracksPhiCorr->GetYaxis()->SetTitle("counts"); + fOutput->Add(fHistTracksPhiCorr); + + fHistClusPhiCorr = new TH1F("fHistClusPhiCorr", "fHistClusPhiCorr", 128, -1.6, 4.8); + fHistClusPhiCorr->GetXaxis()->SetTitle("#Delta#phi"); + fHistClusPhiCorr->GetYaxis()->SetTitle("counts"); + fOutput->Add(fHistClusPhiCorr); for (Int_t i = 0; i < 5; i++) { TString histnamephi("fHistTrackPhi_"); @@ -292,9 +306,27 @@ void AliAnalysisTaskSAQA::FillHistograms() cluster->GetPosition(pos); TVector3 clusVec(pos); fHistClusPhiEta->Fill(clusVec.Eta(), clusVec.Phi()); + + for(Int_t ic2 = iClusters+1; ic2 < nclusters; ic2++) { + AliVCluster* cluster2 = GetCaloCluster(ic2); + if (!cluster2) { + printf("ERROR: Could not receive cluster %d\n", ic2); + continue; + } + + if (!(cluster2->IsEMCAL())) continue; + + Float_t pos2[3]; + cluster2->GetPosition(pos2); + TVector3 clusVec2(pos2); + + Float_t dphi = clusVec.Phi() - clusVec2.Phi(); + if (dphi < -1.6) dphi += TMath::Pi() * 2; + if (dphi > 4.8) dphi -= TMath::Pi() * 2; + fHistClusPhiCorr->Fill(dphi); + } } //cluster loop - // Track loop Int_t ntracks = GetNumberOfTracks(); //cout << ntracks << " tracks" << endl; @@ -308,54 +340,44 @@ void AliAnalysisTaskSAQA::FillHistograms() if (!AcceptTrack(track)) continue; + for(Int_t it2 = i+1; it2 < ntracks; it2++) { + AliVTrack* track2 = GetTrack(it2); + if(!track2) { + AliError(Form("ERROR: Could not retrieve track %d", it2)); + continue; + } + + if (!AcceptTrack(track2)) continue; + + Float_t dphi = track->Phi() - track2->Phi(); + if (dphi < -1.6) dphi += TMath::Pi() * 2; + if (dphi > 4.8) dphi -= TMath::Pi() * 2; + fHistTracksPhiCorr->Fill(dphi); + } // second track loop + fHistTracksPt->Fill(track->Pt()); Int_t clId = track->GetEMCALcluster(); - if (clId > -1) { + if (clId > -1 && clId < nclusters) { AliVCluster* cluster = GetCaloCluster(clId); if (cluster) fHistEPcorrelation->Fill(track->P(),cluster->E()); } - Float_t eta,phi; - Int_t label; - - if(track->InheritsFrom("AliESDtrack")) { - AliESDtrack *esdtrack = dynamic_cast(track); - eta = esdtrack->Eta(); - phi = esdtrack->Phi(); - label = esdtrack->GetLabel(); - } - else if (track->InheritsFrom("AliAODTrack")) { - AliAODTrack *aodtrack = dynamic_cast(track); - eta = aodtrack->Eta(); - phi = aodtrack->Phi(); - label = aodtrack->GetLabel(); - } - else if (track->InheritsFrom("AliPicoTrack")) { - AliPicoTrack *picotrack = dynamic_cast(track); - eta = picotrack->Eta(); - phi = picotrack->Phi(); - label = picotrack->GetLabel(); - } - else { - AliWarning("Track type not recognized! Will not plot phi\eta distributions!"); - continue; - } + Int_t label = track->GetLabel(); - fHistTrPhiEta->Fill(eta, phi); + fHistTrPhiEta->Fill(track->Eta(), track->Phi()); - fHistTrackEta[4]->Fill(eta); - fHistTrackPhi[4]->Fill(phi); + fHistTrackEta[4]->Fill(track->Eta()); + fHistTrackPhi[4]->Fill(track->Phi()); if (label >= 0 && label < 4) { - fHistTrackEta[label]->Fill(eta); - fHistTrackPhi[label]->Fill(phi); + fHistTrackEta[label]->Fill(track->Eta()); + fHistTrackPhi[label]->Fill(track->Phi()); } else { AliWarning(Form("Track label %d not recognized!",label)); } - } Int_t ntrgclusters = GetNumberOfTrgClusters(); diff --git a/PWGGA/EMCALTasks/AliAnalysisTaskSAQA.h b/PWGGA/EMCALTasks/AliAnalysisTaskSAQA.h index bdf56f58249..9aace4fd816 100644 --- a/PWGGA/EMCALTasks/AliAnalysisTaskSAQA.h +++ b/PWGGA/EMCALTasks/AliAnalysisTaskSAQA.h @@ -58,6 +58,8 @@ class AliAnalysisTaskSAQA : public AliAnalysisTaskSE { TH2F *fHistTrPhiEta; // Phi-Eta distribution of tracks TH2F *fHistClusPhiEta; // Phi-Eta distribution of clusters TH1F *fHistMaxTrgCluster; // Energy distribution of max trigger clusters + TH1F *fHistClusPhiCorr; // Clusters phi correlations + TH1F *fHistTracksPhiCorr; // Tracks phi correlations TH1F *fHistTrackPhi[5]; // Phi distribution of hybrid tracks TH1F *fHistTrackEta[5]; // Eta distribution of hybrid tracks diff --git a/PWGGA/EMCALTasks/macros/AddTaskSAJF.C b/PWGGA/EMCALTasks/macros/AddTaskSAJF.C index a617778f4e6..7d90f035d87 100644 --- a/PWGGA/EMCALTasks/macros/AddTaskSAJF.C +++ b/PWGGA/EMCALTasks/macros/AddTaskSAJF.C @@ -5,6 +5,7 @@ AliAnalysisTaskSAJF* AddTaskSAJF( const char *ntracks = "Tracks", const char *nclusters = "CaloClusters", const char *njets = "Jets", + const char *nktjets = "KtJets", const char *ntrgclusters = "ClustersL1GAMMAFEE", UInt_t type = AliAnalysisTaskSAJF::kEMCAL ) @@ -35,6 +36,7 @@ AliAnalysisTaskSAJF* AddTaskSAJF( phTask->SetTracksName(ntracks); phTask->SetClusName(nclusters); phTask->SetJetsName(njets); + phTask->SetKtJetsName(nktjets); phTask->SetTrgClusName(ntrgclusters); //------------------------------------------------------- -- 2.43.0