diff --git a/PWGJE/Tasks/jetHadronRecoil.cxx b/PWGJE/Tasks/jetHadronRecoil.cxx
index 6ed91cdbbda..700ce8910f0 100644
--- a/PWGJE/Tasks/jetHadronRecoil.cxx
+++ b/PWGJE/Tasks/jetHadronRecoil.cxx
@@ -655,29 +655,20 @@ struct JetHadronRecoil {
   }
 
   template <typename T, typename U, typename X, typename Y>
-  void fillRecoilJetMatchedHistograms(T const& jetsBase, U const&, X const& tracks, Y const& particles, float weight = 1.0, float rho = 0.0, float pTHat = 999.0)
+  void fillRecoilJetMatchedHistograms(T const&, U const& jetsTag, X const& tracks, Y const& particles, float weight = 1.0, float rho = 0.0, float pTHat = 999.0)
   {
     std::vector<double> phiTTAr;
-    std::vector<double> phiTTArPart;
     double phiTT = 0;
-    double phiTTPart = 0;
     int nTT = 0;
 
-    for (const auto& track : tracks) {
-      if (!track.has_mcParticle()) {
-        continue;
-      }
-      if (!jetderiveddatautilities::selectTrack(track, trackSelection)) {
-        continue;
-      }
-      if (track.pt() > pTHatTrackMaxMCD * pTHat) {
+    for (const auto& particle : particles) {
+      if (particle.pt() > pTHatTrackMaxMCP * pTHat) {
         if (outlierRejectEvent) {
           return;
         } else {
           continue;
         }
       }
-      auto particle = track.template mcParticle_as<Y>();
       auto pdgParticle = pdg->GetParticle(particle.pdgCode());
       if (!pdgParticle) {
         continue;
@@ -687,22 +678,20 @@ struct JetHadronRecoil {
       }
       if (particle.pt() < ptTTsigMax && particle.pt() > ptTTsigMin) {
         nTT++;
-        phiTTAr.push_back(track.phi());
-        phiTTArPart.push_back(particle.phi());
+        phiTTAr.push_back(particle.phi());
       }
     }
 
     if (nTT > 0) {
       int trigNumber = rand->Integer(nTT);
       phiTT = phiTTAr[trigNumber];
-      phiTTPart = phiTTArPart[trigNumber];
     } else {
       return;
     }
 
-    for (const auto& jetBase : jetsBase) {
+    for (const auto& jetTag : jetsTag) {
 
-      if (jetBase.pt() > pTHatMaxMCD * pTHat) {
+      if (jetTag.pt() > pTHatMaxMCP * pTHat) {
         if (outlierRejectEvent) {
           return;
         } else {
@@ -710,12 +699,12 @@ struct JetHadronRecoil {
         }
       }
 
-      float dphi = RecoDecay::constrainAngle(jetBase.phi() - phiTT);
-      double dR = getWTAaxisDifference(jetBase, tracks);
+      float dphip = RecoDecay::constrainAngle(jetTag.phi() - phiTT);
+      double dRp = getWTAaxisDifference(jetTag, particles);
 
-      if (jetBase.has_matchedJetGeo()) {
-        for (const auto& jetTag : jetBase.template matchedJetGeo_as<std::decay_t<U>>()) {
-          if (jetTag.pt() > pTHatMaxMCP * pTHat) {
+      if (jetTag.has_matchedJetGeo()) {
+        for (const auto& jetBase : jetTag.template matchedJetGeo_as<std::decay_t<T>>()) {
+          if (jetBase.pt() > pTHatMaxMCD * pTHat) {
             if (outlierRejectEvent) {
               return;
             } else {
@@ -723,8 +712,8 @@ struct JetHadronRecoil {
             }
           }
 
-          float dphip = RecoDecay::constrainAngle(jetTag.phi() - phiTTPart);
-          double dRp = getWTAaxisDifference(jetTag, particles);
+          float dphi = RecoDecay::constrainAngle(jetBase.phi() - phiTT);
+          double dR = getWTAaxisDifference(jetBase, tracks);
           registry.fill(HIST("hPhiMatched"), dphi, dphip, weight);
           registry.fill(HIST("hPhiMatched2d"), jetTag.phi(), jetTag.pt(), weight);
           registry.fill(HIST("hPhiResolution"), jetTag.pt(), dphip - dphi, weight);
@@ -872,39 +861,63 @@ struct JetHadronRecoil {
   }
   PROCESS_SWITCH(JetHadronRecoil, processMCDWeightedWithRhoSubtraction, "process MC detector level with event weights and rho subtraction", false);
 
-  void processMCP(aod::JetMcCollision const& collision,
+  void processMCP(aod::JetMcCollision const& mccollision,
+                  soa::SmallGroups<aod::JetCollisionsMCD> const& collisions,
                   soa::Filtered<soa::Join<aod::ChargedMCParticleLevelJets, aod::ChargedMCParticleLevelJetConstituents>> const& jets,
                   soa::Filtered<aod::JetParticles> const& particles)
   {
-    if (std::abs(collision.posZ()) > vertexZCut) {
+    if (std::abs(mccollision.posZ()) > vertexZCut) {
       return;
     }
-    if (skipMBGapEvents && collision.subGeneratorId() == jetderiveddatautilities::JCollisionSubGeneratorId::mbGap) {
+    if (skipMBGapEvents && mccollision.subGeneratorId() == jetderiveddatautilities::JCollisionSubGeneratorId::mbGap) {
       return;
     }
-    if (collision.ptHard() < pTHatMinEvent) {
+    if (mccollision.ptHard() < pTHatMinEvent) {
       return;
     }
-    registry.fill(HIST("hZvtxSelected"), collision.posZ());
-    fillMCPHistograms(jets, particles, 1.0, collision.ptHard());
+    if (collisions.size() < 1) {
+      return;
+    }
+    for (auto const& collision : collisions) {
+      if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) {
+        return;
+      }
+      if (!jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) {
+        return;
+      }
+    }
+    registry.fill(HIST("hZvtxSelected"), mccollision.posZ());
+    fillMCPHistograms(jets, particles, 1.0, mccollision.ptHard());
   }
   PROCESS_SWITCH(JetHadronRecoil, processMCP, "process MC particle level", false);
 
-  void processMCPWeighted(aod::JetMcCollision const& collision,
+  void processMCPWeighted(aod::JetMcCollision const& mccollision,
+                          soa::SmallGroups<aod::JetCollisionsMCD> const& collisions,
                           soa::Filtered<soa::Join<aod::ChargedMCParticleLevelJets, aod::ChargedMCParticleLevelJetConstituents>> const& jets,
                           soa::Filtered<aod::JetParticles> const& particles)
   {
-    if (std::abs(collision.posZ()) > vertexZCut) {
+    if (std::abs(mccollision.posZ()) > vertexZCut) {
       return;
     }
-    if (skipMBGapEvents && collision.subGeneratorId() == jetderiveddatautilities::JCollisionSubGeneratorId::mbGap) {
+    if (skipMBGapEvents && mccollision.subGeneratorId() == jetderiveddatautilities::JCollisionSubGeneratorId::mbGap) {
       return;
     }
-    if (collision.ptHard() < pTHatMinEvent) {
+    if (mccollision.ptHard() < pTHatMinEvent) {
       return;
     }
-    registry.fill(HIST("hZvtxSelected"), collision.posZ(), collision.weight());
-    fillMCPHistograms(jets, particles, collision.weight(), collision.ptHard());
+    if (collisions.size() < 1) {
+      return;
+    }
+    for (auto const& collision : collisions) {
+      if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) {
+        return;
+      }
+      if (!jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) {
+        return;
+      }
+    }
+    registry.fill(HIST("hZvtxSelected"), mccollision.posZ(), mccollision.weight());
+    fillMCPHistograms(jets, particles, mccollision.weight(), mccollision.ptHard());
   }
   PROCESS_SWITCH(JetHadronRecoil, processMCPWeighted, "process MC particle level with event weights", false);
 
@@ -1004,75 +1017,99 @@ struct JetHadronRecoil {
   }
   PROCESS_SWITCH(JetHadronRecoil, processJetsMCPMCDMatchedWeightedWithRhoSubtraction, "process MC matched with event weights (inc jets) and rho subtraction", false);
 
-  void processRecoilJetsMCPMCDMatched(soa::Filtered<soa::Join<aod::JetCollisionsMCD, aod::JMcCollisionLbs>>::iterator const& collision,
+  void processRecoilJetsMCPMCDMatched(aod::JetMcCollisions::iterator const& mccollision,
+                                      soa::SmallGroups<aod::JetCollisionsMCD> const& collisions,
                                       soa::Filtered<soa::Join<aod::ChargedMCDetectorLevelJets, aod::ChargedMCDetectorLevelJetConstituents, aod::ChargedMCDetectorLevelJetsMatchedToChargedMCParticleLevelJets>> const& mcdjets,
-                                      soa::Filtered<aod::JetTracksMCD> const& tracks,
                                       soa::Filtered<aod::JetParticles> const& particles,
-                                      aod::JetMcCollisions const&,
+                                      soa::Filtered<aod::JetTracksMCD> const& tracks,
                                       soa::Filtered<soa::Join<aod::ChargedMCParticleLevelJets, aod::ChargedMCParticleLevelJetConstituents, aod::ChargedMCParticleLevelJetsMatchedToChargedMCDetectorLevelJets>> const& mcpjets)
   {
-    if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) {
+    if (std::abs(mccollision.posZ()) > vertexZCut) {
       return;
     }
-    if (!jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) {
+    if (skipMBGapEvents && mccollision.subGeneratorId() == jetderiveddatautilities::JCollisionSubGeneratorId::mbGap) {
       return;
     }
-    if (!collision.has_mcCollision()) {
+    if (mccollision.ptHard() < pTHatMinEvent) {
       return;
     }
-    if (collision.mcCollision().ptHard() < pTHatMinEvent) {
+    if (collisions.size() < 1) {
       return;
     }
-    registry.fill(HIST("hZvtxSelected"), collision.posZ());
-    fillRecoilJetMatchedHistograms(mcdjets, mcpjets, tracks, particles, 1.0, 0.0, collision.mcCollision().ptHard());
+    for (auto const& collision : collisions) {
+      if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) {
+        return;
+      }
+      if (!jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) {
+        return;
+      }
+    }
+    registry.fill(HIST("hZvtxSelected"), mccollision.posZ(), mccollision.weight());
+    fillRecoilJetMatchedHistograms(mcdjets, mcpjets, tracks, particles, 1.0, 0.0, mccollision.ptHard());
   }
   PROCESS_SWITCH(JetHadronRecoil, processRecoilJetsMCPMCDMatched, "process MC matched (recoil jets)", false);
 
-  void processRecoilJetsMCPMCDMatchedWeighted(soa::Filtered<soa::Join<aod::JetCollisionsMCD, aod::JMcCollisionLbs>>::iterator const& collision,
+  void processRecoilJetsMCPMCDMatchedWeighted(aod::JetMcCollisions::iterator const& mccollision,
+                                              soa::SmallGroups<aod::JetCollisionsMCD> const& collisions,
                                               soa::Filtered<soa::Join<aod::ChargedMCDetectorLevelJets, aod::ChargedMCDetectorLevelJetConstituents, aod::ChargedMCDetectorLevelJetsMatchedToChargedMCParticleLevelJets>> const& mcdjets,
                                               soa::Filtered<aod::JetTracksMCD> const& tracks,
                                               soa::Filtered<aod::JetParticles> const& particles,
-                                              aod::JetMcCollisions const&,
                                               soa::Filtered<soa::Join<aod::ChargedMCParticleLevelJets, aod::ChargedMCParticleLevelJetConstituents, aod::ChargedMCParticleLevelJetsMatchedToChargedMCDetectorLevelJets>> const& mcpjets)
   {
-    if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) {
+    if (std::abs(mccollision.posZ()) > vertexZCut) {
       return;
     }
-    if (!jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) {
+    if (skipMBGapEvents && mccollision.subGeneratorId() == jetderiveddatautilities::JCollisionSubGeneratorId::mbGap) {
       return;
     }
-    if (!collision.has_mcCollision()) {
+    if (mccollision.ptHard() < pTHatMinEvent) {
       return;
     }
-    if (collision.mcCollision().ptHard() < pTHatMinEvent) {
+    if (collisions.size() < 1) {
       return;
     }
-    registry.fill(HIST("hZvtxSelected"), collision.posZ());
-    fillRecoilJetMatchedHistograms(mcdjets, mcpjets, tracks, particles, collision.mcCollision().weight(), 0.0, collision.mcCollision().ptHard());
+    for (auto const& collision : collisions) {
+      if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) {
+        return;
+      }
+      if (!jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) {
+        return;
+      }
+    }
+    registry.fill(HIST("hZvtxSelected"), mccollision.posZ(), mccollision.weight());
+    fillRecoilJetMatchedHistograms(mcdjets, mcpjets, tracks, particles, mccollision.weight(), 0.0, mccollision.ptHard());
   }
   PROCESS_SWITCH(JetHadronRecoil, processRecoilJetsMCPMCDMatchedWeighted, "process MC matched with event weights (recoil jets)", false);
 
-  void processRecoilJetsMCPMCDMatchedWeightedWithRhoSubtraction(soa::Filtered<soa::Join<aod::JetCollisionsMCD, aod::JMcCollisionLbs, aod::BkgChargedRhos>>::iterator const& collision,
+  void processRecoilJetsMCPMCDMatchedWeightedWithRhoSubtraction(soa::Join<aod::JetMcCollisions, aod::BkgChargedRhos>::iterator const& mccollision,
+                                                                soa::SmallGroups<aod::JetCollisionsMCD> const& collisions,
                                                                 soa::Filtered<soa::Join<aod::ChargedMCDetectorLevelJets, aod::ChargedMCDetectorLevelJetConstituents, aod::ChargedMCDetectorLevelJetsMatchedToChargedMCParticleLevelJets>> const& mcdjets,
                                                                 soa::Filtered<aod::JetTracksMCD> const& tracks,
                                                                 soa::Filtered<aod::JetParticles> const& particles,
-                                                                aod::JetMcCollisions const&,
                                                                 soa::Filtered<soa::Join<aod::ChargedMCParticleLevelJets, aod::ChargedMCParticleLevelJetConstituents, aod::ChargedMCParticleLevelJetsMatchedToChargedMCDetectorLevelJets>> const& mcpjets)
   {
-    if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) {
+    if (std::abs(mccollision.posZ()) > vertexZCut) {
       return;
     }
-    if (!jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) {
+    if (skipMBGapEvents && mccollision.subGeneratorId() == jetderiveddatautilities::JCollisionSubGeneratorId::mbGap) {
       return;
     }
-    if (!collision.has_mcCollision()) {
+    if (mccollision.ptHard() < pTHatMinEvent) {
       return;
     }
-    if (collision.mcCollision().ptHard() < pTHatMinEvent) {
+    if (collisions.size() < 1) {
       return;
     }
-    registry.fill(HIST("hZvtxSelected"), collision.posZ());
-    fillRecoilJetMatchedHistograms(mcdjets, mcpjets, tracks, particles, collision.mcCollision().weight(), collision.rho(), collision.mcCollision().ptHard());
+    for (auto const& collision : collisions) {
+      if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) {
+        return;
+      }
+      if (!jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) {
+        return;
+      }
+    }
+    registry.fill(HIST("hZvtxSelected"), mccollision.posZ(), mccollision.weight());
+    fillRecoilJetMatchedHistograms(mcdjets, mcpjets, tracks, particles, mccollision.weight(), mccollision.rho(), mccollision.ptHard());
   }
   PROCESS_SWITCH(JetHadronRecoil, processRecoilJetsMCPMCDMatchedWeightedWithRhoSubtraction, "process MC matched with event weights (recoil jets) and rho subtraction", false);