Updates from Salvatore for Embedding

diff --git a/PWGJE/EMCALJetTasks/AliJetEmbeddingFromAODTask.cxx b/PWGJE/EMCALJetTasks/AliJetEmbeddingFromAODTask.cxx
index c1c86bab4298f02965a4d1cb1ebedb6666d762e3..ef5ba0dca7ae5ac9c7e71aee5638bacecbc8112a 100644 (file)
--- a/PWGJE/EMCALJetTasks/AliJetEmbeddingFromAODTask.cxx
+++ b/PWGJE/EMCALJetTasks/AliJetEmbeddingFromAODTask.cxx
@@ -6,8 +6,6 @@
 
 #include "AliJetEmbeddingFromAODTask.h"
 
-//#include <iostream>
-
 #include <TFile.h>
 #include <TTree.h>
 #include <TClonesArray.h>
@@ -15,6 +13,8 @@
 #include <TObjString.h>
 #include <TGrid.h>
 #include <TH2C.h>
+#include <TList.h>
+#include <TStreamerInfo.h>
 
 #include "AliVEvent.h"
 #include "AliAODTrack.h"
@@ -52,6 +52,7 @@ AliJetEmbeddingFromAODTask::AliJetEmbeddingFromAODTask() :
   fCurrentFileID(0),
   fCurrentAODFileID(-1),
   fCurrentAODFile(0),
+  fPicoTrackVersion(0),
   fAODHeader(0),
   fAODVertex(0),
   fAODTracks(0),
@@ -86,6 +87,7 @@ AliJetEmbeddingFromAODTask::AliJetEmbeddingFromAODTask(const char *name, Bool_t
   fCurrentFileID(0),
   fCurrentAODFileID(-1),
   fCurrentAODFile(0),
+  fPicoTrackVersion(0),
   fAODHeader(0),
   fAODVertex(0),
   fAODTracks(0),
@@ -182,6 +184,15 @@ Bool_t AliJetEmbeddingFromAODTask::OpenNextFile()
     return kFALSE;
   }
 
+  const TList *clist = fCurrentAODFile->GetStreamerInfoCache();
+  if(clist) {
+    TStreamerInfo *cinfo = static_cast<TStreamerInfo*>(clist->FindObject("AliPicoTrack"));
+    if(cinfo) 
+      fPicoTrackVersion = cinfo->GetClassVersion();
+    else
+      fPicoTrackVersion = 0;
+  }
+
   if (fQAhistos)
     fHistFileIDs->Fill(fCurrentFileID, fCurrentAODFileID);
   
@@ -319,10 +330,13 @@ void AliJetEmbeddingFromAODTask::Run()
              aodtrack->GetTrackPhiOnEMCal() < 190 * TMath::DegToRad())
            isEmc = kTRUE;
        }
-       else { /*not AOD mode, let's see if it is PicoTrack*/
+       else if (fPicoTrackVersion > 0) { /*not AOD mode, let's see if it is PicoTrack*/
          AliPicoTrack *ptrack = dynamic_cast<AliPicoTrack*>(track);
          if (ptrack) {
-           type = ptrack->GetTrackType();
+           if (fPicoTrackVersion >= 3)
+             type = ptrack->GetTrackType();
+           else
+             type = ptrack->GetLabel();
            isEmc = ptrack->IsEMCAL();
          }
        }
@@ -376,5 +390,7 @@ void AliJetEmbeddingFromAODTask::Run()
        AddCell(amp, cellNum, time);
       }
     }
+
+    AliDebug(2,Form("Added cells = %d, total cells = %d", fAddedCells, totalCells));
   }
 }

diff --git a/PWGJE/EMCALJetTasks/AliJetEmbeddingFromAODTask.h b/PWGJE/EMCALJetTasks/AliJetEmbeddingFromAODTask.h
index b29db549d287100743a3bf8a0a1b8dc08a993989..3555413139b8983551c9b42b2ba8e978d439f4ce 100644 (file)
--- a/PWGJE/EMCALJetTasks/AliJetEmbeddingFromAODTask.h
+++ b/PWGJE/EMCALJetTasks/AliJetEmbeddingFromAODTask.h
@@ -59,6 +59,7 @@ class AliJetEmbeddingFromAODTask : public AliJetModelBaseTask {
   Int_t          fCurrentFileID    ;//! Current file being processed (trough the event handler)
   Int_t          fCurrentAODFileID ;//! Current file ID
   TFile         *fCurrentAODFile   ;//! Current open file
+  Int_t          fPicoTrackVersion ;//! Version of the PicoTrack class (if any) in fCurrentAODFile
   AliVHeader    *fAODHeader        ;//! AOD header
   TClonesArray  *fAODVertex        ;//! AOD vertex
   TClonesArray  *fAODTracks        ;//! AOD track collection
@@ -70,6 +71,6 @@ class AliJetEmbeddingFromAODTask : public AliJetModelBaseTask {
   AliJetEmbeddingFromAODTask(const AliJetEmbeddingFromAODTask&);            // not implemented
   AliJetEmbeddingFromAODTask &operator=(const AliJetEmbeddingFromAODTask&); // not implemented
 
-  ClassDef(AliJetEmbeddingFromAODTask, 1) // Jet embedding from AOD task
+  ClassDef(AliJetEmbeddingFromAODTask, 2) // Jet embedding from AOD task
 };
 #endif

diff --git a/PWGJE/EMCALJetTasks/AliJetModelBaseTask.cxx b/PWGJE/EMCALJetTasks/AliJetModelBaseTask.cxx
index d8b28978d5906f13128824303fc4cfe1524b546f..e9a2139b388ef3b5643000af9b1bb43ad2b7a11c 100644 (file)
--- a/PWGJE/EMCALJetTasks/AliJetModelBaseTask.cxx
+++ b/PWGJE/EMCALJetTasks/AliJetModelBaseTask.cxx
@@ -147,13 +147,22 @@ void AliJetModelBaseTask::UserExec(Option_t *)
       fOutClusters->Delete();
   }
 
+  AliVCaloCells *tempCaloCells = 0;
+
   if (fCaloCells) {
     fAddedCells = 0;
-    if (!fCopyArray)
-      fCaloCells = static_cast<AliVCaloCells*>(fCaloCells->Clone(Form("%s_old",fCaloCells->GetName())));
+    if (!fCopyArray) {
+      tempCaloCells = fCaloCells;
+      fCaloCells = static_cast<AliVCaloCells*>(tempCaloCells->Clone(Form("%s_old",fCaloCells->GetName())));
+    }
   }
 
   Run();
+
+  if (fCaloCells) {
+    delete fCaloCells;
+    fCaloCells = tempCaloCells;
+  }
 }
 
 //________________________________________________________________________
@@ -285,7 +294,7 @@ Bool_t AliJetModelBaseTask::ExecOnce()
     }
   }
 
-if (!fGeom && (fClusters || fCaloCells)) {
+  if (!fGeom && (fClusters || fCaloCells)) {
     if (fGeomName.Length() > 0) {
       fGeom = AliEMCALGeometry::GetInstance(fGeomName);
       if (!fGeom)
@@ -346,6 +355,8 @@ void AliJetModelBaseTask::CopyCells()
   }
 
   fAddedCells = fCaloCells->GetNumberOfCells();
+
+  AliDebug(2, Form("%d cells from the PYTHIA event", fAddedCells));
 }
 
 //________________________________________________________________________

diff --git a/PWGJE/EMCALJetTasks/AliJetResponseMaker.cxx b/PWGJE/EMCALJetTasks/AliJetResponseMaker.cxx
index aafdd5e4dfdfbc7d033460f14d939ae4be5aabbe..d0b5e8d34b3913f7f53bd8d9c7cc97e7ce31bad6 100644 (file)
--- a/PWGJE/EMCALJetTasks/AliJetResponseMaker.cxx
+++ b/PWGJE/EMCALJetTasks/AliJetResponseMaker.cxx
@@ -18,114 +18,109 @@
 #include "AliGenPythiaEventHeader.h"
 #include "AliLog.h"
 #include "AliMCEvent.h"
+#include "AliRhoParameter.h"
 
 ClassImp(AliJetResponseMaker)
 
 //________________________________________________________________________
 AliJetResponseMaker::AliJetResponseMaker() : 
   AliAnalysisTaskEmcalJet("AliJetResponseMaker", kTRUE),
-  fMCTracksName("MCParticles"),
-  fMCJetsName("MCJets"),
-  fMaxDistance(0.25),
-  fDoWeighting(kFALSE),
-  fEventWeightHist(kFALSE),
-  fMCFiducial(kFALSE),
-  fMCminEta(0),
-  fMCmaxEta(0),
-  fMCminPhi(0),
-  fMCmaxPhi(0),
+  fTracks2Name(""),
+  fCalo2Name(""),
+  fJets2Name(""),
+  fRho2Name(""),
+  fPtBiasJet2Track(0),
+  fPtBiasJet2Clus(0),
+  fAreCollections1MC(kFALSE),  
+  fAreCollections2MC(kTRUE),
+  fMatching(kNoMatching),
+  fMatchingPar(0),
+  fJet2MinEta(-999),
+  fJet2MaxEta(-999),
+  fJet2MinPhi(-999),
+  fJet2MaxPhi(-999),
   fSelectPtHardBin(-999),
-  fDoMatching(kTRUE),
   fPythiaHeader(0),
-  fEventWeight(0),
   fPtHardBin(0),
   fNTrials(0),
-  fMCTracks(0),
-  fMCJets(0),
+  fTracks2(0),
+  fCaloClusters2(0),
+  fJets2(0),
+  fRho2(0),
+  fRho2Val(0),
   fHistNTrials(0),
   fHistEvents(0),
-  fHistMCJetsPhiEta(0),
-  fHistMCJetsPtArea(0),
-  fHistMCJetsPhiEtaFiducial(0),
-  fHistMCJetsPtAreaFiducial(0),
-  fHistMCJetsNEFvsPt(0),
-  fHistMCJetsZvsPt(0),
-  fHistJetsPhiEta(0),
-  fHistJetsPtArea(0),
-  fHistJetsCorrPtArea(0),
-  fHistJetsNEFvsPt(0),
-  fHistJetsZvsPt(0),
-  fHistMatchingLevelMCPt(0),
-  fHistClosestDeltaEtaPhiMCPt(0),
-  fHistClosestDeltaPtMCPt(0),
-  fHistClosestDeltaCorrPtMCPt(0),
-  fHistNonMatchedMCJetsPtArea(0),
-  fHistNonMatchedJetsPtArea(0),
-  fHistNonMatchedJetsCorrPtArea(0),
-  fHistPartvsDetecPt(0),
-  fHistPartvsDetecCorrPt(0),
-  fHistMissedMCJetsPtArea(0)
+  fHistJets1PhiEta(0),
+  fHistJets1PtArea(0),
+  fHistJets1CorrPtArea(0),
+  fHistJets2PhiEta(0),
+  fHistJets2PtArea(0),
+  fHistJets2CorrPtArea(0),
+  fHistMatchingLevelvsJet2Pt(0),
+  fHistClosestDeltaEtaPhivsJet2Pt(0),
+  fHistClosestDeltaPtvsJet2Pt(0),
+  fHistClosestDeltaCorrPtvsJet2Pt(0),
+  fHistNonMatchedJets1PtArea(0),
+  fHistNonMatchedJets2PtArea(0),
+  fHistNonMatchedJets1CorrPtArea(0),
+  fHistNonMatchedJets2CorrPtArea(0),
+  fHistJet1PtvsJet2Pt(0),
+  fHistJet1CorrPtvsJet2CorrPt(0),
+  fHistMissedJets2PtArea(0)
 {
   // Default constructor.
 
-  for (Int_t i = 0; i < 11; i++) {
-    fHistEventWeight[i] = 0;
-  }
-
   SetMakeGeneralHistograms(kTRUE);
 }
 
 //________________________________________________________________________
 AliJetResponseMaker::AliJetResponseMaker(const char *name) : 
   AliAnalysisTaskEmcalJet(name, kTRUE),
-  fMCTracksName("MCParticles"),
-  fMCJetsName("MCJets"),
-  fMaxDistance(0.25),
-  fDoWeighting(kFALSE),
-  fEventWeightHist(kFALSE),
-  fMCFiducial(kFALSE),
-  fMCminEta(0),
-  fMCmaxEta(0),
-  fMCminPhi(0),
-  fMCmaxPhi(0),
+  fTracks2Name("MCParticles"),
+  fCalo2Name(""),
+  fJets2Name("MCJets"),
+  fRho2Name(""),
+  fPtBiasJet2Track(0),
+  fPtBiasJet2Clus(0),
+  fAreCollections1MC(kFALSE),  
+  fAreCollections2MC(kTRUE),
+  fMatching(kNoMatching),
+  fMatchingPar(0.25),
+  fJet2MinEta(-999),
+  fJet2MaxEta(-999),
+  fJet2MinPhi(-999),
+  fJet2MaxPhi(-999),
   fSelectPtHardBin(-999),
-  fDoMatching(kTRUE),
   fPythiaHeader(0),
-  fEventWeight(0),
   fPtHardBin(0),
   fNTrials(0),
-  fMCTracks(0),
-  fMCJets(0),
+  fTracks2(0),
+  fCaloClusters2(0),
+  fJets2(0),
+  fRho2(0),
+  fRho2Val(0),
   fHistNTrials(0),
   fHistEvents(0),
-  fHistMCJetsPhiEta(0),
-  fHistMCJetsPtArea(0),
-  fHistMCJetsPhiEtaFiducial(0),
-  fHistMCJetsPtAreaFiducial(0),
-  fHistMCJetsNEFvsPt(0),
-  fHistMCJetsZvsPt(0),
-  fHistJetsPhiEta(0),
-  fHistJetsPtArea(0),
-  fHistJetsCorrPtArea(0),
-  fHistJetsNEFvsPt(0),
-  fHistJetsZvsPt(0),
-  fHistMatchingLevelMCPt(0),
-  fHistClosestDeltaEtaPhiMCPt(0),
-  fHistClosestDeltaPtMCPt(0),
-  fHistClosestDeltaCorrPtMCPt(0),
-  fHistNonMatchedMCJetsPtArea(0),
-  fHistNonMatchedJetsPtArea(0),
-  fHistNonMatchedJetsCorrPtArea(0),
-  fHistPartvsDetecPt(0),
-  fHistPartvsDetecCorrPt(0),
-  fHistMissedMCJetsPtArea(0)
+  fHistJets1PhiEta(0),
+  fHistJets1PtArea(0),
+  fHistJets1CorrPtArea(0),
+  fHistJets2PhiEta(0),
+  fHistJets2PtArea(0),
+  fHistJets2CorrPtArea(0),
+  fHistMatchingLevelvsJet2Pt(0),
+  fHistClosestDeltaEtaPhivsJet2Pt(0),
+  fHistClosestDeltaPtvsJet2Pt(0),
+  fHistClosestDeltaCorrPtvsJet2Pt(0),
+  fHistNonMatchedJets1PtArea(0),
+  fHistNonMatchedJets2PtArea(0),
+  fHistNonMatchedJets1CorrPtArea(0),
+  fHistNonMatchedJets2CorrPtArea(0),
+  fHistJet1PtvsJet2Pt(0),
+  fHistJet1CorrPtvsJet2CorrPt(0),
+  fHistMissedJets2PtArea(0)
 {
   // Standard constructor.
 
-  for (Int_t i = 0; i < 11; i++) {
-    fHistEventWeight[i] = 0;
-  }
-
   SetMakeGeneralHistograms(kTRUE);
 }
 
@@ -155,134 +150,127 @@ void AliJetResponseMaker::UserCreateOutputObjects()
   fHistEvents->GetYaxis()->SetTitle("total events");
   fOutput->Add(fHistEvents);
 
-  if (fEventWeightHist) {
-    for (Int_t i = 0; i < 11; i++) {
-      TString name(Form("fHistEventWeight_%d", i+1));
-      fHistEventWeight[i] = new TH1F(name, name, 10, 0, 10);
-      fOutput->Add(fHistEventWeight[i]);
-    }
-  }
-
   for (Int_t i = 1; i < 12; i++) {
     fHistNTrials->GetXaxis()->SetBinLabel(i, Form("%d-%d",ptHardLo[i-1],ptHardHi[i-1]));
     fHistEvents->GetXaxis()->SetBinLabel(i, Form("%d-%d",ptHardLo[i-1],ptHardHi[i-1]));
   }
 
-  fHistJetsPhiEta = new TH2F("fHistJetsPhiEta", "fHistJetsPhiEta", 20, -2, 2, 32, 0, 6.4);
-  fHistJetsPhiEta->GetXaxis()->SetTitle("#eta");
-  fHistJetsPhiEta->GetYaxis()->SetTitle("#phi");
-  fOutput->Add(fHistJetsPhiEta);
-  
-  fHistJetsPtArea = new TH2F("fHistJetsPtArea", "fHistJetsPtArea", 40, 0, fJetRadius * fJetRadius * TMath::Pi() * 3, fNbins, fMinBinPt, fMaxBinPt);
-  fHistJetsPtArea->GetXaxis()->SetTitle("area");
-  fHistJetsPtArea->GetYaxis()->SetTitle("p_{T}^{rec} (GeV/c)");
-  fHistJetsPtArea->GetZaxis()->SetTitle("counts");
-  fOutput->Add(fHistJetsPtArea);
-
-  fHistJetsCorrPtArea = new TH2F("fHistJetsCorrPtArea", "fHistJetsCorrPtArea", 40, 0, fJetRadius * fJetRadius * TMath::Pi() * 3, (Int_t)(1.5*fNbins), -fMaxBinPt/2, fMaxBinPt);
-  fHistJetsCorrPtArea->GetXaxis()->SetTitle("area");
-  fHistJetsCorrPtArea->GetYaxis()->SetTitle("p_{T}^{corr} (GeV/c)");
-  fHistJetsCorrPtArea->GetZaxis()->SetTitle("counts");
-  fOutput->Add(fHistJetsCorrPtArea);
-  
-  fHistJetsZvsPt = new TH2F("fHistJetsZvsPt", "fHistJetsZvsPt", fNbins, 0, 1.2, fNbins, fMinBinPt, fMaxBinPt);
-  fHistJetsZvsPt->GetXaxis()->SetTitle("Z");
-  fHistJetsZvsPt->GetYaxis()->SetTitle("p_{T}^{rec} (GeV/c)");
-  fOutput->Add(fHistJetsZvsPt);
+  fHistJets1PhiEta = new TH2F("fHistJets1PhiEta", "fHistJets1PhiEta", 20, -2, 2, 32, 0, 6.4);
+  fHistJets1PhiEta->GetXaxis()->SetTitle("#eta");
+  fHistJets1PhiEta->GetYaxis()->SetTitle("#phi");
+  fOutput->Add(fHistJets1PhiEta);
   
-  fHistJetsNEFvsPt = new TH2F("fHistJetsNEFvsPt", "fHistJetsNEFvsPt", fNbins, 0, 1.2, fNbins, fMinBinPt, fMaxBinPt);
-  fHistJetsNEFvsPt->GetXaxis()->SetTitle("NEF");
-  fHistJetsNEFvsPt->GetYaxis()->SetTitle("p_{T}^{rec} (GeV/c)");
-  fOutput->Add(fHistJetsNEFvsPt);
-
-  fHistMCJetsPhiEta = new TH2F("fHistMCJetsPhiEta", "fHistMCJetsPhiEta", 20, -2, 2, 32, 0, 6.4);
-  fHistMCJetsPhiEta->GetXaxis()->SetTitle("#eta");
-  fHistMCJetsPhiEta->GetYaxis()->SetTitle("#phi");
-  fOutput->Add(fHistMCJetsPhiEta);
-  
-  fHistMCJetsPtArea = new TH2F("fHistMCJetsPtArea", "fHistMCJetsPtArea", 40, 0, fJetRadius * fJetRadius * TMath::Pi() * 3, fNbins, fMinBinPt, fMaxBinPt);
-  fHistMCJetsPtArea->GetXaxis()->SetTitle("area");
-  fHistMCJetsPtArea->GetYaxis()->SetTitle("p_{T}^{gen} (GeV/c)");
-  fHistMCJetsPtArea->GetZaxis()->SetTitle("counts");
-  fOutput->Add(fHistMCJetsPtArea);
-
-  fHistMCJetsPhiEtaFiducial = new TH2F("fHistMCJetsPhiEtaFiducial", "fHistMCJetsPhiEtaFiducial", 20, -2, 2, 32, 0, 6.4);
-  fHistMCJetsPhiEtaFiducial->GetXaxis()->SetTitle("#eta");
-  fHistMCJetsPhiEtaFiducial->GetYaxis()->SetTitle("#phi");
-  fOutput->Add(fHistMCJetsPhiEtaFiducial);
-  
-  fHistMCJetsPtAreaFiducial = new TH2F("fHistMCJetsPtAreaFiducial", "fHistMCJetsPtAreaFiducial", 40, 0, fJetRadius * fJetRadius * TMath::Pi() * 3, fNbins, fMinBinPt, fMaxBinPt);
-  fHistMCJetsPtAreaFiducial->GetXaxis()->SetTitle("area");
-  fHistMCJetsPtAreaFiducial->GetYaxis()->SetTitle("p_{T}^{gen} (GeV/c)");
-  fHistMCJetsPtAreaFiducial->GetZaxis()->SetTitle("counts");
-  fOutput->Add(fHistMCJetsPtAreaFiducial);
+  fHistJets1PtArea = new TH2F("fHistJets1PtArea", "fHistJets1PtArea", 40, 0, fJetRadius * fJetRadius * TMath::Pi() * 3, fNbins, fMinBinPt, fMaxBinPt);
+  fHistJets1PtArea->GetXaxis()->SetTitle("area");
+  fHistJets1PtArea->GetYaxis()->SetTitle("p_{T,1} (GeV/c)");
+  fHistJets1PtArea->GetZaxis()->SetTitle("counts");
+  fOutput->Add(fHistJets1PtArea);
+
+  if (!fRhoName.IsNull()) {
+    fHistJets1CorrPtArea = new TH2F("fHistJets1CorrPtArea", "fHistJets1CorrPtArea", 40, 0, fJetRadius * fJetRadius * TMath::Pi() * 3, 2*fNbins, -fMaxBinPt, fMaxBinPt);
+    fHistJets1CorrPtArea->GetXaxis()->SetTitle("area");
+    fHistJets1CorrPtArea->GetYaxis()->SetTitle("p_{T,1}^{corr} (GeV/c)");
+    fHistJets1CorrPtArea->GetZaxis()->SetTitle("counts");
+    fOutput->Add(fHistJets1CorrPtArea);
+  }
+
+  fHistJets2PhiEta = new TH2F("fHistJets2PhiEta", "fHistJets2PhiEta", 20, -2, 2, 32, 0, 6.4);
+  fHistJets2PhiEta->GetXaxis()->SetTitle("#eta");
+  fHistJets2PhiEta->GetYaxis()->SetTitle("#phi");
+  fOutput->Add(fHistJets2PhiEta);
   
-  fHistMCJetsZvsPt = new TH2F("fHistMCJetsZvsPt", "fHistMCJetsZvsPt", fNbins, 0, 1.2, fNbins, fMinBinPt, fMaxBinPt);
-  fHistMCJetsZvsPt->GetXaxis()->SetTitle("Z");
-  fHistMCJetsZvsPt->GetYaxis()->SetTitle("p_{T}^{gen} (GeV/c)");
-  fOutput->Add(fHistMCJetsZvsPt);
-
-  fHistMCJetsNEFvsPt = new TH2F("fHistMCJetsNEFvsPt", "fHistMCJetsNEFvsPt", fNbins, 0, 1.2, fNbins, fMinBinPt, fMaxBinPt);
-  fHistMCJetsNEFvsPt->GetXaxis()->SetTitle("NEF");
-  fHistMCJetsNEFvsPt->GetYaxis()->SetTitle("p_{T}^{gen} (GeV/c)");
-  fOutput->Add(fHistMCJetsNEFvsPt);
-
-  fHistMatchingLevelMCPt = new TH2F("fHistMatchingLevelMCPt", "fHistMatchingLevelMCPt", fNbins, 0, 1.2, fNbins, fMinBinPt, fMaxBinPt);
-  fHistMatchingLevelMCPt->GetXaxis()->SetTitle("Matching level");
-  fHistMatchingLevelMCPt->GetYaxis()->SetTitle("p_{T}^{gen} (GeV/c)");
-  fOutput->Add(fHistMatchingLevelMCPt);
-
-  fHistClosestDeltaEtaPhiMCPt = new TH3F("fHistClosestDeltaEtaPhiMCPt", "fHistClosestDeltaEtaPhiMCPt", TMath::CeilNint(fJetMaxEta - fJetMinEta) * 20, fJetMinEta * 2, fJetMaxEta * 2, 64, -1.6, 4.8, fNbins, fMinBinPt, fMaxBinPt);
-  fHistClosestDeltaEtaPhiMCPt->GetXaxis()->SetTitle("#Delta#eta");
-  fHistClosestDeltaEtaPhiMCPt->GetYaxis()->SetTitle("#Delta#phi");
-  fHistClosestDeltaEtaPhiMCPt->GetZaxis()->SetTitle("p_{T}^{gen}");
-  fOutput->Add(fHistClosestDeltaEtaPhiMCPt);
-
-  fHistClosestDeltaPtMCPt = new TH2F("fHistClosestDeltaPtMCPt", "fHistClosestDeltaPtMCPt", fNbins, fMinBinPt, fMaxBinPt, (Int_t)(fNbins*1.5), -fMaxBinPt / 2, fMaxBinPt);
-  fHistClosestDeltaPtMCPt->GetXaxis()->SetTitle("p_{T}^{gen}");  
-  fHistClosestDeltaPtMCPt->GetYaxis()->SetTitle("#Deltap_{T}^{rec} (GeV/c)");
-  fHistClosestDeltaPtMCPt->GetZaxis()->SetTitle("counts");
-  fOutput->Add(fHistClosestDeltaPtMCPt);
-
-  fHistClosestDeltaCorrPtMCPt = new TH2F("fHistClosestDeltaCorrPtMCPt", "fHistClosestDeltaCorrPtMCPt", fNbins, fMinBinPt, fMaxBinPt, (Int_t)(fNbins*1.5), -fMaxBinPt / 2, fMaxBinPt);
-  fHistClosestDeltaCorrPtMCPt->GetXaxis()->SetTitle("p_{T}^{gen}");  
-  fHistClosestDeltaCorrPtMCPt->GetYaxis()->SetTitle("#Deltap_{T}^{corr} (GeV/c)");
-  fHistClosestDeltaCorrPtMCPt->GetZaxis()->SetTitle("counts");
-  fOutput->Add(fHistClosestDeltaCorrPtMCPt);
-
-  fHistNonMatchedMCJetsPtArea = new TH2F("fHistNonMatchedMCJetsPtArea", "fHistNonMatchedMCJetsPtArea", 40, 0, fJetRadius * fJetRadius * TMath::Pi() * 3, fNbins, fMinBinPt, fMaxBinPt);
-  fHistNonMatchedMCJetsPtArea->GetXaxis()->SetTitle("area");
-  fHistNonMatchedMCJetsPtArea->GetYaxis()->SetTitle("p_{T}^{gen} (GeV/c)");
-  fHistNonMatchedMCJetsPtArea->GetZaxis()->SetTitle("counts");
-  fOutput->Add(fHistNonMatchedMCJetsPtArea);
-
-  fHistNonMatchedJetsPtArea = new TH2F("fHistNonMatchedJetsPtArea", "fHistNonMatchedJetsPtArea", 40, 0, fJetRadius * fJetRadius * TMath::Pi() * 3, fNbins, fMinBinPt, fMaxBinPt);
-  fHistNonMatchedJetsPtArea->GetXaxis()->SetTitle("area");
-  fHistNonMatchedJetsPtArea->GetYaxis()->SetTitle("p_{T}^{rec} (GeV/c)");
-  fHistNonMatchedJetsPtArea->GetZaxis()->SetTitle("counts");
-  fOutput->Add(fHistNonMatchedJetsPtArea);
-
-  fHistNonMatchedJetsCorrPtArea = new TH2F("fHistNonMatchedJetsCorrPtArea", "fHistNonMatchedJetsCorrPtArea", 40, 0, fJetRadius * fJetRadius * TMath::Pi() * 3, (Int_t)(1.5*fNbins), -fMaxBinPt/2, fMaxBinPt);
-  fHistNonMatchedJetsCorrPtArea->GetXaxis()->SetTitle("area");
-  fHistNonMatchedJetsCorrPtArea->GetYaxis()->SetTitle("p_{T}^{corr} (GeV/c)");
-  fHistNonMatchedJetsCorrPtArea->GetZaxis()->SetTitle("counts");
-  fOutput->Add(fHistNonMatchedJetsCorrPtArea);
-
-  fHistPartvsDetecPt = new TH2F("fHistPartvsDetecPt", "fHistPartvsDetecPt", fNbins, fMinBinPt, fMaxBinPt, fNbins, fMinBinPt, fMaxBinPt);
-  fHistPartvsDetecPt->GetXaxis()->SetTitle("p_{T}^{rec}");
-  fHistPartvsDetecPt->GetYaxis()->SetTitle("p_{T}^{gen}");
-  fOutput->Add(fHistPartvsDetecPt);
-
-  fHistPartvsDetecCorrPt = new TH2F("fHistPartvsDetecCorrPt", "fHistPartvsDetecCorrPt", (Int_t)(1.5*fNbins), -fMaxBinPt/2, fMaxBinPt, fNbins, fMinBinPt, fMaxBinPt);
-  fHistPartvsDetecCorrPt->GetXaxis()->SetTitle("p_{T}^{corr}");
-  fHistPartvsDetecCorrPt->GetYaxis()->SetTitle("p_{T}^{gen}");
-  fOutput->Add(fHistPartvsDetecCorrPt);
-
-  fHistMissedMCJetsPtArea = new TH2F("fHistMissedMCJetsPtArea", "fHistMissedMCJetsPtArea", 40, 0, fJetRadius * fJetRadius * TMath::Pi() * 3, fNbins, fMinBinPt, fMaxBinPt);
-  fHistMissedMCJetsPtArea->GetXaxis()->SetTitle("area");  
-  fHistMissedMCJetsPtArea->GetYaxis()->SetTitle("p_{T} (GeV/c)");
-  fHistMissedMCJetsPtArea->GetZaxis()->SetTitle("counts");
-  fOutput->Add(fHistMissedMCJetsPtArea);
+  fHistJets2PtArea = new TH2F("fHistJets2PtArea", "fHistJets2PtArea", 40, 0, fJetRadius * fJetRadius * TMath::Pi() * 3, fNbins, fMinBinPt, fMaxBinPt);
+  fHistJets2PtArea->GetXaxis()->SetTitle("area");
+  fHistJets2PtArea->GetYaxis()->SetTitle("p_{T,2} (GeV/c)");
+  fHistJets2PtArea->GetZaxis()->SetTitle("counts");
+  fOutput->Add(fHistJets2PtArea);
+
+  if (!fRho2Name.IsNull()) {
+    fHistJets2CorrPtArea = new TH2F("fHistJets2CorrPtArea", "fHistJets2CorrPtArea", 40, 0, fJetRadius * fJetRadius * TMath::Pi() * 3, 2*fNbins, -fMaxBinPt, fMaxBinPt);
+    fHistJets2CorrPtArea->GetXaxis()->SetTitle("area");
+    fHistJets2CorrPtArea->GetYaxis()->SetTitle("p_{T,2}^{corr} (GeV/c)");
+    fHistJets2CorrPtArea->GetZaxis()->SetTitle("counts");
+    fOutput->Add(fHistJets2CorrPtArea);
+  }
+
+  fHistMatchingLevelvsJet2Pt = new TH2F("fHistMatchingLevelvsJet2Pt", "fHistMatchingLevelvsJet2Pt", fNbins/2, 0, 1.2, fNbins/2, fMinBinPt, fMaxBinPt);
+  fHistMatchingLevelvsJet2Pt->GetXaxis()->SetTitle("Matching level");
+  fHistMatchingLevelvsJet2Pt->GetYaxis()->SetTitle("p_{T,2}");  
+  fHistMatchingLevelvsJet2Pt->GetZaxis()->SetTitle("counts");
+  fOutput->Add(fHistMatchingLevelvsJet2Pt);
+
+  fHistClosestDeltaEtaPhivsJet2Pt = new TH3F("fHistClosestDeltaEtaPhivsJet2Pt", "fHistClosestDeltaEtaPhivsJet2Pt", 40, -1, 1, 128, -1.6, 4.8, fNbins/2, fMinBinPt, fMaxBinPt);
+  fHistClosestDeltaEtaPhivsJet2Pt->GetXaxis()->SetTitle("#Delta#eta");
+  fHistClosestDeltaEtaPhivsJet2Pt->GetYaxis()->SetTitle("#Delta#phi");
+  fHistClosestDeltaEtaPhivsJet2Pt->GetZaxis()->SetTitle("p_{T,2}");
+  fOutput->Add(fHistClosestDeltaEtaPhivsJet2Pt);
+
+  fHistClosestDeltaPtvsJet2Pt = new TH2F("fHistClosestDeltaPtvsJet2Pt", "fHistClosestDeltaPtvsJet2Pt", fNbins/2, fMinBinPt, fMaxBinPt, 2*fNbins, -fMaxBinPt, fMaxBinPt);
+  fHistClosestDeltaPtvsJet2Pt->GetXaxis()->SetTitle("p_{T,2}");  
+  fHistClosestDeltaPtvsJet2Pt->GetYaxis()->SetTitle("#deltap_{T} (GeV/c)");
+  fHistClosestDeltaPtvsJet2Pt->GetZaxis()->SetTitle("counts");
+  fOutput->Add(fHistClosestDeltaPtvsJet2Pt);
+
+  if (!fRhoName.IsNull() || !fRho2Name.IsNull()) {  
+    fHistClosestDeltaCorrPtvsJet2Pt = new TH2F("fHistClosestDeltaCorrPtvsJet2Pt", "fHistClosestDeltaCorrPtvsJet2Pt", fNbins/2, fMinBinPt, fMaxBinPt, 2*fNbins, -fMaxBinPt, fMaxBinPt);
+    fHistClosestDeltaCorrPtvsJet2Pt->GetXaxis()->SetTitle("p_{T,2}");  
+    fHistClosestDeltaCorrPtvsJet2Pt->GetYaxis()->SetTitle("#Deltap_{T}^{corr} (GeV/c)");
+    fHistClosestDeltaCorrPtvsJet2Pt->GetZaxis()->SetTitle("counts");
+    fOutput->Add(fHistClosestDeltaCorrPtvsJet2Pt);
+  }
+
+  fHistNonMatchedJets1PtArea = new TH2F("fHistNonMatchedJets1PtArea", "fHistNonMatchedJets1PtArea", 40, 0, fJetRadius * fJetRadius * TMath::Pi() * 3, fNbins, fMinBinPt, fMaxBinPt);
+  fHistNonMatchedJets1PtArea->GetXaxis()->SetTitle("area");
+  fHistNonMatchedJets1PtArea->GetYaxis()->SetTitle("p_{T,1} (GeV/c)");
+  fHistNonMatchedJets1PtArea->GetZaxis()->SetTitle("counts");
+  fOutput->Add(fHistNonMatchedJets1PtArea);
+
+  fHistNonMatchedJets2PtArea = new TH2F("fHistNonMatchedJets2PtArea", "fHistNonMatchedJets2PtArea", 40, 0, fJetRadius * fJetRadius * TMath::Pi() * 3, fNbins, fMinBinPt, fMaxBinPt);
+  fHistNonMatchedJets2PtArea->GetXaxis()->SetTitle("area");
+  fHistNonMatchedJets2PtArea->GetYaxis()->SetTitle("p_{T,2} (GeV/c)");
+  fHistNonMatchedJets2PtArea->GetZaxis()->SetTitle("counts");
+  fOutput->Add(fHistNonMatchedJets2PtArea);
+
+  if (!fRhoName.IsNull()) {  
+    fHistNonMatchedJets1CorrPtArea = new TH2F("fHistNonMatchedJets1CorrPtArea", "fHistNonMatchedJets1CorrPtArea", 40, 0, fJetRadius * fJetRadius * TMath::Pi() * 3, 2*fNbins, -fMaxBinPt, fMaxBinPt);
+    fHistNonMatchedJets1CorrPtArea->GetXaxis()->SetTitle("area");
+    fHistNonMatchedJets1CorrPtArea->GetYaxis()->SetTitle("p_{T,1} (GeV/c)");
+    fHistNonMatchedJets1CorrPtArea->GetZaxis()->SetTitle("counts");
+    fOutput->Add(fHistNonMatchedJets1CorrPtArea);
+  }
+
+  if (!fRho2Name.IsNull()) {  
+    fHistNonMatchedJets2CorrPtArea = new TH2F("fHistNonMatchedJets2CorrPtArea", "fHistNonMatchedJets2CorrPtArea", 40, 0, fJetRadius * fJetRadius * TMath::Pi() * 3, 2*fNbins, -fMaxBinPt, fMaxBinPt);
+    fHistNonMatchedJets2CorrPtArea->GetXaxis()->SetTitle("area");
+    fHistNonMatchedJets2CorrPtArea->GetYaxis()->SetTitle("p_{T,2} (GeV/c)");
+    fHistNonMatchedJets2CorrPtArea->GetZaxis()->SetTitle("counts");
+    fOutput->Add(fHistNonMatchedJets2CorrPtArea);
+  }
+
+  fHistJet1PtvsJet2Pt = new TH2F("fHistJet1PtvsJet2Pt", "fHistJet1PtvsJet2Pt", fNbins, fMinBinPt, fMaxBinPt, fNbins, fMinBinPt, fMaxBinPt);
+  fHistJet1PtvsJet2Pt->GetXaxis()->SetTitle("p_{T,1}");
+  fHistJet1PtvsJet2Pt->GetYaxis()->SetTitle("p_{T,2}");
+  fHistJet1PtvsJet2Pt->GetZaxis()->SetTitle("counts");
+  fOutput->Add(fHistJet1PtvsJet2Pt);
+
+  if (!fRhoName.IsNull() || !fRho2Name.IsNull()) {
+    if (fRhoName.IsNull()) 
+      fHistJet1CorrPtvsJet2CorrPt = new TH2F("fHistJet1CorrPtvsJet2CorrPt", "fHistJet1CorrPtvsJet2CorrPt", fNbins, fMinBinPt, fMaxBinPt, 2*fNbins, -fMaxBinPt, fMaxBinPt);
+    else if (fRho2Name.IsNull()) 
+      fHistJet1CorrPtvsJet2CorrPt = new TH2F("fHistJet1CorrPtvsJet2CorrPt", "fHistJet1CorrPtvsJet2CorrPt", 2*fNbins, -fMaxBinPt, fMaxBinPt, fNbins, fMinBinPt, fMaxBinPt);
+    else
+      fHistJet1CorrPtvsJet2CorrPt = new TH2F("fHistJet1CorrPtvsJet2CorrPt", "fHistJet1CorrPtvsJet2CorrPt", 2*fNbins, -fMaxBinPt, fMaxBinPt, 2*fNbins, -fMaxBinPt, fMaxBinPt);
+    fHistJet1CorrPtvsJet2CorrPt->GetXaxis()->SetTitle("p_{T,1}^{corr}");
+    fHistJet1CorrPtvsJet2CorrPt->GetYaxis()->SetTitle("p_{T,2}^{corr}");
+    fHistJet1CorrPtvsJet2CorrPt->GetZaxis()->SetTitle("counts");
+    fOutput->Add(fHistJet1CorrPtvsJet2CorrPt);
+  }
+
+  fHistMissedJets2PtArea = new TH2F("fHistMissedJets2PtArea", "fHistMissedJets2PtArea", 40, 0, fJetRadius * fJetRadius * TMath::Pi() * 3, fNbins, fMinBinPt, fMaxBinPt);
+  fHistMissedJets2PtArea->GetXaxis()->SetTitle("area");  
+  fHistMissedJets2PtArea->GetYaxis()->SetTitle("p_{T,2} (GeV/c)");
+  fHistMissedJets2PtArea->GetZaxis()->SetTitle("counts");
+  fOutput->Add(fHistMissedJets2PtArea);
 
   PostData(1, fOutput); // Post data for ALL output slots > 0 here, to get at least an empty histogram
 }
@@ -300,54 +288,92 @@ Bool_t AliJetResponseMaker::AcceptJet(AliEmcalJet *jet) const
   return kTRUE;
 }
 
+//________________________________________________________________________
+Bool_t AliJetResponseMaker::AcceptBiasJet2(AliEmcalJet *jet) const
+{ 
+  // Accept jet with a bias.
+
+  if (fLeadingHadronType == 0) {
+    if (jet->MaxTrackPt() < fPtBiasJet2Track) return kFALSE;
+  }
+  else if (fLeadingHadronType == 1) {
+    if (jet->MaxClusterPt() < fPtBiasJet2Clus) return kFALSE;
+  }
+  else {
+    if (jet->MaxTrackPt() < fPtBiasJet2Track && jet->MaxClusterPt() < fPtBiasJet2Clus) return kFALSE;
+  }
+
+  return kTRUE;
+}
+
 //________________________________________________________________________
 void AliJetResponseMaker::ExecOnce()
 {
   // Execute once.
 
-  if (!fMCJetsName.IsNull() && !fMCJets) {
-    fMCJets = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fMCJetsName));
-    if (!fMCJets) {
-      AliError(Form("%s: Could not retrieve mc jets %s!", GetName(), fMCJetsName.Data()));
+  if (!fJets2Name.IsNull() && !fJets2) {
+    fJets2 = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fJets2Name));
+    if (!fJets2) {
+      AliError(Form("%s: Could not retrieve jets2 %s!", GetName(), fJets2Name.Data()));
       return;
     }
-    else if (!fMCJets->GetClass()->GetBaseClass("AliEmcalJet")) {
-      AliError(Form("%s: Collection %s does not contain AliEmcalJet objects!", GetName(), fMCJetsName.Data())); 
-      fMCJets = 0;
+    else if (!fJets2->GetClass()->GetBaseClass("AliEmcalJet")) {
+      AliError(Form("%s: Collection %s does not contain AliEmcalJet objects!", GetName(), fJets2Name.Data())); 
+      fJets2 = 0;
       return;
     }
   }
 
-  if (!fMCTracksName.IsNull() && !fMCTracks) {
-    fMCTracks = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fMCTracksName));
-    if (!fMCTracks) {
-      AliError(Form("%s: Could not retrieve mc tracks %s!", GetName(), fMCTracksName.Data())); 
+  if (!fTracks2Name.IsNull() && !fTracks2) {
+    fTracks2 = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fTracks2Name));
+    if (!fTracks2) {
+      AliError(Form("%s: Could not retrieve tracks2 %s!", GetName(), fTracks2Name.Data())); 
       return;
     }
     else {
-      TClass *cl = fMCTracks->GetClass();
+      TClass *cl = fTracks2->GetClass();
       if (!cl->GetBaseClass("AliVParticle") && !cl->GetBaseClass("AliEmcalParticle")) {
-       AliError(Form("%s: Collection %s does not contain AliVParticle nor AliEmcalParticle objects!", GetName(), fMCTracksName.Data())); 
-       fMCTracks = 0;
+       AliError(Form("%s: Collection %s does not contain AliVParticle nor AliEmcalParticle objects!", GetName(), fTracks2Name.Data())); 
+       fTracks2 = 0;
        return;
       }
     }
   }
 
-  AliAnalysisTaskEmcalJet::ExecOnce();
-
-  if (fMCFiducial) {
-    fMCminEta = fJetMinEta;
-    fMCmaxEta = fJetMaxEta;
-    fMCminPhi = fJetMinPhi;
-    fMCmaxPhi = fJetMaxPhi;
+  if (!fCalo2Name.IsNull() && !fCaloClusters2) {
+    fCaloClusters2 =  dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fCalo2Name));
+    if (!fCaloClusters2) {
+      AliError(Form("%s: Could not retrieve clusters %s!", GetName(), fCalo2Name.Data())); 
+      return;
+    } else {
+      TClass *cl = fCaloClusters2->GetClass();
+      if (!cl->GetBaseClass("AliVCluster") && !cl->GetBaseClass("AliEmcalParticle")) {
+       AliError(Form("%s: Collection %s does not contain AliVCluster nor AliEmcalParticle objects!", GetName(), fCalo2Name.Data())); 
+       fCaloClusters2 = 0;
+       return;
+      }
+    }
   }
-  else {
-    fMCminEta = fJetMinEta - fJetRadius;
-    fMCmaxEta = fJetMaxEta + fJetRadius;
-    fMCminPhi = fJetMinPhi - fJetRadius;
-    fMCmaxPhi = fJetMaxPhi + fJetRadius;
+
+  if (!fRho2Name.IsNull() && !fRho2) {
+    fRho2 = dynamic_cast<AliRhoParameter*>(InputEvent()->FindListObject(fRho2Name));
+    if (!fRho2) {
+      AliError(Form("%s: Could not retrieve rho %s!", GetName(), fRho2Name.Data()));
+      fInitialized = kFALSE;
+      return;
+    }
   }
+
+  if (fJet2MinEta == -999)
+    fJet2MinEta = fJetMinEta - fJetRadius;
+  if (fJet2MaxEta == -999)
+    fJet2MaxEta = fJetMaxEta + fJetRadius;
+  if (fJet2MinPhi == -999)
+    fJet2MinPhi = fJetMinPhi - fJetRadius;
+  if (fJet2MaxPhi == -999)
+    fJet2MaxPhi = fJetMaxPhi + fJetRadius;
+
+  AliAnalysisTaskEmcalJet::ExecOnce();
 }
 
 //________________________________________________________________________
@@ -368,17 +394,15 @@ Bool_t AliJetResponseMaker::RetrieveEventObjects()
 
   if (!AliAnalysisTaskEmcalJet::RetrieveEventObjects())
     return kFALSE;
+
+  if (fRho2)
+    fRho2Val = fRho2->GetVal();
   
   fPythiaHeader = dynamic_cast<AliGenPythiaEventHeader*>(MCEvent()->GenEventHeader());
 
   if (!fPythiaHeader)
     return kFALSE;
 
-  if (fDoWeighting)
-    fEventWeight = fPythiaHeader->EventWeight();
-  else
-    fEventWeight = 1;
-
   const Int_t ptHardLo[11] = { 0, 5,11,21,36,57, 84,117,152,191,234};
   const Int_t ptHardHi[11] = { 5,11,21,36,57,84,117,152,191,234,1000000};
 
@@ -398,37 +422,37 @@ Bool_t AliJetResponseMaker::RetrieveEventObjects()
 Bool_t AliJetResponseMaker::Run()
 {
   // Find the closest jets
-
-  if (!fDoMatching)
+  
+  if (fMatching == kNoMatching)
     return kTRUE;
 
-  DoJetLoop(fJets, fMCJets, kFALSE);
-  DoJetLoop(fMCJets, fJets, kTRUE);
+  DoJetLoop(fJets, fJets2, kFALSE);
+  DoJetLoop(fJets2, fJets, kTRUE);
 
-  const Int_t nMCJets = fMCJets->GetEntriesFast();
+  const Int_t nJets2 = fJets2->GetEntriesFast();
 
-  for (Int_t i = 0; i < nMCJets; i++) {
+  for (Int_t i = 0; i < nJets2; i++) {
 
-    AliEmcalJet* jet = static_cast<AliEmcalJet*>(fMCJets->At(i));
+    AliEmcalJet* jet2 = static_cast<AliEmcalJet*>(fJets2->At(i));
 
-    if (!jet) {
+    if (!jet2) {
       AliError(Form("Could not receive jet %d", i));
       continue;
     }  
 
-    if (!AcceptJet(jet))
+    if (!AcceptJet(jet2))
       continue;
 
-    if (jet->Eta() < fMCminEta || jet->Eta() > fMCmaxEta || jet->Phi() < fMCminPhi || jet->Phi() > fMCmaxPhi)
+    if (jet2->Eta() < fJet2MinEta || jet2->Eta() > fJet2MaxEta || jet2->Phi() < fJet2MinPhi || jet2->Phi() > fJet2MaxPhi)
       continue;
 
-    if (jet->Pt() > fMaxBinPt)
+    if (jet2->Pt() > fMaxBinPt)
       continue;
 
-    if (jet->ClosestJet() && jet->ClosestJet()->ClosestJet() == jet && 
-        jet->ClosestJetDistance() < fMaxDistance) {    // Matched jet found
-      jet->SetMatchedToClosest();
-      jet->ClosestJet()->SetMatchedToClosest();
+    if (jet2->ClosestJet() && jet2->ClosestJet()->ClosestJet() == jet2 && 
+        jet2->ClosestJetDistance() < fMatchingPar) {    // Matched jet found
+      jet2->SetMatchedToClosest();
+      jet2->ClosestJet()->SetMatchedToClosest();
     }
   }
 
@@ -436,7 +460,7 @@ Bool_t AliJetResponseMaker::Run()
 }
 
 //________________________________________________________________________
-void AliJetResponseMaker::DoJetLoop(TClonesArray *jets1, TClonesArray *jets2, Bool_t mc)
+void AliJetResponseMaker::DoJetLoop(TClonesArray *jets1, TClonesArray *jets2, Bool_t first)
 {
   // Do the jet loop.
 
@@ -455,12 +479,12 @@ void AliJetResponseMaker::DoJetLoop(TClonesArray *jets1, TClonesArray *jets2, Bo
     if (!AcceptJet(jet1))
       continue;
 
-    if (!mc) {
-      if (jet1->Eta() < fJetMinEta || jet1->Eta() > fJetMaxEta || jet1->Phi() < fJetMinPhi || jet1->Phi() > fJetMaxPhi)
+    if (first) {
+     if (jet1->Eta() < fJet2MinEta || jet1->Eta() > fJet2MaxEta || jet1->Phi() < fJet2MinPhi || jet1->Phi() > fJet2MaxPhi)
        continue;
     }
     else {
-      if (jet1->Eta() < fMCminEta || jet1->Eta() > fMCmaxEta || jet1->Phi() < fMCminPhi || jet1->Phi() > fMCmaxPhi)
+      if (jet1->Eta() < fJetMinEta || jet1->Eta() > fJetMaxEta || jet1->Phi() < fJetMinPhi || jet1->Phi() > fJetMaxPhi)
        continue;
     }
 
@@ -476,18 +500,19 @@ void AliJetResponseMaker::DoJetLoop(TClonesArray *jets1, TClonesArray *jets2, Bo
       if (!AcceptJet(jet2))
        continue;
 
-      if (mc) {
+      if (first) {
        if (jet2->Eta() < fJetMinEta || jet2->Eta() > fJetMaxEta || jet2->Phi() < fJetMinPhi || jet2->Phi() > fJetMaxPhi)
          continue;
       }
       else {
-       if (jet1->Eta() < fMCminEta || jet1->Eta() > fMCmaxEta || jet1->Phi() < fMCminPhi || jet1->Phi() > fMCmaxPhi)
+       if (jet1->Eta() < fJet2MinEta || jet1->Eta() > fJet2MaxEta || jet1->Phi() < fJet2MinPhi || jet1->Phi() > fJet2MaxPhi)
          continue;
       }
-      
-      Double_t deta = jet2->Eta() - jet1->Eta();
-      Double_t dphi = jet2->Phi() - jet1->Phi();
-      Double_t d = TMath::Sqrt(deta * deta + dphi * dphi);
+
+      Double_t d = GetMatchingLevel(jet1, jet2);
+
+      if (d < 0)
+       continue;
 
       if (d < jet1->ClosestJetDistance()) {
        jet1->SetSecondClosestJet(jet1->ClosestJet(), jet1->ClosestJetDistance());
@@ -500,6 +525,29 @@ void AliJetResponseMaker::DoJetLoop(TClonesArray *jets1, TClonesArray *jets2, Bo
   }
 }
 
+//________________________________________________________________________
+Double_t AliJetResponseMaker::GetMatchingLevel(AliEmcalJet *jet1, AliEmcalJet *jet2) const
+{
+  Double_t r = -1;
+
+  switch (fMatching) {
+  case kGeometrical:
+    {
+      Double_t deta = jet2->Eta() - jet1->Eta();
+      Double_t dphi = jet2->Phi() - jet1->Phi();
+      r = TMath::Sqrt(deta * deta + dphi * dphi);
+    }
+    break;
+  case kMCLabel:
+    AliError("MC label matching not implemented!");
+    break;
+  default:
+    ;
+  }
+  
+  return r;
+}
+
 //________________________________________________________________________
 Bool_t AliJetResponseMaker::FillHistograms()
 {
@@ -507,122 +555,105 @@ Bool_t AliJetResponseMaker::FillHistograms()
 
   fHistEvents->SetBinContent(fPtHardBin + 1, fHistEvents->GetBinContent(fPtHardBin + 1) + 1);
   fHistNTrials->SetBinContent(fPtHardBin + 1, fHistNTrials->GetBinContent(fPtHardBin + 1) + fNTrials);
-  if (fEventWeightHist)
-    fHistEventWeight[fPtHardBin]->Fill(fPythiaHeader->EventWeight());
 
-  const Int_t nMCJets = fMCJets->GetEntriesFast();
+  const Int_t nJets2 = fJets2->GetEntriesFast();
 
-  for (Int_t i = 0; i < nMCJets; i++) {
+  for (Int_t i = 0; i < nJets2; i++) {
 
-    AliEmcalJet* jet = static_cast<AliEmcalJet*>(fMCJets->At(i));
+    AliEmcalJet* jet2 = static_cast<AliEmcalJet*>(fJets2->At(i));
 
-    if (!jet) {
-      AliError(Form("Could not receive jet %d", i));
+    if (!jet2) {
+      AliError(Form("Could not receive jet2 %d", i));
       continue;
     }  
 
-    if (!AcceptJet(jet))
+    if (!AcceptJet(jet2))
+      continue;
+
+    if (!AcceptBiasJet2(jet2))
       continue;
 
-    if (jet->Eta() < fMCminEta || jet->Eta() > fMCmaxEta || jet->Phi() < fMCminPhi || jet->Phi() > fMCmaxPhi)
+    if (jet2->Eta() < fJet2MinEta || jet2->Eta() > fJet2MaxEta || jet2->Phi() < fJet2MinPhi || jet2->Phi() > fJet2MaxPhi)
       continue;
 
-    if (jet->Pt() > fMaxBinPt)
+    if (jet2->Pt() > fMaxBinPt)
       continue;
 
-    if (jet->MatchedJet()) {
+    if (jet2->MatchedJet()) {
 
-      if (!AcceptBiasJet(jet->MatchedJet()) || 
-         jet->MatchedJet()->MaxTrackPt() > fMaxTrackPt || jet->MatchedJet()->MaxClusterPt() > fMaxClusterPt ||
-         jet->MatchedJet()->Pt() > fMaxBinPt) {
-       fHistMissedMCJetsPtArea->Fill(jet->Area(), jet->Pt(), fEventWeight);
+      if (!AcceptBiasJet(jet2->MatchedJet()) || 
+         jet2->MatchedJet()->MaxTrackPt() > fMaxTrackPt || jet2->MatchedJet()->MaxClusterPt() > fMaxClusterPt ||
+         jet2->MatchedJet()->Pt() > fMaxBinPt) {
+       fHistMissedJets2PtArea->Fill(jet2->Area(), jet2->Pt());
       }
       else {
-       fHistMatchingLevelMCPt->Fill(jet->ClosestJetDistance(), jet->Pt(), fEventWeight);
-
-       Double_t deta = jet->MatchedJet()->Eta() - jet->Eta();
-       Double_t dphi = jet->MatchedJet()->Phi() - jet->Phi();
-       fHistClosestDeltaEtaPhiMCPt->Fill(deta, dphi, jet->Pt(), fEventWeight);
-
-       Double_t dpt = jet->MatchedJet()->Pt() - jet->Pt();
-       fHistClosestDeltaPtMCPt->Fill(jet->Pt(), dpt, fEventWeight);
-       fHistClosestDeltaCorrPtMCPt->Fill(jet->Pt(), dpt - fRhoVal * jet->MatchedJet()->Area(), fEventWeight);
-
-       fHistPartvsDetecPt->Fill(jet->MatchedJet()->Pt(), jet->Pt(), fEventWeight);
-       fHistPartvsDetecCorrPt->Fill(jet->MatchedJet()->Pt() - fRhoVal * jet->MatchedJet()->Area(), jet->Pt(), fEventWeight);
+       fHistMatchingLevelvsJet2Pt->Fill(jet2->ClosestJetDistance(), jet2->Pt());
+
+       Double_t deta = jet2->MatchedJet()->Eta() - jet2->Eta();
+       Double_t dphi = jet2->MatchedJet()->Phi() - jet2->Phi();
+       fHistClosestDeltaEtaPhivsJet2Pt->Fill(deta, dphi, jet2->Pt());
+
+       Double_t dpt = jet2->MatchedJet()->Pt() - jet2->Pt();
+       fHistClosestDeltaPtvsJet2Pt->Fill(jet2->Pt(), dpt);
+
+       fHistJet1PtvsJet2Pt->Fill(jet2->MatchedJet()->Pt(), jet2->Pt());
+       
+       if (!fRhoName.IsNull() || !fRho2Name.IsNull()) {
+         dpt -= fRhoVal * jet2->MatchedJet()->Area() - fRho2Val * jet2->Area();
+         fHistClosestDeltaCorrPtvsJet2Pt->Fill(jet2->Pt(), dpt);
+         fHistJet1CorrPtvsJet2CorrPt->Fill(jet2->MatchedJet()->Pt() - fRhoVal * jet2->MatchedJet()->Area(), jet2->Pt() - fRho2Val * jet2->Area());
+       }
       }
     }
     else {
-      fHistNonMatchedMCJetsPtArea->Fill(jet->Area(), jet->Pt(), fEventWeight);
-      fHistMissedMCJetsPtArea->Fill(jet->Area(), jet->Pt(), fEventWeight);
-    }
-
-    fHistMCJetsPtArea->Fill(jet->Area(), jet->Pt(), fEventWeight);
-    fHistMCJetsPhiEta->Fill(jet->Eta(), jet->Phi(), fEventWeight);
+      fHistNonMatchedJets2PtArea->Fill(jet2->Area(), jet2->Pt());
+      fHistMissedJets2PtArea->Fill(jet2->Area(), jet2->Pt());
 
-    fHistMCJetsNEFvsPt->Fill(jet->NEF(), jet->Pt(), fEventWeight);
-      
-    for (Int_t it = 0; it < jet->GetNumberOfTracks(); it++) {
-      AliVParticle *track = jet->TrackAt(it, fMCTracks);
-      if (track)
-       fHistMCJetsZvsPt->Fill(track->Pt() / jet->Pt(), jet->Pt(), fEventWeight);
+      if (!fRho2Name.IsNull())
+       fHistNonMatchedJets2CorrPtArea->Fill(jet2->Area(), jet2->Pt() - fRhoVal * jet2->Area());
     }
 
-    if (!AcceptBiasJet(jet))
-      continue;
-    if (jet->Eta() < fJetMinEta || jet->Eta() > fJetMaxEta || jet->Phi() < fJetMinPhi || jet->Phi() > fJetMaxPhi)
-      continue;
-    
-    fHistMCJetsPtAreaFiducial->Fill(jet->Area(), jet->Pt(), fEventWeight);
-    fHistMCJetsPhiEtaFiducial->Fill(jet->Eta(), jet->Phi(), fEventWeight);
+    fHistJets2PtArea->Fill(jet2->Area(), jet2->Pt());
+    fHistJets2PhiEta->Fill(jet2->Eta(), jet2->Phi());
+
+    if (!fRho2Name.IsNull())
+      fHistJets2CorrPtArea->Fill(jet2->Area(), jet2->Pt() - fRho2Val * jet2->Area());
   }
 
-  const Int_t nJets = fJets->GetEntriesFast();
+  const Int_t nJets1 = fJets->GetEntriesFast();
 
-  for (Int_t i = 0; i < nJets; i++) {
+  for (Int_t i = 0; i < nJets1; i++) {
 
-    AliEmcalJet* jet = static_cast<AliEmcalJet*>(fJets->At(i));
+    AliEmcalJet* jet1 = static_cast<AliEmcalJet*>(fJets->At(i));
 
-    if (!jet) {
-      AliError(Form("Could not receive mc jet %d", i));
+    if (!jet1) {
+      AliError(Form("Could not receive jet %d", i));
       continue;
     }  
     
-    if (!AcceptJet(jet))
+    if (!AcceptJet(jet1))
       continue;
-    if (!AcceptBiasJet(jet))
+
+    if (!AcceptBiasJet(jet1))
       continue;
-    if (jet->MaxTrackPt() > fMaxTrackPt || jet->MaxClusterPt() > fMaxClusterPt)
+
+    if (jet1->MaxTrackPt() > fMaxTrackPt || jet1->MaxClusterPt() > fMaxClusterPt)
       continue;
-    if (jet->Eta() < fJetMinEta || jet->Eta() > fJetMaxEta || jet->Phi() < fJetMinPhi || jet->Phi() > fJetMaxPhi)
+
+    if (jet1->Eta() < fJetMinEta || jet1->Eta() > fJetMaxEta || jet1->Phi() < fJetMinPhi || jet1->Phi() > fJetMaxPhi)
       continue;
 
-    if (!jet->MatchedJet()) {
-      fHistNonMatchedJetsPtArea->Fill(jet->Area(), jet->Pt(), fEventWeight);
-      fHistNonMatchedJetsCorrPtArea->Fill(jet->Area(), jet->Pt() - fRhoVal * jet->Area(), fEventWeight);
+    if (!jet1->MatchedJet()) {
+      fHistNonMatchedJets1PtArea->Fill(jet1->Area(), jet1->Pt());
+      if (!fRhoName.IsNull())
+       fHistNonMatchedJets1CorrPtArea->Fill(jet1->Area(), jet1->Pt() - fRhoVal * jet1->Area());
     }
 
-    fHistJetsPtArea->Fill(jet->Area(), jet->Pt(), fEventWeight);
-    fHistJetsCorrPtArea->Fill(jet->Area(), jet->Pt() - fRhoVal * jet->Area(), fEventWeight);
-
-    fHistJetsPhiEta->Fill(jet->Eta(), jet->Phi(), fEventWeight);
+    fHistJets1PtArea->Fill(jet1->Area(), jet1->Pt());
+    fHistJets1PhiEta->Fill(jet1->Eta(), jet1->Phi());
 
-    fHistJetsNEFvsPt->Fill(jet->NEF(), jet->Pt(), fEventWeight);
-
-    for (Int_t it = 0; it < jet->GetNumberOfTracks(); it++) {
-      AliVParticle *track = jet->TrackAt(it, fTracks);
-      if (track)
-       fHistJetsZvsPt->Fill(track->Pt() / jet->Pt(), jet->Pt(), fEventWeight);
-    }
-
-    for (Int_t ic = 0; ic < jet->GetNumberOfClusters(); ic++) {
-      AliVCluster *cluster = jet->ClusterAt(ic, fCaloClusters);
-      if (cluster) {
-       TLorentzVector nP;
-       cluster->GetMomentum(nP, fVertex);
-       fHistJetsZvsPt->Fill(nP.Pt() / jet->Pt(), jet->Pt(), fEventWeight);
-      }
-    }
+    if (!fRhoName.IsNull())
+      fHistJets1CorrPtArea->Fill(jet1->Area(), jet1->Pt() - fRhoVal * jet1->Area());
   }
 
   return kTRUE;

diff --git a/PWGJE/EMCALJetTasks/AliJetResponseMaker.h b/PWGJE/EMCALJetTasks/AliJetResponseMaker.h
index 629ef7699bf251865dc1880325d1dd3950431be1..fe7d9d1835f32020d6a13ae157aaed04e7a616af 100644 (file)
--- a/PWGJE/EMCALJetTasks/AliJetResponseMaker.h
+++ b/PWGJE/EMCALJetTasks/AliJetResponseMaker.h
@@ -17,78 +17,90 @@ class AliJetResponseMaker : public AliAnalysisTaskEmcalJet {
   AliJetResponseMaker(const char *name);
   virtual ~AliJetResponseMaker();
 
+  enum MatchingType{
+    kNoMatching = 0,
+    kGeometrical = 1,
+    kMCLabel = 2
+  };
+
   void                        UserCreateOutputObjects();
 
-  void                        SetMCJetsName(const char *n)       { fMCJetsName      = n; }
-  void                        SetMCTracksName(const char *n)     { fMCTracksName    = n; }
-  void                        SetMaxDistance(Double_t d)         { fMaxDistance     = d; }
-  void                        SetDoWeighting(Bool_t d = kTRUE)   { fDoWeighting     = d; }
-  void                        SetMCFiducial(Bool_t f = kTRUE)    { fMCFiducial      = f; }
-  void                        SetEventWeightHist(Bool_t h)       { fEventWeightHist = h; }
-  void                        SetPtHardBin(Int_t b)              { fSelectPtHardBin = b; }
-  void                        SetDoMatching(Bool_t b)            { fDoMatching      = b; }
+  void                        SetJets2Name(const char *n)                            { fJets2Name         = n         ; }
+  void                        SetTracks2Name(const char *n)                          { fTracks2Name       = n         ; }
+  void                        SetClus2Name(const char *n)                            { fCalo2Name         = n         ; }
+  void                        SetJet2EtaLimits(Float_t min=-999, Float_t max=-999)   { fJet2MinEta = min, fJet2MaxEta = max ; }
+  void                        SetJet2PhiLimits(Float_t min=-999, Float_t max=-999)   { fJet2MinPhi = min, fJet2MaxPhi = max ; }
+  void                        SetRho2Name(const char *n)                             { fRho2Name          = n         ; }
+  void                        SetPtBiasJet2Clus(Float_t b)                           { fPtBiasJet2Clus    = b         ; }
+  void                        SetPtBiasJet2Track(Float_t b)                          { fPtBiasJet2Track   = b         ; }
+  void                        SetMatching(MatchingType t, Double_t p=1)              { fMatching = t; fMatchingPar = p; }
+  void                        SetPtHardBin(Int_t b)                                  { fSelectPtHardBin   = b         ; }
+  void                        SetMCflag1(Bool_t f)                                   { fAreCollections1MC = f         ; }
+  void                        SetMCflag2(Bool_t f)                                   { fAreCollections2MC = f         ; }
 
  protected:
   Bool_t                      IsEventSelected();
-  Bool_t                      AcceptJet(AliEmcalJet* jet)   const;
+  Bool_t                      AcceptJet(AliEmcalJet* jet) const;
+  Bool_t                      AcceptBiasJet2(AliEmcalJet *jet) const;
   void                        ExecOnce();
   void                        DoJetLoop(TClonesArray *jets1, TClonesArray *jets2, Bool_t mc);
   Bool_t                      FillHistograms();
   Bool_t                      RetrieveEventObjects();
   Bool_t                      Run();
+  Double_t                    GetMatchingLevel(AliEmcalJet *jet1, AliEmcalJet *jet2) const;
 
-  TString                     fMCTracksName;                  // name of MC particle collection
-  TString                     fMCJetsName;                    // name of MC jet collection
-  Double_t                    fMaxDistance;                   // maximum distance between matched particle and detector level jets
-  Bool_t                      fDoWeighting;                   // = true, weight using trials and given x section
-  Bool_t                      fEventWeightHist;               // = true create event weight histogram
-  Bool_t                      fMCFiducial;                    // = true MC jets in fiducial acceptance
-  Double_t                    fMCminEta;                      // MC jets minimum eta
-  Double_t                    fMCmaxEta;                      // MC jets maximum eta
-  Double_t                    fMCminPhi;                      // MC jets minimum phi
-  Double_t                    fMCmaxPhi;                      // MC jets maximum phi
+  TString                     fTracks2Name;                   // name of second track collection
+  TString                     fCalo2Name;                     // name of second cluster collection
+  TString                     fJets2Name;                     // name of second jet collection
+  TString                     fRho2Name;                      // name of second jet collection
+  Float_t                     fPtBiasJet2Track;               // select jets 2 with a minimum pt track
+  Float_t                     fPtBiasJet2Clus;                // select jets 2 with a minimum pt cluster
+  Bool_t                      fAreCollections1MC;             // collections 1 MC
+  Bool_t                      fAreCollections2MC;             // collections 1 MC
+  MatchingType                fMatching;                      // matching type
+  Double_t                    fMatchingPar;                   // maximum distance between matched particle and detector level jets
+  Float_t                     fJet2MinEta;                    // minimum eta jet 2 acceptance
+  Float_t                     fJet2MaxEta;                    // maximum eta jet 2 acceptance
+  Float_t                     fJet2MinPhi;                    // minimum phi jet 2 acceptance
+  Float_t                     fJet2MaxPhi;                    // maximum phi jet 2 acceptance  
   Int_t                       fSelectPtHardBin;               // select one pt hard bin for analysis
-  Bool_t                      fDoMatching;                    // whether or not it should run the matching between MC and rec jets
 
   AliGenPythiaEventHeader    *fPythiaHeader;                  //!event Pythia header
-  Double_t                    fEventWeight;                   //!event weight
   Int_t                       fPtHardBin;                     //!event pt hard bin
   Int_t                       fNTrials;                       //!event trials
-  TClonesArray               *fMCTracks;                      //!MC particles
-  TClonesArray               *fMCJets;                        //!MC jets
+  TClonesArray               *fTracks2;                       //!Tracks 2
+  TClonesArray               *fCaloClusters2;                 //!Clusters 2
+  TClonesArray               *fJets2;                       //!Jets 2
+  AliRhoParameter            *fRho2;                          //!Event rho 2
+  Double_t                    fRho2Val;                       //!Event rho 2 value 
   // General histograms
   TH1                        *fHistNTrials;                   //!total number of trials per pt hard bin
   TH1                        *fHistEvents;                    //!total number of events per pt hard bin
-  TH1                        *fHistEventWeight[11];           //!event weight
-  // Particle level jets
-  TH2                        *fHistMCJetsPhiEta;              //!phi-eta distribution of jets
-  TH2                        *fHistMCJetsPtArea;              //!inclusive jet pt vs area histogram
-  TH2                        *fHistMCJetsPhiEtaFiducial;      //!phi-eta distribution of jets in fiducial acceptance (plus lead hadron bias)
-  TH2                        *fHistMCJetsPtAreaFiducial;      //!inclusive jet pt spectrum in fiducial acceptance (plus lead hadron bias)
-  TH2                        *fHistMCJetsNEFvsPt;             //!jet neutral energy fraction vs. jet pt
-  TH2                        *fHistMCJetsZvsPt;               //!constituent Pt over Jet Pt ratio vs. jet pt
-  // Detector level jets
-  TH2                        *fHistJetsPhiEta;                //!phi-eta distribution of jets
-  TH2                        *fHistJetsPtArea;                //!inclusive jet pt vs. area histogram
-  TH2                        *fHistJetsCorrPtArea;            //!inclusive jet pt vs. area histogram
-  TH2                        *fHistJetsNEFvsPt;               //!jet neutral energy fraction vs. jet pt
-  TH2                        *fHistJetsZvsPt;                 //!constituent Pt over Jet Pt ratio vs. jet pt
-  // Detector-particle level matching
-  TH2                        *fHistMatchingLevelMCPt;         //!matching level vs. particle level pt
-  TH3                        *fHistClosestDeltaEtaPhiMCPt;    //!delta eta-phi between closest particle level to detector level jet vs. particle level pt
-  TH2                        *fHistClosestDeltaPtMCPt;        //!delta pt between closest particle level to detector level jet vs. particle level pt
-  TH2                        *fHistClosestDeltaCorrPtMCPt;    //!delta pt between closest particle level to detector level jet vs. particle level pt
-  TH2                        *fHistNonMatchedMCJetsPtArea;    //!non-matched mc jet pt distribution
-  TH2                        *fHistNonMatchedJetsPtArea;      //!non-matched jet pt distribution
-  TH2                        *fHistNonMatchedJetsCorrPtArea;  //!non-matched jet pt distribution
-  TH2                        *fHistPartvsDetecPt;             //!particle vs detector level jet pt
-  TH2                        *fHistPartvsDetecCorrPt;         //!particle vs detector level jet pt
-  TH2                        *fHistMissedMCJetsPtArea;         //!mc jets not measured
+  // Jets 1
+  TH2                        *fHistJets1PhiEta;               //!phi-eta distribution of jets 1
+  TH2                        *fHistJets1PtArea;               //!inclusive jet pt vs area histogram 1
+  TH2                        *fHistJets1CorrPtArea;           //!inclusive jet pt vs. area histogram 1
+  // Jets 2
+  TH2                        *fHistJets2PhiEta;               //!phi-eta distribution of jets 2
+  TH2                        *fHistJets2PtArea;               //!inclusive jet pt vs. area histogram 2
+  TH2                        *fHistJets2CorrPtArea;           //!inclusive jet pt vs. area histogram 2
+  // Jet1-Jet2 matching
+  TH2                        *fHistMatchingLevelvsJet2Pt;              //!matching level vs jet 2 pt
+  TH3                        *fHistClosestDeltaEtaPhivsJet2Pt;         //!delta eta-phi between matched jets vs jet 2 pt
+  TH2                        *fHistClosestDeltaPtvsJet2Pt;             //!delta pt between matched jets vs jet 2 pt
+  TH2                        *fHistClosestDeltaCorrPtvsJet2Pt;         //!delta pt corr between matched jets vs jet 2 pt
+  TH2                        *fHistNonMatchedJets1PtArea;              //!non-matched jet 1 pt distribution
+  TH2                        *fHistNonMatchedJets2PtArea;              //!non-matched jet 2 pt distribution
+  TH2                        *fHistNonMatchedJets1CorrPtArea;          //!non-matched jet pt distribution
+  TH2                        *fHistNonMatchedJets2CorrPtArea;          //!non-matched jet pt distribution
+  TH2                        *fHistJet1PtvsJet2Pt;                     //!correlation jet 1 pt vs jet 2 pt
+  TH2                        *fHistJet1CorrPtvsJet2CorrPt;             //!correlation jet 1 corr pt vs jet 2 corr pt
+  TH2                        *fHistMissedJets2PtArea;                  //!jets 2 not found in jet 1 collection
 
  private:
   AliJetResponseMaker(const AliJetResponseMaker&);            // not implemented
   AliJetResponseMaker &operator=(const AliJetResponseMaker&); // not implemented
 
-  ClassDef(AliJetResponseMaker, 9) // Jet response matrix producing task
+  ClassDef(AliJetResponseMaker, 10) // Jet response matrix producing task
 };
 #endif

diff --git a/PWGJE/EMCALJetTasks/macros/AddTaskJetResponseMaker.C b/PWGJE/EMCALJetTasks/macros/AddTaskJetResponseMaker.C
index d0724f6dafab9611e7d3233d4606701d111190ee..ea653df54bca0601e00c2828e532de138034716d 100644 (file)
--- a/PWGJE/EMCALJetTasks/macros/AddTaskJetResponseMaker.C
+++ b/PWGJE/EMCALJetTasks/macros/AddTaskJetResponseMaker.C
@@ -63,14 +63,14 @@ AliJetResponseMaker* AddTaskJetResponseMaker(
   jetTask->SetClusName(nclusters);
   jetTask->SetJetsName(njets);
   jetTask->SetRhoName(nrho);
-  jetTask->SetMCJetsName(nmcjets);
-  jetTask->SetMCTracksName(nmctracks);
+  jetTask->SetJets2Name(nmcjets);
+  jetTask->SetTracks2Name(nmctracks);
   jetTask->SetJetRadius(jetradius);
   jetTask->SetJetPtCut(jetptcut);
   jetTask->SetPercAreaCut(jetareacut);
   jetTask->SetPtBiasJetTrack(jetBiasTrack);
   jetTask->SetPtBiasJetClus(jetBiasClus);
-  jetTask->SetMaxDistance(maxDistance);
+  jetTask->SetMatching(AliJetResponseMaker::kGeometrical, maxDistance);
   jetTask->SetVzRange(-10,10);
   jetTask->SetPtHardBin(ptHardBin);