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

  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()) {

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

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

    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 = 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>
	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	if (fAnaType == kEMCAL) {
6fd5039f	186
	187	fHistCellsEnergy = new TH1F("fHistCellsEnergy","Energy spectrum of cells", fNbins, fMinBinPt, fMaxBinPt);
	188	fHistCellsEnergy->GetXaxis()->SetTitle("E [GeV]");
	189	fHistCellsEnergy->GetYaxis()->SetTitle("counts");
	190	fOutput->Add(fHistCellsEnergy);
	191
98750b70	192	fHistChVSneCells = new TH2F("fHistChVSneCells","Charged energy vs. neutral (cells) energy",
98750b70	193	fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5, fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5);
6fd5039f	194	fHistChVSneCells->GetXaxis()->SetTitle("E [GeV]");
	195	fHistChVSneCells->GetYaxis()->SetTitle("P [GeV/c]");
	196	fOutput->Add(fHistChVSneCells);
	197
98750b70	198	fHistChVSneClus = new TH2F("fHistChVSneClus","Charged energy vs. neutral (clusters) energy",
98750b70	199	fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5, fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5);
6fd5039f	200	fHistChVSneClus->GetXaxis()->SetTitle("E [GeV]");
	201	fHistChVSneClus->GetYaxis()->SetTitle("P [GeV/c]");
	202	fOutput->Add(fHistChVSneClus);
	203
98750b70	204	fHistChVSneCorrCells = new TH2F("fHistChVSneCorrCells","Charged energy vs. neutral (corrected cells) energy",
98750b70	205	fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5, fNbins * 2.5, fMinBinPt , fMaxBinPt * 2.5);
6fd5039f	206	fHistChVSneCorrCells->GetXaxis()->SetTitle("E [GeV]");
	207	fHistChVSneCorrCells->GetYaxis()->SetTitle("P [GeV/c]");
	208	fOutput->Add(fHistChVSneCorrCells);
c3ba2d3d	209	}
c3ba2d3d	210
	211	for (Int_t i = 0; i < 5; i++) {
	212	TString histnamephi("fHistTrackPhi_");
	213	histnamephi += i;
	214	fHistTrackPhi[i] = new TH1F(histnamephi.Data(),histnamephi.Data(), 128, 0, 6.4);
	215	fHistTrackPhi[i]->GetXaxis()->SetTitle("Phi");
	216	fOutput->Add(fHistTrackPhi[i]);
	217
	218	TString histnameeta("fHistTrackEta_");
	219	histnameeta += i;
	220	fHistTrackEta[i] = new TH1F(histnameeta.Data(),histnameeta.Data(), 100, -2, 2);
	221	fHistTrackEta[i]->GetXaxis()->SetTitle("Eta");
	222	fOutput->Add(fHistTrackEta[i]);
	223	}
	224
	225	fHistTrackPhi[0]->SetLineColor(kRed);
	226	fHistTrackEta[0]->SetLineColor(kRed);
	227	fHistTrackPhi[1]->SetLineColor(kBlue);
	228	fHistTrackEta[1]->SetLineColor(kBlue);
	229	fHistTrackPhi[2]->SetLineColor(kGreen);
	230	fHistTrackEta[2]->SetLineColor(kGreen);
	231	fHistTrackPhi[3]->SetLineColor(kOrange);
	232	fHistTrackEta[3]->SetLineColor(kOrange);
	233	fHistTrackPhi[4]->SetLineColor(kBlack);
	234	fHistTrackEta[4]->SetLineColor(kBlack);
	235
e44e8726	236	if (!fJetsName.IsNull()) {
6fd5039f	237
e44e8726	238	fHistJetsPhiEta = new TH2F("fHistJetsPhiEta","Phi-Eta distribution of jets", 80, -2, 2, 128, 0, 6.4);
	239	fHistJetsPhiEta->GetXaxis()->SetTitle("#eta");
	240	fHistJetsPhiEta->GetYaxis()->SetTitle("#phi");
	241	fOutput->Add(fHistJetsPhiEta);
	242
	243	TString histname;
	244
	245	for (Int_t i = 0; i < 4; i++) {
	246	histname = "fHistJetsPtNonBias_";
98750b70	247	histname += i;
e44e8726	248	fHistJetsPtNonBias[i] = new TH1F(histname.Data(), histname.Data(), fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5);
	249	fHistJetsPtNonBias[i]->GetXaxis()->SetTitle("p_{T} [GeV/c]");
	250	fHistJetsPtNonBias[i]->GetYaxis()->SetTitle("counts");
	251	fOutput->Add(fHistJetsPtNonBias[i]);
	252
	253	histname = "fHistJetsPtTrack_";
	254	histname += i;
	255	fHistJetsPtTrack[i] = new TH1F(histname.Data(), histname.Data(), fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5);
	256	fHistJetsPtTrack[i]->GetXaxis()->SetTitle("p_{T} [GeV/c]");
	257	fHistJetsPtTrack[i]->GetYaxis()->SetTitle("counts");
	258	fOutput->Add(fHistJetsPtTrack[i]);
	259
	260	if (fAnaType == kEMCAL) {
	261	histname = "fHistJetsPtClus_";
	262	histname += i;
	263	fHistJetsPtClus[i] = new TH1F(histname.Data(), histname.Data(), fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5);
	264	fHistJetsPtClus[i]->GetXaxis()->SetTitle("p_{T} [GeV/c]");
	265	fHistJetsPtClus[i]->GetYaxis()->SetTitle("counts");
	266	fOutput->Add(fHistJetsPtClus[i]);
	267	}
	268
	269	histname = "fHistJetsPt_";
	270	histname += i;
	271	fHistJetsPt[i] = new TH1F(histname.Data(), histname.Data(), fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5);
	272	fHistJetsPt[i]->GetXaxis()->SetTitle("p_{T} [GeV/c]");
	273	fHistJetsPt[i]->GetYaxis()->SetTitle("counts");
	274	fOutput->Add(fHistJetsPt[i]);
99cfd012	275
e44e8726	276	histname = "fHistJetsPtAreaNonBias_";
	277	histname += i;
	278	fHistJetsPtAreaNonBias[i] = new TH2F(histname.Data(), histname.Data(), fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5, 20, 0, fJetRadius * fJetRadius * TMath::Pi() * 1.5);
	279	fHistJetsPtAreaNonBias[i]->GetXaxis()->SetTitle("p_{T} [GeV/c]");
	280	fHistJetsPtAreaNonBias[i]->GetYaxis()->SetTitle("area");
	281	fOutput->Add(fHistJetsPtAreaNonBias[i]);
	282
	283	histname = "fHistJetsPtArea_";
	284	histname += i;
	285	fHistJetsPtArea[i] = new TH2F(histname.Data(), histname.Data(), fNbins * 2.5, fMinBinPt, fMaxBinPt * 2.5, 20, 0, fJetRadius * fJetRadius * TMath::Pi() * 1.5);
	286	fHistJetsPtArea[i]->GetXaxis()->SetTitle("p_{T} [GeV/c]");
	287	fHistJetsPtArea[i]->GetYaxis()->SetTitle("area");
	288	fOutput->Add(fHistJetsPtArea[i]);
	289	}
6fd5039f	290	}
6fd5039f	291
c3ba2d3d	292	PostData(1, fOutput); // Post data for ALL output slots >0 here, to get at least an empty histogram
	293	}
	294
	295	//________________________________________________________________________
6fd5039f	296	Bool_t AliAnalysisTaskSAQA::RetrieveEventObjects()
c3ba2d3d	297	{
c3604199	298	// Retrieve event objects.
	299
	300	if (!AliAnalysisTaskEmcalJet::RetrieveEventObjects())
6fd5039f	301	return kFALSE;
c3ba2d3d	302
e44e8726	303	if (!fTrgClusName.IsNull() && fDoTrigger && !fTrgClusters) {
c3ba2d3d	304	fTrgClusters = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fTrgClusName));
c3ba2d3d	305	if (!fTrgClusters) {
e44e8726	306	AliError(Form("%s: Could not retrieve trigger clusters %s!", GetName(), fTrgClusName.Data()));
	307	return kFALSE;
	308	}
	309	else {
	310	TClass *cl = fTrgClusters->GetClass();
	311	if (!cl->GetBaseClass("AliVCluster") && !cl->GetBaseClass("AliEmcalParticle")) {
	312	AliError(Form("%s: Collection %s does not contain AliVCluster nor AliEmcalParticle objects!", GetName(), fTrgClusName.Data()));
	313	fTrgClusters = 0;
	314	return kFALSE;
	315	}
c3ba2d3d	316	}
c3ba2d3d	317	}
6fd5039f	318
6fd5039f	319	return kTRUE;
c3ba2d3d	320	}
	321
	322	//________________________________________________________________________
6fd5039f	323	Bool_t AliAnalysisTaskSAQA::FillHistograms()
c3ba2d3d	324	{
c3604199	325	// Fill histograms.
c3604199	326
c3ba2d3d	327	fHistCentrality->Fill(fCent);
	328	if (fTracks)
	329	fHistTracksCent->Fill(fCent, fTracks->GetEntriesFast());
	330	if (fCaloClusters)
	331	fHistClusCent->Fill(fCent, fCaloClusters->GetEntriesFast());
	332
c3ba2d3d	333	Float_t trackSum = DoTrackLoop();
c3ba2d3d	334
c3ba2d3d	335	DoJetLoop();
c3ba2d3d	336
6fd5039f	337	if (fAnaType == kEMCAL) {
6fd5039f	338	Float_t clusSum = DoClusterLoop();
c3ba2d3d	339
6fd5039f	340	Float_t cellSum = 0, cellCutSum = 0;
	341
	342	DoCellLoop(cellSum, cellCutSum);
	343
	344	fHistChVSneCells->Fill(cellSum, trackSum);
	345	fHistChVSneClus->Fill(clusSum, trackSum);
	346	fHistChVSneCorrCells->Fill(cellCutSum, trackSum);
c3ba2d3d	347
1f6fff78	348	if (fDoTrigger) {
	349	Float_t maxTrgClus = DoTriggerClusLoop();
	350	fHistMaxL1ClusCent->Fill(fCent, maxTrgClus);
6fd5039f	351
1f6fff78	352	Int_t maxL1amp = -1;
1f6fff78	353	Int_t maxL1thr = -1;
6fd5039f	354
1f6fff78	355	DoTriggerPrimitives(maxL1amp, maxL1thr);
	356
	357	if (maxL1amp > -1)
	358	fHistMaxL1FastORCent->Fill(fCent, maxL1amp);
	359
	360	if (maxL1thr > -1)
	361	fHistMaxL1ThrCent->Fill(fCent, maxL1thr);
	362	}
6fd5039f	363	}
c3ba2d3d	364
6fd5039f	365	return kTRUE;
c3ba2d3d	366	}
	367
	368	//________________________________________________________________________
	369	void AliAnalysisTaskSAQA::DoCellLoop(Float_t &sum, Float_t &sum_cut)
	370	{
c3604199	371	// Do cell loop.
c3604199	372
c3ba2d3d	373	AliVCaloCells *cells = InputEvent()->GetEMCALCells();
	374
	375	if (!cells)
	376	return;
	377
c3604199	378	const Int_t ncells = cells->GetNumberOfCells();
c3ba2d3d	379
c3ba2d3d	380	for (Int_t pos = 0; pos < ncells; pos++) {
c3ba2d3d	381	Float_t amp = cells->GetAmplitude(pos);
c3ba2d3d	382	fHistCellsEnergy->Fill(amp);
c3ba2d3d	383	sum += amp;
c3ba2d3d	384	if (amp < fCellEnergyCut)
c3ba2d3d	385	continue;
c3ba2d3d	386	sum_cut += amp;
c3ba2d3d	387	}
	388	}
	389
	390	//________________________________________________________________________
	391	Float_t AliAnalysisTaskSAQA::DoClusterLoop()
	392	{
c3604199	393	// Do cluster loop.
c3604199	394
c3ba2d3d	395	if (!fCaloClusters)
	396	return 0;
	397
	398	Float_t sum = 0;
	399
	400	// Cluster loop
	401	Int_t nclusters = fCaloClusters->GetEntriesFast();
	402
	403	for (Int_t iClusters = 0; iClusters < nclusters; iClusters++) {
e44e8726	404	AliVCluster* cluster = static_cast<AliVCluster*>(fCaloClusters->At(iClusters));
c3ba2d3d	405	if (!cluster) {
	406	AliError(Form("Could not receive cluster %d", iClusters));
	407	continue;
	408	}
c3ba2d3d	409
e44e8726	410	if (!AcceptCluster(cluster, kTRUE))
e44e8726	411	continue;
c3ba2d3d	412
	413	fHistClustersEnergy->Fill(cluster->E());
	414
	415	sum += cluster->E();
	416
	417	Float_t pos[3];
	418	cluster->GetPosition(pos);
	419	TVector3 clusVec(pos);
	420	fHistClusPhiEta->Fill(clusVec.Eta(), clusVec.Phi());
	421
c3604199	422	}
c3ba2d3d	423
	424	return sum;
	425	}
	426
	427	//________________________________________________________________________
	428	Float_t AliAnalysisTaskSAQA::DoTrackLoop()
	429	{
c3604199	430	// Do track loop.
c3604199	431
c3ba2d3d	432	if (!fTracks)
	433	return 0;
	434
	435	Float_t sum = 0;
	436
c3ba2d3d	437	Int_t ntracks = fTracks->GetEntriesFast();
	438	Int_t nclusters = 0;
	439	if (fCaloClusters)
	440	nclusters = fCaloClusters->GetEntriesFast();
	441
c3604199	442	for (Int_t i = 0; i < ntracks; i++) {
c3ba2d3d	443
e44e8726	444	AliVParticle* track = static_cast<AliVParticle*>(fTracks->At(i)); // pointer to reconstructed to track
1f6fff78	445
c3604199	446	if (!track) {
c3ba2d3d	447	AliError(Form("Could not retrieve track %d",i));
	448	continue;
	449	}
c3ba2d3d	450
1f6fff78	451	AliVTrack* vtrack = dynamic_cast<AliVTrack*>(track);
	452
	453	if (vtrack && !AcceptTrack(vtrack, kTRUE))
	454	continue;
	455
c3ba2d3d	456	fHistTracksPt->Fill(track->Pt());
	457
	458	sum += track->P();
	459
	460	Int_t label = track->GetLabel();
	461
	462	fHistTrPhiEta->Fill(track->Eta(), track->Phi());
	463
	464	fHistTrackEta[4]->Fill(track->Eta());
	465	fHistTrackPhi[4]->Fill(track->Phi());
	466
	467	if (label >= 0 && label < 4) {
	468	fHistTrackEta[label]->Fill(track->Eta());
	469	fHistTrackPhi[label]->Fill(track->Phi());
	470	}
	471
1f6fff78	472	if (!vtrack)
c3ba2d3d	473	continue;
c3ba2d3d	474
1f6fff78	475	fHistTrEmcPhiEta->Fill(vtrack->GetTrackEtaOnEMCal(), vtrack->GetTrackPhiOnEMCal());
c3ba2d3d	476	}
	477
	478	return sum;
	479	}
	480
	481	//________________________________________________________________________
	482	void AliAnalysisTaskSAQA::DoJetLoop()
	483	{
c3604199	484	// Do jet loop.
c3604199	485
c3ba2d3d	486	if (!fJets)
	487	return;
	488
	489	Int_t njets = fJets->GetEntriesFast();
	490
	491	for (Int_t ij = 0; ij < njets; ij++) {
	492
e44e8726	493	AliEmcalJet* jet = static_cast<AliEmcalJet*>(fJets->At(ij));
c3ba2d3d	494
	495	if (!jet) {
	496	AliError(Form("Could not receive jet %d", ij));
	497	continue;
	498	}
	499
6fd5039f	500	if (!AcceptJet(jet, kFALSE))
c3ba2d3d	501	continue;
6fd5039f	502
99cfd012	503	fHistJetsPtNonBias[fCentBin]->Fill(jet->Pt());
99cfd012	504	fHistJetsPtAreaNonBias[fCentBin]->Fill(jet->Pt(), jet->Area());
6fd5039f	505
	506	if (jet->MaxTrackPt() > fPtBiasJetTrack)
	507	fHistJetsPtTrack[fCentBin]->Fill(jet->Pt());
	508
	509	if (fAnaType == kEMCAL && jet->MaxClusterPt() > fPtBiasJetClus)
	510	fHistJetsPtClus[fCentBin]->Fill(jet->Pt());
c3ba2d3d	511
99cfd012	512	if (!AcceptBiasJet(jet))
	513	continue;
	514
	515	fHistJetsPt[fCentBin]->Fill(jet->Pt());
	516	fHistJetsPtArea[fCentBin]->Fill(jet->Pt(), jet->Area());
	517
c3ba2d3d	518	fHistJetsPhiEta->Fill(jet->Eta(), jet->Phi());
	519	}
	520	}
	521
	522	//________________________________________________________________________
	523	Float_t AliAnalysisTaskSAQA::DoTriggerClusLoop()
	524	{
c3604199	525	// Do trigger cluster loop.
c3604199	526
c3ba2d3d	527	if (!fTrgClusters)
	528	return 0;
	529
	530	Int_t ntrgclusters = fTrgClusters->GetEntriesFast();
	531	Float_t maxTrgClus = 0;
	532
	533	for (Int_t iClusters = 0; iClusters < ntrgclusters; iClusters++) {
e44e8726	534	AliVCluster* cluster = static_cast<AliVCluster*>(fTrgClusters->At(iClusters));
c3ba2d3d	535	if (!cluster) {
	536	AliError(Form("Could not receive cluster %d", iClusters));
	537	continue;
	538	}
	539
	540	if (!(cluster->IsEMCAL())) continue;
	541
	542	if (cluster->E() > maxTrgClus)
	543	maxTrgClus = cluster->E();
	544
	545	}
	546	return maxTrgClus;
	547	}
	548
	549	//________________________________________________________________________
	550	void AliAnalysisTaskSAQA::DoTriggerPrimitives(Int_t &maxL1amp, Int_t &maxL1thr)
	551	{
c3604199	552	// Do trigger primitives loop.
c3604199	553
c3ba2d3d	554	AliVCaloTrigger *triggers = InputEvent()->GetCaloTrigger("EMCAL");
	555
	556	if (!triggers \|\| triggers->GetEntries() == 0)
	557	return;
	558
	559	triggers->Reset();
	560	Int_t L1amp = 0;
	561	Int_t L1thr = 0;
	562	maxL1amp = -1;
	563	maxL1thr = -1;
	564
	565	while (triggers->Next()) {
	566	triggers->GetL1TimeSum(L1amp);
	567	if (maxL1amp < L1amp)
	568	maxL1amp = L1amp;
	569
	570	triggers->GetL1Threshold(L1thr);
	571	if (maxL1thr < L1thr)
	572	maxL1thr = L1thr;
	573	}
	574	}
	575
	576	//________________________________________________________________________
	577	void AliAnalysisTaskSAQA::Terminate(Option_t *)
	578	{
	579	// Called once at the end of the analysis.
	580	}