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