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

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

#include <TChain.h>
#include <TClonesArray.h>
#include <TH1F.h>
#include <TH2F.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),
  fHistJetsPhiEta(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++) {
    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),
  fHistJetsPhiEta(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++) {
    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);
  }
       
  fHistJetsPhiEta = new TH2F("fHistJetsPhiEta","Phi-Eta distribution of jets", 80, -2, 2, 128, 0, 6.4);
  fHistJetsPhiEta->GetXaxis()->SetTitle("#eta");
  fHistJetsPhiEta->GetYaxis()->SetTitle("#phi");
  fOutput->Add(fHistJetsPhiEta);

  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);

  TString histname;

  for (Int_t i = 0; i < 4; 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 (strcmp(fTrgClusName,"") && fDoTrigger) {
    fTrgClusters =  dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fTrgClusName));
    if (!fTrgClusters) {
      AliWarning(Form("Could not retrieve trigger clusters!")); 
    }
  }

  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 = dynamic_cast<AliVCluster*>(fCaloClusters->At(iClusters));
    if (!cluster) {
      AliError(Form("Could not receive cluster %d", iClusters));
      continue;
    }  
    
    if (!(cluster->IsEMCAL())) 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;

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

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

    AliVParticle* track = dynamic_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 = dynamic_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());

    fHistJetsPhiEta->Fill(jet->Eta(), jet->Phi());
  }
}

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