]> git.uio.no Git - u/mrichter/AliRoot.git/blobdiff - PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskEmcalJetHadEPpid.cxx
changed binning for event pool, added more trigger QA histos, added more mixed event...
[u/mrichter/AliRoot.git] / PWGJE / EMCALJetTasks / UserTasks / AliAnalysisTaskEmcalJetHadEPpid.cxx
index 95846ff9b17c425d5a9001c285be39c3da582f51..f8d22a0ebe4ca9c21fc2ad4af245f16842fdd68c 100644 (file)
@@ -76,25 +76,30 @@ AliAnalysisTaskEmcalJetHadEPpid::AliAnalysisTaskEmcalJetHadEPpid() :
   fAreacut(0.0), fTrkBias(5), fClusBias(5), fTrkEta(0.9), 
   fJetPtcut(15.0), fJetRad(0.4), fConstituentCut(0.15),
   fesdTrackCuts(0),
-  fDoEventMixing(0), fMixingTracks(50000),
+  fDoEventMixing(0), fMixingTracks(50000), fNMIXtracks(5000), fNMIXevents(5),
+  fTriggerEventType(AliVEvent::kAny), fMixingEventType(AliVEvent::kAny),
   doPlotGlobalRho(0), doVariableBinning(0), dovarbinTHnSparse(0), 
   makeQAhistos(0), makeBIAShistos(0), makeextraCORRhistos(0), makeoldJEThadhistos(0),
   allpidAXIS(0), fcutType("EMCAL"), doPID(0), doPIDtrackBIAS(0),
-  doComments(0), doIOon(0),
+  doComments(0),
+  doFlavourJetAnalysis(0), fJetFlavTag(-99),
+  fBeam(kNA),
   fLocalRhoVal(0),
-  fTracksName(""), fJetsName(""),
+  fTracksName(""), fTracksNameME(""), fJetsName(""),
   event(0),
   isPItpc(0), isKtpc(0), isPtpc(0), // pid TPC
   isPIits(0), isKits(0), isPits(0), // pid ITS
   isPItof(0), isKtof(0), isPtof(0), // pid TOF
   fPoolMgr(0x0),
   fPIDResponse(0x0), fTPCResponse(),
-  fESD(0), fAOD(0),
-  fHistEventQA(0),
+  fESD(0), fAOD(0), fVevent(0),  
+  fHistEventQA(0), fHistEventSelectionQA(0),
+  fHistCentZvertGA(0), fHistCentZvertJE(0), fHistCentZvertMB(0), fHistCentZvertAny(0),
   fHistTPCdEdX(0), fHistITSsignal(0), //fHistTOFsignal(0),
   fHistRhovsCent(0), fHistNjetvsCent(0), fHistCentrality(0),
   fHistZvtx(0), fHistMult(0),
   fHistJetPhi(0), fHistTrackPhi(0),
+  fHistLocalRhoJetpt(0),
   fHistJetHaddPhiIN(0), fHistJetHaddPhiOUT(0), fHistJetHaddPhiMID(0),
   fHistJetHaddPhiBias(0), fHistJetHaddPhiINBias(0), fHistJetHaddPhiOUTBias(0), fHistJetHaddPhiMIDBias(0),
   fHistMEdPHI(0),
@@ -165,9 +170,6 @@ AliAnalysisTaskEmcalJetHadEPpid::AliAnalysisTaskEmcalJetHadEPpid() :
 
   SetMakeGeneralHistograms(kTRUE);
   
-  // define input and output slots here
-  if(doIOon > 0 ) DefineInput(0, TChain::Class());
-  if(doIOon > 0 ) DefineOutput(1, TList::Class());
 }
 
 //________________________________________________________________________
@@ -178,25 +180,30 @@ AliAnalysisTaskEmcalJetHadEPpid::AliAnalysisTaskEmcalJetHadEPpid(const char *nam
   fAreacut(0.0), fTrkBias(5), fClusBias(5), fTrkEta(0.9), 
   fJetPtcut(15.0), fJetRad(0.4), fConstituentCut(0.15),
   fesdTrackCuts(0),
-  fDoEventMixing(0), fMixingTracks(50000),
+  fDoEventMixing(0), fMixingTracks(50000), fNMIXtracks(5000), fNMIXevents(5),
+  fTriggerEventType(AliVEvent::kAny), fMixingEventType(AliVEvent::kAny),
   doPlotGlobalRho(0), doVariableBinning(0), dovarbinTHnSparse(0), 
   makeQAhistos(0), makeBIAShistos(0), makeextraCORRhistos(0), makeoldJEThadhistos(0),
   allpidAXIS(0), fcutType("EMCAL"), doPID(0), doPIDtrackBIAS(0),
-  doComments(0), doIOon(0),
+  doComments(0),
+  doFlavourJetAnalysis(0), fJetFlavTag(-99),
+  fBeam(kNA),
   fLocalRhoVal(0),
-  fTracksName(""), fJetsName(""),
+  fTracksName(""), fTracksNameME(""), fJetsName(""),
   event(0),
   isPItpc(0), isKtpc(0), isPtpc(0), // pid TPC
   isPIits(0), isKits(0), isPits(0), // pid ITS
   isPItof(0), isKtof(0), isPtof(0), // pid TOF
   fPoolMgr(0x0),
   fPIDResponse(0x0), fTPCResponse(),
-  fESD(0), fAOD(0),
-  fHistEventQA(0),
+  fESD(0), fAOD(0), fVevent(0),  
+  fHistEventQA(0), fHistEventSelectionQA(0),
+  fHistCentZvertGA(0), fHistCentZvertJE(0), fHistCentZvertMB(0), fHistCentZvertAny(0),
   fHistTPCdEdX(0), fHistITSsignal(0), //fHistTOFsignal(0),
   fHistRhovsCent(0), fHistNjetvsCent(0), fHistCentrality(0),
   fHistZvtx(0), fHistMult(0),
   fHistJetPhi(0), fHistTrackPhi(0),
+  fHistLocalRhoJetpt(0),
   fHistJetHaddPhiIN(0), fHistJetHaddPhiOUT(0), fHistJetHaddPhiMID(0),
   fHistJetHaddPhiBias(0), fHistJetHaddPhiINBias(0), fHistJetHaddPhiOUTBias(0), fHistJetHaddPhiMIDBias(0),
   fHistMEdPHI(0),
@@ -267,9 +274,6 @@ AliAnalysisTaskEmcalJetHadEPpid::AliAnalysisTaskEmcalJetHadEPpid(const char *nam
 
   SetMakeGeneralHistograms(kTRUE);
 
-  // define input and output slots here
-  if(doIOon > 0 ) DefineInput(0, TChain::Class());
-  if(doIOon > 0 ) DefineOutput(1, TList::Class());
 }
 
 //_______________________________________________________________________
@@ -303,17 +307,35 @@ void AliAnalysisTaskEmcalJetHadEPpid::UserCreateOutputObjects()
   fHistJetHaddPhiIN = new TH1F("fHistJetHaddPhiIN","Jet-Hadron #Delta#varphi IN PLANE", 128,-0.5*TMath::Pi(), 1.5*TMath::Pi());
   fHistJetHaddPhiOUT = new TH1F("fHistJetHaddPhiOUT","Jet-Hadron #Delta#varphi OUT PLANE",128,-0.5*TMath::Pi(), 1.5*TMath::Pi());
   fHistJetHaddPhiMID = new TH1F("fHistJetHaddPhiMID","Jet-Hadron #Delta#varphi MIDDLE of PLANE",128,-0.5*TMath::Pi(), 1.5*TMath::Pi());
-  
-  fHistEventQA = new TH1F("fHistEventQA", "Event Counter at checkpoints in code", 25, -0.5, 24.5);
+  fHistLocalRhoJetpt = new TH1F("fHistLocalRhoJetpt","Local Rho corrected Jet p_{T}", 50, -50, 200);
+
+  // Centrality and Zvertex distribution for various triggers - Event Mixing QA
+  fHistCentZvertGA = new TH2F("fHistCentZvertGA", "Centrality - Z-vertex distribution for GA trigger", 20, 0, 100, 10, -10, 10);
+  fOutput->Add(fHistCentZvertGA);
+  fHistCentZvertJE = new TH2F("fHistCentZvertJE", "Centrality - Z-vertex distribution for JE trigger", 20, 0, 100, 10, -10, 10);
+  fOutput->Add(fHistCentZvertJE);
+  fHistCentZvertMB = new TH2F("fHistCentZvertMB", "Centrality - Z-vertex distribution for MB trigger", 20, 0, 100, 10, -10, 10);
+  fOutput->Add(fHistCentZvertMB);
+  fHistCentZvertAny = new TH2F("fHistCentZvertAny", "Centrality - Z-vertex distribution for kAny trigger", 20, 0, 100, 10, -10, 10);
+  fOutput->Add(fHistCentZvertAny);
+
+  // Event QA histo  
+  fHistEventQA = new TH1F("fHistEventQA", "Event Counter at checkpoints in code", 20, 0.5, 20.5);
   SetfHistQAcounterLabels(fHistEventQA); 
   fOutput->Add(fHistEventQA);
+
+  // Event Selection QA histo
+  fHistEventSelectionQA = new TH1F("fHistEventSelectionQA", "Trigger Selection Counter", 20, 0.5, 20.5);
+  SetfHistEvtSelQALabels(fHistEventSelectionQA);
+  fOutput->Add(fHistEventSelectionQA);
+
   // add to output lists
   fOutput->Add(fHistNjetvsCent);
   fOutput->Add(fHistJetHaddPHI);
   fOutput->Add(fHistJetHaddPhiIN);
   fOutput->Add(fHistJetHaddPhiOUT);
   fOutput->Add(fHistJetHaddPhiMID);
+  fOutput->Add(fHistLocalRhoJetpt);
 
   // create histo's used for general QA
   if (makeQAhistos) {
@@ -570,7 +592,7 @@ void AliAnalysisTaskEmcalJetHadEPpid::UserCreateOutputObjects()
   UInt_t bitcode = 0;  // bit coded, see GetDimParamsPID() below
   UInt_t bitcodeCorr = 0; // bit coded, see GetDimparamsCorr() below
   bitcoded = 1<<0 | 1<<1 | 1<<2 | 1<<3 | 1<<4 | 1<<5 | 1<<6 | 1<<7 | 1<<8; // | 1<<9;
-  if(fDoEventMixing) {
+  //if(fDoEventMixing) {
     fhnJH = NewTHnSparseF("fhnJH", bitcoded);
   
     if(dovarbinTHnSparse){
@@ -579,32 +601,38 @@ void AliAnalysisTaskEmcalJetHadEPpid::UserCreateOutputObjects()
     }
        
     fOutput->Add(fhnJH);
-  }
+  //}
 
   bitcodeCorr = 1<<0 | 1<<1 | 1<<2 | 1<<3; // | 1<<4 | 1<<5;
   fhnCorr = NewTHnSparseFCorr("fhnCorr", bitcodeCorr);
   if(dovarbinTHnSparse) fhnCorr->GetAxis(1)->Set(nbinsjetPT, xlowjetPT);
-  fOutput->Add(fhnCorr);
-  
-/*
-  // for pp we need mult bins for event mixing. Create binning here, to also make a histogram from it
-  Int_t nCentralityBins  = 8;
-  Double_t centralityBins[9] = {0.0, 4., 9, 15, 25, 35, 55, 100.0,500.0};  
-  Double_t centralityBins[nCentralityBins+1];
-  for(Int_t ic=0; ic<nCentralityBins+1; ic++){
-    if(ic==nCentralityBins) centralityBins[ic]=500;
-    else centralityBins[ic]=10.0*ic; 
-  }
-*/
+  fOutput->Add(fhnCorr);  
 
-  // setup for Pb-Pb collisions
-  Int_t nCentralityBins  = 100;
-  Double_t centralityBins[nCentralityBins+1];
-  for(Int_t ic=0; ic<nCentralityBins; ic++){
-    centralityBins[ic]=1.0*ic;
+  /*
+    Double_t centralityBins[nCentralityBins+1];
+    for(Int_t ic=0; ic<nCentralityBins+1; ic++){
+      if(ic==nCentralityBins) centralityBins[ic]=500;
+      else centralityBins[ic]=10.0*ic; 
+    }
+  */
+
+  // set up centrality bins for mixed events
+  // for pp we need mult bins for event mixing. Create binning here, to also make a histogram from it
+  Int_t nCentralityBinspp = 8;
+  //Double_t centralityBinspp[nCentralityBinspp+1];
+  Double_t centralityBinspp[9] = {0.0, 4., 9, 15, 25, 35, 55, 100.0, 500.0};  
+
+  // Setup for Pb-Pb collisions
+  Int_t nCentralityBinsPbPb = 10; //100;
+  Double_t centralityBinsPbPb[nCentralityBinsPbPb+1];
+  for(Int_t ic=0; ic<nCentralityBinsPbPb; ic++){
+      centralityBinsPbPb[ic]=10.0*ic; //1.0*ic;
   }
 
-  fHistMult = new TH1F("fHistMult","multiplicity",nCentralityBins,centralityBins);
+  if(fBeam == 0) fHistMult = new TH1F("fHistMult","multiplicity",nCentralityBinspp,centralityBinspp);
+  if(fBeam == 1) fHistMult = new TH1F("fHistMult","multiplicity",nCentralityBinsPbPb,centralityBinsPbPb);
+  //if(AliAnalysisTaskEmcal::GetBeamType() == 0) fHistMult = new TH1F("fHistMult","multiplicity",nCentralityBinspp,centralityBinspp);
+  //if(AliAnalysisTaskEmcal::GetBeamType() == 1) fHistMult = new TH1F("fHistMult","multiplicity",nCentralityBinsPbPb,centralityBinsPbPb);
 //  fOutput->Add(fHistMult);
 
   // Event Mixing
@@ -613,7 +641,10 @@ void AliAnalysisTaskEmcalJetHadEPpid::UserCreateOutputObjects()
   Int_t nZvtxBins  = 5+1+5;
   Double_t vertexBins[] = { -10, -8, -6, -4, -2, 0, 2, 4, 6, 8, 10};
   Double_t* zvtxbin = vertexBins;
-  fPoolMgr = new AliEventPoolManager(poolsize, trackDepth, nCentralityBins, centralityBins, nZvtxBins, zvtxbin);
+  if(fBeam == 0) fPoolMgr = new AliEventPoolManager(poolsize, trackDepth, nCentralityBinspp, centralityBinspp, nZvtxBins, zvtxbin);
+  if(fBeam == 1) fPoolMgr = new AliEventPoolManager(poolsize, trackDepth, nCentralityBinsPbPb, centralityBinsPbPb, nZvtxBins, zvtxbin);
+//  if(GetBeamType() == 0) fPoolMgr = new AliEventPoolManager(poolsize, trackDepth, nCentralityBinspp, centralityBinspp, nZvtxBins, zvtxbin);
+//  if(GetBeamType() == 1) fPoolMgr = new AliEventPoolManager(poolsize, trackDepth, nCentralityBinsPbPb, centralityBinsPbPb, nZvtxBins, zvtxbin);
 
   // set up event mixing sparse
   if(fDoEventMixing){
@@ -648,7 +679,7 @@ void AliAnalysisTaskEmcalJetHadEPpid::UserCreateOutputObjects()
     // *****************************************************************************************
 
     // PID counter
-    fHistPID = new TH1F("fHistPID","PID Counter",15, 0, 15.0);
+    fHistPID = new TH1F("fHistPID","PID Counter", 15, 0.5, 15.5);
     SetfHistPIDcounterLabels(fHistPID);
     fOutput->Add(fHistPID);
 
@@ -709,14 +740,40 @@ void AliAnalysisTaskEmcalJetHadEPpid::ExecOnce()
 Bool_t AliAnalysisTaskEmcalJetHadEPpid::Run()
 { // Main loop called for each event
   // TEST TEST TEST TEST for OBJECTS!
+
   fHistEventQA->Fill(1); // All Events that get entered
 
-  if(!fLocalRho){
-    AliError(Form("Couldn't get fLocalRho object, try to get it from Event based on name\n"));
-    fLocalRho = GetLocalRhoFromEvent(fLocalRhoName);
-    if(!fLocalRho) return kTRUE;
-  }
+  UInt_t trig = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
+  if(trig == 0) fHistEventSelectionQA->Fill(1);
+  if(trig & AliVEvent::kAny) fHistEventSelectionQA->Fill(2);
+  if(trig & AliVEvent::kAnyINT) fHistEventSelectionQA->Fill(3);
+  if(trig & AliVEvent::kMB) fHistEventSelectionQA->Fill(4);
+  if(trig & AliVEvent::kINT7) fHistEventSelectionQA->Fill(5);
+  if(trig & AliVEvent::kEMC1) fHistEventSelectionQA->Fill(6);
+  if(trig & AliVEvent::kEMC7) fHistEventSelectionQA->Fill(7);
+  if(trig & AliVEvent::kEMC8) fHistEventSelectionQA->Fill(8);
+  if(trig & AliVEvent::kEMCEJE) fHistEventSelectionQA->Fill(9);
+  if(trig & AliVEvent::kEMCEGA) fHistEventSelectionQA->Fill(10);
+  if(trig & AliVEvent::kCentral) fHistEventSelectionQA->Fill(11);
+  if(trig & AliVEvent::kSemiCentral) fHistEventSelectionQA->Fill(12);
+  if(trig & AliVEvent::kINT8) fHistEventSelectionQA->Fill(13);
+
+  if(trig & (AliVEvent::kEMCEJE | AliVEvent::kMB)) fHistEventSelectionQA->Fill(14);
+  if(trig & (AliVEvent::kEMCEGA | AliVEvent::kMB)) fHistEventSelectionQA->Fill(15);
+  if(trig & (AliVEvent::kAnyINT | AliVEvent::kMB)) fHistEventSelectionQA->Fill(16);
+
+  if(trig & (AliVEvent::kEMCEJE & AliVEvent::kMB)) fHistEventSelectionQA->Fill(17);
+  if(trig & (AliVEvent::kEMCEGA & AliVEvent::kMB)) fHistEventSelectionQA->Fill(18);
+  if(trig & (AliVEvent::kAnyINT & AliVEvent::kMB)) fHistEventSelectionQA->Fill(19);
+
+  if(GetBeamType() == 1) {
+    if(!fLocalRho){
+      AliError(Form("Couldn't get fLocalRho object, try to get it from Event based on name\n"));
+      fLocalRho = GetLocalRhoFromEvent(fLocalRhoName);
+      if(!fLocalRho) return kTRUE;
+    }
+  } // check for LocalRho object if PbPb data
+
   if(!fTracks){
     AliError(Form("No fTracks object!!\n"));
     return kTRUE;
@@ -757,11 +814,16 @@ Bool_t AliAnalysisTaskEmcalJetHadEPpid::Run()
   Int_t centbin = GetCentBin(fCent);
   if (makeQAhistos) fHistCentrality->Fill(fCent); // won't be filled in pp collision (Keep this in mind!)
 
+  // BEAM TYPE enumerator: kNA = -1, kpp = 0, kAA = 1, kpA = 2
   // for pp analyses we will just use the first centrality bin
-  //if (centbin == -1) centbin = 0;
+  if(GetBeamType() == 0) if (centbin == -1) centbin = 0;
+  if(GetBeamType() == 1) if (centbin == -1) return kTRUE;
 
-  // apply cut to event on Centrality > 90%
-  if(fCent>90) return kTRUE;
+  // if we are on PbPb data do cut on centrality > 90%, else by default DON'T
+  if (GetBeamType() == 1) {
+    // apply cut to event on Centrality > 90%
+    if(fCent>90) return kTRUE;
+  }
 
   fHistEventQA->Fill(4);  // events after centrality check
 
@@ -791,6 +853,7 @@ Bool_t AliAnalysisTaskEmcalJetHadEPpid::Run()
   // initialize TClonesArray pointers to jets and tracks
   TClonesArray *jets = 0;
   TClonesArray *tracks = 0; 
+  TClonesArray *tracksME = 0;
 
   // get Tracks object
   tracks = dynamic_cast<TClonesArray*>(list->FindObject(fTracks));
@@ -799,6 +862,13 @@ Bool_t AliAnalysisTaskEmcalJetHadEPpid::Run()
     return kTRUE;
   } // verify existence of tracks
 
+  // get ME Tracks object
+  tracksME = dynamic_cast<TClonesArray*>(list->FindObject(fTracksNameME));
+  if (!tracksME) {
+    AliError(Form("Pointer to tracks %s == 0", fTracksNameME.Data()));
+    return kTRUE;
+  } // verify existence of tracks
+
   // get Jets object
   jets = dynamic_cast<TClonesArray*>(list->FindObject(fJets));
   if(!jets){
@@ -821,36 +891,37 @@ Bool_t AliAnalysisTaskEmcalJetHadEPpid::Run()
   // initialize track parameters
   Int_t iTT=-1;
   Double_t ptmax=-10;
+  Int_t NtrackAcc = 0;
+
+  fVevent = dynamic_cast<AliVEvent*>(InputEvent());
+  if (!fVevent) {
+    printf("ERROR: fVEvent not available\n");
+    return kTRUE;
+  }
+
+  // fill event mixing QA
+  if(trig & AliVEvent::kEMCEGA) fHistCentZvertGA->Fill(fCent, zVtx);
+  if(trig & AliVEvent::kEMCEJE) fHistCentZvertJE->Fill(fCent, zVtx);
+  if(trig & AliVEvent::kMB) fHistCentZvertMB->Fill(fCent, zVtx);
+  if(trig & AliVEvent::kAny) fHistCentZvertAny->Fill(fCent, zVtx);
 
   // loop over tracks - to get hardest track (highest pt)
   for (Int_t iTracks = 0; iTracks < Ntracks; iTracks++){
-       AliVTrack* track = static_cast<AliVTrack*>(tracks->At(iTracks));
-    if (!track) {
-      AliError(Form("Couldn't get VTrack track %d\n", iTracks));        
+    AliVParticle* Vtrack = static_cast<AliVParticle*>(tracks->At(iTracks)); 
+    if (!Vtrack) {
+      printf("ERROR: Could not receive track %d\n", iTracks);
       continue;
-    } // verify existence of tracks
-
-/* track quality cuts
-    if(!useAOD) {
-      AliESDtrack* esdtrack = fESD->GetTrack(iTracks);
-      if (!esdtrack) {
-        AliError(Form("Couldn't get ESD track %d\n", iTracks));
-        continue;
-      }
-
-      if(!fesdTrackCuts->AcceptTrack(esdtrack)) continue;
-      track = static_cast<AliVTrack*>(esdtrack);
-    }
-
-    if(useAOD) {
-         track = static_cast<AliVTrack*>(tracks->At(iTracks));
     }
-*/ // track quality cuts
+    
+    AliVTrack *track = dynamic_cast<AliVTrack*>(Vtrack);
+    if(!track) continue;
     
     // track cuts
     if(TMath::Abs(track->Eta())>0.9) continue;
     if(track->Pt()<0.15) continue;
     //iCount++;
+    NtrackAcc++;
+
     if(track->Pt()>ptmax){
       ptmax=track->Pt();             // max pT track
       iTT=iTracks;                   // trigger tracks
@@ -894,7 +965,10 @@ Bool_t AliAnalysisTaskEmcalJetHadEPpid::Run()
     if(!AcceptMyJet(jet)) continue;
 
     NjetAcc++;                     // # of accepted jets
-  
+
+    // if FlavourJetAnalysis, get desired FlavTag and check against Jet
+    if(doFlavourJetAnalysis) { if(!AcceptFlavourJet(jet, fJetFlavTag)) continue;}
+
     // use this to get total # of jets passing cuts in events!!!!!!!!
     if (makeQAhistos) fHistJetPhi->Fill(jet->Phi()); // Jet Phi histogram (filled)
 
@@ -915,11 +989,16 @@ Bool_t AliAnalysisTaskEmcalJetHadEPpid::Run()
      AliEmcalJet *jet = static_cast<AliEmcalJet*>(fJets->At(ijet));
      if (!jet) continue;
 
+     if (!(trig & fTriggerEventType)) continue;
+
         // (should probably be higher..., but makes a cut on jet pT)
      if (jet->Pt()<0.1) continue;
      // do we accept jet? apply jet cuts
      if (!AcceptMyJet(jet)) continue;
 
+     // if FlavourJetAnalysis, get desired FlavTag and check against Jet
+     if(doFlavourJetAnalysis) { if(!AcceptFlavourJet(jet, fJetFlavTag)) continue;}
+
      fHistEventQA->Fill(10); // accepted jets
 
      // check on lead jet
@@ -932,14 +1011,16 @@ Bool_t AliAnalysisTaskEmcalJetHadEPpid::Run()
      // initialize and calculate various parameters: pt, eta, phi, rho, etc...
      Double_t jetphi = jet->Phi();      // phi of jet
      NJETAcc++;   // # accepted jets
-     fLocalRhoVal = fLocalRho->GetLocalVal(jetphi, fJetRad); //GetJetRadius(0)); // get local rho value
      Double_t jeteta = jet->Eta();     // ETA of jet
      Double_t jetPt = -500; 
      Double_t jetPtGlobal = -500; 
-     //Double_t jetPtLocal = -500;            // initialize corr jet pt
+     Double_t jetPtLocal = -500;            // initialize corr jet pt
+     if(GetBeamType() == 1) {
+       fLocalRhoVal = fLocalRho->GetLocalVal(jetphi, fJetRad); //GetJetRadius(0)); // get local rho value
+       jetPtLocal = jet->Pt()-jet->Area()*fLocalRhoVal; // corrected pT of jet using Rho modulated for V2 and V3
+     }
      jetPt = jet->Pt();
      jetPtGlobal = jet->Pt()-jet->Area()*fRhoVal;  // corrected pT of jet from rho value
-     //jetPtLocal = jet->Pt()-jet->Area()*fLocalRhoVal; // corrected pT of jet using Rho modulated for V2 and V3
      Double_t dEP = -500;                    // initialize angle between jet and event plane
      dEP = RelativeEPJET(jetphi,fEPV0); // angle betweeen jet and event plane
 
@@ -998,39 +1079,19 @@ Bool_t AliAnalysisTaskEmcalJetHadEPpid::Run()
         // set up and fill Jet-Hadron Correction THnSparse
         Double_t CorrEntries[4] = {fCent, jet->Pt(), dEP, zVtx};
         fhnCorr->Fill(CorrEntries);    // fill Sparse Histo with Correction entries
+
+        if(GetBeamType() == 1) fHistLocalRhoJetpt->Fill(jetPtLocal);
       }
 
       // loop over all track for an event containing a jet with a pT>fJetPtCut  (15)GeV
       for (Int_t iTracks = 0; iTracks < Ntracks; ++iTracks) {
-/* track quality cuts
-
-        AliVTrack* track; 
-
-        if(!useAOD) {
-          AliESDtrack* esdtrack = fESD->GetTrack(iTracks);
-          if (!esdtrack) {
-            AliError(Form("Couldn't get ESD track %d\n", iTracks));
-            continue;
-          }
-
-          if(!fesdTrackCuts->AcceptTrack(esdtrack)) continue;
-          track = static_cast<AliVTrack*>(esdtrack);
-        }
-
-        if(useAOD) {
-             track = static_cast<AliVTrack*>(tracks->At(iTracks));
+        AliVParticle* Vtrackass = static_cast<AliVParticle*>(tracks->At(iTracks)); 
+        if (!Vtrackass) {
+          printf("ERROR: Could not receive track %d\n", iTracks);
+          continue;
         }
     
-        if (!track) {
-          AliError(Form("Couldn't get VTrack track %d\n", iTracks));        
-          continue;
-        } // verify existence of tracks
-
-*/ // track quality cuts 
-        AliVTrack* track = static_cast<AliVTrack*>(tracks->At(iTracks));
-//->GetTrack(iTracks);  
-         
-        //AliVTrack* track = static_cast<AliVTrack*>(tracks->At(iTracks));
+        AliVTrack *track = dynamic_cast<AliVTrack*>(Vtrackass);
         if (!track) {
           AliError(Form("Couldn't get AliVtrack %d\n", iTracks));
           continue;
@@ -1074,7 +1135,7 @@ Bool_t AliAnalysisTaskEmcalJetHadEPpid::Run()
           // set up and fill Jet-Hadron THnSparse
           Double_t triggerEntries[9] = {fCent, jet->Pt(), track->Pt(), deta, dphijh, dEP, zVtx, trCharge, leadjet};
           fhnJH->Fill(triggerEntries);    // fill Sparse Histo with trigger entries
-          
+
           // fill histo's
           if(makeQAhistos) fHistSEphieta->Fill(dphijh, deta); // single event distribution
           if (makeoldJEThadhistos) fHistJetHBias[centbin][iptjet][ieta]->Fill(dphijh,track->Pt());
@@ -1129,60 +1190,25 @@ Bool_t AliAnalysisTaskEmcalJetHadEPpid::Run()
 
 ///////////////////////////////////////
 
-         //AliAODTrack *trackAOD =  static_cast<AliAODTrack*>(track);
+          // get detector signals
+          dEdx = track->GetTPCsignal();
+          ITSsig = track->GetITSsignal();
+          TOFsig = track->GetTOFsignal();
 
-                //if (trackAOD) {
-         if (useAOD) {
-               AliAODTrack *trackAOD = fAOD->GetTrack(iTracks);
-            // get detector signals
-            dEdx = trackAOD->GetTPCsignal();
-            ITSsig = trackAOD->GetITSsignal();
-            TOFsig = trackAOD->GetTOFsignal();
-
-            // TPC nSigma's
-            nSigmaPion_TPC = fPIDResponse->NumberOfSigmasTPC(trackAOD,AliPID::kPion);
-            nSigmaKaon_TPC = fPIDResponse->NumberOfSigmasTPC(trackAOD,AliPID::kKaon);
-            nSigmaProton_TPC = fPIDResponse->NumberOfSigmasTPC(trackAOD,AliPID::kProton);
-
-            // TOF nSigma's
-            nSigmaPion_TOF = fPIDResponse->NumberOfSigmasTOF(trackAOD,AliPID::kPion);
-            nSigmaKaon_TOF = fPIDResponse->NumberOfSigmasTOF(trackAOD,AliPID::kKaon);
-            nSigmaProton_TOF = fPIDResponse->NumberOfSigmasTOF(trackAOD,AliPID::kProton);
-
-            // ITS nSigma's
-            nSigmaPion_ITS = fPIDResponse->NumberOfSigmasITS(trackAOD,AliPID::kPion);
-            nSigmaKaon_ITS = fPIDResponse->NumberOfSigmasITS(trackAOD,AliPID::kKaon);
-            nSigmaProton_ITS = fPIDResponse->NumberOfSigmasITS(trackAOD,AliPID::kProton);
-             } // end of AOD pid
-
-
-                 //if (!trackAOD) {
-          // get PID parameters, first check if AOD/ESD
-             if (!useAOD) {
-            AliESDtrack *trackESD = fESD->GetTrack(iTracks);
-                       //AliESDtrack *trackESD = static_cast<AliESDtrack*>(track);
-
-            // get detector signals
-            dEdx = trackESD->GetTPCsignal();
-            ITSsig = trackESD->GetITSsignal();
-            TOFsig = trackESD->GetTOFsignal();
-
-            // TPC nSigma's
-            nSigmaPion_TPC = fPIDResponse->NumberOfSigmasTPC(trackESD,AliPID::kPion);
-            nSigmaKaon_TPC = fPIDResponse->NumberOfSigmasTPC(trackESD,AliPID::kKaon);
-            nSigmaProton_TPC = fPIDResponse->NumberOfSigmasTPC(trackESD,AliPID::kProton);
-
-            // TOF nSigma's
-            nSigmaPion_TOF = fPIDResponse->NumberOfSigmasTOF(trackESD,AliPID::kPion);
-            nSigmaKaon_TOF = fPIDResponse->NumberOfSigmasTOF(trackESD,AliPID::kKaon);
-            nSigmaProton_TOF = fPIDResponse->NumberOfSigmasTOF(trackESD,AliPID::kProton);
-
-            // ITS nSigma's
-            nSigmaPion_ITS = fPIDResponse->NumberOfSigmasITS(trackESD,AliPID::kPion);
-            nSigmaKaon_ITS = fPIDResponse->NumberOfSigmasITS(trackESD,AliPID::kKaon);
-            nSigmaProton_ITS = fPIDResponse->NumberOfSigmasITS(trackESD,AliPID::kProton);
-             } // end of ESD pid
+          // TPC nSigma's
+          nSigmaPion_TPC = fPIDResponse->NumberOfSigmasTPC(track,AliPID::kPion);
+          nSigmaKaon_TPC = fPIDResponse->NumberOfSigmasTPC(track,AliPID::kKaon);
+          nSigmaProton_TPC = fPIDResponse->NumberOfSigmasTPC(track,AliPID::kProton);
+
+          // TOF nSigma's
+          nSigmaPion_TOF = fPIDResponse->NumberOfSigmasTOF(track,AliPID::kPion);
+          nSigmaKaon_TOF = fPIDResponse->NumberOfSigmasTOF(track,AliPID::kKaon);
+          nSigmaProton_TOF = fPIDResponse->NumberOfSigmasTOF(track,AliPID::kProton);
+
+          // ITS nSigma's
+          nSigmaPion_ITS = fPIDResponse->NumberOfSigmasITS(track,AliPID::kPion);
+          nSigmaKaon_ITS = fPIDResponse->NumberOfSigmasITS(track,AliPID::kKaon);
+          nSigmaProton_ITS = fPIDResponse->NumberOfSigmasITS(track,AliPID::kProton);
 
           // fill detector signal histograms
           if (makeQAhistos) fHistTPCdEdX->Fill(pt, dEdx);
@@ -1198,85 +1224,85 @@ Bool_t AliAnalysisTaskEmcalJetHadEPpid::Run()
           // check track has pT < 0.900 GeV  - use TPC pid
           if (pt<0.900 && dEdx>0) {
                nPIDtpc = 4;
-            nPID = 0.5;
+            nPID = 1;
 
             // PION check - TPC
             if (TMath::Abs(nSigmaPion_TPC)<2 && TMath::Abs(nSigmaKaon_TPC)>2 && TMath::Abs(nSigmaProton_TPC)>2 ){
               isPItpc = kTRUE;
               nPIDtpc = 1;
-              nPID=1.5;
+              nPID=2;
             }else isPItpc = kFALSE; 
 
             // KAON check - TPC
             if (TMath::Abs(nSigmaKaon_TPC)<2 && TMath::Abs(nSigmaPion_TPC)>3 && TMath::Abs(nSigmaProton_TPC)>2 ){
               isKtpc = kTRUE;
               nPIDtpc = 2;
-              nPID=2.5;
+              nPID=3;
             }else isKtpc = kFALSE;
 
             // PROTON check - TPC
             if (TMath::Abs(nSigmaProton_TPC)<2 && TMath::Abs(nSigmaPion_TPC)>3 && TMath::Abs(nSigmaKaon_TPC)>2 ){
               isPtpc = kTRUE;
               nPIDtpc = 3;
-              nPID=3.5;
+              nPID=4;
             }else isPtpc = kFALSE;
           }  // cut on track pT for TPC
 
           // check track has pT < 0.500 GeV - use ITS pid
           if (pt<0.500 && ITSsig>0) {
             nPIDits = 4;
-            nPID = 4.5;
+            nPID = 5;
 
             // PION check - ITS
             if (TMath::Abs(nSigmaPion_ITS)<2 && TMath::Abs(nSigmaKaon_ITS)>2 && TMath::Abs(nSigmaProton_ITS)>2 ){
               isPIits = kTRUE;
               nPIDits = 1; 
-                 nPID=5.5;
+                 nPID=6;
             }else isPIits = kFALSE;
 
             // KAON check - ITS
             if (TMath::Abs(nSigmaKaon_ITS)<2 && TMath::Abs(nSigmaPion_ITS)>3 && TMath::Abs(nSigmaProton_ITS)>2 ){
               isKits = kTRUE;
               nPIDits = 2;
-              nPID=6.5;
+              nPID=7;
             }else isKits = kFALSE;
 
             // PROTON check - ITS
             if (TMath::Abs(nSigmaProton_ITS)<2 && TMath::Abs(nSigmaPion_ITS)>3 && TMath::Abs(nSigmaKaon_ITS)>2 ){
               isPits = kTRUE;
               nPIDits = 3;
-                 nPID=7.5;
+                 nPID=8;
             }else isPits = kFALSE;
           }  // cut on track pT for ITS
 
           // check track has 0.900 GeV < pT < 2.500 GeV - use TOF pid
           if (pt>0.900 && pt<2.500 && TOFsig>0) {
                nPIDtof = 4;
-            nPID = 8.5;
+            nPID = 9;
 
             // PION check - TOF
             if (TMath::Abs(nSigmaPion_TOF)<2 && TMath::Abs(nSigmaKaon_TOF)>2 && TMath::Abs(nSigmaProton_TOF)>2 ){
               isPItof = kTRUE;
               nPIDtof = 1;
-              nPID=9.5;
+              nPID=10;
             }else isPItof = kFALSE;
 
             // KAON check - TOF
             if (TMath::Abs(nSigmaKaon_TOF)<2 && TMath::Abs(nSigmaPion_TOF)>3 && TMath::Abs(nSigmaProton_TOF)>2 ){
               isKtof = kTRUE;
               nPIDtof = 2;
-              nPID=10.5;
+              nPID=11;
             }else isKtof = kFALSE;
 
             // PROTON check - TOF
             if (TMath::Abs(nSigmaProton_TOF)<2 && TMath::Abs(nSigmaPion_TOF)>3 && TMath::Abs(nSigmaKaon_TOF)>2 ){
               isPtof = kTRUE;
               nPIDtof = 3;
-              nPID=11.5;
+              nPID=12;
             }else isPtof = kFALSE;
           }  // cut on track pT for TOF
 
-          if (nPID == -99) nPID = 13.5;
+          if (nPID == -99) nPID = 14;
              fHistPID->Fill(nPID);
 
           // PID sparse getting filled 
@@ -1334,7 +1360,13 @@ Bool_t AliAnalysisTaskEmcalJetHadEPpid::Run()
 
 // ***************************************************************************************************************
 // ******************************** Event MIXING *****************************************************************
-  TObjArray* tracksClone = CloneAndReduceTrackList(tracks); // TEST
+// ***************************************************************************************************************
+
+  // initialize object array of cloned picotracks
+  TObjArray* tracksClone = 0x0;
+  
+  // PbPb collisions - create cloned picotracks
+  //if(GetBeamType() == 1) tracksClone = CloneAndReduceTrackList(tracks); // TEST
 
   //Prepare to do event mixing
   if(fDoEventMixing>0){
@@ -1357,33 +1389,109 @@ Bool_t AliAnalysisTaskEmcalJetHadEPpid::Run()
     //    of 1./nMix can be applied.
 
     // mix jets from triggered events with tracks from MB events
-    // get the trigger bit
-    // need to change trigger bits between different runs
-//T    UInt_t trigger = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
-//T    if (trigger==0)  return kTRUE; // return
-
-    //Double_t Ntrks=(Double_t)Ntracks*1.0;
-    //cout<<"Test.. Ntrks: "<<fPoolMgr->GetEventPool(Ntrks);
+    // get the trigger bit, need to change trigger bits between different runs
+    UInt_t trigger = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
+    // if event was not selected (triggered) for any reseason (should never happen) then return
+    if (trigger==0)  return kTRUE;
+
+    // initialize event pools
+    AliEventPool* pool = 0x0;
+    AliEventPool* poolpp = 0x0;
+    Double_t Ntrks = -999;
+
+    // pp collisions - get event pool
+    if(GetBeamType() == 0) {
+      Ntrks=(Double_t)Ntracks*1.0;
+      //cout<<"Test.. Ntrks: "<<fPoolMgr->GetEventPool(Ntrks);
+      poolpp = fPoolMgr->GetEventPool(Ntrks, zVtx); // for pp
+    }
 
-    AliEventPool* pool = fPoolMgr->GetEventPool(fCent, zVtx); // for PbPb? fcent
-    //AliEventPool* pool = fPoolMgr->GetEventPool(Ntrks, zVtx); // for pp
+    // PbPb collisions - get event pool 
+    if(GetBeamType() == 1) pool = fPoolMgr->GetEventPool(fCent, zVtx); // for PbPb? fcent
 
-    if (!pool){
-      AliFatal(Form("No pool found for centrality = %f, zVtx = %f", fCent, zVtx));
-      //AliFatal(Form("No pool found for multiplicity = %f, zVtx = %f", Ntrks, zVtx));
+    // if we don't have a pool, return
+    if (!pool && !poolpp){
+      if(GetBeamType() == 1) AliFatal(Form("No pool found for centrality = %f, zVtx = %f", fCent, zVtx));
+      if(GetBeamType() == 0) AliFatal(Form("No pool found for multiplicity = %f, zVtx = %f", Ntrks, zVtx));
       return kTRUE;
     }
 
     fHistEventQA->Fill(15); // mixed events cases that have pool
 
+    // initialize background tracks array
+    TObjArray* bgTracks;
+
+    // next line might not apply for PbPb collisions
+    // use only jets from EMCal-triggered events (for lhc11a use AliVEvent::kEMC1)
+    //check for a trigger jet
+    // fmixingtrack/10 ??
+  if(GetBeamType() == 1) if(trigger & fTriggerEventType) { //kEMCEJE)) {     
+    if (pool->IsReady() || pool->NTracksInPool() > fNMIXtracks || pool->GetCurrentNEvents() >= fNMIXevents) {
+
+      // loop over jets (passing cuts?)
+      for (Int_t ijet = 0; ijet < Njets; ijet++) {
+        Double_t leadjet=0;
+        if (ijet==ijethi) leadjet=1;
+
+        // get jet object
+        AliEmcalJet *jet = static_cast<AliEmcalJet*>(jets->At(ijet));
+           if (!jet) continue;
+
+               // (should probably be higher..., but makes a cut on jet pT)
+       if (jet->Pt()<0.1) continue;
+       if (!AcceptMyJet(jet)) continue;
+
+        fHistEventQA->Fill(16); // event mixing jets
+               
+        // set cut to do event mixing only if we have a jet meeting our pt threshold (bias applied below)
+        if (jet->Pt()<fJetPtcut) continue;
+
+        // get number of current events in pool
+        Int_t nMix = pool->GetCurrentNEvents();  // how many particles in pool to mix
+
+          // Fill for biased jet triggers only
+        if ((jet->MaxTrackPt()>fTrkBias) || (jet->MaxClusterPt()>fClusBias)) {  // && jet->Pt() > fJetPtcut) {
+          // Fill mixed-event histos here  
+          for (Int_t jMix=0; jMix<nMix; jMix++) {
+                       fHistEventQA->Fill(17); // event mixing nMix                 
+
+                   // get jMix'th event
+                       bgTracks = pool->GetEvent(jMix);
+            const Int_t Nbgtrks = bgTracks->GetEntries();
+            for(Int_t ibg=0; ibg<Nbgtrks; ibg++) {
+              AliPicoTrack *part = static_cast<AliPicoTrack*>(bgTracks->At(ibg));
+              if(!part) continue;
+              if(TMath::Abs(part->Eta())>0.9) continue;
+              if(part->Pt()<0.15) continue;
+
+              Double_t DEta = part->Eta()-jet->Eta();                // difference in eta
+              Double_t DPhi = RelativePhi(jet->Phi(),part->Phi());   // difference in phi
+              Double_t dEP = RelativeEPJET(jet->Phi(),fEPV0);       // difference between jet and EP
+                     Double_t mixcharge = part->Charge();
+              //Double_t DR=TMath::Sqrt(DPhi*DPhi+DEta*DEta);      // difference in R
+                           
+              // create / fill mixed event sparse
+              Double_t triggerEntries[10] = {fCent,jet->Pt(),part->Pt(),DEta,DPhi,dEP,zVtx, mixcharge, leadjet}; //array for ME sparse
+              fhnMixedEvents->Fill(triggerEntries,1./nMix);   // fill Sparse histo of mixed events
+
+              fHistEventQA->Fill(18); // event mixing - nbgtracks
+              if(makeextraCORRhistos) fHistMEphieta->Fill(DPhi,DEta, 1./nMix);
+            } // end of background track loop
+          } // end of filling mixed-event histo's
+        } // end of check for biased jet triggers
+      } // end of jet loop
+    } // end of check for pool being ready
+  } // end EMC triggered loop
+
+//=============================================================================================================
+
     // use only jets from EMCal-triggered events (for lhc11a use AliVEvent::kEMC1)
 ///    if (trigger & AliVEvent::kEMC1) {
-//T    if (trigger & AliVEvent::kEMCEJE) {  // TEST
-      //check for a trigger jet
-      // fmixingtrack/10 ??
-      if (pool->IsReady() || pool->NTracksInPool() > fMixingTracks / 10 || pool->GetCurrentNEvents() >= 5) {
+    // pp collisions
+    if(GetBeamType() == 0) if(trigger & fTriggerEventType) { //kEMC1)) {     
+      if (poolpp->IsReady() || poolpp->NTracksInPool() > fNMIXtracks || poolpp->GetCurrentNEvents() >= fNMIXevents) {
+
         // loop over jets (passing cuts?)
-  
         for (Int_t ijet = 0; ijet < Njets; ijet++) {
           Double_t leadjet=0;
           if (ijet==ijethi) leadjet=1;
@@ -1398,51 +1506,78 @@ Bool_t AliAnalysisTaskEmcalJetHadEPpid::Run()
 
           fHistEventQA->Fill(16); // event mixing jets
 
-          Int_t nMix = pool->GetCurrentNEvents();  // how many particles in pool to mix
+          // set cut to do event mixing only if we have a jet meeting our pt threshold (bias applied below)
+                 if (jet->Pt()<fJetPtcut) continue;
 
-          if (jet->Pt()<fJetPtcut) continue;
+          // get number of current events in pool 
+          Int_t nMix = poolpp->GetCurrentNEvents();  // how many particles in pool to mix
 
           // Fill for biased jet triggers only
           if ((jet->MaxTrackPt()>fTrkBias) || (jet->MaxClusterPt()>fClusBias)) {  // && jet->Pt() > fJetPtcut) {
             // Fill mixed-event histos here  
             for (Int_t jMix=0; jMix<nMix; jMix++) {
-                               fHistEventQA->Fill(17); // event mixing nMix                 
-
-                TObjArray* bgTracks = pool->GetEvent(jMix);
-                const Int_t Nbgtrks = bgTracks->GetEntries();
-                for(Int_t ibg=0; ibg<Nbgtrks; ibg++) {
-                  AliPicoTrack *part = static_cast<AliPicoTrack*>(bgTracks->At(ibg));
-                  if(!part) continue;
-                  if(TMath::Abs(part->Eta())>0.9) continue;
-                  if(part->Pt()<0.15) continue;
-
-                  Double_t DEta = part->Eta()-jet->Eta();                // difference in eta
-                  Double_t DPhi = RelativePhi(jet->Phi(),part->Phi());   // difference in phi
-                  Double_t dEP = RelativeEPJET(jet->Phi(),fEPV0);           // difference between jet and EP
-                         Double_t mixcharge = part->Charge();
-                  //Double_t DR=TMath::Sqrt(DPhi*DPhi+DEta*DEta);      // difference in R
-                           
-                  Double_t triggerEntries[10] = {fCent,jet->Pt(),part->Pt(),DEta,DPhi,dEP,zVtx, mixcharge, leadjet}; //array for ME sparse
-                  fhnMixedEvents->Fill(triggerEntries,1./nMix);   // fill Sparse histo of mixed events
-                  
-                                 fHistEventQA->Fill(18); // event mixing - nbgtracks
-                  if(makeextraCORRhistos) fHistMEphieta->Fill(DPhi,DEta, 1./nMix);
-                } // end of background track loop
-             } // end of filling mixed-event histo's
+                         fHistEventQA->Fill(17); // event mixing nMix                 
+
+                     // get jMix'th event
+                         bgTracks = poolpp->GetEvent(jMix);
+              const Int_t Nbgtrks = bgTracks->GetEntries();
+              for(Int_t ibg=0; ibg<Nbgtrks; ibg++) {
+                AliPicoTrack *part = static_cast<AliPicoTrack*>(bgTracks->At(ibg));
+                if(!part) continue;
+                if(TMath::Abs(part->Eta())>0.9) continue;
+                if(part->Pt()<0.15) continue;
+
+                Double_t DEta = part->Eta()-jet->Eta();                // difference in eta
+                Double_t DPhi = RelativePhi(jet->Phi(),part->Phi());   // difference in phi
+                Double_t dEP = RelativeEPJET(jet->Phi(),fEPV0);             // difference between jet and EP
+                Double_t mixcharge = part->Charge();
+                //Double_t DR=TMath::Sqrt(DPhi*DPhi+DEta*DEta);      // difference in R
+
+                // create / fill mixed event sparse
+                Double_t triggerEntries[10] = {fCent,jet->Pt(),part->Pt(),DEta,DPhi,dEP,zVtx, mixcharge, leadjet}; //array for ME sparse
+                fhnMixedEvents->Fill(triggerEntries,1./nMix);   // fill Sparse histo of mixed events
+
+                fHistEventQA->Fill(18); // event mixing - nbgtracks
+                if(makeextraCORRhistos) fHistMEphieta->Fill(DPhi,DEta, 1./nMix);
+              } // end of background track loop
+            } // end of filling mixed-event histo's
           } // end of check for biased jet triggers
         } // end of jet loop
-      } // end of check for triggered jet
-//    } //end EMC triggered loop
+      } // end of check for pool being ready
+    } //end EMC triggered loop
 
+    // pp collisions
     // use only tracks from MB events (for lhc11a use AliVEvent::kMB)
 ///    if (trigger & AliVEvent::kMB) {
 //T    if (trigger & AliVEvent::kAnyINT){ // test
-      // create a list of reduced objects. This speeds up processing and reduces memory consumption for the event pool
-//T      TObjArray* tracksClone = CloneAndReduceTrackList(tracks);
+    if(GetBeamType() == 0) {
+
+      // use only tracks from MB events (for lhc11a use AliVEvent::kMB)
+      if(trigger & fMixingEventType) { //kMB) {
+
+        // create a list of reduced objects. This speeds up processing and reduces memory consumption for the event pool
+        tracksClone = CloneAndReduceTrackList(tracks);
+
+        // update pool if jet in event or not
+        poolpp->UpdatePool(tracksClone);
+
+      } // check on track from MB events
+    }
 
-      // update pool if jet in event or not
-      pool->UpdatePool(tracksClone);
-///    } // check on track from MB events
+    // PbPb collisions
+    if(GetBeamType() == 1) {
+      
+      // use only tracks from MB events
+      if(trigger & fMixingEventType) { //kMB) {
+
+        // create a list of reduced objects. This speeds up processing and reduces memory consumption for the event pool
+        tracksClone = CloneAndReduceTrackList(tracks);
+
+        // update pool if jet in event or not
+        pool->UpdatePool(tracksClone);
+
+      } // MB events
+    } // PbPb collisions
   } // end of event mixing
 
   // print some stats on the event
@@ -1451,8 +1586,8 @@ Bool_t AliAnalysisTaskEmcalJetHadEPpid::Run()
 
   if (doComments) {
     cout<<"Event #: "<<event<<"     Jet Radius: "<<fJetRad<<"     Constituent Pt Cut: "<<fConstituentCut<<endl;
-    cout<<"# of jets: "<<Njets<<"      Highest jet pt: "<<highestjetpt<<"     leading hadron pt: "<<leadhadronPT<<endl;
-    cout<<"# tracks: "<<Ntracks<<"      Highest track pt: "<<ptmax<<endl;
+    cout<<"# of jets: "<<Njets<<"      NjetAcc: "<<NjetAcc<<"      Highest jet pt: "<<highestjetpt<<"     leading hadron pt: "<<leadhadronPT<<endl;
+    cout<<"# tracks: "<<Ntracks<<"      NtrackAcc: "<<NtrackAcc<<"      Highest track pt: "<<ptmax<<endl;
     cout<<" =============================================== "<<endl;
   }
 
@@ -1700,51 +1835,19 @@ void AliAnalysisTaskEmcalJetHadEPpid::GetDimParams(Int_t iEntry, TString &label,
 
 //_________________________________________________
 // From CF event mixing code PhiCorrelations
-TObjArray* AliAnalysisTaskEmcalJetHadEPpid::CloneAndReduceTrackList(TObjArray* tracks)
+TObjArray* AliAnalysisTaskEmcalJetHadEPpid::CloneAndReduceTrackList(TObjArray* tracksME)
 {
   // clones a track list by using AliPicoTrack which uses much less memory (used for event mixing)
   TObjArray* tracksClone = new TObjArray;
   tracksClone->SetOwner(kTRUE);
 
-  //AliVParticle* particle = 
-  //Int_t nTrax = fESD->GetNumberOfTracks();
-  //cout << "nTrax " << nTrax <<endl;
-
-  // Need to test, not sure if this is working
-  // check whether aod or esd first
-  // what kind of event do we have: AOD or ESD?
-/*
-  Bool_t useAOD; 
-  if (dynamic_cast<AliAODEvent*>(InputEvent())) useAOD = kTRUE;
-  else useAOD = kFALSE;  
-
-  for (Int_t i = 0; i < nTrax; ++i) {
-    if(!useAOD) { // esd info already here
-      AliESDtrack* esdtrack = fESD->GetTrack(i);
-      if (!esdtrack) {
-        AliError(Form("Couldn't get ESD track %d\n", i));
-        continue;
-      }
-
-      if(!fesdTrackCuts->AcceptTrack(esdtrack)) continue;
-      const AliESDtrack *particle = static_cast<const AliESDtrack *>(esdtrack);
-      //AliESDtrack *particle = GetAcceptTrack(esdtrack);
-      if(!particle) continue;
-    }
-
-    if(useAOD) {
-      AliVParticle* particle = (AliVParticle*) tracks->At(i); 
-      if(!particle) continue;
-    }
-*/    
-
 // ===============================
 
 //      cout << "RM Hybrid track : " << i << "  " << particle->Pt() << endl;  
 
   //cout << "nEntries " << tracks->GetEntriesFast() <<endl;
-  for (Int_t i=0; i<tracks->GetEntriesFast(); i++) {         // AOD/general case
-    AliVParticle* particle = (AliVParticle*) tracks->At(i);  // AOD/general case
+  for (Int_t i=0; i<tracksME->GetEntriesFast(); i++) {         // AOD/general case
+    AliVParticle* particle = (AliVParticle*) tracksME->At(i);  // AOD/general case
     if(TMath::Abs(particle->Eta())>fTrkEta) continue;
     if(particle->Pt()<0.15)continue;
 
@@ -1997,26 +2100,28 @@ Int_t AliAnalysisTaskEmcalJetHadEPpid::AcceptMyJet(AliEmcalJet *jet) {
 void AliAnalysisTaskEmcalJetHadEPpid::SetfHistPIDcounterLabels(TH1* h) const
 {
     // fill the analysis summary histrogram, saves all relevant analysis settigns
-    h->GetXaxis()->SetBinLabel(1, "TPC: Unidentified"); // 0.5
-    h->GetXaxis()->SetBinLabel(2, "TPC: Pion"); // 1.5
-    h->GetXaxis()->SetBinLabel(3, "TPC: Kaon"); // 2.5
-    h->GetXaxis()->SetBinLabel(4, "TPC: Proton"); // 3.5
-    h->GetXaxis()->SetBinLabel(5, "ITS: Unidentified"); // 4.5
-    h->GetXaxis()->SetBinLabel(6, "ITS: Pion"); // 5.5
-    h->GetXaxis()->SetBinLabel(7, "ITS: Kaon"); // 6.5
-    h->GetXaxis()->SetBinLabel(8, "ITS: Proton"); // 7.5
-    h->GetXaxis()->SetBinLabel(9, "TOF: Unidentified"); // 8.5
-    h->GetXaxis()->SetBinLabel(10, "TOF: Pion"); // 9.5 
-    h->GetXaxis()->SetBinLabel(11, "TOF: Kaon"); // 10.5
-    h->GetXaxis()->SetBinLabel(12, "TOF: Proton"); // 11.5
-    h->GetXaxis()->SetBinLabel(14, "Unidentified tracks"); //13.5
-
+    h->GetXaxis()->SetBinLabel(1, "TPC: Unidentified");
+    h->GetXaxis()->SetBinLabel(2, "TPC: Pion");
+    h->GetXaxis()->SetBinLabel(3, "TPC: Kaon");
+    h->GetXaxis()->SetBinLabel(4, "TPC: Proton");
+    h->GetXaxis()->SetBinLabel(5, "ITS: Unidentified");
+    h->GetXaxis()->SetBinLabel(6, "ITS: Pion");
+    h->GetXaxis()->SetBinLabel(7, "ITS: Kaon");
+    h->GetXaxis()->SetBinLabel(8, "ITS: Proton");
+    h->GetXaxis()->SetBinLabel(9, "TOF: Unidentified");
+    h->GetXaxis()->SetBinLabel(10, "TOF: Pion"); 
+    h->GetXaxis()->SetBinLabel(11, "TOF: Kaon");
+    h->GetXaxis()->SetBinLabel(12, "TOF: Proton");
+    h->GetXaxis()->SetBinLabel(14, "Unidentified tracks");
+
+    // set x-axis labels vertically
+    h->LabelsOption("v");
 }
 
 //void AliAnalysisTaskEmcalJetHadEPpid::FillAnalysisSummaryHistogram() const
 void AliAnalysisTaskEmcalJetHadEPpid::SetfHistQAcounterLabels(TH1* h) const
 {
-    // fill the analysis summary histrogram, saves all relevant analysis settigns
+    // label bins of the analysis event summary
     h->GetXaxis()->SetBinLabel(1, "All events started"); 
     h->GetXaxis()->SetBinLabel(2, "object check"); 
     h->GetXaxis()->SetBinLabel(3, "aod/esd check"); 
@@ -2028,14 +2133,46 @@ void AliAnalysisTaskEmcalJetHadEPpid::SetfHistQAcounterLabels(TH1* h) const
     h->GetXaxis()->SetBinLabel(9, "after track/jet loop to get highest pt"); 
     h->GetXaxis()->SetBinLabel(10, "accepted jets"); 
     h->GetXaxis()->SetBinLabel(11, "jets meeting pt threshold"); 
-    h->GetXaxis()->SetBinLabel(12, "accepted tracks in events from trigger jet"); 
-    h->GetXaxis()->SetBinLabel(13, "after AliVEvent and fPIDResponse"); 
+    h->GetXaxis()->SetBinLabel(12, "accepted tracks in events w/ trigger jet"); 
+    h->GetXaxis()->SetBinLabel(13, "after AliVEvent & fPIDResponse"); 
     h->GetXaxis()->SetBinLabel(14, "events before event mixing"); 
-    h->GetXaxis()->SetBinLabel(15, "mixed events having a pool"); 
+    h->GetXaxis()->SetBinLabel(15, "mixed events w/ pool"); 
     h->GetXaxis()->SetBinLabel(16, "event mixing: jets"); 
     h->GetXaxis()->SetBinLabel(17, "event mixing: nMix"); 
     h->GetXaxis()->SetBinLabel(18, "event mixing: nbackground tracks"); 
     h->GetXaxis()->SetBinLabel(19, "event mixing: THE END"); 
+
+    // set x-axis labels vertically
+    h->LabelsOption("v");
+}
+
+void AliAnalysisTaskEmcalJetHadEPpid::SetfHistEvtSelQALabels(TH1* h) const
+{  
+    // label bins of the analysis trigger selection summary
+    h->GetXaxis()->SetBinLabel(1, "no trigger");
+    h->GetXaxis()->SetBinLabel(2, "kAny");
+    h->GetXaxis()->SetBinLabel(3, "kAnyINT");
+    h->GetXaxis()->SetBinLabel(4, "kMB");
+    h->GetXaxis()->SetBinLabel(5, "kINT7");
+    h->GetXaxis()->SetBinLabel(6, "kEMC1");
+    h->GetXaxis()->SetBinLabel(7, "kEMC7");
+    h->GetXaxis()->SetBinLabel(8, "kEMC8");
+    h->GetXaxis()->SetBinLabel(9, "kEMCEJE");
+    h->GetXaxis()->SetBinLabel(10, "kEMCEGA");
+    h->GetXaxis()->SetBinLabel(11, "kCentral");
+    h->GetXaxis()->SetBinLabel(12, "kSemiCentral");
+    h->GetXaxis()->SetBinLabel(13, "kINT8");
+    h->GetXaxis()->SetBinLabel(14, "kEMCEJE or kMB");
+    h->GetXaxis()->SetBinLabel(15, "kEMCEGA or kMB");
+    h->GetXaxis()->SetBinLabel(16, "kAnyINT or kMB");
+    h->GetXaxis()->SetBinLabel(17, "kEMCEJE & kMB");
+    h->GetXaxis()->SetBinLabel(18, "kEMCEGA & kMB");
+    h->GetXaxis()->SetBinLabel(19, "kAnyINT & kMB");
+
+
+    // set x-axis labels vertically
+    h->LabelsOption("v");
+    //h->LabelsDeflate("X");
 }
 
 //______________________________________________________________________
@@ -2125,4 +2262,48 @@ void AliAnalysisTaskEmcalJetHadEPpid::GetDimParamsCorr(Int_t iEntry, TString &la
    }// end of switch
 } // end of Correction (ME) sparse
 
+//________________________________________________________________________
+//Int_t AliAnalysisTaskEmcalJetHadEPpid::AcceptFlavourJet(AliEmcalJet* fljet, Int_t NUM, Int_t NUM2, Int_t NUM3) {
+Int_t AliAnalysisTaskEmcalJetHadEPpid::AcceptFlavourJet(AliEmcalJet* fljet, Int_t NUM) {
+  // Get jet if accepted for given flavour tag
+  // If jet not accepted return 0
+  if(!fljet) {
+    AliError(Form("%s:Jet not found",GetName()));
+    return 0;
+  }
+
+  Int_t flavNUM = -99;//, flavNUM2 = -99, flavNUM3 = -99; FIXME commented out to avoid compiler warning
+  flavNUM = NUM;
+  //flavNUM2 = NUM2;
+  //flavNUM3 = NUM3;
 
+/*
+  // from the AliEmcalJet class, the tagging enumerator
+  enum EFlavourTag{
+       kDStar = 1<<0, kD0 = 1<<1, 
+          kSig1 = 1<<2, kSig2 = 1<<3, 
+          kBckgrd1 = 1<<4, kBckgrd2 = 1<<5, kBckgrd3 = 1<<6
+  }; 
+  // bit 0 = no tag, bit 1 = Dstar, bit 2 = D0 and so forth...
+*/   
+
+  // get flavour of jet (if any)
+  Int_t flav = -999;
+  flav = fljet->GetFlavour();
+
+  // cases (for now..)
+  // 3 = electron rich, 5 = hadron (bkgrd) rich
+  // if flav < 1, its not tagged, so return kFALSE (0)
+  if(flav < 1) return 0;
+
+  // if flav is not equal to what we want then return kFALSE (0)
+  //if(flav != flavNUM && flav != flavNUM2 && flav != flavNUM3) return 0;
+  if(flav != flavNUM) return 0;  
+
+  // we have the flavour we want, so return kTRUE (1)
+  //if(flav == flavNUM || flav == flavNUM2 || flav == flavNUM3) return 1;
+  if(flav == flavNUM) return 1;
+
+  // we by default have a flavour tagged jet
+  return 1;
+}