PWGJE/AliAnalysisTaskPartonDisc.cxx

   1 /*************************************************************************
   2 * Copyright(c) 1998-2008, ALICE Experiment at CERN, All rights reserved. *
   3 *                                                                        *
   4 * Author: The ALICE Off-line Project.                                    *
   5 * Contributors are mentioned in the code where appropriate.              *
   6 *                                                                        *
   7 * Permission to use, copy, modify and distribute this software and its   *
   8 * documentation strictly for non-commercial purposes is hereby granted   *
   9 * without fee, provided that the above copyright notice appears in all   *
  10 * copies and that both the copyright notice and this permission notice   *
  11 * appear in the supporting documentation. The authors make no claims     *
  12 * about the suitability of this software for any purpose. It is          *
  13 * provided "as is" without express or implied warranty.                  *
  14 **************************************************************************/
  15
  16 ////////////////////////////////////////////////////////
  17 //                                                    //
  18 // Analysis task for parton discrimination studies    //
  19 //                                                    //
  20 // Author:                                            //
  21 // Hermes Leon Vargas  (hleon@ikf.uni-frankfurt.de)   //
  22 //                                                    //
  23 ////////////////////////////////////////////////////////
  24
  25 #include "TROOT.h"
  26 #include "TDirectory.h"
  27 #include "TKey.h"
  28 #include "TList.h"
  29 #include "TSystem.h"
  30 #include "TChain.h"
  31 #include "TTree.h"
  32 #include "TFile.h"
  33 #include "TString.h"
  34 #include "TH1F.h"
  35 #include "TH1I.h"
  36 #include "TH2F.h"
  37 #include "TH2I.h"
  38 #include "TH3F.h"
  39 #include "TProfile.h"
  40 #include "TCanvas.h"
  41 #include "AliAnalysisTask.h"
  42 #include "AliAnalysisManager.h"
  43 #include "AliAODHandler.h"
  44 #include "AliVEvent.h"
  45 #include "AliAODEvent.h"
  46 #include "AliAODInputHandler.h"
  47 #include "AliVParticle.h"
  48 #include "AliAODMCParticle.h"
  49 #include "AliGenEventHeader.h"
  50 #include "AliGenPythiaEventHeader.h"
  51 #include "AliGenDPMjetEventHeader.h"
  52 #include "AliAODMCHeader.h"
  53 #include "AliMCEventHandler.h"
  54 #include "AliMCEvent.h"
  55 #include <algorithm>
  56 #include "AliLog.h"
  57 #include "AliAODVertex.h"
  58 #include "AliAODHeader.h"
  59 #include "AliESDtrack.h"
  60 #include "AliAnalysisHelperJetTasks.h"
  61 #include "AliAnalysisTaskPartonDisc.h"
  62 #include "AliAODVZERO.h"
  63 #include "TRandom3.h"
  64 #include "TDatime.h"
  65
  66 // Analysis task for parton discrimination
  67
  68 ClassImp(AliAnalysisTaskPartonDisc)
  69
  70 Double_t *AliAnalysisTaskPartonDisc::fgContainer = 0x0;
  71
  72 //________________________________________________________________________
  73 AliAnalysisTaskPartonDisc::AliAnalysisTaskPartonDisc()
  74   : AliAnalysisTaskSE(), fAOD(0), fUseAODMC(kFALSE), fPhojetMC(kFALSE), fBranchMC("jetsMC"), fBranchRec("jetsREC"), fBranchSecRec(""), fSqrts(0),  fNtX(0), fJetRadius(0.), fFlavorRadius(0.), fFilterBit(0xFF), fOutputList(0), fJetPt(0), fJetPtSec(0), fJetPtMC(0), fJetEta(0), fJetEtaSec(0), fJetPhi(0), fJetPhiSec(0), fJetEtaMC(0), fJetPhiMC(0), fPtAODMC(0), fPtAOD(0), fEtaAODMC(0), fPhiAODMC(0), fEtaAOD(0), fPhiAOD(0), fFlavor(0), fNJetsMC(0), fNJetsRD(0), fNJetsRDSeco(0), fJetsMultPtMC(0), fJetsMultPtRD(0), fNChTrRD(0), fProfNChTrRD(0), fFracQQ(0), fFracGQ(0), fFracGG(0), fFracOutGoingQQ(0), fFracOutGoingGQ(0), fFracOutGoingGG(0), fh1Xsec(0), fh1Trials(0), fMpdg(0), fProcessJetPt(0), fFlavorLead(0), fProcessLeadJetPt(0), fPDGMothLPart(0), fFlavProc(0), fAvgTrials(1), fUseAODJetInput(kFALSE), fMinTrackPtInNTX(0), fMaxTrackPtInNTX(0), fSCMRD(0), fMinpTVal(0), fZVertex(0), fh1Events(0), fUseOnlyMC(kFALSE), fCheckMCStatus(kTRUE), fEvtCount(0), fNAccJetsMC(0), fNAccJetsRD(0), fNAccJetsRDSeco(0), fEnablePrints(kFALSE), fRecJetPtInclusive(0), fMCJetPtInclusive(0), fRecJetPtLeading(0), fMCJetPtLeading(0), fSecRecJetPtInclusive(0), fSecRecJetPtLeading(0), fHasPerpCone(kTRUE), fEtaPerpCoord(0), fPhiPerpCoord(0), fPtPerpCoord(0), fJetEvent(kFALSE), fPerpCone(0), fNChTrMCPerp(0), fNChTrRecPerp(0), fSCMMCPerp(0), fSCMRecPerp(0), fIsHIevent(kFALSE), fCurrentJetMinPtNT90(0), fBckgSbsJet(0), fCurrentJetMinPtNT90Recalc(0), fNChTrCorrMCQuark(0), fNChTrCorrMCGluon(0), fNChTrCorrMCPerp(0), fIsPossibleToSubstBckg(kTRUE), fNChTrRecECorr(0), fNChTrRecPerpECorr(0), fRefMult(0), fCurrentJetCharge(0), fRefMultWOJet(0), fVZEROMult(0), fMultWOJetVZero(0), fVZero(0), fRefMultFullV0(0), fRefMultV0Corr(0), fFullV0V0Corr(0), fNTXV0MultPt(0), fNTXCBMultPt(0), fMinpTValUE(2.0), fRefMultFullV0UJ(0), fRefMultV0CorrUJ(0), fFullV0V0CorrUJ(0), fMultWOJetVZeroUJ(0), fRefMultWOJetUJ(0), fMaxpTValUE(2.0), fRefAODTrackCount(0), fRefAODTrackCountUJ(0), fTrackCountWOJet(0), fTrackCountWOJetUJ(0), fTrackCountWOJetUJMC(0), fFullV0V0CorrUJMC(0), fMinpTValMC(2.0), fIncExcR(0.0), fForceNotTR(kFALSE), fNotExtDiJEx(kFALSE), fMinTrackPtInNTXRecalc(0), fMaxTrackPtInNTXRecalc(0), fPtDistInJetConeRaw(0), fPtDistInPerpConeRaw(0), fPtInPerpCon(0), fMinTrackPtInNTXR(0), fMaxTrackPtInNTXR(0), fEventCent(0), fJetEtaAll(0), fJetEtaOnlyTPCcut(0), fNChTrRecECorrPPMult(0), fNChTrRecPerpECorrPPMult(0), fForceSkipSJ(kFALSE), fJetPtCentPbPbRaw(0), fJetPtCentPbPbCorr(0), fJetAcceptance(0.5), fIncreasingExcl(kFALSE), fTotTracksCone(0), fTotTracksInCone(0), fTTrackRandomRejection(0), fJTrackRandomRejection(0), fMinPtInGlobMult(0)
  75 {
  76   // Constructor
  77
  78   for(Int_t a=0; a<16;a++)
  79     {
  80       fJetFlags[a]=kTRUE;
  81       if(a<12)
  82         {
  83           fNChTr[a]=0;
  84           fHistPtParton[a]=0;
  85           fSCM[a]=0;
  86           if(a<8)
  87             {
  88               fNChTrRDMult[a]=0;
  89               fNAccJetsRDMult[a]=0;
  90               fTotalJetCharge[a]=0;
  91               fSCMRDMult[a]=0;
  92               fNChTrRDMultMC[a]=0;
  93               fSCMRDMultMC[a]=0;
  94               fNChTrRDMultSE[a]=0;
  95               fNAccJetsRDMultSE[a]=0;
  96               fTotalJetChargeSE[a]=0;
  97               fSCMRDMultSE[a]=0;
  98               fNChTrRDMultOJ[a]=0;
  99               fSCMRDMultOJ[a]=0;
 100               fNChTrRDMultSEOJ[a]=0;
 101               fSCMRDMultSEOJ[a]=0;
 102               fNChTrRDMultOJMC[a]=0;
 103               fSCMRDMultOJMC[a]=0;
 104               fNChTrRDMultSEOJMC[a]=0;
 105               fSCMRDMultSEOJMC[a]=0;
 106               fNChTrRecPerpMultSEOJ[a]=0;
 107               fJEtaMCMultOJ[a]=0;
 108               fJEtaMCMultSEOJ[a]=0;
 109               fJEtaRDMultOJ[a]=0;
 110               fJEtaRDMultSEOJ[a]=0;
 111               fJetPtMCMultOJ[a]=0;
 112               fJetPtMCMultSEOJ[a]=0;
 113               fJetPtRDMultOJ[a]=0;
 114               fJetPtRDMultSEOJ[a]=0;
 115               fEntriesQuark[a]=0;
 116               fEntriesGluon[a]=0;
 117             }
 118           if(a<6)
 119             {
 120               fProcessPDG[a]=0;
 121               fFragPion[a]=0;
 122               fFragKaon[a]=0;
 123               fFragProton[a]=0;
 124               fFragChargedR4[a]=0;
 125               fFragChargedR3[a]=0;
 126               fFragChargedR2[a]=0;
 127               fHistContainerR4[a]=0;
 128               fHistContainerR3[a]=0;
 129               fHistContainerR2[a]=0;
 130               if(a<3)
 131                 {
 132                   fJetEtaJetPt[a]=0;
 133                   if(a<2)
 134                     {
 135                       fFragCandidates[a]=0;
 136                       fMinTrackPtInNTXh[a]=0;
 137                       fMaxTrackPtInNTXh[a]=0;
 138                     }
 139                 }
 140             }
 141         }
 142     }
 143 }
 144 //________________________________________________________________________
 145 AliAnalysisTaskPartonDisc::AliAnalysisTaskPartonDisc(const char *name)
 146   : AliAnalysisTaskSE(name), fAOD(0), fUseAODMC(kFALSE), fPhojetMC(kFALSE), fBranchMC("jetsMC"), fBranchRec("jetsREC"), fBranchSecRec(""), fSqrts(0),  fNtX(0), fJetRadius(0.), fFlavorRadius(0.), fFilterBit(0xFF), fOutputList(0), fJetPt(0), fJetPtSec(0), fJetPtMC(0), fJetEta(0), fJetEtaSec(0), fJetPhi(0), fJetPhiSec(0), fJetEtaMC(0), fJetPhiMC(0), fPtAODMC(0), fPtAOD(0), fEtaAODMC(0), fPhiAODMC(0), fEtaAOD(0), fPhiAOD(0), fFlavor(0), fNJetsMC(0), fNJetsRD(0), fNJetsRDSeco(0), fJetsMultPtMC(0), fJetsMultPtRD(0), fNChTrRD(0), fProfNChTrRD(0), fFracQQ(0), fFracGQ(0), fFracGG(0), fFracOutGoingQQ(0), fFracOutGoingGQ(0), fFracOutGoingGG(0), fh1Xsec(0), fh1Trials(0), fMpdg(0), fProcessJetPt(0), fFlavorLead(0), fProcessLeadJetPt(0), fPDGMothLPart(0), fFlavProc(0), fAvgTrials(1), fUseAODJetInput(kFALSE), fMinTrackPtInNTX(0), fMaxTrackPtInNTX(0), fSCMRD(0), fMinpTVal(0), fZVertex(0), fh1Events(0), fUseOnlyMC(kFALSE), fCheckMCStatus(kTRUE), fEvtCount(0), fNAccJetsMC(0), fNAccJetsRD(0), fNAccJetsRDSeco(0), fEnablePrints(kFALSE), fRecJetPtInclusive(0), fMCJetPtInclusive(0), fRecJetPtLeading(0), fMCJetPtLeading(0), fSecRecJetPtInclusive(0), fSecRecJetPtLeading(0), fHasPerpCone(kTRUE), fEtaPerpCoord(0), fPhiPerpCoord(0), fPtPerpCoord(0), fJetEvent(kFALSE), fPerpCone(0), fNChTrMCPerp(0), fNChTrRecPerp(0), fSCMMCPerp(0), fSCMRecPerp(0), fIsHIevent(kFALSE), fCurrentJetMinPtNT90(0), fBckgSbsJet(0), fCurrentJetMinPtNT90Recalc(0), fNChTrCorrMCQuark(0), fNChTrCorrMCGluon(0), fNChTrCorrMCPerp(0), fIsPossibleToSubstBckg(kTRUE), fNChTrRecECorr(0), fNChTrRecPerpECorr(0), fRefMult(0), fCurrentJetCharge(0), fRefMultWOJet(0), fVZEROMult(0), fMultWOJetVZero(0), fVZero(0), fRefMultFullV0(0), fRefMultV0Corr(0), fFullV0V0Corr(0), fNTXV0MultPt(0), fNTXCBMultPt(0), fMinpTValUE(2.0), fRefMultFullV0UJ(0), fRefMultV0CorrUJ(0), fFullV0V0CorrUJ(0), fMultWOJetVZeroUJ(0), fRefMultWOJetUJ(0), fMaxpTValUE(2.0), fRefAODTrackCount(0), fRefAODTrackCountUJ(0), fTrackCountWOJet(0), fTrackCountWOJetUJ(0), fTrackCountWOJetUJMC(0), fFullV0V0CorrUJMC(0), fMinpTValMC(2.0), fIncExcR(0.0), fForceNotTR(kFALSE), fNotExtDiJEx(kFALSE), fMinTrackPtInNTXRecalc(0), fMaxTrackPtInNTXRecalc(0), fPtDistInJetConeRaw(0), fPtDistInPerpConeRaw(0), fPtInPerpCon(0), fMinTrackPtInNTXR(0), fMaxTrackPtInNTXR(0), fEventCent(0), fJetEtaAll(0), fJetEtaOnlyTPCcut(0), fNChTrRecECorrPPMult(0), fNChTrRecPerpECorrPPMult(0), fForceSkipSJ(kFALSE), fJetPtCentPbPbRaw(0), fJetPtCentPbPbCorr(0), fJetAcceptance(0.5), fIncreasingExcl(kFALSE), fTotTracksCone(0), fTotTracksInCone(0), fTTrackRandomRejection(0), fJTrackRandomRejection(0), fMinPtInGlobMult(0)
 147 {
 148
 149   // Constructor
 150
 151   for(Int_t a=0; a<16;a++)
 152     {
 153       fJetFlags[a]=kTRUE;
 154       if(a<12)
 155         {
 156           fNChTr[a]=0;
 157           fHistPtParton[a]=0;
 158           fSCM[a]=0;
 159           if(a<8)
 160             {
 161               fNChTrRDMult[a]=0;
 162               fNAccJetsRDMult[a]=0;
 163               fTotalJetCharge[a]=0;
 164               fSCMRDMult[a]=0;
 165               fNChTrRDMultMC[a]=0;
 166               fSCMRDMultMC[a]=0;
 167               fNChTrRDMultSE[a]=0;
 168               fNAccJetsRDMultSE[a]=0;
 169               fTotalJetChargeSE[a]=0;
 170               fSCMRDMultSE[a]=0;
 171               fNChTrRDMultOJ[a]=0;
 172               fSCMRDMultOJ[a]=0;
 173               fNChTrRDMultSEOJ[a]=0;
 174               fSCMRDMultSEOJ[a]=0;
 175               fNChTrRDMultOJMC[a]=0;
 176               fSCMRDMultOJMC[a]=0;
 177               fNChTrRDMultSEOJMC[a]=0;
 178               fSCMRDMultSEOJMC[a]=0;
 179               fNChTrRecPerpMultSEOJ[a]=0;
 180               fJEtaMCMultOJ[a]=0;
 181               fJEtaMCMultSEOJ[a]=0;
 182               fJEtaRDMultOJ[a]=0;
 183               fJEtaRDMultSEOJ[a]=0;
 184               fJetPtMCMultOJ[a]=0;
 185               fJetPtMCMultSEOJ[a]=0;
 186               fJetPtRDMultOJ[a]=0;
 187               fJetPtRDMultSEOJ[a]=0;
 188               fEntriesQuark[a]=0;
 189               fEntriesGluon[a]=0;
 190             }
 191           if(a<6)
 192             {
 193               fProcessPDG[a]=0;
 194               fFragPion[a]=0;
 195               fFragKaon[a]=0;
 196               fFragProton[a]=0;
 197               fFragChargedR4[a]=0;
 198               fFragChargedR3[a]=0;
 199               fFragChargedR2[a]=0;
 200               fHistContainerR4[a]=0;
 201               fHistContainerR3[a]=0;
 202               fHistContainerR2[a]=0;
 203               if(a<3)
 204                 {
 205                   fJetEtaJetPt[a]=0;
 206                   if(a<2)
 207                     {
 208                       fFragCandidates[a]=0;
 209                       fMinTrackPtInNTXh[a]=0;
 210                       fMaxTrackPtInNTXh[a]=0;
 211                     }
 212                 }
 213             }
 214         }
 215     }
 216
 217   // Define input and output slots here
 218   // Input slot #0 works with a TChain
 219   DefineInput(0, TChain::Class());
 220   // Output slot #0 id reserved by the base class for AOD
 221   // Output slot #1 writes into a TH1 container
 222   DefineOutput(1, TList::Class());
 223 }
 224 //________________________________________________________________________
 225 Bool_t AliAnalysisTaskPartonDisc::UserNotify()
 226 {
 227   //
 228   // read the cross sections
 229   // and number of trials from pyxsec.root
 230   // from AliAnalysisTaskJetSpectrum2
 231   //
 232
 233   TTree *tree = AliAnalysisManager::GetAnalysisManager()->GetTree();
 234   Float_t xsection = 0;
 235   Float_t ftrials  = 1;
 236   Int_t nevents = 0;
 237
 238   fAvgTrials = 1;
 239   if(tree)
 240     {
 241       TFile *curfile = tree->GetCurrentFile();
 242       if (!curfile)
 243         {
 244           Error("Notify","No current file");
 245           return kFALSE;
 246         }
 247       if(!fh1Xsec||!fh1Trials)
 248         {
 249           Printf("%s%d No Histogram fh1Xsec",(char*)__FILE__,__LINE__);
 250           return kFALSE;
 251         }
 252       AliAnalysisHelperJetTasks::PythiaInfoFromFile(curfile->GetName(),xsection,ftrials);
 253       fh1Xsec->Fill("<#sigma>",xsection);
 254       // construct a poor man average trials (per event!?)
 255       Float_t nEntries = (Float_t)tree->GetTree()->GetEntries();
 256       if(ftrials>=nEntries && nEntries>0.)fAvgTrials = ftrials/nEntries;
 257       // number of events read out to create the AOD
 258       NumberOfReadEventsAOD(curfile->GetName(),nevents);
 259       fh1Events->Fill("#sum{nevents}",nevents); //  filled once per file
 260     }
 261   return kTRUE;
 262
 263 }
 264 //________________________________________________________________________
 265 void AliAnalysisTaskPartonDisc::UserCreateOutputObjects()
 266 {
 267   // Create histograms
 268   // Called once
 269
 270   fOutputList = new TList();
 271   fOutputList->SetOwner(kTRUE);
 272
 273   fJetPt = new TH1F("fJetPt", "p_{T} distribution of reco jets", 60, 0., 300.);
 274   fJetPt->GetXaxis()->SetTitle("p_{T} (GeV/c)");
 275   fJetPt->GetYaxis()->SetTitle("dN/dp_{T} (c/GeV)");
 276   fJetPt->Sumw2();
 277   fOutputList->Add(fJetPt);
 278
 279   fJetPtSec = new TH1F("fJetPtSec", "p_{T} distribution of reco jets, seconday rec branch", 60, 0., 300.);
 280   fJetPtSec->GetXaxis()->SetTitle("p_{T} (GeV/c)");
 281   fJetPtSec->GetYaxis()->SetTitle("dN/dp_{T} (c/GeV)");
 282   fJetPtSec->Sumw2();
 283   fOutputList->Add(fJetPtSec);
 284
 285   fJetPtMC = new TH1F("fJetPtMC", "p_{T} distribution of mc jets", 60, 0., 300.);
 286   fJetPtMC->GetXaxis()->SetTitle("p_{T} (GeV/c)");
 287   fJetPtMC->GetYaxis()->SetTitle("dN/dp_{T} (c/GeV)");
 288   fJetPtMC->Sumw2();
 289   fOutputList->Add(fJetPtMC);
 290
 291   fJetEta = new TH2F("fJetEta", "Eta distribution of reconstructed jets", 50, -1.5, 1.5, 50, -1.5, 1.5);
 292   fJetEta->GetXaxis()->SetTitle("#eta");
 293   fJetEta->GetYaxis()->SetTitle("#eta");
 294   fJetEta->Sumw2();
 295   fOutputList->Add(fJetEta);
 296
 297   fJetEtaSec = new TH2F("fJetEtaSec", "Eta distribution of reconstructed jets, secondary branch", 50, -1.5, 1.5, 50, -1.5, 1.5);
 298   fJetEtaSec->GetXaxis()->SetTitle("#eta");
 299   fJetEtaSec->GetYaxis()->SetTitle("#eta");
 300   fJetEtaSec->Sumw2();
 301   fOutputList->Add(fJetEtaSec);
 302
 303   fJetPhi = new TH2F("fJetPhi", "Phi distribution of reconstructed jets", 50, 0., TMath::TwoPi(), 50, 0., TMath::TwoPi());
 304   fJetPhi->GetXaxis()->SetTitle("#phi");
 305   fJetPhi->GetYaxis()->SetTitle("#phi");
 306   fJetPhi->Sumw2();
 307   fOutputList->Add(fJetPhi);
 308
 309   fJetPhiSec = new TH2F("fJetPhiSec", "Phi distribution of reconstructed jets, secondary branch", 50, 0., TMath::TwoPi(), 50, 0., TMath::TwoPi());
 310   fJetPhiSec->GetXaxis()->SetTitle("#phi");
 311   fJetPhiSec->GetYaxis()->SetTitle("#phi");
 312   fJetPhiSec->Sumw2();
 313   fOutputList->Add(fJetPhiSec);
 314
 315   fJetEtaMC = new TH2F("fJetEtaMC", "Eta distribution of MC jets", 50, -1.5, 1.5, 50, -1.5, 1.5);
 316   fJetEtaMC->GetXaxis()->SetTitle("#eta");
 317   fJetEtaMC->GetYaxis()->SetTitle("#eta");
 318   fJetEtaMC->Sumw2();
 319   fOutputList->Add(fJetEtaMC);
 320
 321   fJetPhiMC = new TH2F("fJetPhiMC", "Phi distribution of MC jets", 50, 0., TMath::TwoPi(), 50, 0., TMath::TwoPi());
 322   fJetPhiMC->GetXaxis()->SetTitle("#phi");
 323   fJetPhiMC->GetYaxis()->SetTitle("#phi");
 324   fJetPhiMC->Sumw2();
 325   fOutputList->Add(fJetPhiMC);
 326
 327   fPtAODMC = new TH2F("fPtAODMC", "p_{T} distribution of mc tracks", 200, 0., 100., 200, 0., 100.);
 328   fPtAODMC->GetXaxis()->SetTitle("p_{T} (GeV/c)");
 329   fPtAODMC->GetYaxis()->SetTitle("p_{T} (GeV/c)");
 330   fPtAODMC->Sumw2();
 331   fOutputList->Add(fPtAODMC);
 332
 333   fPtAOD = new TH2F("fPtAOD", "p_{T} distribution of aod tracks", 200, 0., 100., 200, 0., 100.);
 334   fPtAOD->GetXaxis()->SetTitle("p_{T} (GeV/c)");
 335   fPtAOD->GetYaxis()->SetTitle("p_{T} (GeV/c)");
 336   fPtAOD->Sumw2();
 337   fOutputList->Add(fPtAOD);
 338
 339   fEtaAODMC = new TH2F("fEtaAODMC", "Eta distribution of MC aod tracks", 50, -1.5, 1.5, 50, -1.5, 1.5);
 340   fEtaAODMC->GetXaxis()->SetTitle("#eta");
 341   fEtaAODMC->GetYaxis()->SetTitle("#eta");
 342   fEtaAODMC->Sumw2();
 343   fOutputList->Add(fEtaAODMC);
 344
 345   fPhiAODMC = new TH2F("fPhiAODMC", "Phi distribution of MC aod tracks", 50, 0., TMath::TwoPi(), 50, 0., TMath::TwoPi());
 346   fPhiAODMC->GetXaxis()->SetTitle("#phi");
 347   fPhiAODMC->GetYaxis()->SetTitle("#phi");
 348   fPhiAODMC->Sumw2();
 349   fOutputList->Add(fPhiAODMC);
 350
 351   fEtaAOD = new TH2F("fEtaAOD", "Eta distribution of aod tracks", 50, -1.5, 1.5, 50, -1.5, 1.5);
 352   fEtaAOD->GetXaxis()->SetTitle("#eta");
 353   fEtaAOD->GetYaxis()->SetTitle("#eta");
 354   fEtaAOD->Sumw2();
 355   fOutputList->Add(fEtaAOD);
 356
 357   fPhiAOD = new TH2F("fPhiAOD", "Phi distribution of aod tracks", 50, 0.,TMath::TwoPi(), 50, 0.,TMath::TwoPi());
 358   fPhiAOD->GetXaxis()->SetTitle("#phi");
 359   fPhiAOD->GetYaxis()->SetTitle("#phi");
 360   fPhiAOD->Sumw2();
 361   fOutputList->Add(fPhiAOD);
 362
 363   fFlavor = new TH2F("fFlavor", "Flavor distribution of jets", 27, -5.5, 21.5, 60, 0., 300.);
 364   fFlavor->GetXaxis()->SetTitle("PDG code");
 365   fFlavor->GetYaxis()->SetTitle("p_{T}^{JET}");
 366   fFlavor->Sumw2();
 367   fOutputList->Add(fFlavor);
 368
 369   fNJetsMC = new TH2F("fNJetsMC", "Number of simulated jets per event, as a function of p_T", 101, -0.5, 100.5, 101, -0.5, 100.5);
 370   fNJetsMC->GetXaxis()->SetTitle("Number of jets");
 371   fNJetsMC->GetYaxis()->SetTitle("Number of jets");
 372   fNJetsMC->Sumw2();
 373   fOutputList->Add(fNJetsMC);
 374
 375   fNJetsRD = new TH2F("fNJetsRD", "Number of jets per event in real data", 101, -0.5, 100.5, 101, -0.5, 100.5);
 376   fNJetsRD->GetXaxis()->SetTitle("Number of jets");
 377   fNJetsRD->GetYaxis()->SetTitle("Number of jets");
 378   fNJetsRD->Sumw2();
 379   fOutputList->Add(fNJetsRD);
 380
 381   fNJetsRDSeco = new TH2F("fNJetsRDSeco", "Number of jets per event in real data, secondary branch", 101, -0.5, 100.5, 101, -0.5, 100.5);
 382   fNJetsRDSeco->GetXaxis()->SetTitle("Number of jets");
 383   fNJetsRDSeco->GetYaxis()->SetTitle("Number of jets");
 384   fNJetsRDSeco->Sumw2();
 385   fOutputList->Add(fNJetsRDSeco);
 386
 387   fJetsMultPtMC = new TH2F("fJetsMultPtMC", "Jet multiplicity associated to jet pT, as a function of p_T MC", 60, 0., 300., 7, -0.5, 6.5);
 388   fJetsMultPtMC->GetXaxis()->SetTitle("p_{T}^{JET}");
 389   fJetsMultPtMC->GetYaxis()->SetTitle("Number of jets");
 390   fJetsMultPtMC->Sumw2();
 391   fOutputList->Add(fJetsMultPtMC);
 392
 393   fJetsMultPtRD = new TH2F("fJetsMultPtRD", "Jet multiplicity associated to jet pT, as a function of p_T Reco Data",60, 0., 300., 7, -0.5, 6.5);
 394   fJetsMultPtRD->GetXaxis()->SetTitle("p_{T}^{JET}");
 395   fJetsMultPtRD->GetYaxis()->SetTitle("Number of jets");
 396   fJetsMultPtRD->Sumw2();
 397   fOutputList->Add(fJetsMultPtRD);
 398
 399   fNChTrRD = new TH2F("fNChTrRD","Number of tracks to recover transverse energy, jet_{p_{T}}",101,-0.5,100.5, 60, 0., 300.);
 400   fNChTrRD->GetXaxis()->SetTitle("NTracks");
 401   fNChTrRD->GetYaxis()->SetTitle("p_{T}^{JET}");
 402   fNChTrRD->Sumw2();
 403   fOutputList->Add(fNChTrRD);
 404
 405   fProfNChTrRD = new TProfile("fProfNChTrRD","Number of tracks to recover transverse energy, jet_{p_{T}}", 50, 0, 250);
 406   fProfNChTrRD->GetXaxis()->SetTitle("p_{T}^{JET}");
 407   fProfNChTrRD->GetYaxis()->SetTitle("NTracks");
 408   fProfNChTrRD->Sumw2();
 409   fOutputList->Add(fProfNChTrRD);
 410
 411   fFracQQ = new TH1F("fFracQQ","QQ",1000,0.,0.5);
 412   fFracQQ->GetXaxis()->SetTitle("x_{T}");
 413   fFracQQ->GetYaxis()->SetTitle("Entries");
 414   fFracQQ->Sumw2();
 415   fOutputList->Add(fFracQQ);
 416
 417   fFracGQ = new TH1F("fFracGQ","GQ",1000,0.,0.5);
 418   fFracGQ->GetXaxis()->SetTitle("x_{T}");
 419   fFracGQ->GetYaxis()->SetTitle("Entries");
 420   fFracGQ->Sumw2();
 421   fOutputList->Add(fFracGQ);
 422
 423   fFracGG = new TH1F("fFracGG","GG",1000,0.,0.5);
 424   fFracGG->GetXaxis()->SetTitle("x_{T}");
 425   fFracGG->GetYaxis()->SetTitle("Entries");
 426   fFracGG->Sumw2();
 427   fOutputList->Add(fFracGG);
 428
 429   fFracOutGoingQQ = new TH1F("fFracOutGoingQQ","QQ",1000,0.,0.5);
 430   fFracOutGoingQQ->GetXaxis()->SetTitle("x_{T}");
 431   fFracOutGoingQQ->GetYaxis()->SetTitle("Entries");
 432   fFracOutGoingQQ->Sumw2();
 433   fOutputList->Add(fFracOutGoingQQ);
 434
 435   fFracOutGoingGQ = new TH1F("fFracOutGoingGQ","GQ",1000,0.,0.5);
 436   fFracOutGoingGQ->GetXaxis()->SetTitle("x_{T}");
 437   fFracOutGoingGQ->GetYaxis()->SetTitle("Entries");
 438   fFracOutGoingGQ->Sumw2();
 439   fOutputList->Add(fFracOutGoingGQ);
 440
 441   fFracOutGoingGG = new TH1F("fFracOutGoingGG","GG",1000,0.,0.5);
 442   fFracOutGoingGG->GetXaxis()->SetTitle("x_{T}");
 443   fFracOutGoingGG->GetYaxis()->SetTitle("Entries");
 444   fFracOutGoingGG->Sumw2();
 445   fOutputList->Add(fFracOutGoingGG);
 446
 447   fh1Xsec =  new TProfile("h1Xsec","xsec from pyxsec.root",1,0,1);
 448   fh1Xsec->SetXTitle("<#sigma>");
 449   fh1Xsec->Sumw2();
 450   fOutputList->Add(fh1Xsec);
 451
 452   fh1Trials = new TH1F("h1Trials","trials from pyxsec.root",1,0,1);
 453   fh1Trials->SetXTitle("#sum{ntrials}");
 454   fh1Trials->Sumw2();
 455   fOutputList->Add(fh1Trials);
 456
 457   fProcessJetPt = new TH2F("fProcessJetPt","Pythia process number, jet_{p_{T}}",70, 0.5, 70.5, 60, 0., 300.);
 458   fProcessJetPt->GetXaxis()->SetTitle("Pythia process");
 459   fProcessJetPt->GetYaxis()->SetTitle("p_{T}^{JET}");
 460   fProcessJetPt->Sumw2();
 461   fOutputList->Add(fProcessJetPt);
 462
 463   fFlavorLead = new TH2F("fFlavorLead", "Flavor distribution of leading jets", 27, -5.5, 21.5, 60, 0., 300.);
 464   fFlavorLead->GetXaxis()->SetTitle("PDG code");
 465   fFlavorLead->GetYaxis()->SetTitle("p_{T}^{JET}");
 466   fFlavorLead->Sumw2();
 467   fOutputList->Add(fFlavorLead);
 468
 469   fProcessLeadJetPt = new TH2F("fProcessLeadJetPt","Pythia process number for leading, jet_{p_{T}}",70, 0.5, 70.5, 60, 0., 300.);
 470   fProcessLeadJetPt->GetXaxis()->SetTitle("Pythia process");
 471   fProcessLeadJetPt->GetYaxis()->SetTitle("p_{T}^{JET}");
 472   fProcessLeadJetPt->Sumw2();
 473   fOutputList->Add(fProcessLeadJetPt);
 474
 475   fPDGMothLPart = new TH3F("fPDGMothLPart","Mother of leading parton, leading parton, jet p_{T}", 27, -5.5, 21.5, 27, -5.5, 21.5, 60, 0., 300.);
 476   fPDGMothLPart->GetXaxis()->SetTitle("Mother of leading parton");
 477   fPDGMothLPart->GetYaxis()->SetTitle("Leading parton");
 478   fPDGMothLPart->GetZaxis()->SetTitle("p_{T}^{JET}");
 479   fPDGMothLPart->Sumw2();
 480   fOutputList->Add(fPDGMothLPart);
 481
 482   fFlavProc = new TH2F("fFlavProc","Flavor, Flavor status code", 27, -5.5, 21.5, 101, -0.5, 100.5);
 483   fFlavProc->GetXaxis()->SetTitle("Jet flavor");
 484   fFlavProc->GetYaxis()->SetTitle("Parton status code");
 485   fFlavProc->Sumw2();
 486   fOutputList->Add(fFlavProc);
 487
 488   fSCMRD = new TH2F("fSCMRD","Second Central Moment, jet_{p_{T}}",200,0.,0.2, 60, 0., 300.);
 489   fSCMRD->GetXaxis()->SetTitle("<#delta R_{c}^{2}>");
 490   fSCMRD->GetYaxis()->SetTitle("p_{T}^{JET}");
 491   fSCMRD->Sumw2();
 492   fOutputList->Add(fSCMRD);
 493
 494   fZVertex = new TH2F("fZVertex","Z vertex position, Z vertex position}",40,-20.,20., 40, -20., 20.);
 495   fZVertex->GetXaxis()->SetTitle("Vertex z");
 496   fZVertex->GetYaxis()->SetTitle("Vertex z");
 497   fZVertex->Sumw2();
 498   fOutputList->Add(fZVertex);
 499
 500   fh1Events = new TH1F("fh1Events","nevents from PWG4_JetTasksOutput.root",1,0,1);
 501   fh1Events->SetXTitle("#sum{nevents}");
 502   fh1Events->Sumw2();
 503   fOutputList->Add(fh1Events);
 504
 505   fNAccJetsMC = new TH2F("fNAccJetsMC", "Number accepted simulated jets per event", 101, -0.5, 100.5, 101, -0.5, 100.5);
 506   fNAccJetsMC->GetXaxis()->SetTitle("Number of jets");
 507   fNAccJetsMC->GetYaxis()->SetTitle("Number of jets");
 508   fNAccJetsMC->Sumw2();
 509   fOutputList->Add(fNAccJetsMC);
 510
 511   fNAccJetsRD = new TH2F("fNAccJetsRD", "Number of accepted jets per event in real data", 101, -0.5, 100.5, 101, -0.5, 100.5);
 512   fNAccJetsRD->GetXaxis()->SetTitle("Number of jets");
 513   fNAccJetsRD->GetYaxis()->SetTitle("Number of jets");
 514   fNAccJetsRD->Sumw2();
 515   fOutputList->Add(fNAccJetsRD);
 516
 517   fNAccJetsRDSeco = new TH2F("fNAccJetsRDSeco", "Number of accepted jets per event in real data, secondary branch", 101, -0.5, 100.5, 101, -0.5, 100.5);
 518   fNAccJetsRDSeco->GetXaxis()->SetTitle("Number of jets");
 519   fNAccJetsRDSeco->GetYaxis()->SetTitle("Number of jets");
 520   fNAccJetsRDSeco->Sumw2();
 521   fOutputList->Add(fNAccJetsRDSeco);
 522
 523   fRecJetPtInclusive = new TH1F("fRecJetPtInclusive", "p_{T} distribution of inclusive reco jets", 60, 0., 300.);
 524   fRecJetPtInclusive->GetXaxis()->SetTitle("p_{T} (GeV/c)");
 525   fRecJetPtInclusive->GetYaxis()->SetTitle("d#sigma (mb)");
 526   fRecJetPtInclusive->Sumw2();
 527   fOutputList->Add(fRecJetPtInclusive);
 528
 529   fMCJetPtInclusive = new TH1F("fMCJetPtInclusive", "p_{T} distribution of inclusive MC jets", 60, 0., 300.);
 530   fMCJetPtInclusive->GetXaxis()->SetTitle("p_{T} (GeV/c)");
 531   fMCJetPtInclusive->GetYaxis()->SetTitle("d#sigma (mb)");
 532   fMCJetPtInclusive->Sumw2();
 533   fOutputList->Add(fMCJetPtInclusive);
 534
 535   fRecJetPtLeading = new TH1F("fRecJetPtLeading", "p_{T} distribution of leading reco jets", 60, 0., 300.);
 536   fRecJetPtLeading->GetXaxis()->SetTitle("p_{T} (GeV/c)");
 537   fRecJetPtLeading->GetYaxis()->SetTitle("d#sigma (mb)");
 538   fRecJetPtLeading->Sumw2();
 539   fOutputList->Add(fRecJetPtLeading);
 540
 541   fMCJetPtLeading = new TH1F("fMCJetPtLeading", "p_{T} distribution of leading MC jets", 60, 0., 300.);
 542   fMCJetPtLeading->GetXaxis()->SetTitle("p_{T} (GeV/c)");
 543   fMCJetPtLeading->GetYaxis()->SetTitle("d#sigma (mb)");
 544   fMCJetPtLeading->Sumw2();
 545   fOutputList->Add(fMCJetPtLeading);
 546
 547   fSecRecJetPtInclusive = new TH1F("fSecRecJetPtInclusive", "p_{T} distribution of inclusive reco jets (2nd branch)", 60, 0., 300.);
 548   fSecRecJetPtInclusive->GetXaxis()->SetTitle("p_{T} (GeV/c)");
 549   fSecRecJetPtInclusive->GetYaxis()->SetTitle("d#sigma (mb)");
 550   fSecRecJetPtInclusive->Sumw2();
 551   fOutputList->Add(fSecRecJetPtInclusive);
 552
 553   fSecRecJetPtLeading = new TH1F("fSecRecJetPtLeading", "p_{T} distribution of leading reco jets (2nd branch)", 60, 0., 300.);
 554   fSecRecJetPtLeading->GetXaxis()->SetTitle("p_{T} (GeV/c)");
 555   fSecRecJetPtLeading->GetYaxis()->SetTitle("d#sigma (mb)");
 556   fSecRecJetPtLeading->Sumw2();
 557   fOutputList->Add(fSecRecJetPtLeading);
 558
 559   fNChTrMCPerp = new TH2F("fNChTrMCPerp","Number of tracks to recover transverse energy of perp. cone, jet_{p_{T} MC}",101,-0.5,100.5, 60, 0., 300.);
 560   fNChTrMCPerp->GetXaxis()->SetTitle("NTracks Perp");
 561   fNChTrMCPerp->GetYaxis()->SetTitle("p_{T}^{MC JET}");
 562   fNChTrMCPerp->Sumw2();
 563   fOutputList->Add(fNChTrMCPerp);
 564
 565   fNChTrRecPerp = new TH2F("fNChTrRecPerp","Number of tracks to recover transverse energy of perp. cone, jet_{p_{T} Rec}",101,-0.5,100.5, 60, 0., 300.);
 566   fNChTrRecPerp->GetXaxis()->SetTitle("NTracks Perp");
 567   fNChTrRecPerp->GetYaxis()->SetTitle("p_{T}^{RECO JET}");
 568   fNChTrRecPerp->Sumw2();
 569   fOutputList->Add(fNChTrRecPerp);
 570
 571   fSCMMCPerp = new TH2F("fSCMMCPerp","Second Central Moment of perp. cone, jet_{p_{T} MC}",200,0.,0.2, 60, 0., 300.);
 572   fSCMMCPerp->GetXaxis()->SetTitle("<#delta R_{c}^{2}> Perp");
 573   fSCMMCPerp->GetYaxis()->SetTitle("p_{T}^{JET}");
 574   fSCMMCPerp->Sumw2();
 575   fOutputList->Add(fSCMMCPerp);
 576
 577   fSCMRecPerp = new TH2F("fSCMRecPerp","Second Central Moment of perp. cone, jet_{p_{T} Reco}",200,0.,0.2, 60, 0., 300.);
 578   fSCMRecPerp->GetXaxis()->SetTitle("<#delta R_{c}^{2}> Perp");
 579   fSCMRecPerp->GetYaxis()->SetTitle("p_{T}^{JET}");
 580   fSCMRecPerp->Sumw2();
 581   fOutputList->Add(fSCMRecPerp);
 582
 583   fNChTrCorrMCQuark = new TH2F("fNChTrCorrMCQuark","Number of tracks to recover corrected transverse energy, MC quarks",101,-0.5,100.5, 60, 0., 300.);
 584   fNChTrCorrMCQuark->GetXaxis()->SetTitle("NTracks");
 585   fNChTrCorrMCQuark->GetYaxis()->SetTitle("p_{T}^{MC Corr. JET}");
 586   fNChTrCorrMCQuark->Sumw2();
 587   fOutputList->Add(fNChTrCorrMCQuark);
 588
 589   fNChTrCorrMCGluon = new TH2F("fNChTrCorrMCGluon","Number of tracks to recover corrected transverse energy, MC gluons",101,-0.5,100.5, 60, 0., 300.);
 590   fNChTrCorrMCGluon->GetXaxis()->SetTitle("NTracks");
 591   fNChTrCorrMCGluon->GetYaxis()->SetTitle("p_{T}^{MC Corr. JET}");
 592   fNChTrCorrMCGluon->Sumw2();
 593   fOutputList->Add(fNChTrCorrMCGluon);
 594
 595   fNChTrCorrMCPerp = new TH2F("fNChTrCorrMCPerp","Number of tracks to recover perp. cone. after corrected jet pT",101,-0.5,100.5, 60, 0., 300.);
 596   fNChTrCorrMCPerp->GetXaxis()->SetTitle("NTracks");
 597   fNChTrCorrMCPerp->GetYaxis()->SetTitle("p_{T}^{MC Corr. JET}");
 598   fNChTrCorrMCPerp->Sumw2();
 599   fOutputList->Add(fNChTrCorrMCPerp);
 600
 601   // 9 selection bins: (nuevo)
 602   // 1st. Proton collisions                  fill 1  Bin1 [0.5,1.5)
 603   // 2nd. PbPb collisions, Bin  0-10         fill 2  Bin2 [1.5,2.5)
 604   // 3rd. PbPb collisions, Bin 10-20         fill 3  Bin3 [2.5,3.5)
 605   // 4rd. PbPb collisions, Bin 20-30         fill 4  Bin4 [3.5,4.5)
 606   // 5th. PbPb collisions, Bin 30-40         fill 5  Bin5 [4.5,5.5)
 607   // 6th. PbPb collisions, Bin 40-50         fill 6  Bin6 [5.5,6.5)
 608   // 7th. PbPb collisions, Bin 50-60         fill 7  Bin7 [6.5,7.5)
 609   // 8th. PbPb collisions, Bin 60-70         fill 8  Bin8 [7.5,8.5)
 610   // 9th. PbPb collisions, Bin 70-80         fill 9  Bin9 [8.5,9.5)
 611   // 10th. PbPb collisions, Bin 80-100.1    fill 10  Bin10 [9.5,10.5)
 612
 613   fNChTrRecECorr = new TH3F("fNChTrRecECorr","NTX in ener. corr. jet , corr. jet pT, centrality",101,-0.5,100.5, 60, 0., 300.,10,0.5,10.5);
 614   fNChTrRecECorr->GetXaxis()->SetTitle("NTracks");
 615   fNChTrRecECorr->GetYaxis()->SetTitle("p_{T}^{JET}");
 616   fNChTrRecECorr->GetZaxis()->SetTitle("Selection Bin");
 617   fNChTrRecECorr->Sumw2();
 618   fOutputList->Add(fNChTrRecECorr);
 619
 620   fNChTrRecPerpECorr = new TH3F("fNChTrRecPerpECorr","Tracks above min in perp.cone , corr. jet pT, centrality",101,-0.5,100.5, 60, 0., 300.,10,0.5,10.5);
 621   fNChTrRecPerpECorr->GetXaxis()->SetTitle("NTracks");
 622   fNChTrRecPerpECorr->GetYaxis()->SetTitle("p_{T}^{JET}");
 623   fNChTrRecPerpECorr->GetZaxis()->SetTitle("Selection Bin");
 624   fNChTrRecPerpECorr->Sumw2();
 625   fOutputList->Add(fNChTrRecPerpECorr);
 626
 627   fRefMult = new TH1F("fRefMult", "Reference multiplicity in the AOD", 301, -0.5, 300.5);
 628   fRefMult->GetXaxis()->SetTitle("Reference multiplicity");
 629   fRefMult->Sumw2();
 630   fOutputList->Add(fRefMult);
 631
 632   fRefMultWOJet = new TH2F("fRefMultWOJet", "Reference multiplicity in the AOD, multiplicity without jets", 301, -0.5, 300.5, 301, -0.5, 300.5);
 633   fRefMultWOJet->GetXaxis()->SetTitle("Reference multiplicity");
 634   fRefMultWOJet->GetYaxis()->SetTitle("Multiplicity without jets");
 635   fRefMultWOJet->Sumw2();
 636   fOutputList->Add(fRefMultWOJet);
 637
 638   fVZEROMult = new TH2F("fVZEROMult", "Multiplicity V0A and V0C", 501, -0.5, 500.5, 501, -0.5, 500.5);
 639   fVZEROMult->GetXaxis()->SetTitle("Multiplicity V0A");
 640   fVZEROMult->GetYaxis()->SetTitle("Multiplicity V0C");
 641   fVZEROMult->Sumw2();
 642   fOutputList->Add(fVZEROMult);
 643
 644   fMultWOJetVZero = new TH2F("fMultWOJetVZero", "Multiplicity without jets and VZERO mult.",301, -0.5, 300.5, 1001, -0.5, 1000.5);
 645   fMultWOJetVZero->GetXaxis()->SetTitle("Multiplicity without jets TPC");
 646   fMultWOJetVZero->GetYaxis()->SetTitle("Multiplicity full V0");
 647   fMultWOJetVZero->Sumw2();
 648   fOutputList->Add(fMultWOJetVZero);
 649
 650   fRefMultFullV0 = new TH2F("fRefMultFullV0", "Reference multiplicity in the AOD, multiplicity from full V0",301, -0.5, 300.5, 1001, -0.5, 1000.5);
 651   fRefMultFullV0->GetXaxis()->SetTitle("Reference multiplicity in AOD");
 652   fRefMultFullV0->GetYaxis()->SetTitle("Multiplicity full V0");
 653   fRefMultFullV0->Sumw2();
 654   fOutputList->Add(fRefMultFullV0);
 655
 656   fRefMultV0Corr = new TH2F("fRefMultV0Corr", "Reference multiplicity in the AOD, multiplicity from corrected V0",301, -0.5, 300.5, 1001, -0.5, 1000.5);
 657   fRefMultV0Corr->GetXaxis()->SetTitle("Reference multiplicity in AOD");
 658   fRefMultV0Corr->GetYaxis()->SetTitle("Multiplicity V0 no jets");
 659   fRefMultV0Corr->Sumw2();
 660   fOutputList->Add(fRefMultV0Corr);
 661
 662   fFullV0V0Corr = new TH2F("fFullV0V0Corr", "Multiplicity from full V0, multiplicity from corrected V0",1001, -0.5, 1000.5, 1001, -0.5, 1000.5);
 663   fFullV0V0Corr->GetXaxis()->SetTitle("Multiplicity from full V0");
 664   fFullV0V0Corr->GetYaxis()->SetTitle("Multiplicity V0 no jets");
 665   fFullV0V0Corr->Sumw2();
 666   fOutputList->Add(fFullV0V0Corr);
 667
 668   fNTXV0MultPt = new TH3F("fNTXV0MultPt", "NTX, Multiplicity from corrected V0, jet pT",101,-0.5,100.5, 1001, -0.5, 1000.5, 60, 0., 300.);
 669   fNTXV0MultPt->GetXaxis()->SetTitle("NTracks");
 670   fNTXV0MultPt->GetYaxis()->SetTitle("Multiplicity V0 no jets");
 671   fNTXV0MultPt->GetZaxis()->SetTitle("p_{T}^{JET}");
 672   fNTXV0MultPt->Sumw2();
 673   fOutputList->Add(fNTXV0MultPt);
 674
 675   fNTXCBMultPt = new TH3F("fNTXCBMultPt", "NTX, Multiplicity from corrected Central Barrel, jet pT",101,-0.5,100.5, 301, -0.5, 300.5, 60, 0., 300.);
 676   fNTXCBMultPt->GetXaxis()->SetTitle("NTracks");
 677   fNTXCBMultPt->GetYaxis()->SetTitle("Multiplicity corrected Central Barrel");
 678   fNTXCBMultPt->GetZaxis()->SetTitle("p_{T}^{JET}");
 679   fNTXCBMultPt->Sumw2();
 680   fOutputList->Add(fNTXCBMultPt);
 681
 682   fRefMultFullV0UJ = new TH2F("fRefMultFullV0UJ", "Reference multiplicity in the AOD, multiplicity from full V0, 1 jet event",301, -0.5, 300.5, 1001, -0.5, 1000.5);
 683   fRefMultFullV0UJ->GetXaxis()->SetTitle("Reference multiplicity in AOD");
 684   fRefMultFullV0UJ->GetYaxis()->SetTitle("Multiplicity full V0");
 685   fRefMultFullV0UJ->Sumw2();
 686   fOutputList->Add(fRefMultFullV0UJ);
 687
 688   fRefMultV0CorrUJ = new TH2F("fRefMultV0CorrUJ", "Reference multiplicity in the AOD, multiplicity from corrected V0, 1 jet event",301, -0.5, 300.5, 1001, -0.5, 1000.5);
 689   fRefMultV0CorrUJ->GetXaxis()->SetTitle("Reference multiplicity in AOD");
 690   fRefMultV0CorrUJ->GetYaxis()->SetTitle("Multiplicity V0 no jets");
 691   fRefMultV0CorrUJ->Sumw2();
 692   fOutputList->Add(fRefMultV0CorrUJ);
 693
 694   fFullV0V0CorrUJ = new TH2F("fFullV0V0CorrUJ", "Multiplicity from full V0, multiplicity from corrected V0, 1 jet event",1001, -0.5, 1000.5, 1001, -0.5, 1000.5);
 695   fFullV0V0CorrUJ->GetXaxis()->SetTitle("Multiplicity from full V0");
 696   fFullV0V0CorrUJ->GetYaxis()->SetTitle("Multiplicity V0 no jets");
 697   fFullV0V0CorrUJ->Sumw2();
 698   fOutputList->Add(fFullV0V0CorrUJ);
 699
 700   fMultWOJetVZeroUJ = new TH2F("fMultWOJetVZeroUJ", "Multiplicity without jets and VZERO mult., 1 jet event",301, -0.5, 300.5, 1001, -0.5, 1000.5);
 701   fMultWOJetVZeroUJ->GetXaxis()->SetTitle("Multiplicity without jets TPC");
 702   fMultWOJetVZeroUJ->GetYaxis()->SetTitle("Multiplicity full V0");
 703   fMultWOJetVZeroUJ->Sumw2();
 704   fOutputList->Add(fMultWOJetVZeroUJ);
 705
 706   fRefMultWOJetUJ = new TH2F("fRefMultWOJetUJ", "Reference multiplicity in the AOD, multiplicity without jets, 1 jet event", 301, -0.5, 300.5, 301, -0.5, 300.5);
 707   fRefMultWOJetUJ->GetXaxis()->SetTitle("Reference multiplicity");
 708   fRefMultWOJetUJ->GetYaxis()->SetTitle("Multiplicity without jets");
 709   fRefMultWOJetUJ->Sumw2();
 710   fOutputList->Add(fRefMultWOJetUJ);
 711
 712   fRefAODTrackCount = new TH2F("fRefAODTrackCount", "Reference multiplicity in the AOD, my own referece mult.", 301, -0.5, 300.5, 301, -0.5, 300.5);
 713   fRefAODTrackCount->GetXaxis()->SetTitle("AOD Reference multiplicity");
 714   fRefAODTrackCount->GetYaxis()->SetTitle("My Reference multiplicity");
 715   fRefAODTrackCount->Sumw2();
 716   fOutputList->Add(fRefAODTrackCount);
 717
 718   fRefAODTrackCountUJ = new TH2F("fRefAODTrackCountUJ", "Reference multiplicity in the AOD, my own referece mult., 1 jet event", 301, -0.5, 300.5, 301, -0.5, 300.5);
 719   fRefAODTrackCountUJ->GetXaxis()->SetTitle("AOD Reference multiplicity");
 720   fRefAODTrackCountUJ->GetYaxis()->SetTitle("My Reference multiplicity");
 721   fRefAODTrackCountUJ->Sumw2();
 722   fOutputList->Add(fRefAODTrackCountUJ);
 723
 724   fTrackCountWOJet = new TH2F("fTrackCountWOJet", "My own total referece mult., soft mult", 151, -0.5, 150.5, 151, -0.5, 150.5);
 725   fTrackCountWOJet->GetXaxis()->SetTitle("Total TPC multiplicity");
 726   fTrackCountWOJet->GetYaxis()->SetTitle("Soft TPC multiplicity");
 727   fTrackCountWOJet->Sumw2();
 728   fOutputList->Add(fTrackCountWOJet);
 729
 730   fTrackCountWOJetUJ = new TH2F("fTrackCountWOJetUJ", "My own total referece mult., soft mult, 1 jet", 151, -0.5, 150.5, 151, -0.5, 150.5);
 731   fTrackCountWOJetUJ->GetXaxis()->SetTitle("Total TPC multiplicity");
 732   fTrackCountWOJetUJ->GetYaxis()->SetTitle("Soft TPC multiplicity");
 733   fTrackCountWOJetUJ->Sumw2();
 734   fOutputList->Add(fTrackCountWOJetUJ);
 735
 736   fTrackCountWOJetUJMC = new TH2F("fTrackCountWOJetUJMC", "My own total referece mult., soft mult, 1 jet, MC!", 151, -0.5, 150.5, 151, -0.5, 150.5);
 737   fTrackCountWOJetUJMC->GetXaxis()->SetTitle("Total TPC (eta) multiplicity");
 738   fTrackCountWOJetUJMC->GetYaxis()->SetTitle("Soft TPC (eta) multiplicity");
 739   fTrackCountWOJetUJMC->Sumw2();
 740   fOutputList->Add(fTrackCountWOJetUJMC);
 741
 742   fFullV0V0CorrUJMC = new TH2F("fFullV0V0CorrUJMC", "Multiplicity from full V0, multiplicity from corrected V0, 1 jet event, MC!",1001, -0.5, 1000.5, 1001, -0.5, 1000.5);
 743   fFullV0V0CorrUJMC->GetXaxis()->SetTitle("Multiplicity from full V0 (acceptance)");
 744   fFullV0V0CorrUJMC->GetYaxis()->SetTitle("Multiplicity V0(acceptance) no jets");
 745   fFullV0V0CorrUJMC->Sumw2();
 746   fOutputList->Add(fFullV0V0CorrUJMC);
 747
 748   fMinTrackPtInNTXRecalc = new TH3F("fMinTrackPtInNTXRecalc", "Minimum track pT for the jets after pT correction, raw jet pT", 200, 0., 100., 60, 0., 300.,10,0.5,10.5);
 749   fMinTrackPtInNTXRecalc->GetXaxis()->SetTitle("p_{T}^{TRACK} (GeV/c)");
 750   fMinTrackPtInNTXRecalc->GetYaxis()->SetTitle("p_{T}^{JET} (GeV/c)");
 751   fMinTrackPtInNTXRecalc->GetZaxis()->SetTitle("Selection Bin");  // 9 selections bins as fNChTrRecECorr
 752   fMinTrackPtInNTXRecalc->Sumw2();
 753   fOutputList->Add(fMinTrackPtInNTXRecalc);
 754
 755   fMaxTrackPtInNTXRecalc = new TH2F("fMaxTrackPtInNTXRecalc", "Maximum track pT for the jets after pT correction, raw jet pT", 200, 0., 100., 60, 0., 300.);
 756   fMaxTrackPtInNTXRecalc->GetXaxis()->SetTitle("p_{T}^{TRACK} (GeV/c)");
 757   fMaxTrackPtInNTXRecalc->GetYaxis()->SetTitle("p_{T}^{JET} (GeV/c)");
 758   fMaxTrackPtInNTXRecalc->Sumw2();
 759   fOutputList->Add(fMaxTrackPtInNTXRecalc);
 760
 761   fPtDistInJetConeRaw = new TH3F("fPtDistInJetConeRaw","pT of tracks in cone, raw jet pT bin, centrality", 200, 0., 100., 8, 0.5, 8.5, 10, 0.5, 10.5);
 762   fPtDistInJetConeRaw->GetXaxis()->SetTitle("p_{T}^{TRACK} (GeV/c)");
 763   fPtDistInJetConeRaw->GetYaxis()->SetTitle("p_{T}^{JET} Bin");
 764   fPtDistInJetConeRaw->GetZaxis()->SetTitle("Centrality Bin");
 765   fPtDistInJetConeRaw->Sumw2();
 766   fOutputList->Add(fPtDistInJetConeRaw);
 767
 768   fPtDistInPerpConeRaw = new TH3F("fPtDistInPerpConeRaw","pT of tracks in cone, raw jet pT bin, centrality", 200, 0., 100., 8, 0.5, 8.5, 10, 0.5, 10.5);
 769   fPtDistInPerpConeRaw->GetXaxis()->SetTitle("p_{T}^{TRACK} (GeV/c)");
 770   fPtDistInPerpConeRaw->GetYaxis()->SetTitle("p_{T}^{JET} Bin");
 771   fPtDistInPerpConeRaw->GetZaxis()->SetTitle("Centrality Bin");
 772   fPtDistInPerpConeRaw->Sumw2();
 773   fOutputList->Add(fPtDistInPerpConeRaw);
 774
 775   fPtInPerpCon = new TH3F("fPtInPerpCon","Summed pT of perpendicular cone, raw jet pT bin, centrality", 200, 0., 100., 8, 0.5, 8.5, 10, 0.5, 10.5);
 776   fPtInPerpCon->GetXaxis()->SetTitle("p_{T}^{PERP.CONE} (GeV/c)");
 777   fPtInPerpCon->GetYaxis()->SetTitle("p_{T}^{JET} Bin");
 778   fPtInPerpCon->GetZaxis()->SetTitle("Centrality Bin");
 779   fPtInPerpCon->Sumw2();
 780   fOutputList->Add(fPtInPerpCon);
 781
 782   fJetEtaAll = new TH1F("fJetEtaAll", "Eta distribution of reconstructed jets, no cuts", 50, -1.5, 1.5);
 783   fJetEtaAll->GetXaxis()->SetTitle("#eta");
 784   fJetEtaAll->GetYaxis()->SetTitle("entries");
 785   fJetEtaAll->Sumw2();
 786   fOutputList->Add(fJetEtaAll);
 787
 788   fJetEtaOnlyTPCcut = new TH1F("fJetEtaOnlyTPCcut", "Eta distribution of reconstructed jets, only tpc acceptance cut", 50, -1.5, 1.5);
 789   fJetEtaOnlyTPCcut->GetXaxis()->SetTitle("#eta");
 790   fJetEtaOnlyTPCcut->GetYaxis()->SetTitle("entries");
 791   fJetEtaOnlyTPCcut->Sumw2();
 792   fOutputList->Add(fJetEtaOnlyTPCcut);
 793
 794   // 9 multiplicity bins
 795   // 1st.     <5    TPC tracks       fill 1  Bin1 [0.5,1.5)
 796   // 2nd. >= 5  <10 TPC tracks       fill 2  Bin2 [1.5,2.5)
 797   // 3rd. >= 10 <15 TPC tracks       fill 3  Bin3 [2.5,3.5)
 798   // 4rd. >= 15 <20 TPC tracks       fill 4  Bin4 [3.5,4.5)
 799   // 5th. >= 20 <30 TPC tracks       fill 5  Bin5 [4.5,5.5)
 800   // 6th. >= 30 <40 TPC tracks       fill 6  Bin6 [5.5,6.5)
 801   // 7th. >= 40 <50 TPC tracks       fill 7  Bin7 [6.5,7.5)
 802   // 8th.    >50    TPC tracks       fill 8  Bin8 [7.5,8.5)
 803
 804   fNChTrRecECorrPPMult = new TH3F("fNChTrRecECorrPPMult","NTX in ener. corr. jet , corr. jet pT, pp mult.",101,-0.5,100.5, 60, 0., 300.,8,0.5,8.5);
 805   fNChTrRecECorrPPMult->GetXaxis()->SetTitle("NTracks_Corrected");
 806   fNChTrRecECorrPPMult->GetYaxis()->SetTitle("p_{T}^{JET}");
 807   fNChTrRecECorrPPMult->GetZaxis()->SetTitle("Multiplicity Bin");
 808   fNChTrRecECorrPPMult->Sumw2();
 809   fOutputList->Add(fNChTrRecECorrPPMult);
 810
 811   fNChTrRecPerpECorrPPMult = new TH3F("fNChTrRecPerpECorrPPMult","Tracks above min in perp.cone , corr. jet pT, centrality",101,-0.5,100.5, 60, 0., 300.,8,0.5,8.5);
 812   fNChTrRecPerpECorrPPMult->GetXaxis()->SetTitle("NTracks_Corrected");
 813   fNChTrRecPerpECorrPPMult->GetYaxis()->SetTitle("p_{T}^{JET}");
 814   fNChTrRecPerpECorrPPMult->GetZaxis()->SetTitle("Multiplicity Bin");
 815   fNChTrRecPerpECorrPPMult->Sumw2();
 816   fOutputList->Add(fNChTrRecPerpECorrPPMult);
 817
 818   fJetPtCentPbPbRaw = new TH2F("fJetPtCentPbPbRaw", "raw p_{T} distribution of reco jets", 60, 0., 300.,10,0.5,10.5);
 819   fJetPtCentPbPbRaw->GetXaxis()->SetTitle("p_{T} (GeV/c)");
 820   fJetPtCentPbPbRaw->GetYaxis()->SetTitle("Selection Bin");
 821   fJetPtCentPbPbRaw->Sumw2();
 822   fOutputList->Add(fJetPtCentPbPbRaw);
 823
 824   fJetPtCentPbPbCorr = new TH2F("fJetPtCentPbPbCorr", "Corrected p_{T} distribution of reco jets", 60, 0., 300.,10,0.5,10.5);
 825   fJetPtCentPbPbCorr->GetXaxis()->SetTitle("p_{T} (GeV/c)");
 826   fJetPtCentPbPbCorr->GetYaxis()->SetTitle("Selection Bin");
 827   fJetPtCentPbPbCorr->Sumw2();
 828   fOutputList->Add(fJetPtCentPbPbCorr);
 829
 830   fTotTracksCone = new TH3F("fTotTracksCone","Total number of tracks in the cone, raw jet pT bin, centrality", 200, 0.5, 200.5, 8, 0.5, 8.5, 10, 0.5, 10.5);
 831   fTotTracksCone->GetXaxis()->SetTitle("NTracks");
 832   fTotTracksCone->GetYaxis()->SetTitle("p_{T}^{JET} Bin");
 833   fTotTracksCone->GetZaxis()->SetTitle("Centrality Bin");
 834   fTotTracksCone->Sumw2();
 835   fOutputList->Add(fTotTracksCone);
 836
 837   for(Int_t ipt=0;ipt<12;ipt++)
 838     {
 839       fNChTr[ipt] = new TH2F(Form("fNChTr[%i]",ipt),"Number of tracks to recover transverse energy, jet_{p_{T}}",101,-0.5,100.5, 60, 0., 300.);
 840       fNChTr[ipt]->GetXaxis()->SetTitle("NTracks");
 841       fNChTr[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
 842       fNChTr[ipt]->Sumw2();
 843       fOutputList->Add(fNChTr[ipt]);
 844
 845       fHistPtParton[ipt] = new TH1F(Form("fHistPtParton[%i]",ipt),"pT distribution of jets",50,0.,250.);
 846       fHistPtParton[ipt]->GetXaxis()->SetTitle("p_{T}^{JET}");
 847       fHistPtParton[ipt]->GetYaxis()->SetTitle("Entries");
 848       fHistPtParton[ipt]->Sumw2();
 849       fOutputList->Add(fHistPtParton[ipt]);
 850
 851       fSCM[ipt] = new TH2F(Form("fSCM[%i]",ipt),"Second Central Moment, jet_{p_{T}}",200,0.,0.2, 60, 0., 300.);
 852       fSCM[ipt]->GetXaxis()->SetTitle("<#delta R_{c}^{2}>");
 853       fSCM[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
 854       fSCM[ipt]->Sumw2();
 855       fOutputList->Add(fSCM[ipt]);
 856
 857       if(ipt<8)
 858         {
 859           fNChTrRDMult[ipt] = new TH2F(Form("fNChTrRDMult[%i]",ipt),"Number of tracks to recover transverse energy, jet_{p_{T}}",101,-0.5,100.5, 60, 0., 300.);
 860           fNChTrRDMult[ipt]->GetXaxis()->SetTitle("NTracks");
 861           fNChTrRDMult[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
 862           fNChTrRDMult[ipt]->Sumw2();
 863           fOutputList->Add(fNChTrRDMult[ipt]);
 864
 865           fNAccJetsRDMult[ipt] = new TH1F(Form("fNAccJetsRDMult[%i]",ipt),"Number of accepted jets per event in real data", 101, -0.5, 100.5);
 866           fNAccJetsRDMult[ipt]->GetXaxis()->SetTitle("Number of jets");
 867           fNAccJetsRDMult[ipt]->Sumw2();
 868           fOutputList->Add(fNAccJetsRDMult[ipt]);
 869
 870           fTotalJetCharge[ipt] = new TH1F(Form("fTotalJetCharge[%i]",ipt),"Charge in the jet", 41, -20.5, 20.5);
 871           fTotalJetCharge[ipt]->GetXaxis()->SetTitle("Charge in jet");
 872           fTotalJetCharge[ipt]->Sumw2();
 873           fOutputList->Add(fTotalJetCharge[ipt]);
 874
 875           fSCMRDMult[ipt] = new TH2F(Form("fSCMRDMult[%i]",ipt),"Second Central Moment, jet_{p_{T}}",200,0.,0.2, 60, 0., 300.);
 876           fSCMRDMult[ipt]->GetXaxis()->SetTitle("<#delta R_{c}^{2}>");
 877           fSCMRDMult[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
 878           fSCMRDMult[ipt]->Sumw2();
 879           fOutputList->Add(fSCMRDMult[ipt]);
 880
 881           fNChTrRDMultMC[ipt] = new TH2F(Form("fNChTrRDMultMC[%i]",ipt),"Number of tracks to recover transverse energy, jet_{p_{T}}",101,-0.5,100.5, 60, 0., 300.);
 882           fNChTrRDMultMC[ipt]->GetXaxis()->SetTitle("NTracks");
 883           fNChTrRDMultMC[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
 884           fNChTrRDMultMC[ipt]->Sumw2();
 885           fOutputList->Add(fNChTrRDMultMC[ipt]);
 886
 887           fSCMRDMultMC[ipt] = new TH2F(Form("fSCMRDMultMC[%i]",ipt),"Second Central Moment, jet_{p_{T}}",200,0.,0.2, 60, 0., 300.);
 888           fSCMRDMultMC[ipt]->GetXaxis()->SetTitle("<#delta R_{c}^{2}>");
 889           fSCMRDMultMC[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
 890           fSCMRDMultMC[ipt]->Sumw2();
 891           fOutputList->Add(fSCMRDMultMC[ipt]);
 892
 893           //Second multiplicity estimator, removing jets and an area
 894           fNChTrRDMultSE[ipt] = new TH2F(Form("fNChTrRDMultSE[%i]",ipt),"Number of tracks to recover transverse energy, jet_{p_{T}}",101,-0.5,100.5, 60, 0., 300.);
 895           fNChTrRDMultSE[ipt]->GetXaxis()->SetTitle("NTracks");
 896           fNChTrRDMultSE[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
 897           fNChTrRDMultSE[ipt]->Sumw2();
 898           fOutputList->Add(fNChTrRDMultSE[ipt]);
 899
 900           fNAccJetsRDMultSE[ipt] = new TH1F(Form("fNAccJetsRDMultSE[%i]",ipt),"Number of accepted jets per event in real data", 101, -0.5, 100.5);
 901           fNAccJetsRDMultSE[ipt]->GetXaxis()->SetTitle("Number of jets");
 902           fNAccJetsRDMultSE[ipt]->Sumw2();
 903           fOutputList->Add(fNAccJetsRDMultSE[ipt]);
 904
 905           fTotalJetChargeSE[ipt] = new TH1F(Form("fTotalJetChargeSE[%i]",ipt),"Charge in the jet", 41, -20.5, 20.5);
 906           fTotalJetChargeSE[ipt]->GetXaxis()->SetTitle("Charge in jet");
 907           fTotalJetChargeSE[ipt]->Sumw2();
 908           fOutputList->Add(fTotalJetChargeSE[ipt]);
 909
 910           fSCMRDMultSE[ipt] = new TH2F(Form("fSCMRDMultSE[%i]",ipt),"Second Central Moment, jet_{p_{T}}",200,0.,0.2, 60, 0., 300.);
 911           fSCMRDMultSE[ipt]->GetXaxis()->SetTitle("<#delta R_{c}^{2}>");
 912           fSCMRDMultSE[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
 913           fSCMRDMultSE[ipt]->Sumw2();
 914           fOutputList->Add(fSCMRDMultSE[ipt]);
 915
 916           fNChTrRDMultOJ[ipt] = new TH2F(Form("fNChTrRDMultOJ[%i]",ipt),"Number of tracks to recover transverse energy, jet_{p_{T}, 1 jet}",101,-0.5,100.5, 60, 0., 300.);
 917           fNChTrRDMultOJ[ipt]->GetXaxis()->SetTitle("NTracks");
 918           fNChTrRDMultOJ[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
 919           fNChTrRDMultOJ[ipt]->Sumw2();
 920           fOutputList->Add(fNChTrRDMultOJ[ipt]);
 921
 922           fSCMRDMultOJ[ipt] = new TH2F(Form("fSCMRDMultOJ[%i]",ipt),"Second Central Moment, jet_{p_{T}}, 1 jet",200,0.,0.2, 60, 0., 300.);
 923           fSCMRDMultOJ[ipt]->GetXaxis()->SetTitle("<#delta R_{c}^{2}>");
 924           fSCMRDMultOJ[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
 925           fSCMRDMultOJ[ipt]->Sumw2();
 926           fOutputList->Add(fSCMRDMultOJ[ipt]);
 927
 928           fNChTrRDMultSEOJ[ipt] = new TH2F(Form("fNChTrRDMultSEOJ[%i]",ipt),"Number of tracks to recover transverse energy, jet_{p_{T}}, 1 jet",101,-0.5,100.5, 60, 0., 300.);
 929           fNChTrRDMultSEOJ[ipt]->GetXaxis()->SetTitle("NTracks");
 930           fNChTrRDMultSEOJ[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
 931           fNChTrRDMultSEOJ[ipt]->Sumw2();
 932           fOutputList->Add(fNChTrRDMultSEOJ[ipt]);
 933
 934           fSCMRDMultSEOJ[ipt] = new TH2F(Form("fSCMRDMultSEOJ[%i]",ipt),"Second Central Moment, jet_{p_{T}}, 1 jet",200,0.,0.2, 60, 0., 300.);
 935           fSCMRDMultSEOJ[ipt]->GetXaxis()->SetTitle("<#delta R_{c}^{2}>");
 936           fSCMRDMultSEOJ[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
 937           fSCMRDMultSEOJ[ipt]->Sumw2();
 938           fOutputList->Add(fSCMRDMultSEOJ[ipt]);
 939
 940           fNChTrRDMultOJMC[ipt] = new TH2F(Form("fNChTrRDMultOJMC[%i]",ipt),"Number of tracks to recover transverse energy, jet_{p_{T}, 1 jet, MC}",101,-0.5,100.5, 60, 0., 300.);
 941           fNChTrRDMultOJMC[ipt]->GetXaxis()->SetTitle("NTracks");
 942           fNChTrRDMultOJMC[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
 943           fNChTrRDMultOJMC[ipt]->Sumw2();
 944           fOutputList->Add(fNChTrRDMultOJMC[ipt]);
 945
 946           fSCMRDMultOJMC[ipt] = new TH2F(Form("fSCMRDMultOJMC[%i]",ipt),"Second Central Moment, jet_{p_{T}}, 1 jet, MC",200,0.,0.2, 60, 0., 300.);
 947           fSCMRDMultOJMC[ipt]->GetXaxis()->SetTitle("<#delta R_{c}^{2}>");
 948           fSCMRDMultOJMC[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
 949           fSCMRDMultOJMC[ipt]->Sumw2();
 950           fOutputList->Add(fSCMRDMultOJMC[ipt]);
 951
 952           fNChTrRDMultSEOJMC[ipt] = new TH2F(Form("fNChTrRDMultSEOJMC[%i]",ipt),"Number of tracks to recover transverse energy, jet_{p_{T}}, 1 jet, MC",101,-0.5,100.5, 60, 0., 300.);
 953           fNChTrRDMultSEOJMC[ipt]->GetXaxis()->SetTitle("NTracks");
 954           fNChTrRDMultSEOJMC[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
 955           fNChTrRDMultSEOJMC[ipt]->Sumw2();
 956           fOutputList->Add(fNChTrRDMultSEOJMC[ipt]);
 957
 958           fSCMRDMultSEOJMC[ipt] = new TH2F(Form("fSCMRDMultSEOJMC[%i]",ipt),"Second Central Moment, jet_{p_{T}}, 1 jet, MC",200,0.,0.2, 60, 0., 300.);
 959           fSCMRDMultSEOJMC[ipt]->GetXaxis()->SetTitle("<#delta R_{c}^{2}>");
 960           fSCMRDMultSEOJMC[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
 961           fSCMRDMultSEOJMC[ipt]->Sumw2();
 962           fOutputList->Add(fSCMRDMultSEOJMC[ipt]);
 963
 964           fNChTrRecPerpMultSEOJ[ipt] = new TH2F(Form("fNChTrRecPerpMultSEOJ[%i]",ipt),"Number of tracks above the min pT used in NTX_Raw, jet_{p_{T}}, 1 jet",101,-0.5,100.5, 60, 0., 300.);
 965           fNChTrRecPerpMultSEOJ[ipt]->GetXaxis()->SetTitle("NTracks_{Exc.}");
 966           fNChTrRecPerpMultSEOJ[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
 967           fNChTrRecPerpMultSEOJ[ipt]->Sumw2();
 968           fOutputList->Add(fNChTrRecPerpMultSEOJ[ipt]);
 969
 970           fJEtaMCMultOJ[ipt] = new TH1F(Form("fJEtaMCMultOJ[%i]",ipt), "Eta distribution of MC jets, V0-like mult. bins, 1 jet", 50, -1.5, 1.5);
 971           fJEtaMCMultOJ[ipt]->GetXaxis()->SetTitle("#eta");
 972           fJEtaMCMultOJ[ipt]->GetYaxis()->SetTitle("entries");
 973           fJEtaMCMultOJ[ipt]->Sumw2();
 974           fOutputList->Add(fJEtaMCMultOJ[ipt]);
 975
 976           fJEtaMCMultSEOJ[ipt] = new TH1F(Form("fJEtaMCMultSEOJ[%i]",ipt), "Eta distribution of MC jets, TPC-like mult. bins, 1 jet", 50, -1.5, 1.5);
 977           fJEtaMCMultSEOJ[ipt]->GetXaxis()->SetTitle("#eta");
 978           fJEtaMCMultSEOJ[ipt]->GetYaxis()->SetTitle("entries");
 979           fJEtaMCMultSEOJ[ipt]->Sumw2();
 980           fOutputList->Add(fJEtaMCMultSEOJ[ipt]);
 981
 982           fJEtaRDMultOJ[ipt] = new TH1F(Form("fJEtaRDMultOJ[%i]",ipt), "Eta distribution of reco jets, V0 mult. bins, 1 jet", 50, -1.5, 1.5);
 983           fJEtaRDMultOJ[ipt]->GetXaxis()->SetTitle("#eta");
 984           fJEtaRDMultOJ[ipt]->GetYaxis()->SetTitle("entries");
 985           fJEtaRDMultOJ[ipt]->Sumw2();
 986           fOutputList->Add(fJEtaRDMultOJ[ipt]);
 987
 988           fJEtaRDMultSEOJ[ipt] = new TH1F(Form("fJEtaRDMultSEOJ[%i]",ipt), "Eta distribution of reco jets, TPC mult. bins, 1 jet", 50, -1.5, 1.5);
 989           fJEtaRDMultSEOJ[ipt]->GetXaxis()->SetTitle("#eta");
 990           fJEtaRDMultSEOJ[ipt]->GetYaxis()->SetTitle("entries");
 991           fJEtaRDMultSEOJ[ipt]->Sumw2();
 992           fOutputList->Add(fJEtaRDMultSEOJ[ipt]);
 993
 994           fJetPtMCMultOJ[ipt] = new TH1F(Form("fJetPtMCMultOJ[%i]",ipt), "pT distribution of MC jets, V0-like mult. bins, 1 jet", 60, 0., 300.);
 995           fJetPtMCMultOJ[ipt]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
 996           fJetPtMCMultOJ[ipt]->GetYaxis()->SetTitle("entries");
 997           fJetPtMCMultOJ[ipt]->Sumw2();
 998           fOutputList->Add(fJetPtMCMultOJ[ipt]);
 999
1000           fJetPtMCMultSEOJ[ipt] = new TH1F(Form("fJetPtMCMultSEOJ[%i]",ipt), "pT distribution of MC jets, TPC-like mult. bins, 1 jet", 60, 0., 300.);
1001           fJetPtMCMultSEOJ[ipt]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
1002           fJetPtMCMultSEOJ[ipt]->GetYaxis()->SetTitle("entries");
1003           fJetPtMCMultSEOJ[ipt]->Sumw2();
1004           fOutputList->Add(fJetPtMCMultSEOJ[ipt]);
1005
1006           fJetPtRDMultOJ[ipt] = new TH1F(Form("fJetPtRDMultOJ[%i]",ipt), "pT distribution of reco jets, V0 mult. bins, 1 jet", 60, 0., 300.);
1007           fJetPtRDMultOJ[ipt]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
1008           fJetPtRDMultOJ[ipt]->GetYaxis()->SetTitle("entries");
1009           fJetPtRDMultOJ[ipt]->Sumw2();
1010           fOutputList->Add(fJetPtRDMultOJ[ipt]);
1011
1012           fJetPtRDMultSEOJ[ipt] = new TH1F(Form("fJetPtRDMultSEOJ[%i]",ipt), "pT distribution of reco jets, TPC mult. bins, 1 jet", 60, 0., 300.);
1013           fJetPtRDMultSEOJ[ipt]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
1014           fJetPtRDMultSEOJ[ipt]->GetYaxis()->SetTitle("entries");
1015           fJetPtRDMultSEOJ[ipt]->Sumw2();
1016           fOutputList->Add(fJetPtRDMultSEOJ[ipt]);
1017
1018           fEntriesQuark[ipt] = new TH2F(Form("fEntriesQuark[%i]",ipt),"NTX of quarks in multiplicity bins, 1 jet, MC",101,-0.5,100.5, 60, 0., 300.);
1019           fEntriesQuark[ipt]->GetXaxis()->SetTitle("NTracks");
1020           fEntriesQuark[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
1021           fEntriesQuark[ipt]->Sumw2();
1022           fOutputList->Add(fEntriesQuark[ipt]);
1023
1024           fEntriesGluon[ipt] = new TH2F(Form("fEntriesGluon[%i]",ipt),"NTX of gluons in multiplicity bins, 1 jet, MC",101,-0.5,100.5, 60, 0., 300.);
1025           fEntriesGluon[ipt]->GetXaxis()->SetTitle("NTracks");
1026           fEntriesGluon[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
1027           fEntriesGluon[ipt]->Sumw2();
1028           fOutputList->Add(fEntriesGluon[ipt]);
1029         } // end if <8
1030
1031       if(ipt<6)  // only entries for reconstructed || simulated jets
1032         {
1033           fProcessPDG[ipt] = new TH2I(Form("fProcessPDG[%i]",ipt),"Pythia process and jet p_T", 60, 0., 300., 70, 0.5, 70.5);
1034           fProcessPDG[ipt]->GetXaxis()->SetTitle("p_{T}^{JET}");
1035           fProcessPDG[ipt]->GetYaxis()->SetTitle("Pythia process code");
1036           fProcessPDG[ipt]->Sumw2();
1037           fOutputList->Add(fProcessPDG[ipt]);
1038
1039           fFragPion[ipt] = new TH2F(Form("fFragPion[%i]",ipt),"Fragmentation in pions",35,0.,8.,50,0.,250.);
1040           fFragPion[ipt]->GetXaxis()->SetTitle("#xi=ln[Jet_{E_{T}}/H_{p_{T}}]");
1041           fFragPion[ipt]->GetYaxis()->SetTitle("Jet_{E_{T}}");
1042           fFragPion[ipt]->Sumw2();
1043           fOutputList->Add(fFragPion[ipt]);
1044
1045           fFragKaon[ipt] = new TH2F(Form("fFragKaon[%i]",ipt),"Fragmentation in kaons",35,0.,8.,50,0.,250.);
1046           fFragKaon[ipt]->GetXaxis()->SetTitle("#xi=ln[Jet_{E_{T}}/H_{p_{T}}]");
1047           fFragKaon[ipt]->GetYaxis()->SetTitle("Jet_{E_{T}}");
1048           fFragKaon[ipt]->Sumw2();
1049           fOutputList->Add(fFragKaon[ipt]);
1050
1051           fFragProton[ipt] = new TH2F(Form("fFragProton[%i]",ipt),"Fragmentation in protons",35,0.,8.,50,0.,250.);
1052           fFragProton[ipt]->GetXaxis()->SetTitle("#xi=ln[Jet_{E_{T}}/H_{p_{T}}]");
1053           fFragProton[ipt]->GetYaxis()->SetTitle("Jet_{E_{T}}");
1054           fFragProton[ipt]->Sumw2();
1055           fOutputList->Add(fFragProton[ipt]);
1056
1057           fFragChargedR4[ipt] = new TH2F(Form("fFragChargedR4[%i]",ipt),"Fragmentation in charged particles",35,0.,8.,50,0.,250.);
1058           fFragChargedR4[ipt]->GetXaxis()->SetTitle("#xi=ln[Jet_{E_{T}}/H_{p_{T}}]");
1059           fFragChargedR4[ipt]->GetYaxis()->SetTitle("Jet_{E_{T}}");
1060           fFragChargedR4[ipt]->Sumw2();
1061           fOutputList->Add(fFragChargedR4[ipt]);
1062
1063           fFragChargedR3[ipt] = new TH2F(Form("fFragChargedR3[%i]",ipt),"Fragmentation in charged particles",35,0.,8.,50,0.,250.);
1064           fFragChargedR3[ipt]->GetXaxis()->SetTitle("#xi=ln[Jet_{E_{T}}/H_{p_{T}}]");
1065           fFragChargedR3[ipt]->GetYaxis()->SetTitle("Jet_{E_{T}}");
1066           fFragChargedR3[ipt]->Sumw2();
1067           fOutputList->Add(fFragChargedR3[ipt]);
1068
1069           fFragChargedR2[ipt] = new TH2F(Form("fFragChargedR2[%i]",ipt),"Fragmentation in charged particles",35,0.,8.,50,0.,250.);
1070           fFragChargedR2[ipt]->GetXaxis()->SetTitle("#xi=ln[Jet_{E_{T}}/H_{p_{T}}]");
1071           fFragChargedR2[ipt]->GetYaxis()->SetTitle("Jet_{E_{T}}");
1072           fFragChargedR2[ipt]->Sumw2();
1073           fOutputList->Add(fFragChargedR2[ipt]);
1074
1075           // do not add the temporary containers
1076           fHistContainerR4[ipt] = new TH2F(Form("fHistContainerR4[%i]",ipt),"Temporary fragmentation in charged particles",35,0.,8.,50,0.,250.);
1077           fHistContainerR4[ipt]->GetXaxis()->SetTitle("#xi=ln[Jet_{E_{T}}/H_{p_{T}}]");
1078           fHistContainerR4[ipt]->GetYaxis()->SetTitle("Jet_{E_{T}}");
1079           fHistContainerR4[ipt]->Sumw2();
1080
1081           fHistContainerR3[ipt] = new TH2F(Form("fHistContainerR3[%i]",ipt),"Temporary fragmentation in charged particles",35,0.,8.,50,0.,250.);
1082           fHistContainerR3[ipt]->GetXaxis()->SetTitle("#xi=ln[Jet_{E_{T}}/H_{p_{T}}]");
1083           fHistContainerR3[ipt]->GetYaxis()->SetTitle("Jet_{E_{T}}");
1084           fHistContainerR3[ipt]->Sumw2();
1085
1086           fHistContainerR2[ipt] = new TH2F(Form("fHistContainerR2[%i]",ipt),"Temporary fragmentation in charged particles",35,0.,8.,50,0.,250.);
1087           fHistContainerR2[ipt]->GetXaxis()->SetTitle("#xi=ln[Jet_{E_{T}}/H_{p_{T}}]");
1088           fHistContainerR2[ipt]->GetYaxis()->SetTitle("Jet_{E_{T}}");
1089           fHistContainerR2[ipt]->Sumw2();
1090
1091           if(ipt<3)
1092             {
1093               fJetEtaJetPt[ipt] = new TH1F(Form("fJetEtaJetPt[%i]",ipt), "Eta distribution of reconstructed jets, all cut, with pT upper boundary", 50, -1.5, 1.5);
1094               fJetEtaJetPt[ipt]->GetXaxis()->SetTitle("#eta");
1095               fJetEtaJetPt[ipt]->GetYaxis()->SetTitle("entries");
1096               fJetEtaJetPt[ipt]->Sumw2();
1097               fOutputList->Add(fJetEtaJetPt[ipt]);
1098
1099               if(ipt<2)
1100                 {
1101                   fFragCandidates[ipt] = new TH2F(Form("fFragCandidates[%i]",ipt),"Parton identified candidates",35,0.,8.,50,0.,250.);
1102                   fFragCandidates[ipt]->GetXaxis()->SetTitle("#xi=ln[Jet_{E_{T}}/H_{p_{T}}]");
1103                   fFragCandidates[ipt]->GetYaxis()->SetTitle("Jet_{E_{T}}");
1104                   fFragCandidates[ipt]->Sumw2();
1105                   fOutputList->Add(fFragCandidates[ipt]);
1106
1107                   fMinTrackPtInNTXh[ipt] = new TH3F(Form("fMinTrackPtInNTXh[%i]",ipt), "Minimum track pT for the jets", 200, 0., 100., 60, 0., 300.,10,0.5,10.5);
1108                   fMinTrackPtInNTXh[ipt]->GetXaxis()->SetTitle("p_{T}^{TRACK}");
1109                   fMinTrackPtInNTXh[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
1110                   fMinTrackPtInNTXh[ipt]->GetZaxis()->SetTitle("Selection Bin"); //9 selection bins as fNChTrRecECorr
1111                   fMinTrackPtInNTXh[ipt]->Sumw2();
1112                   fOutputList->Add(fMinTrackPtInNTXh[ipt]);
1113
1114                   fMaxTrackPtInNTXh[ipt] = new TH2F(Form("fMaxTrackPtInNTXh[%i]",ipt), "Maximum track pT for the jets", 200, 0., 100., 60, 0., 300.);
1115                   fMaxTrackPtInNTXh[ipt]->GetXaxis()->SetTitle("p_{T}^{TRACK}");
1116                   fMaxTrackPtInNTXh[ipt]->GetYaxis()->SetTitle("p_{T}^{JET}");
1117                   fMaxTrackPtInNTXh[ipt]->Sumw2();
1118                   fOutputList->Add(fMaxTrackPtInNTXh[ipt]);
1119                 } // index < 2
1120             } // index < 3
1121         } // index < 6
1122     } // index < 12
1123
1124   fPerpCone = new AliAODJet();
1125   fBckgSbsJet = new Double_t[3];
1126
1127   PostData(1, fOutputList); // Post data for ALL output slots >0 here, to get at least an empty histogram
1128 }
1129
1130 //________________________________________________________________________
1131 void AliAnalysisTaskPartonDisc::UserExec(Option_t *)
1132 {
1133   // Main loop
1134   // Called for each event
1135
1136   //  fAOD
1137   if(fUseAODJetInput)
1138     {
1139       fAOD = dynamic_cast<AliAODEvent*>(InputEvent());
1140       if(!fAOD)
1141         {
1142           Printf("%s:%d AODEvent not found in Input Manager %d",(char*)__FILE__,__LINE__,fUseAODJetInput);
1143           return;
1144         }
1145       // fetch the header
1146     }
1147   else
1148     {
1149       //  assume that the AOD is in the general output...
1150       fAOD  = AODEvent();
1151       if(!fAOD)
1152         {
1153           Printf("%s:%d AODEvent not found in the Output",(char*)__FILE__,__LINE__);
1154           return;
1155         }
1156     }
1157
1158   // fin de test para fAOD
1159
1160   if(!fInputEvent)
1161     {
1162       Error("UserExec","No event found!");
1163       return;
1164     }
1165
1166   AliAODHandler *aodHandler = (AliAODHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
1167   if(!aodHandler)
1168     {
1169       AliError("No AOD Handler!");
1170       return;
1171     }
1172
1173   fEventCent=900; //dummy val for debugging
1174
1175   if(fIsHIevent)
1176     {
1177       AliAODHeader *aodHeader = fAOD->GetHeader();
1178       fEventCent = aodHeader->GetCentrality();
1179     }
1180
1181   // Random number generator seeded per event
1182   TDatime dt;
1183   UInt_t curtime = dt.Get();
1184   UInt_t procid = gSystem->GetPid();
1185   UInt_t seed = curtime-procid;
1186   gRandom->SetSeed(seed);
1187
1188   // Jet eta exclusion
1189   if(fIncreasingExcl)
1190     fJetAcceptance = 0.5 - fIncExcR; // if the increase is 0.1 -> only jets within |eta|<0.4
1191
1192   // First test of reference multiplicity
1193   Int_t refMultiplicity = fAOD->GetHeader()->GetRefMultiplicity();
1194   fRefMult->Fill(refMultiplicity);
1195
1196   // Multiplicity from V0 (V0A+V0C)
1197   fVZero = fAOD->GetVZEROData();
1198   Float_t multV0A = 0.0;
1199   Float_t multV0C = 0.0;
1200   Float_t multFullV0 = 0.0;
1201   if(fVZero)
1202     {
1203       multV0A = fVZero->GetMTotV0A();
1204       multV0C = fVZero->GetMTotV0C();
1205       multFullV0 = multV0A+multV0C;
1206     }
1207   fVZEROMult->Fill(multV0A,multV0C);
1208
1209   fEvtCount++;
1210   Double_t jfr = fJetRadius;   // radius used during jet finding
1211   Int_t ntx = fNtX;   // NTX value
1212   const Int_t maxJetNum=6; // maximum number of generated jets to process
1213   AliAODJet genJets[6];  // containers for the
1214   AliAODJet recJets[6];  // correlation gen-reco
1215   Int_t nGenJets=0;
1216   Int_t nRecJets=0;
1217   Int_t genJetsFlavor[6]={0};    // flavor of the generated jets
1218   Int_t evtype = 0; //pythia event type
1219   // Variables para la variable de estructura
1220   Double_t deltaPhiPt = 0.0;
1221   Double_t deltaEtaPt = 0.0;
1222   Double_t deltaPhiSqPt = 0.0;
1223   Double_t deltaEtaSqPt = 0.0;
1224   Double_t totalTrackPt = 0.0;
1225   Double_t firstMomDeltPhi = 0.0;
1226   Double_t firstMomDeltEta = 0.0;
1227   Double_t secondMomDeltPhi = 0.0;
1228   Double_t secondMomDeltEta = 0.0;
1229   Double_t secondCentralPhi = 0.0;
1230   Double_t secondCentralEta = 0.0;
1231   Double_t secondCentralR = 0.0;
1232
1233   // Variables para la variable de estructura
1234   // del cono perpendicular
1235   Double_t deltaPhiPtPerp = 0.0;
1236   Double_t deltaEtaPtPerp = 0.0;
1237   Double_t deltaPhiSqPtPerp = 0.0;
1238   Double_t deltaEtaSqPtPerp = 0.0;
1239   Double_t totalTrackPtPerp = 0.0;
1240   Double_t firstMomDeltPhiPerp = 0.0;
1241   Double_t firstMomDeltEtaPerp = 0.0;
1242   Double_t secondMomDeltPhiPerp = 0.0;
1243   Double_t secondMomDeltEtaPerp = 0.0;
1244   Double_t secondCentralPhiPerp = 0.0;
1245   Double_t secondCentralEtaPerp = 0.0;
1246   Double_t secondCentralRPerp = 0.0;
1247
1248   Double_t perpendicularPt;
1249   Float_t px,py,pz,en; // jet 4-vector à la UA1
1250   Float_t pTbs, etabs, phibs; // energy corrected jet properties
1251
1252   // Process the MC info from the AOD
1253   if(fUseAODMC)
1254     {
1255       // Get the MC array
1256       TClonesArray *mcarray = dynamic_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName()));
1257       if(!mcarray)
1258         {
1259           AliError("ERROR:No MC info in the AOD input");
1260           return;
1261         }
1262
1263       AliMCEvent* mcEvent = MCEvent();
1264       if(mcEvent)
1265         {
1266           if(!fPhojetMC) // if it is pythia
1267             evtype = GetMCEventType(mcEvent);
1268           // From pythia 6.2 manual pp 414
1269           // QCD Hard Processes
1270           // 11 f_{i}+f_{j} -> f_{i}+f_{j} com77, ben84, eic84, chi90
1271           // 12 f_{i}+barf_{i} -> f_{k}+barf_{k}
1272           // 13 f_{i}+barf_{i} -> g+g
1273           // 28 f_{i}+g -> f_{i}+g
1274           // 53 g+g -> f_{k}+barf_{k}
1275           // 68 g+g -> g+g
1276           if(fPhojetMC) // if it is phojet
1277             evtype = GetPhojetEventType(mcEvent);
1278         }
1279       if(!mcEvent) // if a pure AOD event
1280         {
1281           AliDebug(2,Form("%s:%d No MCEvent \n",(char*)__FILE__,__LINE__));
1282           AliDebug(2,Form("Trying to get the MC header \n"));
1283           AliAODMCHeader *genEvH = static_cast<AliAODMCHeader*>(fAOD->FindListObject("mcHeader"));
1284           if(!genEvH)
1285             {
1286               AliDebug(2,Form(" %s:%d No Pythia header!",(char*)__FILE__,__LINE__));
1287               evtype = 0;
1288             }
1289           if(genEvH)
1290             evtype = genEvH->GetEventType();
1291         }
1292       // Get the branch with the MC jets
1293       TClonesArray *aodMCJets = dynamic_cast<TClonesArray*>(fAOD->FindListObject(fBranchMC.Data()));
1294       if(!aodMCJets)
1295         {
1296           AliDebug(2,Form("%s:%d no MC Jet array with name %s in AOD",(char*)__FILE__,__LINE__,fBranchMC.Data()));
1297           return;
1298         }
1299       AliDebug(2,Form("There are %d MC jets in this event\n", aodMCJets->GetEntries()));
1300       Int_t mcjets =  aodMCJets->GetEntries();
1301       fNJetsMC->Fill(mcjets,mcjets); // number of jets FROM the branch, filled per event, this gives the event normalization...
1302       HasOverlapedCones(aodMCJets); // Procedure for tagging usable jets
1303                                     // Up 16 jets are flagged
1304
1305       // Loop over AODMC physical primary charged particles
1306       // for the complete event
1307       Int_t tracksMC = mcarray->GetEntriesFast();
1308       AliDebug(2,Form("There are %i tracks in the mcarray",tracksMC));
1309       Double_t aodMCTrackEta = 0.0;
1310       perpendicularPt = 0.0;
1311       px=0.0;
1312       py=0.0;
1313       pz=0.0;
1314       en=0.0;
1315       pTbs=0.0;
1316       etabs=0.0;
1317       phibs=0.0;
1318       fBckgSbsJet[0]=0.0;
1319       fBckgSbsJet[1]=0.0;
1320       fBckgSbsJet[2]=0.0;
1321       Int_t softRefMcNoJets = 0;
1322       Int_t myTotalMultiplicityMc = 0;
1323       Int_t v0LikeTotalMcMult = 0;
1324       Double_t randomNum = 0.;
1325       for(Int_t aodMCTrack = 0; aodMCTrack < tracksMC; aodMCTrack++ )
1326         {
1327           AliAODMCParticle *mctrackf = (AliAODMCParticle*) mcarray->At(aodMCTrack);
1328           if(!mctrackf) continue;
1329           if(!mctrackf->IsPhysicalPrimary()) continue;
1330           if(mctrackf->Charge()==0||mctrackf->Charge()==-99) continue;
1331           randomNum = gRandom->Rndm();
1332           if(randomNum<fTTrackRandomRejection) continue; //rechaza fTTrackRandomRejection
1333
1334           //Lo del V0, voy a contar particulas primarias cargadas
1335           if(mctrackf->Pt()>fMinpTValMC) // cut off en MC para MIPs
1336             {
1337               //V0A
1338               if(((mctrackf->Eta())>(2.8))&&((mctrackf->Eta())<(5.1)))
1339                 v0LikeTotalMcMult++;
1340               //V0C
1341               if(((mctrackf->Eta())>(-3.7))&&((mctrackf->Eta())<(-1.7)))
1342                 v0LikeTotalMcMult++;
1343             }
1344           //Fin de lo del V0
1345           aodMCTrackEta = TMath::Abs(mctrackf->Eta());
1346           if(aodMCTrackEta>0.9) continue;
1347           fPtAODMC->Fill(mctrackf->Pt(),mctrackf->Pt());
1348           fEtaAODMC->Fill(mctrackf->Eta(),mctrackf->Eta());
1349           fPhiAODMC->Fill(mctrackf->Phi(),mctrackf->Phi());
1350           if(fJetEvent) // if has an accepted jet, calculate the perpendicular cone
1351             {
1352               if(HasPerpendicularCone()) // If there is a perpendicular cone available
1353                 {
1354                   if(mctrackf->Pt()>fMinpTVal)
1355                     {
1356                     if(GetDeltaR(fEtaPerpCoord,fPhiPerpCoord,mctrackf->Eta(),mctrackf->Phi())<fJetRadius)
1357                       perpendicularPt = perpendicularPt + mctrackf->Pt();
1358                     }
1359                 }
1360             } // end IF jet event
1361           if(mctrackf->Pt()>fMinPtInGlobMult) // Min pT used in multiplicity estimation
1362             {
1363               myTotalMultiplicityMc++; // total multiplicity TPC like
1364               if(mctrackf->Pt()<fMinpTValUE) continue; // pT cut  fMinpTValUE
1365               if(mctrackf->Pt()>fMaxpTValUE) continue; // pT cut  fMaxpTValUE
1366               if(!IsTrackInsideExcludedArea(mctrackf->Eta(), mctrackf->Phi(), aodMCJets))
1367                 softRefMcNoJets++;
1368             }
1369         } // end loop over particles
1370
1371       Int_t correctedV0LikeMult= v0LikeTotalMcMult-GetV0LikeExcludedMultMC(aodMCJets,mcarray);
1372
1373       //estimadores
1374       if(mcjets==1) // correlation for only monojet events
1375         {
1376           fFullV0V0CorrUJMC->Fill(v0LikeTotalMcMult,correctedV0LikeMult);
1377           fTrackCountWOJetUJMC->Fill(myTotalMultiplicityMc,softRefMcNoJets);
1378         }
1379
1380       if(fJetEvent) // if has an accepted jet, calculate the perpendicular cone
1381         {
1382           if(HasPerpendicularCone()) // If there is a perpendicular cone available
1383             {
1384               px = perpendicularPt*TMath::Cos(fPhiPerpCoord);
1385               py = perpendicularPt*TMath::Sin(fPhiPerpCoord);
1386               pz = perpendicularPt/TMath::Tan(2.0*TMath::ATan(TMath::Exp(-fEtaPerpCoord)));
1387               en = TMath::Sqrt(px*px + py*py + pz*pz);
1388               fPerpCone->SetPxPyPzE(px, py, pz, en);
1389             }
1390           if(!HasPerpendicularCone())
1391             AliDebug(2,"No perpendicular cone!!!");
1392         }
1393
1394
1395       fh1Trials->Fill("#sum{ntrials}",fAvgTrials);
1396
1397       Int_t flavor = 0;     // flavor of the jet
1398       Int_t nTracksPerc;    // ntx for the original jet
1399       Int_t nTracksPercBckgSubst;  // ntx for the energy corrected jet
1400       Double_t jetPt=0;
1401       Int_t pdgOfMCt;
1402       Float_t trackxi;
1403       Double_t jetXt;
1404       Double_t jetPts[7]={0};  // to store the pt of the jets
1405       Int_t mcJetCounter=0;    // counter of MC jets
1406       Int_t nTracksAboveThresholdPerp=0;  // n tracks of the perpendicular cone
1407       Int_t nTrUpThrPerpBckSubs=0;  // n tracks of the perpendicular cone, after the minimum pT recalculation
1408       fIsPossibleToSubstBckg = kTRUE; // Initialize before the loop
1409       if(fJetEvent) // si tiene jets validos
1410         {
1411           if(!HasPerpendicularCone()) // pero no encontro un cono perpendicular libre
1412             fIsPossibleToSubstBckg = kFALSE; // if not perpendicular cone, set to kFALSE, so no perpendicular calculations available
1413         }
1414       // Loop to fill a pT spectrum of the mc jets
1415       Int_t imcj=0; // index for montecarlo jets to correlate
1416       for (Int_t indxmc = 0; indxmc < mcjets; indxmc++)
1417         {
1418           AliAODJet *mcjet = dynamic_cast<AliAODJet*>(aodMCJets->At(indxmc));
1419           if (!mcjet)
1420             {
1421               AliDebug(2,Form("ERROR: Could not receive jet %d\n", indxmc));
1422               continue;
1423             }
1424
1425           ///////////////////////////////////////////////////////////////////////////////
1426           ///// Part for Chritians plot of inclusive and leading jets comp at 2.76 TeV //
1427           if(!IsInsideAcceptance(mcjet))  // old condition
1428             continue;
1429           if(indxmc==0) // leading jet
1430             fMCJetPtLeading->Fill(mcjet->Pt());
1431           fMCJetPtInclusive->Fill(mcjet->Pt()); // all
1432           ///// End of Christians Plot MC
1433           ///////////////////////////////////////////////////////////////////////////////
1434
1435           if(indxmc>15)
1436             continue;
1437
1438           if(!fJetFlags[indxmc]) // If the jet is flaged kFALSE, not usable
1439             continue;
1440
1441           //Initialize variables for this jet
1442           //adiciones para la variable de estructura
1443           nTracksPerc = 0;
1444           nTracksPercBckgSubst = 0;
1445           fMinTrackPtInNTX=200.0;  //Initialize for each jet, overflown
1446           fMaxTrackPtInNTX=200.0;  //Initialize for each jet, overflown
1447           fMinTrackPtInNTXR=200.0;  //Initialize for each jet, overflown
1448           fMaxTrackPtInNTXR=200.0;  //Initialize for each jet, overflown
1449           deltaPhiPt = 0.0;
1450           deltaEtaPt = 0.0;
1451           deltaPhiSqPt = 0.0;
1452           deltaEtaSqPt = 0.0;
1453           totalTrackPt = 0.0;
1454           firstMomDeltPhi = 0.0;
1455           firstMomDeltEta = 0.0;
1456           secondMomDeltPhi = 0.0;
1457           secondMomDeltEta = 0.0;
1458           secondCentralPhi = 0.0;
1459           secondCentralEta = 0.0;
1460           secondCentralR = 0.0;
1461
1462           if(imcj<maxJetNum)
1463             genJets[imcj]= *mcjet;
1464           if(mcJetCounter<maxJetNum)
1465             jetPts[mcJetCounter]=mcjet->Pt();
1466           mcJetCounter++;  // number of jets in the acceptance
1467           jetPt = mcjet->Pt();
1468           flavor =  GetJetFlavour(mcjet,tracksMC,mcarray);
1469           if(imcj<maxJetNum)
1470             genJetsFlavor[imcj] = flavor;
1471           fJetPtMC->Fill(mcjet->Pt());
1472           fJetEtaMC->Fill(mcjet->Eta(),mcjet->Eta());
1473           fJetPhiMC->Fill(mcjet->Phi(),mcjet->Phi());
1474           fFlavor->Fill(flavor,jetPt);
1475           AliDebug(4,Form("Sabor del jet con pt=%f es :%d \n",jetPt,flavor));
1476           nTracksPerc = GetNumberOfMcChargedTracks(ntx,mcjet,tracksMC,mcarray,jfr); // este fija el min track pT, si es posible substraer el bckg
1477           if(fIsPossibleToSubstBckg&&!IsEqualRel(fCurrentJetMinPtNT90, 7000.)) //calculating only if there is a perpendicular cone available //IsEqualRel(jetpT, 0.0) //fCurrentJetMinPtNT90!=7000.
1478             {                                                     //and only if the method worked
1479               AliDebug(4,Form("For this jet and I have a perpendicular cone available"));
1480               // Aqui lo que debo contar es el numero de tracks arriba del min pT del jet correspondiente
1481               // que es fCurrentJetMinPtNT90
1482               nTracksAboveThresholdPerp = GetNMcChargedTracksAboveThreshold(fPerpCone,tracksMC,mcarray,jfr);
1483             }
1484           // Corrected jet (pT)
1485           if(fIsPossibleToSubstBckg)   // for the current jet
1486             {
1487               pTbs= mcjet->Pt()-fPerpCone->Pt();
1488               etabs= mcjet->Eta();
1489               phibs= mcjet->Phi();
1490               fBckgSbsJet[0]=pTbs; //pT
1491               fBckgSbsJet[1]=etabs; //eta
1492               fBckgSbsJet[2]=phibs; //phi
1493               // Now re-calculate nt90 for the energy corrected jet
1494               nTracksPercBckgSubst = GetRecalcNTXMc(ntx,mcjet,tracksMC,mcarray,jfr);
1495               // Now re-calculate the perpendicular cone NT90 background
1496               if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.)) //calculating for the current jet, if the previos method worked //!IsEqualRel(fCurrentJetMinPtNT90, 7000.) //fCurrentJetMinPtNT90Recalc!=7000.
1497                 {
1498                   // Aqui lo que debo contar es el numero de tracks arriba del min pT del jet correspondiente
1499                   // despues de la correccion de energia del jet
1500                   nTrUpThrPerpBckSubs = GetRecalcNMcChTrUpThr(fPerpCone,tracksMC,mcarray,jfr);
1501                 }
1502             }
1503
1504           //check cross sections incoming partons
1505           jetXt= 2*jetPt/fSqrts;
1506           if(evtype==11||evtype==12||evtype==13) //QQ
1507             fFracQQ->Fill(jetXt);
1508           if(evtype==28) //GQ
1509             fFracGQ->Fill(jetXt);
1510           if(evtype==53||evtype==68) //GG
1511             fFracGG->Fill(jetXt);
1512
1513           //check cross sections outgoing partons
1514           if(evtype==11||evtype==12||evtype==53) //QQ
1515             fFracOutGoingQQ->Fill(jetXt);
1516           if(evtype==28) //GQ
1517             fFracOutGoingGQ->Fill(jetXt);
1518           if(evtype==13||evtype==68) //GG
1519             fFracOutGoingGG->Fill(jetXt);
1520
1521           fProcessJetPt->Fill(evtype,jetPt);  // pythia process, filled for each jet in acceptance
1522
1523           //Fill jet flavor as a function of pT and the pythia process but only leading jet
1524           if(imcj==0)  //leading jet
1525             {
1526               fFlavorLead->Fill(flavor,jetPt);
1527               fProcessLeadJetPt->Fill(evtype,jetPt);
1528             }
1529           AliDebug(4,Form("Before the check of comparison"));
1530           // To check tracks related to this MC jet
1531           // RefTracks check
1532           Bool_t rTrkFlagMC = kFALSE;
1533           Int_t trkinmcjet = mcjet->GetRefTracks()->GetEntriesFast();
1534           if(trkinmcjet!=0&&!fForceNotTR)
1535             rTrkFlagMC = kTRUE;
1536           AliDebug(4,Form("Number of tracks in RefTracks MC jet:%i \n",trkinmcjet));
1537           if(rTrkFlagMC)  // If there are tracks refs available
1538             {
1539               AliDebug(4,Form("Checking composition in MC with track refs"));
1540               for(Int_t aodMCT = 0; aodMCT < trkinmcjet; aodMCT++ )
1541                 {
1542                   pdgOfMCt=0;
1543                   trackxi=0;
1544                   AliAODMCParticle *mctrack = (AliAODMCParticle*) mcjet->GetRefTracks()->At(aodMCT);
1545                   if(!mctrack) continue;
1546                   if(!mctrack->IsPhysicalPrimary()) continue;
1547                   if(mctrack->Charge()==0||mctrack->Charge()==-99) continue;
1548                   if(mctrack->Pt()<fMinpTVal) continue; // MC no cut in the case of track reference, should be in, NO, cut anyhow to be safe
1549                   randomNum = gRandom->Rndm();
1550                   if(randomNum<fJTrackRandomRejection) continue; //rechaza fJTrackRandomRejection
1551                   deltaPhiPt += DeltaPhiMC(mcjet, mctrack)*mctrack->Pt();
1552                   deltaEtaPt += DeltaEtaMC(mcjet, mctrack)*mctrack->Pt();
1553                   deltaPhiSqPt += DeltaPhiSqMC(mcjet, mctrack)*mctrack->Pt();
1554                   deltaEtaSqPt += DeltaEtaSqMC(mcjet, mctrack)*mctrack->Pt();
1555                   totalTrackPt += mctrack->Pt();
1556
1557                   pdgOfMCt=abs(mctrack->GetPdgCode());
1558                   if(!IsEqualRel(mctrack->Pt(), 0.0)) //!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.) // mctrack->Pt()!=0
1559                     trackxi= log(jetPt/mctrack->Pt());
1560                   switch(abs(flavor))
1561                     {
1562                     case 1:
1563                       if(pdgOfMCt==321)
1564                         fFragKaon[0]->Fill(trackxi,jetPt);
1565                       if(pdgOfMCt==211)
1566                         fFragPion[0]->Fill(trackxi,jetPt);
1567                       if(pdgOfMCt==2212)
1568                         fFragProton[0]->Fill(trackxi,jetPt);
1569                       break;
1570                     case 2:
1571                       if(pdgOfMCt==321)
1572                         fFragKaon[1]->Fill(trackxi,jetPt);
1573                       if(pdgOfMCt==211)
1574                         fFragPion[1]->Fill(trackxi,jetPt);
1575                       if(pdgOfMCt==2212)
1576                         fFragProton[1]->Fill(trackxi,jetPt);
1577                       break;
1578                     case 3:
1579                       if(pdgOfMCt==321)
1580                         fFragKaon[2]->Fill(trackxi,jetPt);
1581                       if(pdgOfMCt==211)
1582                         fFragPion[2]->Fill(trackxi,jetPt);
1583                       if(pdgOfMCt==2212)
1584                         fFragProton[2]->Fill(trackxi,jetPt);
1585                       break;
1586                     case 4:
1587                       if(pdgOfMCt==321)
1588                         fFragKaon[3]->Fill(trackxi,jetPt);
1589                       if(pdgOfMCt==211)
1590                         fFragPion[3]->Fill(trackxi,jetPt);
1591                       if(pdgOfMCt==2212)
1592                         fFragProton[3]->Fill(trackxi,jetPt);
1593                       break;
1594                     case 5:
1595                       if(pdgOfMCt==321)
1596                         fFragKaon[4]->Fill(trackxi,jetPt);
1597                       if(pdgOfMCt==211)
1598                         fFragPion[4]->Fill(trackxi,jetPt);
1599                       if(pdgOfMCt==2212)
1600                         fFragProton[4]->Fill(trackxi,jetPt);
1601                       break;
1602                     case 21:
1603                       if(pdgOfMCt==321)
1604                         fFragKaon[5]->Fill(trackxi,jetPt);
1605                       if(pdgOfMCt==211)
1606                         fFragPion[5]->Fill(trackxi,jetPt);
1607                       if(pdgOfMCt==2212)
1608                         fFragProton[5]->Fill(trackxi,jetPt);
1609                       break;
1610                     default:
1611                       break;
1612                     } // end switch flavor
1613                 }// end loop over AODMC particles of trackrefs
1614               if(!IsEqualRel(totalTrackPt, 0.0)) //!IsEqualRel(totalTrackPt, 0.0) //totalTrackPt!=0.0
1615                 {
1616                   firstMomDeltPhi = deltaPhiPt/totalTrackPt;
1617                   firstMomDeltEta = deltaEtaPt/totalTrackPt;
1618                   secondMomDeltPhi = deltaPhiSqPt/totalTrackPt;
1619                   secondMomDeltEta = deltaEtaSqPt/totalTrackPt;
1620                   secondCentralPhi = secondMomDeltPhi - firstMomDeltPhi*firstMomDeltPhi;
1621                   secondCentralEta = secondMomDeltEta - firstMomDeltEta*firstMomDeltEta;
1622                   secondCentralR = secondCentralPhi + secondCentralEta;
1623                 } // end if totalTrackPt!=0.0
1624               if(IsEqualRel(totalTrackPt, 0.0))  //totalTrackPt==0.0
1625                 secondCentralR = 10.0; //overflow
1626             }// end version with ref tracks (flag check)
1627
1628           if(!rTrkFlagMC)  // No ref tracks available
1629             {
1630               AliDebug(4,Form("Checking composition in MC without track refs"));
1631               for(Int_t aodMCT = 0; aodMCT < tracksMC; aodMCT++ )
1632                 {
1633                   pdgOfMCt=0;
1634                   trackxi=0;
1635                   AliAODMCParticle *mctrack = (AliAODMCParticle*) mcarray->At(aodMCT);
1636                   if(!mctrack) continue;
1637                   if(!mctrack->IsPhysicalPrimary()) continue;
1638                   if(mctrack->Charge()==0||mctrack->Charge()==-99) continue;
1639                   if(!IsMCTrackInsideThisJet(mctrack, mcjet, jfr)) continue;
1640                   if(mctrack->Pt()<fMinpTVal) continue; // MC: HERE PT CUT, NO TRACK REF
1641                   randomNum = gRandom->Rndm();
1642                   if(randomNum<fJTrackRandomRejection) continue; //rechaza fJTrackRandomRejection
1643                   deltaPhiPt += DeltaPhiMC(mcjet, mctrack)*mctrack->Pt();
1644                   deltaEtaPt += DeltaEtaMC(mcjet, mctrack)*mctrack->Pt();
1645                   deltaPhiSqPt += DeltaPhiSqMC(mcjet, mctrack)*mctrack->Pt();
1646                   deltaEtaSqPt += DeltaEtaSqMC(mcjet, mctrack)*mctrack->Pt();
1647                   totalTrackPt += mctrack->Pt();
1648
1649                   pdgOfMCt=abs(mctrack->GetPdgCode());
1650                   if(!IsEqualRel(mctrack->Pt(), 0.0)) //!IsEqualRel(mctrack->Pt(), 0.0) // mctrack->Pt()!=0
1651                     trackxi= log(jetPt/mctrack->Pt());
1652                   switch(flavor)
1653                     {
1654                     case 1:
1655                       if(pdgOfMCt==321)
1656                         fFragKaon[0]->Fill(trackxi,jetPt);
1657                       if(pdgOfMCt==211)
1658                         fFragPion[0]->Fill(trackxi,jetPt);
1659                       if(pdgOfMCt==2212)
1660                         fFragProton[0]->Fill(trackxi,jetPt);
1661                       break;
1662                     case 2:
1663                       if(pdgOfMCt==321)
1664                         fFragKaon[1]->Fill(trackxi,jetPt);
1665                       if(pdgOfMCt==211)
1666                         fFragPion[1]->Fill(trackxi,jetPt);
1667                       if(pdgOfMCt==2212)
1668                         fFragProton[1]->Fill(trackxi,jetPt);
1669                       break;
1670                     case 3:
1671                       if(pdgOfMCt==321)
1672                         fFragKaon[2]->Fill(trackxi,jetPt);
1673                       if(pdgOfMCt==211)
1674                         fFragPion[2]->Fill(trackxi,jetPt);
1675                       if(pdgOfMCt==2212)
1676                         fFragProton[2]->Fill(trackxi,jetPt);
1677                       break;
1678                     case 4:
1679                       if(pdgOfMCt==321)
1680                         fFragKaon[3]->Fill(trackxi,jetPt);
1681                       if(pdgOfMCt==211)
1682                         fFragPion[3]->Fill(trackxi,jetPt);
1683                       if(pdgOfMCt==2212)
1684                         fFragProton[3]->Fill(trackxi,jetPt);
1685                       break;
1686                     case 5:
1687                       if(pdgOfMCt==321)
1688                         fFragKaon[4]->Fill(trackxi,jetPt);
1689                       if(pdgOfMCt==211)
1690                         fFragPion[4]->Fill(trackxi,jetPt);
1691                       if(pdgOfMCt==2212)
1692                         fFragProton[4]->Fill(trackxi,jetPt);
1693                       break;
1694                     case 21:
1695                       if(pdgOfMCt==321)
1696                         fFragKaon[5]->Fill(trackxi,jetPt);
1697                       if(pdgOfMCt==211)
1698                         fFragPion[5]->Fill(trackxi,jetPt);
1699                       if(pdgOfMCt==2212)
1700                     fFragProton[5]->Fill(trackxi,jetPt);
1701                       break;
1702                     default:
1703                       break;
1704                     } // end switch flavor
1705                 }// end loop over AODMC particles
1706               if(!IsEqualRel(totalTrackPt, 0.0)) //!IsEqualRel(totalTrackPt, 0.0) // totalTrackPt!=0.0
1707                 {
1708                   firstMomDeltPhi = deltaPhiPt/totalTrackPt;
1709                   firstMomDeltEta = deltaEtaPt/totalTrackPt;
1710                   secondMomDeltPhi = deltaPhiSqPt/totalTrackPt;
1711                   secondMomDeltEta = deltaEtaSqPt/totalTrackPt;
1712                   secondCentralPhi = secondMomDeltPhi - firstMomDeltPhi*firstMomDeltPhi;
1713                   secondCentralEta = secondMomDeltEta - firstMomDeltEta*firstMomDeltEta;
1714                   secondCentralR = secondCentralPhi + secondCentralEta;
1715                 } // end if totalTrackPt!=0.0
1716               if(IsEqualRel(totalTrackPt, 0.0)) //!IsEqualRel(totalTrackPt, 0.0) //totalTrackPt==0.0
1717                 secondCentralR = 10.0; //overflow
1718             } //End old version (no ref tracks)
1719
1720           if(fIsPossibleToSubstBckg)
1721             {
1722               // To make sure, re-initialize
1723               deltaPhiPtPerp = 0.0;
1724               deltaEtaPtPerp = 0.0;
1725               deltaPhiSqPtPerp = 0.0;
1726               deltaEtaSqPtPerp = 0.0;
1727               totalTrackPtPerp = 0.0;
1728               firstMomDeltPhiPerp = 0.0;
1729               firstMomDeltEtaPerp = 0.0;
1730               secondMomDeltPhiPerp = 0.0;
1731               secondMomDeltEtaPerp = 0.0;
1732               secondCentralPhiPerp = 0.0;
1733               secondCentralEtaPerp = 0.0;
1734               secondCentralRPerp = 0.0;
1735
1736               AliDebug(4,Form("Checking SCM in MC for the perpendicular cone"));
1737               for(Int_t aodMCperp = 0; aodMCperp < tracksMC; aodMCperp++ )
1738                 {
1739                   AliAODMCParticle *mctrackperp = (AliAODMCParticle*) mcarray->At(aodMCperp);
1740                   if(!mctrackperp) continue;
1741                   if(!mctrackperp->IsPhysicalPrimary()) continue;
1742                   if(mctrackperp->Charge()==0||mctrackperp->Charge()==-99) continue;
1743                   if(!IsMCTrackInsideThisJet(mctrackperp, fPerpCone, jfr)) continue;
1744                   if(mctrackperp->Pt()<fMinpTVal) continue; // MC: HERE PT CUT
1745                   randomNum = gRandom->Rndm();
1746                   if(randomNum<fJTrackRandomRejection) continue; //rechaza fJTrackRandomRejection
1747                   deltaPhiPtPerp += DeltaPhiMC(fPerpCone, mctrackperp)*mctrackperp->Pt();
1748                   deltaEtaPtPerp += DeltaEtaMC(fPerpCone, mctrackperp)*mctrackperp->Pt();
1749                   deltaPhiSqPtPerp += DeltaPhiSqMC(fPerpCone, mctrackperp)*mctrackperp->Pt();
1750                   deltaEtaSqPtPerp += DeltaEtaSqMC(fPerpCone, mctrackperp)*mctrackperp->Pt();
1751                   totalTrackPtPerp += mctrackperp->Pt();
1752                 }// end loop over AODMC particles
1753               if(!IsEqualRel(totalTrackPtPerp, 0.0)) //!IsEqualRel(totalTrackPt, 0.0) // totalTrackPtPerp!=0.0
1754                 {
1755                   firstMomDeltPhiPerp = deltaPhiPtPerp/totalTrackPtPerp;
1756                   firstMomDeltEtaPerp = deltaEtaPtPerp/totalTrackPtPerp;
1757                   secondMomDeltPhiPerp = deltaPhiSqPtPerp/totalTrackPtPerp;
1758                   secondMomDeltEtaPerp = deltaEtaSqPtPerp/totalTrackPtPerp;
1759                   secondCentralPhiPerp = secondMomDeltPhiPerp - firstMomDeltPhiPerp*firstMomDeltPhiPerp;
1760                   secondCentralEtaPerp = secondMomDeltEtaPerp - firstMomDeltEtaPerp*firstMomDeltEtaPerp;
1761                   secondCentralRPerp = secondCentralPhiPerp + secondCentralEtaPerp;
1762                 } // end if totalTrackPt!=0.0
1763               if(IsEqualRel(totalTrackPtPerp, 0.0)) //!IsEqualRel(totalTrackPtPerp, 0.0) //totalTrackPtPerp==0.0
1764                 secondCentralRPerp = 10.0; //overflow
1765             }
1766           ///// end of adding the SCM for the perpendicular cone
1767
1768           if(mcjets==1) // if only one jet in the whole event, and inside acceptance
1769             {
1770               // reference multiplicity stuff in pp, also filled in PbPb, but does not matter.
1771               // set to: V0 like corrected multiplicity: correctedV0LikeMult
1772               if(correctedV0LikeMult<25)
1773                 {
1774                   fNChTrRDMultOJMC[0]->Fill(nTracksPerc,jetPt);
1775                   fSCMRDMultOJMC[0]->Fill(secondCentralR,jetPt);
1776                   fJEtaMCMultOJ[0]->Fill(mcjet->Eta());
1777                   fJetPtMCMultOJ[0]->Fill(mcjet->Pt());
1778                 }
1779               if(correctedV0LikeMult>=25&&correctedV0LikeMult<50)
1780                 {
1781                   fNChTrRDMultOJMC[1]->Fill(nTracksPerc,jetPt);
1782                   fSCMRDMultOJMC[1]->Fill(secondCentralR,jetPt);
1783                   fJEtaMCMultOJ[1]->Fill(mcjet->Eta());
1784                   fJetPtMCMultOJ[1]->Fill(mcjet->Pt());
1785                 }
1786               if(correctedV0LikeMult>=50&&correctedV0LikeMult<90)
1787                 {
1788                   fNChTrRDMultOJMC[2]->Fill(nTracksPerc,jetPt);
1789                   fSCMRDMultOJMC[2]->Fill(secondCentralR,jetPt);
1790                   fJEtaMCMultOJ[2]->Fill(mcjet->Eta());
1791                   fJetPtMCMultOJ[2]->Fill(mcjet->Pt());
1792                 }
1793               if(correctedV0LikeMult>=90&&correctedV0LikeMult<120)
1794                 {
1795                   fNChTrRDMultOJMC[3]->Fill(nTracksPerc,jetPt);
1796                   fSCMRDMultOJMC[3]->Fill(secondCentralR,jetPt);
1797                   fJEtaMCMultOJ[3]->Fill(mcjet->Eta());
1798                   fJetPtMCMultOJ[3]->Fill(mcjet->Pt());
1799                 }
1800               if(correctedV0LikeMult>=120&&correctedV0LikeMult<150)
1801                 {
1802                   fNChTrRDMultOJMC[4]->Fill(nTracksPerc,jetPt);
1803                   fSCMRDMultOJMC[4]->Fill(secondCentralR,jetPt);
1804                   fJEtaMCMultOJ[4]->Fill(mcjet->Eta());
1805                   fJetPtMCMultOJ[4]->Fill(mcjet->Pt());
1806                 }
1807               if(correctedV0LikeMult>=150&&correctedV0LikeMult<200)
1808                 {
1809                   fNChTrRDMultOJMC[5]->Fill(nTracksPerc,jetPt);
1810                   fSCMRDMultOJMC[5]->Fill(secondCentralR,jetPt);
1811                   fJEtaMCMultOJ[5]->Fill(mcjet->Eta());
1812                   fJetPtMCMultOJ[5]->Fill(mcjet->Pt());
1813                 }
1814               if(correctedV0LikeMult>=200&&correctedV0LikeMult<300)
1815                 {
1816                   fNChTrRDMultOJMC[6]->Fill(nTracksPerc,jetPt);
1817                   fSCMRDMultOJMC[6]->Fill(secondCentralR,jetPt);
1818                   fJEtaMCMultOJ[6]->Fill(mcjet->Eta());
1819                   fJetPtMCMultOJ[6]->Fill(mcjet->Pt());
1820                 }
1821               if(correctedV0LikeMult>=300)
1822                 {
1823                   fNChTrRDMultOJMC[7]->Fill(nTracksPerc,jetPt);
1824                   fSCMRDMultOJMC[7]->Fill(secondCentralR,jetPt);
1825                   fJEtaMCMultOJ[7]->Fill(mcjet->Eta());
1826                   fJetPtMCMultOJ[7]->Fill(mcjet->Pt());
1827                 }
1828               //Results for inclusive jets
1829               // 2nd. Reference: set to: TPC tracks minus jet, minus dijet area
1830               if(softRefMcNoJets<5)
1831                 {
1832                   fNChTrRDMultSEOJMC[0]->Fill(nTracksPerc,jetPt);
1833                   fSCMRDMultSEOJMC[0]->Fill(secondCentralR,jetPt);
1834                   fJEtaMCMultSEOJ[0]->Fill(mcjet->Eta());
1835                   fJetPtMCMultSEOJ[0]->Fill(mcjet->Pt());
1836                   if(abs(flavor)==1||abs(flavor)==2||abs(flavor)==3||abs(flavor)==4||abs(flavor)==5) //if quark jet
1837                     fEntriesQuark[0]->Fill(nTracksPerc,jetPt);
1838                   if(abs(flavor)==21) //if gluon jet
1839                     fEntriesGluon[0]->Fill(nTracksPerc,jetPt);
1840                 }
1841               if(softRefMcNoJets>=5&&softRefMcNoJets<10)
1842                 {
1843                   fNChTrRDMultSEOJMC[1]->Fill(nTracksPerc,jetPt);
1844                   fSCMRDMultSEOJMC[1]->Fill(secondCentralR,jetPt);
1845                   fJEtaMCMultSEOJ[1]->Fill(mcjet->Eta());
1846                   fJetPtMCMultSEOJ[1]->Fill(mcjet->Pt());
1847                   if(abs(flavor)==1||abs(flavor)==2||abs(flavor)==3||abs(flavor)==4||abs(flavor)==5) //if quark jet
1848                     fEntriesQuark[1]->Fill(nTracksPerc,jetPt);
1849                   if(abs(flavor)==21) //if gluon jet
1850                     fEntriesGluon[1]->Fill(nTracksPerc,jetPt);
1851                 }
1852               if(softRefMcNoJets>=10&&softRefMcNoJets<15)
1853                 {
1854                   fNChTrRDMultSEOJMC[2]->Fill(nTracksPerc,jetPt);
1855                   fSCMRDMultSEOJMC[2]->Fill(secondCentralR,jetPt);
1856                   fJEtaMCMultSEOJ[2]->Fill(mcjet->Eta());
1857                   fJetPtMCMultSEOJ[2]->Fill(mcjet->Pt());
1858                   if(abs(flavor)==1||abs(flavor)==2||abs(flavor)==3||abs(flavor)==4||abs(flavor)==5) //if quark jet
1859                     fEntriesQuark[2]->Fill(nTracksPerc,jetPt);
1860                   if(abs(flavor)==21) //if gluon jet
1861                     fEntriesGluon[2]->Fill(nTracksPerc,jetPt);
1862                 }
1863               if(softRefMcNoJets>=15&&softRefMcNoJets<20)
1864                 {
1865                   fNChTrRDMultSEOJMC[3]->Fill(nTracksPerc,jetPt);
1866                   fSCMRDMultSEOJMC[3]->Fill(secondCentralR,jetPt);
1867                   fJEtaMCMultSEOJ[3]->Fill(mcjet->Eta());
1868                   fJetPtMCMultSEOJ[3]->Fill(mcjet->Pt());
1869                   if(abs(flavor)==1||abs(flavor)==2||abs(flavor)==3||abs(flavor)==4||abs(flavor)==5) //if quark jet
1870                     fEntriesQuark[3]->Fill(nTracksPerc,jetPt);
1871                   if(abs(flavor)==21) //if gluon jet
1872                     fEntriesGluon[3]->Fill(nTracksPerc,jetPt);
1873                 }
1874               if(softRefMcNoJets>=20&&softRefMcNoJets<30)
1875                 {
1876                   fNChTrRDMultSEOJMC[4]->Fill(nTracksPerc,jetPt);
1877                   fSCMRDMultSEOJMC[4]->Fill(secondCentralR,jetPt);
1878                   fJEtaMCMultSEOJ[4]->Fill(mcjet->Eta());
1879                   fJetPtMCMultSEOJ[4]->Fill(mcjet->Pt());
1880                   if(abs(flavor)==1||abs(flavor)==2||abs(flavor)==3||abs(flavor)==4||abs(flavor)==5) //if quark jet
1881                     fEntriesQuark[4]->Fill(nTracksPerc,jetPt);
1882                   if(abs(flavor)==21) //if gluon jet
1883                     fEntriesGluon[4]->Fill(nTracksPerc,jetPt);
1884                 }
1885               if(softRefMcNoJets>=30&&softRefMcNoJets<40)
1886                 {
1887                   fNChTrRDMultSEOJMC[5]->Fill(nTracksPerc,jetPt);
1888                   fSCMRDMultSEOJMC[5]->Fill(secondCentralR,jetPt);
1889                   fJEtaMCMultSEOJ[5]->Fill(mcjet->Eta());
1890                   fJetPtMCMultSEOJ[5]->Fill(mcjet->Pt());
1891                   if(abs(flavor)==1||abs(flavor)==2||abs(flavor)==3||abs(flavor)==4||abs(flavor)==5) //if quark jet
1892                     fEntriesQuark[5]->Fill(nTracksPerc,jetPt);
1893                   if(abs(flavor)==21) //if gluon jet
1894                     fEntriesGluon[5]->Fill(nTracksPerc,jetPt);
1895                 }
1896               if(softRefMcNoJets>=40&&softRefMcNoJets<50)
1897                 {
1898                   fNChTrRDMultSEOJMC[6]->Fill(nTracksPerc,jetPt);
1899                   fSCMRDMultSEOJMC[6]->Fill(secondCentralR,jetPt);
1900                   fJEtaMCMultSEOJ[6]->Fill(mcjet->Eta());
1901                   fJetPtMCMultSEOJ[6]->Fill(mcjet->Pt());
1902                   if(abs(flavor)==1||abs(flavor)==2||abs(flavor)==3||abs(flavor)==4||abs(flavor)==5) //if quark jet
1903                     fEntriesQuark[6]->Fill(nTracksPerc,jetPt);
1904                   if(abs(flavor)==21) //if gluon jet
1905                     fEntriesGluon[6]->Fill(nTracksPerc,jetPt);
1906                 }
1907               if(softRefMcNoJets>=50)
1908                 {
1909                   fNChTrRDMultSEOJMC[7]->Fill(nTracksPerc,jetPt);
1910                   fSCMRDMultSEOJMC[7]->Fill(secondCentralR,jetPt);
1911                   fJEtaMCMultSEOJ[7]->Fill(mcjet->Eta());
1912                   fJetPtMCMultSEOJ[7]->Fill(mcjet->Pt());
1913                   if(abs(flavor)==1||abs(flavor)==2||abs(flavor)==3||abs(flavor)==4||abs(flavor)==5) //if quark jet
1914                     fEntriesQuark[7]->Fill(nTracksPerc,jetPt);
1915                   if(abs(flavor)==21) //if gluon jet
1916                     fEntriesGluon[7]->Fill(nTracksPerc,jetPt);
1917                 }
1918             }
1919           //End results for inclusive jets,starts parton by parton
1920
1921           switch(abs(flavor))
1922             {
1923             case 1:
1924               fNChTr[0]->Fill(nTracksPerc,jetPt);
1925               fProcessPDG[0]->Fill(jetPt,evtype);
1926               fHistPtParton[0]->Fill(jetPt);
1927               fSCM[0]->Fill(secondCentralR,jetPt);
1928               fMinTrackPtInNTXh[0]->Fill(fMinTrackPtInNTX,jetPt,1); // 0 for pp MC
1929               fMaxTrackPtInNTXh[0]->Fill(fMaxTrackPtInNTX,jetPt); // 0 for MC
1930               if(fIsPossibleToSubstBckg)
1931                 {
1932                   fNChTrCorrMCQuark->Fill(nTracksPercBckgSubst,pTbs);
1933                   fSCMMCPerp->Fill(secondCentralR,jetPt);
1934                   if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.)) //!IsEqualRel(mctrack->Pt(), 0.0) // fCurrentJetMinPtNT90!=7000.
1935                     fNChTrMCPerp->Fill(nTracksAboveThresholdPerp,jetPt);
1936                   if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.)) // !IsEqualRel(fCurrentJetMinPtNT90, 7000.) // fCurrentJetMinPtNT90Recalc!=7000.
1937                     fNChTrCorrMCPerp->Fill(nTrUpThrPerpBckSubs,pTbs);
1938                 }
1939               break;
1940             case 2:
1941               fNChTr[1]->Fill(nTracksPerc,jetPt);
1942               fProcessPDG[1]->Fill(jetPt,evtype);
1943               fHistPtParton[1]->Fill(jetPt);
1944               fSCM[1]->Fill(secondCentralR,jetPt);
1945               fMinTrackPtInNTXh[0]->Fill(fMinTrackPtInNTX,jetPt,1); // 0 for pp MC
1946               fMaxTrackPtInNTXh[0]->Fill(fMaxTrackPtInNTX,jetPt); // 0 for MC
1947               if(fIsPossibleToSubstBckg)
1948                 {
1949                   fNChTrCorrMCQuark->Fill(nTracksPercBckgSubst,pTbs);
1950                   fSCMMCPerp->Fill(secondCentralR,jetPt);
1951                   if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
1952                     fNChTrMCPerp->Fill(nTracksAboveThresholdPerp,jetPt);
1953                   if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
1954                     fNChTrCorrMCPerp->Fill(nTrUpThrPerpBckSubs,pTbs);
1955                 }
1956               break;
1957             case 3:
1958               fNChTr[2]->Fill(nTracksPerc,jetPt);
1959               fProcessPDG[2]->Fill(jetPt,evtype);
1960               fHistPtParton[2]->Fill(jetPt);
1961               fSCM[2]->Fill(secondCentralR,jetPt);
1962               fMinTrackPtInNTXh[0]->Fill(fMinTrackPtInNTX,jetPt,1); // 0 for pp MC
1963               fMaxTrackPtInNTXh[0]->Fill(fMaxTrackPtInNTX,jetPt); // 0 for MC
1964               if(fIsPossibleToSubstBckg)
1965                 {
1966                   fNChTrCorrMCQuark->Fill(nTracksPercBckgSubst,pTbs);
1967                   fSCMMCPerp->Fill(secondCentralR,jetPt);
1968                   if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
1969                     fNChTrMCPerp->Fill(nTracksAboveThresholdPerp,jetPt);
1970                   if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
1971                     fNChTrCorrMCPerp->Fill(nTrUpThrPerpBckSubs,pTbs);
1972                 }
1973               break;
1974             case 4:
1975               fNChTr[3]->Fill(nTracksPerc,jetPt);
1976               fProcessPDG[3]->Fill(jetPt,evtype);
1977               fHistPtParton[3]->Fill(jetPt);
1978               fSCM[3]->Fill(secondCentralR,jetPt);
1979               fMinTrackPtInNTXh[0]->Fill(fMinTrackPtInNTX,jetPt,1); // 0 for pp MC
1980               fMaxTrackPtInNTXh[0]->Fill(fMaxTrackPtInNTX,jetPt); // 0 for MC
1981               if(fIsPossibleToSubstBckg)
1982                 {
1983                   fNChTrCorrMCQuark->Fill(nTracksPercBckgSubst,pTbs);
1984                   fSCMMCPerp->Fill(secondCentralR,jetPt);
1985                   if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
1986                     fNChTrMCPerp->Fill(nTracksAboveThresholdPerp,jetPt);
1987                   if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
1988                     fNChTrCorrMCPerp->Fill(nTrUpThrPerpBckSubs,pTbs);
1989                 }
1990               break;
1991             case 5:
1992               fNChTr[4]->Fill(nTracksPerc,jetPt);
1993               fProcessPDG[4]->Fill(jetPt,evtype);
1994               fHistPtParton[4]->Fill(jetPt);
1995               fSCM[4]->Fill(secondCentralR,jetPt);
1996               fMinTrackPtInNTXh[0]->Fill(fMinTrackPtInNTX,jetPt,1); // 0 for pp MC
1997               fMaxTrackPtInNTXh[0]->Fill(fMaxTrackPtInNTX,jetPt); // 0 for MC
1998               if(fIsPossibleToSubstBckg)
1999                 {
2000                   fNChTrCorrMCQuark->Fill(nTracksPercBckgSubst,pTbs);
2001                   fSCMMCPerp->Fill(secondCentralR,jetPt);
2002                   if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
2003                     fNChTrMCPerp->Fill(nTracksAboveThresholdPerp,jetPt);
2004                   if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
2005                     fNChTrCorrMCPerp->Fill(nTrUpThrPerpBckSubs,pTbs);
2006                 }
2007               break;
2008             case 21:
2009               fNChTr[5]->Fill(nTracksPerc,jetPt);
2010               fProcessPDG[5]->Fill(jetPt,evtype);
2011               fHistPtParton[5]->Fill(jetPt);
2012               fSCM[5]->Fill(secondCentralR,jetPt);
2013               fMinTrackPtInNTXh[0]->Fill(fMinTrackPtInNTX,jetPt,1); // 0 for pp MC
2014               fMaxTrackPtInNTXh[0]->Fill(fMaxTrackPtInNTX,jetPt); // 0 for MC
2015               if(fIsPossibleToSubstBckg)
2016                 {
2017                   fNChTrCorrMCGluon->Fill(nTracksPercBckgSubst,pTbs);
2018                   fSCMMCPerp->Fill(secondCentralR,jetPt);
2019                   if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
2020                     fNChTrMCPerp->Fill(nTracksAboveThresholdPerp,jetPt);
2021                   if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
2022                     fNChTrCorrMCPerp->Fill(nTrUpThrPerpBckSubs,pTbs);
2023                 }
2024               break;
2025             default:
2026               break;
2027             }
2028           AliDebug(4,Form("Sabor del jet numero:%d es: %d y se necesitaron %d tracks \n",indxmc,flavor,nTracksPerc));
2029           imcj++;
2030         } // MC jets for cycle
2031       nGenJets=imcj;
2032       for(Int_t u=0 ; u<mcJetCounter  ;u++)
2033         {
2034           if(u<7)
2035             fJetsMultPtMC->Fill(jetPts[u],mcJetCounter);
2036         }
2037       // if(fEnablePrints)
2038       //  {
2039       //   if(mcJetCounter>=3)
2040       //    printf("%i Jets inside acceptance at event number:%i \n",mcJetCounter,fEvtCount-1);
2041       //  }
2042       fNAccJetsMC->Fill(mcJetCounter,mcJetCounter);
2043     } // end if MC info in AOD
2044
2045   if(!fUseOnlyMC)
2046     {
2047       // Primero que todo, debe de ir la seleccion de eventos reconstruidos:
2048       // 1. Que tenga un vertice reconstruido dentro de 10 cm.
2049       // Vertex info for reconstructed events
2050       AliAODVertex *pvx = fAOD->GetPrimaryVertex();
2051       if(!pvx)
2052         {
2053           AliError("No primary vertex!");
2054           return;
2055         }
2056       if(TMath::Abs(pvx->GetZ())>10.) // if the event vertex is larger than 10 cm, reject
2057         return;
2058       fZVertex->Fill(pvx->GetZ(),pvx->GetZ()); // vertex, provide number of accepted events as entries for reco jets
2059
2060       ///////////////////////////////////////
2061       // SECONDARY RECO BRANCH STUFF       //
2062       // Get the secondary branch with the reconstructed jets
2063       if(fBranchSecRec!="")
2064         {
2065           AliDebug(4,Form("fBranchSecRec was not default \n"));
2066           TClonesArray *aodSecRecJets = dynamic_cast<TClonesArray*>(fAOD->FindListObject(fBranchSecRec.Data()));
2067           if(!aodSecRecJets)
2068             {
2069               AliError(Form("%s:%d no reconstructed Secondary Jet array with name %s in AOD",(char*)__FILE__,__LINE__,fBranchSecRec.Data()));
2070               return;  //stop the analysis
2071             }
2072           AliDebug(4,Form("There are %d reconstructed jets from the secondary branch in this event \n", aodSecRecJets->GetEntries()));
2073           Int_t recojetsSEC =  aodSecRecJets->GetEntries();
2074           fNJetsRDSeco->Fill(recojetsSEC,recojetsSEC);  // number of jets in the secondary branch
2075
2076           HasOverlapedCones(aodSecRecJets); // Procedure for tagging usable jets
2077                                             // Up 16 jets are flagged
2078
2079           AliDebug(4,"Antes de realizar el loop jets reconstruidos del segundo branch \n");
2080           Int_t secondjetacccounter = 0;
2081           for (Int_t IDXS = 0; IDXS < recojetsSEC; IDXS++)
2082             {
2083               AliDebug(4,Form("Number of current jet:%i \n",IDXS));
2084               AliAODJet *rjetsec = dynamic_cast<AliAODJet*>(aodSecRecJets->At(IDXS));
2085               if (!rjetsec)
2086                 {
2087                   AliDebug(2,Form("ERROR: Could not receive jet %d from the second branch\n", IDXS));
2088                   continue;
2089                 }
2090
2091               ///////////////////////////////////////////////////////////////////////////////
2092               ///// Part for Chritians plot of inclusive and leading jets comp at 2.76 TeV //
2093               if(!IsInsideAcceptance(rjetsec))  // old condition
2094                 continue;
2095               if(IDXS==0) // leading jet
2096                 fSecRecJetPtLeading->Fill(rjetsec->Pt());
2097               fSecRecJetPtInclusive->Fill(rjetsec->Pt()); // all
2098               ///// End of Christians Plot reco 2nd branch
2099               ///////////////////////////////////////////////////////////////////////////////
2100
2101               if(IDXS>15)
2102                 continue;
2103
2104               if(!fJetFlags[IDXS]) // If the jet is flaged kFALSE, not usable
2105                 continue;
2106
2107               fJetPtSec->Fill(rjetsec->Pt());
2108               fJetEtaSec->Fill(rjetsec->Eta(),rjetsec->Eta());
2109               fJetPhiSec->Fill(rjetsec->Phi(),rjetsec->Phi());
2110               secondjetacccounter++;
2111             }
2112           fNAccJetsRDSeco->Fill(secondjetacccounter,secondjetacccounter);
2113         }
2114       // END OF SECONDARY BRANCH STUFF     //
2115       ///////////////////////////////////////
2116
2117       // Get the branch with the reconstructed jets
2118       TClonesArray *aodRecJets = dynamic_cast<TClonesArray*>(fAOD->FindListObject(fBranchRec.Data()));
2119       if(!aodRecJets)
2120         {
2121           AliError(Form("%s:%d no reconstructed Jet array with name %s in AOD",(char*)__FILE__,__LINE__,fBranchRec.Data()));
2122           return;
2123         }
2124
2125       AliDebug(4,Form("There are %d reconstructed jets in this event\n", aodRecJets->GetEntries()));
2126       Int_t recojets =  aodRecJets->GetEntries();
2127       fNJetsRD->Fill(recojets,recojets); // numero de jets directamente del branch
2128
2129       HasOverlapedCones(aodRecJets); // Procedure for tagging usable jets
2130                                     // Up 16 jets are flagged
2131
2132       AliDebug(4,"Antes de realizar el loop sobre AOD tracks \n");
2133       // Loop over AOD tracks
2134       Int_t tracksAOD = fAOD->GetNumberOfTracks();
2135       AliDebug(4,Form("Numero de tracks en el AOD:%d \n",tracksAOD));
2136       Double_t aodtracketa = 0.0;
2137       perpendicularPt = 0.0;
2138       px=0.0;
2139       py=0.0;
2140       pz=0.0;
2141       en=0.0;
2142       pTbs=0.0;
2143       etabs=0.0;
2144       phibs=0.0;
2145       fBckgSbsJet[0]=0.0;
2146       fBckgSbsJet[1]=0.0;
2147       fBckgSbsJet[2]=0.0;
2148       Int_t refNJMult = 0;
2149       Int_t myTotalMultRef = 0;
2150       Int_t myTotalSoftMultRef = 0;
2151       for(Int_t aodT = 0; aodT < tracksAOD; aodT++ )
2152         {
2153           AliAODTrack *aodtrack = fAOD->GetTrack(aodT);
2154           if(!aodtrack) continue;
2155           aodtracketa = TMath::Abs(aodtrack->Eta());
2156           if(aodtracketa>0.9) continue;
2157           if(!aodtrack->TestFilterBit(fFilterBit)) continue; //track filter selection
2158           if(!aodtrack->IsPrimaryCandidate()) continue; // only primaries, maybe is redundant with the previous selection...
2159           fEtaAOD->Fill(aodtrack->Eta(),aodtrack->Eta());
2160           fPhiAOD->Fill(aodtrack->Phi(),aodtrack->Phi());
2161           fPtAOD->Fill(aodtrack->Pt(),aodtrack->Pt());
2162           if(fJetEvent) // if has an accepted jet, calculate the perpendicular cone
2163             {
2164               if(HasPerpendicularCone()) // If there is a perpendicular cone available
2165                 {
2166                   if(aodtrack->Pt()>fMinpTVal)
2167                     {
2168                       if(GetDeltaR(fEtaPerpCoord,fPhiPerpCoord,aodtrack->Eta(),aodtrack->Phi())<fJetRadius)
2169                         perpendicularPt = perpendicularPt + aodtrack->Pt();
2170                     }
2171                 }
2172             } // end if jet event
2173           //Total TPC multiplicity of primaries
2174           if(aodtrack->Pt()>fMinPtInGlobMult) // Min pT used in multiplicity estimation
2175             {
2176               myTotalMultRef++;
2177               if(aodtrack->Pt()<fMinpTValUE) continue; // pT cut  fMinpTValUE
2178               if(aodtrack->Pt()>fMaxpTValUE) continue; // pT cut  fMaxpTValUE
2179               myTotalSoftMultRef++;
2180               if(!IsTrackInsideExcludedArea(aodtrack->Eta(), aodtrack->Phi(), aodRecJets))
2181                 refNJMult++;
2182             }
2183         } // end track loop over the event...
2184
2185       fRefMultWOJet->Fill(refMultiplicity,refNJMult);
2186       fMultWOJetVZero->Fill(refNJMult,multFullV0);
2187       Double_t v0CorrMult = multFullV0 - GetV0ExcludedMultiplicity(aodRecJets);
2188       fRefMultFullV0->Fill(refMultiplicity,multFullV0);
2189       fRefMultV0Corr->Fill(refMultiplicity,v0CorrMult);
2190       fFullV0V0Corr->Fill(multFullV0,v0CorrMult);
2191       fRefAODTrackCount->Fill(refMultiplicity,myTotalMultRef);
2192       fTrackCountWOJet->Fill(myTotalMultRef,refNJMult);
2193
2194       if(recojets==1) // correlation for only monojet events
2195         {
2196           fRefMultFullV0UJ->Fill(refMultiplicity,multFullV0);
2197           fRefMultV0CorrUJ->Fill(refMultiplicity,v0CorrMult);
2198           fFullV0V0CorrUJ->Fill(multFullV0,v0CorrMult);
2199           fMultWOJetVZeroUJ->Fill(refNJMult,multFullV0);
2200           fRefMultWOJetUJ->Fill(refMultiplicity,refNJMult);
2201           fRefAODTrackCountUJ->Fill(refMultiplicity,myTotalMultRef);
2202           fTrackCountWOJetUJ->Fill(myTotalMultRef,refNJMult);
2203         }
2204
2205       if(fJetEvent) // if has an accepted jet, calculate the perpendicular cone
2206         {
2207           if(HasPerpendicularCone()) // If there is a perpendicular cone available
2208             {
2209               px = perpendicularPt*TMath::Cos(fPhiPerpCoord);
2210               py = perpendicularPt*TMath::Sin(fPhiPerpCoord);
2211               pz = perpendicularPt/TMath::Tan(2.0*TMath::ATan(TMath::Exp(-fEtaPerpCoord)));
2212               en = TMath::Sqrt(px*px + py*py + pz*pz);
2213               fPerpCone->SetPxPyPzE(px, py, pz, en);
2214             }
2215         }
2216
2217       // Loop to fill a pT spectrum of the reco jets
2218       Int_t irecj=0; // index for reconstructed jets to correlate
2219       Int_t nrectracks[6]={0};
2220       Double_t ptrecjet[6]={0};
2221       Double_t scmr[6]={0};
2222       Double_t aodtrackxi=0;
2223       Int_t ntxreco;
2224       Int_t nTRecAboveThresholdPerp=0;
2225       Int_t ntxrecoRecalc;
2226       Int_t nTRecAboveThresholdPerpRecalc=0;
2227
2228       for(Int_t i=0; i<6; i++) // Reset per event
2229         {
2230           fHistContainerR4[i]->Reset();
2231           fHistContainerR3[i]->Reset();
2232           fHistContainerR2[i]->Reset();
2233         }
2234
2235       Double_t jetPtsR[7]={0};  // to store the pt of the jets
2236       Int_t rJetCounter=0;    // counter of accepted reco jets
2237       fIsPossibleToSubstBckg = kTRUE; // Initialize before the loop
2238       if(fJetEvent) // si tiene jets validos
2239         {
2240           if(!HasPerpendicularCone()) // pero no encontro un cono perpendicular libre
2241             fIsPossibleToSubstBckg = kFALSE; // if not perpendicular cone, set to kFALSE, so no perpendicular calculations available
2242         }
2243
2244       AliDebug(4,"Antes de realizar el loop jets reconstruidos \n");
2245       for (Int_t indxrec = 0; indxrec < recojets; indxrec++)
2246         {
2247           AliDebug(4,Form("Number of current jet:%i \n",indxrec));
2248           ntxreco = 0;
2249           ntxrecoRecalc = 0;
2250           fMinTrackPtInNTX=200.0;  //Initialize for each jet, overflown
2251           fMaxTrackPtInNTX=200.0;  //Initialize for each jet, overflown
2252           fMinTrackPtInNTXR=200.0;  //Initialize for each jet, overflown
2253           fMaxTrackPtInNTXR=200.0;  //Initialize for each jet, overflown
2254           deltaPhiPt = 0.0;
2255           deltaEtaPt = 0.0;
2256           deltaPhiSqPt = 0.0;
2257           deltaEtaSqPt = 0.0;
2258           totalTrackPt = 0.0;
2259           firstMomDeltPhi = 0.0;
2260           firstMomDeltEta = 0.0;
2261           secondMomDeltPhi = 0.0;
2262           secondMomDeltEta = 0.0;
2263           secondCentralPhi = 0.0;
2264           secondCentralEta = 0.0;
2265           secondCentralR = 0.0;
2266           fTotTracksInCone=0; // Underflown at initialization per jet
2267
2268           AliAODJet *rjet = dynamic_cast<AliAODJet*>(aodRecJets->At(indxrec));
2269           if (!rjet)
2270             {
2271               AliDebug(2,Form("ERROR: Could not receive jet %d\n", indxrec));
2272               continue;
2273             }
2274           fJetEtaAll->Fill(rjet->Eta());// all jets
2275
2276           ///////////////////////////////////////////////////////////////////////////////
2277           ///// Part for Chritians plot of inclusive and leading jets comp at 2.76 TeV //
2278           if(!IsInsideAcceptance(rjet))  // old condition
2279             continue;
2280           if(indxrec==0) // leading jet
2281             fRecJetPtLeading->Fill(rjet->Pt());
2282           fRecJetPtInclusive->Fill(rjet->Pt()); // all
2283           fJetEtaOnlyTPCcut->Fill(rjet->Eta());// only eta acceptance cut for TPC
2284           ///// End of Christians Plot reco
2285           ///////////////////////////////////////////////////////////////////////////////
2286
2287           if(indxrec>15)
2288             continue;
2289
2290           if(!fJetFlags[indxrec]) // If the jet is flaged kFALSE, not usable
2291             continue;
2292
2293           AliDebug(4,Form("Jet #%i is in the acceptance \n",indxrec));
2294           if(rJetCounter<7)
2295             jetPtsR[rJetCounter]=rjet->Pt();
2296           rJetCounter++;
2297           fJetPt->Fill(rjet->Pt());
2298           fJetEta->Fill(rjet->Eta(),rjet->Eta());
2299           fJetPhi->Fill(rjet->Phi(),rjet->Phi());
2300
2301           if(rjet->Pt()>10.)
2302             fJetEtaJetPt[0]->Fill(rjet->Eta());
2303           if(rjet->Pt()>30.)
2304             fJetEtaJetPt[1]->Fill(rjet->Eta());
2305           if(rjet->Pt()>50.)
2306             fJetEtaJetPt[2]->Fill(rjet->Eta());
2307
2308           // Reco RefTracks check
2309           Bool_t rTrkFlagRec = kFALSE;
2310           Int_t trkinrecjet = rjet->GetRefTracks()->GetEntriesFast();
2311           if(trkinrecjet!=0&&!fForceNotTR)
2312             rTrkFlagRec = kTRUE;
2313           AliDebug(4,Form("Number of tracks in RefTracks reco jet:%i \n",trkinrecjet));
2314           if(rTrkFlagRec)
2315             {
2316               // Check the properties of the tracks in this jet with track refs
2317               AliDebug(4,Form("Checking composition in Reco jets with track refs"));
2318               for(Int_t aodT = 0; aodT <trkinrecjet; aodT++ )
2319                 {
2320                   aodtrackxi=0;
2321                   AliAODTrack *aodtrack = dynamic_cast<AliAODTrack*>(rjet->GetRefTracks()->At(aodT));
2322                   if(!aodtrack)
2323                     {
2324                       AliError("Error, no AOD Track!");
2325                       continue;
2326                     }
2327                   if(!aodtrack->TestFilterBit(fFilterBit))
2328                     {
2329                       //                      printf("Rejecting track from track refs due to wrong filterbit! \n");
2330                       continue; //track filter selection
2331                     }
2332                   if(!aodtrack->IsPrimaryCandidate())
2333                     {
2334                       //                      printf("Rejecting track from track refs due to no primary candidate! \n");
2335                       continue; // only primaries
2336                     }
2337                   deltaPhiPt += DeltaPhiTrack(rjet, aodtrack)*aodtrack->Pt();
2338                   deltaEtaPt += DeltaEtaTrack(rjet, aodtrack)*aodtrack->Pt();
2339                   deltaPhiSqPt += DeltaPhiSqTrack(rjet, aodtrack)*aodtrack->Pt();
2340                   deltaEtaSqPt += DeltaEtaSqTrack(rjet, aodtrack)*aodtrack->Pt();
2341                   totalTrackPt += aodtrack->Pt();
2342                   fTotTracksInCone++; // Counting tracks
2343                   if(!IsEqualRel(aodtrack->Pt(), 0.0)) //!IsEqualRel(totalTrackPtPerp, 0.0) //aodtrack->Pt()!=0
2344                     aodtrackxi= log(rjet->Pt()/aodtrack->Pt());
2345                   if(irecj<maxJetNum)
2346                     {
2347                       fHistContainerR4[irecj]->Fill(aodtrackxi,rjet->Pt());
2348                       if(!IsTrackInsideThisJet(aodtrack, rjet, 0.3)) continue;
2349                       fHistContainerR3[irecj]->Fill(aodtrackxi,rjet->Pt());
2350                       if(!IsTrackInsideThisJet(aodtrack, rjet, 0.2)) continue;
2351                       fHistContainerR2[irecj]->Fill(aodtrackxi,rjet->Pt());
2352                     }
2353                 } //end loop over track references
2354               if(!IsEqualRel(totalTrackPt, 0.0)) //!IsEqualRel(totalTrackPt, 0.0)  // totalTrackPt!=0.0
2355                 {
2356                   firstMomDeltPhi = deltaPhiPt/totalTrackPt;
2357                   firstMomDeltEta = deltaEtaPt/totalTrackPt;
2358                   secondMomDeltPhi = deltaPhiSqPt/totalTrackPt;
2359                   secondMomDeltEta = deltaEtaSqPt/totalTrackPt;
2360                   secondCentralPhi = secondMomDeltPhi - firstMomDeltPhi*firstMomDeltPhi;
2361                   secondCentralEta = secondMomDeltEta - firstMomDeltEta*firstMomDeltEta;
2362                   secondCentralR = secondCentralPhi + secondCentralEta;
2363                 } // end if totalTrackPt!=0.0
2364               if(IsEqualRel(totalTrackPt, 0.0)) //!IsEqualRel(totalTrackPt, 0.0) // totalTrackPt==0.0
2365                 secondCentralR = 10.0; //overflow value
2366             } // end if there are track references
2367
2368           if(!rTrkFlagRec)
2369             {
2370               // Check properties of the tracks in this jet without track refs
2371               AliDebug(4,Form("Checking composition in Reco jets without track refs"));
2372               for(Int_t aodT = 0; aodT < tracksAOD; aodT++ )
2373                 {
2374                   AliAODTrack *aodtrack = fAOD->GetTrack(aodT);
2375                   if(!aodtrack) continue;
2376                   if(!IsTrackInsideThisJet(aodtrack, rjet, jfr)) continue;
2377                   if(!aodtrack->TestFilterBit(fFilterBit)) continue; //track filter selection
2378                   if(!aodtrack->IsPrimaryCandidate()) continue; // only primaries, perhaps redundant with the previous
2379                   if(aodtrack->Pt()<fMinpTVal) continue; //DATA: PT CUT
2380                   deltaPhiPt += DeltaPhiTrack(rjet, aodtrack)*aodtrack->Pt();
2381                   deltaEtaPt += DeltaEtaTrack(rjet, aodtrack)*aodtrack->Pt();
2382                   deltaPhiSqPt += DeltaPhiSqTrack(rjet, aodtrack)*aodtrack->Pt();
2383                   deltaEtaSqPt += DeltaEtaSqTrack(rjet, aodtrack)*aodtrack->Pt();
2384                   totalTrackPt += aodtrack->Pt();
2385                   fTotTracksInCone++; // Counting tracks
2386                   if(!IsEqualRel(aodtrack->Pt(), 0.0)) //!IsEqualRel(totalTrackPt, 0.0) //aodtrack->Pt()!=0
2387                     aodtrackxi= log(rjet->Pt()/aodtrack->Pt());
2388                   if(irecj<maxJetNum)
2389                     {
2390                       fHistContainerR4[irecj]->Fill(aodtrackxi,rjet->Pt());
2391                       if(!IsTrackInsideThisJet(aodtrack, rjet, 0.3)) continue;
2392                       fHistContainerR3[irecj]->Fill(aodtrackxi,rjet->Pt());
2393                       if(!IsTrackInsideThisJet(aodtrack, rjet, 0.2)) continue;
2394                       fHistContainerR2[irecj]->Fill(aodtrackxi,rjet->Pt());
2395                     }
2396                 } // end loop over tracks
2397               if(!IsEqualRel(totalTrackPt, 0.0)) //!IsEqualRel(totalTrackPt, 0.0) //totalTrackPt!=0.0
2398                 {
2399                   firstMomDeltPhi = deltaPhiPt/totalTrackPt;
2400                   firstMomDeltEta = deltaEtaPt/totalTrackPt;
2401                   secondMomDeltPhi = deltaPhiSqPt/totalTrackPt;
2402                   secondMomDeltEta = deltaEtaSqPt/totalTrackPt;
2403                   secondCentralPhi = secondMomDeltPhi - firstMomDeltPhi*firstMomDeltPhi;
2404                   secondCentralEta = secondMomDeltEta - firstMomDeltEta*firstMomDeltEta;
2405                   secondCentralR = secondCentralPhi + secondCentralEta;
2406                 } // end if totalTrackPt!=0.0
2407               if(IsEqualRel(totalTrackPt, 0.0)) //!IsEqualRel(totalTrackPt, 0.0) // totalTrackPt==0.0
2408                 secondCentralR = 10.0; //overflow value
2409             } // end of no track references
2410           //Esto es lo anterior, toma al jet como es, y calcula NT90
2411           ntxreco=GetNumberOfChargedTracks(ntx,rjet, tracksAOD, fAOD, jfr); // this call fixes the minimum pT track
2412           //Y aqui calcula cuantos tracks se necesitan arriba del threshold establecido en la linea anterior
2413           //esto debe ser para cada jet. Lo unico que se calcula una sola vez es el cono perpendicular
2414           if(fIsPossibleToSubstBckg&&!IsEqualRel(fCurrentJetMinPtNT90, 7000.)) //and only if the method worked
2415             nTRecAboveThresholdPerp = GetNRecChargedTracksAboveThreshold(fPerpCone,tracksAOD, fAOD,jfr); //here one changes NTX
2416
2417           // correct the jet pT
2418           if(fIsPossibleToSubstBckg) // If there is a perpendicular cone available, substract backg and fill the new jet pT
2419             {
2420               pTbs= rjet->Pt()-fPerpCone->Pt();
2421               etabs= rjet->Eta();
2422               phibs= rjet->Phi();
2423               fBckgSbsJet[0]=pTbs; //pT
2424               fBckgSbsJet[1]=etabs; //eta
2425               fBckgSbsJet[2]=phibs; //phi
2426               // Now re-calculate nt90 for the energy corrected jet
2427               ntxrecoRecalc = GetRecalcNTXRec(ntx,rjet, tracksAOD, fAOD, jfr); //This call saves the new min pT
2428               // Now re-calculate the perpendicular cone NT90 background
2429               if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.)) //calculating for the current jet, if the previous method worked
2430                 nTRecAboveThresholdPerpRecalc = GetRecalcNRecChTrUpThr(fPerpCone,tracksAOD, fAOD,jfr);
2431             }
2432
2433           // SCM perpendicular cone
2434           if(fIsPossibleToSubstBckg)
2435             {
2436               // To make sure, re-initialize
2437               deltaPhiPtPerp = 0.0;
2438               deltaEtaPtPerp = 0.0;
2439               deltaPhiSqPtPerp = 0.0;
2440               deltaEtaSqPtPerp = 0.0;
2441               totalTrackPtPerp = 0.0;
2442               firstMomDeltPhiPerp = 0.0;
2443               firstMomDeltEtaPerp = 0.0;
2444               secondMomDeltPhiPerp = 0.0;
2445               secondMomDeltEtaPerp = 0.0;
2446               secondCentralPhiPerp = 0.0;
2447               secondCentralEtaPerp = 0.0;
2448               secondCentralRPerp = 0.0;
2449               AliDebug(4,Form("Checking SCM of perpendicular cone in Reco jets"));
2450               for(Int_t aodTperp = 0; aodTperp < tracksAOD; aodTperp++ )
2451                 { //fPerpCone
2452                   AliAODTrack *aodtrackperprec = fAOD->GetTrack(aodTperp);
2453                   if(!aodtrackperprec) continue;
2454                   if(!IsTrackInsideThisJet(aodtrackperprec, fPerpCone, jfr)) continue;
2455                   if(!aodtrackperprec->TestFilterBit(fFilterBit)) continue; //track filter selection
2456                   if(!aodtrackperprec->IsPrimaryCandidate()) continue; // only primaries, perhaps redundant with the previous
2457                   if(aodtrackperprec->Pt()<fMinpTVal) continue; //DATA: PT CUT
2458                   deltaPhiPtPerp += DeltaPhiTrack(fPerpCone, aodtrackperprec)*aodtrackperprec->Pt();
2459                   deltaEtaPtPerp += DeltaEtaTrack(fPerpCone, aodtrackperprec)*aodtrackperprec->Pt();
2460                   deltaPhiSqPtPerp += DeltaPhiSqTrack(fPerpCone, aodtrackperprec)*aodtrackperprec->Pt();
2461                   deltaEtaSqPtPerp += DeltaEtaSqTrack(fPerpCone, aodtrackperprec)*aodtrackperprec->Pt();
2462                   totalTrackPtPerp += aodtrackperprec->Pt();
2463                 } // end loop over tracks
2464               if(!IsEqualRel(totalTrackPtPerp, 0.0)) //!IsEqualRel(totalTrackPt, 0.0) // totalTrackPtPerp!=0.0
2465                 {
2466                   firstMomDeltPhiPerp = deltaPhiPtPerp/totalTrackPtPerp;
2467                   firstMomDeltEtaPerp = deltaEtaPtPerp/totalTrackPtPerp;
2468                   secondMomDeltPhiPerp = deltaPhiSqPtPerp/totalTrackPtPerp;
2469                   secondMomDeltEtaPerp = deltaEtaSqPtPerp/totalTrackPtPerp;
2470                   secondCentralPhiPerp = secondMomDeltPhiPerp - firstMomDeltPhiPerp*firstMomDeltPhiPerp;
2471                   secondCentralEtaPerp = secondMomDeltEtaPerp - firstMomDeltEtaPerp*firstMomDeltEtaPerp;
2472                   secondCentralRPerp = secondCentralPhiPerp + secondCentralEtaPerp;
2473                 } // end if totalTrackPt!=0.0
2474               if(IsEqualRel(totalTrackPtPerp, 0.0)) //!IsEqualRel(totalTrackPt, 0.0) // totalTrackPtPerp==0.0
2475                 secondCentralRPerp = 10.0; //overflow
2476             }
2477
2478           ///// end of adding the SCM for the perpendicular cone
2479
2480           if(irecj<maxJetNum)
2481             {
2482               recJets[irecj]= *rjet;
2483               nrectracks[irecj] = ntxreco;
2484               ptrecjet[irecj] = rjet->Pt();
2485               scmr[irecj] = secondCentralR;
2486               AliDebug(4,Form("Para el jet reco num: %d se necesitaron %d tracks \n",irecj,nrectracks[irecj]));
2487             }
2488           AliDebug(4,"Before filling the histograms for this jet \n");
2489           fNChTrRD->Fill(ntxreco,rjet->Pt());
2490           fSCMRD->Fill(secondCentralR,rjet->Pt());
2491           fProfNChTrRD->Fill(rjet->Pt(),ntxreco);
2492
2493           fNTXV0MultPt->Fill(ntxreco,v0CorrMult,rjet->Pt());
2494           fNTXCBMultPt->Fill(ntxreco,refNJMult,rjet->Pt());
2495
2496           //refNJMult
2497           // reference multiplicity stuff in pp, also filled in PbPb, but does not matter.
2498           // set to: V0 corrected multiplicity: v0CorrMult
2499           if(v0CorrMult<25)
2500             {
2501               fNChTrRDMult[0]->Fill(ntxreco,rjet->Pt());
2502               fSCMRDMult[0]->Fill(secondCentralR,rjet->Pt());
2503               fTotalJetCharge[0]->Fill(fCurrentJetCharge);
2504               if(recojets==1) // if only one jet in the whole event, and inside acceptance
2505                 {
2506                   fNChTrRDMultOJ[0]->Fill(ntxreco,rjet->Pt());
2507                   fSCMRDMultOJ[0]->Fill(secondCentralR,rjet->Pt());
2508                   fJEtaRDMultOJ[0]->Fill(rjet->Eta());
2509                   fJetPtRDMultOJ[0]->Fill(rjet->Pt());
2510                 }
2511             }
2512           if(v0CorrMult>=25&&v0CorrMult<50)
2513             {
2514               fNChTrRDMult[1]->Fill(ntxreco,rjet->Pt());
2515               fSCMRDMult[1]->Fill(secondCentralR,rjet->Pt());
2516               fTotalJetCharge[1]->Fill(fCurrentJetCharge);
2517               if(recojets==1) // if only one jet in the whole event, and inside acceptance
2518                 {
2519                   fNChTrRDMultOJ[1]->Fill(ntxreco,rjet->Pt());
2520                   fSCMRDMultOJ[1]->Fill(secondCentralR,rjet->Pt());
2521                   fJEtaRDMultOJ[1]->Fill(rjet->Eta());
2522                   fJetPtRDMultOJ[1]->Fill(rjet->Pt());
2523                 }
2524             }
2525           if(v0CorrMult>=50&&v0CorrMult<90)
2526             {
2527               fNChTrRDMult[2]->Fill(ntxreco,rjet->Pt());
2528               fSCMRDMult[2]->Fill(secondCentralR,rjet->Pt());
2529               fTotalJetCharge[2]->Fill(fCurrentJetCharge);
2530               if(recojets==1) // if only one jet in the whole event, and inside acceptance
2531                 {
2532                   fNChTrRDMultOJ[2]->Fill(ntxreco,rjet->Pt());
2533                   fSCMRDMultOJ[2]->Fill(secondCentralR,rjet->Pt());
2534                   fJEtaRDMultOJ[2]->Fill(rjet->Eta());
2535                   fJetPtRDMultOJ[2]->Fill(rjet->Pt());
2536                 }
2537             }
2538           if(v0CorrMult>=90&&v0CorrMult<120)
2539             {
2540               fNChTrRDMult[3]->Fill(ntxreco,rjet->Pt());
2541               fSCMRDMult[3]->Fill(secondCentralR,rjet->Pt());
2542               fTotalJetCharge[3]->Fill(fCurrentJetCharge);
2543               if(recojets==1) // if only one jet in the whole event, and inside acceptance
2544                 {
2545                   fNChTrRDMultOJ[3]->Fill(ntxreco,rjet->Pt());
2546                   fSCMRDMultOJ[3]->Fill(secondCentralR,rjet->Pt());
2547                   fJEtaRDMultOJ[3]->Fill(rjet->Eta());
2548                   fJetPtRDMultOJ[3]->Fill(rjet->Pt());
2549                 }
2550             }
2551           if(v0CorrMult>=120&&v0CorrMult<150)
2552             {
2553               fNChTrRDMult[4]->Fill(ntxreco,rjet->Pt());
2554               fSCMRDMult[4]->Fill(secondCentralR,rjet->Pt());
2555               fTotalJetCharge[4]->Fill(fCurrentJetCharge);
2556               if(recojets==1) // if only one jet in the whole event, and inside acceptance
2557                 {
2558                   fNChTrRDMultOJ[4]->Fill(ntxreco,rjet->Pt());
2559                   fSCMRDMultOJ[4]->Fill(secondCentralR,rjet->Pt());
2560                   fJEtaRDMultOJ[4]->Fill(rjet->Eta());
2561                   fJetPtRDMultOJ[4]->Fill(rjet->Pt());
2562                 }
2563             }
2564           if(v0CorrMult>=150&&v0CorrMult<200)
2565             {
2566               fNChTrRDMult[5]->Fill(ntxreco,rjet->Pt());
2567               fSCMRDMult[5]->Fill(secondCentralR,rjet->Pt());
2568               fTotalJetCharge[5]->Fill(fCurrentJetCharge);
2569               if(recojets==1) // if only one jet in the whole event, and inside acceptance
2570                 {
2571                   fNChTrRDMultOJ[5]->Fill(ntxreco,rjet->Pt());
2572                   fSCMRDMultOJ[5]->Fill(secondCentralR,rjet->Pt());
2573                   fJEtaRDMultOJ[5]->Fill(rjet->Eta());
2574                   fJetPtRDMultOJ[5]->Fill(rjet->Pt());
2575                 }
2576             }
2577           if(v0CorrMult>=200&&v0CorrMult<300)
2578             {
2579               fNChTrRDMult[6]->Fill(ntxreco,rjet->Pt());
2580               fSCMRDMult[6]->Fill(secondCentralR,rjet->Pt());
2581               fTotalJetCharge[6]->Fill(fCurrentJetCharge);
2582               if(recojets==1) // if only one jet in the whole event, and inside acceptance
2583                 {
2584                   fNChTrRDMultOJ[6]->Fill(ntxreco,rjet->Pt());
2585                   fSCMRDMultOJ[6]->Fill(secondCentralR,rjet->Pt());
2586                   fJEtaRDMultOJ[6]->Fill(rjet->Eta());
2587                   fJetPtRDMultOJ[6]->Fill(rjet->Pt());
2588                 }
2589             }
2590           if(v0CorrMult>=300)
2591             {
2592               fNChTrRDMult[7]->Fill(ntxreco,rjet->Pt());
2593               fSCMRDMult[7]->Fill(secondCentralR,rjet->Pt());
2594               fTotalJetCharge[7]->Fill(fCurrentJetCharge);
2595               if(recojets==1) // if only one jet in the whole event, and inside acceptance
2596                 {
2597                   fNChTrRDMultOJ[7]->Fill(ntxreco,rjet->Pt());
2598                   fSCMRDMultOJ[7]->Fill(secondCentralR,rjet->Pt());
2599                   fJEtaRDMultOJ[7]->Fill(rjet->Eta());
2600                   fJetPtRDMultOJ[7]->Fill(rjet->Pt());
2601                 }
2602             }
2603
2604           // 2nd. Reference: set to: TPC tracks minus jet, minus dijet area
2605           if(refNJMult<5) //&&refNJMult>1
2606             {
2607               fNChTrRDMultSE[0]->Fill(ntxreco,rjet->Pt());
2608               fSCMRDMultSE[0]->Fill(secondCentralR,rjet->Pt());
2609               fTotalJetChargeSE[0]->Fill(fCurrentJetCharge);
2610               if(recojets==1) // if only one jet in the whole event, and inside acceptance
2611                 {
2612                   fNChTrRDMultSEOJ[0]->Fill(ntxreco,rjet->Pt());
2613                   fSCMRDMultSEOJ[0]->Fill(secondCentralR,rjet->Pt());
2614                   fJEtaRDMultSEOJ[0]->Fill(rjet->Eta());
2615                   fJetPtRDMultSEOJ[0]->Fill(rjet->Pt());
2616                   if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
2617                     fNChTrRecPerpMultSEOJ[0]->Fill(nTRecAboveThresholdPerp,rjet->Pt());
2618                   if(fIsPossibleToSubstBckg) // if it was possible to calculate a perpendicular cone
2619                     {
2620                       fNChTrRecECorrPPMult->Fill(ntxrecoRecalc,pTbs,1); //filling mult bin
2621                       fNChTrRecPerpECorrPPMult->Fill(nTRecAboveThresholdPerpRecalc,pTbs,1); //filling mult bin
2622                     }
2623                 }
2624             }
2625           if(refNJMult>=5&&refNJMult<10)
2626             {
2627               fNChTrRDMultSE[1]->Fill(ntxreco,rjet->Pt());
2628               fSCMRDMultSE[1]->Fill(secondCentralR,rjet->Pt());
2629               fTotalJetChargeSE[1]->Fill(fCurrentJetCharge);
2630               if(recojets==1) // if only one jet in the whole event, and inside acceptance
2631                 {
2632                   fNChTrRDMultSEOJ[1]->Fill(ntxreco,rjet->Pt());
2633                   fSCMRDMultSEOJ[1]->Fill(secondCentralR,rjet->Pt());
2634                   fJEtaRDMultSEOJ[1]->Fill(rjet->Eta());
2635                   fJetPtRDMultSEOJ[1]->Fill(rjet->Pt());
2636                   if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
2637                     fNChTrRecPerpMultSEOJ[1]->Fill(nTRecAboveThresholdPerp,rjet->Pt());
2638                   if(fIsPossibleToSubstBckg) // if it was possible to calculate a perpendicular cone
2639                     {
2640                       fNChTrRecECorrPPMult->Fill(ntxrecoRecalc,pTbs,2); //filling mult bin
2641                       fNChTrRecPerpECorrPPMult->Fill(nTRecAboveThresholdPerpRecalc,pTbs,2); //filling mult bin
2642                     }
2643                 }
2644             }
2645           if(refNJMult>=10&&refNJMult<15)
2646             {
2647               fNChTrRDMultSE[2]->Fill(ntxreco,rjet->Pt());
2648               fSCMRDMultSE[2]->Fill(secondCentralR,rjet->Pt());
2649               fTotalJetChargeSE[2]->Fill(fCurrentJetCharge);
2650               if(recojets==1) // if only one jet in the whole event, and inside acceptance
2651                 {
2652                   fNChTrRDMultSEOJ[2]->Fill(ntxreco,rjet->Pt());
2653                   fSCMRDMultSEOJ[2]->Fill(secondCentralR,rjet->Pt());
2654                   fJEtaRDMultSEOJ[2]->Fill(rjet->Eta());
2655                   fJetPtRDMultSEOJ[2]->Fill(rjet->Pt());
2656                   if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
2657                     fNChTrRecPerpMultSEOJ[2]->Fill(nTRecAboveThresholdPerp,rjet->Pt());
2658                   if(fIsPossibleToSubstBckg) // if it was possible to calculate a perpendicular cone
2659                     {
2660                       fNChTrRecECorrPPMult->Fill(ntxrecoRecalc,pTbs,3); //filling mult bin
2661                       fNChTrRecPerpECorrPPMult->Fill(nTRecAboveThresholdPerpRecalc,pTbs,3); //filling mult bin
2662                     }
2663                 }
2664             }
2665           if(refNJMult>=15&&refNJMult<20)
2666             {
2667               fNChTrRDMultSE[3]->Fill(ntxreco,rjet->Pt());
2668               fSCMRDMultSE[3]->Fill(secondCentralR,rjet->Pt());
2669               fTotalJetChargeSE[3]->Fill(fCurrentJetCharge);
2670               if(recojets==1) // if only one jet in the whole event, and inside acceptance
2671                 {
2672                   fNChTrRDMultSEOJ[3]->Fill(ntxreco,rjet->Pt());
2673                   fSCMRDMultSEOJ[3]->Fill(secondCentralR,rjet->Pt());
2674                   fJEtaRDMultSEOJ[3]->Fill(rjet->Eta());
2675                   fJetPtRDMultSEOJ[3]->Fill(rjet->Pt());
2676                   if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
2677                     fNChTrRecPerpMultSEOJ[3]->Fill(nTRecAboveThresholdPerp,rjet->Pt());
2678                   if(fIsPossibleToSubstBckg) // if it was possible to calculate a perpendicular cone
2679                     {
2680                       fNChTrRecECorrPPMult->Fill(ntxrecoRecalc,pTbs,4); //filling mult bin
2681                       fNChTrRecPerpECorrPPMult->Fill(nTRecAboveThresholdPerpRecalc,pTbs,4); //filling mult bin
2682                     }
2683                 }
2684             }
2685           if(refNJMult>=20&&refNJMult<30)
2686             {
2687               fNChTrRDMultSE[4]->Fill(ntxreco,rjet->Pt());
2688               fSCMRDMultSE[4]->Fill(secondCentralR,rjet->Pt());
2689               fTotalJetChargeSE[4]->Fill(fCurrentJetCharge);
2690               if(recojets==1) // if only one jet in the whole event, and inside acceptance
2691                 {
2692                   fNChTrRDMultSEOJ[4]->Fill(ntxreco,rjet->Pt());
2693                   fSCMRDMultSEOJ[4]->Fill(secondCentralR,rjet->Pt());
2694                   fJEtaRDMultSEOJ[4]->Fill(rjet->Eta());
2695                   fJetPtRDMultSEOJ[4]->Fill(rjet->Pt());
2696                   if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
2697                     fNChTrRecPerpMultSEOJ[4]->Fill(nTRecAboveThresholdPerp,rjet->Pt());
2698                   if(fIsPossibleToSubstBckg) // if it was possible to calculate a perpendicular cone
2699                     {
2700                       fNChTrRecECorrPPMult->Fill(ntxrecoRecalc,pTbs,5); //filling mult bin
2701                       fNChTrRecPerpECorrPPMult->Fill(nTRecAboveThresholdPerpRecalc,pTbs,5); //filling mult bin
2702                     }
2703                 }
2704             }
2705           if(refNJMult>=30&&refNJMult<40)
2706             {
2707               fNChTrRDMultSE[5]->Fill(ntxreco,rjet->Pt());
2708               fSCMRDMultSE[5]->Fill(secondCentralR,rjet->Pt());
2709               fTotalJetChargeSE[5]->Fill(fCurrentJetCharge);
2710               if(recojets==1) // if only one jet in the whole event, and inside acceptance
2711                 {
2712                   fNChTrRDMultSEOJ[5]->Fill(ntxreco,rjet->Pt());
2713                   fSCMRDMultSEOJ[5]->Fill(secondCentralR,rjet->Pt());
2714                   fJEtaRDMultSEOJ[5]->Fill(rjet->Eta());
2715                   fJetPtRDMultSEOJ[5]->Fill(rjet->Pt());
2716                   if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
2717                     fNChTrRecPerpMultSEOJ[5]->Fill(nTRecAboveThresholdPerp,rjet->Pt());
2718                   if(fIsPossibleToSubstBckg) // if it was possible to calculate a perpendicular cone
2719                     {
2720                       fNChTrRecECorrPPMult->Fill(ntxrecoRecalc,pTbs,6); //filling mult bin
2721                       fNChTrRecPerpECorrPPMult->Fill(nTRecAboveThresholdPerpRecalc,pTbs,6); //filling mult bin
2722                     }
2723                 }
2724             }
2725           if(refNJMult>=40&&refNJMult<50)
2726             {
2727               fNChTrRDMultSE[6]->Fill(ntxreco,rjet->Pt());
2728               fSCMRDMultSE[6]->Fill(secondCentralR,rjet->Pt());
2729               fTotalJetChargeSE[6]->Fill(fCurrentJetCharge);
2730               if(recojets==1) // if only one jet in the whole event, and inside acceptance
2731                 {
2732                   fNChTrRDMultSEOJ[6]->Fill(ntxreco,rjet->Pt());
2733                   fSCMRDMultSEOJ[6]->Fill(secondCentralR,rjet->Pt());
2734                   fJEtaRDMultSEOJ[6]->Fill(rjet->Eta());
2735                   fJetPtRDMultSEOJ[6]->Fill(rjet->Pt());
2736                   if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
2737                     fNChTrRecPerpMultSEOJ[6]->Fill(nTRecAboveThresholdPerp,rjet->Pt());
2738                   if(fIsPossibleToSubstBckg) // if it was possible to calculate a perpendicular cone
2739                     {
2740                       fNChTrRecECorrPPMult->Fill(ntxrecoRecalc,pTbs,7); //filling mult bin
2741                       fNChTrRecPerpECorrPPMult->Fill(nTRecAboveThresholdPerpRecalc,pTbs,7); //filling mult bin
2742                     }
2743                 }
2744             }
2745           if(refNJMult>=50)
2746             {
2747               fNChTrRDMultSE[7]->Fill(ntxreco,rjet->Pt());
2748               fSCMRDMultSE[7]->Fill(secondCentralR,rjet->Pt());
2749               fTotalJetChargeSE[7]->Fill(fCurrentJetCharge);
2750               if(recojets==1) // if only one jet in the whole event, and inside acceptance
2751                 {
2752                   fNChTrRDMultSEOJ[7]->Fill(ntxreco,rjet->Pt());
2753                   fSCMRDMultSEOJ[7]->Fill(secondCentralR,rjet->Pt());
2754                   fJEtaRDMultSEOJ[7]->Fill(rjet->Eta());
2755                   fJetPtRDMultSEOJ[7]->Fill(rjet->Pt());
2756                   if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
2757                     fNChTrRecPerpMultSEOJ[7]->Fill(nTRecAboveThresholdPerp,rjet->Pt());
2758                   if(fIsPossibleToSubstBckg) // if it was possible to calculate a perpendicular cone
2759                     {
2760                       fNChTrRecECorrPPMult->Fill(ntxrecoRecalc,pTbs,8); //filling mult bin
2761                       fNChTrRecPerpECorrPPMult->Fill(nTRecAboveThresholdPerpRecalc,pTbs,8); //filling mult bin
2762                     }
2763                 }
2764             }
2765
2766           if(fIsPossibleToSubstBckg) // if it was possible to calculate a perpendicular cone
2767             {
2768               if(!IsEqualRel(fCurrentJetMinPtNT90, 7000.))
2769                 fNChTrRecPerp->Fill(nTRecAboveThresholdPerp,rjet->Pt());  // these are my previous histos
2770               fSCMRecPerp->Fill(secondCentralRPerp,rjet->Pt());  // this are my previous histos
2771               if(!fIsHIevent) //if is a proton proton event
2772                 {
2773                   fNChTrRecECorr->Fill(ntxrecoRecalc,pTbs,1); //filling proton bin
2774                   if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
2775                     {
2776                       fNChTrRecPerpECorr->Fill(nTRecAboveThresholdPerpRecalc,pTbs,1); //filling proton bin
2777                       if((rjet->Pt()>10.)&&(rjet->Pt()<20.))
2778                         {
2779                           fPtInPerpCon->Fill(fPerpCone->Pt(),1,1);
2780                           fTotTracksCone->Fill(fTotTracksInCone,1,1);
2781                           FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 1, 1);
2782                         }
2783                       if((rjet->Pt()>20.)&&(rjet->Pt()<30.))
2784                         {
2785                           fPtInPerpCon->Fill(fPerpCone->Pt(),2,1);
2786                           fTotTracksCone->Fill(fTotTracksInCone,2,1);
2787                           FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 1, 2);
2788                         }
2789                       if((rjet->Pt()>30.)&&(rjet->Pt()<40.))
2790                         {
2791                           fPtInPerpCon->Fill(fPerpCone->Pt(),3,1);
2792                           fTotTracksCone->Fill(fTotTracksInCone,3,1);
2793                           FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 1, 3);
2794                         }
2795                       if((rjet->Pt()>40.)&&(rjet->Pt()<50.))
2796                         {
2797                           fPtInPerpCon->Fill(fPerpCone->Pt(),4,1);
2798                           fTotTracksCone->Fill(fTotTracksInCone,4,1);
2799                           FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 1, 4);
2800                         }
2801                       if((rjet->Pt()>50.)&&(rjet->Pt()<60.))
2802                         {
2803                           fPtInPerpCon->Fill(fPerpCone->Pt(),5,1);
2804                           fTotTracksCone->Fill(fTotTracksInCone,5,1);
2805                           FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 1, 5);
2806                         }
2807                       if((rjet->Pt()>60.)&&(rjet->Pt()<70.))
2808                         {
2809                           fPtInPerpCon->Fill(fPerpCone->Pt(),6,1);
2810                           fTotTracksCone->Fill(fTotTracksInCone,6,1);
2811                           FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 1, 6);
2812                         }
2813                       if((rjet->Pt()>70.)&&(rjet->Pt()<80.))
2814                         {
2815                           fPtInPerpCon->Fill(fPerpCone->Pt(),7,1);
2816                           fTotTracksCone->Fill(fTotTracksInCone,7,1);
2817                           FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 1, 7);
2818                         }
2819                       if((rjet->Pt()>80.)&&(rjet->Pt()<90.))
2820                         {
2821                           fPtInPerpCon->Fill(fPerpCone->Pt(),8,1);
2822                           fTotTracksCone->Fill(fTotTracksInCone,8,1);
2823                           FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 1, 8);
2824                         }
2825                     }
2826                 }
2827               if(fIsHIevent) //if is a PbPb event
2828                 {
2829                   if(fEventCent>=0&&fEventCent<10.)
2830                     {
2831                       fNChTrRecECorr->Fill(ntxrecoRecalc,pTbs,2); //filling first centrality bin
2832                       fJetPtCentPbPbRaw->Fill(rjet->Pt(),2);
2833                       fJetPtCentPbPbCorr->Fill(pTbs,2);
2834                       if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
2835                         {
2836                           fNChTrRecPerpECorr->Fill(nTRecAboveThresholdPerpRecalc,pTbs,2); //filling first centrality bin
2837                           fMinTrackPtInNTXRecalc->Fill(fMinTrackPtInNTXR,rjet->Pt(),2);
2838                           fMinTrackPtInNTXh[1]->Fill(fMinTrackPtInNTX,rjet->Pt(),2);
2839                           if((rjet->Pt()>10.)&&(rjet->Pt()<20.))
2840                             {
2841                               fPtInPerpCon->Fill(fPerpCone->Pt(),1,2);
2842                               fTotTracksCone->Fill(fTotTracksInCone,1,2);
2843                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 2, 1);
2844                             }
2845                           if((rjet->Pt()>20.)&&(rjet->Pt()<30.))
2846                             {
2847                               fPtInPerpCon->Fill(fPerpCone->Pt(),2,2);
2848                               fTotTracksCone->Fill(fTotTracksInCone,2,2);
2849                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 2, 2);
2850                             }
2851                           if((rjet->Pt()>30.)&&(rjet->Pt()<40.))
2852                             {
2853                               fPtInPerpCon->Fill(fPerpCone->Pt(),3,2);
2854                               fTotTracksCone->Fill(fTotTracksInCone,3,2);
2855                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 2, 3);
2856                             }
2857                           if((rjet->Pt()>40.)&&(rjet->Pt()<50.))
2858                             {
2859                               fPtInPerpCon->Fill(fPerpCone->Pt(),4,2);
2860                               fTotTracksCone->Fill(fTotTracksInCone,4,2);
2861                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 2, 4);
2862                             }
2863                           if((rjet->Pt()>50.)&&(rjet->Pt()<60.))
2864                             {
2865                               fPtInPerpCon->Fill(fPerpCone->Pt(),5,2);
2866                               fTotTracksCone->Fill(fTotTracksInCone,5,2);
2867                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 2, 5);
2868                             }
2869                           if((rjet->Pt()>60.)&&(rjet->Pt()<70.))
2870                             {
2871                               fPtInPerpCon->Fill(fPerpCone->Pt(),6,2);
2872                               fTotTracksCone->Fill(fTotTracksInCone,6,2);
2873                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 2, 6);
2874                             }
2875                           if((rjet->Pt()>70.)&&(rjet->Pt()<80.))
2876                             {
2877                               fPtInPerpCon->Fill(fPerpCone->Pt(),7,2);
2878                               fTotTracksCone->Fill(fTotTracksInCone,7,2);
2879                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 2, 7);
2880                             }
2881                           if((rjet->Pt()>80.)&&(rjet->Pt()<90.))
2882                             {
2883                               fPtInPerpCon->Fill(fPerpCone->Pt(),8,2);
2884                               fTotTracksCone->Fill(fTotTracksInCone,8,2);
2885                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 2, 8);
2886                             }
2887                         }
2888                     }
2889                   if(fEventCent>=10&&fEventCent<20.)
2890                     {
2891                       fNChTrRecECorr->Fill(ntxrecoRecalc,pTbs,3); //filling second centrality bin
2892                       fJetPtCentPbPbRaw->Fill(rjet->Pt(),3);
2893                       fJetPtCentPbPbCorr->Fill(pTbs,3);
2894                       if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
2895                         {
2896                           fNChTrRecPerpECorr->Fill(nTRecAboveThresholdPerpRecalc,pTbs,3); //filling second centrality bin
2897                           fMinTrackPtInNTXRecalc->Fill(fMinTrackPtInNTXR,rjet->Pt(),3);
2898                           fMinTrackPtInNTXh[1]->Fill(fMinTrackPtInNTX,rjet->Pt(),3);
2899                           if((rjet->Pt()>10.)&&(rjet->Pt()<20.))
2900                             {
2901                               fPtInPerpCon->Fill(fPerpCone->Pt(),1,3);
2902                               fTotTracksCone->Fill(fTotTracksInCone,1,3);
2903                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 3, 1);
2904                             }
2905                           if((rjet->Pt()>20.)&&(rjet->Pt()<30.))
2906                             {
2907                               fPtInPerpCon->Fill(fPerpCone->Pt(),2,3);
2908                               fTotTracksCone->Fill(fTotTracksInCone,2,3);
2909                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 3, 2);
2910                             }
2911                           if((rjet->Pt()>30.)&&(rjet->Pt()<40.))
2912                             {
2913                               fPtInPerpCon->Fill(fPerpCone->Pt(),3,3);
2914                               fTotTracksCone->Fill(fTotTracksInCone,3,3);
2915                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 3, 3);
2916                             }
2917                           if((rjet->Pt()>40.)&&(rjet->Pt()<50.))
2918                             {
2919                               fPtInPerpCon->Fill(fPerpCone->Pt(),4,3);
2920                               fTotTracksCone->Fill(fTotTracksInCone,4,3);
2921                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 3, 4);
2922                             }
2923                           if((rjet->Pt()>50.)&&(rjet->Pt()<60.))
2924                             {
2925                               fPtInPerpCon->Fill(fPerpCone->Pt(),5,3);
2926                               fTotTracksCone->Fill(fTotTracksInCone,5,3);
2927                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 3, 5);
2928                             }
2929                           if((rjet->Pt()>60.)&&(rjet->Pt()<70.))
2930                             {
2931                               fPtInPerpCon->Fill(fPerpCone->Pt(),6,3);
2932                               fTotTracksCone->Fill(fTotTracksInCone,6,3);
2933                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 3, 6);
2934                             }
2935                           if((rjet->Pt()>70.)&&(rjet->Pt()<80.))
2936                             {
2937                               fPtInPerpCon->Fill(fPerpCone->Pt(),7,3);
2938                               fTotTracksCone->Fill(fTotTracksInCone,7,3);
2939                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 3, 7);
2940                             }
2941                           if((rjet->Pt()>80.)&&(rjet->Pt()<90.))
2942                             {
2943                               fPtInPerpCon->Fill(fPerpCone->Pt(),8,3);
2944                               fTotTracksCone->Fill(fTotTracksInCone,8,3);
2945                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 3, 8);
2946                             }
2947                         }
2948                     }
2949                   if(fEventCent>=20&&fEventCent<30.)
2950                     {
2951                       fNChTrRecECorr->Fill(ntxrecoRecalc,pTbs,4); //filling third centrality bin
2952                       fJetPtCentPbPbRaw->Fill(rjet->Pt(),4);
2953                       fJetPtCentPbPbCorr->Fill(pTbs,4);
2954                       if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
2955                         {
2956                           fNChTrRecPerpECorr->Fill(nTRecAboveThresholdPerpRecalc,pTbs,4); //filling third centrality bin
2957                           fMinTrackPtInNTXRecalc->Fill(fMinTrackPtInNTXR,rjet->Pt(),4);
2958                           fMinTrackPtInNTXh[1]->Fill(fMinTrackPtInNTX,rjet->Pt(),4);
2959                           if((rjet->Pt()>10.)&&(rjet->Pt()<20.))
2960                             {
2961                               fPtInPerpCon->Fill(fPerpCone->Pt(),1,4);
2962                               fTotTracksCone->Fill(fTotTracksInCone,1,4);
2963                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 4, 1);
2964                             }
2965                           if((rjet->Pt()>20.)&&(rjet->Pt()<30.))
2966                             {
2967                               fPtInPerpCon->Fill(fPerpCone->Pt(),2,4);
2968                               fTotTracksCone->Fill(fTotTracksInCone,2,4);
2969                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 4, 2);
2970                             }
2971                           if((rjet->Pt()>30.)&&(rjet->Pt()<40.))
2972                             {
2973                               fPtInPerpCon->Fill(fPerpCone->Pt(),3,4);
2974                               fTotTracksCone->Fill(fTotTracksInCone,3,4);
2975                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 4, 3);
2976                             }
2977                           if((rjet->Pt()>40.)&&(rjet->Pt()<50.))
2978                             {
2979                               fPtInPerpCon->Fill(fPerpCone->Pt(),4,4);
2980                               fTotTracksCone->Fill(fTotTracksInCone,4,4);
2981                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 4, 4);
2982                             }
2983                           if((rjet->Pt()>50.)&&(rjet->Pt()<60.))
2984                             {
2985                               fPtInPerpCon->Fill(fPerpCone->Pt(),5,4);
2986                               fTotTracksCone->Fill(fTotTracksInCone,5,4);
2987                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 4, 5);
2988                             }
2989                           if((rjet->Pt()>60.)&&(rjet->Pt()<70.))
2990                             {
2991                               fPtInPerpCon->Fill(fPerpCone->Pt(),6,4);
2992                               fTotTracksCone->Fill(fTotTracksInCone,6,4);
2993                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 4, 6);
2994                             }
2995                           if((rjet->Pt()>70.)&&(rjet->Pt()<80.))
2996                             {
2997                               fPtInPerpCon->Fill(fPerpCone->Pt(),7,4);
2998                               fTotTracksCone->Fill(fTotTracksInCone,7,4);
2999                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 4, 7);
3000                             }
3001                           if((rjet->Pt()>80.)&&(rjet->Pt()<90.))
3002                             {
3003                               fPtInPerpCon->Fill(fPerpCone->Pt(),8,4);
3004                               fTotTracksCone->Fill(fTotTracksInCone,8,4);
3005                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 4, 8);
3006                             }
3007                         }
3008                     }
3009                   if(fEventCent>=30&&fEventCent<40.)
3010                     {
3011                       fNChTrRecECorr->Fill(ntxrecoRecalc,pTbs,5); //filling fourth centrality bin
3012                       fJetPtCentPbPbRaw->Fill(rjet->Pt(),5);
3013                       fJetPtCentPbPbCorr->Fill(pTbs,5);
3014                       if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
3015                         {
3016                           fNChTrRecPerpECorr->Fill(nTRecAboveThresholdPerpRecalc,pTbs,5); //filling fourth centrality bin
3017                           fMinTrackPtInNTXRecalc->Fill(fMinTrackPtInNTXR,rjet->Pt(),5);
3018                           fMinTrackPtInNTXh[1]->Fill(fMinTrackPtInNTX,rjet->Pt(),5);
3019                           if((rjet->Pt()>10.)&&(rjet->Pt()<20.))
3020                             {
3021                               fPtInPerpCon->Fill(fPerpCone->Pt(),1,5);
3022                               fTotTracksCone->Fill(fTotTracksInCone,1,5);
3023                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 5, 1);
3024                             }
3025                           if((rjet->Pt()>20.)&&(rjet->Pt()<30.))
3026                             {
3027                               fPtInPerpCon->Fill(fPerpCone->Pt(),2,5);
3028                               fTotTracksCone->Fill(fTotTracksInCone,2,5);
3029                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 5, 2);
3030                             }
3031                           if((rjet->Pt()>30.)&&(rjet->Pt()<40.))
3032                             {
3033                               fPtInPerpCon->Fill(fPerpCone->Pt(),3,5);
3034                               fTotTracksCone->Fill(fTotTracksInCone,3,5);
3035                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 5, 3);
3036                             }
3037                           if((rjet->Pt()>40.)&&(rjet->Pt()<50.))
3038                             {
3039                               fPtInPerpCon->Fill(fPerpCone->Pt(),4,5);
3040                               fTotTracksCone->Fill(fTotTracksInCone,4,5);
3041                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 5, 4);
3042                             }
3043                           if((rjet->Pt()>50.)&&(rjet->Pt()<60.))
3044                             {
3045                               fPtInPerpCon->Fill(fPerpCone->Pt(),5,5);
3046                               fTotTracksCone->Fill(fTotTracksInCone,5,5);
3047                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 5, 5);
3048                             }
3049                           if((rjet->Pt()>60.)&&(rjet->Pt()<70.))
3050                             {
3051                               fPtInPerpCon->Fill(fPerpCone->Pt(),6,5);
3052                               fTotTracksCone->Fill(fTotTracksInCone,6,5);
3053                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 5, 6);
3054                             }
3055                           if((rjet->Pt()>70.)&&(rjet->Pt()<80.))
3056                             {
3057                               fPtInPerpCon->Fill(fPerpCone->Pt(),7,5);
3058                               fTotTracksCone->Fill(fTotTracksInCone,7,5);
3059                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 5, 7);
3060                             }
3061                           if((rjet->Pt()>80.)&&(rjet->Pt()<90.))
3062                             {
3063                               fPtInPerpCon->Fill(fPerpCone->Pt(),8,5);
3064                               fTotTracksCone->Fill(fTotTracksInCone,8,5);
3065                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 5, 8);
3066                             }
3067                         }
3068                     }
3069                   if(fEventCent>=40&&fEventCent<50.)
3070                     {
3071                       fNChTrRecECorr->Fill(ntxrecoRecalc,pTbs,6); //filling fourth centrality bin
3072                       fJetPtCentPbPbRaw->Fill(rjet->Pt(),6);
3073                       fJetPtCentPbPbCorr->Fill(pTbs,6);
3074                       if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
3075                         {
3076                           fNChTrRecPerpECorr->Fill(nTRecAboveThresholdPerpRecalc,pTbs,6); //filling fourth centrality bin
3077                           fMinTrackPtInNTXRecalc->Fill(fMinTrackPtInNTXR,rjet->Pt(),6);
3078                           fMinTrackPtInNTXh[1]->Fill(fMinTrackPtInNTX,rjet->Pt(),6);
3079                           if((rjet->Pt()>10.)&&(rjet->Pt()<20.))
3080                             {
3081                               fPtInPerpCon->Fill(fPerpCone->Pt(),1,6);
3082                               fTotTracksCone->Fill(fTotTracksInCone,1,6);
3083                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 6, 1);
3084                             }
3085                           if((rjet->Pt()>20.)&&(rjet->Pt()<30.))
3086                             {
3087                               fPtInPerpCon->Fill(fPerpCone->Pt(),2,6);
3088                               fTotTracksCone->Fill(fTotTracksInCone,2,6);
3089                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 6, 2);
3090                             }
3091                           if((rjet->Pt()>30.)&&(rjet->Pt()<40.))
3092                             {
3093                               fPtInPerpCon->Fill(fPerpCone->Pt(),3,6);
3094                               fTotTracksCone->Fill(fTotTracksInCone,3,6);
3095                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 6, 3);
3096                             }
3097                           if((rjet->Pt()>40.)&&(rjet->Pt()<50.))
3098                             {
3099                               fPtInPerpCon->Fill(fPerpCone->Pt(),4,6);
3100                               fTotTracksCone->Fill(fTotTracksInCone,4,6);
3101                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 6, 4);
3102                             }
3103                           if((rjet->Pt()>50.)&&(rjet->Pt()<60.))
3104                             {
3105                               fPtInPerpCon->Fill(fPerpCone->Pt(),5,6);
3106                               fTotTracksCone->Fill(fTotTracksInCone,5,6);
3107                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 6, 5);
3108                             }
3109                           if((rjet->Pt()>60.)&&(rjet->Pt()<70.))
3110                             {
3111                               fPtInPerpCon->Fill(fPerpCone->Pt(),6,6);
3112                               fTotTracksCone->Fill(fTotTracksInCone,6,6);
3113                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 6, 6);
3114                             }
3115                           if((rjet->Pt()>70.)&&(rjet->Pt()<80.))
3116                             {
3117                               fPtInPerpCon->Fill(fPerpCone->Pt(),7,6);
3118                               fTotTracksCone->Fill(fTotTracksInCone,7,6);
3119                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 6, 7);
3120                             }
3121                           if((rjet->Pt()>80.)&&(rjet->Pt()<90.))
3122                             {
3123                               fPtInPerpCon->Fill(fPerpCone->Pt(),8,6);
3124                               fTotTracksCone->Fill(fTotTracksInCone,8,6);
3125                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 6, 8);
3126                             }
3127                         }
3128                     }
3129                   if(fEventCent>=50&&fEventCent<60.)
3130                     {
3131                       fNChTrRecECorr->Fill(ntxrecoRecalc,pTbs,7); //filling fourth centrality bin
3132                       fJetPtCentPbPbRaw->Fill(rjet->Pt(),7);
3133                       fJetPtCentPbPbCorr->Fill(pTbs,7);
3134                       if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
3135                         {
3136                           fNChTrRecPerpECorr->Fill(nTRecAboveThresholdPerpRecalc,pTbs,7); //filling fourth centrality bin
3137                           fMinTrackPtInNTXRecalc->Fill(fMinTrackPtInNTXR,rjet->Pt(),7);
3138                           fMinTrackPtInNTXh[1]->Fill(fMinTrackPtInNTX,rjet->Pt(),7);
3139                           if((rjet->Pt()>10.)&&(rjet->Pt()<20.))
3140                             {
3141                               fPtInPerpCon->Fill(fPerpCone->Pt(),1,7);
3142                               fTotTracksCone->Fill(fTotTracksInCone,1,7);
3143                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 7, 1);
3144                             }
3145                           if((rjet->Pt()>20.)&&(rjet->Pt()<30.))
3146                             {
3147                               fPtInPerpCon->Fill(fPerpCone->Pt(),2,7);
3148                               fTotTracksCone->Fill(fTotTracksInCone,2,7);
3149                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 7, 2);
3150                             }
3151                           if((rjet->Pt()>30.)&&(rjet->Pt()<40.))
3152                             {
3153                               fPtInPerpCon->Fill(fPerpCone->Pt(),3,7);
3154                               fTotTracksCone->Fill(fTotTracksInCone,3,7);
3155                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 7, 3);
3156                             }
3157                           if((rjet->Pt()>40.)&&(rjet->Pt()<50.))
3158                             {
3159                               fPtInPerpCon->Fill(fPerpCone->Pt(),4,7);
3160                               fTotTracksCone->Fill(fTotTracksInCone,4,7);
3161                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 7, 4);
3162                             }
3163                           if((rjet->Pt()>50.)&&(rjet->Pt()<60.))
3164                             {
3165                               fPtInPerpCon->Fill(fPerpCone->Pt(),5,7);
3166                               fTotTracksCone->Fill(fTotTracksInCone,5,7);
3167                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 7, 5);
3168                             }
3169                           if((rjet->Pt()>60.)&&(rjet->Pt()<70.))
3170                             {
3171                               fPtInPerpCon->Fill(fPerpCone->Pt(),6,7);
3172                               fTotTracksCone->Fill(fTotTracksInCone,6,7);
3173                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 7, 6);
3174                             }
3175                           if((rjet->Pt()>70.)&&(rjet->Pt()<80.))
3176                             {
3177                               fPtInPerpCon->Fill(fPerpCone->Pt(),7,7);
3178                               fTotTracksCone->Fill(fTotTracksInCone,7,7);
3179                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 7, 7);
3180                             }
3181                           if((rjet->Pt()>80.)&&(rjet->Pt()<90.))
3182                             {
3183                               fPtInPerpCon->Fill(fPerpCone->Pt(),8,7);
3184                               fTotTracksCone->Fill(fTotTracksInCone,8,7);
3185                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 7, 8);
3186                             }
3187                         }
3188                     }
3189                   if(fEventCent>=60&&fEventCent<70.)
3190                     {
3191                       fNChTrRecECorr->Fill(ntxrecoRecalc,pTbs,8); //filling fourth centrality bin
3192                       fJetPtCentPbPbRaw->Fill(rjet->Pt(),8);
3193                       fJetPtCentPbPbCorr->Fill(pTbs,8);
3194                       if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
3195                         {
3196                           fNChTrRecPerpECorr->Fill(nTRecAboveThresholdPerpRecalc,pTbs,8); //filling fourth centrality bin
3197                           fMinTrackPtInNTXRecalc->Fill(fMinTrackPtInNTXR,rjet->Pt(),8);
3198                           fMinTrackPtInNTXh[1]->Fill(fMinTrackPtInNTX,rjet->Pt(),8);
3199                           if((rjet->Pt()>10.)&&(rjet->Pt()<20.))
3200                             {
3201                               fPtInPerpCon->Fill(fPerpCone->Pt(),1,8);
3202                               fTotTracksCone->Fill(fTotTracksInCone,1,8);
3203                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 8, 1);
3204                             }
3205                           if((rjet->Pt()>20.)&&(rjet->Pt()<30.))
3206                             {
3207                               fPtInPerpCon->Fill(fPerpCone->Pt(),2,8);
3208                               fTotTracksCone->Fill(fTotTracksInCone,2,8);
3209                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 8, 2);
3210                             }
3211                           if((rjet->Pt()>30.)&&(rjet->Pt()<40.))
3212                             {
3213                               fPtInPerpCon->Fill(fPerpCone->Pt(),3,8);
3214                               fTotTracksCone->Fill(fTotTracksInCone,3,8);
3215                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 8, 3);
3216                             }
3217                           if((rjet->Pt()>40.)&&(rjet->Pt()<50.))
3218                             {
3219                               fPtInPerpCon->Fill(fPerpCone->Pt(),4,8);
3220                               fTotTracksCone->Fill(fTotTracksInCone,4,8);
3221                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 8, 4);
3222                             }
3223                           if((rjet->Pt()>50.)&&(rjet->Pt()<60.))
3224                             {
3225                               fPtInPerpCon->Fill(fPerpCone->Pt(),5,8);
3226                               fTotTracksCone->Fill(fTotTracksInCone,5,8);
3227                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 8, 5);
3228                             }
3229                           if((rjet->Pt()>60.)&&(rjet->Pt()<70.))
3230                             {
3231                               fPtInPerpCon->Fill(fPerpCone->Pt(),6,8);
3232                               fTotTracksCone->Fill(fTotTracksInCone,6,8);
3233                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 8, 6);
3234                             }
3235                           if((rjet->Pt()>70.)&&(rjet->Pt()<80.))
3236                             {
3237                               fPtInPerpCon->Fill(fPerpCone->Pt(),7,8);
3238                               fTotTracksCone->Fill(fTotTracksInCone,7,8);
3239                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 8, 7);
3240                             }
3241                           if((rjet->Pt()>80.)&&(rjet->Pt()<90.))
3242                             {
3243                               fPtInPerpCon->Fill(fPerpCone->Pt(),8,8);
3244                               fTotTracksCone->Fill(fTotTracksInCone,8,8);
3245                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 8, 8);
3246                             }
3247                         }
3248                     }
3249                   if(fEventCent>=70&&fEventCent<80.)
3250                     {
3251                       fNChTrRecECorr->Fill(ntxrecoRecalc,pTbs,9); //filling fourth centrality bin
3252                       fJetPtCentPbPbRaw->Fill(rjet->Pt(),9);
3253                       fJetPtCentPbPbCorr->Fill(pTbs,9);
3254                       if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
3255                         {
3256                           fNChTrRecPerpECorr->Fill(nTRecAboveThresholdPerpRecalc,pTbs,9); //filling fourth centrality bin
3257                           fMinTrackPtInNTXRecalc->Fill(fMinTrackPtInNTXR,rjet->Pt(),9);
3258                           fMinTrackPtInNTXh[1]->Fill(fMinTrackPtInNTX,rjet->Pt(),9);
3259                           if((rjet->Pt()>10.)&&(rjet->Pt()<20.))
3260                             {
3261                               fPtInPerpCon->Fill(fPerpCone->Pt(),1,9);
3262                               fTotTracksCone->Fill(fTotTracksInCone,1,9);
3263                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 9, 1);
3264                             }
3265                           if((rjet->Pt()>20.)&&(rjet->Pt()<30.))
3266                             {
3267                               fPtInPerpCon->Fill(fPerpCone->Pt(),2,9);
3268                               fTotTracksCone->Fill(fTotTracksInCone,2,9);
3269                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 9, 2);
3270                             }
3271                           if((rjet->Pt()>30.)&&(rjet->Pt()<40.))
3272                             {
3273                               fPtInPerpCon->Fill(fPerpCone->Pt(),3,9);
3274                               fTotTracksCone->Fill(fTotTracksInCone,3,9);
3275                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 9, 3);
3276                             }
3277                           if((rjet->Pt()>40.)&&(rjet->Pt()<50.))
3278                             {
3279                               fPtInPerpCon->Fill(fPerpCone->Pt(),4,9);
3280                               fTotTracksCone->Fill(fTotTracksInCone,4,9);
3281                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 9, 4);
3282                             }
3283                           if((rjet->Pt()>50.)&&(rjet->Pt()<60.))
3284                             {
3285                               fPtInPerpCon->Fill(fPerpCone->Pt(),5,9);
3286                               fTotTracksCone->Fill(fTotTracksInCone,5,9);
3287                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 9, 5);
3288                             }
3289                           if((rjet->Pt()>60.)&&(rjet->Pt()<70.))
3290                             {
3291                               fPtInPerpCon->Fill(fPerpCone->Pt(),6,9);
3292                               fTotTracksCone->Fill(fTotTracksInCone,6,9);
3293                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 9, 6);
3294                             }
3295                           if((rjet->Pt()>70.)&&(rjet->Pt()<80.))
3296                             {
3297                               fPtInPerpCon->Fill(fPerpCone->Pt(),7,9);
3298                               fTotTracksCone->Fill(fTotTracksInCone,7,9);
3299                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 9, 7);
3300                             }
3301                           if((rjet->Pt()>80.)&&(rjet->Pt()<90.))
3302                             {
3303                               fPtInPerpCon->Fill(fPerpCone->Pt(),8,9);
3304                               fTotTracksCone->Fill(fTotTracksInCone,8,9);
3305                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 9, 8);
3306                             }
3307                         }
3308                     }
3309                   if(fEventCent>=80&&fEventCent<100.)
3310                     {
3311                       fNChTrRecECorr->Fill(ntxrecoRecalc,pTbs,10); //filling sixth centrality bin
3312                       fJetPtCentPbPbRaw->Fill(rjet->Pt(),10);
3313                       fJetPtCentPbPbCorr->Fill(pTbs,10);
3314                       if(!IsEqualRel(fCurrentJetMinPtNT90Recalc, 7000.))
3315                         {
3316                           fNChTrRecPerpECorr->Fill(nTRecAboveThresholdPerpRecalc,pTbs,10); //filling sixth centrality bin
3317                           fMinTrackPtInNTXRecalc->Fill(fMinTrackPtInNTXR,rjet->Pt(),10);
3318                           fMinTrackPtInNTXh[1]->Fill(fMinTrackPtInNTX,rjet->Pt(),10);
3319                           if((rjet->Pt()>10.)&&(rjet->Pt()<20.))
3320                             {
3321                               fPtInPerpCon->Fill(fPerpCone->Pt(),1,10);
3322                               fTotTracksCone->Fill(fTotTracksInCone,1,10);
3323                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 10, 1);
3324                             }
3325                           if((rjet->Pt()>20.)&&(rjet->Pt()<30.))
3326                             {
3327                               fPtInPerpCon->Fill(fPerpCone->Pt(),2,10);
3328                               fTotTracksCone->Fill(fTotTracksInCone,2,10);
3329                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 10, 2);
3330                             }
3331                           if((rjet->Pt()>30.)&&(rjet->Pt()<40.))
3332                             {
3333                               fPtInPerpCon->Fill(fPerpCone->Pt(),3,10);
3334                               fTotTracksCone->Fill(fTotTracksInCone,3,10);
3335                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 10, 3);
3336                             }
3337                           if((rjet->Pt()>40.)&&(rjet->Pt()<50.))
3338                             {
3339                               fPtInPerpCon->Fill(fPerpCone->Pt(),4,10);
3340                               fTotTracksCone->Fill(fTotTracksInCone,4,10);
3341                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 10, 4);
3342                             }
3343                           if((rjet->Pt()>50.)&&(rjet->Pt()<60.))
3344                             {
3345                               fPtInPerpCon->Fill(fPerpCone->Pt(),5,10);
3346                               fTotTracksCone->Fill(fTotTracksInCone,5,10);
3347                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 10, 5);
3348                             }
3349                           if((rjet->Pt()>60.)&&(rjet->Pt()<70.))
3350                             {
3351                               fPtInPerpCon->Fill(fPerpCone->Pt(),6,10);
3352                               fTotTracksCone->Fill(fTotTracksInCone,6,10);
3353                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 10, 6);
3354                             }
3355                           if((rjet->Pt()>70.)&&(rjet->Pt()<80.))
3356                             {
3357                               fPtInPerpCon->Fill(fPerpCone->Pt(),7,10);
3358                               fTotTracksCone->Fill(fTotTracksInCone,7,10);
3359                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 10, 7);
3360                             }
3361                           if((rjet->Pt()>80.)&&(rjet->Pt()<90.))
3362                             {
3363                               fPtInPerpCon->Fill(fPerpCone->Pt(),8,10);
3364                               fTotTracksCone->Fill(fTotTracksInCone,8,10);
3365                               FillPerpConeHisto(fPtDistInPerpConeRaw, tracksAOD, fAOD, 10, 8);
3366                             }
3367                         }
3368                     }
3369                 }
3370             }
3371
3372           AliDebug(4,"Before filling the histograms for this jet of min and max pT in NTX \n");
3373           AliDebug(4,Form("Min:%f, Max:%f \n",fMinTrackPtInNTX,fMaxTrackPtInNTX));
3374           fMinTrackPtInNTXh[1]->Fill(fMinTrackPtInNTX,rjet->Pt(),1); // for rec pp or inclusive PbPb
3375           fJetPtCentPbPbRaw->Fill(rjet->Pt(),1); // for rec pp or inclusive PbPb
3376           fJetPtCentPbPbCorr->Fill(pTbs,1); // for rec pp or inclusive PbPb
3377           fMaxTrackPtInNTXh[1]->Fill(fMaxTrackPtInNTX,rjet->Pt());
3378           if(fIsPossibleToSubstBckg) // if it was possible to calculate a perpendicular cone
3379             {
3380               fMinTrackPtInNTXRecalc->Fill(fMinTrackPtInNTXR,rjet->Pt(),1); // for rec pp or inclusive PbPb
3381               fMaxTrackPtInNTXRecalc->Fill(fMaxTrackPtInNTXR,rjet->Pt());
3382             }
3383           AliDebug(4,"After filling the histograms for this jet of min and max pT in NTX \n");
3384           for(Int_t v=0 ; v<rJetCounter; v++)
3385             {
3386               if(v<7)
3387                 fJetsMultPtRD->Fill(jetPtsR[v],rJetCounter);
3388             }
3389           irecj++;
3390         } //reco jets
3391       nRecJets=irecj;
3392       fNAccJetsRD->Fill(rJetCounter,rJetCounter);
3393       // reference multiplicity stuff in pp, also filled in PbPb, but does not matter.
3394       if(v0CorrMult<25)
3395         fNAccJetsRDMult[0]->Fill(rJetCounter);
3396       if(v0CorrMult>=25&&v0CorrMult<50)
3397         fNAccJetsRDMult[1]->Fill(rJetCounter);
3398       if(v0CorrMult>=50&&v0CorrMult<90)
3399         fNAccJetsRDMult[2]->Fill(rJetCounter);
3400       if(v0CorrMult>=90&&v0CorrMult<120)
3401         fNAccJetsRDMult[3]->Fill(rJetCounter);
3402       if(v0CorrMult>=120&&v0CorrMult<150)
3403         fNAccJetsRDMult[4]->Fill(rJetCounter);
3404       if(v0CorrMult>=150&&v0CorrMult<200)
3405         fNAccJetsRDMult[5]->Fill(rJetCounter);
3406       if(v0CorrMult>=200&&v0CorrMult<300)
3407         fNAccJetsRDMult[6]->Fill(rJetCounter);
3408       if(v0CorrMult>=300)
3409         fNAccJetsRDMult[7]->Fill(rJetCounter);
3410
3411       // reference multiplicity from tracks in TPC minus jet related tracks
3412       if(refNJMult<5) // &&refNJMult>1
3413         fNAccJetsRDMultSE[0]->Fill(rJetCounter);
3414       if(refNJMult>=5&&refNJMult<10)
3415         fNAccJetsRDMultSE[1]->Fill(rJetCounter);
3416       if(refNJMult>=10&&refNJMult<15)
3417         fNAccJetsRDMultSE[2]->Fill(rJetCounter);
3418       if(refNJMult>=15&&refNJMult<20)
3419         fNAccJetsRDMultSE[3]->Fill(rJetCounter);
3420       if(refNJMult>=20&&refNJMult<30)
3421         fNAccJetsRDMultSE[4]->Fill(rJetCounter);
3422       if(refNJMult>=30&&refNJMult<40)
3423         fNAccJetsRDMultSE[5]->Fill(rJetCounter);
3424       if(refNJMult>=40&&refNJMult<50)
3425         fNAccJetsRDMultSE[6]->Fill(rJetCounter);
3426       if(refNJMult>=50)
3427         fNAccJetsRDMultSE[7]->Fill(rJetCounter);
3428
3429       AliDebug(4,"Checking if this data contains MC, in order to relate the jets \n");
3430       if(fUseAODMC)
3431         {
3432           AliDebug(4,"Relating MC jets with reconstructed jets");
3433           // Relate the jets
3434           Int_t fCJDebug = 0; //debug level for getclosest jet
3435           nGenJets = TMath::Min(nGenJets,maxJetNum);
3436           nRecJets = TMath::Min(nRecJets,maxJetNum);
3437           Int_t iGenIndex[maxJetNum];    // Index of the generated jet for i-th rec -1 if none
3438           Int_t iRecIndex[maxJetNum];    // Index of the reco jet for i-th gen -1 if none
3439           for(int i = 0;i<maxJetNum;++i)
3440             {
3441               iGenIndex[i] = iRecIndex[i] = -1;
3442             }
3443
3444           AliAnalysisHelperJetTasks::GetClosestJets(genJets,nGenJets,recJets,nRecJets,
3445                                                     iGenIndex,iRecIndex,fCJDebug);
3446           if(fCJDebug > 10)
3447             AliDebug(4,Form("%s:%d",(char*)__FILE__,__LINE__));
3448           if(fCJDebug > 3)
3449             {
3450               for(int i = 0;i<maxJetNum;++i)
3451                 {
3452                   if(iGenIndex[i]>=0)
3453                     {
3454                       AliDebug(4,Form("iGenFound: %d -> %d",i,iGenIndex[i]));
3455                       //  para el i-esimo jet reconstruido corresponde el jet iGenIndex[i]
3456                       AliDebug(4,Form("El jet reconstruido numero %d tiene sabor %d",i, genJetsFlavor[iGenIndex[i]]));
3457                     }
3458                   if(iRecIndex[i]>=0)
3459                     {
3460                       AliDebug(4,Form("iRecFound: %d -> %d",i,iRecIndex[i]));
3461                       //  para el i-esimo jet generado corresponde el jet iRecIndex[i]
3462                     }
3463                 }
3464             }
3465           AliDebug(4,"Helper part finished");
3466
3467           // Llenar los histogramas para los jets reconstruidos
3468
3469           Int_t crf = 0;      // current reco jet flavor
3470           Int_t crt = 0;      // current reco jet tracks
3471           Double_t crpt = 0;  // current jet pt
3472           Double_t cscm = 0.0;// current second central moment
3473
3474           for(Int_t ixr=0; ixr<maxJetNum; ixr++)
3475             {
3476               AliDebug(4,Form("Processing jet number:%i",ixr));
3477               if(iGenIndex[ixr]>=0)
3478                 {
3479                   crf = genJetsFlavor[iGenIndex[ixr]]; //para el reco jet con indice ixr
3480                   crt = nrectracks[ixr];  // se necesitaron este numero de tracks
3481                   crpt = ptrecjet[ixr];
3482                   cscm = scmr[ixr];
3483
3484                   //Fill candidates histos
3485                   if(crt>=7) //gluon candidate
3486                     fFragCandidates[0]->Add(fHistContainerR4[ixr]);
3487                   if(crt<=4) //quark candidate
3488                     fFragCandidates[1]->Add(fHistContainerR4[ixr]);
3489
3490                   switch(abs(crf))
3491                     {
3492                     case 1:
3493                       fNChTr[6]->Fill(crt,crpt);
3494                       fHistPtParton[6]->Fill(crpt);
3495                       fSCM[6]->Fill(cscm,crpt);
3496                       fFragChargedR4[0]->Add(fHistContainerR4[ixr]);
3497                       fFragChargedR3[0]->Add(fHistContainerR3[ixr]);
3498                       fFragChargedR2[0]->Add(fHistContainerR2[ixr]);
3499                       break;
3500                     case 2:
3501                       fNChTr[7]->Fill(crt,crpt);
3502                       fHistPtParton[7]->Fill(crpt);
3503                       fSCM[7]->Fill(cscm,crpt);
3504                       fFragChargedR4[1]->Add(fHistContainerR4[ixr]);
3505                       fFragChargedR3[1]->Add(fHistContainerR3[ixr]);
3506                       fFragChargedR2[1]->Add(fHistContainerR2[ixr]);
3507                       break;
3508                     case 3:
3509                       fNChTr[8]->Fill(crt,crpt);
3510                       fHistPtParton[8]->Fill(crpt);
3511                       fSCM[8]->Fill(cscm,crpt);
3512                       fFragChargedR4[2]->Add(fHistContainerR4[ixr]);
3513                       fFragChargedR3[2]->Add(fHistContainerR3[ixr]);
3514                       fFragChargedR2[2]->Add(fHistContainerR2[ixr]);
3515                       break;
3516                     case 4:
3517                       fNChTr[9]->Fill(crt,crpt);
3518                       fHistPtParton[9]->Fill(crpt);
3519                       fSCM[9]->Fill(cscm,crpt);
3520                       fFragChargedR4[3]->Add(fHistContainerR4[ixr]);
3521                       fFragChargedR3[3]->Add(fHistContainerR3[ixr]);
3522                       fFragChargedR2[3]->Add(fHistContainerR2[ixr]);
3523                       break;
3524                     case 5:
3525                       fNChTr[10]->Fill(crt,crpt);
3526                       fHistPtParton[10]->Fill(crpt);
3527                       fSCM[10]->Fill(cscm,crpt);
3528                       fFragChargedR4[4]->Add(fHistContainerR4[ixr]);
3529                       fFragChargedR3[4]->Add(fHistContainerR3[ixr]);
3530                       fFragChargedR2[4]->Add(fHistContainerR2[ixr]);
3531                       break;
3532                     case 21:
3533                       fNChTr[11]->Fill(crt,crpt);
3534                       fHistPtParton[11]->Fill(crpt);
3535                       fSCM[11]->Fill(cscm,crpt);
3536                       fFragChargedR4[5]->Add(fHistContainerR4[ixr]);
3537                       fFragChargedR3[5]->Add(fHistContainerR3[ixr]);
3538                       fFragChargedR2[5]->Add(fHistContainerR2[ixr]);
3539                       break;
3540                     default:
3541                       break;
3542                     }  // end switch
3543                   AliDebug(4,Form("Sabor del reco jet con pt:%f y numero:%d es: %d y se necesitaron %d tracks \n",crpt,ixr,crf,crt));
3544                 } // end index condition
3545             }  // end for cycle correlation gen-reco flavor
3546         } // end if MC info
3547     } // end of only MC info in the AOD, no reco jets
3548   PostData(1, fOutputList);
3549 }
3550
3551 //________________________________________________________________________
3552 void AliAnalysisTaskPartonDisc::Terminate(const Option_t *)
3553 {
3554   // Draw result to the screen
3555   // Called once at the end of the query
3556 }
3557 //________________________________________________________________________
3558 Int_t AliAnalysisTaskPartonDisc::GetMCEventType(AliMCEvent *mcEvent)
3559 {
3560   //
3561   // Get the event type from the pythia headers
3562   //
3563
3564   Int_t processNumber = 0;
3565   AliGenEventHeader* genHeader = mcEvent->GenEventHeader();
3566   AliGenPythiaEventHeader* pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(genHeader);
3567
3568   if(!pythiaGenHeader)
3569     {
3570       AliDebug(4,Form(" %s:%d No Pythia header!",(char*)__FILE__,__LINE__));
3571       return 0;
3572     }
3573
3574   processNumber = pythiaGenHeader->ProcessType();
3575
3576   return processNumber;
3577 }
3578 //________________________________________________________________________
3579 Int_t AliAnalysisTaskPartonDisc::GetPhojetEventType(AliMCEvent *mcEvent)
3580 {
3581   //
3582   // Get the event type from the phojet header
3583   //
3584
3585   Int_t processNumber = 0;
3586   AliGenEventHeader* genHeader = mcEvent->GenEventHeader();
3587   AliGenDPMjetEventHeader* phojetGenHeader = dynamic_cast<AliGenDPMjetEventHeader*>(genHeader);
3588
3589   if(!phojetGenHeader)
3590     {
3591       AliDebug(4,Form(" %s:%d No Phojet header!",(char*)__FILE__,__LINE__));
3592       return 0;
3593     }
3594
3595   processNumber = phojetGenHeader->ProcessType();
3596
3597   return processNumber;
3598 }
3599 //________________________________________________________________________
3600 Bool_t AliAnalysisTaskPartonDisc::IsInsideAcceptance(AliAODJet *jet)
3601 {
3602   //
3603   // Check if the jet is inside abs(eta)<=fJetAcceptance
3604   //
3605
3606   Double_t jeteta = jet->Eta();
3607   if(TMath::Abs(jeteta)<=fJetAcceptance)
3608     return kTRUE;
3609   else
3610     return kFALSE;
3611
3612 }
3613 //________________________________________________________________________
3614 Int_t AliAnalysisTaskPartonDisc::GetJetFlavour(AliAODJet *jet, Int_t ntracks, TClonesArray *mcarray)
3615 {
3616   //
3617   // Get the jet flavour, using the definition:
3618   // The flavour will be that of the parton with the highest energy
3619   // within an angular distance <= 0.3
3620   // This method also keeps track of the mother of the parton giving the flavor
3621   //
3622
3623   Int_t flavour = 0;
3624   Int_t pdgCode;
3625   Int_t aPDGcode;
3626   Double_t currentEnergy = 0;
3627   Double_t maxEnergy = 0;
3628   Double_t jeteta = jet->Eta();
3629   Double_t jetphi = jet->Phi();
3630   Double_t tracketa = 0;
3631   Double_t trackphi = 0;
3632   Double_t flavrad = fFlavorRadius;   //radius used for flavor
3633   Int_t indexM = 0;
3634   UInt_t status=0; //status code of leading parton
3635   fMpdg=0; // Initialize before each selection
3636   AliAODMCParticle *moftrack=0;
3637       for (Int_t iTracks = 0; iTracks < ntracks; iTracks++)
3638         {
3639           AliAODMCParticle *mctrack = (AliAODMCParticle*) mcarray->At(iTracks);
3640           if(!mctrack) continue;
3641           pdgCode = mctrack->GetPdgCode();
3642           aPDGcode = abs(pdgCode);
3643           if(aPDGcode==1||aPDGcode==2||aPDGcode==3||aPDGcode==4||aPDGcode==5||aPDGcode==6||aPDGcode==9||aPDGcode==21)
3644             {
3645               tracketa = mctrack->Eta();
3646               trackphi = mctrack->Phi();
3647               if(GetDeltaR(jeteta, jetphi, tracketa, trackphi)<=flavrad)
3648                 {
3649                   currentEnergy = mctrack->E();
3650                   if(currentEnergy>maxEnergy)
3651                     {
3652                       maxEnergy = currentEnergy;
3653                       flavour = pdgCode;
3654                       indexM = mctrack->GetMother();
3655                       if(fCheckMCStatus) // default is true
3656                         status =  mctrack->GetStatus();
3657                       //                      fFlavProc->Fill(flavour,status);
3658                       //testing
3659                       if(indexM<=0)
3660                         fMpdg = 0; // Unknown
3661                       else
3662                         {
3663                           moftrack = (AliAODMCParticle*) mcarray->At(indexM);
3664                           fMpdg = moftrack->GetPdgCode();
3665                         }
3666                     }
3667                 }
3668             }
3669         }
3670
3671       // //Restriction to pythia string fragmentation
3672       // if(!fPhojetMC)  //if pythia
3673       //        {
3674       //          if(fMpdg!=0) // if not from the string
3675       //            flavour=0;
3676       //        }
3677
3678       //  PDG code of the mother of the leading parton, leading parton, jet pT
3679       fPDGMothLPart->Fill(fMpdg,flavour,jet->Pt());
3680       fFlavProc->Fill(flavour,status);
3681
3682   return flavour;
3683 }
3684 //________________________________________________________________________
3685 Double_t AliAnalysisTaskPartonDisc::GetDeltaR(Double_t eta1, Double_t phi1,Double_t eta2, Double_t phi2)
3686 {
3687   //
3688   // Return R between the two jets or particles
3689   //
3690
3691   Double_t deltaphi = TMath::Abs(phi2-phi1);
3692   if (deltaphi > TMath::Pi())
3693     deltaphi = 2.0 * TMath::Pi() - deltaphi;
3694
3695
3696   Double_t deltaR = sqrt((eta2-eta1)*(eta2-eta1)+deltaphi*deltaphi);
3697   return deltaR;
3698
3699 }
3700 //________________________________________________________________________
3701 Int_t AliAnalysisTaskPartonDisc::GetNumberOfMcChargedTracks(Int_t percentage,AliAODJet *jet, Int_t ntracks, TClonesArray *mcarray, Double_t jr)
3702 {
3703   //
3704   // Calculate the number of charged particles necessary to
3705   // add the given percentage of the jet energy (transverse energy)
3706   // for the MC case
3707
3708   Int_t numberOfChargedTracks = 0;
3709   Int_t currentNumber = 0;
3710   Double_t jeteta = jet->Eta();
3711   Double_t jetphi = jet->Phi();
3712   Double_t jetpT = jet->Pt();
3713   Double_t tracketa = 0;
3714   Double_t trackphi = 0;
3715   Int_t arraysize = 1000;
3716   Bool_t rfTrkFlag  = kFALSE;
3717   fCurrentJetCharge=0;
3718
3719   AliDebug(4,Form("Eta of the jet:%f ",jeteta));
3720   if(IsEqualRel(jetpT, 0.0)) //IsEqualRel(jetpT, 0.0) // jetpT==0
3721     return 0;
3722
3723   // RefTracks
3724   Int_t trkinjet = jet->GetRefTracks()->GetEntriesFast();
3725   if(trkinjet!=0)
3726     rfTrkFlag = kTRUE;
3727   AliDebug(4,Form("Number of tracks in this mc jet by RefTracks:%i \n",trkinjet));
3728
3729   AllocateStaticContainer(arraysize);
3730   InitializeStaticContainer(arraysize);
3731
3732   Double_t randomNum = 0.;
3733
3734   if(!rfTrkFlag)  // if not track ref, check track by track
3735     {
3736       AliDebug(4,Form("Empty Track Refs (mc)!"));
3737       for (Int_t iTracks = 0; iTracks < ntracks; iTracks++)
3738         {
3739           AliAODMCParticle *mctrack = (AliAODMCParticle*) mcarray->At(iTracks);
3740           if(!mctrack) continue;
3741           tracketa = mctrack->Eta();
3742           trackphi = mctrack->Phi();
3743           if(mctrack->Pt()<fMinpTVal) continue; // pT cut, not using track refs
3744           if(mctrack->IsPhysicalPrimary())
3745             {
3746               if(mctrack->Charge()!=0&&mctrack->Charge()!=-99)
3747                 {
3748                   if(GetDeltaR(jeteta, jetphi, tracketa, trackphi)<=jr)
3749                     {
3750                       randomNum = gRandom->Rndm();
3751                       if(randomNum<fJTrackRandomRejection) continue; //rechaza fJTrackRandomRejection dentro del cono
3752                       currentNumber++;
3753                       fCurrentJetCharge=fCurrentJetCharge+mctrack->Charge(); //add the charge of this track
3754                       fgContainer[currentNumber-1] = mctrack->Pt();  // save the current pt in the container
3755                     } // end if inside jet
3756                 } // end charged
3757             } // end physical primary
3758         }   // end for tracks
3759     } // end rfTrkFlag
3760
3761   if(rfTrkFlag)  // if track ref, use them
3762     {
3763       AliDebug(4,Form("Using Track Refs (mc)!"));
3764       for(Int_t ixt=0; ixt<trkinjet;ixt++)
3765         {
3766           AliAODMCParticle *vtrack = dynamic_cast<AliAODMCParticle*>(jet->GetRefTracks()->At(ixt));
3767           if(!vtrack) continue;
3768           if(vtrack->Charge()!=0&&vtrack->Charge()!=-99)
3769             {
3770               randomNum = gRandom->Rndm();
3771               if(randomNum<fJTrackRandomRejection) continue; //rechaza fJTrackRandomRejection dentro del cono
3772               currentNumber++;
3773               fCurrentJetCharge=fCurrentJetCharge+vtrack->Charge(); //add the charge of this track
3774               fgContainer[currentNumber-1] = vtrack->Pt();  // save the current pt in the container
3775             }
3776         } // end trk in jet
3777     } // end if trk ref
3778
3779   // sort the contents of the container
3780   SortArray(fgContainer,arraysize);
3781   // loop over the contents and count how many tracks are necessary to recover the percentage of the energy
3782   numberOfChargedTracks = TracksForPercentage(fgContainer, arraysize, percentage, jetpT);
3783   AliDebug(4,Form("Number of tracks was:%i, returning",numberOfChargedTracks));
3784   return numberOfChargedTracks;
3785
3786 }
3787 //________________________________________________________________________
3788 Int_t AliAnalysisTaskPartonDisc::GetNumberOfChargedTracks(Int_t percentage,AliAODJet *jet, Int_t ntracks, AliAODEvent *aode, Double_t jr)
3789 {
3790   //
3791   // Calculate the number of charged particles necessary to
3792   // add the given percentage of the jet energy (transverse energy)
3793   // for the AOD track case
3794
3795   Int_t numberOfChargedTracks = 0;
3796   Int_t currentNumber = 0;
3797   Double_t jeteta = jet->Eta();
3798   Double_t jetphi = jet->Phi();
3799   Double_t jetpT = jet->Pt();
3800   Double_t tracketa = 0;
3801   Double_t trackphi = 0;
3802   Int_t arraysize = 1000;
3803   Bool_t rfTrkFlag  = kFALSE;
3804   fCurrentJetCharge=0;
3805
3806   if(IsEqualRel(jetpT, 0.0)) // IsEqualRel(jetpT, 0.0) // jetpT==0
3807     return 0;
3808
3809   // RefTracks
3810   Int_t trkinjet = jet->GetRefTracks()->GetEntriesFast();
3811   if(trkinjet!=0&&!fForceNotTR)
3812     rfTrkFlag = kTRUE;
3813   AliDebug(4,Form("Number of tracks in this reco jet by RefTracks:%i \n",trkinjet));
3814
3815   AllocateStaticContainer(arraysize);
3816   InitializeStaticContainer(arraysize);
3817   if(!rfTrkFlag)  // if not track ref, check track by track
3818     {
3819       AliDebug(4,Form("Empty Track Refs (reco)!"));
3820       for (Int_t iTracks = 0; iTracks < ntracks; iTracks++)
3821         {
3822           AliAODTrack *aodtrack = aode->GetTrack(iTracks);
3823           if(!aodtrack) continue;
3824           tracketa = aodtrack->Eta();
3825           trackphi = aodtrack->Phi();
3826           if(GetDeltaR(jeteta, jetphi, tracketa, trackphi)<=jr)
3827             {
3828               if(!aodtrack->TestFilterBit(fFilterBit)) continue; //track filter selection
3829               if(!aodtrack->IsPrimaryCandidate()) continue; // only primaries
3830               if(aodtrack->Pt()<fMinpTVal) continue; // pT cut, not using track refs
3831               currentNumber++;
3832               fCurrentJetCharge=fCurrentJetCharge+aodtrack->Charge();
3833               fgContainer[currentNumber-1] = aodtrack->Pt();  // save the current pt in the container
3834
3835               ////////start centrality dependent pT spec ////////
3836               if(!fIsHIevent) //if is a proton proton event
3837                 {
3838                   if((jet->Pt()>10.)&&(jet->Pt()<20.))
3839                     fPtDistInJetConeRaw->Fill(aodtrack->Pt(),1,1);
3840                   if((jet->Pt()>20.)&&(jet->Pt()<30.))
3841                     fPtDistInJetConeRaw->Fill(aodtrack->Pt(),2,1);
3842                   if((jet->Pt()>30.)&&(jet->Pt()<40.))
3843                     fPtDistInJetConeRaw->Fill(aodtrack->Pt(),3,1);
3844                   if((jet->Pt()>40.)&&(jet->Pt()<50.))
3845                     fPtDistInJetConeRaw->Fill(aodtrack->Pt(),4,1);
3846                   if((jet->Pt()>50.)&&(jet->Pt()<60.))
3847                     fPtDistInJetConeRaw->Fill(aodtrack->Pt(),5,1);
3848                   if((jet->Pt()>60.)&&(jet->Pt()<70.))
3849                     fPtDistInJetConeRaw->Fill(aodtrack->Pt(),6,1);
3850                   if((jet->Pt()>70.)&&(jet->Pt()<80.))
3851                     fPtDistInJetConeRaw->Fill(aodtrack->Pt(),7,1);
3852                   if((jet->Pt()>80.)&&(jet->Pt()<90.))
3853                     fPtDistInJetConeRaw->Fill(aodtrack->Pt(),8,1);
3854                 } // end of pp event
3855               if(fIsHIevent) //if is a PbPb event
3856                 {
3857                   if(fEventCent>=0&&fEventCent<10.)
3858                     {
3859                       if((jet->Pt()>10.)&&(jet->Pt()<20.))
3860                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),1,2);
3861                       if((jet->Pt()>20.)&&(jet->Pt()<30.))
3862                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),2,2);
3863                       if((jet->Pt()>30.)&&(jet->Pt()<40.))
3864                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),3,2);
3865                       if((jet->Pt()>40.)&&(jet->Pt()<50.))
3866                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),4,2);
3867                       if((jet->Pt()>50.)&&(jet->Pt()<60.))
3868                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),5,2);
3869                       if((jet->Pt()>60.)&&(jet->Pt()<70.))
3870                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),6,2);
3871                       if((jet->Pt()>70.)&&(jet->Pt()<80.))
3872                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),7,2);
3873                       if((jet->Pt()>80.)&&(jet->Pt()<90.))
3874                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),8,2);
3875                     } // end of 0-10
3876                   if(fEventCent>=10&&fEventCent<20.)
3877                     {
3878                       if((jet->Pt()>10.)&&(jet->Pt()<20.))
3879                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),1,3);
3880                       if((jet->Pt()>20.)&&(jet->Pt()<30.))
3881                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),2,3);
3882                       if((jet->Pt()>30.)&&(jet->Pt()<40.))
3883                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),3,3);
3884                       if((jet->Pt()>40.)&&(jet->Pt()<50.))
3885                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),4,3);
3886                       if((jet->Pt()>50.)&&(jet->Pt()<60.))
3887                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),5,3);
3888                       if((jet->Pt()>60.)&&(jet->Pt()<70.))
3889                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),6,3);
3890                       if((jet->Pt()>70.)&&(jet->Pt()<80.))
3891                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),7,3);
3892                       if((jet->Pt()>80.)&&(jet->Pt()<90.))
3893                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),8,3);
3894                     } // end of 10-20
3895                   if(fEventCent>=20&&fEventCent<30.)
3896                     {
3897                       if((jet->Pt()>10.)&&(jet->Pt()<20.))
3898                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),1,4);
3899                       if((jet->Pt()>20.)&&(jet->Pt()<30.))
3900                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),2,4);
3901                       if((jet->Pt()>30.)&&(jet->Pt()<40.))
3902                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),3,4);
3903                       if((jet->Pt()>40.)&&(jet->Pt()<50.))
3904                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),4,4);
3905                       if((jet->Pt()>50.)&&(jet->Pt()<60.))
3906                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),5,4);
3907                       if((jet->Pt()>60.)&&(jet->Pt()<70.))
3908                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),6,4);
3909                       if((jet->Pt()>70.)&&(jet->Pt()<80.))
3910                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),7,4);
3911                       if((jet->Pt()>80.)&&(jet->Pt()<90.))
3912                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),8,4);
3913                     } // end of 20-30
3914                   if(fEventCent>=30&&fEventCent<40.)
3915                     {
3916                       if((jet->Pt()>10.)&&(jet->Pt()<20.))
3917                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),1,5);
3918                       if((jet->Pt()>20.)&&(jet->Pt()<30.))
3919                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),2,5);
3920                       if((jet->Pt()>30.)&&(jet->Pt()<40.))
3921                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),3,5);
3922                       if((jet->Pt()>40.)&&(jet->Pt()<50.))
3923                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),4,5);
3924                       if((jet->Pt()>50.)&&(jet->Pt()<60.))
3925                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),5,5);
3926                       if((jet->Pt()>60.)&&(jet->Pt()<70.))
3927                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),6,5);
3928                       if((jet->Pt()>70.)&&(jet->Pt()<80.))
3929                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),7,5);
3930                       if((jet->Pt()>80.)&&(jet->Pt()<90.))
3931                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),8,5);
3932                     } // end of 30-40
3933                   if(fEventCent>=40&&fEventCent<50.)
3934                     {
3935                       if((jet->Pt()>10.)&&(jet->Pt()<20.))
3936                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),1,6);
3937                       if((jet->Pt()>20.)&&(jet->Pt()<30.))
3938                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),2,6);
3939                       if((jet->Pt()>30.)&&(jet->Pt()<40.))
3940                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),3,6);
3941                       if((jet->Pt()>40.)&&(jet->Pt()<50.))
3942                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),4,6);
3943                       if((jet->Pt()>50.)&&(jet->Pt()<60.))
3944                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),5,6);
3945                       if((jet->Pt()>60.)&&(jet->Pt()<70.))
3946                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),6,6);
3947                       if((jet->Pt()>70.)&&(jet->Pt()<80.))
3948                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),7,6);
3949                       if((jet->Pt()>80.)&&(jet->Pt()<90.))
3950                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),8,6);
3951                     }  // end of 40-50
3952                   if(fEventCent>=50&&fEventCent<60.)
3953                     {
3954                       if((jet->Pt()>10.)&&(jet->Pt()<20.))
3955                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),1,7);
3956                       if((jet->Pt()>20.)&&(jet->Pt()<30.))
3957                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),2,7);
3958                       if((jet->Pt()>30.)&&(jet->Pt()<40.))
3959                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),3,7);
3960                       if((jet->Pt()>40.)&&(jet->Pt()<50.))
3961                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),4,7);
3962                       if((jet->Pt()>50.)&&(jet->Pt()<60.))
3963                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),5,7);
3964                       if((jet->Pt()>60.)&&(jet->Pt()<70.))
3965                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),6,7);
3966                       if((jet->Pt()>70.)&&(jet->Pt()<80.))
3967                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),7,7);
3968                       if((jet->Pt()>80.)&&(jet->Pt()<90.))
3969                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),8,7);
3970                     }  // end of 50-60
3971                   if(fEventCent>=60&&fEventCent<70.)
3972                     {
3973                       if((jet->Pt()>10.)&&(jet->Pt()<20.))
3974                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),1,8);
3975                       if((jet->Pt()>20.)&&(jet->Pt()<30.))
3976                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),2,8);
3977                       if((jet->Pt()>30.)&&(jet->Pt()<40.))
3978                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),3,8);
3979                       if((jet->Pt()>40.)&&(jet->Pt()<50.))
3980                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),4,8);
3981                       if((jet->Pt()>50.)&&(jet->Pt()<60.))
3982                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),5,8);
3983                       if((jet->Pt()>60.)&&(jet->Pt()<70.))
3984                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),6,8);
3985                       if((jet->Pt()>70.)&&(jet->Pt()<80.))
3986                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),7,8);
3987                       if((jet->Pt()>80.)&&(jet->Pt()<90.))
3988                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),8,8);
3989                     }  // end of 60-70
3990                   if(fEventCent>=70&&fEventCent<80.)
3991                     {
3992                       if((jet->Pt()>10.)&&(jet->Pt()<20.))
3993                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),1,9);
3994                       if((jet->Pt()>20.)&&(jet->Pt()<30.))
3995                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),2,9);
3996                       if((jet->Pt()>30.)&&(jet->Pt()<40.))
3997                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),3,9);
3998                       if((jet->Pt()>40.)&&(jet->Pt()<50.))
3999                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),4,9);
4000                       if((jet->Pt()>50.)&&(jet->Pt()<60.))
4001                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),5,9);
4002                       if((jet->Pt()>60.)&&(jet->Pt()<70.))
4003                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),6,9);
4004                       if((jet->Pt()>70.)&&(jet->Pt()<80.))
4005                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),7,9);
4006                       if((jet->Pt()>80.)&&(jet->Pt()<90.))
4007                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),8,9);
4008                     }  // end of 70-80
4009                   if(fEventCent>=80&&fEventCent<100.)
4010                     {
4011                       if((jet->Pt()>10.)&&(jet->Pt()<20.))
4012                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),1,10);
4013                       if((jet->Pt()>20.)&&(jet->Pt()<30.))
4014                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),2,10);
4015                       if((jet->Pt()>30.)&&(jet->Pt()<40.))
4016                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),3,10);
4017                       if((jet->Pt()>40.)&&(jet->Pt()<50.))
4018                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),4,10);
4019                       if((jet->Pt()>50.)&&(jet->Pt()<60.))
4020                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),5,10);
4021                       if((jet->Pt()>60.)&&(jet->Pt()<70.))
4022                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),6,10);
4023                       if((jet->Pt()>70.)&&(jet->Pt()<80.))
4024                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),7,10);
4025                       if((jet->Pt()>80.)&&(jet->Pt()<90.))
4026                         fPtDistInJetConeRaw->Fill(aodtrack->Pt(),8,10);
4027                     }  // end of 80-100
4028                 }  //end of PbPb event
4029               ////////end centrality dependent pT spec/////
4030             } // end if inside jet
4031         } // end for tracks
4032     } // end of no track ref
4033
4034   if(rfTrkFlag)  // if track ref, use them
4035     {
4036       AliDebug(4,Form("Using Track Refs (reco)!"));
4037       for(Int_t ixt=0; ixt<trkinjet;ixt++)
4038         {
4039           AliVParticle *vtrack = dynamic_cast<AliVParticle*>(jet->GetRefTracks()->At(ixt));
4040           if(!vtrack) continue;
4041           // No further checks, all cuts should be in in the track refs
4042           if(vtrack->Charge()!=0&&vtrack->Charge()!=-99)
4043             {
4044               currentNumber++;
4045               fCurrentJetCharge=fCurrentJetCharge+vtrack->Charge();
4046               fgContainer[currentNumber-1] = vtrack->Pt();  // save the current pt in the container
4047
4048               ////////start centrality dependent pT spec ////////
4049               if(!fIsHIevent) //if is a proton proton event
4050                 {
4051                   if((jet->Pt()>10.)&&(jet->Pt()<20.))
4052                     fPtDistInJetConeRaw->Fill(vtrack->Pt(),1,1);
4053                   if((jet->Pt()>20.)&&(jet->Pt()<30.))
4054                     fPtDistInJetConeRaw->Fill(vtrack->Pt(),2,1);
4055                   if((jet->Pt()>30.)&&(jet->Pt()<40.))
4056                     fPtDistInJetConeRaw->Fill(vtrack->Pt(),3,1);
4057                   if((jet->Pt()>40.)&&(jet->Pt()<50.))
4058                     fPtDistInJetConeRaw->Fill(vtrack->Pt(),4,1);
4059                   if((jet->Pt()>50.)&&(jet->Pt()<60.))
4060                     fPtDistInJetConeRaw->Fill(vtrack->Pt(),5,1);
4061                   if((jet->Pt()>60.)&&(jet->Pt()<70.))
4062                     fPtDistInJetConeRaw->Fill(vtrack->Pt(),6,1);
4063                   if((jet->Pt()>70.)&&(jet->Pt()<80.))
4064                     fPtDistInJetConeRaw->Fill(vtrack->Pt(),7,1);
4065                   if((jet->Pt()>80.)&&(jet->Pt()<90.))
4066                     fPtDistInJetConeRaw->Fill(vtrack->Pt(),8,1);
4067                 } // end of pp event
4068               if(fIsHIevent) //if is a PbPb event
4069                 {
4070                   if(fEventCent>=0&&fEventCent<10.)
4071                     {
4072                       if((jet->Pt()>10.)&&(jet->Pt()<20.))
4073                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),1,2);
4074                       if((jet->Pt()>20.)&&(jet->Pt()<30.))
4075                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),2,2);
4076                       if((jet->Pt()>30.)&&(jet->Pt()<40.))
4077                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),3,2);
4078                       if((jet->Pt()>40.)&&(jet->Pt()<50.))
4079                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),4,2);
4080                       if((jet->Pt()>50.)&&(jet->Pt()<60.))
4081                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),5,2);
4082                       if((jet->Pt()>60.)&&(jet->Pt()<70.))
4083                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),6,2);
4084                       if((jet->Pt()>70.)&&(jet->Pt()<80.))
4085                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),7,2);
4086                       if((jet->Pt()>80.)&&(jet->Pt()<90.))
4087                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),8,2);
4088                     } // end of 0-10
4089                   if(fEventCent>=10&&fEventCent<20.)
4090                     {
4091                       if((jet->Pt()>10.)&&(jet->Pt()<20.))
4092                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),1,3);
4093                       if((jet->Pt()>20.)&&(jet->Pt()<30.))
4094                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),2,3);
4095                       if((jet->Pt()>30.)&&(jet->Pt()<40.))
4096                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),3,3);
4097                       if((jet->Pt()>40.)&&(jet->Pt()<50.))
4098                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),4,3);
4099                       if((jet->Pt()>50.)&&(jet->Pt()<60.))
4100                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),5,3);
4101                       if((jet->Pt()>60.)&&(jet->Pt()<70.))
4102                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),6,3);
4103                       if((jet->Pt()>70.)&&(jet->Pt()<80.))
4104                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),7,3);
4105                       if((jet->Pt()>80.)&&(jet->Pt()<90.))
4106                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),8,3);
4107                     } // end of 10-20
4108                   if(fEventCent>=20&&fEventCent<30.)
4109                     {
4110                       if((jet->Pt()>10.)&&(jet->Pt()<20.))
4111                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),1,4);
4112                       if((jet->Pt()>20.)&&(jet->Pt()<30.))
4113                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),2,4);
4114                       if((jet->Pt()>30.)&&(jet->Pt()<40.))
4115                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),3,4);
4116                       if((jet->Pt()>40.)&&(jet->Pt()<50.))
4117                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),4,4);
4118                       if((jet->Pt()>50.)&&(jet->Pt()<60.))
4119                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),5,4);
4120                       if((jet->Pt()>60.)&&(jet->Pt()<70.))
4121                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),6,4);
4122                       if((jet->Pt()>70.)&&(jet->Pt()<80.))
4123                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),7,4);
4124                       if((jet->Pt()>80.)&&(jet->Pt()<90.))
4125                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),8,4);
4126                     } // end of 20-30
4127                   if(fEventCent>=30&&fEventCent<40.)
4128                     {
4129                       if((jet->Pt()>10.)&&(jet->Pt()<20.))
4130                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),1,5);
4131                       if((jet->Pt()>20.)&&(jet->Pt()<30.))
4132                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),2,5);
4133                       if((jet->Pt()>30.)&&(jet->Pt()<40.))
4134                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),3,5);
4135                       if((jet->Pt()>40.)&&(jet->Pt()<50.))
4136                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),4,5);
4137                       if((jet->Pt()>50.)&&(jet->Pt()<60.))
4138                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),5,5);
4139                       if((jet->Pt()>60.)&&(jet->Pt()<70.))
4140                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),6,5);
4141                       if((jet->Pt()>70.)&&(jet->Pt()<80.))
4142                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),7,5);
4143                       if((jet->Pt()>80.)&&(jet->Pt()<90.))
4144                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),8,5);
4145                     } // end of 30-40
4146                   if(fEventCent>=40&&fEventCent<50.)
4147                     {
4148                       if((jet->Pt()>10.)&&(jet->Pt()<20.))
4149                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),1,6);
4150                       if((jet->Pt()>20.)&&(jet->Pt()<30.))
4151                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),2,6);
4152                       if((jet->Pt()>30.)&&(jet->Pt()<40.))
4153                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),3,6);
4154                       if((jet->Pt()>40.)&&(jet->Pt()<50.))
4155                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),4,6);
4156                       if((jet->Pt()>50.)&&(jet->Pt()<60.))
4157                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),5,6);
4158                       if((jet->Pt()>60.)&&(jet->Pt()<70.))
4159                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),6,6);
4160                       if((jet->Pt()>70.)&&(jet->Pt()<80.))
4161                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),7,6);
4162                       if((jet->Pt()>80.)&&(jet->Pt()<90.))
4163                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),8,6);
4164                     }  // end of 40-50
4165                   if(fEventCent>=50&&fEventCent<60.)
4166                     {
4167                       if((jet->Pt()>10.)&&(jet->Pt()<20.))
4168                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),1,7);
4169                       if((jet->Pt()>20.)&&(jet->Pt()<30.))
4170                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),2,7);
4171                       if((jet->Pt()>30.)&&(jet->Pt()<40.))
4172                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),3,7);
4173                       if((jet->Pt()>40.)&&(jet->Pt()<50.))
4174                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),4,7);
4175                       if((jet->Pt()>50.)&&(jet->Pt()<60.))
4176                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),5,7);
4177                       if((jet->Pt()>60.)&&(jet->Pt()<70.))
4178                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),6,7);
4179                       if((jet->Pt()>70.)&&(jet->Pt()<80.))
4180                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),7,7);
4181                       if((jet->Pt()>80.)&&(jet->Pt()<90.))
4182                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),8,7);
4183                     }  // end of 50-60
4184                   if(fEventCent>=60&&fEventCent<70.)
4185                     {
4186                       if((jet->Pt()>10.)&&(jet->Pt()<20.))
4187                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),1,8);
4188                       if((jet->Pt()>20.)&&(jet->Pt()<30.))
4189                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),2,8);
4190                       if((jet->Pt()>30.)&&(jet->Pt()<40.))
4191                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),3,8);
4192                       if((jet->Pt()>40.)&&(jet->Pt()<50.))
4193                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),4,8);
4194                       if((jet->Pt()>50.)&&(jet->Pt()<60.))
4195                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),5,8);
4196                       if((jet->Pt()>60.)&&(jet->Pt()<70.))
4197                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),6,8);
4198                       if((jet->Pt()>70.)&&(jet->Pt()<80.))
4199                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),7,8);
4200                       if((jet->Pt()>80.)&&(jet->Pt()<90.))
4201                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),8,8);
4202                     }  // end of 60-70
4203                   if(fEventCent>=70&&fEventCent<80.)
4204                     {
4205                       if((jet->Pt()>10.)&&(jet->Pt()<20.))
4206                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),1,9);
4207                       if((jet->Pt()>20.)&&(jet->Pt()<30.))
4208                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),2,9);
4209                       if((jet->Pt()>30.)&&(jet->Pt()<40.))
4210                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),3,9);
4211                       if((jet->Pt()>40.)&&(jet->Pt()<50.))
4212                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),4,9);
4213                       if((jet->Pt()>50.)&&(jet->Pt()<60.))
4214                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),5,9);
4215                       if((jet->Pt()>60.)&&(jet->Pt()<70.))
4216                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),6,9);
4217                       if((jet->Pt()>70.)&&(jet->Pt()<80.))
4218                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),7,9);
4219                       if((jet->Pt()>80.)&&(jet->Pt()<90.))
4220                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),8,9);
4221                     }  // end of 70-80
4222                   if(fEventCent>=80&&fEventCent<100.)
4223                     {
4224                       if((jet->Pt()>10.)&&(jet->Pt()<20.))
4225                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),1,10);
4226                       if((jet->Pt()>20.)&&(jet->Pt()<30.))
4227                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),2,10);
4228                       if((jet->Pt()>30.)&&(jet->Pt()<40.))
4229                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),3,10);
4230                       if((jet->Pt()>40.)&&(jet->Pt()<50.))
4231                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),4,10);
4232                       if((jet->Pt()>50.)&&(jet->Pt()<60.))
4233                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),5,10);
4234                       if((jet->Pt()>60.)&&(jet->Pt()<70.))
4235                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),6,10);
4236                       if((jet->Pt()>70.)&&(jet->Pt()<80.))
4237                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),7,10);
4238                       if((jet->Pt()>80.)&&(jet->Pt()<90.))
4239                         fPtDistInJetConeRaw->Fill(vtrack->Pt(),8,10);
4240                     }  // end of 80-100
4241                 }  //end of PbPb event
4242               ////////end centrality dependent pT spec/////
4243             }
4244         } // end trk in jet
4245     } // end if trk ref
4246
4247
4248   // sort the contents of the container
4249   SortArray(fgContainer,arraysize);
4250   // loop over the contents and count how many tracks are necessary to recover the percetage of the energy
4251   numberOfChargedTracks = TracksForPercentage(fgContainer, arraysize, percentage, jetpT);
4252   return numberOfChargedTracks;
4253 }
4254 //________________________________________________________________________
4255 void AliAnalysisTaskPartonDisc::AllocateStaticContainer(Int_t size)
4256 {
4257   //
4258   // Allocate the static container with the given dimensions
4259   //
4260
4261   if(fgContainer)
4262     return;
4263   fgContainer = new Double_t[size];
4264
4265 }
4266 //________________________________________________________________________
4267 void AliAnalysisTaskPartonDisc::InitializeStaticContainer(Int_t size)
4268 {
4269   //
4270   // Initialize the static container with the given dimensions
4271   //
4272
4273   memset(fgContainer,0,size*sizeof(Double_t));
4274
4275 }
4276 //________________________________________________________________________
4277 void AliAnalysisTaskPartonDisc::SortArray(Double_t *pointer, Int_t arraySize)
4278 {
4279   //
4280   // Sort the contents of the array
4281   // From lower to higher value
4282   //
4283
4284   std::sort(pointer,pointer+arraySize);
4285
4286 }
4287 //________________________________________________________________________
4288 Int_t AliAnalysisTaskPartonDisc::TracksForPercentage(Double_t *array, Int_t arraysize, Int_t percentage, Double_t jetenergy)
4289 {
4290   //
4291   // Loop over the contents and count how many tracks are necessary to recover
4292   // the given percentage of the energy.
4293   // If all tracks did not sum the required fraction, it returns 500
4294   //
4295
4296   AliDebug(4,Form("Calculating the number of tracks for a jet with energy:%f \n",jetenergy));
4297   Double_t ptsum = 0;
4298   Double_t threshold = jetenergy*percentage/100;
4299   Int_t tracknummer=0;
4300   fCurrentJetMinPtNT90 = 7000.; //dummy value for debugging
4301   for(Int_t inverse=arraysize; inverse>0; inverse--)
4302     {
4303       ptsum= ptsum + array[inverse-1];
4304       if(inverse==arraysize) //if the highest value
4305         fMaxTrackPtInNTX=array[inverse-1]; //saving the highest pT track value
4306       tracknummer++;
4307       fMinTrackPtInNTX=array[inverse-1]; // this is the current lowest pT track used
4308       if(fIsPossibleToSubstBckg) //Store the value if it was possible to find a perpendicular cone
4309         fCurrentJetMinPtNT90=array[inverse-1];
4310       if(ptsum>=threshold)  // the threshold was reached
4311         break;
4312       if((inverse==1)&&(ptsum<threshold)) //if it was not possible to reach the threshold
4313         {
4314           tracknummer = 500; //dummy value for debugging
4315           fCurrentJetMinPtNT90 = 7000.; //dummy value for debugging
4316         }
4317     }
4318
4319   AliDebug(4,"Done calculating the number of tracks, returning to main code \n");
4320   return tracknummer;
4321
4322 }
4323 //________________________________________________________________________
4324 Bool_t AliAnalysisTaskPartonDisc::IsMCTrackInsideThisJet(AliAODMCParticle *MCParticle, AliAODJet *Jet, Double_t jr)
4325 {
4326   //
4327   // Return kTrue if the mc track is inside the area covered by the cone of the jet
4328   //
4329
4330   Double_t etapart = MCParticle->Eta();
4331   Double_t phipart = MCParticle->Phi();
4332   Double_t etajet = Jet->Eta();
4333   Double_t phijet = Jet->Phi();
4334   Double_t deltaeta = etajet-etapart;
4335   Double_t deltaphi = TMath::Abs(phijet-phipart);
4336   if (deltaphi > TMath::Pi())
4337     deltaphi = 2.0 * TMath::Pi() - deltaphi;
4338
4339   Double_t deltar = sqrt(deltaeta*deltaeta+deltaphi*deltaphi);
4340   if(deltar<=jr)
4341     return kTRUE;
4342   else
4343     return kFALSE;
4344
4345 }
4346 //________________________________________________________________________
4347 Bool_t AliAnalysisTaskPartonDisc::IsTrackInsideThisJet(AliAODTrack *aodT, AliAODJet *Jet, Double_t jr)
4348 {
4349   //
4350   // Return kTrue if the track is inside the area covered by the cone of the jet
4351   //
4352
4353   Double_t etapart = aodT->Eta();
4354   Double_t phipart = aodT->Phi();
4355   Double_t etajet = Jet->Eta();
4356   Double_t phijet = Jet->Phi();
4357   Double_t deltaeta = etajet-etapart;
4358   Double_t deltaphi = TMath::Abs(phijet-phipart);
4359   if (deltaphi > TMath::Pi())
4360     deltaphi = 2.0 * TMath::Pi() - deltaphi;
4361
4362   Double_t deltar = sqrt(deltaeta*deltaeta+deltaphi*deltaphi);
4363   if(deltar<=jr)
4364     return kTRUE;
4365   else
4366     return kFALSE;
4367
4368 }
4369 //________________________________________________________________________
4370 Bool_t AliAnalysisTaskPartonDisc::VertexInJet(AliAODVertex *pvtx, AliAODVertex *vtx, AliAODJet *jet, Double_t jr)
4371 {
4372   //
4373   // Return kTRUE if the cone covers the vector
4374   // from the primary vertex to this vertex
4375   //
4376
4377   Double_t pvx =  pvtx->GetX(); //primary vertex x
4378   Double_t pvy =  pvtx->GetY(); //primary vertex y
4379   Double_t pvz =  pvtx->GetZ(); //primary vertex z
4380
4381   Double_t vx =  vtx->GetX(); // vertex x
4382   Double_t vy =  vtx->GetY(); // vertex y
4383   Double_t vz =  vtx->GetZ(); // vertex z
4384
4385   if(IsEqualRel(pvx, vx) && IsEqualRel(pvy, vy) && IsEqualRel(pvz, vz)) //!IsEqualRel(totalTrackPt, 0.0) // pvx==vx && pvy==vy && pvz==vz
4386     return kFALSE;
4387
4388   Double_t thetaval = GetThetaAngle(vx-pvx,vy-pvy,vz-pvz);
4389   Double_t etaval = GetEtaValue(thetaval);
4390   Double_t phival = GetPhiAngle(vx-pvx,vy-pvy);
4391
4392   Double_t etajet = jet->Eta();
4393   Double_t phijet = jet->Phi();
4394
4395   if(GetDeltaR(etajet,phijet,etaval,phival)<=jr)
4396     return kTRUE;
4397
4398   return kFALSE;
4399 }
4400 //________________________________________________________________________
4401 Double_t AliAnalysisTaskPartonDisc::GetEtaValue(Double_t theta) const
4402 {
4403   //
4404   // Get the eta value
4405   //
4406
4407   Double_t eta = -TMath::Log(theta/2);
4408   return eta;
4409
4410 }
4411 //________________________________________________________________________
4412 Double_t AliAnalysisTaskPartonDisc::GetThetaAngle(Double_t xval, Double_t yval, Double_t zval)
4413 {
4414   //
4415   // Get the theta angle related to these coordinates
4416   //
4417
4418   if(IsEqualRel(zval, 0.0)) //!IsEqualRel(totalTrackPt, 0.0) // zval==0
4419     return TMath::PiOver2();
4420
4421   Double_t theta = 0;
4422   Double_t erre = TMath::Sqrt(xval*xval+yval*yval+zval*zval);
4423
4424   if(zval>0)
4425     theta = TMath::ACos(zval/erre);
4426
4427   if(zval<0)
4428     theta = TMath::Pi() - TMath::ACos(TMath::Abs(zval)/erre);
4429
4430   if(IsEqualRel(theta, 0.0)) // theta==0
4431     AliError("ERROR in GetThetaAngle!");
4432
4433   return theta;
4434
4435 }
4436 //________________________________________________________________________
4437 Double_t AliAnalysisTaskPartonDisc::GetPhiAngle(Double_t xval, Double_t yval)
4438 {
4439   //
4440   // Get the phi angle related to these coordinates
4441   //
4442
4443   if(IsEqualRel(xval, 0.0)) //IsEqualRel(zval, 0.0) // xval==0
4444     {
4445       if(yval>0)
4446         return TMath::PiOver2();
4447       if(yval<0)
4448         return (3/2*TMath::Pi());
4449     }
4450   Double_t phi = 0;
4451
4452   if(xval>0)
4453     {
4454       if(yval>0)
4455         phi = TMath::ATan(yval/xval);
4456       if(yval<0)
4457         phi = 2*TMath::Pi()- TMath::ATan(TMath::Abs(yval)/xval);
4458     }
4459   if(xval<0)
4460     {
4461       if(yval>0)
4462         phi = TMath::Pi() - TMath::ATan(yval/TMath::Abs(xval));
4463       if(yval<0)
4464         phi = TMath::Pi() + TMath::ATan(TMath::Abs(yval/xval));
4465     }
4466
4467   return phi;
4468 }
4469 //________________________________________________________________________
4470 Double_t AliAnalysisTaskPartonDisc::DeltaPhiMC(AliAODJet *jet, AliAODMCParticle *particle)
4471 {
4472   //
4473   // Get delta-phi MC jet-track
4474   //
4475
4476   Double_t deltaphi = jet->Phi()-particle->Phi();
4477   if (deltaphi > TMath::Pi())
4478     deltaphi = 2.0 * TMath::Pi() - deltaphi;
4479   if (deltaphi < -TMath::Pi())
4480     deltaphi =  -deltaphi- 2.0 * TMath::Pi();
4481
4482   return deltaphi;
4483
4484 }
4485 //________________________________________________________________________
4486 Double_t AliAnalysisTaskPartonDisc::DeltaEtaMC(AliAODJet *jet, AliAODMCParticle *particle)
4487 {
4488   //
4489   // Get delta-eta MC jet-track
4490   //
4491
4492   Double_t deltaetaMC = jet->Eta() - particle->Eta();
4493   return deltaetaMC;
4494 }
4495 //________________________________________________________________________
4496 Double_t AliAnalysisTaskPartonDisc::DeltaPhiSqMC(AliAODJet *jet, AliAODMCParticle *particle)
4497 {
4498   //
4499   // Get delta-phi^2 MC jet-track
4500   //
4501
4502   Double_t deltaphi = DeltaPhiMC(jet,particle);
4503   Double_t deltaphiSqMC = deltaphi*deltaphi;
4504   return deltaphiSqMC;
4505 }
4506 //________________________________________________________________________
4507 Double_t AliAnalysisTaskPartonDisc::DeltaEtaSqMC(AliAODJet *jet, AliAODMCParticle *particle)
4508 {
4509   //
4510   // Get delta-eta^2 MC jet-track
4511   //
4512
4513   Double_t deltaeta = DeltaEtaMC(jet,particle);
4514   Double_t deltaetaSqMC = deltaeta*deltaeta;
4515   return deltaetaSqMC;
4516 }
4517 //________________________________________________________________________
4518 Double_t AliAnalysisTaskPartonDisc::DeltaPhiTrack(AliAODJet *jet, AliAODTrack *track)
4519 {
4520   //
4521   // Get delta-phi Track jet-track
4522   //
4523
4524   // Double_t deltaphiTrack = jet->Phi() - track->Phi();
4525   // return deltaphiTrack;
4526
4527   Double_t deltaphi = jet->Phi() - track->Phi();
4528   if (deltaphi > TMath::Pi())
4529     deltaphi = 2.0 * TMath::Pi() - deltaphi;
4530   if (deltaphi < -TMath::Pi())
4531     deltaphi =  -deltaphi- 2.0 * TMath::Pi();
4532
4533   return deltaphi;
4534
4535
4536 }
4537 //________________________________________________________________________
4538 Double_t AliAnalysisTaskPartonDisc::DeltaEtaTrack(AliAODJet *jet, AliAODTrack *track)
4539 {
4540   //
4541   // Get delta-eta Track jet-track
4542   //
4543
4544   Double_t deltaetaTrack = jet->Eta() - track->Eta();
4545   return deltaetaTrack;
4546 }
4547 //________________________________________________________________________
4548 Double_t AliAnalysisTaskPartonDisc::DeltaPhiSqTrack(AliAODJet *jet, AliAODTrack *track)
4549 {
4550   //
4551   // Get delta-phi^2 Track jet-track
4552   //
4553
4554   Double_t deltaphi = DeltaPhiTrack(jet,track);
4555   Double_t deltaphiSqTrack = deltaphi*deltaphi;
4556   return deltaphiSqTrack;
4557 }
4558 //________________________________________________________________________
4559 Double_t AliAnalysisTaskPartonDisc::DeltaEtaSqTrack(AliAODJet *jet, AliAODTrack *track)
4560 {
4561   //
4562   // Get delta-eta^2 Track jet-track
4563   //
4564
4565   Double_t deltaeta = DeltaEtaTrack(jet,track);
4566   Double_t deltaetaSqTrack = deltaeta*deltaeta;
4567   return deltaetaSqTrack;
4568 }
4569 //_________________________________________________________________________
4570 Bool_t AliAnalysisTaskPartonDisc::NumberOfReadEventsAOD(const char* currFile, Int_t &fNEvents)
4571 {
4572   //
4573   // get the number of events read out to create this AOD
4574   // from the njets distribution from UA1
4575   // This is to called in Notify and should provide the path to the AOD/ESD file
4576   // code from AliAnalysisTaskJetSpectrum2
4577
4578   TString file(currFile);
4579   fNEvents = 1;
4580
4581   if(file.Contains("root_archive.zip#"))
4582     {
4583       Ssiz_t pos1 = file.Index("root_archive",12,TString::kExact);
4584       Ssiz_t pos = file.Index("#",1,pos1,TString::kExact);
4585       file.Replace(pos+1,20,"");
4586     }
4587   else
4588     {
4589       // not an archive take the basename....
4590       file.ReplaceAll(gSystem->BaseName(file.Data()),"");
4591     }
4592   Printf("%s",file.Data());
4593
4594   TFile *fnev = TFile::Open(Form("%s%s",file.Data(),"PWG4_JetTasksOutput.root"));
4595   if(!fnev)
4596     {
4597       return kFALSE;
4598     } // no PWG4_JetTasksOutput.root
4599   else
4600     {
4601       TList *list;
4602       gDirectory->GetObject("PWG4_jethist_aodmc_ua104/jethist_aodmc_ua104;1",list);
4603       if(!list)
4604         {
4605           fnev->Close();
4606           return kFALSE;
4607         }
4608       fNEvents = ((TH1*)list->FindObject("NJetsH"))->GetEntries();
4609       fnev->Close();
4610     }
4611   return kTRUE;
4612 }
4613 //___________________________________________________________________________
4614 void AliAnalysisTaskPartonDisc::HasOverlapedCones(TClonesArray *JetArray)
4615 {
4616   //
4617   // Check if there are jet cones that overlap on the current event
4618   // for UA1 and SISCone, based on the cone axis and the radius.
4619   // There can be maximum 7.85 jet in the phi acceptance, with no overlap in
4620   // the phi direction (2pi/0.8).
4621   // Plus there can be up to two jets in contained in the eta acceptance,
4622   // if they are centered in -0.5 and 0.5 respectively, per phi interval
4623   // In total there can be up to 15.7 jets
4624   // Check up to 16 jets, inside the acceptance,
4625   // set the flags for up to those 8 jets.
4626   //
4627
4628   // Now also check if there is a perpendicular area to the leading jet
4629   // that does not contain a jet, if so, set a flag to kTRUE
4630   // Possibility to remove single track jets if there are track references
4631
4632   fJetEvent=kFALSE;
4633   fHasPerpCone=kTRUE;
4634   fEtaPerpCoord=0.0;
4635   fPhiPerpCoord=0.0;
4636   fPtPerpCoord=0.0;
4637
4638   ResetJetFlags(); // reset the flags
4639
4640   Int_t njets = JetArray->GetEntries();
4641   Int_t maxNjets = 16;
4642   Double_t etaCoordinates[16]={0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0};
4643   Double_t phiCoordinates[16]={0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0};
4644
4645   for (Int_t idxj = 0; idxj < njets; idxj++)
4646     {
4647       if(idxj>15)
4648         continue;  //maximum 16 jets
4649
4650       AliAODJet *currentJet = dynamic_cast<AliAODJet*>(JetArray->At(idxj));
4651       if (!currentJet)
4652         {
4653           AliDebug(2,Form("ERROR: Could not receive jet %d \n", idxj));
4654           continue;
4655         }
4656       // Store the axis coordinates of all sixteen jets
4657       etaCoordinates[idxj]=currentJet->Eta();
4658       phiCoordinates[idxj]=currentJet->Phi();
4659     }  //end of first cycle
4660
4661   // Ahora checar que no tengan overlap
4662   Double_t deltaeta = 0.0;
4663   Double_t deltaphi = 0.0;
4664   Double_t deltar = 0.0;
4665   Int_t currentIdxJet = 0;
4666   Int_t trkinjet = 0;
4667
4668   for (Int_t inxoj = 0; inxoj < maxNjets; inxoj++)
4669     {
4670       // only check up to the number of found jets in the event
4671       if(inxoj==njets)
4672         break;
4673
4674       // Optional RefTracks check for single track jets
4675       if(fForceSkipSJ)
4676         {
4677           AliAODJet *currentJet = dynamic_cast<AliAODJet*>(JetArray->At(inxoj));
4678           if (!currentJet)
4679             {
4680               AliDebug(2,Form("ERROR: Could not receive jet %d \n", inxoj));
4681               continue;
4682             }
4683           trkinjet = currentJet->GetRefTracks()->GetEntriesFast();
4684           if(trkinjet==1) // si tiene 1 solo track se marca como malo
4685             {
4686               fJetFlags[inxoj]=kFALSE;
4687               continue;
4688             }
4689         } // end of skip of single track jets condition
4690
4691       // First check if the current jet has its axis inside acceptance
4692       if(!(TMath::Abs(etaCoordinates[inxoj])<=fJetAcceptance)) //
4693         {
4694           fJetFlags[inxoj]=kFALSE;
4695           continue;
4696         }
4697       currentIdxJet = inxoj;
4698       //Check this jet with the rest of the jets
4699       for (Int_t idx2 = 0; idx2 < maxNjets; idx2++)
4700         {
4701           if(idx2==njets) // just check the number of found jets
4702             break;
4703
4704           if(currentIdxJet==idx2) // if the same jet
4705             continue;
4706           if(!fJetFlags[idx2]) // if the other jet is already not usable
4707             continue;
4708           if(!(TMath::Abs(etaCoordinates[idx2])<=fJetAcceptance)) // if the jet is outside acceptance
4709             continue;
4710           deltaeta = etaCoordinates[currentIdxJet]-etaCoordinates[idx2];
4711           deltaphi = phiCoordinates[currentIdxJet]-phiCoordinates[idx2];
4712           if (deltaphi > TMath::Pi())
4713             deltaphi = 2.0 * TMath::Pi() - deltaphi;
4714           deltar = sqrt(deltaeta*deltaeta+deltaphi*deltaphi);
4715           if(deltar<=2.0*fJetRadius) // if the distance between jet axis is less than 2r with any jet, mark as not usable
4716             {
4717               fJetFlags[currentIdxJet]=kFALSE;
4718               fJetFlags[idx2]=kFALSE; // both jets are not usable
4719               // if(fEnablePrints)
4720               //        {
4721               //          printf("Rejecting jet #:%i because it had overlap with jet #:%i \n",currentIdxJet, idx2);
4722               //          printf("Eta1:%f, Phi1:%f \n", etaCoordinates[currentIdxJet],phiCoordinates[currentIdxJet]);
4723               //          printf("Eta2:%f, Phi2:%f \n", etaCoordinates[idx2],phiCoordinates[idx2]);
4724               //          printf("Current event number:%i \n",fEvtCount-1);
4725               //        }
4726             } // end of actual flagging
4727         } // end of checking the current jet with the rest
4728     } // end of loop over the jets of the branch
4729
4730   // Check if there is at least one accepted jet, so it makes sense to calculate the perpendicular cone
4731   Int_t accJets = 0;
4732   for (Int_t checkjets = 0; checkjets < maxNjets; checkjets++)
4733     {
4734       // only check up to the number of found jets in the event
4735       if(checkjets==njets)
4736         break;
4737       if(fJetFlags[checkjets]) // find the accepted leading jet in acceptance
4738         accJets++;
4739     }
4740   if(accJets>0)
4741     fJetEvent=kTRUE;
4742
4743   // Check for the leading jet on the event
4744   for (Int_t searchlead = 0; searchlead < maxNjets; searchlead++)
4745     {
4746       // only check up to the number of found jets in the event
4747       if(searchlead==njets)
4748         break;
4749       if(fJetFlags[searchlead]) // find the accepted leading jet in acceptance
4750         {
4751           // Phi + pi/2
4752           fPhiPerpCoord = phiCoordinates[searchlead] + 0.5*TMath::Pi();
4753           if(fPhiPerpCoord>2.0*TMath::Pi())
4754             fPhiPerpCoord = fPhiPerpCoord - 2.0*TMath::Pi();
4755           // Same eta
4756           fEtaPerpCoord = etaCoordinates[searchlead];
4757           // Now check if this cone overlaps with any found jet
4758           for (Int_t jets = 0; jets < maxNjets; jets++)
4759             {
4760               // only check up to the number of found jets in the event
4761               if(jets==njets)
4762                 break;
4763               // now check that this jet is not the same as the leading
4764               if(jets==searchlead)
4765                 continue;
4766
4767               deltaphi = phiCoordinates[jets]-fPhiPerpCoord;
4768               if (deltaphi > TMath::Pi())
4769                 deltaphi = 2.0 * TMath::Pi() - deltaphi;
4770               if(deltaphi<=2.0*fJetRadius) // if the distance between cone axis is less than 2r with any jet, mark as not usable
4771                 {
4772                   fHasPerpCone=kFALSE;
4773                 }
4774                 // }
4775             } // loop over accepted jets
4776           break; // done doing stuff with the leading
4777         } // if for the first accepted jet (leading)
4778     }
4779 }
4780 //_______________________________________________________________________
4781 void AliAnalysisTaskPartonDisc::ResetJetFlags()
4782 {
4783   //
4784   // Reset the flags used for tagging jets from the branches
4785   // Use before calling HasOverlapedCones(jetbranch)
4786   //
4787
4788   for(Int_t a=0; a<16;a++)
4789     {
4790       fJetFlags[a]=kTRUE;
4791     }
4792
4793 }
4794 //________________________________________________________________________
4795 Int_t AliAnalysisTaskPartonDisc::GetNMcChargedTracksAboveThreshold(AliAODJet *jet, Int_t ntracks, TClonesArray *mcarray, Double_t jr)
4796 {
4797   // Calculate the number of charged particles above threshold
4798   // inside this jet for the MC case
4799   // the threshold is fCurrentJetMinPtNT90
4800
4801   Int_t numberOfChargedTracks = 0;
4802   Int_t currentNumber = 0;
4803   Double_t jeteta = jet->Eta();
4804   Double_t jetphi = jet->Phi();
4805   Double_t jetpT = jet->Pt();
4806   Double_t tracketa = 0;
4807   Double_t trackphi = 0;
4808
4809   if(IsEqualRel(jetpT, 0.0)) //IsEqualRel(zval, 0.0) //jetpT==0
4810     return 0;
4811
4812   if(IsEqualRel(fCurrentJetMinPtNT90, 7000.)) // fCurrentJetMinPtNT90==7000.
4813     return 1000; //dummy val for debugging
4814
4815   Double_t randomNum = 0.;
4816
4817   for (Int_t iTracks = 0; iTracks < ntracks; iTracks++)
4818     {
4819       AliAODMCParticle *mctrack = (AliAODMCParticle*) mcarray->At(iTracks);
4820       if(!mctrack) continue;
4821       tracketa = mctrack->Eta();
4822       trackphi = mctrack->Phi();
4823       if(mctrack->Pt()<fCurrentJetMinPtNT90) continue;
4824       if(mctrack->IsPhysicalPrimary())
4825         {
4826           if(mctrack->Charge()!=0&&mctrack->Charge()!=-99)
4827             {
4828               if(GetDeltaR(jeteta, jetphi, tracketa, trackphi)<=jr)
4829                 {
4830                   randomNum = gRandom->Rndm();
4831                   if(randomNum<fJTrackRandomRejection) continue; //rechaza fJTrackRandomRejection
4832                   currentNumber++;
4833                 } // end if inside jet
4834             } // end charged
4835         } // end physical primary
4836     }   // end for tracks
4837
4838   numberOfChargedTracks = currentNumber;
4839   AliDebug(4,Form("Number of tracks above threshold MC was:%i, returning",numberOfChargedTracks));
4840   return numberOfChargedTracks;
4841
4842 }
4843 //________________________________________________________________________
4844   Int_t AliAnalysisTaskPartonDisc::GetRecalcNTXMc(Int_t percentage, AliAODJet *originaljet, Int_t ntracks, TClonesArray *mcarray, Double_t jr)
4845 {
4846   //
4847   // Calculate the number of charged particles necessary to
4848   // add the given percentage of the jet energy (transverse energy)
4849   // after background substraction, for the MC case
4850
4851   Int_t numberOfChargedTracks = 0;
4852   Int_t currentNumber = 0;
4853   Double_t jetpT = fBckgSbsJet[0]; //pT
4854   Double_t jeteta = fBckgSbsJet[1]; //eta
4855   Double_t jetphi = fBckgSbsJet[2]; //phi
4856   Double_t tracketa = 0;
4857   Double_t trackphi = 0;
4858   Int_t arraysize = 1000;
4859   Bool_t rfTrkFlag  = kFALSE;
4860
4861   if(IsEqualRel(jetpT, 0.0)) //IsEqualRel(jetpT, 0.0) //jetpT==0
4862     return 0;
4863
4864   // RefTracks
4865   Int_t trkinjet = originaljet->GetRefTracks()->GetEntriesFast();
4866   if(trkinjet!=0)
4867     rfTrkFlag = kTRUE;
4868   AliDebug(4,Form("Number of tracks in this mc jet by RefTracks:%i \n",trkinjet));
4869
4870   AllocateStaticContainer(arraysize);
4871   InitializeStaticContainer(arraysize);
4872
4873   Double_t randomNum = 0.;
4874
4875   if(!rfTrkFlag)  // if not track ref, check track by track
4876     {
4877       AliDebug(4,Form("Empty Track Refs (mc)!"));
4878       for (Int_t iTracks = 0; iTracks < ntracks; iTracks++)
4879         {
4880           AliAODMCParticle *mctrack = (AliAODMCParticle*) mcarray->At(iTracks);
4881           if(!mctrack) continue;
4882           tracketa = mctrack->Eta();
4883           trackphi = mctrack->Phi();
4884           if(mctrack->Pt()<fMinpTVal) continue; // pT cut, not using track refs
4885           if(mctrack->IsPhysicalPrimary())
4886             {
4887               if(mctrack->Charge()!=0&&mctrack->Charge()!=-99)
4888                 {
4889                   if(GetDeltaR(jeteta, jetphi, tracketa, trackphi)<=jr)
4890                     {
4891                       randomNum = gRandom->Rndm();
4892                       if(randomNum<fJTrackRandomRejection) continue; //rechaza fJTrackRandomRejection
4893                       currentNumber++;
4894                       fgContainer[currentNumber-1] = mctrack->Pt();  // save the current pt in the container
4895                     } // end if inside jet
4896                 } // end charged
4897             } // end physical primary
4898         }   // end for tracks
4899     } // end rfTrkFlag
4900
4901   if(rfTrkFlag)  // if track ref, use them
4902     {
4903       AliDebug(4,Form("Using Track Refs (mc)!"));
4904       for(Int_t ixt=0; ixt<trkinjet;ixt++)
4905         {
4906           AliAODMCParticle *vtrack = dynamic_cast<AliAODMCParticle*>(originaljet->GetRefTracks()->At(ixt));
4907           if(!vtrack) continue;
4908           if(vtrack->Charge()!=0&&vtrack->Charge()!=-99)
4909             {
4910               randomNum = gRandom->Rndm();
4911               if(randomNum<fJTrackRandomRejection) continue; //rechaza fJTrackRandomRejection
4912               currentNumber++;
4913               fgContainer[currentNumber-1] = vtrack->Pt();  // save the current pt in the container
4914             }
4915         } // end trk in jet
4916     } // end if trk ref
4917
4918   // sort the contents of the container
4919   SortArray(fgContainer,arraysize);
4920   // loop over the contents and count how many tracks are necessary to recover the percentage of the energy
4921   numberOfChargedTracks = TracksForPercentageRecalc(fgContainer, arraysize, percentage, jetpT); //este es el que tengo que modificar...
4922   AliDebug(4,Form("Number of tracks was:%i, returning",numberOfChargedTracks));
4923   return numberOfChargedTracks;
4924 }
4925 //________________________________________________________________________
4926 Int_t AliAnalysisTaskPartonDisc::TracksForPercentageRecalc(Double_t *array, Int_t arraysize, Int_t percentage, Double_t jetenergy)
4927 {
4928   //
4929   // Loop over the contents and count how many tracks are necessary to recover
4930   // the given percentage of the energy.
4931   // If all tracks did not sum the required fraction, it returns 500
4932   // this saves the minimum pT used, during the nt90 recalculation
4933   // after jet energy correction
4934
4935   AliDebug(4,Form("Re-calculating the number of tracks for a jet with corrected pT:%f \n",jetenergy));
4936   Double_t ptsum = 0;
4937   Double_t threshold = jetenergy*percentage/100;
4938   Int_t tracknummer=0;
4939   fCurrentJetMinPtNT90Recalc=7000.; //dummy value for debugging
4940   for(Int_t inverse=arraysize; inverse>0; inverse--)
4941     {
4942       ptsum= ptsum + array[inverse-1];
4943       if(inverse==arraysize) //if the highest value
4944         fMaxTrackPtInNTXR=array[inverse-1]; //saving the highest pT track value in the recalculation
4945       tracknummer++;
4946       fMinTrackPtInNTXR=array[inverse-1]; // this is the current lowest pT track used in the recalculation
4947       if(fIsPossibleToSubstBckg) //Store the value for the current jet, during recalculation
4948         fCurrentJetMinPtNT90Recalc=array[inverse-1];
4949       if(ptsum>=threshold)  // the threshold was reached
4950         break;
4951       if((inverse==1)&&(ptsum<threshold)) //if it was not possible to reach the threshold
4952         {
4953           tracknummer = 500;
4954           fCurrentJetMinPtNT90Recalc=7000.; //dummy values for debugging
4955         }
4956     }
4957
4958   AliDebug(4,"Done re-calculating the number of tracks, returning to main code \n");
4959   return tracknummer;
4960
4961 }
4962 //________________________________________________________________________
4963 Int_t AliAnalysisTaskPartonDisc::GetRecalcNMcChTrUpThr(AliAODJet *jet, Int_t ntracks, TClonesArray *mcarray, Double_t jr)
4964 {
4965   // Calculate the number of charged particles above threshold
4966   // inside this jet for the MC case
4967   // the threshold is fCurrentJetMinPtNT90Recalc
4968
4969   Int_t numberOfChargedTracks = 0;
4970   Int_t currentNumber = 0;
4971   Double_t jeteta = jet->Eta();
4972   Double_t jetphi = jet->Phi();
4973   Double_t jetpT = jet->Pt();
4974   Double_t tracketa = 0;
4975   Double_t trackphi = 0;
4976
4977   if(IsEqualRel(jetpT, 0.0)) //IsEqualRel(jetpT, 0.0) //jetpT==0
4978     return 0;
4979
4980   Double_t randomNum = 0.;
4981
4982   for (Int_t iTracks = 0; iTracks < ntracks; iTracks++)
4983     {
4984       AliAODMCParticle *mctrack = (AliAODMCParticle*) mcarray->At(iTracks);
4985       if(!mctrack) continue;
4986       tracketa = mctrack->Eta();
4987       trackphi = mctrack->Phi();
4988       if(mctrack->Pt()<fCurrentJetMinPtNT90Recalc) continue;
4989       if(mctrack->IsPhysicalPrimary())
4990         {
4991           if(mctrack->Charge()!=0&&mctrack->Charge()!=-99)
4992             {
4993               if(GetDeltaR(jeteta, jetphi, tracketa, trackphi)<=jr)
4994                 {
4995                   randomNum = gRandom->Rndm();
4996                   if(randomNum<fJTrackRandomRejection) continue; //rechaza fJTrackRandomRejection
4997                   currentNumber++;
4998                 } // end if inside jet
4999             } // end charged
5000         } // end physical primary
5001     }   // end for tracks
5002
5003   numberOfChargedTracks = currentNumber;
5004   AliDebug(4,Form("Recalculated number of tracks above threshold MC was:%i, returning",numberOfChargedTracks));
5005   return numberOfChargedTracks;
5006
5007 }
5008 //________________________________________________________________________
5009 Int_t AliAnalysisTaskPartonDisc::GetNRecChargedTracksAboveThreshold(AliAODJet *jet, Int_t ntracks, AliAODEvent *aode, Double_t jr)
5010 {
5011   //
5012   // Calculate the number of charged particles
5013   // above the threshold set by the NTX calculation
5014   // for the AOD track case, the threshold is fCurrentJetMinPtNT90
5015   // the fCurrentJetMinPtNT90 was set when calling the NTX method before
5016
5017   Int_t numberOfChargedTracks = 0;
5018   Int_t currentNumber = 0;
5019   Double_t jeteta = jet->Eta();
5020   Double_t jetphi = jet->Phi();
5021   Double_t jetpT = jet->Pt();
5022   Double_t tracketa = 0;
5023   Double_t trackphi = 0;
5024
5025   if(IsEqualRel(jetpT, 0.0)) //IsEqualRel(jetpT, 0.0) // jetpT==0
5026       return 0;
5027
5028   for (Int_t iTracks = 0; iTracks < ntracks; iTracks++)
5029     {
5030       AliAODTrack *aodtrack = aode->GetTrack(iTracks);
5031       if(!aodtrack) continue;
5032       tracketa = aodtrack->Eta();
5033       trackphi = aodtrack->Phi();
5034       if(GetDeltaR(jeteta, jetphi, tracketa, trackphi)<=jr)
5035         {
5036           if(!aodtrack->TestFilterBit(fFilterBit)) continue; //track filter selection
5037           if(!aodtrack->IsPrimaryCandidate()) continue; // only primaries
5038           if(aodtrack->Pt()<fCurrentJetMinPtNT90) continue;
5039           currentNumber++;
5040         } // end if inside jet
5041     } // end for tracks
5042
5043   numberOfChargedTracks = currentNumber;
5044   return numberOfChargedTracks;
5045 }
5046 //________________________________________________________________________
5047 Int_t AliAnalysisTaskPartonDisc::GetRecalcNTXRec(Int_t percentage,AliAODJet *originaljet, Int_t ntracks, AliAODEvent *aode, Double_t jr)
5048 {
5049   //
5050   // Calculate the number of charged particles necessary to
5051   // add the given percentage of the jet energy (transverse energy)
5052   // after pT recalculation, for the AOD track case
5053
5054   Int_t numberOfChargedTracks = 0;
5055   Int_t currentNumber = 0;
5056   Double_t jetpT = fBckgSbsJet[0]; //pT
5057   Double_t jeteta = fBckgSbsJet[1]; //eta
5058   Double_t jetphi = fBckgSbsJet[2]; //phi
5059   Double_t tracketa = 0;
5060   Double_t trackphi = 0;
5061   Int_t arraysize = 1000;
5062   Bool_t rfTrkFlag  = kFALSE;
5063
5064   if(IsEqualRel(jetpT, 0.0)) //IsEqualRel(jetpT, 0.0) //jetpT==0
5065     return 0;
5066
5067   // RefTracks
5068   Int_t trkinjet = originaljet->GetRefTracks()->GetEntriesFast();
5069   if(trkinjet!=0&&!fForceNotTR)
5070     rfTrkFlag = kTRUE;
5071   AliDebug(4,Form("Number of tracks in this reco jet by RefTracks:%i \n",trkinjet));
5072
5073   AllocateStaticContainer(arraysize);
5074   InitializeStaticContainer(arraysize);
5075   if(!rfTrkFlag)  // if not track ref, check track by track
5076     {
5077       AliDebug(4,Form("Empty Track Refs (reco)!"));
5078       for (Int_t iTracks = 0; iTracks < ntracks; iTracks++)
5079         {
5080           AliAODTrack *aodtrack = aode->GetTrack(iTracks);
5081           if(!aodtrack) continue;
5082           tracketa = aodtrack->Eta();
5083           trackphi = aodtrack->Phi();
5084           if(GetDeltaR(jeteta, jetphi, tracketa, trackphi)<=jr)
5085             {
5086               if(!aodtrack->TestFilterBit(fFilterBit)) continue; //track filter selection
5087               if(!aodtrack->IsPrimaryCandidate()) continue; // only primaries
5088               if(aodtrack->Pt()<fMinpTVal) continue; // pT cut, not using track refs
5089               currentNumber++;
5090               fgContainer[currentNumber-1] = aodtrack->Pt();  // save the current pt in the container
5091             } // end if inside jet
5092         } // end for tracks
5093     } // end of no track ref
5094
5095   if(rfTrkFlag)  // if track ref, use them
5096     {
5097       AliDebug(4,Form("Using Track Refs (reco)!"));
5098       for(Int_t ixt=0; ixt<trkinjet;ixt++)
5099         {
5100           AliVParticle *vtrack = dynamic_cast<AliVParticle*>(originaljet->GetRefTracks()->At(ixt));
5101           if(!vtrack) continue;
5102           // No further checks, all cuts should be in in the track refs
5103           if(vtrack->Charge()!=0&&vtrack->Charge()!=-99)
5104             {
5105               currentNumber++;
5106               fgContainer[currentNumber-1] = vtrack->Pt();  // save the current pt in the container
5107             }
5108         } // end trk in jet
5109     } // end if trk ref
5110
5111
5112   // sort the contents of the container
5113   SortArray(fgContainer,arraysize);
5114   // loop over the contents and count how many tracks are necessary to recover the percetage of the energy
5115   numberOfChargedTracks = TracksForPercentageRecalc(fgContainer, arraysize, percentage, jetpT);
5116   return numberOfChargedTracks;
5117 }
5118 //________________________________________________________________________
5119 Int_t AliAnalysisTaskPartonDisc::GetRecalcNRecChTrUpThr(AliAODJet *jet, Int_t ntracks, AliAODEvent *aode, Double_t jr)
5120 {
5121   //
5122   // Calculate the number of charged particles
5123   // above the threshold set by the NTX calculation
5124   // for the AOD track case, the threshold is fCurrentJetMinPtNT90Recalc
5125   // the fCurrentJetMinPtNT90Recalc was set when calling the NTX method before
5126
5127   Int_t numberOfChargedTracks = 0;
5128   Int_t currentNumber = 0;
5129   Double_t jeteta = jet->Eta();
5130   Double_t jetphi = jet->Phi();
5131   Double_t jetpT = jet->Pt();
5132   Double_t tracketa = 0;
5133   Double_t trackphi = 0;
5134
5135   if(IsEqualRel(jetpT, 0.0)) //IsEqualRel(jetpT, 0.0) // jetpT==0
5136       return 0;
5137
5138   for (Int_t iTracks = 0; iTracks < ntracks; iTracks++)
5139     {
5140       AliAODTrack *aodtrack = aode->GetTrack(iTracks);
5141       if(!aodtrack) continue;
5142       tracketa = aodtrack->Eta();
5143       trackphi = aodtrack->Phi();
5144       if(GetDeltaR(jeteta, jetphi, tracketa, trackphi)<=jr)
5145         {
5146           if(!aodtrack->TestFilterBit(fFilterBit)) continue; //track filter selection
5147           if(!aodtrack->IsPrimaryCandidate()) continue; // only primaries
5148           if(aodtrack->Pt()<fCurrentJetMinPtNT90Recalc) continue;
5149           currentNumber++;
5150         } // end if inside jet
5151     } // end for tracks
5152
5153   numberOfChargedTracks = currentNumber;
5154   return numberOfChargedTracks;
5155 }
5156 //________________________________________________________________________
5157 Bool_t AliAnalysisTaskPartonDisc::IsTrackInsideExcludedArea(Double_t tracketa, Double_t trackphi, TClonesArray *recojetsA)
5158 {
5159   //
5160   // Check if these track coordinates are in an excluded area
5161   //
5162
5163   //Primero: checar si esta dentro de cualquier jet, no importa si esta dentro de la
5164   //aceptancia o no(en base al eje), aun podria haber tracks del jet dentro del
5165   //evento.
5166   Int_t numbRecJ =  recojetsA->GetEntries();
5167   Double_t etaCurrJet = 0.0;
5168   Double_t phiCurrJet = 0.0;
5169   Double_t deltaeta = 0.0;
5170   Double_t deltaphi = 0.0;
5171   Double_t deltar = 0.0;
5172   Double_t extendedRadius = fJetRadius+fIncExcR;
5173   Double_t extendedRadiusDiJet = 0.0;
5174   Double_t phiCurrJetExArL = 0.0; // preliminary left boundary of exluded phi of current jet
5175   Double_t phiCurrJetExArR = 0.0; // preliminary right boundary of exluded phi of current jet
5176   Double_t leftBoundary = 0.0;
5177   Double_t rightBoundary = 0.0;
5178
5179   if(fNotExtDiJEx)
5180     extendedRadiusDiJet = fJetRadius;  // old behaviour
5181   if(!fNotExtDiJEx)
5182     extendedRadiusDiJet = fJetRadius+fIncExcR;  // new behaviour
5183
5184   for (Int_t indxrec = 0; indxrec < numbRecJ; indxrec++)
5185     {
5186       AliDebug(4,Form("Number of current jet:%i \n",indxrec));
5187       AliAODJet *rjet = dynamic_cast<AliAODJet*>(recojetsA->At(indxrec));
5188       if (!rjet)
5189         {
5190           AliDebug(2,Form("ERROR: Could not receive jet %d\n", indxrec));
5191           continue;
5192         }
5193       etaCurrJet = rjet->Eta();
5194       phiCurrJet = rjet->Phi();
5195       deltaeta = etaCurrJet-tracketa;
5196       deltaphi = phiCurrJet-trackphi;
5197       if (deltaphi > TMath::Pi())
5198         deltaphi = 2.0 * TMath::Pi() - deltaphi;
5199       deltar = sqrt(deltaeta*deltaeta+deltaphi*deltaphi);
5200       if(deltar<=extendedRadius) // if the track is inside the jet, reject (extended radius)
5201         {
5202           //      printf("Excluding track for being in the extended jet area. Eta:%f, Phi:%f, deltar=%f \n",tracketa,trackphi,deltar);
5203           return kTRUE;
5204         }
5205       // Now check if it is in the expected dijet area for the two hardest jets
5206       if(indxrec==0||indxrec==1) //two hardest jets in the event
5207         {
5208           //left boundary
5209           phiCurrJetExArL= phiCurrJet + TMath::Pi() - extendedRadiusDiJet;
5210           if(phiCurrJetExArL>TMath::TwoPi())
5211             phiCurrJetExArL=phiCurrJetExArL-TMath::TwoPi();
5212           //right boundary
5213           phiCurrJetExArR= phiCurrJet + TMath::Pi() + extendedRadiusDiJet;
5214           if(phiCurrJetExArR>TMath::TwoPi())
5215             phiCurrJetExArR=phiCurrJetExArR-TMath::TwoPi();
5216           // //Assign left and right boundary
5217           leftBoundary=phiCurrJetExArL;
5218           rightBoundary=phiCurrJetExArR;
5219           // now check if inside the excluded area
5220           if(trackphi>=leftBoundary&&trackphi<=rightBoundary)
5221             {
5222               // printf("Excluding track for being in di-jet excluded area!!! \n");
5223               // printf("phi of track:%f, left bound:%f, right bound:%f \n",trackphi,leftBoundary,rightBoundary);
5224               return kTRUE;
5225             }
5226         }
5227     }
5228   // Si sobrevive todos los tests, regresar kFALSE
5229   return kFALSE;
5230 }
5231 //________________________________________________________________________
5232 Double_t AliAnalysisTaskPartonDisc::GetV0ExcludedMultiplicity(TClonesArray *recojets)
5233 {
5234   //
5235   // Calculate the V0 MIP multiplicity that should be excluded due
5236   // to possible jet activity
5237   //
5238
5239   //Check if there is V0 info
5240   if(!fVZero)
5241     {
5242       AliDebug(2,"ERROR: There is not VZERO info in the AOD");
5243       //      printf("No hay objeto fVZero \n");
5244       return 0.0;
5245     }
5246
5247   Int_t numbRecJ =  recojets->GetEntries();
5248   Double_t phiCurrJet = 0.0;
5249   //Check if there are jets
5250   if(numbRecJ==0)
5251     {
5252       AliDebug(2,"ERROR: There are not jets in the event");
5253       return 0.0;
5254     }
5255
5256   //Flags for V0A sectors
5257   Bool_t removeS0cells = kFALSE;
5258   Bool_t removeS1cells = kFALSE;
5259   Bool_t removeS2cells = kFALSE;
5260   Bool_t removeS3cells = kFALSE;
5261   Bool_t removeS4cells = kFALSE;
5262   Bool_t removeS5cells = kFALSE;
5263   Bool_t removeS6cells = kFALSE;
5264   Bool_t removeS7cells = kFALSE;
5265   //Flags for V0C sectors
5266   Bool_t removeS0cellsV0C = kFALSE;
5267   Bool_t removeS1cellsV0C = kFALSE;
5268   Bool_t removeS2cellsV0C = kFALSE;
5269   Bool_t removeS3cellsV0C = kFALSE;
5270   Bool_t removeS4cellsV0C = kFALSE;
5271   Bool_t removeS5cellsV0C = kFALSE;
5272   Bool_t removeS6cellsV0C = kFALSE;
5273   Bool_t removeS7cellsV0C = kFALSE;
5274   //Excedent multiplicity in V0A, V0C and total
5275   Double_t excedentV0A = 0.0;
5276   Double_t excedentV0C = 0.0;
5277   Double_t excedentV0Total = 0.0;
5278   Double_t phiValLow = 0.0;
5279   Double_t phiValUp  = 0.0;
5280   Double_t extendedR = fJetRadius + fIncExcR;
5281
5282   for (Int_t indxrec = 0; indxrec < numbRecJ; indxrec++)
5283     {
5284       // Now check the two hardest jets
5285       if(indxrec==0||indxrec==1) //two hardest jets in the event
5286         {
5287           AliAODJet *rjet = dynamic_cast<AliAODJet*>(recojets->At(indxrec));
5288           if (!rjet)
5289             {
5290               AliDebug(2,Form("ERROR: Could not receive jet %d\n", indxrec));
5291               continue;
5292             }
5293           phiCurrJet = rjet->Phi();
5294
5295           //Get the excluded phi boundaries
5296           Double_t b1 = phiCurrJet  + TMath::Pi() - extendedR;
5297           Double_t b2  = phiCurrJet  + TMath::Pi() + extendedR;
5298           if(b1>TMath::TwoPi())
5299             b1 = b1 - TMath::TwoPi();
5300           if(b2>TMath::TwoPi())
5301             b2 = b2 - TMath::TwoPi();
5302
5303           phiValLow = b1;
5304           phiValUp = b2;
5305
5306           if(phiValLow>TMath::TwoPi()||phiValUp>TMath::TwoPi()||phiValLow<0.||phiValUp<0.)
5307             return 500.0;
5308
5309           // First V0A (EN EVE LA NUMERACION EMPIEZA EN 1...)
5310           // Cells in sector S0 ( 0    to  pi/4): 32,40,48,56
5311           // Cells in sector S1 ( pi/4 to  pi/2): 33,41,49,57
5312           // Cells in sector S2 ( pi/2 to 3pi/4): 34,42,50,58
5313           // Cells in sector S3 (3pi/4 to  pi  ): 35,43,51,59
5314           // Cells in sector S4 ( pi   to 5pi/4): 36,44,52,60
5315           // Cells in sector S5 (5pi/4 to 3pi/2): 37,45,53,61
5316           // Cells in sector S6 (3pi/2 to 7pi/4): 38,46,54,62
5317           // Cells in sector S7 (7pi/4 to 2pi  ): 39,47,55,63
5318
5319           //Check if falls in sector S0
5320           if(phiValLow>=(0.)&&phiValLow<=(1./4.*TMath::Pi()))
5321             removeS0cells = kTRUE;
5322           if(phiValUp>=(0.)&&phiValUp<=(1./4.*TMath::Pi()))
5323             removeS0cells = kTRUE;
5324           //Check if falls in sector S1
5325           if(phiValLow>=(1./4.*TMath::Pi())&&phiValLow<=(1./2.*TMath::Pi()))
5326             removeS1cells = kTRUE;
5327           if(phiValUp>=(1./4.*TMath::Pi())&&phiValUp<=(1./2.*TMath::Pi()))
5328             removeS1cells = kTRUE;
5329           //Check if falls in sector S2
5330           if(phiValLow>=(1./2.*TMath::Pi())&&phiValLow<=(3./4.*TMath::Pi()))
5331             removeS2cells = kTRUE;
5332           if(phiValUp>=(1./2.*TMath::Pi())&&phiValUp<=(3./4.*TMath::Pi()))
5333             removeS2cells = kTRUE;
5334           //Check if falls in sector S3
5335           if(phiValLow>=(3./4.*TMath::Pi())&&phiValLow<=(TMath::Pi()))
5336             removeS3cells = kTRUE;
5337           if(phiValUp>=(3./4.*TMath::Pi())&&phiValUp<=(TMath::Pi()))
5338             removeS3cells = kTRUE;
5339           //Check if falls in sector S4
5340           if(phiValLow>=(TMath::Pi())&&phiValLow<=(5./4.*TMath::Pi()))
5341             removeS4cells = kTRUE;
5342           if(phiValUp>=(TMath::Pi())&&phiValUp<=(5./4.*TMath::Pi()))
5343             removeS4cells = kTRUE;
5344           //Check if falls in sector S5
5345           if(phiValLow>=(5./4.*TMath::Pi())&&phiValLow<=(3./2.*TMath::Pi()))
5346             removeS5cells = kTRUE;
5347           if(phiValUp>=(5./4.*TMath::Pi())&&phiValUp<=(3./2.*TMath::Pi()))
5348             removeS5cells = kTRUE;
5349           //Check if falls in sector S6
5350           if(phiValLow>=(3./2.*TMath::Pi())&&phiValLow<=(7./4.*TMath::Pi()))
5351             removeS6cells = kTRUE;
5352           if(phiValUp>=(3./2.*TMath::Pi())&&phiValUp<=(7./4.*TMath::Pi()))
5353             removeS6cells = kTRUE;
5354           //Check if falls in sector S7
5355           if(phiValLow>=(7./4.*TMath::Pi())&&phiValLow<=(TMath::TwoPi()))
5356             removeS7cells = kTRUE;
5357           if(phiValUp>=(7./4.*TMath::Pi())&&phiValUp<=(TMath::TwoPi()))
5358             removeS7cells = kTRUE;
5359
5360           /////////////////////////////////////////////////////////////////////////////////
5361
5362           // Now V0C (EN EVE LA NUMERACION EMPIEZA EN 1...)
5363           // Cells in sector S0 ( pi/2 to 3pi/4): 0,8,16,24
5364           // Cells in sector S1 (3pi/4 to  pi  ): 1,9,17,25
5365           // Cells in sector S2 ( pi   to 5pi/4): 2,10,18,26
5366           // Cells in sector S3 (5pi/4 to 3pi/2): 3,11,19,27
5367           // Cells in sector S4 (3pi/2 to 7pi/4): 4,12,20,28
5368           // Cells in sector S5 (7pi/4 to 2pi  ): 5,13,21,29
5369           // Cells in sector S6 ( 0    to  pi/4): 6,14,22,30
5370           // Cells in sector S7 ( pi/4 to  pi/2): 7,15,23,31
5371
5372           //Check if falls in sector S0
5373           if(phiValLow>=(1./2.*TMath::Pi())&&phiValLow<=(3./4.*TMath::Pi()))
5374             removeS0cellsV0C = kTRUE;
5375           if(phiValUp>=(1./2.*TMath::Pi())&&phiValUp<=(3./4.*TMath::Pi()))
5376             removeS0cellsV0C = kTRUE;
5377           //Check if falls in sector S1
5378           if(phiValLow>=(3./4.*TMath::Pi())&&phiValLow<=(TMath::Pi()))
5379             removeS1cellsV0C = kTRUE;
5380           if(phiValUp>=(3./4.*TMath::Pi())&&phiValUp<=(TMath::Pi()))
5381             removeS1cellsV0C = kTRUE;
5382           //Check if falls in sector S2
5383           if(phiValLow>=(TMath::Pi())&&phiValLow<=(5./4.*TMath::Pi()))
5384             removeS2cellsV0C = kTRUE;
5385           if(phiValUp>=(TMath::Pi())&&phiValUp<=(5./4.*TMath::Pi()))
5386             removeS2cellsV0C = kTRUE;
5387           //Check if falls in sector S3
5388           if(phiValLow>=(5./4.*TMath::Pi())&&phiValLow<=(3./2.*TMath::Pi()))
5389             removeS3cellsV0C = kTRUE;
5390           if(phiValUp>=(5./4.*TMath::Pi())&&phiValUp<=(3./2.*TMath::Pi()))
5391             removeS3cellsV0C = kTRUE;
5392           //Check if falls in sector S4
5393           if(phiValLow>=(3./2.*TMath::Pi())&&phiValLow<=(7./4.*TMath::Pi()))
5394             removeS4cellsV0C = kTRUE;
5395           if(phiValUp>=(3./2.*TMath::Pi())&&phiValUp<=(7./4.*TMath::Pi()))
5396             removeS4cellsV0C = kTRUE;
5397           //Check if falls in sector S5
5398           if(phiValLow>=(7./4.*TMath::Pi())&&phiValLow<=(TMath::TwoPi()))
5399             removeS5cellsV0C = kTRUE;
5400           if(phiValUp>=(7./4.*TMath::Pi())&&phiValUp<=(TMath::TwoPi()))
5401             removeS5cellsV0C = kTRUE;
5402           //Check if falls in sector S6
5403           if(phiValLow>=(0.)&&phiValLow<=(1./4.*TMath::Pi()))
5404             removeS6cellsV0C = kTRUE;
5405           if(phiValUp>=(0.)&&phiValUp<=(1./4.*TMath::Pi()))
5406             removeS6cellsV0C = kTRUE;
5407           //Check if falls in sector S7
5408           if(phiValLow>=(1./4.*TMath::Pi())&&phiValLow<=(1./2.*TMath::Pi()))
5409             removeS7cellsV0C = kTRUE;
5410           if(phiValUp>=(1./4.*TMath::Pi())&&phiValUp<=(1./2.*TMath::Pi()))
5411             removeS7cellsV0C = kTRUE;
5412
5413           //      printf("phi del jet:%f, philow:%f, phiup:%f \n",phiCurrJet,phiValLow,phiValUp);
5414         } // end if leading jets (2)
5415     } // end jet loop
5416
5417   // printf("_________V0A____________\n");
5418   // printf("Status sector S0:%i \n",removeS0cells);
5419   // printf("Status sector S1:%i \n",removeS1cells);
5420   // printf("Status sector S2:%i \n",removeS2cells);
5421   // printf("Status sector S3:%i \n",removeS3cells);
5422   // printf("Status sector S4:%i \n",removeS4cells);
5423   // printf("Status sector S5:%i \n",removeS5cells);
5424   // printf("Status sector S6:%i \n",removeS6cells);
5425   // printf("Status sector S7:%i \n",removeS7cells);
5426   // printf("_______________________\n");
5427
5428   if(removeS0cells)
5429     excedentV0A = excedentV0A + fVZero->GetMultiplicity(32)+fVZero->GetMultiplicity(40)+fVZero->GetMultiplicity(48)+fVZero->GetMultiplicity(56);
5430   if(removeS1cells)
5431     excedentV0A = excedentV0A + fVZero->GetMultiplicity(33)+fVZero->GetMultiplicity(41)+fVZero->GetMultiplicity(49)+fVZero->GetMultiplicity(57);
5432   if(removeS2cells)
5433     excedentV0A = excedentV0A + fVZero->GetMultiplicity(34)+fVZero->GetMultiplicity(42)+fVZero->GetMultiplicity(50)+fVZero->GetMultiplicity(58);
5434   if(removeS3cells)
5435     excedentV0A = excedentV0A + fVZero->GetMultiplicity(35)+fVZero->GetMultiplicity(43)+fVZero->GetMultiplicity(51)+fVZero->GetMultiplicity(59);
5436   if(removeS4cells)
5437     excedentV0A = excedentV0A + fVZero->GetMultiplicity(36)+fVZero->GetMultiplicity(44)+fVZero->GetMultiplicity(52)+fVZero->GetMultiplicity(60);
5438   if(removeS5cells)
5439     excedentV0A = excedentV0A + fVZero->GetMultiplicity(37)+fVZero->GetMultiplicity(45)+fVZero->GetMultiplicity(53)+fVZero->GetMultiplicity(61);
5440   if(removeS6cells)
5441     excedentV0A = excedentV0A + fVZero->GetMultiplicity(38)+fVZero->GetMultiplicity(46)+fVZero->GetMultiplicity(54)+fVZero->GetMultiplicity(62);
5442   if(removeS7cells)
5443     excedentV0A = excedentV0A + fVZero->GetMultiplicity(39)+fVZero->GetMultiplicity(47)+fVZero->GetMultiplicity(55)+fVZero->GetMultiplicity(63);
5444
5445   // printf("________V0C____________\n");
5446   // printf("Status sector S0:%i \n",removeS0cellsV0C);
5447   // printf("Status sector S1:%i \n",removeS1cellsV0C);
5448   // printf("Status sector S2:%i \n",removeS2cellsV0C);
5449   // printf("Status sector S3:%i \n",removeS3cellsV0C);
5450   // printf("Status sector S4:%i \n",removeS4cellsV0C);
5451   // printf("Status sector S5:%i \n",removeS5cellsV0C);
5452   // printf("Status sector S6:%i \n",removeS6cellsV0C);
5453   // printf("Status sector S7:%i \n",removeS7cellsV0C);
5454   // printf("_______________________\n");
5455
5456   if(removeS0cellsV0C)
5457     excedentV0C = excedentV0C + fVZero->GetMultiplicity(0)+fVZero->GetMultiplicity(8)+fVZero->GetMultiplicity(16)+fVZero->GetMultiplicity(24);
5458   if(removeS1cellsV0C)
5459     excedentV0C = excedentV0C + fVZero->GetMultiplicity(1)+fVZero->GetMultiplicity(9)+fVZero->GetMultiplicity(17)+fVZero->GetMultiplicity(25);
5460   if(removeS2cellsV0C)
5461     excedentV0C = excedentV0C + fVZero->GetMultiplicity(2)+fVZero->GetMultiplicity(10)+fVZero->GetMultiplicity(18)+fVZero->GetMultiplicity(26);
5462   if(removeS3cellsV0C)
5463     excedentV0C = excedentV0C + fVZero->GetMultiplicity(3)+fVZero->GetMultiplicity(11)+fVZero->GetMultiplicity(19)+fVZero->GetMultiplicity(27);
5464   if(removeS4cellsV0C)
5465     excedentV0C = excedentV0C + fVZero->GetMultiplicity(4)+fVZero->GetMultiplicity(12)+fVZero->GetMultiplicity(20)+fVZero->GetMultiplicity(28);
5466   if(removeS5cellsV0C)
5467     excedentV0C = excedentV0C + fVZero->GetMultiplicity(5)+fVZero->GetMultiplicity(13)+fVZero->GetMultiplicity(21)+fVZero->GetMultiplicity(29);
5468   if(removeS6cellsV0C)
5469     excedentV0C = excedentV0C + fVZero->GetMultiplicity(6)+fVZero->GetMultiplicity(14)+fVZero->GetMultiplicity(22)+fVZero->GetMultiplicity(30);
5470   if(removeS7cellsV0C)
5471     excedentV0C = excedentV0C + fVZero->GetMultiplicity(7)+fVZero->GetMultiplicity(15)+fVZero->GetMultiplicity(23)+fVZero->GetMultiplicity(31);
5472
5473   excedentV0Total = excedentV0A+excedentV0C;
5474
5475   //  printf("La multiplicidad total en V0 es:%f, la multiplicidad excedente en V0A es:%f, y en V0C es:%f, la multiplicidad corregida es:%f \n",fVZero->GetMTotV0A()+fVZero->GetMTotV0C(),excedentV0A,excedentV0C,fVZero->GetMTotV0A()+fVZero->GetMTotV0C()-excedentV0Total);
5476
5477   return excedentV0Total;
5478 }
5479 //________________________________________________________________________
5480 Int_t AliAnalysisTaskPartonDisc::GetV0LikeExcludedMultMC(TClonesArray *mcjets, TClonesArray *mcparticles)
5481 {
5482   //
5483   // Calculate the V0 like multiplicity that should be excluded due
5484   // to possible jet activity in MC events
5485   //
5486
5487   Int_t nMcJets =  mcjets->GetEntries();
5488   Int_t tracksMC = mcparticles->GetEntriesFast();
5489   Double_t phiCurrJet = 0.0;
5490   //Check if there are jets
5491   if(nMcJets==0)
5492     {
5493       AliDebug(2,"ERROR: There are no MC jets in the event");
5494       return 0;
5495     }
5496   Int_t excludedMultV0Like = 0;
5497   Double_t trackphi=0.0;
5498   Double_t extendedR = fJetRadius + fIncExcR;
5499   for (Int_t indxMC = 0; indxMC < nMcJets; indxMC++)
5500     {
5501       // Now check the two hardest jets
5502       if(indxMC==0||indxMC==1) //two hardest jets in the event
5503         {
5504           AliAODJet *mcJet = dynamic_cast<AliAODJet*>(mcjets->At(indxMC));
5505           if (!mcJet)
5506             {
5507               AliDebug(2,Form("ERROR: Could not receive jet %d\n", indxMC));
5508               continue;
5509             }
5510           phiCurrJet = mcJet->Phi();
5511           //Get the excluded phi boundaries
5512           Double_t b1 = phiCurrJet  + TMath::Pi() - extendedR;
5513           Double_t b2  = phiCurrJet  + TMath::Pi() + extendedR;
5514           if(b1>TMath::TwoPi())
5515             b1 = b1 - TMath::TwoPi();
5516           if(b2>TMath::TwoPi())
5517             b2 = b2 - TMath::TwoPi();
5518           // now check the charged tracks in the V0 acceptance
5519           for(Int_t aodMCTrack = 0; aodMCTrack < tracksMC; aodMCTrack++ )
5520             {
5521               AliAODMCParticle *mctrackf = (AliAODMCParticle*) mcparticles->At(aodMCTrack);
5522               if(!mctrackf) continue;
5523               if(!mctrackf->IsPhysicalPrimary()) continue;
5524               if(mctrackf->Charge()==0||mctrackf->Charge()==-99) continue;
5525               if(mctrackf->Pt()<fMinpTValMC) continue; // cut off en MC
5526               trackphi = mctrackf->Phi();
5527               if(trackphi>=b1&&trackphi<=b2)
5528                 {
5529                   //V0A
5530                   if(((mctrackf->Eta())>(2.8))&&((mctrackf->Eta())<(5.1)))
5531                     excludedMultV0Like++;
5532                   //V0C
5533                   if(((mctrackf->Eta())>(-3.7))&&((mctrackf->Eta())<(-1.7)))
5534                     excludedMultV0Like++;
5535                 }
5536             }
5537         } // end of 2 hardest jets
5538     } // end jet loop
5539   return excludedMultV0Like;
5540 }
5541 //________________________________________________________________________
5542 void AliAnalysisTaskPartonDisc::FillPerpConeHisto(TH3F *currenthisto, Int_t ntracks, AliAODEvent *aode, Int_t CentralityBin, Int_t pTBin)
5543 {
5544
5545   // Fills the histrogram of the pT distribution in the perpendicular cone
5546
5547   Double_t aodtracketaC = 0.;
5548
5549   for(Int_t aodT = 0; aodT < ntracks; aodT++ )
5550     {
5551       AliAODTrack *aodtrackC = aode->GetTrack(aodT);
5552       if(!aodtrackC) continue;
5553       aodtracketaC = TMath::Abs(aodtrackC->Eta());
5554       if(aodtracketaC>0.9) continue;
5555       if(!aodtrackC->TestFilterBit(fFilterBit)) continue; //track filter selection
5556       if(!aodtrackC->IsPrimaryCandidate()) continue; // only primaries, maybe is redundant with the previous selection...
5557       if(fJetEvent) // if has an accepted jet, calculate the perpendicular cone
5558         {
5559           if(HasPerpendicularCone()) // If there is a perpendicular cone available
5560             {
5561               if(aodtrackC->Pt()>fMinpTVal)
5562                 {
5563                   if(GetDeltaR(fEtaPerpCoord,fPhiPerpCoord,aodtrackC->Eta(),aodtrackC->Phi())<fJetRadius)
5564                     {
5565                       currenthisto->Fill(aodtrackC->Pt(),pTBin,CentralityBin);
5566                     }
5567                 }
5568             }
5569         } // end if jet event
5570     }
5571 }
5572 //________________________________________________________________________
5573 Bool_t AliAnalysisTaskPartonDisc::IsEqualRel(Double_t vA, Double_t vB)
5574 {
5575   // Comparison of Double_t values
5576
5577   Double_t epsVal = 0.000001;
5578   return TMath::Abs(vA-vB) <= epsVal*TMath::Abs(vA);
5579
5580 }