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