ROOT logo
/**************************************************************************
 * Copyright(c) 1998-2014, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/*
 * Analysis task of the pt analysis on EMCal-triggered events
 *
 *   Author: Markus Fasel
 */

#include <map>
#include <cstring>
#include <iostream>
#include <memory>
#include <vector>
#include <string>
#include <sstream>

#include <TClonesArray.h>
#include <TDirectory.h>
#include <TH1.h>
#include <THashList.h>
#include <TList.h>
#include <TKey.h>
#include <TMath.h>
#include <TObjArray.h>
#include <TObjString.h>
#include <TString.h>
#include <TVector2.h>

#include "AliAODEvent.h"
#include "AliESDEvent.h"
#include "AliInputEventHandler.h"
#include "AliMCEvent.h"
#include "AliParticleContainer.h"
#include "AliVCluster.h"
#include "AliVParticle.h"
#include "AliVTrack.h"
#include "AliVVertex.h"

#include "AliClusterContainer.h"
#include "AliEmcalJet.h"
#include "AliEmcalTriggerPatchInfo.h"
#include "AliEmcalPhysicsSelection.h"
#include "AliAnalysisTaskPtEMCalTrigger.h"
#include "AliEMCalHistoContainer.h"
#include "AliEMCalPtTaskVTrackSelection.h"
#include "AliEMCalPtTaskTrackSelectionESD.h"
#include "AliEMCalPtTaskTrackSelectionAOD.h"
#include "AliJetContainer.h"
#include "AliParticleContainer.h"
#include "AliPicoTrack.h"

ClassImp(EMCalTriggerPtAnalysis::AliAnalysisTaskPtEMCalTrigger)

namespace EMCalTriggerPtAnalysis {

  /*
   * constants
   */
  const Int_t AliAnalysisTaskPtEMCalTrigger::kNJetRadii = 4;
  const Double_t jetRadVals[AliAnalysisTaskPtEMCalTrigger::kNJetRadii] = {0.2, 0.3, 0.4, 0.5};
  const Double_t *AliAnalysisTaskPtEMCalTrigger::kJetRadii = jetRadVals;

  //______________________________________________________________________________
  AliAnalysisTaskPtEMCalTrigger::AliAnalysisTaskPtEMCalTrigger():
                		    AliAnalysisTaskEmcalJet(),
                		    fHistos(NULL),
                		    fListTrackCuts(NULL),
                		    fEtaRange(),
                		    fPtRange(),
                		    fEnergyRange(),
                		    fVertexRange(),
                		    fJetContainersMC(),
                		    fJetContainersData(),
                		    fSelectAllTracks(kFALSE),
                		    fSwapEta(kFALSE),
                		    fUseTriggersFromTriggerMaker(kFALSE)
  {
    /*
     * Dummy constructor, initialising the values with default (NULL) values
     */
  }

  //______________________________________________________________________________
  AliAnalysisTaskPtEMCalTrigger::AliAnalysisTaskPtEMCalTrigger(const char *name):
                		    AliAnalysisTaskEmcalJet(name, kTRUE),
                		    fHistos(NULL),
                		    fListTrackCuts(NULL),
                		    fEtaRange(),
                		    fPtRange(),
                        fEnergyRange(),
                        fVertexRange(),
                        fJetContainersMC(),
                        fJetContainersData(),
                        fSelectAllTracks(kFALSE),
                		    fSwapEta(kFALSE),
                		    fUseTriggersFromTriggerMaker(kFALSE)
  {
    /*
     * Main constructor, setting default values for eta and zvertex cut
     */

    fListTrackCuts = new TList;
    fListTrackCuts->SetOwner(false);

    // Set default cuts
    fEtaRange.SetLimits(-0.8, 0.8);
    fPtRange.SetLimits(0.15, 100.);
    fEnergyRange.SetLimits(0., 1000.);
    fVertexRange.SetLimits(-10., 10.);
    SetMakeGeneralHistograms(kTRUE);
  }

  //______________________________________________________________________________
  AliAnalysisTaskPtEMCalTrigger::~AliAnalysisTaskPtEMCalTrigger(){
    /*
     * Destructor, deleting output
     */
    //if(fTrackSelection) delete fTrackSelection;
    if(fHistos) delete fHistos;
    if(fListTrackCuts) delete fListTrackCuts;
  }

  //______________________________________________________________________________
  void AliAnalysisTaskPtEMCalTrigger::UserCreateOutputObjects(){
    /*
     * Create the list of output objects and define the histograms.
     * Also adding the track cuts to the list of histograms.
     */
    AliAnalysisTaskEmcal::UserCreateOutputObjects();
    SetCaloTriggerPatchInfoName("EmcalTriggers");
    fHistos = new AliEMCalHistoContainer("PtEMCalTriggerHistograms");
    fHistos->ReleaseOwner();

    if(fJetContainersMC.GetEntries()){
      AliDebug(1,"Jet containers for MC truth:");
      TObjString *contname(NULL);
      TIter contMCIter(&fJetContainersMC);
      while((contname = dynamic_cast<TObjString *>(contMCIter.Next())))
        AliDebug(1, Form("Next container: %s", contname->String().Data()));
    }
    if(fJetContainersData.GetEntries()){
      AliDebug(1, "Jet containers for Data:");
      TObjString *contname(NULL);
      TIter contDataIter(&fJetContainersData);
      while((contname = dynamic_cast<TObjString *>(contDataIter.Next())))
        AliDebug(1, Form("Next container: %s", contname->String().Data()));
    }
    if(fJetCollArray.GetEntries()){
      AliDebug(1, "Jet containers attached to this task:");
      AliJetContainer *cont(NULL);
      TIter contIter(&fJetCollArray);
      while((cont = dynamic_cast<AliJetContainer *>(contIter.Next())))
        AliDebug(1, Form("Container: %s", cont->GetName()));
    }

    std::map<std::string, std::string> triggerCombinations;
    const char *triggernames[12] = {"MinBias", "EMCJHigh", "EMCJLow", "EMCGHigh", "EMCGLow", "NoEMCal", "EMCHighBoth", "EMCHighGammaOnly", "EMCHighJetOnly", "EMCLowBoth", "EMCLowGammaOnly", "EMCLowJetOnly"},
        *bitnames[4] = {"CINT7", "EMC7", "kEMCEGA", "kEMCEJE"};
    // Define axes for the trigger correlation histogram
    const TAxis *triggeraxis[5]; memset(triggeraxis, 0, sizeof(const TAxis *) * 5);
    const TAxis *bitaxes[4]; memset(bitaxes, 0, sizeof(TAxis *) * 4);
    const char *binlabels[2] = {"OFF", "ON"};
    TAxis mytrgaxis[5], mybitaxis[4];
    for(int itrg = 0; itrg < 5; ++itrg){
      DefineAxis(mytrgaxis[itrg], triggernames[itrg], triggernames[itrg], 2, -0.5, 1.5, binlabels);
      triggeraxis[itrg] = mytrgaxis+itrg;
      if(itrg < 4){
        DefineAxis(mybitaxis[itrg], bitnames[itrg], bitnames[itrg], 2, -0.5, 1.5, binlabels);
        bitaxes[itrg] = mybitaxis+itrg;
      }
    }
    // Define names and titles for different triggers in the histogram container
    triggerCombinations.insert(std::pair<std::string,std::string>(triggernames[0], "min. bias events"));
    triggerCombinations.insert(std::pair<std::string,std::string>(triggernames[1], "jet-triggered events (high threshold)"));
    triggerCombinations.insert(std::pair<std::string,std::string>(triggernames[2], "jet-triggered events (low threshold)"));
    triggerCombinations.insert(std::pair<std::string,std::string>(triggernames[3], "gamma-triggered events (high threshold)"));
    triggerCombinations.insert(std::pair<std::string,std::string>(triggernames[4], "gamma-triggered events (low threshold)"));
    triggerCombinations.insert(std::pair<std::string,std::string>(triggernames[5], "non-EMCal-triggered events"));
    triggerCombinations.insert(std::pair<std::string,std::string>(triggernames[6], "jet and gamma triggered events (high threshold)"));
    triggerCombinations.insert(std::pair<std::string,std::string>(triggernames[7], "exclusively gamma-triggered events (high threshold)"));
    triggerCombinations.insert(std::pair<std::string,std::string>(triggernames[8], "exclusively jet-triggered events (high threshold)"));
    triggerCombinations.insert(std::pair<std::string,std::string>(triggernames[9], "jet and gamma triggered events (low threshold)"));
    triggerCombinations.insert(std::pair<std::string,std::string>(triggernames[10], "exclusively gamma-triggered events (low threshold)"));
    triggerCombinations.insert(std::pair<std::string,std::string>(triggernames[11], "exclusively-triggered events (low threshold)"));
    // Define axes for the pt histogram
    // Dimensions:
    // 1. pt
    // 2. eta
    // 3. phi
    // 4. vertex
    // 5. pileup (0 = all events, 1 = after pileup rejection)
    // 6. track cuts (0 = no cuts; 1 = after std cuts)
    TArrayD ptbinning, zvertexBinning, etabinning, pileupaxis(3);
    pileupaxis[0] = -0.5; pileupaxis[1] = 0.5; pileupaxis[2] = 1.5;
    CreateDefaultPtBinning(ptbinning);
    CreateDefaultZVertexBinning(zvertexBinning);
    CreateDefaultEtaBinning(etabinning);
    TAxis htrackaxes[7];
    DefineAxis(htrackaxes[0], "pt", "p_{t} (GeV/c)", ptbinning);
    DefineAxis(htrackaxes[1], "eta", "#eta", etabinning);
    DefineAxis(htrackaxes[2], "phi", "#phi", 20, 0, 2 * TMath::Pi());
    DefineAxis(htrackaxes[3], "zvertex", "z_{V} (cm)", zvertexBinning);
    DefineAxis(htrackaxes[4], "pileup", "Pileup rejection", 2, -0.5, 1.5);
    DefineAxis(htrackaxes[5], "trackcuts", "Track Cuts", (fListTrackCuts ? fListTrackCuts->GetEntries() : 0) + 1, -0.5, (fListTrackCuts ? fListTrackCuts->GetEntries() : 0) + 0.5);
    DefineAxis(htrackaxes[6], "mbtrigger", "Has MB trigger", 2, -0.5, 1.5);
    const TAxis *trackaxes[7];
    for(int iaxis = 0; iaxis < 7; ++iaxis) trackaxes[iaxis] = htrackaxes + iaxis;
    TAxis hclusteraxes[4];
    DefineAxis(hclusteraxes[0], "energy", "E (GeV)", ptbinning);
    DefineAxis(hclusteraxes[1], "zvertex", "z_{V} (cm)", zvertexBinning);
    DefineAxis(hclusteraxes[2], "pileup", "Pileup rejection", 2,1 -0.5, 1.5);
    DefineAxis(hclusteraxes[3], "mbtrigger", "Has MB trigger", 2, -0.5, 1.5);
    const TAxis *clusteraxes[4];
    for(int iaxis = 0; iaxis < 4; ++iaxis) clusteraxes[iaxis] = hclusteraxes + iaxis;
    TAxis hpatchenergyaxes[5];
    DefineAxis(hpatchenergyaxes[0], "energy", "Patch energy (GeV)", 100, 0., 100);
    DefineAxis(hpatchenergyaxes[1], "eta", "#eta", etabinning);
    DefineAxis(hpatchenergyaxes[2], "phi", "#phi",  20, 0, 2 * TMath::Pi());
    DefineAxis(hpatchenergyaxes[3], "isMain", "Main trigger", 2, -0.5, 1.5);
    DefineAxis(hpatchenergyaxes[4],  "emcalgood", "EMCAL good event", 2, -0.5, 1.5);
    const TAxis *patchenergyaxes[5];
    for(int iaxis = 0; iaxis < 5; ++iaxis) patchenergyaxes[iaxis] = hpatchenergyaxes + iaxis;
    TAxis hpatchampaxes[5];
    DefineAxis(hpatchampaxes[0], "amplitude", "Patch energy (GeV)", 10000, 0., 10000.);
    DefineAxis(hpatchampaxes[1], "eta", "#eta", etabinning);
    DefineAxis(hpatchampaxes[2], "phi", "#phi",  20, 0, 2 * TMath::Pi());
    DefineAxis(hpatchampaxes[3], "isMain", "Main trigger", 2, -0.5, 1.5);
    DefineAxis(hpatchampaxes[4],  "emcalgood", "EMCAL good event", 2, -0.5, 1.5);
    const TAxis *patchampaxes[5];
    for(int iaxis = 0; iaxis < 5; ++iaxis) patchampaxes[iaxis] = hpatchampaxes + iaxis;
    try{
      std::string patchnames[] = {"Level0", "JetHigh", "JetLow", "GammaHigh", "GammaLow"};
      for(std::string * triggerpatch = patchnames; triggerpatch < patchnames + sizeof(patchnames)/sizeof(std::string); ++triggerpatch){
        fHistos->CreateTHnSparse(Form("Energy%s", triggerpatch->c_str()), Form("Patch energy for %s trigger patches", triggerpatch->c_str()), 5, patchenergyaxes, "s");
        fHistos->CreateTHnSparse(Form("EnergyRough%s", triggerpatch->c_str()), Form("Rough patch energy for %s trigger patches", triggerpatch->c_str()), 5, patchenergyaxes, "s");
        fHistos->CreateTHnSparse(Form("Amplitude%s", triggerpatch->c_str()), Form("Patch amplitude for %s trigger patches", triggerpatch->c_str()), 5, patchampaxes, "s");
      }

      // Create histogram for MC-truth
      fHistos->CreateTHnSparse("hMCtrueParticles", "Particle-based histogram for MC-true particles", 5, trackaxes, "s");
      if(fJetCollArray.GetEntries()){
        for(int irad = 0; irad < kNJetRadii; irad++){
          fHistos->CreateTHnSparse(Form("hMCtrueParticlesRad%02d", int(kJetRadii[irad]*10)),
              Form("Particle-based histogram for MC-true particles in Jets with radius %.1f", kJetRadii[irad]*10), 5, trackaxes, "s");
        }
        // histogram for isolated particles
        fHistos->CreateTHnSparse("hMCtrueParticlesIsolated", "Particle-based histogram for isolated MC-true particles", 5, trackaxes, "s");
      }
      for(std::map<std::string,std::string>::iterator it = triggerCombinations.begin(); it != triggerCombinations.end(); ++it){
        const std::string name = it->first, &title = it->second;
        // Create event-based histogram
        fHistos->CreateTH2(Form("hEventHist%s", name.c_str()), Form("Event-based data for %s events; pileup rejection; z_{V} (cm)", title.c_str()), pileupaxis, zvertexBinning);
        // Create track-based histogram
        fHistos->CreateTHnSparse(Form("hTrackHist%s", name.c_str()), Form("Track-based data for %s events", title.c_str()), 7, trackaxes, "s");
        fHistos->CreateTHnSparse(Form("hTrackInAcceptanceHist%s", name.c_str()), Form("Track-based data for %s events  for tracks matched to EMCal clusters", title.c_str()), 7, trackaxes, "s");
        fHistos->CreateTHnSparse(Form("hMCTrackHist%s", name.c_str()), Form("Track-based data for %s events with MC kinematics", title.c_str()), 7, trackaxes, "s");
        fHistos->CreateTHnSparse(Form("hMCTrackInAcceptanceHist%s", name.c_str()), Form("Track-based data for %s events with MC kinematics for tracks matched to EMCal clusters", title.c_str()), 7, trackaxes, "s");
        // Create cluster-based histogram (Uncalibrated and calibrated clusters)
        fHistos->CreateTHnSparse(Form("hClusterCalibHist%s", name.c_str()), Form("Calib. cluster-based histogram for %s events", title.c_str()), 4, clusteraxes, "s");
        fHistos->CreateTHnSparse(Form("hClusterUncalibHist%s", name.c_str()), Form("Uncalib. cluster-based histogram for %s events", title.c_str()), 4, clusteraxes, "s");
        if(fJetCollArray.GetEntries()){
          // Create histograms for particles in different jetfinder radii, only track-based
          for(int irad = 0; irad < kNJetRadii; irad++){
            fHistos->CreateTHnSparse(Form("hTrackHist%sRad%02d", name.c_str(), int(kJetRadii[irad]*10)),
                Form("Track-based data for %s events for tracks in jets with Radius %.1f", title.c_str(), kJetRadii[irad]), 7, trackaxes, "s");
            fHistos->CreateTHnSparse(Form("hTrackInAcceptanceHist%sRad%02d", name.c_str(), int(kJetRadii[irad]*10)),
                Form("Track-based data for %s events for tracks matched to EMCal clusters in jets with Radius %.1f", title.c_str(), kJetRadii[irad]),
                7, trackaxes, "s");
            fHistos->CreateTHnSparse(Form("hMCTrackHist%sRad%02d", name.c_str(), int(kJetRadii[irad]*10)),
                Form("Track-based data for %s events with MC kinematics for tracks in jets with Radius %.1f", title.c_str(), kJetRadii[irad]),
                7, trackaxes, "s");
            fHistos->CreateTHnSparse(Form("hMCTrackInAcceptanceHist%sRad%02d", name.c_str(), int(kJetRadii[irad]*10)),
                Form("Track-based data for %s events with MC kinematics for tracks matched to EMCal clusters in jets with Radius %.1f", title.c_str(), kJetRadii[irad]),
                7, trackaxes, "s");
            fHistos->CreateTHnSparse(Form("hClusterCalibHist%sRad%02d", name.c_str(), int(kJetRadii[irad]*10)),
                Form("Calib. cluster-based histogram for %s events for clusters in Jets with radius %.1f", title.c_str(), kJetRadii[irad]), 4, clusteraxes, "s");
          }
        }
        // Create also histograms for isolated particles
        fHistos->CreateTHnSparse(Form("hTrackHist%sIsolated", name.c_str()), Form("Track-based data for %s events for isolated tracks", title.c_str()), 7, trackaxes, "s");
        fHistos->CreateTHnSparse(Form("hTrackInAcceptanceHist%sIsolated", name.c_str()), Form("Track-based data for %s events for isolated tracks matched to EMCal clusters", title.c_str()), 7, trackaxes, "s");
        fHistos->CreateTHnSparse(Form("hMCTrackHist%sIsolated", name.c_str()), Form("Track-based data for %s events with MC kinematics for isolated tracks", title.c_str()), 7, trackaxes, "s");
        fHistos->CreateTHnSparse(Form("hMCTrackInAcceptanceHist%sIsolated", name.c_str()), Form("Track-based data for %s events with MC kinematics for isolated tracks matched to EMCal clusters", title.c_str()), 7, trackaxes, "s");
      }
      fHistos->CreateTHnSparse("hEventTriggers", "Trigger type per event", 5, triggeraxis);
      fHistos->CreateTHnSparse("hEventsTriggerbit", "Trigger bits for the different events", 4, bitaxes);
    } catch (HistoContainerContentException &e){
      std::stringstream errormessage;
      errormessage << "Creation of histogram failed: " << e.what();
      AliError(errormessage.str().c_str());
    }
    fOutput->Add(fHistos->GetListOfHistograms());
    if(fListTrackCuts && fListTrackCuts->GetEntries()){
      TIter cutIter(fListTrackCuts);
      AliEMCalPtTaskVTrackSelection *cutObject(NULL);
      while((cutObject = dynamic_cast<AliEMCalPtTaskVTrackSelection *>(cutIter()))){
        AliESDtrackCuts *cuts = dynamic_cast<AliESDtrackCuts *>(cutObject->GetTrackCuts());
        if(cuts){
          cuts->DefineHistograms();
          fOutput->Add(cuts);
        }
      }
    }
    PostData(1, fOutput);
  }

  //______________________________________________________________________________
  Bool_t AliAnalysisTaskPtEMCalTrigger::Run(){
    /*
     * Runs the event loop
     *
     * @param option: Additional options
     */
    // Common checks: Have SPD vertex and primary vertex from tracks, and both need to have at least one contributor
    AliDebug(1,Form("Number of calibrated clusters: %d", fCaloClusters->GetEntries()));
    AliDebug(1,Form("Number of matched tracks: %d", fTracks->GetEntries()));
    if(fMCEvent){
      // Build always trigger strig from the trigger maker in case of MC
      fUseTriggersFromTriggerMaker = kTRUE;
    }

    Bool_t emcalGood = fInputHandler->IsEventSelected() & AliEmcalPhysicsSelection::kEmcalOk;

    // Loop over trigger patches, fill patch energy
    AliEmcalTriggerPatchInfo *triggerpatch(NULL);
    TIter patchIter(this->fTriggerPatchInfo);
    while((triggerpatch = dynamic_cast<AliEmcalTriggerPatchInfo *>(patchIter()))){
      double triggerpatchinfo[5] = {triggerpatch->GetPatchE(), triggerpatch->GetEtaGeo(), triggerpatch->GetPhiGeo(), triggerpatch->IsMainTrigger() ? 1. : 0., emcalGood ? 1. : 0.};
      double triggerpatchinfoamp[5] = {static_cast<double>(triggerpatch->GetADCAmp()), triggerpatch->GetEtaGeo(), triggerpatch->GetPhiGeo(), triggerpatch->IsMainTrigger() ? 1. : 0., emcalGood ? 1. : 0.};
      double triggerpatchinfoer[5] = {triggerpatch->GetADCAmpGeVRough(), triggerpatch->GetEtaGeo(), triggerpatch->GetPhiGeo(), triggerpatch->IsMainTrigger() ? 1. : 0., emcalGood ? 1. : 0.};
      if(triggerpatch->IsJetHigh()){
        fHistos->FillTHnSparse("EnergyJetHigh", triggerpatchinfo);
        fHistos->FillTHnSparse("AmplitudeJetHigh", triggerpatchinfoamp);
        fHistos->FillTHnSparse("EnergyRoughJetHigh", triggerpatchinfoer);
      }
      if(triggerpatch->IsJetLow()){
        fHistos->FillTHnSparse("EnergyJetLow", triggerpatchinfo);
        fHistos->FillTHnSparse("AmplitudeJetLow", triggerpatchinfoamp);
        fHistos->FillTHnSparse("EnergyRoughJetLow", triggerpatchinfoer);
      }
      if(triggerpatch->IsGammaHigh()){
        fHistos->FillTHnSparse("EnergyGammaHigh", triggerpatchinfo);
        fHistos->FillTHnSparse("AmplitudeGammaHigh", triggerpatchinfoamp);
        fHistos->FillTHnSparse("EnergyRoughGammaHigh", triggerpatchinfoer);
      }
      if(triggerpatch->IsGammaLow()){
        fHistos->FillTHnSparse("EnergyGammaLow", triggerpatchinfo);
        fHistos->FillTHnSparse("AmplitudeGammaLow", triggerpatchinfoamp);
        fHistos->FillTHnSparse("EnergyRoughGammaLow", triggerpatchinfoer);
      }
      if(triggerpatch->IsLevel0()){
        fHistos->FillTHnSparse("EnergyLevel0", triggerpatchinfo);
        fHistos->FillTHnSparse("AmplitudeLevel0", triggerpatchinfoamp);
        fHistos->FillTHnSparse("EnergyRoughLevel0", triggerpatchinfoer);
      }
    }

    const AliVVertex *vtxTracks = fInputEvent->GetPrimaryVertex(),
        *vtxSPD = GetSPDVertex();
    if(!(vtxTracks && vtxSPD)) return false;
    if(!fVertexRange.IsInRange(vtxTracks->GetZ())) return false;
    if(vtxTracks->GetNContributors() < 1 || vtxSPD->GetNContributors() < 1) return false;

    double triggers[5]; memset(triggers, 0, sizeof(double) * 5);
    double triggerbits[4]; memset(triggerbits, 0, sizeof(double) * 4);
    if(fInputHandler->IsEventSelected() & AliVEvent::kINT7){
      triggers[0] = 1.;
      triggerbits[0] = 1.;
    }

    // check triggerbits
    if(fInputHandler->IsEventSelected() & AliVEvent::kEMC7){
      triggerbits[1] = 1.;
    }
    if(fInputHandler->IsEventSelected() & AliVEvent::kEMCEGA){
      triggerbits[2] = 1.;
    }
    if(fInputHandler->IsEventSelected() & AliVEvent::kEMCEJE){
      triggerbits[3] = 1.;
    }
    try{
      fHistos->FillTHnSparse("hEventsTriggerbit", triggerbits);
    } catch(HistoContainerContentException &e) {
      std::stringstream errormessage;
      errormessage << "Filling of histogram failed: " << e.what();
      AliError(errormessage.str().c_str());
    }

    std::vector<std::string> triggerstrings;
    // EMCal-triggered event, distinguish types
    TString trgstr(fUseTriggersFromTriggerMaker ? BuildTriggerString() : fInputEvent->GetFiredTriggerClasses());
    AliDebug(1, Form("Triggerstring: %s\n", trgstr.Data()));
    if(trgstr.Contains("EJ1")){
      triggerstrings.push_back("EMCJHigh");
      triggers[1] = 1;
      if(trgstr.Contains("EG1"))
        triggerstrings.push_back("EMCHighBoth");
      else
        triggerstrings.push_back("EMCHighJetOnly");
    }
    if(trgstr.Contains("EJ2")){
      triggerstrings.push_back("EMCJLow");
      triggers[2] = 1;
      if(trgstr.Contains("EG2"))
        triggerstrings.push_back("EMCLowBoth");
      else
        triggerstrings.push_back("EMCLowJetOnly");
    }
    if(trgstr.Contains("EG1")){
      triggerstrings.push_back("EMCGHigh");
      triggers[3] = 1;
      if(!trgstr.Contains("EJ1"))
        triggerstrings.push_back("EMCHighGammaOnly");
    }
    if(trgstr.Contains("EG2")){
      triggerstrings.push_back("EMCGLow");
      triggers[4] = 1;
      if(!trgstr.Contains("EJ2"))
        triggerstrings.push_back("EMCLowGammaOnly");
    }

    try{
      fHistos->FillTHnSparse("hEventTriggers", triggers);
    } catch (HistoContainerContentException &e){
      std::stringstream errormessage;
      errormessage << "Filling of histogram failed: " << e.what();
      AliError(errormessage.str().c_str());
    }

    // apply event selection: Combine the Pileup cut from SPD with the other pA Vertex selection cuts.
    bool isPileupEvent = fInputEvent->IsPileupFromSPD(3, 0.8, 3., 2., 5.);
    isPileupEvent = isPileupEvent || (TMath::Abs(vtxTracks->GetZ() - vtxSPD->GetZ()) > 0.5);
    double covSPD[6]; vtxSPD->GetCovarianceMatrix(covSPD);
    isPileupEvent = isPileupEvent || (TString(vtxSPD->GetTitle()).Contains("vertexer:Z") && TMath::Sqrt(covSPD[5]) > 0.25);

    // Fill event-based histogram
    const double &zv = vtxTracks->GetZ();
    if(triggers[0]) FillEventHist("MinBias", zv, isPileupEvent);
    if(!triggerstrings.size()) // Non-EMCal-triggered
      FillEventHist("NoEMCal", zv, isPileupEvent);
    else{
      // EMCal-triggered events
      for(std::vector<std::string>::iterator it = triggerstrings.begin(); it != triggerstrings.end(); ++it)
        FillEventHist(it->c_str(), zv, isPileupEvent);
    }

    const AliEmcalJet *foundJet(NULL);
    char histname[1024];
    std::vector<double> coneradii;
    AliJetContainer *jetContMC(NULL), *jetContData(NULL);

    // Fill MC truth
    AliVParticle *part(NULL);
    if(fMCEvent){
      if(fJetCollArray.GetEntries() &&
                  (jetContMC = dynamic_cast<AliJetContainer *>(fJetCollArray.FindObject((static_cast<TObjString *>(fJetContainersMC.At(0)))->String().Data())))){
        // In case we have a jet array we loop over all MC selected particles in the particle container of the jet array
        TIter particles(jetContMC->GetParticleContainer()->GetArray());
        while((part = dynamic_cast<AliVParticle *>(particles()))){
          if(part->Charge() == 0) continue;
          if(!fEtaRange.IsInRange(part->Eta())) continue;
          if(!fPtRange.IsInRange(part->Pt())) continue;
          FillMCParticleHist("hMCtrueParticles", part, zv, isPileupEvent);

          /*
           * Jet part: Find track in jet container,
           * check according to number of particles in jet, and
           * check for different cone radii
           */
          foundJet = FoundTrackInJet(part, jetContMC);
          if(foundJet && foundJet->GetNumberOfConstituents() > 1){
            for(int irad = 0; irad < kNJetRadii; irad++){
              if(IsInRadius(part, foundJet, kJetRadii[irad])){
                sprintf(histname, "hMCtrueParticlesRad%02d", int(kJetRadii[irad]*10));
                FillMCParticleHist(histname,  part, zv, isPileupEvent);
              }
            }
          } else {
            // isolated track
            FillMCParticleHist("hMCtrueParticlesIsolated", part, zv, isPileupEvent);
          }
        }
      } else {
        // Use MC Event
        for(int ipart = 0; ipart < fMCEvent->GetNumberOfTracks(); ipart++){
          // Select only physical primary particles
          part = fMCEvent->GetTrack(ipart);
          if(part->Charge() == 0) continue;
          if(!fEtaRange.IsInRange(part->Eta())) continue;
          if(!fPtRange.IsInRange(part->Pt())) continue;
          if(!fMCEvent->IsPhysicalPrimary(ipart)) continue;
          FillMCParticleHist("hMCtrueParticles", part, zv, isPileupEvent);
        }
      }
    }

    AliVTrack *track(NULL);
    AliPicoTrack *picoTrack(NULL);
    TObject *containerObject(NULL);
    // Loop over all tracks (No cuts applied)
    if(fSelectAllTracks){
      // loop over all tracks only if requested
      TIter allTrackIter(fTracks);
      while((containerObject = dynamic_cast<TObject *>(allTrackIter()))){
        if((picoTrack = dynamic_cast<AliPicoTrack *>(containerObject))){
          track = picoTrack->GetTrack();
        } else
          track = dynamic_cast<AliVTrack *>(containerObject);
        if(!IsTrueTrack(track)) continue;
        if(!fEtaRange.IsInRange(track->Eta())) continue;
        if(!fPtRange.IsInRange(track->Pt())) continue;
        if(triggers[0]) FillTrackHist("MinBias", track, zv, isPileupEvent, 0, triggers[0]);
        if(!triggerstrings.size()) // Non-EMCal-triggered
          FillTrackHist("NoEMCal", track, zv, isPileupEvent, 0, triggers[0]);
        else {
          // EMCal-triggered events
          for(std::vector<std::string>::iterator it = triggerstrings.begin(); it != triggerstrings.end(); ++it)
            FillTrackHist(it->c_str(), track, zv, isPileupEvent, 0, triggers[0]);
        }
      }
    }

    // Now apply track selection cuts
    // allow for several track selections to be tested at the same time
    // each track selection gets a different cut ID starting from 1
    // cut ID 0 is reserved for the case of no cuts
    // In case we have a jet container attached we check whether the track is
    // found in a jet, and check for different cone radii around a jet
    if(fListTrackCuts && fListTrackCuts->GetEntries()){
      for(int icut = 0; icut < fListTrackCuts->GetEntries(); icut++){
        AliEMCalPtTaskVTrackSelection *trackSelection = static_cast<AliEMCalPtTaskVTrackSelection *>(fListTrackCuts->At(icut));
        TIter trackIter(trackSelection->GetAcceptedTracks(fTracks));
        while((track = dynamic_cast<AliVTrack *>(trackIter()))){
          if(fMCEvent && !IsTrueTrack(track)) continue;   // Reject fake tracks in case of MC
          if(!fEtaRange.IsInRange(track->Eta())) continue;
          if(!fPtRange.IsInRange(track->Pt())) continue;
          coneradii.clear();
          if(this->fJetCollArray.GetEntries() &&
              (jetContData = dynamic_cast<AliJetContainer *>(this->fJetCollArray.FindObject((static_cast<TObjString *>(this->fJetContainersData.At(0)))->String().Data())))){
            foundJet = FoundTrackInJet(track, jetContData);
            if(foundJet){
              for(int irad = 0; irad < kNJetRadii; irad++){
                if(IsInRadius(track, foundJet, kJetRadii[irad])) coneradii.push_back(kJetRadii[irad]);
              }
            }
          }
          if(triggers[0]){
            FillTrackHist("MinBias", track, zv, isPileupEvent, icut + 1, triggers[0]);
            if(coneradii.size()){
              for(std::vector<double>::iterator radIter = coneradii.begin(); radIter != coneradii.end(); radIter++)
                FillTrackHist("MinBias", track, zv, isPileupEvent, icut + 1, triggers[0], *radIter);
            }
          }
          if(!triggerstrings.size()){ // Non-EMCal-triggered
            FillTrackHist("NoEMCal", track, zv, isPileupEvent, icut + 1, triggers[0]);
            for(std::vector<double>::iterator radIter = coneradii.begin(); radIter != coneradii.end(); radIter++)
              FillTrackHist("NoEMCal", track, zv, isPileupEvent, icut + 1, triggers[0], *radIter);
          } else {
            // EMCal-triggered events
            for(std::vector<std::string>::iterator it = triggerstrings.begin(); it != triggerstrings.end(); ++it){
              FillTrackHist(it->c_str(), track, zv, isPileupEvent, icut + 1, triggers[0]);
              for(std::vector<double>::iterator radIter = coneradii.begin(); radIter != coneradii.end(); radIter++)
                FillTrackHist(it->c_str(), track, zv, isPileupEvent, icut + 1, triggers[0], *radIter);
            }
          }
        }
      }
    }

    // Next step we loop over the (uncalibrated) emcal clusters and fill histograms with the cluster energy
    const AliVCluster *clust(NULL);
    for(int icl = 0; icl < fInputEvent->GetNumberOfCaloClusters(); icl++){
      clust = fInputEvent->GetCaloCluster(icl);
      if(!clust->IsEMCAL()) continue;
      if(!fEnergyRange.IsInRange(clust->E())) continue;
      if(triggers[0]) FillClusterHist("hClusterUncalibHistMinBias", clust, zv, isPileupEvent, triggers[0]);
      if(!triggerstrings.size()){	// Non-EMCal-triggered
        FillClusterHist("hClusterUncalibHistNoEMCal", clust, zv, isPileupEvent, triggers[0]);
      } else{
        for(std::vector<std::string>::iterator it = triggerstrings.begin(); it != triggerstrings.end(); ++it){
          sprintf(histname, "hClusterUncalibHist%s", it->c_str());
          FillClusterHist(histname, clust, zv, isPileupEvent, triggers[0]);
        }
      }
    }

    if(fCaloClusters){
      TIter clustIter(fCaloClusters);
      while((clust = dynamic_cast<const AliVCluster *>(clustIter()))){
        if(!clust->IsEMCAL()) continue;
        if(!fEnergyRange.IsInRange(clust->E())) continue;
        if(triggers[0]) FillClusterHist("hClusterCalibHistMinBias", clust, zv, isPileupEvent, triggers[0]);
        if(!triggerstrings.size())	// Non-EMCal-triggered
          FillClusterHist("hClusterCalibHistNoEMCal", clust, zv, isPileupEvent, triggers[0]);
        else{
          for(std::vector<std::string>::iterator it = triggerstrings.begin(); it != triggerstrings.end(); ++it){
            sprintf(histname, "hClusterCalibHist%s", it->c_str());
            FillClusterHist(histname, clust, zv, isPileupEvent, triggers[0]);
          }
        }
      }
    }

    PostData(1, fOutput);
    return true;
  }

  //______________________________________________________________________________
  void AliAnalysisTaskPtEMCalTrigger::CreateDefaultPtBinning(TArrayD &binning) const{
    /*
     * Creating the default pt binning.
     *
     * @param binning: Array where to store the results.
     */
    std::vector<double> mybinning;
    std::map<double,double> definitions;
    definitions.insert(std::pair<double,double>(2.5, 0.1));
    definitions.insert(std::pair<double,double>(7., 0.25));
    definitions.insert(std::pair<double,double>(15., 0.5));
    definitions.insert(std::pair<double,double>(25., 1.));
    definitions.insert(std::pair<double,double>(40., 2.5));
    definitions.insert(std::pair<double,double>(50., 5.));
    definitions.insert(std::pair<double,double>(100., 10.));
    double currentval = 0;
    for(std::map<double,double>::iterator id = definitions.begin(); id != definitions.end(); ++id){
      double limit = id->first, binwidth = id->second;
      while(currentval < limit){
        currentval += binwidth;
        mybinning.push_back(currentval);
      }
    }
    binning.Set(mybinning.size());
    int ib = 0;
    for(std::vector<double>::iterator it = mybinning.begin(); it != mybinning.end(); ++it)
      binning[ib++] = *it;
  }

  //______________________________________________________________________________
  void AliAnalysisTaskPtEMCalTrigger::CreateDefaultZVertexBinning(TArrayD &binning) const {
    /*
     * Creating default z-Vertex binning.
     *
     * @param binning: Array where to store the results.
     */
    std::vector<double> mybinning;
    double currentval = -10;
    mybinning.push_back(currentval);
    while(currentval <= 10.){
      currentval += 5.;
      mybinning.push_back(currentval);
    }
    binning.Set(mybinning.size());
    int ib = 0;
    for(std::vector<double>::iterator it = mybinning.begin(); it != mybinning.end(); ++it)
      binning[ib++] = *it;
  }

  //______________________________________________________________________________
  void AliAnalysisTaskPtEMCalTrigger::CreateDefaultEtaBinning(TArrayD& binning) const {
    /*
     * Creating default z-Vertex binning.
     *
     * @param binning: Array where to store the results.
     */
    std::vector<double> mybinning;
    double currentval = -0.8;
    mybinning.push_back(currentval);
    while(currentval <= 0.8){
      currentval += 0.1;
      mybinning.push_back(currentval);
    }
    binning.Set(mybinning.size());
    int ib = 0;
    for(std::vector<double>::iterator it = mybinning.begin(); it != mybinning.end(); ++it)
      binning[ib++] = *it;
  }

  //______________________________________________________________________________
  void AliAnalysisTaskPtEMCalTrigger::DefineAxis(TAxis& axis, const char* name,
      const char* title, const TArrayD& binning, const char** labels) {
    /*
     * Define an axis with a given binning
     *
     * @param axis: Axis to be defined
     * @param name: Name of the axis
     * @param title: Title of the axis
     * @param binning: axis binning
     * @param labels (@optional): array of bin labels
     */
    axis.Set(binning.GetSize()-1, binning.GetArray());
    axis.SetName(name);
    axis.SetTitle(title);
    if(labels){
      for(int ib = 1; ib <= axis.GetNbins(); ++ib)
        axis.SetBinLabel(ib, labels[ib-1]);
    }
  }

  //______________________________________________________________________________
  void AliAnalysisTaskPtEMCalTrigger::DefineAxis(TAxis& axis, const char* name,
      const char* title, int nbins, double min, double max,
      const char** labels) {
    /*
     * Define an axis with number of bins from min to max
     *
     * @param axis: Axis to be defined
     * @param name: Name of the axis
     * @param title: Title of the axis
     * @param nbins: Number of bins
     * @param min: lower limit of the axis
     * @param max: upper limit of the axis
     * @param labels (@optional): array of bin labels
     */
    axis.Set(nbins, min, max);
    axis.SetName(name);
    axis.SetTitle(title);
    if(labels){
      for(int ib = 1; ib <= axis.GetNbins(); ++ib)
        axis.SetBinLabel(ib, labels[ib-1]);
    }
  }


  //______________________________________________________________________________
  void AliAnalysisTaskPtEMCalTrigger::FillEventHist(const char* trigger,
      double vz, bool isPileup) {
    /*
     * Fill event-based histogram
     *
     * @param trigger: name of the trigger configuration to be processed
     * @param vz: z-position of the vertex
     * @param isPileup: signalises if the event is flagged as pileup event
     */
    char histname[1024];
    sprintf(histname, "hEventHist%s", trigger);
    try{
      fHistos->FillTH2(histname, 0., vz);
    } catch (HistoContainerContentException &e){
      std::stringstream errormessage;
      errormessage << "Filling of histogram failed: " << e.what();
      AliError(errormessage.str().c_str());
    }
    if(!isPileup){
      try{
        fHistos->FillTH2(histname, 1., vz);
      } catch(HistoContainerContentException &e){
        std::stringstream errormessage;
        errormessage << "Filling of histogram failed: " << e.what();
        AliError(errormessage.str().c_str());
      }
    }
  }

  //______________________________________________________________________________
  void AliAnalysisTaskPtEMCalTrigger::FillTrackHist(const char* trigger,
      const AliVTrack* track, double vz, bool isPileup, int cut, bool isMinBias, double jetradius) {
    /*
     * Fill track-based histogram with corresponding information
     *
     * @param trigger: name of the trigger
     * @param track: ESD track selected
     * @param vz: z-position of the vertex
     * @param isPileup: flag event as pileup event
     * @param cut: id of the cut (0 = no cut)
     */
    double etasign = fSwapEta ? -1. : 1.;
    double data[7] = {TMath::Abs(track->Pt()), etasign * track->Eta(), track->Phi(), vz, 0, static_cast<double>(cut), isMinBias ? 1. : 0.};
    double dataMC[7] = {0., 0., 0., vz, 0, static_cast<double>(cut), isMinBias ? 1. : 0.};
    AliVParticle *assocMC(NULL);
    if(fMCEvent && (assocMC = fMCEvent->GetTrack(TMath::Abs(track->GetLabel())))){
      // Select track onl
      dataMC[0] = TMath::Abs(assocMC->Pt());
      dataMC[1] = etasign * assocMC->Eta();
      dataMC[2] = assocMC->Phi();
    }
    char histname[1024], histnameAcc[1024], histnameMC[1024], histnameMCAcc[1024];
    sprintf(histname, "hTrackHist%s", trigger);
    sprintf(histnameAcc, "hTrackInAcceptanceHist%s", trigger);
    sprintf(histnameMC, "hMCTrackHist%s", trigger);
    sprintf(histnameMCAcc, "hMCTrackInAcceptanceHist%s", trigger);
    if(jetradius > 0.){
      char *hnames[] = {histname, histnameAcc, histnameMC, histnameMCAcc};
      for(unsigned int iname = 0; iname < sizeof(hnames)/sizeof(char *); iname++){
        char *myhname = hnames[iname];
        sprintf(myhname, "%sRad%02d", myhname, int(jetradius * 10.));
      }
    }
    Bool_t isEMCAL = kFALSE;
    if(track->IsEMCAL()){
      // Check if the cluster is matched to only one track
      AliVCluster *emcclust(NULL);
      AliDebug(2, Form("cluster id: %d\n", track->GetEMCALcluster()));
      if(fCaloClusters) {
        AliDebug(2, "Using calibrated clusters");
        emcclust = dynamic_cast<AliVCluster *>(fCaloClusters->At(track->GetEMCALcluster()));
      } else {
        AliDebug(2, "Using uncalibrated clusters");
        emcclust = fInputEvent->GetCaloCluster(track->GetEMCALcluster());
      }
      if(!emcclust) AliError("Null pointer to EMCal cluster");
      if(emcclust && emcclust->GetNTracksMatched() <= 1){
        isEMCAL = kTRUE;
      }
    }
    try{
      fHistos->FillTHnSparse(histname, data);
      if(fMCEvent) fHistos->FillTHnSparse(histnameMC, dataMC);
      if(isEMCAL){
        fHistos->FillTHnSparse(histnameAcc, data);
        if(fMCEvent) fHistos->FillTHnSparse(histnameMCAcc, dataMC);
      }
    } catch (HistoContainerContentException &e){
      std::stringstream errormessage;
      errormessage << "Filling of histogram failed: " << e.what();
      AliError(errormessage.str().c_str());
    }
    if(!isPileup){
      data[4] = 1;
      dataMC[4] = 1;
      try{
        fHistos->FillTHnSparse(histname, data);
        if(fMCEvent) fHistos->FillTHnSparse(histnameMC, dataMC);
        if(isEMCAL){
          fHistos->FillTHnSparse(histnameAcc, data);
          if(fMCEvent) fHistos->FillTHnSparse(histnameMCAcc, dataMC);
        }
      } catch (HistoContainerContentException &e){
        std::stringstream errormessage;
        errormessage << "Filling of histogram failed: " << e.what();
        AliError(errormessage.str().c_str());
      }
    }
  }

  //______________________________________________________________________________
  void AliAnalysisTaskPtEMCalTrigger::FillClusterHist(const char* histname,
      const AliVCluster* clust, double vz, bool isPileup, bool isMinBias) {
    /*
     * Fill cluster-based histogram with corresponding information
     *
     * @param trigger: name of the trigger
     * @param cluster: the EMCal cluster information
     * @param vz: z-position of the vertex
     * @param isPileup: flag event as pileup event
     */
    double data[4] =  {clust->E(), vz, 0, isMinBias ? 1. : 0.};
    try{
      fHistos->FillTHnSparse(histname, data);
    } catch (HistoContainerContentException &e){
      std::stringstream errormessage;
      errormessage << "Filling of histogram failed: " << e.what();
      AliError(errormessage.str().c_str());
    }
    if(!isPileup){
      data[2] = 1.;
      try{
        fHistos->FillTHnSparse(histname, data);
      } catch (HistoContainerContentException &e){
        std::stringstream errormessage;
        errormessage << "Filling of histogram failed: " << e.what();
        AliError(errormessage.str().c_str());
      }
    }
  }

  //______________________________________________________________________________
  void AliAnalysisTaskPtEMCalTrigger::FillMCParticleHist(const char *histname, const AliVParticle * const track, double vz, bool isPileup){
    /*
     * Fill histogram for MC-true particles with the information pt, eta and phi
     *
     * @param track: the Monte-Carlo track
     */
    double data[5] = {TMath::Abs(track->Pt()), track->Eta(), track->Phi(), vz, 0.};
    fHistos->FillTHnSparse(histname, data);
    if(!isPileup){
      data[4] = 1.;
      fHistos->FillTHnSparse(histname, data);
    }
  }

  //______________________________________________________________________________
  bool AliAnalysisTaskPtEMCalTrigger::IsTrueTrack(const AliVTrack *const track) const{
    /*
     * Check if the track has an associated MC particle, and that the particle is a physical primary
     * In case of data we do not do the selection at that step (always return true)
     *
     * @param track: Track to check
     * @result: true primary track (true or false)
     */
    if(!fMCEvent) return true;
    AliVParticle *mcassociate = fMCEvent->GetTrack(TMath::Abs(track->GetLabel()));
    if(!mcassociate) return false;
    return fMCEvent->IsPhysicalPrimary(TMath::Abs(track->GetLabel()));
  }

  //______________________________________________________________________________
  void AliAnalysisTaskPtEMCalTrigger::AddESDTrackCuts(AliESDtrackCuts* trackCuts) {
    /*
     * Add new track cuts to the task
     *
     * @param trackCuts: Object of type AliESDtrackCuts
     */
    fListTrackCuts->AddLast(new AliEMCalPtTaskTrackSelectionESD(trackCuts));
  }

  //______________________________________________________________________________
  void AliAnalysisTaskPtEMCalTrigger::AddCutsForAOD(AliESDtrackCuts* trackCuts, UInt_t filterbits) {
    /*
     * Add new track cuts to the task
     *
     * @param trackCuts: Object of type AliESDtrackCuts
     */
    fListTrackCuts->AddLast(new AliEMCalPtTaskTrackSelectionAOD(trackCuts, filterbits));
  }


  //______________________________________________________________________________
  TString AliAnalysisTaskPtEMCalTrigger::BuildTriggerString() {
    /*
     * Build trigger string from the trigger maker
     *
     * @return: blank-separated string of fired trigger classes
     */
    AliDebug(1, "trigger checking");
    TString result = "";
    if(HasTriggerType(kJ1)) result += "EJ1 ";
    if(HasTriggerType(kJ2)) result += "EJ2 ";
    if(HasTriggerType(kG1)) result += "EG1 ";
    if(HasTriggerType(kG2)) result += "EG2 ";
    return result;
  }

  //______________________________________________________________________________
  const AliVVertex* AliAnalysisTaskPtEMCalTrigger::GetSPDVertex() const {
    /*
     * Accessor for the SPD vertex, creating transparency for ESDs and AODs
     *
     * @return: the spd vertex
     */
    AliESDEvent *esd = dynamic_cast<AliESDEvent *>(fInputEvent);
    if(esd){
      return esd->GetPrimaryVertexSPD();
    } else {
      AliAODEvent *aod = dynamic_cast<AliAODEvent *>(fInputEvent);
      if(aod){
        return aod->GetPrimaryVertexSPD();
      }
    }
    return NULL;
  }

  //______________________________________________________________________________
  const AliEmcalJet * AliAnalysisTaskPtEMCalTrigger::FoundTrackInJet(
      const AliVParticle * const track, AliJetContainer *const jets) const
  {
    /*
     * Correlate track to reconstructed jet
     *
     * @param track: particle to be checked
     * @param jets: container of recontructed jets
     * @return: The matched jet (NULL if not found)
     */
    const AliEmcalJet *result = NULL;
    const AliEmcalJet *tmp = jets->GetNextAcceptJet(0);
    while(tmp){
      if(TrackInJet(track, tmp, jets->GetParticleContainer())){
        result = tmp;
        break;
      }
      tmp = jets->GetNextAcceptJet();
    }
    return result;
  }

  //______________________________________________________________________________
  bool AliAnalysisTaskPtEMCalTrigger::IsInRadius(const AliVParticle *const track, const AliEmcalJet *reconstructedJet, Double_t radius) const {
    /*
     * Check if track is in radius around a given jet
     *
     * @param track: Track to check
     * @param reconstructed jet: jet to probe
     * @param radius: cone radius
     * @return: result of the test (true if track is inside the cone radius, false otherwise)
     */
    return reconstructedJet->DeltaR(track) < radius;
  }

  //______________________________________________________________________________
  bool AliAnalysisTaskPtEMCalTrigger::IsInRadius(const AliVCluster *const clust, const AliEmcalJet *reconstructedJet, Double_t radius) const {
    /*
     * Check if track is in radius around a given jet
     *
     * @param track: Track to check
     * @param reconstructed jet: jet to probe
     * @param radius: cone radius
     * @return: result of the test (true if track is inside the cone radius, false otherwise)
     */
    double vertexPos[3];
    fInputEvent->GetPrimaryVertex()->GetXYZ(vertexPos);
    TLorentzVector clustVect;
    clust->GetMomentum(clustVect, vertexPos);

    Double_t dPhi = reconstructedJet->Phi() - clustVect.Phi();
    Double_t dEta = reconstructedJet->Eta() - clustVect.Eta();
    dPhi = TVector2::Phi_mpi_pi ( dPhi );

    double deltaR = TMath::Sqrt ( dPhi * dPhi + dEta * dEta );
    return deltaR < radius;
  }

  //______________________________________________________________________________
  bool AliAnalysisTaskPtEMCalTrigger::TrackInJet(const AliVParticle* const track,
      const AliEmcalJet* reconstructedJet, const AliParticleContainer * const particles) const {
    /*
     * Check whether track is among the jet constituents
     *
     * @param track: track to check
     * @param reconstructedJet: reconstructed jet to check
     * @param tracks: container with tracks used for jetfinding
     * @return: true if found, false otherwise
     */
    bool found = false;
    const AliPicoTrack *picotmp(NULL);
    const AliVParticle *tmp(NULL);
    for(int ipart = 0; ipart < reconstructedJet->GetNumberOfTracks(); ipart++){
      tmp = dynamic_cast<const AliVParticle *>(reconstructedJet->TrackAt(ipart, particles->GetArray()));
      if((picotmp = dynamic_cast<const AliPicoTrack *>(tmp)))   // handle pico tracks
        tmp = picotmp->GetTrack();
      if(!tmp->Compare(track)){
        found = true;
        break;
      }
    }
    return found;
  }

  //______________________________________________________________________________
  const AliEmcalJet* AliAnalysisTaskPtEMCalTrigger::FoundClusterInJet(const AliVCluster* const clust, AliJetContainer* const jets) const {
    /*
     * Check whether a cluster is in a radius around a given jet
     *
     * @param clust: The cluster to check
     * @param reconstructedJet: reconstructed jet to check
     * @return: the jet containing the cluster (null otherwise)
     */
    const AliEmcalJet *result = NULL;
    const AliEmcalJet *tmp = jets->GetNextAcceptJet(0);
    while(tmp){
      if(ClusterInJet(clust, tmp, jets->GetClusterContainer())){
        result = tmp;
        break;
      }
      tmp =jets->GetNextAcceptJet();
    }
    return result;
  }

  //______________________________________________________________________________
  bool AliAnalysisTaskPtEMCalTrigger::ClusterInJet(const AliVCluster* const clust,
      const AliEmcalJet* reconstructedJet, const AliClusterContainer* const clusters) const {
    /*
     * Check whether cluster is among the jet constituents
     *
     * @param track: track to check
     * @param reconstructedJet: reconstructed jet to check
     * @param clusters: the cluster container
     * @return: true if found, false otherwise
     */
    bool found = false;
    const AliVCluster *tmp(NULL);
    for(int ipart = 0; ipart < reconstructedJet->GetNumberOfTracks(); ipart++){
      tmp = dynamic_cast<const AliVCluster *>(reconstructedJet->ClusterAt(ipart, clusters->GetArray()));
      if(!tmp->Compare(clust)){
        found = true;
        break;
      }
    }
    return found;
  }

  //______________________________________________________________________________
  void EMCalTriggerPtAnalysis::AliAnalysisTaskPtEMCalTrigger::AddJetContainerName(const Char_t* contname, Bool_t isMC) {
    /*
     * Add new Jet input container to the analysis task
     *
     * @param contname: Name of the container
     * @param isMC: Defines whether the container is for MC truth or not
     */
    TList &mycontainer = isMC ? fJetContainersMC : fJetContainersData;
    mycontainer.Add(new TObjString(contname));
  }
}
 AliAnalysisTaskPtEMCalTrigger.cxx:1
 AliAnalysisTaskPtEMCalTrigger.cxx:2
 AliAnalysisTaskPtEMCalTrigger.cxx:3
 AliAnalysisTaskPtEMCalTrigger.cxx:4
 AliAnalysisTaskPtEMCalTrigger.cxx:5
 AliAnalysisTaskPtEMCalTrigger.cxx:6
 AliAnalysisTaskPtEMCalTrigger.cxx:7
 AliAnalysisTaskPtEMCalTrigger.cxx:8
 AliAnalysisTaskPtEMCalTrigger.cxx:9
 AliAnalysisTaskPtEMCalTrigger.cxx:10
 AliAnalysisTaskPtEMCalTrigger.cxx:11
 AliAnalysisTaskPtEMCalTrigger.cxx:12
 AliAnalysisTaskPtEMCalTrigger.cxx:13
 AliAnalysisTaskPtEMCalTrigger.cxx:14
 AliAnalysisTaskPtEMCalTrigger.cxx:15
 AliAnalysisTaskPtEMCalTrigger.cxx:16
 AliAnalysisTaskPtEMCalTrigger.cxx:17
 AliAnalysisTaskPtEMCalTrigger.cxx:18
 AliAnalysisTaskPtEMCalTrigger.cxx:19
 AliAnalysisTaskPtEMCalTrigger.cxx:20
 AliAnalysisTaskPtEMCalTrigger.cxx:21
 AliAnalysisTaskPtEMCalTrigger.cxx:22
 AliAnalysisTaskPtEMCalTrigger.cxx:23
 AliAnalysisTaskPtEMCalTrigger.cxx:24
 AliAnalysisTaskPtEMCalTrigger.cxx:25
 AliAnalysisTaskPtEMCalTrigger.cxx:26
 AliAnalysisTaskPtEMCalTrigger.cxx:27
 AliAnalysisTaskPtEMCalTrigger.cxx:28
 AliAnalysisTaskPtEMCalTrigger.cxx:29
 AliAnalysisTaskPtEMCalTrigger.cxx:30
 AliAnalysisTaskPtEMCalTrigger.cxx:31
 AliAnalysisTaskPtEMCalTrigger.cxx:32
 AliAnalysisTaskPtEMCalTrigger.cxx:33
 AliAnalysisTaskPtEMCalTrigger.cxx:34
 AliAnalysisTaskPtEMCalTrigger.cxx:35
 AliAnalysisTaskPtEMCalTrigger.cxx:36
 AliAnalysisTaskPtEMCalTrigger.cxx:37
 AliAnalysisTaskPtEMCalTrigger.cxx:38
 AliAnalysisTaskPtEMCalTrigger.cxx:39
 AliAnalysisTaskPtEMCalTrigger.cxx:40
 AliAnalysisTaskPtEMCalTrigger.cxx:41
 AliAnalysisTaskPtEMCalTrigger.cxx:42
 AliAnalysisTaskPtEMCalTrigger.cxx:43
 AliAnalysisTaskPtEMCalTrigger.cxx:44
 AliAnalysisTaskPtEMCalTrigger.cxx:45
 AliAnalysisTaskPtEMCalTrigger.cxx:46
 AliAnalysisTaskPtEMCalTrigger.cxx:47
 AliAnalysisTaskPtEMCalTrigger.cxx:48
 AliAnalysisTaskPtEMCalTrigger.cxx:49
 AliAnalysisTaskPtEMCalTrigger.cxx:50
 AliAnalysisTaskPtEMCalTrigger.cxx:51
 AliAnalysisTaskPtEMCalTrigger.cxx:52
 AliAnalysisTaskPtEMCalTrigger.cxx:53
 AliAnalysisTaskPtEMCalTrigger.cxx:54
 AliAnalysisTaskPtEMCalTrigger.cxx:55
 AliAnalysisTaskPtEMCalTrigger.cxx:56
 AliAnalysisTaskPtEMCalTrigger.cxx:57
 AliAnalysisTaskPtEMCalTrigger.cxx:58
 AliAnalysisTaskPtEMCalTrigger.cxx:59
 AliAnalysisTaskPtEMCalTrigger.cxx:60
 AliAnalysisTaskPtEMCalTrigger.cxx:61
 AliAnalysisTaskPtEMCalTrigger.cxx:62
 AliAnalysisTaskPtEMCalTrigger.cxx:63
 AliAnalysisTaskPtEMCalTrigger.cxx:64
 AliAnalysisTaskPtEMCalTrigger.cxx:65
 AliAnalysisTaskPtEMCalTrigger.cxx:66
 AliAnalysisTaskPtEMCalTrigger.cxx:67
 AliAnalysisTaskPtEMCalTrigger.cxx:68
 AliAnalysisTaskPtEMCalTrigger.cxx:69
 AliAnalysisTaskPtEMCalTrigger.cxx:70
 AliAnalysisTaskPtEMCalTrigger.cxx:71
 AliAnalysisTaskPtEMCalTrigger.cxx:72
 AliAnalysisTaskPtEMCalTrigger.cxx:73
 AliAnalysisTaskPtEMCalTrigger.cxx:74
 AliAnalysisTaskPtEMCalTrigger.cxx:75
 AliAnalysisTaskPtEMCalTrigger.cxx:76
 AliAnalysisTaskPtEMCalTrigger.cxx:77
 AliAnalysisTaskPtEMCalTrigger.cxx:78
 AliAnalysisTaskPtEMCalTrigger.cxx:79
 AliAnalysisTaskPtEMCalTrigger.cxx:80
 AliAnalysisTaskPtEMCalTrigger.cxx:81
 AliAnalysisTaskPtEMCalTrigger.cxx:82
 AliAnalysisTaskPtEMCalTrigger.cxx:83
 AliAnalysisTaskPtEMCalTrigger.cxx:84
 AliAnalysisTaskPtEMCalTrigger.cxx:85
 AliAnalysisTaskPtEMCalTrigger.cxx:86
 AliAnalysisTaskPtEMCalTrigger.cxx:87
 AliAnalysisTaskPtEMCalTrigger.cxx:88
 AliAnalysisTaskPtEMCalTrigger.cxx:89
 AliAnalysisTaskPtEMCalTrigger.cxx:90
 AliAnalysisTaskPtEMCalTrigger.cxx:91
 AliAnalysisTaskPtEMCalTrigger.cxx:92
 AliAnalysisTaskPtEMCalTrigger.cxx:93
 AliAnalysisTaskPtEMCalTrigger.cxx:94
 AliAnalysisTaskPtEMCalTrigger.cxx:95
 AliAnalysisTaskPtEMCalTrigger.cxx:96
 AliAnalysisTaskPtEMCalTrigger.cxx:97
 AliAnalysisTaskPtEMCalTrigger.cxx:98
 AliAnalysisTaskPtEMCalTrigger.cxx:99
 AliAnalysisTaskPtEMCalTrigger.cxx:100
 AliAnalysisTaskPtEMCalTrigger.cxx:101
 AliAnalysisTaskPtEMCalTrigger.cxx:102
 AliAnalysisTaskPtEMCalTrigger.cxx:103
 AliAnalysisTaskPtEMCalTrigger.cxx:104
 AliAnalysisTaskPtEMCalTrigger.cxx:105
 AliAnalysisTaskPtEMCalTrigger.cxx:106
 AliAnalysisTaskPtEMCalTrigger.cxx:107
 AliAnalysisTaskPtEMCalTrigger.cxx:108
 AliAnalysisTaskPtEMCalTrigger.cxx:109
 AliAnalysisTaskPtEMCalTrigger.cxx:110
 AliAnalysisTaskPtEMCalTrigger.cxx:111
 AliAnalysisTaskPtEMCalTrigger.cxx:112
 AliAnalysisTaskPtEMCalTrigger.cxx:113
 AliAnalysisTaskPtEMCalTrigger.cxx:114
 AliAnalysisTaskPtEMCalTrigger.cxx:115
 AliAnalysisTaskPtEMCalTrigger.cxx:116
 AliAnalysisTaskPtEMCalTrigger.cxx:117
 AliAnalysisTaskPtEMCalTrigger.cxx:118
 AliAnalysisTaskPtEMCalTrigger.cxx:119
 AliAnalysisTaskPtEMCalTrigger.cxx:120
 AliAnalysisTaskPtEMCalTrigger.cxx:121
 AliAnalysisTaskPtEMCalTrigger.cxx:122
 AliAnalysisTaskPtEMCalTrigger.cxx:123
 AliAnalysisTaskPtEMCalTrigger.cxx:124
 AliAnalysisTaskPtEMCalTrigger.cxx:125
 AliAnalysisTaskPtEMCalTrigger.cxx:126
 AliAnalysisTaskPtEMCalTrigger.cxx:127
 AliAnalysisTaskPtEMCalTrigger.cxx:128
 AliAnalysisTaskPtEMCalTrigger.cxx:129
 AliAnalysisTaskPtEMCalTrigger.cxx:130
 AliAnalysisTaskPtEMCalTrigger.cxx:131
 AliAnalysisTaskPtEMCalTrigger.cxx:132
 AliAnalysisTaskPtEMCalTrigger.cxx:133
 AliAnalysisTaskPtEMCalTrigger.cxx:134
 AliAnalysisTaskPtEMCalTrigger.cxx:135
 AliAnalysisTaskPtEMCalTrigger.cxx:136
 AliAnalysisTaskPtEMCalTrigger.cxx:137
 AliAnalysisTaskPtEMCalTrigger.cxx:138
 AliAnalysisTaskPtEMCalTrigger.cxx:139
 AliAnalysisTaskPtEMCalTrigger.cxx:140
 AliAnalysisTaskPtEMCalTrigger.cxx:141
 AliAnalysisTaskPtEMCalTrigger.cxx:142
 AliAnalysisTaskPtEMCalTrigger.cxx:143
 AliAnalysisTaskPtEMCalTrigger.cxx:144
 AliAnalysisTaskPtEMCalTrigger.cxx:145
 AliAnalysisTaskPtEMCalTrigger.cxx:146
 AliAnalysisTaskPtEMCalTrigger.cxx:147
 AliAnalysisTaskPtEMCalTrigger.cxx:148
 AliAnalysisTaskPtEMCalTrigger.cxx:149
 AliAnalysisTaskPtEMCalTrigger.cxx:150
 AliAnalysisTaskPtEMCalTrigger.cxx:151
 AliAnalysisTaskPtEMCalTrigger.cxx:152
 AliAnalysisTaskPtEMCalTrigger.cxx:153
 AliAnalysisTaskPtEMCalTrigger.cxx:154
 AliAnalysisTaskPtEMCalTrigger.cxx:155
 AliAnalysisTaskPtEMCalTrigger.cxx:156
 AliAnalysisTaskPtEMCalTrigger.cxx:157
 AliAnalysisTaskPtEMCalTrigger.cxx:158
 AliAnalysisTaskPtEMCalTrigger.cxx:159
 AliAnalysisTaskPtEMCalTrigger.cxx:160
 AliAnalysisTaskPtEMCalTrigger.cxx:161
 AliAnalysisTaskPtEMCalTrigger.cxx:162
 AliAnalysisTaskPtEMCalTrigger.cxx:163
 AliAnalysisTaskPtEMCalTrigger.cxx:164
 AliAnalysisTaskPtEMCalTrigger.cxx:165
 AliAnalysisTaskPtEMCalTrigger.cxx:166
 AliAnalysisTaskPtEMCalTrigger.cxx:167
 AliAnalysisTaskPtEMCalTrigger.cxx:168
 AliAnalysisTaskPtEMCalTrigger.cxx:169
 AliAnalysisTaskPtEMCalTrigger.cxx:170
 AliAnalysisTaskPtEMCalTrigger.cxx:171
 AliAnalysisTaskPtEMCalTrigger.cxx:172
 AliAnalysisTaskPtEMCalTrigger.cxx:173
 AliAnalysisTaskPtEMCalTrigger.cxx:174
 AliAnalysisTaskPtEMCalTrigger.cxx:175
 AliAnalysisTaskPtEMCalTrigger.cxx:176
 AliAnalysisTaskPtEMCalTrigger.cxx:177
 AliAnalysisTaskPtEMCalTrigger.cxx:178
 AliAnalysisTaskPtEMCalTrigger.cxx:179
 AliAnalysisTaskPtEMCalTrigger.cxx:180
 AliAnalysisTaskPtEMCalTrigger.cxx:181
 AliAnalysisTaskPtEMCalTrigger.cxx:182
 AliAnalysisTaskPtEMCalTrigger.cxx:183
 AliAnalysisTaskPtEMCalTrigger.cxx:184
 AliAnalysisTaskPtEMCalTrigger.cxx:185
 AliAnalysisTaskPtEMCalTrigger.cxx:186
 AliAnalysisTaskPtEMCalTrigger.cxx:187
 AliAnalysisTaskPtEMCalTrigger.cxx:188
 AliAnalysisTaskPtEMCalTrigger.cxx:189
 AliAnalysisTaskPtEMCalTrigger.cxx:190
 AliAnalysisTaskPtEMCalTrigger.cxx:191
 AliAnalysisTaskPtEMCalTrigger.cxx:192
 AliAnalysisTaskPtEMCalTrigger.cxx:193
 AliAnalysisTaskPtEMCalTrigger.cxx:194
 AliAnalysisTaskPtEMCalTrigger.cxx:195
 AliAnalysisTaskPtEMCalTrigger.cxx:196
 AliAnalysisTaskPtEMCalTrigger.cxx:197
 AliAnalysisTaskPtEMCalTrigger.cxx:198
 AliAnalysisTaskPtEMCalTrigger.cxx:199
 AliAnalysisTaskPtEMCalTrigger.cxx:200
 AliAnalysisTaskPtEMCalTrigger.cxx:201
 AliAnalysisTaskPtEMCalTrigger.cxx:202
 AliAnalysisTaskPtEMCalTrigger.cxx:203
 AliAnalysisTaskPtEMCalTrigger.cxx:204
 AliAnalysisTaskPtEMCalTrigger.cxx:205
 AliAnalysisTaskPtEMCalTrigger.cxx:206
 AliAnalysisTaskPtEMCalTrigger.cxx:207
 AliAnalysisTaskPtEMCalTrigger.cxx:208
 AliAnalysisTaskPtEMCalTrigger.cxx:209
 AliAnalysisTaskPtEMCalTrigger.cxx:210
 AliAnalysisTaskPtEMCalTrigger.cxx:211
 AliAnalysisTaskPtEMCalTrigger.cxx:212
 AliAnalysisTaskPtEMCalTrigger.cxx:213
 AliAnalysisTaskPtEMCalTrigger.cxx:214
 AliAnalysisTaskPtEMCalTrigger.cxx:215
 AliAnalysisTaskPtEMCalTrigger.cxx:216
 AliAnalysisTaskPtEMCalTrigger.cxx:217
 AliAnalysisTaskPtEMCalTrigger.cxx:218
 AliAnalysisTaskPtEMCalTrigger.cxx:219
 AliAnalysisTaskPtEMCalTrigger.cxx:220
 AliAnalysisTaskPtEMCalTrigger.cxx:221
 AliAnalysisTaskPtEMCalTrigger.cxx:222
 AliAnalysisTaskPtEMCalTrigger.cxx:223
 AliAnalysisTaskPtEMCalTrigger.cxx:224
 AliAnalysisTaskPtEMCalTrigger.cxx:225
 AliAnalysisTaskPtEMCalTrigger.cxx:226
 AliAnalysisTaskPtEMCalTrigger.cxx:227
 AliAnalysisTaskPtEMCalTrigger.cxx:228
 AliAnalysisTaskPtEMCalTrigger.cxx:229
 AliAnalysisTaskPtEMCalTrigger.cxx:230
 AliAnalysisTaskPtEMCalTrigger.cxx:231
 AliAnalysisTaskPtEMCalTrigger.cxx:232
 AliAnalysisTaskPtEMCalTrigger.cxx:233
 AliAnalysisTaskPtEMCalTrigger.cxx:234
 AliAnalysisTaskPtEMCalTrigger.cxx:235
 AliAnalysisTaskPtEMCalTrigger.cxx:236
 AliAnalysisTaskPtEMCalTrigger.cxx:237
 AliAnalysisTaskPtEMCalTrigger.cxx:238
 AliAnalysisTaskPtEMCalTrigger.cxx:239
 AliAnalysisTaskPtEMCalTrigger.cxx:240
 AliAnalysisTaskPtEMCalTrigger.cxx:241
 AliAnalysisTaskPtEMCalTrigger.cxx:242
 AliAnalysisTaskPtEMCalTrigger.cxx:243
 AliAnalysisTaskPtEMCalTrigger.cxx:244
 AliAnalysisTaskPtEMCalTrigger.cxx:245
 AliAnalysisTaskPtEMCalTrigger.cxx:246
 AliAnalysisTaskPtEMCalTrigger.cxx:247
 AliAnalysisTaskPtEMCalTrigger.cxx:248
 AliAnalysisTaskPtEMCalTrigger.cxx:249
 AliAnalysisTaskPtEMCalTrigger.cxx:250
 AliAnalysisTaskPtEMCalTrigger.cxx:251
 AliAnalysisTaskPtEMCalTrigger.cxx:252
 AliAnalysisTaskPtEMCalTrigger.cxx:253
 AliAnalysisTaskPtEMCalTrigger.cxx:254
 AliAnalysisTaskPtEMCalTrigger.cxx:255
 AliAnalysisTaskPtEMCalTrigger.cxx:256
 AliAnalysisTaskPtEMCalTrigger.cxx:257
 AliAnalysisTaskPtEMCalTrigger.cxx:258
 AliAnalysisTaskPtEMCalTrigger.cxx:259
 AliAnalysisTaskPtEMCalTrigger.cxx:260
 AliAnalysisTaskPtEMCalTrigger.cxx:261
 AliAnalysisTaskPtEMCalTrigger.cxx:262
 AliAnalysisTaskPtEMCalTrigger.cxx:263
 AliAnalysisTaskPtEMCalTrigger.cxx:264
 AliAnalysisTaskPtEMCalTrigger.cxx:265
 AliAnalysisTaskPtEMCalTrigger.cxx:266
 AliAnalysisTaskPtEMCalTrigger.cxx:267
 AliAnalysisTaskPtEMCalTrigger.cxx:268
 AliAnalysisTaskPtEMCalTrigger.cxx:269
 AliAnalysisTaskPtEMCalTrigger.cxx:270
 AliAnalysisTaskPtEMCalTrigger.cxx:271
 AliAnalysisTaskPtEMCalTrigger.cxx:272
 AliAnalysisTaskPtEMCalTrigger.cxx:273
 AliAnalysisTaskPtEMCalTrigger.cxx:274
 AliAnalysisTaskPtEMCalTrigger.cxx:275
 AliAnalysisTaskPtEMCalTrigger.cxx:276
 AliAnalysisTaskPtEMCalTrigger.cxx:277
 AliAnalysisTaskPtEMCalTrigger.cxx:278
 AliAnalysisTaskPtEMCalTrigger.cxx:279
 AliAnalysisTaskPtEMCalTrigger.cxx:280
 AliAnalysisTaskPtEMCalTrigger.cxx:281
 AliAnalysisTaskPtEMCalTrigger.cxx:282
 AliAnalysisTaskPtEMCalTrigger.cxx:283
 AliAnalysisTaskPtEMCalTrigger.cxx:284
 AliAnalysisTaskPtEMCalTrigger.cxx:285
 AliAnalysisTaskPtEMCalTrigger.cxx:286
 AliAnalysisTaskPtEMCalTrigger.cxx:287
 AliAnalysisTaskPtEMCalTrigger.cxx:288
 AliAnalysisTaskPtEMCalTrigger.cxx:289
 AliAnalysisTaskPtEMCalTrigger.cxx:290
 AliAnalysisTaskPtEMCalTrigger.cxx:291
 AliAnalysisTaskPtEMCalTrigger.cxx:292
 AliAnalysisTaskPtEMCalTrigger.cxx:293
 AliAnalysisTaskPtEMCalTrigger.cxx:294
 AliAnalysisTaskPtEMCalTrigger.cxx:295
 AliAnalysisTaskPtEMCalTrigger.cxx:296
 AliAnalysisTaskPtEMCalTrigger.cxx:297
 AliAnalysisTaskPtEMCalTrigger.cxx:298
 AliAnalysisTaskPtEMCalTrigger.cxx:299
 AliAnalysisTaskPtEMCalTrigger.cxx:300
 AliAnalysisTaskPtEMCalTrigger.cxx:301
 AliAnalysisTaskPtEMCalTrigger.cxx:302
 AliAnalysisTaskPtEMCalTrigger.cxx:303
 AliAnalysisTaskPtEMCalTrigger.cxx:304
 AliAnalysisTaskPtEMCalTrigger.cxx:305
 AliAnalysisTaskPtEMCalTrigger.cxx:306
 AliAnalysisTaskPtEMCalTrigger.cxx:307
 AliAnalysisTaskPtEMCalTrigger.cxx:308
 AliAnalysisTaskPtEMCalTrigger.cxx:309
 AliAnalysisTaskPtEMCalTrigger.cxx:310
 AliAnalysisTaskPtEMCalTrigger.cxx:311
 AliAnalysisTaskPtEMCalTrigger.cxx:312
 AliAnalysisTaskPtEMCalTrigger.cxx:313
 AliAnalysisTaskPtEMCalTrigger.cxx:314
 AliAnalysisTaskPtEMCalTrigger.cxx:315
 AliAnalysisTaskPtEMCalTrigger.cxx:316
 AliAnalysisTaskPtEMCalTrigger.cxx:317
 AliAnalysisTaskPtEMCalTrigger.cxx:318
 AliAnalysisTaskPtEMCalTrigger.cxx:319
 AliAnalysisTaskPtEMCalTrigger.cxx:320
 AliAnalysisTaskPtEMCalTrigger.cxx:321
 AliAnalysisTaskPtEMCalTrigger.cxx:322
 AliAnalysisTaskPtEMCalTrigger.cxx:323
 AliAnalysisTaskPtEMCalTrigger.cxx:324
 AliAnalysisTaskPtEMCalTrigger.cxx:325
 AliAnalysisTaskPtEMCalTrigger.cxx:326
 AliAnalysisTaskPtEMCalTrigger.cxx:327
 AliAnalysisTaskPtEMCalTrigger.cxx:328
 AliAnalysisTaskPtEMCalTrigger.cxx:329
 AliAnalysisTaskPtEMCalTrigger.cxx:330
 AliAnalysisTaskPtEMCalTrigger.cxx:331
 AliAnalysisTaskPtEMCalTrigger.cxx:332
 AliAnalysisTaskPtEMCalTrigger.cxx:333
 AliAnalysisTaskPtEMCalTrigger.cxx:334
 AliAnalysisTaskPtEMCalTrigger.cxx:335
 AliAnalysisTaskPtEMCalTrigger.cxx:336
 AliAnalysisTaskPtEMCalTrigger.cxx:337
 AliAnalysisTaskPtEMCalTrigger.cxx:338
 AliAnalysisTaskPtEMCalTrigger.cxx:339
 AliAnalysisTaskPtEMCalTrigger.cxx:340
 AliAnalysisTaskPtEMCalTrigger.cxx:341
 AliAnalysisTaskPtEMCalTrigger.cxx:342
 AliAnalysisTaskPtEMCalTrigger.cxx:343
 AliAnalysisTaskPtEMCalTrigger.cxx:344
 AliAnalysisTaskPtEMCalTrigger.cxx:345
 AliAnalysisTaskPtEMCalTrigger.cxx:346
 AliAnalysisTaskPtEMCalTrigger.cxx:347
 AliAnalysisTaskPtEMCalTrigger.cxx:348
 AliAnalysisTaskPtEMCalTrigger.cxx:349
 AliAnalysisTaskPtEMCalTrigger.cxx:350
 AliAnalysisTaskPtEMCalTrigger.cxx:351
 AliAnalysisTaskPtEMCalTrigger.cxx:352
 AliAnalysisTaskPtEMCalTrigger.cxx:353
 AliAnalysisTaskPtEMCalTrigger.cxx:354
 AliAnalysisTaskPtEMCalTrigger.cxx:355
 AliAnalysisTaskPtEMCalTrigger.cxx:356
 AliAnalysisTaskPtEMCalTrigger.cxx:357
 AliAnalysisTaskPtEMCalTrigger.cxx:358
 AliAnalysisTaskPtEMCalTrigger.cxx:359
 AliAnalysisTaskPtEMCalTrigger.cxx:360
 AliAnalysisTaskPtEMCalTrigger.cxx:361
 AliAnalysisTaskPtEMCalTrigger.cxx:362
 AliAnalysisTaskPtEMCalTrigger.cxx:363
 AliAnalysisTaskPtEMCalTrigger.cxx:364
 AliAnalysisTaskPtEMCalTrigger.cxx:365
 AliAnalysisTaskPtEMCalTrigger.cxx:366
 AliAnalysisTaskPtEMCalTrigger.cxx:367
 AliAnalysisTaskPtEMCalTrigger.cxx:368
 AliAnalysisTaskPtEMCalTrigger.cxx:369
 AliAnalysisTaskPtEMCalTrigger.cxx:370
 AliAnalysisTaskPtEMCalTrigger.cxx:371
 AliAnalysisTaskPtEMCalTrigger.cxx:372
 AliAnalysisTaskPtEMCalTrigger.cxx:373
 AliAnalysisTaskPtEMCalTrigger.cxx:374
 AliAnalysisTaskPtEMCalTrigger.cxx:375
 AliAnalysisTaskPtEMCalTrigger.cxx:376
 AliAnalysisTaskPtEMCalTrigger.cxx:377
 AliAnalysisTaskPtEMCalTrigger.cxx:378
 AliAnalysisTaskPtEMCalTrigger.cxx:379
 AliAnalysisTaskPtEMCalTrigger.cxx:380
 AliAnalysisTaskPtEMCalTrigger.cxx:381
 AliAnalysisTaskPtEMCalTrigger.cxx:382
 AliAnalysisTaskPtEMCalTrigger.cxx:383
 AliAnalysisTaskPtEMCalTrigger.cxx:384
 AliAnalysisTaskPtEMCalTrigger.cxx:385
 AliAnalysisTaskPtEMCalTrigger.cxx:386
 AliAnalysisTaskPtEMCalTrigger.cxx:387
 AliAnalysisTaskPtEMCalTrigger.cxx:388
 AliAnalysisTaskPtEMCalTrigger.cxx:389
 AliAnalysisTaskPtEMCalTrigger.cxx:390
 AliAnalysisTaskPtEMCalTrigger.cxx:391
 AliAnalysisTaskPtEMCalTrigger.cxx:392
 AliAnalysisTaskPtEMCalTrigger.cxx:393
 AliAnalysisTaskPtEMCalTrigger.cxx:394
 AliAnalysisTaskPtEMCalTrigger.cxx:395
 AliAnalysisTaskPtEMCalTrigger.cxx:396
 AliAnalysisTaskPtEMCalTrigger.cxx:397
 AliAnalysisTaskPtEMCalTrigger.cxx:398
 AliAnalysisTaskPtEMCalTrigger.cxx:399
 AliAnalysisTaskPtEMCalTrigger.cxx:400
 AliAnalysisTaskPtEMCalTrigger.cxx:401
 AliAnalysisTaskPtEMCalTrigger.cxx:402
 AliAnalysisTaskPtEMCalTrigger.cxx:403
 AliAnalysisTaskPtEMCalTrigger.cxx:404
 AliAnalysisTaskPtEMCalTrigger.cxx:405
 AliAnalysisTaskPtEMCalTrigger.cxx:406
 AliAnalysisTaskPtEMCalTrigger.cxx:407
 AliAnalysisTaskPtEMCalTrigger.cxx:408
 AliAnalysisTaskPtEMCalTrigger.cxx:409
 AliAnalysisTaskPtEMCalTrigger.cxx:410
 AliAnalysisTaskPtEMCalTrigger.cxx:411
 AliAnalysisTaskPtEMCalTrigger.cxx:412
 AliAnalysisTaskPtEMCalTrigger.cxx:413
 AliAnalysisTaskPtEMCalTrigger.cxx:414
 AliAnalysisTaskPtEMCalTrigger.cxx:415
 AliAnalysisTaskPtEMCalTrigger.cxx:416
 AliAnalysisTaskPtEMCalTrigger.cxx:417
 AliAnalysisTaskPtEMCalTrigger.cxx:418
 AliAnalysisTaskPtEMCalTrigger.cxx:419
 AliAnalysisTaskPtEMCalTrigger.cxx:420
 AliAnalysisTaskPtEMCalTrigger.cxx:421
 AliAnalysisTaskPtEMCalTrigger.cxx:422
 AliAnalysisTaskPtEMCalTrigger.cxx:423
 AliAnalysisTaskPtEMCalTrigger.cxx:424
 AliAnalysisTaskPtEMCalTrigger.cxx:425
 AliAnalysisTaskPtEMCalTrigger.cxx:426
 AliAnalysisTaskPtEMCalTrigger.cxx:427
 AliAnalysisTaskPtEMCalTrigger.cxx:428
 AliAnalysisTaskPtEMCalTrigger.cxx:429
 AliAnalysisTaskPtEMCalTrigger.cxx:430
 AliAnalysisTaskPtEMCalTrigger.cxx:431
 AliAnalysisTaskPtEMCalTrigger.cxx:432
 AliAnalysisTaskPtEMCalTrigger.cxx:433
 AliAnalysisTaskPtEMCalTrigger.cxx:434
 AliAnalysisTaskPtEMCalTrigger.cxx:435
 AliAnalysisTaskPtEMCalTrigger.cxx:436
 AliAnalysisTaskPtEMCalTrigger.cxx:437
 AliAnalysisTaskPtEMCalTrigger.cxx:438
 AliAnalysisTaskPtEMCalTrigger.cxx:439
 AliAnalysisTaskPtEMCalTrigger.cxx:440
 AliAnalysisTaskPtEMCalTrigger.cxx:441
 AliAnalysisTaskPtEMCalTrigger.cxx:442
 AliAnalysisTaskPtEMCalTrigger.cxx:443
 AliAnalysisTaskPtEMCalTrigger.cxx:444
 AliAnalysisTaskPtEMCalTrigger.cxx:445
 AliAnalysisTaskPtEMCalTrigger.cxx:446
 AliAnalysisTaskPtEMCalTrigger.cxx:447
 AliAnalysisTaskPtEMCalTrigger.cxx:448
 AliAnalysisTaskPtEMCalTrigger.cxx:449
 AliAnalysisTaskPtEMCalTrigger.cxx:450
 AliAnalysisTaskPtEMCalTrigger.cxx:451
 AliAnalysisTaskPtEMCalTrigger.cxx:452
 AliAnalysisTaskPtEMCalTrigger.cxx:453
 AliAnalysisTaskPtEMCalTrigger.cxx:454
 AliAnalysisTaskPtEMCalTrigger.cxx:455
 AliAnalysisTaskPtEMCalTrigger.cxx:456
 AliAnalysisTaskPtEMCalTrigger.cxx:457
 AliAnalysisTaskPtEMCalTrigger.cxx:458
 AliAnalysisTaskPtEMCalTrigger.cxx:459
 AliAnalysisTaskPtEMCalTrigger.cxx:460
 AliAnalysisTaskPtEMCalTrigger.cxx:461
 AliAnalysisTaskPtEMCalTrigger.cxx:462
 AliAnalysisTaskPtEMCalTrigger.cxx:463
 AliAnalysisTaskPtEMCalTrigger.cxx:464
 AliAnalysisTaskPtEMCalTrigger.cxx:465
 AliAnalysisTaskPtEMCalTrigger.cxx:466
 AliAnalysisTaskPtEMCalTrigger.cxx:467
 AliAnalysisTaskPtEMCalTrigger.cxx:468
 AliAnalysisTaskPtEMCalTrigger.cxx:469
 AliAnalysisTaskPtEMCalTrigger.cxx:470
 AliAnalysisTaskPtEMCalTrigger.cxx:471
 AliAnalysisTaskPtEMCalTrigger.cxx:472
 AliAnalysisTaskPtEMCalTrigger.cxx:473
 AliAnalysisTaskPtEMCalTrigger.cxx:474
 AliAnalysisTaskPtEMCalTrigger.cxx:475
 AliAnalysisTaskPtEMCalTrigger.cxx:476
 AliAnalysisTaskPtEMCalTrigger.cxx:477
 AliAnalysisTaskPtEMCalTrigger.cxx:478
 AliAnalysisTaskPtEMCalTrigger.cxx:479
 AliAnalysisTaskPtEMCalTrigger.cxx:480
 AliAnalysisTaskPtEMCalTrigger.cxx:481
 AliAnalysisTaskPtEMCalTrigger.cxx:482
 AliAnalysisTaskPtEMCalTrigger.cxx:483
 AliAnalysisTaskPtEMCalTrigger.cxx:484
 AliAnalysisTaskPtEMCalTrigger.cxx:485
 AliAnalysisTaskPtEMCalTrigger.cxx:486
 AliAnalysisTaskPtEMCalTrigger.cxx:487
 AliAnalysisTaskPtEMCalTrigger.cxx:488
 AliAnalysisTaskPtEMCalTrigger.cxx:489
 AliAnalysisTaskPtEMCalTrigger.cxx:490
 AliAnalysisTaskPtEMCalTrigger.cxx:491
 AliAnalysisTaskPtEMCalTrigger.cxx:492
 AliAnalysisTaskPtEMCalTrigger.cxx:493
 AliAnalysisTaskPtEMCalTrigger.cxx:494
 AliAnalysisTaskPtEMCalTrigger.cxx:495
 AliAnalysisTaskPtEMCalTrigger.cxx:496
 AliAnalysisTaskPtEMCalTrigger.cxx:497
 AliAnalysisTaskPtEMCalTrigger.cxx:498
 AliAnalysisTaskPtEMCalTrigger.cxx:499
 AliAnalysisTaskPtEMCalTrigger.cxx:500
 AliAnalysisTaskPtEMCalTrigger.cxx:501
 AliAnalysisTaskPtEMCalTrigger.cxx:502
 AliAnalysisTaskPtEMCalTrigger.cxx:503
 AliAnalysisTaskPtEMCalTrigger.cxx:504
 AliAnalysisTaskPtEMCalTrigger.cxx:505
 AliAnalysisTaskPtEMCalTrigger.cxx:506
 AliAnalysisTaskPtEMCalTrigger.cxx:507
 AliAnalysisTaskPtEMCalTrigger.cxx:508
 AliAnalysisTaskPtEMCalTrigger.cxx:509
 AliAnalysisTaskPtEMCalTrigger.cxx:510
 AliAnalysisTaskPtEMCalTrigger.cxx:511
 AliAnalysisTaskPtEMCalTrigger.cxx:512
 AliAnalysisTaskPtEMCalTrigger.cxx:513
 AliAnalysisTaskPtEMCalTrigger.cxx:514
 AliAnalysisTaskPtEMCalTrigger.cxx:515
 AliAnalysisTaskPtEMCalTrigger.cxx:516
 AliAnalysisTaskPtEMCalTrigger.cxx:517
 AliAnalysisTaskPtEMCalTrigger.cxx:518
 AliAnalysisTaskPtEMCalTrigger.cxx:519
 AliAnalysisTaskPtEMCalTrigger.cxx:520
 AliAnalysisTaskPtEMCalTrigger.cxx:521
 AliAnalysisTaskPtEMCalTrigger.cxx:522
 AliAnalysisTaskPtEMCalTrigger.cxx:523
 AliAnalysisTaskPtEMCalTrigger.cxx:524
 AliAnalysisTaskPtEMCalTrigger.cxx:525
 AliAnalysisTaskPtEMCalTrigger.cxx:526
 AliAnalysisTaskPtEMCalTrigger.cxx:527
 AliAnalysisTaskPtEMCalTrigger.cxx:528
 AliAnalysisTaskPtEMCalTrigger.cxx:529
 AliAnalysisTaskPtEMCalTrigger.cxx:530
 AliAnalysisTaskPtEMCalTrigger.cxx:531
 AliAnalysisTaskPtEMCalTrigger.cxx:532
 AliAnalysisTaskPtEMCalTrigger.cxx:533
 AliAnalysisTaskPtEMCalTrigger.cxx:534
 AliAnalysisTaskPtEMCalTrigger.cxx:535
 AliAnalysisTaskPtEMCalTrigger.cxx:536
 AliAnalysisTaskPtEMCalTrigger.cxx:537
 AliAnalysisTaskPtEMCalTrigger.cxx:538
 AliAnalysisTaskPtEMCalTrigger.cxx:539
 AliAnalysisTaskPtEMCalTrigger.cxx:540
 AliAnalysisTaskPtEMCalTrigger.cxx:541
 AliAnalysisTaskPtEMCalTrigger.cxx:542
 AliAnalysisTaskPtEMCalTrigger.cxx:543
 AliAnalysisTaskPtEMCalTrigger.cxx:544
 AliAnalysisTaskPtEMCalTrigger.cxx:545
 AliAnalysisTaskPtEMCalTrigger.cxx:546
 AliAnalysisTaskPtEMCalTrigger.cxx:547
 AliAnalysisTaskPtEMCalTrigger.cxx:548
 AliAnalysisTaskPtEMCalTrigger.cxx:549
 AliAnalysisTaskPtEMCalTrigger.cxx:550
 AliAnalysisTaskPtEMCalTrigger.cxx:551
 AliAnalysisTaskPtEMCalTrigger.cxx:552
 AliAnalysisTaskPtEMCalTrigger.cxx:553
 AliAnalysisTaskPtEMCalTrigger.cxx:554
 AliAnalysisTaskPtEMCalTrigger.cxx:555
 AliAnalysisTaskPtEMCalTrigger.cxx:556
 AliAnalysisTaskPtEMCalTrigger.cxx:557
 AliAnalysisTaskPtEMCalTrigger.cxx:558
 AliAnalysisTaskPtEMCalTrigger.cxx:559
 AliAnalysisTaskPtEMCalTrigger.cxx:560
 AliAnalysisTaskPtEMCalTrigger.cxx:561
 AliAnalysisTaskPtEMCalTrigger.cxx:562
 AliAnalysisTaskPtEMCalTrigger.cxx:563
 AliAnalysisTaskPtEMCalTrigger.cxx:564
 AliAnalysisTaskPtEMCalTrigger.cxx:565
 AliAnalysisTaskPtEMCalTrigger.cxx:566
 AliAnalysisTaskPtEMCalTrigger.cxx:567
 AliAnalysisTaskPtEMCalTrigger.cxx:568
 AliAnalysisTaskPtEMCalTrigger.cxx:569
 AliAnalysisTaskPtEMCalTrigger.cxx:570
 AliAnalysisTaskPtEMCalTrigger.cxx:571
 AliAnalysisTaskPtEMCalTrigger.cxx:572
 AliAnalysisTaskPtEMCalTrigger.cxx:573
 AliAnalysisTaskPtEMCalTrigger.cxx:574
 AliAnalysisTaskPtEMCalTrigger.cxx:575
 AliAnalysisTaskPtEMCalTrigger.cxx:576
 AliAnalysisTaskPtEMCalTrigger.cxx:577
 AliAnalysisTaskPtEMCalTrigger.cxx:578
 AliAnalysisTaskPtEMCalTrigger.cxx:579
 AliAnalysisTaskPtEMCalTrigger.cxx:580
 AliAnalysisTaskPtEMCalTrigger.cxx:581
 AliAnalysisTaskPtEMCalTrigger.cxx:582
 AliAnalysisTaskPtEMCalTrigger.cxx:583
 AliAnalysisTaskPtEMCalTrigger.cxx:584
 AliAnalysisTaskPtEMCalTrigger.cxx:585
 AliAnalysisTaskPtEMCalTrigger.cxx:586
 AliAnalysisTaskPtEMCalTrigger.cxx:587
 AliAnalysisTaskPtEMCalTrigger.cxx:588
 AliAnalysisTaskPtEMCalTrigger.cxx:589
 AliAnalysisTaskPtEMCalTrigger.cxx:590
 AliAnalysisTaskPtEMCalTrigger.cxx:591
 AliAnalysisTaskPtEMCalTrigger.cxx:592
 AliAnalysisTaskPtEMCalTrigger.cxx:593
 AliAnalysisTaskPtEMCalTrigger.cxx:594
 AliAnalysisTaskPtEMCalTrigger.cxx:595
 AliAnalysisTaskPtEMCalTrigger.cxx:596
 AliAnalysisTaskPtEMCalTrigger.cxx:597
 AliAnalysisTaskPtEMCalTrigger.cxx:598
 AliAnalysisTaskPtEMCalTrigger.cxx:599
 AliAnalysisTaskPtEMCalTrigger.cxx:600
 AliAnalysisTaskPtEMCalTrigger.cxx:601
 AliAnalysisTaskPtEMCalTrigger.cxx:602
 AliAnalysisTaskPtEMCalTrigger.cxx:603
 AliAnalysisTaskPtEMCalTrigger.cxx:604
 AliAnalysisTaskPtEMCalTrigger.cxx:605
 AliAnalysisTaskPtEMCalTrigger.cxx:606
 AliAnalysisTaskPtEMCalTrigger.cxx:607
 AliAnalysisTaskPtEMCalTrigger.cxx:608
 AliAnalysisTaskPtEMCalTrigger.cxx:609
 AliAnalysisTaskPtEMCalTrigger.cxx:610
 AliAnalysisTaskPtEMCalTrigger.cxx:611
 AliAnalysisTaskPtEMCalTrigger.cxx:612
 AliAnalysisTaskPtEMCalTrigger.cxx:613
 AliAnalysisTaskPtEMCalTrigger.cxx:614
 AliAnalysisTaskPtEMCalTrigger.cxx:615
 AliAnalysisTaskPtEMCalTrigger.cxx:616
 AliAnalysisTaskPtEMCalTrigger.cxx:617
 AliAnalysisTaskPtEMCalTrigger.cxx:618
 AliAnalysisTaskPtEMCalTrigger.cxx:619
 AliAnalysisTaskPtEMCalTrigger.cxx:620
 AliAnalysisTaskPtEMCalTrigger.cxx:621
 AliAnalysisTaskPtEMCalTrigger.cxx:622
 AliAnalysisTaskPtEMCalTrigger.cxx:623
 AliAnalysisTaskPtEMCalTrigger.cxx:624
 AliAnalysisTaskPtEMCalTrigger.cxx:625
 AliAnalysisTaskPtEMCalTrigger.cxx:626
 AliAnalysisTaskPtEMCalTrigger.cxx:627
 AliAnalysisTaskPtEMCalTrigger.cxx:628
 AliAnalysisTaskPtEMCalTrigger.cxx:629
 AliAnalysisTaskPtEMCalTrigger.cxx:630
 AliAnalysisTaskPtEMCalTrigger.cxx:631
 AliAnalysisTaskPtEMCalTrigger.cxx:632
 AliAnalysisTaskPtEMCalTrigger.cxx:633
 AliAnalysisTaskPtEMCalTrigger.cxx:634
 AliAnalysisTaskPtEMCalTrigger.cxx:635
 AliAnalysisTaskPtEMCalTrigger.cxx:636
 AliAnalysisTaskPtEMCalTrigger.cxx:637
 AliAnalysisTaskPtEMCalTrigger.cxx:638
 AliAnalysisTaskPtEMCalTrigger.cxx:639
 AliAnalysisTaskPtEMCalTrigger.cxx:640
 AliAnalysisTaskPtEMCalTrigger.cxx:641
 AliAnalysisTaskPtEMCalTrigger.cxx:642
 AliAnalysisTaskPtEMCalTrigger.cxx:643
 AliAnalysisTaskPtEMCalTrigger.cxx:644
 AliAnalysisTaskPtEMCalTrigger.cxx:645
 AliAnalysisTaskPtEMCalTrigger.cxx:646
 AliAnalysisTaskPtEMCalTrigger.cxx:647
 AliAnalysisTaskPtEMCalTrigger.cxx:648
 AliAnalysisTaskPtEMCalTrigger.cxx:649
 AliAnalysisTaskPtEMCalTrigger.cxx:650
 AliAnalysisTaskPtEMCalTrigger.cxx:651
 AliAnalysisTaskPtEMCalTrigger.cxx:652
 AliAnalysisTaskPtEMCalTrigger.cxx:653
 AliAnalysisTaskPtEMCalTrigger.cxx:654
 AliAnalysisTaskPtEMCalTrigger.cxx:655
 AliAnalysisTaskPtEMCalTrigger.cxx:656
 AliAnalysisTaskPtEMCalTrigger.cxx:657
 AliAnalysisTaskPtEMCalTrigger.cxx:658
 AliAnalysisTaskPtEMCalTrigger.cxx:659
 AliAnalysisTaskPtEMCalTrigger.cxx:660
 AliAnalysisTaskPtEMCalTrigger.cxx:661
 AliAnalysisTaskPtEMCalTrigger.cxx:662
 AliAnalysisTaskPtEMCalTrigger.cxx:663
 AliAnalysisTaskPtEMCalTrigger.cxx:664
 AliAnalysisTaskPtEMCalTrigger.cxx:665
 AliAnalysisTaskPtEMCalTrigger.cxx:666
 AliAnalysisTaskPtEMCalTrigger.cxx:667
 AliAnalysisTaskPtEMCalTrigger.cxx:668
 AliAnalysisTaskPtEMCalTrigger.cxx:669
 AliAnalysisTaskPtEMCalTrigger.cxx:670
 AliAnalysisTaskPtEMCalTrigger.cxx:671
 AliAnalysisTaskPtEMCalTrigger.cxx:672
 AliAnalysisTaskPtEMCalTrigger.cxx:673
 AliAnalysisTaskPtEMCalTrigger.cxx:674
 AliAnalysisTaskPtEMCalTrigger.cxx:675
 AliAnalysisTaskPtEMCalTrigger.cxx:676
 AliAnalysisTaskPtEMCalTrigger.cxx:677
 AliAnalysisTaskPtEMCalTrigger.cxx:678
 AliAnalysisTaskPtEMCalTrigger.cxx:679
 AliAnalysisTaskPtEMCalTrigger.cxx:680
 AliAnalysisTaskPtEMCalTrigger.cxx:681
 AliAnalysisTaskPtEMCalTrigger.cxx:682
 AliAnalysisTaskPtEMCalTrigger.cxx:683
 AliAnalysisTaskPtEMCalTrigger.cxx:684
 AliAnalysisTaskPtEMCalTrigger.cxx:685
 AliAnalysisTaskPtEMCalTrigger.cxx:686
 AliAnalysisTaskPtEMCalTrigger.cxx:687
 AliAnalysisTaskPtEMCalTrigger.cxx:688
 AliAnalysisTaskPtEMCalTrigger.cxx:689
 AliAnalysisTaskPtEMCalTrigger.cxx:690
 AliAnalysisTaskPtEMCalTrigger.cxx:691
 AliAnalysisTaskPtEMCalTrigger.cxx:692
 AliAnalysisTaskPtEMCalTrigger.cxx:693
 AliAnalysisTaskPtEMCalTrigger.cxx:694
 AliAnalysisTaskPtEMCalTrigger.cxx:695
 AliAnalysisTaskPtEMCalTrigger.cxx:696
 AliAnalysisTaskPtEMCalTrigger.cxx:697
 AliAnalysisTaskPtEMCalTrigger.cxx:698
 AliAnalysisTaskPtEMCalTrigger.cxx:699
 AliAnalysisTaskPtEMCalTrigger.cxx:700
 AliAnalysisTaskPtEMCalTrigger.cxx:701
 AliAnalysisTaskPtEMCalTrigger.cxx:702
 AliAnalysisTaskPtEMCalTrigger.cxx:703
 AliAnalysisTaskPtEMCalTrigger.cxx:704
 AliAnalysisTaskPtEMCalTrigger.cxx:705
 AliAnalysisTaskPtEMCalTrigger.cxx:706
 AliAnalysisTaskPtEMCalTrigger.cxx:707
 AliAnalysisTaskPtEMCalTrigger.cxx:708
 AliAnalysisTaskPtEMCalTrigger.cxx:709
 AliAnalysisTaskPtEMCalTrigger.cxx:710
 AliAnalysisTaskPtEMCalTrigger.cxx:711
 AliAnalysisTaskPtEMCalTrigger.cxx:712
 AliAnalysisTaskPtEMCalTrigger.cxx:713
 AliAnalysisTaskPtEMCalTrigger.cxx:714
 AliAnalysisTaskPtEMCalTrigger.cxx:715
 AliAnalysisTaskPtEMCalTrigger.cxx:716
 AliAnalysisTaskPtEMCalTrigger.cxx:717
 AliAnalysisTaskPtEMCalTrigger.cxx:718
 AliAnalysisTaskPtEMCalTrigger.cxx:719
 AliAnalysisTaskPtEMCalTrigger.cxx:720
 AliAnalysisTaskPtEMCalTrigger.cxx:721
 AliAnalysisTaskPtEMCalTrigger.cxx:722
 AliAnalysisTaskPtEMCalTrigger.cxx:723
 AliAnalysisTaskPtEMCalTrigger.cxx:724
 AliAnalysisTaskPtEMCalTrigger.cxx:725
 AliAnalysisTaskPtEMCalTrigger.cxx:726
 AliAnalysisTaskPtEMCalTrigger.cxx:727
 AliAnalysisTaskPtEMCalTrigger.cxx:728
 AliAnalysisTaskPtEMCalTrigger.cxx:729
 AliAnalysisTaskPtEMCalTrigger.cxx:730
 AliAnalysisTaskPtEMCalTrigger.cxx:731
 AliAnalysisTaskPtEMCalTrigger.cxx:732
 AliAnalysisTaskPtEMCalTrigger.cxx:733
 AliAnalysisTaskPtEMCalTrigger.cxx:734
 AliAnalysisTaskPtEMCalTrigger.cxx:735
 AliAnalysisTaskPtEMCalTrigger.cxx:736
 AliAnalysisTaskPtEMCalTrigger.cxx:737
 AliAnalysisTaskPtEMCalTrigger.cxx:738
 AliAnalysisTaskPtEMCalTrigger.cxx:739
 AliAnalysisTaskPtEMCalTrigger.cxx:740
 AliAnalysisTaskPtEMCalTrigger.cxx:741
 AliAnalysisTaskPtEMCalTrigger.cxx:742
 AliAnalysisTaskPtEMCalTrigger.cxx:743
 AliAnalysisTaskPtEMCalTrigger.cxx:744
 AliAnalysisTaskPtEMCalTrigger.cxx:745
 AliAnalysisTaskPtEMCalTrigger.cxx:746
 AliAnalysisTaskPtEMCalTrigger.cxx:747
 AliAnalysisTaskPtEMCalTrigger.cxx:748
 AliAnalysisTaskPtEMCalTrigger.cxx:749
 AliAnalysisTaskPtEMCalTrigger.cxx:750
 AliAnalysisTaskPtEMCalTrigger.cxx:751
 AliAnalysisTaskPtEMCalTrigger.cxx:752
 AliAnalysisTaskPtEMCalTrigger.cxx:753
 AliAnalysisTaskPtEMCalTrigger.cxx:754
 AliAnalysisTaskPtEMCalTrigger.cxx:755
 AliAnalysisTaskPtEMCalTrigger.cxx:756
 AliAnalysisTaskPtEMCalTrigger.cxx:757
 AliAnalysisTaskPtEMCalTrigger.cxx:758
 AliAnalysisTaskPtEMCalTrigger.cxx:759
 AliAnalysisTaskPtEMCalTrigger.cxx:760
 AliAnalysisTaskPtEMCalTrigger.cxx:761
 AliAnalysisTaskPtEMCalTrigger.cxx:762
 AliAnalysisTaskPtEMCalTrigger.cxx:763
 AliAnalysisTaskPtEMCalTrigger.cxx:764
 AliAnalysisTaskPtEMCalTrigger.cxx:765
 AliAnalysisTaskPtEMCalTrigger.cxx:766
 AliAnalysisTaskPtEMCalTrigger.cxx:767
 AliAnalysisTaskPtEMCalTrigger.cxx:768
 AliAnalysisTaskPtEMCalTrigger.cxx:769
 AliAnalysisTaskPtEMCalTrigger.cxx:770
 AliAnalysisTaskPtEMCalTrigger.cxx:771
 AliAnalysisTaskPtEMCalTrigger.cxx:772
 AliAnalysisTaskPtEMCalTrigger.cxx:773
 AliAnalysisTaskPtEMCalTrigger.cxx:774
 AliAnalysisTaskPtEMCalTrigger.cxx:775
 AliAnalysisTaskPtEMCalTrigger.cxx:776
 AliAnalysisTaskPtEMCalTrigger.cxx:777
 AliAnalysisTaskPtEMCalTrigger.cxx:778
 AliAnalysisTaskPtEMCalTrigger.cxx:779
 AliAnalysisTaskPtEMCalTrigger.cxx:780
 AliAnalysisTaskPtEMCalTrigger.cxx:781
 AliAnalysisTaskPtEMCalTrigger.cxx:782
 AliAnalysisTaskPtEMCalTrigger.cxx:783
 AliAnalysisTaskPtEMCalTrigger.cxx:784
 AliAnalysisTaskPtEMCalTrigger.cxx:785
 AliAnalysisTaskPtEMCalTrigger.cxx:786
 AliAnalysisTaskPtEMCalTrigger.cxx:787
 AliAnalysisTaskPtEMCalTrigger.cxx:788
 AliAnalysisTaskPtEMCalTrigger.cxx:789
 AliAnalysisTaskPtEMCalTrigger.cxx:790
 AliAnalysisTaskPtEMCalTrigger.cxx:791
 AliAnalysisTaskPtEMCalTrigger.cxx:792
 AliAnalysisTaskPtEMCalTrigger.cxx:793
 AliAnalysisTaskPtEMCalTrigger.cxx:794
 AliAnalysisTaskPtEMCalTrigger.cxx:795
 AliAnalysisTaskPtEMCalTrigger.cxx:796
 AliAnalysisTaskPtEMCalTrigger.cxx:797
 AliAnalysisTaskPtEMCalTrigger.cxx:798
 AliAnalysisTaskPtEMCalTrigger.cxx:799
 AliAnalysisTaskPtEMCalTrigger.cxx:800
 AliAnalysisTaskPtEMCalTrigger.cxx:801
 AliAnalysisTaskPtEMCalTrigger.cxx:802
 AliAnalysisTaskPtEMCalTrigger.cxx:803
 AliAnalysisTaskPtEMCalTrigger.cxx:804
 AliAnalysisTaskPtEMCalTrigger.cxx:805
 AliAnalysisTaskPtEMCalTrigger.cxx:806
 AliAnalysisTaskPtEMCalTrigger.cxx:807
 AliAnalysisTaskPtEMCalTrigger.cxx:808
 AliAnalysisTaskPtEMCalTrigger.cxx:809
 AliAnalysisTaskPtEMCalTrigger.cxx:810
 AliAnalysisTaskPtEMCalTrigger.cxx:811
 AliAnalysisTaskPtEMCalTrigger.cxx:812
 AliAnalysisTaskPtEMCalTrigger.cxx:813
 AliAnalysisTaskPtEMCalTrigger.cxx:814
 AliAnalysisTaskPtEMCalTrigger.cxx:815
 AliAnalysisTaskPtEMCalTrigger.cxx:816
 AliAnalysisTaskPtEMCalTrigger.cxx:817
 AliAnalysisTaskPtEMCalTrigger.cxx:818
 AliAnalysisTaskPtEMCalTrigger.cxx:819
 AliAnalysisTaskPtEMCalTrigger.cxx:820
 AliAnalysisTaskPtEMCalTrigger.cxx:821
 AliAnalysisTaskPtEMCalTrigger.cxx:822
 AliAnalysisTaskPtEMCalTrigger.cxx:823
 AliAnalysisTaskPtEMCalTrigger.cxx:824
 AliAnalysisTaskPtEMCalTrigger.cxx:825
 AliAnalysisTaskPtEMCalTrigger.cxx:826
 AliAnalysisTaskPtEMCalTrigger.cxx:827
 AliAnalysisTaskPtEMCalTrigger.cxx:828
 AliAnalysisTaskPtEMCalTrigger.cxx:829
 AliAnalysisTaskPtEMCalTrigger.cxx:830
 AliAnalysisTaskPtEMCalTrigger.cxx:831
 AliAnalysisTaskPtEMCalTrigger.cxx:832
 AliAnalysisTaskPtEMCalTrigger.cxx:833
 AliAnalysisTaskPtEMCalTrigger.cxx:834
 AliAnalysisTaskPtEMCalTrigger.cxx:835
 AliAnalysisTaskPtEMCalTrigger.cxx:836
 AliAnalysisTaskPtEMCalTrigger.cxx:837
 AliAnalysisTaskPtEMCalTrigger.cxx:838
 AliAnalysisTaskPtEMCalTrigger.cxx:839
 AliAnalysisTaskPtEMCalTrigger.cxx:840
 AliAnalysisTaskPtEMCalTrigger.cxx:841
 AliAnalysisTaskPtEMCalTrigger.cxx:842
 AliAnalysisTaskPtEMCalTrigger.cxx:843
 AliAnalysisTaskPtEMCalTrigger.cxx:844
 AliAnalysisTaskPtEMCalTrigger.cxx:845
 AliAnalysisTaskPtEMCalTrigger.cxx:846
 AliAnalysisTaskPtEMCalTrigger.cxx:847
 AliAnalysisTaskPtEMCalTrigger.cxx:848
 AliAnalysisTaskPtEMCalTrigger.cxx:849
 AliAnalysisTaskPtEMCalTrigger.cxx:850
 AliAnalysisTaskPtEMCalTrigger.cxx:851
 AliAnalysisTaskPtEMCalTrigger.cxx:852
 AliAnalysisTaskPtEMCalTrigger.cxx:853
 AliAnalysisTaskPtEMCalTrigger.cxx:854
 AliAnalysisTaskPtEMCalTrigger.cxx:855
 AliAnalysisTaskPtEMCalTrigger.cxx:856
 AliAnalysisTaskPtEMCalTrigger.cxx:857
 AliAnalysisTaskPtEMCalTrigger.cxx:858
 AliAnalysisTaskPtEMCalTrigger.cxx:859
 AliAnalysisTaskPtEMCalTrigger.cxx:860
 AliAnalysisTaskPtEMCalTrigger.cxx:861
 AliAnalysisTaskPtEMCalTrigger.cxx:862
 AliAnalysisTaskPtEMCalTrigger.cxx:863
 AliAnalysisTaskPtEMCalTrigger.cxx:864
 AliAnalysisTaskPtEMCalTrigger.cxx:865
 AliAnalysisTaskPtEMCalTrigger.cxx:866
 AliAnalysisTaskPtEMCalTrigger.cxx:867
 AliAnalysisTaskPtEMCalTrigger.cxx:868
 AliAnalysisTaskPtEMCalTrigger.cxx:869
 AliAnalysisTaskPtEMCalTrigger.cxx:870
 AliAnalysisTaskPtEMCalTrigger.cxx:871
 AliAnalysisTaskPtEMCalTrigger.cxx:872
 AliAnalysisTaskPtEMCalTrigger.cxx:873
 AliAnalysisTaskPtEMCalTrigger.cxx:874
 AliAnalysisTaskPtEMCalTrigger.cxx:875
 AliAnalysisTaskPtEMCalTrigger.cxx:876
 AliAnalysisTaskPtEMCalTrigger.cxx:877
 AliAnalysisTaskPtEMCalTrigger.cxx:878
 AliAnalysisTaskPtEMCalTrigger.cxx:879
 AliAnalysisTaskPtEMCalTrigger.cxx:880
 AliAnalysisTaskPtEMCalTrigger.cxx:881
 AliAnalysisTaskPtEMCalTrigger.cxx:882
 AliAnalysisTaskPtEMCalTrigger.cxx:883
 AliAnalysisTaskPtEMCalTrigger.cxx:884
 AliAnalysisTaskPtEMCalTrigger.cxx:885
 AliAnalysisTaskPtEMCalTrigger.cxx:886
 AliAnalysisTaskPtEMCalTrigger.cxx:887
 AliAnalysisTaskPtEMCalTrigger.cxx:888
 AliAnalysisTaskPtEMCalTrigger.cxx:889
 AliAnalysisTaskPtEMCalTrigger.cxx:890
 AliAnalysisTaskPtEMCalTrigger.cxx:891
 AliAnalysisTaskPtEMCalTrigger.cxx:892
 AliAnalysisTaskPtEMCalTrigger.cxx:893
 AliAnalysisTaskPtEMCalTrigger.cxx:894
 AliAnalysisTaskPtEMCalTrigger.cxx:895
 AliAnalysisTaskPtEMCalTrigger.cxx:896
 AliAnalysisTaskPtEMCalTrigger.cxx:897
 AliAnalysisTaskPtEMCalTrigger.cxx:898
 AliAnalysisTaskPtEMCalTrigger.cxx:899
 AliAnalysisTaskPtEMCalTrigger.cxx:900
 AliAnalysisTaskPtEMCalTrigger.cxx:901
 AliAnalysisTaskPtEMCalTrigger.cxx:902
 AliAnalysisTaskPtEMCalTrigger.cxx:903
 AliAnalysisTaskPtEMCalTrigger.cxx:904
 AliAnalysisTaskPtEMCalTrigger.cxx:905
 AliAnalysisTaskPtEMCalTrigger.cxx:906
 AliAnalysisTaskPtEMCalTrigger.cxx:907
 AliAnalysisTaskPtEMCalTrigger.cxx:908
 AliAnalysisTaskPtEMCalTrigger.cxx:909
 AliAnalysisTaskPtEMCalTrigger.cxx:910
 AliAnalysisTaskPtEMCalTrigger.cxx:911
 AliAnalysisTaskPtEMCalTrigger.cxx:912
 AliAnalysisTaskPtEMCalTrigger.cxx:913
 AliAnalysisTaskPtEMCalTrigger.cxx:914
 AliAnalysisTaskPtEMCalTrigger.cxx:915
 AliAnalysisTaskPtEMCalTrigger.cxx:916
 AliAnalysisTaskPtEMCalTrigger.cxx:917
 AliAnalysisTaskPtEMCalTrigger.cxx:918
 AliAnalysisTaskPtEMCalTrigger.cxx:919
 AliAnalysisTaskPtEMCalTrigger.cxx:920
 AliAnalysisTaskPtEMCalTrigger.cxx:921
 AliAnalysisTaskPtEMCalTrigger.cxx:922
 AliAnalysisTaskPtEMCalTrigger.cxx:923
 AliAnalysisTaskPtEMCalTrigger.cxx:924
 AliAnalysisTaskPtEMCalTrigger.cxx:925
 AliAnalysisTaskPtEMCalTrigger.cxx:926
 AliAnalysisTaskPtEMCalTrigger.cxx:927
 AliAnalysisTaskPtEMCalTrigger.cxx:928
 AliAnalysisTaskPtEMCalTrigger.cxx:929
 AliAnalysisTaskPtEMCalTrigger.cxx:930
 AliAnalysisTaskPtEMCalTrigger.cxx:931
 AliAnalysisTaskPtEMCalTrigger.cxx:932
 AliAnalysisTaskPtEMCalTrigger.cxx:933
 AliAnalysisTaskPtEMCalTrigger.cxx:934
 AliAnalysisTaskPtEMCalTrigger.cxx:935
 AliAnalysisTaskPtEMCalTrigger.cxx:936
 AliAnalysisTaskPtEMCalTrigger.cxx:937
 AliAnalysisTaskPtEMCalTrigger.cxx:938
 AliAnalysisTaskPtEMCalTrigger.cxx:939
 AliAnalysisTaskPtEMCalTrigger.cxx:940
 AliAnalysisTaskPtEMCalTrigger.cxx:941
 AliAnalysisTaskPtEMCalTrigger.cxx:942
 AliAnalysisTaskPtEMCalTrigger.cxx:943
 AliAnalysisTaskPtEMCalTrigger.cxx:944
 AliAnalysisTaskPtEMCalTrigger.cxx:945
 AliAnalysisTaskPtEMCalTrigger.cxx:946
 AliAnalysisTaskPtEMCalTrigger.cxx:947
 AliAnalysisTaskPtEMCalTrigger.cxx:948
 AliAnalysisTaskPtEMCalTrigger.cxx:949
 AliAnalysisTaskPtEMCalTrigger.cxx:950
 AliAnalysisTaskPtEMCalTrigger.cxx:951
 AliAnalysisTaskPtEMCalTrigger.cxx:952
 AliAnalysisTaskPtEMCalTrigger.cxx:953
 AliAnalysisTaskPtEMCalTrigger.cxx:954
 AliAnalysisTaskPtEMCalTrigger.cxx:955
 AliAnalysisTaskPtEMCalTrigger.cxx:956
 AliAnalysisTaskPtEMCalTrigger.cxx:957
 AliAnalysisTaskPtEMCalTrigger.cxx:958
 AliAnalysisTaskPtEMCalTrigger.cxx:959
 AliAnalysisTaskPtEMCalTrigger.cxx:960
 AliAnalysisTaskPtEMCalTrigger.cxx:961
 AliAnalysisTaskPtEMCalTrigger.cxx:962
 AliAnalysisTaskPtEMCalTrigger.cxx:963
 AliAnalysisTaskPtEMCalTrigger.cxx:964
 AliAnalysisTaskPtEMCalTrigger.cxx:965
 AliAnalysisTaskPtEMCalTrigger.cxx:966
 AliAnalysisTaskPtEMCalTrigger.cxx:967
 AliAnalysisTaskPtEMCalTrigger.cxx:968
 AliAnalysisTaskPtEMCalTrigger.cxx:969
 AliAnalysisTaskPtEMCalTrigger.cxx:970
 AliAnalysisTaskPtEMCalTrigger.cxx:971
 AliAnalysisTaskPtEMCalTrigger.cxx:972
 AliAnalysisTaskPtEMCalTrigger.cxx:973
 AliAnalysisTaskPtEMCalTrigger.cxx:974
 AliAnalysisTaskPtEMCalTrigger.cxx:975
 AliAnalysisTaskPtEMCalTrigger.cxx:976
 AliAnalysisTaskPtEMCalTrigger.cxx:977
 AliAnalysisTaskPtEMCalTrigger.cxx:978
 AliAnalysisTaskPtEMCalTrigger.cxx:979
 AliAnalysisTaskPtEMCalTrigger.cxx:980
 AliAnalysisTaskPtEMCalTrigger.cxx:981
 AliAnalysisTaskPtEMCalTrigger.cxx:982
 AliAnalysisTaskPtEMCalTrigger.cxx:983
 AliAnalysisTaskPtEMCalTrigger.cxx:984
 AliAnalysisTaskPtEMCalTrigger.cxx:985
 AliAnalysisTaskPtEMCalTrigger.cxx:986
 AliAnalysisTaskPtEMCalTrigger.cxx:987
 AliAnalysisTaskPtEMCalTrigger.cxx:988
 AliAnalysisTaskPtEMCalTrigger.cxx:989
 AliAnalysisTaskPtEMCalTrigger.cxx:990
 AliAnalysisTaskPtEMCalTrigger.cxx:991
 AliAnalysisTaskPtEMCalTrigger.cxx:992
 AliAnalysisTaskPtEMCalTrigger.cxx:993
 AliAnalysisTaskPtEMCalTrigger.cxx:994
 AliAnalysisTaskPtEMCalTrigger.cxx:995
 AliAnalysisTaskPtEMCalTrigger.cxx:996
 AliAnalysisTaskPtEMCalTrigger.cxx:997
 AliAnalysisTaskPtEMCalTrigger.cxx:998
 AliAnalysisTaskPtEMCalTrigger.cxx:999
 AliAnalysisTaskPtEMCalTrigger.cxx:1000
 AliAnalysisTaskPtEMCalTrigger.cxx:1001
 AliAnalysisTaskPtEMCalTrigger.cxx:1002
 AliAnalysisTaskPtEMCalTrigger.cxx:1003
 AliAnalysisTaskPtEMCalTrigger.cxx:1004
 AliAnalysisTaskPtEMCalTrigger.cxx:1005
 AliAnalysisTaskPtEMCalTrigger.cxx:1006
 AliAnalysisTaskPtEMCalTrigger.cxx:1007
 AliAnalysisTaskPtEMCalTrigger.cxx:1008
 AliAnalysisTaskPtEMCalTrigger.cxx:1009
 AliAnalysisTaskPtEMCalTrigger.cxx:1010
 AliAnalysisTaskPtEMCalTrigger.cxx:1011
 AliAnalysisTaskPtEMCalTrigger.cxx:1012
 AliAnalysisTaskPtEMCalTrigger.cxx:1013
 AliAnalysisTaskPtEMCalTrigger.cxx:1014
 AliAnalysisTaskPtEMCalTrigger.cxx:1015
 AliAnalysisTaskPtEMCalTrigger.cxx:1016
 AliAnalysisTaskPtEMCalTrigger.cxx:1017
 AliAnalysisTaskPtEMCalTrigger.cxx:1018
 AliAnalysisTaskPtEMCalTrigger.cxx:1019
 AliAnalysisTaskPtEMCalTrigger.cxx:1020
 AliAnalysisTaskPtEMCalTrigger.cxx:1021
 AliAnalysisTaskPtEMCalTrigger.cxx:1022
 AliAnalysisTaskPtEMCalTrigger.cxx:1023
 AliAnalysisTaskPtEMCalTrigger.cxx:1024
 AliAnalysisTaskPtEMCalTrigger.cxx:1025
 AliAnalysisTaskPtEMCalTrigger.cxx:1026
 AliAnalysisTaskPtEMCalTrigger.cxx:1027
 AliAnalysisTaskPtEMCalTrigger.cxx:1028
 AliAnalysisTaskPtEMCalTrigger.cxx:1029
 AliAnalysisTaskPtEMCalTrigger.cxx:1030
 AliAnalysisTaskPtEMCalTrigger.cxx:1031
 AliAnalysisTaskPtEMCalTrigger.cxx:1032
 AliAnalysisTaskPtEMCalTrigger.cxx:1033
 AliAnalysisTaskPtEMCalTrigger.cxx:1034
 AliAnalysisTaskPtEMCalTrigger.cxx:1035
 AliAnalysisTaskPtEMCalTrigger.cxx:1036
 AliAnalysisTaskPtEMCalTrigger.cxx:1037
 AliAnalysisTaskPtEMCalTrigger.cxx:1038
 AliAnalysisTaskPtEMCalTrigger.cxx:1039
 AliAnalysisTaskPtEMCalTrigger.cxx:1040
 AliAnalysisTaskPtEMCalTrigger.cxx:1041
 AliAnalysisTaskPtEMCalTrigger.cxx:1042
 AliAnalysisTaskPtEMCalTrigger.cxx:1043
 AliAnalysisTaskPtEMCalTrigger.cxx:1044
 AliAnalysisTaskPtEMCalTrigger.cxx:1045
 AliAnalysisTaskPtEMCalTrigger.cxx:1046
 AliAnalysisTaskPtEMCalTrigger.cxx:1047
 AliAnalysisTaskPtEMCalTrigger.cxx:1048
 AliAnalysisTaskPtEMCalTrigger.cxx:1049
 AliAnalysisTaskPtEMCalTrigger.cxx:1050
 AliAnalysisTaskPtEMCalTrigger.cxx:1051
 AliAnalysisTaskPtEMCalTrigger.cxx:1052
 AliAnalysisTaskPtEMCalTrigger.cxx:1053
 AliAnalysisTaskPtEMCalTrigger.cxx:1054
 AliAnalysisTaskPtEMCalTrigger.cxx:1055
 AliAnalysisTaskPtEMCalTrigger.cxx:1056
 AliAnalysisTaskPtEMCalTrigger.cxx:1057
 AliAnalysisTaskPtEMCalTrigger.cxx:1058
 AliAnalysisTaskPtEMCalTrigger.cxx:1059
 AliAnalysisTaskPtEMCalTrigger.cxx:1060
 AliAnalysisTaskPtEMCalTrigger.cxx:1061
 AliAnalysisTaskPtEMCalTrigger.cxx:1062
 AliAnalysisTaskPtEMCalTrigger.cxx:1063
 AliAnalysisTaskPtEMCalTrigger.cxx:1064
 AliAnalysisTaskPtEMCalTrigger.cxx:1065
 AliAnalysisTaskPtEMCalTrigger.cxx:1066
 AliAnalysisTaskPtEMCalTrigger.cxx:1067
 AliAnalysisTaskPtEMCalTrigger.cxx:1068
 AliAnalysisTaskPtEMCalTrigger.cxx:1069
 AliAnalysisTaskPtEMCalTrigger.cxx:1070
 AliAnalysisTaskPtEMCalTrigger.cxx:1071
 AliAnalysisTaskPtEMCalTrigger.cxx:1072
 AliAnalysisTaskPtEMCalTrigger.cxx:1073
 AliAnalysisTaskPtEMCalTrigger.cxx:1074
 AliAnalysisTaskPtEMCalTrigger.cxx:1075
 AliAnalysisTaskPtEMCalTrigger.cxx:1076
 AliAnalysisTaskPtEMCalTrigger.cxx:1077
 AliAnalysisTaskPtEMCalTrigger.cxx:1078
 AliAnalysisTaskPtEMCalTrigger.cxx:1079
 AliAnalysisTaskPtEMCalTrigger.cxx:1080
 AliAnalysisTaskPtEMCalTrigger.cxx:1081
 AliAnalysisTaskPtEMCalTrigger.cxx:1082
 AliAnalysisTaskPtEMCalTrigger.cxx:1083
 AliAnalysisTaskPtEMCalTrigger.cxx:1084
 AliAnalysisTaskPtEMCalTrigger.cxx:1085
 AliAnalysisTaskPtEMCalTrigger.cxx:1086
 AliAnalysisTaskPtEMCalTrigger.cxx:1087
 AliAnalysisTaskPtEMCalTrigger.cxx:1088
 AliAnalysisTaskPtEMCalTrigger.cxx:1089
 AliAnalysisTaskPtEMCalTrigger.cxx:1090
 AliAnalysisTaskPtEMCalTrigger.cxx:1091
 AliAnalysisTaskPtEMCalTrigger.cxx:1092
 AliAnalysisTaskPtEMCalTrigger.cxx:1093
 AliAnalysisTaskPtEMCalTrigger.cxx:1094
 AliAnalysisTaskPtEMCalTrigger.cxx:1095
 AliAnalysisTaskPtEMCalTrigger.cxx:1096
 AliAnalysisTaskPtEMCalTrigger.cxx:1097
 AliAnalysisTaskPtEMCalTrigger.cxx:1098
 AliAnalysisTaskPtEMCalTrigger.cxx:1099
 AliAnalysisTaskPtEMCalTrigger.cxx:1100
 AliAnalysisTaskPtEMCalTrigger.cxx:1101
 AliAnalysisTaskPtEMCalTrigger.cxx:1102
 AliAnalysisTaskPtEMCalTrigger.cxx:1103
 AliAnalysisTaskPtEMCalTrigger.cxx:1104
 AliAnalysisTaskPtEMCalTrigger.cxx:1105