--- /dev/null
+// $Id$
+
+#include <TChain.h>
+#include <TClonesArray.h>
+#include <TH1F.h>
+#include <TH2F.h>
+#include <TList.h>
+#include <TLorentzVector.h>
+#include <TParticle.h>
+
+#include "AliAnalysisManager.h"
+#include "AliCentrality.h"
+#include "AliVCluster.h"
+#include "AliESDtrack.h"
+#include "AliEmcalJet.h"
+#include "AliAODTrack.h"
+#include "AliESDtrack.h"
+#include "AliEmcalJet.h"
+#include "AliVEventHandler.h"
+#include "AliPicoTrack.h"
+
+#include "AliEmcalQATask.h"
+
+ClassImp(AliEmcalQATask)
+
+//________________________________________________________________________
+AliEmcalQATask::AliEmcalQATask() :
+ AliAnalysisTaskSE("AliEmcalQATask"),
+ fOutput(0),
+ fTracksName("Tracks"),
+ fCaloName("CaloClusters"),
+ fJetsName("Jets"),
+ fTrgClusName("ClustersL1GAMMAFEE"),
+ fTracks(0),
+ fCaloClusters(0),
+ fJets(0),
+ fTrgClusters(0),
+ fCent(0),
+ fHistCentrality(0),
+ fHistTracksCent(0),
+ fHistClusCent(0),
+ fHistTracksPt(0),
+ fHistClustersEnergy(0),
+ fHistEPcorrelation(0),
+ fHistJetsEnergy(0),
+ fHistTrPhiEta(0),
+ fHistClusPhiEta(0),
+ fHistJetPhiEta(0),
+ fHistMaxTrgCluster(0),
+ Ptbins(100),
+ Ptlow(0),
+ Ptup(50),
+ Ebins(100),
+ Elow(0),
+ Eup(50)
+{
+ // Default constructor.
+
+ for (Int_t i = 0; i < 5; i++) {
+ fHistTrackPhi[i] = 0;
+ fHistTrackEta[i] = 0;
+ }
+
+ fBranchNames="ESD:AliESDRun.,AliESDHeader.,PrimaryVertex.";
+
+}
+
+//________________________________________________________________________
+AliEmcalQATask::AliEmcalQATask(const char *name) :
+ AliAnalysisTaskSE("AliEmcalQATask"),
+ fOutput(0),
+ fTracksName("Tracks"),
+ fCaloName("CaloClusters"),
+ fJetsName("Jets"),
+ fTrgClusName("ClustersL1GAMMAFEE"),
+ fTracks(0),
+ fCaloClusters(0),
+ fJets(0),
+ fTrgClusters(0),
+ fCent(0),
+ fHistCentrality(0),
+ fHistTracksCent(0),
+ fHistClusCent(0),
+ fHistTracksPt(0),
+ fHistClustersEnergy(0),
+ fHistEPcorrelation(0),
+ fHistJetsEnergy(0),
+ fHistTrPhiEta(0),
+ fHistClusPhiEta(0),
+ fHistJetPhiEta(0),
+ fHistMaxTrgCluster(0),
+ Ptbins(100),
+ Ptlow(0),
+ Ptup(50),
+ Ebins(100),
+ Elow(0),
+ Eup(50)
+{
+ // Standard constructor.
+
+ for (Int_t i = 0; i < 5; i++) {
+ fHistTrackPhi[i] = 0;
+ fHistTrackEta[i] = 0;
+ }
+
+ if (!name)
+ return;
+
+ SetName(name);
+ fBranchNames="ESD:AliESDRun.,AliESDHeader.,PrimaryVertex.";
+
+ DefineInput(0,TChain::Class());
+ DefineOutput(1,TList::Class());
+}
+
+//________________________________________________________________________
+AliEmcalQATask::~AliEmcalQATask()
+{
+ // Destructor
+}
+
+//________________________________________________________________________
+void AliEmcalQATask::UserCreateOutputObjects()
+{
+ // Create histograms
+
+ fOutput = new TList();
+ fOutput->SetOwner(); // IMPORTANT!
+
+ fHistCentrality = new TH1F("fHistCentrality","Event centrality distribution", Ebins, 0, 100);
+ fHistCentrality->GetXaxis()->SetTitle("Centrality (%)");
+ fHistCentrality->GetYaxis()->SetTitle("counts");
+ fOutput->Add(fHistCentrality);
+
+ fHistTracksCent = new TH2F("fHistTracksCent","Tracks vs. centrality", Ebins, 0, 100, Ebins, 0, 4000);
+ fHistTracksCent->GetXaxis()->SetTitle("Centrality (%)");
+ fHistTracksCent->GetYaxis()->SetTitle("No. of tracks");
+ fOutput->Add(fHistTracksCent);
+
+ fHistClusCent = new TH2F("fHistClusCent","Clusters vs. centrality", Ebins, 0, 100, Ebins, 0, 2000);
+ fHistClusCent->GetXaxis()->SetTitle("Centrality (%)");
+ fHistClusCent->GetYaxis()->SetTitle("No. of clusters");
+ fOutput->Add(fHistClusCent);
+
+ fHistTracksPt = new TH1F("fHistTracksPt","P_{T} spectrum of reconstructed tracks", Ptbins, Ptlow, Ptup);
+ fHistTracksPt->GetXaxis()->SetTitle("P_{T} [GeV/c]");
+ fHistTracksPt->GetYaxis()->SetTitle("counts");
+ fOutput->Add(fHistTracksPt);
+
+ fHistClustersEnergy = new TH1F("fHistClustersEnergy","Energy spectrum of clusters", Ebins, Elow, Eup);
+ fHistClustersEnergy->GetXaxis()->SetTitle("E [GeV]");
+ fHistClustersEnergy->GetYaxis()->SetTitle("counts");
+ fOutput->Add(fHistClustersEnergy);
+
+ fHistEPcorrelation = new TH2F("fHistEPcorrelation","Energy-momentum correlation", Ptbins, Ptlow, Ptup, Ebins, Elow, Eup);
+ fHistEPcorrelation->GetXaxis()->SetTitle("P [GeV/c]");
+ fHistEPcorrelation->GetYaxis()->SetTitle("E [GeV]");
+ fOutput->Add(fHistEPcorrelation);
+
+ fHistJetsEnergy = new TH1F("fHistJetsEnergy","Energy spectrum of jets", Ebins, Elow, Eup);
+ fHistJetsEnergy->GetXaxis()->SetTitle("E [GeV]");
+ fHistJetsEnergy->GetYaxis()->SetTitle("counts");
+ fOutput->Add(fHistJetsEnergy);
+
+ fHistTrPhiEta = new TH2F("fHistTrPhiEta","Phi-Eta distribution of tracks", 20, -2, 2, 32, 0, 6.4);
+ fHistTrPhiEta->GetXaxis()->SetTitle("Eta");
+ fHistTrPhiEta->GetYaxis()->SetTitle("Phi");
+ fOutput->Add(fHistTrPhiEta);
+
+ fHistClusPhiEta = new TH2F("fHistClusPhiEta","Phi-Eta distribution of clusters", 20, -2, 2, 32, 0, 6.4);
+ fHistClusPhiEta->GetXaxis()->SetTitle("Eta");
+ fHistClusPhiEta->GetYaxis()->SetTitle("Phi");
+ fOutput->Add(fHistClusPhiEta);
+
+ fHistJetPhiEta = new TH2F("fHistJetPhiEta","Phi-Eta distribution of jets", 20, -2, 2, 32, 0, 6.4);
+ fHistJetPhiEta->GetXaxis()->SetTitle("Eta");
+ fHistJetPhiEta->GetYaxis()->SetTitle("Phi");
+ fOutput->Add(fHistJetPhiEta);
+
+ fHistMaxTrgCluster = new TH1F("fHistMaxTrgCluster","Energy distribution of max trigger clusters", Ebins, Elow, Eup);
+ fHistMaxTrgCluster->GetXaxis()->SetTitle("E [GeV]");
+ fHistMaxTrgCluster->GetYaxis()->SetTitle("counts");
+ fOutput->Add(fHistMaxTrgCluster);
+
+ for (Int_t i = 0; i < 5; i++) {
+ TString histnamephi("fHistTrackPhi_");
+ histnamephi += i;
+ fHistTrackPhi[i] = new TH1F(histnamephi.Data(),histnamephi.Data(), 128, 0, 6.4);
+ fHistTrackPhi[i]->GetXaxis()->SetTitle("Phi");
+ fOutput->Add(fHistTrackPhi[i]);
+
+ TString histnameeta("fHistTrackEta_");
+ histnameeta += i;
+ fHistTrackEta[i] = new TH1F(histnameeta.Data(),histnameeta.Data(), 100, -2, 2);
+ fHistTrackEta[i]->GetXaxis()->SetTitle("Eta");
+ fOutput->Add(fHistTrackEta[i]);
+ }
+
+ fHistTrackPhi[0]->SetLineColor(kRed);
+ fHistTrackEta[0]->SetLineColor(kRed);
+ fHistTrackPhi[1]->SetLineColor(kBlue);
+ fHistTrackEta[1]->SetLineColor(kBlue);
+ fHistTrackPhi[2]->SetLineColor(kGreen);
+ fHistTrackEta[2]->SetLineColor(kGreen);
+ fHistTrackPhi[3]->SetLineColor(kOrange);
+ fHistTrackEta[3]->SetLineColor(kOrange);
+ fHistTrackPhi[4]->SetLineColor(kBlack);
+ fHistTrackEta[4]->SetLineColor(kBlack);
+
+ PostData(1, fOutput); // Post data for ALL output slots >0 here, to get at least an empty histogram
+}
+
+void AliEmcalQATask::RetrieveEventObjects()
+{
+ fCaloClusters = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fCaloName));
+ if (!fCaloClusters) {
+ AliWarning(Form("Could not retrieve clusters!"));
+ }
+
+ fTracks = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fTracksName));
+ if (!fTracks) {
+ AliWarning(Form("Could not retrieve tracks!"));
+ }
+
+ fJets = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fJetsName));
+ if (!fJets) {
+ AliWarning(Form("Could not retrieve jets!"));
+ }
+
+ if (strcmp(fTrgClusName,"")) {
+ fTrgClusters = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fTrgClusName));
+ if (!fTrgClusters) {
+ AliWarning(Form("Could not retrieve trigger clusters!"));
+ }
+ }
+
+ fCent = InputEvent()->GetCentrality();
+}
+
+AliVTrack* AliEmcalQATask::GetTrack(const Int_t i) const
+{
+ if (fTracks)
+ return dynamic_cast<AliVTrack*>(fTracks->At(i));
+ else
+ return 0;
+}
+
+Int_t AliEmcalQATask::GetNumberOfTracks() const
+{
+ if (fTracks)
+ return fTracks->GetEntriesFast();
+ else
+ return 0;
+}
+
+AliVCluster* AliEmcalQATask::GetCaloCluster(const Int_t i) const
+{
+ if (fCaloClusters)
+ return dynamic_cast<AliVCluster*>(fCaloClusters->At(i));
+ else
+ return 0;
+}
+
+Int_t AliEmcalQATask::GetNumberOfCaloClusters() const
+{
+ if (fCaloClusters)
+ return fCaloClusters->GetEntriesFast();
+ else
+ return 0;
+}
+
+AliEmcalJet* AliEmcalQATask::GetJet(const Int_t i) const
+{
+ if (fJets)
+ return dynamic_cast<AliEmcalJet*>(fJets->At(i));
+ else
+ return 0;
+}
+
+Int_t AliEmcalQATask::GetNumberOfJets() const
+{
+ if (fJets)
+ return fJets->GetEntriesFast();
+ else
+ return 0;
+}
+
+AliVCluster* AliEmcalQATask::GetTrgCluster(const Int_t i) const
+{
+ if (fTrgClusters)
+ return dynamic_cast<AliVCluster*>(fTrgClusters->At(i));
+ else
+ return 0;
+}
+
+Int_t AliEmcalQATask::GetNumberOfTrgClusters() const
+{
+ if (fTrgClusters)
+ return fTrgClusters->GetEntriesFast();
+ else
+ return 0;
+}
+
+void AliEmcalQATask::FillHistograms()
+{
+
+ fHistCentrality->Fill(fCent->GetCentralityPercentile("V0M"));
+ fHistTracksCent->Fill(fCent->GetCentralityPercentile("V0M"), GetNumberOfTracks());
+ fHistClusCent->Fill(fCent->GetCentralityPercentile("V0M"), GetNumberOfCaloClusters());
+
+ // Cluster loop
+ Int_t nclusters = GetNumberOfCaloClusters();
+ //cout << nclusters << " clusters" << endl;
+ for (Int_t iClusters = 0; iClusters < nclusters; iClusters++) {
+ AliVCluster* cluster = GetCaloCluster(iClusters);
+ if (!cluster) {
+ printf("ERROR: Could not receive cluster %d\n", iClusters);
+ continue;
+ }
+
+ if (!(cluster->IsEMCAL())) continue;
+
+ fHistClustersEnergy->Fill(cluster->E());
+
+ Float_t pos[3];
+ cluster->GetPosition(pos);
+ TVector3 clusVec(pos);
+ fHistClusPhiEta->Fill(clusVec.Eta(), clusVec.Phi());
+ } //cluster loop
+
+
+ // Track loop
+ Int_t ntracks = GetNumberOfTracks();
+ //cout << ntracks << " tracks" << endl;
+ for(Int_t i = 0; i < ntracks; i++) {
+ //cout << "track n. " << i << endl;
+ AliVTrack* track = GetTrack(i); // pointer to reconstructed to track
+ if(!track) {
+ AliError(Form("ERROR: Could not retrieve esdtrack %d",i));
+ continue;
+ }
+
+ if (!AcceptTrack(track)) continue;
+
+ fHistTracksPt->Fill(track->Pt());
+
+ Int_t clId = track->GetEMCALcluster();
+ if (clId > -1) {
+ 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<AliESDtrack*>(track);
+ eta = esdtrack->Eta();
+ phi = esdtrack->Phi();
+ label = esdtrack->GetLabel();
+ }
+ else if (track->InheritsFrom("AliAODTrack")) {
+ AliAODTrack *aodtrack = dynamic_cast<AliAODTrack*>(track);
+ eta = aodtrack->Eta();
+ phi = aodtrack->Phi();
+ label = aodtrack->GetLabel();
+ }
+ else if (track->InheritsFrom("AliPicoTrack")) {
+ AliPicoTrack *picotrack = dynamic_cast<AliPicoTrack*>(track);
+ eta = picotrack->Eta();
+ phi = picotrack->Phi();
+ label = picotrack->GetLabel();
+ }
+ else {
+ AliWarning("Track type not recognized! Will not plot phi\eta distributions!");
+ continue;
+ }
+
+ fHistTrPhiEta->Fill(eta, phi);
+
+ fHistTrackEta[4]->Fill(eta);
+ fHistTrackPhi[4]->Fill(phi);
+
+ if (label >= 0 && label < 4) {
+ fHistTrackEta[label]->Fill(eta);
+ fHistTrackPhi[label]->Fill(phi);
+ }
+ else {
+ AliWarning(Form("Track label %d not recognized!",label));
+ }
+
+ }
+
+ // Jet loop
+ Int_t njets = GetNumberOfJets();
+ //cout << njets << " jets" << endl;
+ for (Int_t ij = 0; ij < njets; ij++) {
+ AliEmcalJet* jet = GetJet(ij);
+ if (!jet) {
+ printf("ERROR: Could not receive jet %d\n", ij);
+ continue;
+ }
+
+ if (jet->E() <= 0)
+ continue;
+
+ fHistJetPhiEta->Fill(jet->Eta(), jet->Phi());
+ fHistJetsEnergy->Fill(jet->E());
+ } //jet loop
+
+ Int_t ntrgclusters = GetNumberOfTrgClusters();
+ Float_t maxe = 0;
+ //cout << ntrgclusters << " clusters" << endl;
+ for (Int_t iClusters = 0; iClusters < ntrgclusters; iClusters++) {
+ AliVCluster* cluster = GetTrgCluster(iClusters);
+ if (!cluster) {
+ printf("ERROR: Could not receive cluster %d\n", iClusters);
+ continue;
+ }
+
+ if (!(cluster->IsEMCAL())) continue;
+
+ if (cluster->E() > maxe)
+ maxe = cluster->E();
+
+ } //cluster loop
+ fHistMaxTrgCluster->Fill(maxe);
+
+}
+
+//________________________________________________________________________
+Bool_t AliEmcalQATask::AcceptTrack(AliVTrack* /*track*/)
+{
+ return kTRUE;
+}
+
+//________________________________________________________________________
+void AliEmcalQATask::UserExec(Option_t *)
+{
+ // Main loop, called for each event.
+ // Add jets to event if not yet there
+
+ RetrieveEventObjects();
+
+ FillHistograms();
+
+ // information for this iteration of the UserExec in the container
+ PostData(1, fOutput);
+}
+
+//________________________________________________________________________
+void AliEmcalQATask::Terminate(Option_t *)
+{
+ // Called once at the end of the analysis.
+}
--- /dev/null
+#ifndef ALIEMCALQATASK_H
+#define ALIEMCALQATASK_H
+
+// $Id$
+
+class TClonesArray;
+class TString;
+class AliVTrack;
+class AliVCluster;
+class TList;
+class TH1F;
+class TH2F;
+class AliEmcalJet;
+
+#include "AliAnalysisTaskSE.h"
+
+class AliEmcalQATask : public AliAnalysisTaskSE {
+ public:
+ AliEmcalQATask();
+ AliEmcalQATask(const char *name);
+ virtual ~AliEmcalQATask();
+
+ void UserCreateOutputObjects();
+ void UserExec(Option_t *option);
+ void Terminate(Option_t *option);
+
+ void SetClusName(const char *n) { fCaloName = n ; }
+ void SetJetsName(const char *n) { fJetsName = n ; }
+ void SetTracksName(const char *n) { fTracksName = n ; }
+ void SetTrgClusName(const char *n) { fTrgClusName = n ; }
+
+ protected:
+
+ AliVTrack *GetTrack(const Int_t i) const;
+ Int_t GetNumberOfTracks() const;
+ AliVCluster *GetCaloCluster(const Int_t i) const;
+ Int_t GetNumberOfCaloClusters() const;
+ AliEmcalJet *GetJet(const Int_t i) const;
+ Int_t GetNumberOfJets() const;
+ AliVCluster *GetTrgCluster(const Int_t i) const;
+ Int_t GetNumberOfTrgClusters() const;
+ void FillHistograms() ;
+ void RetrieveEventObjects() ;
+ Bool_t AcceptTrack(AliVTrack* /*track*/) ;
+
+ TList *fOutput; // Output list
+
+ TString fTracksName; // name of track collection
+ TString fCaloName; // name of calo cluster collection
+ TString fJetsName; // name of jet collection
+ TString fTrgClusName; // name of trg clus name
+ TClonesArray *fTracks; //!Tracks
+ TClonesArray *fCaloClusters; //!Clusters
+ TClonesArray *fJets; //!Jets
+ TClonesArray *fTrgClusters; //!Trg Clusters
+ AliCentrality *fCent; // Event centrality
+ TH1F *fHistCentrality; // Event centrality distribution
+ TH2F *fHistTracksCent; // Number of tracks vs. centrality
+ TH2F *fHistClusCent; // Number of clusters vs. centrality
+ TH1F *fHistTracksPt; // Pt spectrum of tracks
+ TH1F *fHistClustersEnergy; // Energy spectrum of clusters
+ TH2F *fHistEPcorrelation; // Energy-momentum correlation
+ TH1F *fHistJetsEnergy; // Energy spectrum of jets
+ TH2F *fHistTrPhiEta; // Phi-Eta distribution of tracks
+ TH2F *fHistClusPhiEta; // Phi-Eta distribution of clusters
+ TH2F *fHistJetPhiEta; // Phi-Eta distribution of jets
+ TH1F *fHistMaxTrgCluster; // Energy distribution of max trigger clusters
+ TH1F *fHistTrackPhi[5]; // Phi distribution of hybrid tracks
+ TH1F *fHistTrackEta[5]; // Eta distribution of hybrid tracks
+
+ Int_t Ptbins; // No. of pt bins
+ Float_t Ptlow; // Min pt
+ Float_t Ptup; // Max pt
+ Int_t Ebins; // No. of e bins
+ Float_t Elow; // Min e
+ Float_t Eup; // Max e
+
+ private:
+ AliEmcalQATask(const AliEmcalQATask&); // not implemented
+ AliEmcalQATask &operator=(const AliEmcalQATask&); // not implemented
+
+ ClassDef(AliEmcalQATask, 1) // Quality task for Emcal analysis
+};
+#endif
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff