[u/mrichter/AliRoot.git] / PWGGA / EMCALJetTasks / UserTasks / AliAnalysisTaskSAQA.cxx

// $Id$
//
// General QA task.
//
// Author: S.Aiola

#include <TChain.h>
#include <TClonesArray.h>
#include <TH1F.h>
#include <TH2F.h>
#include <TH3F.h>
#include <TList.h>
#include <TLorentzVector.h>

#include "AliAnalysisManager.h"
#include "AliCentrality.h"
#include "AliVCluster.h"
#include "AliVParticle.h"
#include "AliVTrack.h"
#include "AliEmcalJet.h"
#include "AliVEventHandler.h"
#include "AliLog.h"

#include "AliAnalysisTaskSAQA.h"

ClassImp(AliAnalysisTaskSAQA)

//________________________________________________________________________
AliAnalysisTaskSAQA::AliAnalysisTaskSAQA() : 
  AliAnalysisTaskEmcalJet("AliAnalysisTaskSAQA", kTRUE),
  fCellEnergyCut(0.1),
  fDoTrigger(kFALSE),
  fTrgClusName("ClustersL1GAMMAFEE"),
  fTrgClusters(0),
  fHistCentrality(0),
  fHistTracksCent(0),
  fHistClusCent(0),
  fHistMaxL1FastORCent(0),
  fHistMaxL1ClusCent(0),
  fHistMaxL1ThrCent(0),
  fHistTracksPt(0),
  fHistTrPhiEta(0),
  fHistTrEmcPhiEta(0),
  fHistClustersEnergy(0),
  fHistClusPhiEta(0),
  fHistCellsEnergy(0),
  fHistChVSneCells(0),
  fHistChVSneClus(0),
  fHistChVSneCorrCells(0)
{
  // Default constructor.

  for (Int_t i = 0; i < 5; i++) {
    fHistTrackPhi[i] = 0;
    fHistTrackEta[i] = 0;
  }

  for (Int_t i = 0; i < 4; i++) {
    fHistJetsPhiEtaPt[i] = 0;
    fHistJetsPtNonBias[i] = 0;
    fHistJetsPtTrack[i] = 0;
    fHistJetsPtClus[i] = 0;
    fHistJetsPt[i] = 0;
    fHistJetsPtArea[i] = 0;
    fHistJetsPtAreaNonBias[i] = 0;
  }
}

//________________________________________________________________________
AliAnalysisTaskSAQA::AliAnalysisTaskSAQA(const char *name) : 
  AliAnalysisTaskEmcalJet(name, kTRUE),
  fCellEnergyCut(0.1),
  fDoTrigger(kFALSE),
  fTrgClusName("ClustersL1GAMMAFEE"),
  fTrgClusters(0),
  fHistCentrality(0),
  fHistTracksCent(0),
  fHistClusCent(0),
  fHistMaxL1FastORCent(0),
  fHistMaxL1ClusCent(0),
  fHistMaxL1ThrCent(0),
  fHistTracksPt(0),
  fHistTrPhiEta(0),
  fHistTrEmcPhiEta(0),
  fHistClustersEnergy(0),
  fHistClusPhiEta(0),
  fHistCellsEnergy(0),
  fHistChVSneCells(0),
  fHistChVSneClus(0),
  fHistChVSneCorrCells(0)
{
  // Standard constructor.

  for (Int_t i = 0; i < 5; i++) {
    fHistTrackPhi[i] = 0;
    fHistTrackEta[i] = 0;
  }

  for (Int_t i = 0; i < 4; i++) {
    fHistJetsPhiEtaPt[i] = 0;
    fHistJetsPtNonBias[i] = 0;
    fHistJetsPtTrack[i] = 0;
    fHistJetsPtClus[i] = 0;
    fHistJetsPt[i] = 0;
    fHistJetsPtArea[i] = 0;
    fHistJetsPtAreaNonBias[i] = 0;
  }
}

//________________________________________________________________________
AliAnalysisTaskSAQA::~AliAnalysisTaskSAQA()
{
  // Destructor
}

//________________________________________________________________________
void AliAnalysisTaskSAQA::UserCreateOutputObjects()
{
  // Create histograms

  OpenFile(1);
  fOutput = new TList();
  fOutput->SetOwner();

  fHistCentrality = new TH1F("fHistCentrality","Event centrality distribution", fNbins, 0, 100);
  fHistCentrality->GetXaxis()->SetTitle("Centrality (%)");
  fHistCentrality->GetYaxis()->SetTitle("counts");
  fOutput->Add(fHistCentrality);

  fHistTracksCent = new TH2F("fHistTracksCent","Tracks vs. centrality", fNbins, 0, 100, fNbins, 0, 4000);
  fHistTracksCent->GetXaxis()->SetTitle("Centrality (%)");
  fHistTracksCent->GetYaxis()->SetTitle("No. of tracks");
  fOutput->Add(fHistTracksCent);

  if (fAnaType == kEMCAL) {
    fHistClusCent = new TH2F("fHistClusCent","Clusters vs. centrality", fNbins, 0, 100, fNbins, 0, 2000);
    fHistClusCent->GetXaxis()->SetTitle("Centrality (%)");
    fHistClusCent->GetYaxis()->SetTitle("No. of clusters");
    fOutput->Add(fHistClusCent);
    
    if (fDoTrigger) {
      fHistMaxL1FastORCent = new TH2F("fHistMaxL1FastORCent","fHistMaxL1ClusCent", 100, 0, 100, 250, 0, 250);
      fHistMaxL1FastORCent->GetXaxis()->SetTitle("Centrality [%]");
      fHistMaxL1FastORCent->GetYaxis()->SetTitle("Maximum L1 FastOR");
      fOutput->Add(fHistMaxL1FastORCent);
      
      fHistMaxL1ClusCent = new TH2F("fHistMaxL1ClusCent","fHistMaxL1ClusCent", 100, 0, 100, 250, 0, 250);
      fHistMaxL1ClusCent->GetXaxis()->SetTitle("Centrality [%]");
      fHistMaxL1ClusCent->GetYaxis()->SetTitle("Maximum L1 trigger cluster");
      fOutput->Add(fHistMaxL1ClusCent);
      
      fHistMaxL1ThrCent = new TH2F("fHistMaxL1ThrCent","fHistMaxL1ThrCent", 100, 0, 100, 250, 0, 250);
      fHistMaxL1ThrCent->GetXaxis()->SetTitle("Centrality [%]");
      fHistMaxL1ThrCent->GetYaxis()->SetTitle("Maximum L1 threshold");
      fOutput->Add(fHistMaxL1ThrCent);
    }
  }

  fHistTracksPt = new TH1F("fHistTracksPt","p_{T} spectrum of reconstructed tracks", fNbins, fMinBinPt, fMaxBinPt);
  fHistTracksPt->GetXaxis()->SetTitle("p_{T} [GeV/c]");
  fHistTracksPt->GetYaxis()->SetTitle("counts");
  fOutput->Add(fHistTracksPt);
       
  fHistTrPhiEta = new TH2F("fHistTrPhiEta","Phi-Eta distribution of tracks", 80, -2, 2, 128, 0, 6.4);
  fHistTrPhiEta->GetXaxis()->SetTitle("#eta");
  fHistTrPhiEta->GetYaxis()->SetTitle("#phi");
  fOutput->Add(fHistTrPhiEta);

  fHistTrEmcPhiEta = new TH2F("fHistTrEmcPhiEta","Phi-Eta emcal distribution of tracks", 80, -2, 2, 128, 0, 6.4);
  fHistTrEmcPhiEta->GetXaxis()->SetTitle("#eta");
  fHistTrEmcPhiEta->GetYaxis()->SetTitle("#phi");
  fOutput->Add(fHistTrEmcPhiEta);

  if (fAnaType == kEMCAL) {
    fHistClustersEnergy = new TH1F("fHistClustersEnergy","Energy spectrum of clusters", fNbins, fMinBinPt, fMaxBinPt);
    fHistClustersEnergy->GetXaxis()->SetTitle("E [GeV]");
    fHistClustersEnergy->GetYaxis()->SetTitle("counts");
    fOutput->Add(fHistClustersEnergy);

    fHistClusPhiEta = new TH2F("fHistClusPhiEta","Phi-Eta distribution of clusters", 80, -2, 2, 128, 0, 6.4);
    fHistClusPhiEta->GetXaxis()->SetTitle("#eta");
    fHistClusPhiEta->GetYaxis()->SetTitle("#phi");
    fOutput->Add(fHistClusPhiEta);
  }

  if (fAnaType == kEMCAL) {
   
    fHistCellsEnergy = new TH1F("fHistCellsEnergy","Energy spectrum of cells", fNbins, fMinBinPt, fMaxBinPt);
    fHistCellsEnergy->GetXaxis()->SetTitle("E [GeV]");
    fHistCellsEnergy->GetYaxis()->SetTitle("counts");
    fOutput->Add(fHistCellsEnergy);
    
    fHistChVSneCells = new TH2F("fHistChVSneCells","Charged energy vs. neutral (cells) energy", 
				fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5, fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5);
    fHistChVSneCells->GetXaxis()->SetTitle("E [GeV]");
    fHistChVSneCells->GetYaxis()->SetTitle("P [GeV/c]");
    fOutput->Add(fHistChVSneCells);
    
    fHistChVSneClus = new TH2F("fHistChVSneClus","Charged energy vs. neutral (clusters) energy", 
			       fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5, fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5);
    fHistChVSneClus->GetXaxis()->SetTitle("E [GeV]");
    fHistChVSneClus->GetYaxis()->SetTitle("P [GeV/c]");
    fOutput->Add(fHistChVSneClus);
    
    fHistChVSneCorrCells = new TH2F("fHistChVSneCorrCells","Charged energy vs. neutral (corrected cells) energy", 
				    fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5, fNbins * 2.5, fMinBinPt , fMaxBinPt * 2.5);
    fHistChVSneCorrCells->GetXaxis()->SetTitle("E [GeV]");
    fHistChVSneCorrCells->GetYaxis()->SetTitle("P [GeV/c]");
    fOutput->Add(fHistChVSneCorrCells);
  }
 
  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);

  if (!fJetsName.IsNull()) {

    TString histname;

    for (Int_t i = 0; i < 4; i++) {
      histname = "fHistJetsPhiEtaPt_";
      histname += i;
      fHistJetsPhiEtaPt[i] = new TH3F(histname.Data(), histname.Data(), 80, -2, 2, 128, 0, 6.4, fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5);
      fHistJetsPhiEtaPt[i]->GetXaxis()->SetTitle("#eta");
      fHistJetsPhiEtaPt[i]->GetYaxis()->SetTitle("#phi");
      fHistJetsPhiEtaPt[i]->GetZaxis()->SetTitle("p_{T} [GeV/c]");
      fOutput->Add(fHistJetsPhiEtaPt[i]);

      histname = "fHistJetsPtNonBias_";
      histname += i;
      fHistJetsPtNonBias[i] = new TH1F(histname.Data(), histname.Data(), fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5);
      fHistJetsPtNonBias[i]->GetXaxis()->SetTitle("p_{T} [GeV/c]");
      fHistJetsPtNonBias[i]->GetYaxis()->SetTitle("counts");
      fOutput->Add(fHistJetsPtNonBias[i]);

      histname = "fHistJetsPtTrack_";
      histname += i;
      fHistJetsPtTrack[i] = new TH1F(histname.Data(), histname.Data(), fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5);
      fHistJetsPtTrack[i]->GetXaxis()->SetTitle("p_{T} [GeV/c]");
      fHistJetsPtTrack[i]->GetYaxis()->SetTitle("counts");
      fOutput->Add(fHistJetsPtTrack[i]);

      if (fAnaType == kEMCAL) {
	histname = "fHistJetsPtClus_";
	histname += i;
	fHistJetsPtClus[i] = new TH1F(histname.Data(), histname.Data(), fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5);
	fHistJetsPtClus[i]->GetXaxis()->SetTitle("p_{T} [GeV/c]");
	fHistJetsPtClus[i]->GetYaxis()->SetTitle("counts");
	fOutput->Add(fHistJetsPtClus[i]);
      }

      histname = "fHistJetsPt_";
      histname += i;
      fHistJetsPt[i] = new TH1F(histname.Data(), histname.Data(), fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5);
      fHistJetsPt[i]->GetXaxis()->SetTitle("p_{T} [GeV/c]");
      fHistJetsPt[i]->GetYaxis()->SetTitle("counts");
      fOutput->Add(fHistJetsPt[i]);

      histname = "fHistJetsPtAreaNonBias_";
      histname += i;
      fHistJetsPtAreaNonBias[i] = new TH2F(histname.Data(), histname.Data(), fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5, 20, 0, fJetRadius * fJetRadius * TMath::Pi() * 1.5);
      fHistJetsPtAreaNonBias[i]->GetXaxis()->SetTitle("p_{T} [GeV/c]");
      fHistJetsPtAreaNonBias[i]->GetYaxis()->SetTitle("area");
      fOutput->Add(fHistJetsPtAreaNonBias[i]);

      histname = "fHistJetsPtArea_";
      histname += i;
      fHistJetsPtArea[i] = new TH2F(histname.Data(), histname.Data(), fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5, 20, 0, fJetRadius * fJetRadius * TMath::Pi() * 1.5);
      fHistJetsPtArea[i]->GetXaxis()->SetTitle("p_{T} [GeV/c]");
      fHistJetsPtArea[i]->GetYaxis()->SetTitle("area");
      fOutput->Add(fHistJetsPtArea[i]);
    }
  }

  PostData(1, fOutput); // Post data for ALL output slots >0 here, to get at least an empty histogram
}

//________________________________________________________________________
Bool_t AliAnalysisTaskSAQA::RetrieveEventObjects()
{
  // Retrieve event objects.

  if (!AliAnalysisTaskEmcalJet::RetrieveEventObjects())
    return kFALSE;

  if (!fTrgClusName.IsNull() && fDoTrigger && !fTrgClusters) {
    fTrgClusters =  dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fTrgClusName));
    if (!fTrgClusters) {
      AliError(Form("%s: Could not retrieve trigger clusters %s!", GetName(), fTrgClusName.Data())); 
      return kFALSE;
    }
    else {
      TClass *cl = fTrgClusters->GetClass();
      if (!cl->GetBaseClass("AliVCluster") && !cl->GetBaseClass("AliEmcalParticle")) {
	AliError(Form("%s: Collection %s does not contain AliVCluster nor AliEmcalParticle objects!", GetName(), fTrgClusName.Data())); 
	fTrgClusters = 0;
	return kFALSE;
      }
    }
  }

  return kTRUE;
}

//________________________________________________________________________
Bool_t AliAnalysisTaskSAQA::FillHistograms()
{
  // Fill histograms.

  fHistCentrality->Fill(fCent);
  if (fTracks)
    fHistTracksCent->Fill(fCent, fTracks->GetEntriesFast());
  if (fCaloClusters)
    fHistClusCent->Fill(fCent, fCaloClusters->GetEntriesFast());

  Float_t trackSum = DoTrackLoop();

  DoJetLoop();

  if (fAnaType == kEMCAL) {
    Float_t clusSum = DoClusterLoop();

    Float_t cellSum = 0, cellCutSum = 0;
    
    DoCellLoop(cellSum, cellCutSum);
    
    fHistChVSneCells->Fill(cellSum, trackSum);
    fHistChVSneClus->Fill(clusSum, trackSum);
    fHistChVSneCorrCells->Fill(cellCutSum, trackSum);

    if (fDoTrigger) {
      Float_t maxTrgClus = DoTriggerClusLoop();
      fHistMaxL1ClusCent->Fill(fCent, maxTrgClus);
    
      Int_t maxL1amp = -1;
      Int_t maxL1thr = -1;
    
      DoTriggerPrimitives(maxL1amp, maxL1thr);
      
      if (maxL1amp > -1) 
	fHistMaxL1FastORCent->Fill(fCent, maxL1amp);
      
      if (maxL1thr > -1) 
	fHistMaxL1ThrCent->Fill(fCent, maxL1thr);
    }
  }

  return kTRUE;
}

//________________________________________________________________________
void AliAnalysisTaskSAQA::DoCellLoop(Float_t &sum, Float_t &sum_cut)
{
  // Do cell loop.

  AliVCaloCells *cells = InputEvent()->GetEMCALCells();

  if (!cells)
    return;

  const Int_t ncells = cells->GetNumberOfCells();

  for (Int_t pos = 0; pos < ncells; pos++) {
    Float_t amp = cells->GetAmplitude(pos);
    fHistCellsEnergy->Fill(amp);
    sum += amp;
    if (amp < fCellEnergyCut)
      continue;
    sum_cut += amp;
  } 
}

//________________________________________________________________________
Float_t AliAnalysisTaskSAQA::DoClusterLoop()
{
  // Do cluster loop.

  if (!fCaloClusters)
    return 0;

  Float_t sum = 0;

  // Cluster loop
  Int_t nclusters =  fCaloClusters->GetEntriesFast();

  for (Int_t iClusters = 0; iClusters < nclusters; iClusters++) {
    AliVCluster* cluster = static_cast<AliVCluster*>(fCaloClusters->At(iClusters));
    if (!cluster) {
      AliError(Form("Could not receive cluster %d", iClusters));
      continue;
    }  

    if (!AcceptCluster(cluster, kTRUE))
      continue;

    fHistClustersEnergy->Fill(cluster->E());

    sum += cluster->E();

    Float_t pos[3];
    cluster->GetPosition(pos);
    TVector3 clusVec(pos);
    fHistClusPhiEta->Fill(clusVec.Eta(), clusVec.Phi());

  }

  return sum;
}

//________________________________________________________________________
Float_t AliAnalysisTaskSAQA::DoTrackLoop()
{
  // Do track loop.

  if (!fTracks)
    return 0;

  Float_t sum = 0;

  Int_t ntracks = fTracks->GetEntriesFast();
  Int_t nclusters = 0;
  if (fCaloClusters)
    nclusters = fCaloClusters->GetEntriesFast();

  for (Int_t i = 0; i < ntracks; i++) {

    AliVParticle* track = static_cast<AliVParticle*>(fTracks->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, kTRUE)) 
      continue;
    
    fHistTracksPt->Fill(track->Pt());

    sum += track->P();

    Int_t label = track->GetLabel();
      
    fHistTrPhiEta->Fill(track->Eta(), track->Phi());
    
    fHistTrackEta[4]->Fill(track->Eta());
    fHistTrackPhi[4]->Fill(track->Phi());

    if (label >= 0 && label < 4) {
      fHistTrackEta[label]->Fill(track->Eta());
      fHistTrackPhi[label]->Fill(track->Phi());
    }

    if (!vtrack)
      continue;

    fHistTrEmcPhiEta->Fill(vtrack->GetTrackEtaOnEMCal(), vtrack->GetTrackPhiOnEMCal());
  }
  
  return sum;
}

//________________________________________________________________________
void AliAnalysisTaskSAQA::DoJetLoop()
{
  // Do jet loop.

  if (!fJets)
    return;

  Int_t njets = fJets->GetEntriesFast();

  for (Int_t ij = 0; ij < njets; ij++) {

    AliEmcalJet* jet = static_cast<AliEmcalJet*>(fJets->At(ij));

    if (!jet) {
      AliError(Form("Could not receive jet %d", ij));
      continue;
    }  

    if (!AcceptJet(jet, kFALSE))
      continue;

    fHistJetsPtNonBias[fCentBin]->Fill(jet->Pt());
    fHistJetsPtAreaNonBias[fCentBin]->Fill(jet->Pt(), jet->Area());

    if (jet->MaxTrackPt() > fPtBiasJetTrack)
      fHistJetsPtTrack[fCentBin]->Fill(jet->Pt());
    
    if (fAnaType == kEMCAL && jet->MaxClusterPt() > fPtBiasJetClus)
      fHistJetsPtClus[fCentBin]->Fill(jet->Pt());
    
    if (!AcceptBiasJet(jet))
      continue;

    fHistJetsPt[fCentBin]->Fill(jet->Pt());
    fHistJetsPtArea[fCentBin]->Fill(jet->Pt(), jet->Area());

    fHistJetsPhiEtaPt[fCentBin]->Fill(jet->Eta(), jet->Phi(), jet->Pt());
  }
}

//________________________________________________________________________
Float_t AliAnalysisTaskSAQA::DoTriggerClusLoop()
{
  // Do trigger cluster loop.

  if (!fTrgClusters)
    return 0;

  Int_t ntrgclusters = fTrgClusters->GetEntriesFast();
  Float_t maxTrgClus = 0;

  for (Int_t iClusters = 0; iClusters < ntrgclusters; iClusters++) {
    AliVCluster* cluster = static_cast<AliVCluster*>(fTrgClusters->At(iClusters));
    if (!cluster) {
      AliError(Form("Could not receive cluster %d", iClusters));
      continue;
    }  
    
    if (!(cluster->IsEMCAL())) continue;

    if (cluster->E() > maxTrgClus)
      maxTrgClus = cluster->E();

  }
  return maxTrgClus;
}

//________________________________________________________________________
void AliAnalysisTaskSAQA::DoTriggerPrimitives(Int_t &maxL1amp, Int_t &maxL1thr)
{
  // Do trigger primitives loop.

  AliVCaloTrigger *triggers = InputEvent()->GetCaloTrigger("EMCAL");

  if (!triggers || triggers->GetEntries() == 0)
    return;
    
  triggers->Reset();
  Int_t L1amp = 0;
  Int_t L1thr = 0;
  maxL1amp = -1;
  maxL1thr = -1;

  while (triggers->Next()) {
    triggers->GetL1TimeSum(L1amp);
    if (maxL1amp < L1amp) 
      maxL1amp = L1amp;

    triggers->GetL1Threshold(L1thr);
    if (maxL1thr < L1thr) 
      maxL1thr = L1thr;
  }
}

//________________________________________________________________________
void AliAnalysisTaskSAQA::Terminate(Option_t *) 
{
  // Called once at the end of the analysis.
}
Commit	Line	Data
6e8d91c9	1	// $Id$
c3ba2d3d	2	//
297edd60	3	// General QA task.
c3ba2d3d	4	//
297edd60	5	// Author: S.Aiola
c3ba2d3d	6
	7	#include <TChain.h>
	8	#include <TClonesArray.h>
	9	#include <TH1F.h>
	10	#include <TH2F.h>
3000c095	11	#include <TH3F.h>
c3ba2d3d	12	#include <TList.h>
	13	#include <TLorentzVector.h>
	14
	15	#include "AliAnalysisManager.h"
	16	#include "AliCentrality.h"
	17	#include "AliVCluster.h"
	18	#include "AliVParticle.h"
	19	#include "AliVTrack.h"
	20	#include "AliEmcalJet.h"
	21	#include "AliVEventHandler.h"
	22	#include "AliLog.h"
	23
	24	#include "AliAnalysisTaskSAQA.h"
	25
	26	ClassImp(AliAnalysisTaskSAQA)
	27
	28	//________________________________________________________________________
	29	AliAnalysisTaskSAQA::AliAnalysisTaskSAQA() :
99cfd012	30	AliAnalysisTaskEmcalJet("AliAnalysisTaskSAQA", kTRUE),
c3ba2d3d	31	fCellEnergyCut(0.1),
1f6fff78	32	fDoTrigger(kFALSE),
c3ba2d3d	33	fTrgClusName("ClustersL1GAMMAFEE"),
	34	fTrgClusters(0),
	35	fHistCentrality(0),
	36	fHistTracksCent(0),
	37	fHistClusCent(0),
	38	fHistMaxL1FastORCent(0),
	39	fHistMaxL1ClusCent(0),
	40	fHistMaxL1ThrCent(0),
	41	fHistTracksPt(0),
	42	fHistTrPhiEta(0),
6fd5039f	43	fHistTrEmcPhiEta(0),
c3ba2d3d	44	fHistClustersEnergy(0),
c3ba2d3d	45	fHistClusPhiEta(0),
c3ba2d3d	46	fHistCellsEnergy(0),
	47	fHistChVSneCells(0),
	48	fHistChVSneClus(0),
	49	fHistChVSneCorrCells(0)
	50	{
	51	// Default constructor.
	52
	53	for (Int_t i = 0; i < 5; i++) {
	54	fHistTrackPhi[i] = 0;
	55	fHistTrackEta[i] = 0;
	56	}
6fd5039f	57
6fd5039f	58	for (Int_t i = 0; i < 4; i++) {
3000c095	59	fHistJetsPhiEtaPt[i] = 0;
99cfd012	60	fHistJetsPtNonBias[i] = 0;
6fd5039f	61	fHistJetsPtTrack[i] = 0;
	62	fHistJetsPtClus[i] = 0;
	63	fHistJetsPt[i] = 0;
98750b70	64	fHistJetsPtArea[i] = 0;
99cfd012	65	fHistJetsPtAreaNonBias[i] = 0;
6fd5039f	66	}
c3ba2d3d	67	}
	68
	69	//________________________________________________________________________
	70	AliAnalysisTaskSAQA::AliAnalysisTaskSAQA(const char *name) :
99cfd012	71	AliAnalysisTaskEmcalJet(name, kTRUE),
c3ba2d3d	72	fCellEnergyCut(0.1),
1f6fff78	73	fDoTrigger(kFALSE),
c3ba2d3d	74	fTrgClusName("ClustersL1GAMMAFEE"),
	75	fTrgClusters(0),
	76	fHistCentrality(0),
	77	fHistTracksCent(0),
	78	fHistClusCent(0),
	79	fHistMaxL1FastORCent(0),
	80	fHistMaxL1ClusCent(0),
	81	fHistMaxL1ThrCent(0),
	82	fHistTracksPt(0),
	83	fHistTrPhiEta(0),
6fd5039f	84	fHistTrEmcPhiEta(0),
c3ba2d3d	85	fHistClustersEnergy(0),
c3ba2d3d	86	fHistClusPhiEta(0),
c3ba2d3d	87	fHistCellsEnergy(0),
	88	fHistChVSneCells(0),
	89	fHistChVSneClus(0),
	90	fHistChVSneCorrCells(0)
	91	{
	92	// Standard constructor.
	93
	94	for (Int_t i = 0; i < 5; i++) {
	95	fHistTrackPhi[i] = 0;
	96	fHistTrackEta[i] = 0;
	97	}
6fd5039f	98
6fd5039f	99	for (Int_t i = 0; i < 4; i++) {
3000c095	100	fHistJetsPhiEtaPt[i] = 0;
99cfd012	101	fHistJetsPtNonBias[i] = 0;
6fd5039f	102	fHistJetsPtTrack[i] = 0;
	103	fHistJetsPtClus[i] = 0;
	104	fHistJetsPt[i] = 0;
98750b70	105	fHistJetsPtArea[i] = 0;
99cfd012	106	fHistJetsPtAreaNonBias[i] = 0;
6fd5039f	107	}
c3ba2d3d	108	}
	109
	110	//________________________________________________________________________
	111	AliAnalysisTaskSAQA::~AliAnalysisTaskSAQA()
	112	{
	113	// Destructor
	114	}
	115
	116	//________________________________________________________________________
	117	void AliAnalysisTaskSAQA::UserCreateOutputObjects()
	118	{
	119	// Create histograms
	120
	121	OpenFile(1);
	122	fOutput = new TList();
6fd5039f	123	fOutput->SetOwner();
c3ba2d3d	124
	125	fHistCentrality = new TH1F("fHistCentrality","Event centrality distribution", fNbins, 0, 100);
	126	fHistCentrality->GetXaxis()->SetTitle("Centrality (%)");
	127	fHistCentrality->GetYaxis()->SetTitle("counts");
	128	fOutput->Add(fHistCentrality);
	129
	130	fHistTracksCent = new TH2F("fHistTracksCent","Tracks vs. centrality", fNbins, 0, 100, fNbins, 0, 4000);
	131	fHistTracksCent->GetXaxis()->SetTitle("Centrality (%)");
	132	fHistTracksCent->GetYaxis()->SetTitle("No. of tracks");
	133	fOutput->Add(fHistTracksCent);
	134
6fd5039f	135	if (fAnaType == kEMCAL) {
	136	fHistClusCent = new TH2F("fHistClusCent","Clusters vs. centrality", fNbins, 0, 100, fNbins, 0, 2000);
	137	fHistClusCent->GetXaxis()->SetTitle("Centrality (%)");
	138	fHistClusCent->GetYaxis()->SetTitle("No. of clusters");
	139	fOutput->Add(fHistClusCent);
	140
1f6fff78	141	if (fDoTrigger) {
	142	fHistMaxL1FastORCent = new TH2F("fHistMaxL1FastORCent","fHistMaxL1ClusCent", 100, 0, 100, 250, 0, 250);
	143	fHistMaxL1FastORCent->GetXaxis()->SetTitle("Centrality [%]");
	144	fHistMaxL1FastORCent->GetYaxis()->SetTitle("Maximum L1 FastOR");
	145	fOutput->Add(fHistMaxL1FastORCent);
	146
	147	fHistMaxL1ClusCent = new TH2F("fHistMaxL1ClusCent","fHistMaxL1ClusCent", 100, 0, 100, 250, 0, 250);
	148	fHistMaxL1ClusCent->GetXaxis()->SetTitle("Centrality [%]");
	149	fHistMaxL1ClusCent->GetYaxis()->SetTitle("Maximum L1 trigger cluster");
	150	fOutput->Add(fHistMaxL1ClusCent);
	151
	152	fHistMaxL1ThrCent = new TH2F("fHistMaxL1ThrCent","fHistMaxL1ThrCent", 100, 0, 100, 250, 0, 250);
	153	fHistMaxL1ThrCent->GetXaxis()->SetTitle("Centrality [%]");
	154	fHistMaxL1ThrCent->GetYaxis()->SetTitle("Maximum L1 threshold");
	155	fOutput->Add(fHistMaxL1ThrCent);
	156	}
6fd5039f	157	}
	158
	159	fHistTracksPt = new TH1F("fHistTracksPt","p_{T} spectrum of reconstructed tracks", fNbins, fMinBinPt, fMaxBinPt);
	160	fHistTracksPt->GetXaxis()->SetTitle("p_{T} [GeV/c]");
c3ba2d3d	161	fHistTracksPt->GetYaxis()->SetTitle("counts");
	162	fOutput->Add(fHistTracksPt);
	163
6fd5039f	164	fHistTrPhiEta = new TH2F("fHistTrPhiEta","Phi-Eta distribution of tracks", 80, -2, 2, 128, 0, 6.4);
c3ba2d3d	165	fHistTrPhiEta->GetXaxis()->SetTitle("#eta");
	166	fHistTrPhiEta->GetYaxis()->SetTitle("#phi");
	167	fOutput->Add(fHistTrPhiEta);
	168
6fd5039f	169	fHistTrEmcPhiEta = new TH2F("fHistTrEmcPhiEta","Phi-Eta emcal distribution of tracks", 80, -2, 2, 128, 0, 6.4);
	170	fHistTrEmcPhiEta->GetXaxis()->SetTitle("#eta");
	171	fHistTrEmcPhiEta->GetYaxis()->SetTitle("#phi");
	172	fOutput->Add(fHistTrEmcPhiEta);
	173
	174	if (fAnaType == kEMCAL) {
	175	fHistClustersEnergy = new TH1F("fHistClustersEnergy","Energy spectrum of clusters", fNbins, fMinBinPt, fMaxBinPt);
	176	fHistClustersEnergy->GetXaxis()->SetTitle("E [GeV]");
	177	fHistClustersEnergy->GetYaxis()->SetTitle("counts");
	178	fOutput->Add(fHistClustersEnergy);
	179
	180	fHistClusPhiEta = new TH2F("fHistClusPhiEta","Phi-Eta distribution of clusters", 80, -2, 2, 128, 0, 6.4);
	181	fHistClusPhiEta->GetXaxis()->SetTitle("#eta");
	182	fHistClusPhiEta->GetYaxis()->SetTitle("#phi");
	183	fOutput->Add(fHistClusPhiEta);
	184	}
c3ba2d3d	185
6fd5039f	186	if (fAnaType == kEMCAL) {
6fd5039f	187
	188	fHistCellsEnergy = new TH1F("fHistCellsEnergy","Energy spectrum of cells", fNbins, fMinBinPt, fMaxBinPt);
	189	fHistCellsEnergy->GetXaxis()->SetTitle("E [GeV]");
	190	fHistCellsEnergy->GetYaxis()->SetTitle("counts");
	191	fOutput->Add(fHistCellsEnergy);
	192
98750b70	193	fHistChVSneCells = new TH2F("fHistChVSneCells","Charged energy vs. neutral (cells) energy",
98750b70	194	fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5, fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5);
6fd5039f	195	fHistChVSneCells->GetXaxis()->SetTitle("E [GeV]");
	196	fHistChVSneCells->GetYaxis()->SetTitle("P [GeV/c]");
	197	fOutput->Add(fHistChVSneCells);
	198
98750b70	199	fHistChVSneClus = new TH2F("fHistChVSneClus","Charged energy vs. neutral (clusters) energy",
98750b70	200	fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5, fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5);
6fd5039f	201	fHistChVSneClus->GetXaxis()->SetTitle("E [GeV]");
	202	fHistChVSneClus->GetYaxis()->SetTitle("P [GeV/c]");
	203	fOutput->Add(fHistChVSneClus);
	204
98750b70	205	fHistChVSneCorrCells = new TH2F("fHistChVSneCorrCells","Charged energy vs. neutral (corrected cells) energy",
98750b70	206	fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5, fNbins * 2.5, fMinBinPt , fMaxBinPt * 2.5);
6fd5039f	207	fHistChVSneCorrCells->GetXaxis()->SetTitle("E [GeV]");
	208	fHistChVSneCorrCells->GetYaxis()->SetTitle("P [GeV/c]");
	209	fOutput->Add(fHistChVSneCorrCells);
c3ba2d3d	210	}
c3ba2d3d	211
	212	for (Int_t i = 0; i < 5; i++) {
	213	TString histnamephi("fHistTrackPhi_");
	214	histnamephi += i;
	215	fHistTrackPhi[i] = new TH1F(histnamephi.Data(),histnamephi.Data(), 128, 0, 6.4);
	216	fHistTrackPhi[i]->GetXaxis()->SetTitle("Phi");
	217	fOutput->Add(fHistTrackPhi[i]);
	218
	219	TString histnameeta("fHistTrackEta_");
	220	histnameeta += i;
	221	fHistTrackEta[i] = new TH1F(histnameeta.Data(),histnameeta.Data(), 100, -2, 2);
	222	fHistTrackEta[i]->GetXaxis()->SetTitle("Eta");
	223	fOutput->Add(fHistTrackEta[i]);
	224	}
	225
	226	fHistTrackPhi[0]->SetLineColor(kRed);
	227	fHistTrackEta[0]->SetLineColor(kRed);
	228	fHistTrackPhi[1]->SetLineColor(kBlue);
	229	fHistTrackEta[1]->SetLineColor(kBlue);
	230	fHistTrackPhi[2]->SetLineColor(kGreen);
	231	fHistTrackEta[2]->SetLineColor(kGreen);
	232	fHistTrackPhi[3]->SetLineColor(kOrange);
	233	fHistTrackEta[3]->SetLineColor(kOrange);
	234	fHistTrackPhi[4]->SetLineColor(kBlack);
	235	fHistTrackEta[4]->SetLineColor(kBlack);
	236
e44e8726	237	if (!fJetsName.IsNull()) {
6fd5039f	238
e44e8726	239	TString histname;
	240
	241	for (Int_t i = 0; i < 4; i++) {
3000c095	242	histname = "fHistJetsPhiEtaPt_";
	243	histname += i;
	244	fHistJetsPhiEtaPt[i] = new TH3F(histname.Data(), histname.Data(), 80, -2, 2, 128, 0, 6.4, fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5);
	245	fHistJetsPhiEtaPt[i]->GetXaxis()->SetTitle("#eta");
	246	fHistJetsPhiEtaPt[i]->GetYaxis()->SetTitle("#phi");
	247	fHistJetsPhiEtaPt[i]->GetZaxis()->SetTitle("p_{T} [GeV/c]");
	248	fOutput->Add(fHistJetsPhiEtaPt[i]);
	249
e44e8726	250	histname = "fHistJetsPtNonBias_";
98750b70	251	histname += i;
e44e8726	252	fHistJetsPtNonBias[i] = new TH1F(histname.Data(), histname.Data(), fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5);
	253	fHistJetsPtNonBias[i]->GetXaxis()->SetTitle("p_{T} [GeV/c]");
	254	fHistJetsPtNonBias[i]->GetYaxis()->SetTitle("counts");
	255	fOutput->Add(fHistJetsPtNonBias[i]);
	256
	257	histname = "fHistJetsPtTrack_";
	258	histname += i;
	259	fHistJetsPtTrack[i] = new TH1F(histname.Data(), histname.Data(), fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5);
	260	fHistJetsPtTrack[i]->GetXaxis()->SetTitle("p_{T} [GeV/c]");
	261	fHistJetsPtTrack[i]->GetYaxis()->SetTitle("counts");
	262	fOutput->Add(fHistJetsPtTrack[i]);
	263
	264	if (fAnaType == kEMCAL) {
	265	histname = "fHistJetsPtClus_";
	266	histname += i;
	267	fHistJetsPtClus[i] = new TH1F(histname.Data(), histname.Data(), fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5);
	268	fHistJetsPtClus[i]->GetXaxis()->SetTitle("p_{T} [GeV/c]");
	269	fHistJetsPtClus[i]->GetYaxis()->SetTitle("counts");
	270	fOutput->Add(fHistJetsPtClus[i]);
	271	}
	272
	273	histname = "fHistJetsPt_";
	274	histname += i;
	275	fHistJetsPt[i] = new TH1F(histname.Data(), histname.Data(), fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5);
	276	fHistJetsPt[i]->GetXaxis()->SetTitle("p_{T} [GeV/c]");
	277	fHistJetsPt[i]->GetYaxis()->SetTitle("counts");
	278	fOutput->Add(fHistJetsPt[i]);
99cfd012	279
e44e8726	280	histname = "fHistJetsPtAreaNonBias_";
	281	histname += i;
	282	fHistJetsPtAreaNonBias[i] = new TH2F(histname.Data(), histname.Data(), fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5, 20, 0, fJetRadius * fJetRadius * TMath::Pi() * 1.5);
	283	fHistJetsPtAreaNonBias[i]->GetXaxis()->SetTitle("p_{T} [GeV/c]");
	284	fHistJetsPtAreaNonBias[i]->GetYaxis()->SetTitle("area");
	285	fOutput->Add(fHistJetsPtAreaNonBias[i]);
	286
	287	histname = "fHistJetsPtArea_";
	288	histname += i;
	289	fHistJetsPtArea[i] = new TH2F(histname.Data(), histname.Data(), fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5, 20, 0, fJetRadius * fJetRadius * TMath::Pi() * 1.5);
	290	fHistJetsPtArea[i]->GetXaxis()->SetTitle("p_{T} [GeV/c]");
	291	fHistJetsPtArea[i]->GetYaxis()->SetTitle("area");
	292	fOutput->Add(fHistJetsPtArea[i]);
	293	}
6fd5039f	294	}
6fd5039f	295
c3ba2d3d	296	PostData(1, fOutput); // Post data for ALL output slots >0 here, to get at least an empty histogram
	297	}
	298
	299	//________________________________________________________________________
6fd5039f	300	Bool_t AliAnalysisTaskSAQA::RetrieveEventObjects()
c3ba2d3d	301	{
c3604199	302	// Retrieve event objects.
	303
	304	if (!AliAnalysisTaskEmcalJet::RetrieveEventObjects())
6fd5039f	305	return kFALSE;
c3ba2d3d	306
e44e8726	307	if (!fTrgClusName.IsNull() && fDoTrigger && !fTrgClusters) {
c3ba2d3d	308	fTrgClusters = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fTrgClusName));
c3ba2d3d	309	if (!fTrgClusters) {
e44e8726	310	AliError(Form("%s: Could not retrieve trigger clusters %s!", GetName(), fTrgClusName.Data()));
	311	return kFALSE;
	312	}
	313	else {
	314	TClass *cl = fTrgClusters->GetClass();
	315	if (!cl->GetBaseClass("AliVCluster") && !cl->GetBaseClass("AliEmcalParticle")) {
	316	AliError(Form("%s: Collection %s does not contain AliVCluster nor AliEmcalParticle objects!", GetName(), fTrgClusName.Data()));
	317	fTrgClusters = 0;
	318	return kFALSE;
	319	}
c3ba2d3d	320	}
c3ba2d3d	321	}
6fd5039f	322
6fd5039f	323	return kTRUE;
c3ba2d3d	324	}
	325
	326	//________________________________________________________________________
6fd5039f	327	Bool_t AliAnalysisTaskSAQA::FillHistograms()
c3ba2d3d	328	{
c3604199	329	// Fill histograms.
c3604199	330
c3ba2d3d	331	fHistCentrality->Fill(fCent);
	332	if (fTracks)
	333	fHistTracksCent->Fill(fCent, fTracks->GetEntriesFast());
	334	if (fCaloClusters)
	335	fHistClusCent->Fill(fCent, fCaloClusters->GetEntriesFast());
	336
c3ba2d3d	337	Float_t trackSum = DoTrackLoop();
c3ba2d3d	338
c3ba2d3d	339	DoJetLoop();
c3ba2d3d	340
6fd5039f	341	if (fAnaType == kEMCAL) {
6fd5039f	342	Float_t clusSum = DoClusterLoop();
c3ba2d3d	343
6fd5039f	344	Float_t cellSum = 0, cellCutSum = 0;
	345
	346	DoCellLoop(cellSum, cellCutSum);
	347
	348	fHistChVSneCells->Fill(cellSum, trackSum);
	349	fHistChVSneClus->Fill(clusSum, trackSum);
	350	fHistChVSneCorrCells->Fill(cellCutSum, trackSum);
c3ba2d3d	351
1f6fff78	352	if (fDoTrigger) {
	353	Float_t maxTrgClus = DoTriggerClusLoop();
	354	fHistMaxL1ClusCent->Fill(fCent, maxTrgClus);
6fd5039f	355
1f6fff78	356	Int_t maxL1amp = -1;
1f6fff78	357	Int_t maxL1thr = -1;
6fd5039f	358
1f6fff78	359	DoTriggerPrimitives(maxL1amp, maxL1thr);
	360
	361	if (maxL1amp > -1)
	362	fHistMaxL1FastORCent->Fill(fCent, maxL1amp);
	363
	364	if (maxL1thr > -1)
	365	fHistMaxL1ThrCent->Fill(fCent, maxL1thr);
	366	}
6fd5039f	367	}
c3ba2d3d	368
6fd5039f	369	return kTRUE;
c3ba2d3d	370	}
	371
	372	//________________________________________________________________________
	373	void AliAnalysisTaskSAQA::DoCellLoop(Float_t &sum, Float_t &sum_cut)
	374	{
c3604199	375	// Do cell loop.
c3604199	376
c3ba2d3d	377	AliVCaloCells *cells = InputEvent()->GetEMCALCells();
	378
	379	if (!cells)
	380	return;
	381
c3604199	382	const Int_t ncells = cells->GetNumberOfCells();
c3ba2d3d	383
c3ba2d3d	384	for (Int_t pos = 0; pos < ncells; pos++) {
c3ba2d3d	385	Float_t amp = cells->GetAmplitude(pos);
c3ba2d3d	386	fHistCellsEnergy->Fill(amp);
c3ba2d3d	387	sum += amp;
c3ba2d3d	388	if (amp < fCellEnergyCut)
c3ba2d3d	389	continue;
c3ba2d3d	390	sum_cut += amp;
c3ba2d3d	391	}
	392	}
	393
	394	//________________________________________________________________________
	395	Float_t AliAnalysisTaskSAQA::DoClusterLoop()
	396	{
c3604199	397	// Do cluster loop.
c3604199	398
c3ba2d3d	399	if (!fCaloClusters)
	400	return 0;
	401
	402	Float_t sum = 0;
	403
	404	// Cluster loop
	405	Int_t nclusters = fCaloClusters->GetEntriesFast();
	406
	407	for (Int_t iClusters = 0; iClusters < nclusters; iClusters++) {
e44e8726	408	AliVCluster* cluster = static_cast<AliVCluster*>(fCaloClusters->At(iClusters));
c3ba2d3d	409	if (!cluster) {
	410	AliError(Form("Could not receive cluster %d", iClusters));
	411	continue;
	412	}
c3ba2d3d	413
e44e8726	414	if (!AcceptCluster(cluster, kTRUE))
e44e8726	415	continue;
c3ba2d3d	416
	417	fHistClustersEnergy->Fill(cluster->E());
	418
	419	sum += cluster->E();
	420
	421	Float_t pos[3];
	422	cluster->GetPosition(pos);
	423	TVector3 clusVec(pos);
	424	fHistClusPhiEta->Fill(clusVec.Eta(), clusVec.Phi());
	425
c3604199	426	}
c3ba2d3d	427
	428	return sum;
	429	}
	430
	431	//________________________________________________________________________
	432	Float_t AliAnalysisTaskSAQA::DoTrackLoop()
	433	{
c3604199	434	// Do track loop.
c3604199	435
c3ba2d3d	436	if (!fTracks)
	437	return 0;
	438
	439	Float_t sum = 0;
	440
c3ba2d3d	441	Int_t ntracks = fTracks->GetEntriesFast();
	442	Int_t nclusters = 0;
	443	if (fCaloClusters)
	444	nclusters = fCaloClusters->GetEntriesFast();
	445
c3604199	446	for (Int_t i = 0; i < ntracks; i++) {
c3ba2d3d	447
e44e8726	448	AliVParticle* track = static_cast<AliVParticle*>(fTracks->At(i)); // pointer to reconstructed to track
1f6fff78	449
c3604199	450	if (!track) {
c3ba2d3d	451	AliError(Form("Could not retrieve track %d",i));
	452	continue;
	453	}
c3ba2d3d	454
1f6fff78	455	AliVTrack* vtrack = dynamic_cast<AliVTrack*>(track);
	456
	457	if (vtrack && !AcceptTrack(vtrack, kTRUE))
	458	continue;
	459
c3ba2d3d	460	fHistTracksPt->Fill(track->Pt());
	461
	462	sum += track->P();
	463
	464	Int_t label = track->GetLabel();
	465
	466	fHistTrPhiEta->Fill(track->Eta(), track->Phi());
	467
	468	fHistTrackEta[4]->Fill(track->Eta());
	469	fHistTrackPhi[4]->Fill(track->Phi());
	470
	471	if (label >= 0 && label < 4) {
	472	fHistTrackEta[label]->Fill(track->Eta());
	473	fHistTrackPhi[label]->Fill(track->Phi());
	474	}
	475
1f6fff78	476	if (!vtrack)
c3ba2d3d	477	continue;
c3ba2d3d	478
1f6fff78	479	fHistTrEmcPhiEta->Fill(vtrack->GetTrackEtaOnEMCal(), vtrack->GetTrackPhiOnEMCal());
c3ba2d3d	480	}
	481
	482	return sum;
	483	}
	484
	485	//________________________________________________________________________
	486	void AliAnalysisTaskSAQA::DoJetLoop()
	487	{
c3604199	488	// Do jet loop.
c3604199	489
c3ba2d3d	490	if (!fJets)
	491	return;
	492
	493	Int_t njets = fJets->GetEntriesFast();
	494
	495	for (Int_t ij = 0; ij < njets; ij++) {
	496
e44e8726	497	AliEmcalJet* jet = static_cast<AliEmcalJet*>(fJets->At(ij));
c3ba2d3d	498
	499	if (!jet) {
	500	AliError(Form("Could not receive jet %d", ij));
	501	continue;
	502	}
	503
6fd5039f	504	if (!AcceptJet(jet, kFALSE))
c3ba2d3d	505	continue;
6fd5039f	506
99cfd012	507	fHistJetsPtNonBias[fCentBin]->Fill(jet->Pt());
99cfd012	508	fHistJetsPtAreaNonBias[fCentBin]->Fill(jet->Pt(), jet->Area());
6fd5039f	509
	510	if (jet->MaxTrackPt() > fPtBiasJetTrack)
	511	fHistJetsPtTrack[fCentBin]->Fill(jet->Pt());
	512
	513	if (fAnaType == kEMCAL && jet->MaxClusterPt() > fPtBiasJetClus)
	514	fHistJetsPtClus[fCentBin]->Fill(jet->Pt());
c3ba2d3d	515
99cfd012	516	if (!AcceptBiasJet(jet))
	517	continue;
	518
	519	fHistJetsPt[fCentBin]->Fill(jet->Pt());
	520	fHistJetsPtArea[fCentBin]->Fill(jet->Pt(), jet->Area());
	521
3000c095	522	fHistJetsPhiEtaPt[fCentBin]->Fill(jet->Eta(), jet->Phi(), jet->Pt());
c3ba2d3d	523	}
	524	}
	525
	526	//________________________________________________________________________
	527	Float_t AliAnalysisTaskSAQA::DoTriggerClusLoop()
	528	{
c3604199	529	// Do trigger cluster loop.
c3604199	530
c3ba2d3d	531	if (!fTrgClusters)
	532	return 0;
	533
	534	Int_t ntrgclusters = fTrgClusters->GetEntriesFast();
	535	Float_t maxTrgClus = 0;
	536
	537	for (Int_t iClusters = 0; iClusters < ntrgclusters; iClusters++) {
e44e8726	538	AliVCluster* cluster = static_cast<AliVCluster*>(fTrgClusters->At(iClusters));
c3ba2d3d	539	if (!cluster) {
	540	AliError(Form("Could not receive cluster %d", iClusters));
	541	continue;
	542	}
	543
	544	if (!(cluster->IsEMCAL())) continue;
	545
	546	if (cluster->E() > maxTrgClus)
	547	maxTrgClus = cluster->E();
	548
	549	}
	550	return maxTrgClus;
	551	}
	552
	553	//________________________________________________________________________
	554	void AliAnalysisTaskSAQA::DoTriggerPrimitives(Int_t &maxL1amp, Int_t &maxL1thr)
	555	{
c3604199	556	// Do trigger primitives loop.
c3604199	557
c3ba2d3d	558	AliVCaloTrigger *triggers = InputEvent()->GetCaloTrigger("EMCAL");
	559
	560	if (!triggers \|\| triggers->GetEntries() == 0)
	561	return;
	562
	563	triggers->Reset();
	564	Int_t L1amp = 0;
	565	Int_t L1thr = 0;
	566	maxL1amp = -1;
	567	maxL1thr = -1;
	568
	569	while (triggers->Next()) {
	570	triggers->GetL1TimeSum(L1amp);
	571	if (maxL1amp < L1amp)
	572	maxL1amp = L1amp;
	573
	574	triggers->GetL1Threshold(L1thr);
	575	if (maxL1thr < L1thr)
	576	maxL1thr = L1thr;
	577	}
	578	}
	579
	580	//________________________________________________________________________
	581	void AliAnalysisTaskSAQA::Terminate(Option_t *)
	582	{
	583	// Called once at the end of the analysis.
	584	}