diff --git a/PWGCF/Femto/Core/baseSelection.h b/PWGCF/Femto/Core/baseSelection.h
index d85829beb7a..f5487262912 100644
--- a/PWGCF/Femto/Core/baseSelection.h
+++ b/PWGCF/Femto/Core/baseSelection.h
@@ -259,25 +259,7 @@ class BaseSelection
   template <typename R>
   void setBitmask(int observableIndex, R bitmask)
   {
-    // if there are no selections configured, bail out
-    if (mSelectionContainers.at(observableIndex).isEmpty()) {
-      return;
-    }
-    // if any previous observable did not pass minimal selections, there is no point in setting bitmask for other observables
-    // minimal selection for each observable is computed after adding it
-    if (mPassesMinimalSelections == false) {
-      return;
-    }
-    // set bitmask for given observable
     mSelectionContainers.at(observableIndex).setBitmask(bitmask);
-    // check if minimal selction for this observable holds
-    if (mSelectionContainers.at(observableIndex).passesAsMinimalCut() == false) {
-      mPassesMinimalSelections = false;
-    }
-    // check if any optional selection holds
-    if (mSelectionContainers.at(observableIndex).passesAsOptionalCut() == true) {
-      mPassesOptionalSelections = true;
-    }
   }
 
   /// \brief Print detailed information about all configured selections.
diff --git a/PWGCF/Femto/Core/cascadeHistManager.h b/PWGCF/Femto/Core/cascadeHistManager.h
index 3429a9de3c2..4619b30ae26 100644
--- a/PWGCF/Femto/Core/cascadeHistManager.h
+++ b/PWGCF/Femto/Core/cascadeHistManager.h
@@ -216,13 +216,17 @@ class CascadeHistManager
   template <typename T1, typename T2>
   void fill(T1 const& cascadeCandidate, T2 const& tracks)
   {
+    // this used to work, still under investigation
+    // auto bachelor = cascadeCandidate.template bachelor_as<T2>();
+    // auto posDaughter = cascadeCandidate.template posDau_as<T2>();
+    // auto negDaughter = cascadeCandidate.template negDau_as<T2>();
 
-    auto bachelor = cascadeCandidate.template bachelor_as<T2>();
-    mBachelorManager.fill(bachelor, tracks);
-    auto posDaughter = cascadeCandidate.template posDau_as<T2>();
+    auto posDaughter = tracks.rawIteratorAt(cascadeCandidate.posDauId() - tracks.offset());
     mPosDauManager.fill(posDaughter, tracks);
-    auto negDaughter = cascadeCandidate.template negDau_as<T2>();
+    auto negDaughter = tracks.rawIteratorAt(cascadeCandidate.negDauId() - tracks.offset());
     mNegDauManager.fill(negDaughter, tracks);
+    auto bachelor = tracks.rawIteratorAt(cascadeCandidate.bachelorId() - tracks.offset());
+    mBachelorManager.fill(bachelor, tracks);
 
     if constexpr (modes::isFlagSet(mode, modes::Mode::kAnalysis)) {
       mHistogramRegistry->fill(HIST(cascadePrefix) + HIST(AnalysisDir) + HIST(getHistName(kPt, HistTable)), cascadeCandidate.pt());
diff --git a/PWGCF/Femto/Core/closePairRejection.h b/PWGCF/Femto/Core/closePairRejection.h
index 3cf20930ef4..0ea82363337 100644
--- a/PWGCF/Femto/Core/closePairRejection.h
+++ b/PWGCF/Femto/Core/closePairRejection.h
@@ -243,13 +243,17 @@ class ClosePairRejectionV0V0
     mCtrNeg.setMagField(magField);
   }
   template <typename T1, typename T2, typename T3>
-  void setPair(T1 const& v01, T2 const& v02, T3 const& /*tracks*/)
+  void setPair(T1 const& v01, T2 const& v02, T3 const& tracks)
   {
-    auto posDau1 = v01.template posDau_as<T3>();
-    auto negDau1 = v01.template posDau_as<T3>();
+    // auto posDau1 = v01.template posDau_as<T3>();
+    // auto negDau1 = v01.template posDau_as<T3>();
+    auto posDau1 = tracks.rawIteratorAt(v01.posDauId() - tracks.offset());
+    auto negDau1 = tracks.rawIteratorAt(v01.negDauId() - tracks.offset());
 
-    auto posDau2 = v02.template posDau_as<T3>();
-    auto negDau2 = v02.template posDau_as<T3>();
+    // auto posDau2 = v02.template posDau_as<T3>();
+    // auto negDau2 = v02.template posDau_as<T3>();
+    auto posDau2 = tracks.rawIteratorAt(v02.posDauId() - tracks.offset());
+    auto negDau2 = tracks.rawIteratorAt(v02.negDauId() - tracks.offset());
 
     mCtrPos.compute(posDau1, posDau2);
     mCtrNeg.compute(negDau1, negDau2);
@@ -287,13 +291,15 @@ class ClosePairRejectionTrackV0 // can also be used for any particle type that h
     mCtr.setMagField(magField);
   }
   template <typename T1, typename T2, typename T3>
-  void setPair(const T1& track, const T2& v0, const T3 /*trackTable*/)
+  void setPair(const T1& track, const T2& v0, const T3 trackTable)
   {
     if (track.signedPt() > 0) {
-      auto daughter = v0.template posDau_as<T3>();
+      // auto daughter = v0.template posDau_as<T3>();
+      auto daughter = trackTable.rawIteratorAt(v0.posDauId() - trackTable.offset());
       mCtr.compute(track, daughter);
     } else {
-      auto daughter = v0.template negDau_as<T3>();
+      // auto daughter = v0.template negDau_as<T3>();
+      auto daughter = trackTable.rawIteratorAt(v0.negDauId() - trackTable.offset());
       mCtr.compute(track, daughter);
     }
   }
@@ -328,9 +334,10 @@ class ClosePairRejectionTrackCascade
     mCtr.setMagField(magField);
   }
   template <typename T1, typename T2, typename T3>
-  void setPair(const T1& track, const T2& cascade, const T3 /*trackTable*/)
+  void setPair(const T1& track, const T2& cascade, const T3 trackTable)
   {
-    auto bachelor = cascade.template posDau_as<T3>();
+    // auto bachelor = cascade.template posDau_as<T3>();
+    auto bachelor = trackTable.rawIteratorAt(cascade.bachelorId() - trackTable.offset());
     mCtr.compute(track, bachelor);
   }
 
@@ -365,9 +372,10 @@ class ClosePairRejectionTrackKink
   }
 
   template <typename T1, typename T2, typename T3>
-  void setPair(const T1& track, const T2& kink, const T3 /*trackTable*/)
+  void setPair(const T1& track, const T2& kink, const T3 trackTable)
   {
-    auto daughter = kink.template chaDau_as<T3>();
+    // auto daughter = kink.template chaDau_as<T3>();
+    auto daughter = trackTable.rawIteratorAt(kink.chaDauId() - trackTable.offset());
     mCtr.compute(track, daughter);
   }
 
diff --git a/PWGCF/Femto/Core/collisionBuilder.h b/PWGCF/Femto/Core/collisionBuilder.h
index cd6fc90fc05..80791b52ebc 100644
--- a/PWGCF/Femto/Core/collisionBuilder.h
+++ b/PWGCF/Femto/Core/collisionBuilder.h
@@ -514,7 +514,7 @@ class CollisionBuilderDerivedToDerived
                                         col.mult(),
                                         col.cent(),
                                         col.magField());
-    newCollisionTable.producedCollisionMask(col.collisionMask());
+    newCollisionTable.producedCollisionMask(col.mask());
   }
 };
 
diff --git a/PWGCF/Femto/Core/kinkHistManager.h b/PWGCF/Femto/Core/kinkHistManager.h
index 879edf32e43..bd82a5027d8 100644
--- a/PWGCF/Femto/Core/kinkHistManager.h
+++ b/PWGCF/Femto/Core/kinkHistManager.h
@@ -274,7 +274,9 @@ class KinkHistManager
   template <typename T1, typename T2>
   void fill(T1 const& kinkcandidate, T2 const& tracks)
   {
-    auto chaDaughter = kinkcandidate.template chaDau_as<T2>();
+    // this used to work, still under investigation
+    // auto chaDaughter = kinkcandidate.template chaDau_as<T2>();
+    auto chaDaughter = tracks.rawIteratorAt(kinkcandidate.chaDauId() - tracks.offset());
     mChaDauManager.fill(chaDaughter, tracks);
     fill(kinkcandidate);
   }
diff --git a/PWGCF/Femto/Core/pairBuilder.h b/PWGCF/Femto/Core/pairBuilder.h
index 51a361a75ec..9ffd0f91465 100644
--- a/PWGCF/Femto/Core/pairBuilder.h
+++ b/PWGCF/Femto/Core/pairBuilder.h
@@ -131,7 +131,7 @@ class PairTrackTrackBuilder
   void processSameEvent(T1 const& col, T2& trackTable, T3& partition1, T4& partition2, T5& cache)
   {
     if (mSameSpecies) {
-      auto trackSlice1 = partition1->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache);
+      auto trackSlice1 = partition1->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
       if (trackSlice1.size() == 0) {
         return;
       }
@@ -139,8 +139,8 @@ class PairTrackTrackBuilder
       mCprSe.setMagField(col.magField());
       pairprocesshelpers::processSameEvent(trackSlice1, trackTable, mTrackHistManager1, mPairHistManagerSe, mCprSe, mRng, mMixIdenticalParticles);
     } else {
-      auto trackSlice1 = partition1->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache);
-      auto trackSlice2 = partition2->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache);
+      auto trackSlice1 = partition1->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
+      auto trackSlice2 = partition2->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
       if (trackSlice1.size() == 0 || trackSlice2.size() == 0) {
         return;
       }
@@ -299,7 +299,7 @@ class PairV0V0Builder
   void processSameEvent(T1 const& col, T2& trackTable, T3& /*lambdaTable*/, T4& partition1, T5& partition2, T6& cache)
   {
     if (mSameSpecies) {
-      auto v0Slice1 = partition1->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache);
+      auto v0Slice1 = partition1->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
       if (v0Slice1.size() == 0) {
         return;
       }
@@ -307,8 +307,8 @@ class PairV0V0Builder
       mCprSe.setMagField(col.magField());
       pairprocesshelpers::processSameEvent(v0Slice1, trackTable, mV0HistManager1, mPairHistManagerSe, mCprSe, mRng, mMixIdenticalParticles);
     } else {
-      auto v0Slice1 = partition1->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache);
-      auto v0Slice2 = partition2->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache);
+      auto v0Slice1 = partition1->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
+      auto v0Slice2 = partition2->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
       if (v0Slice1.size() == 0 || v0Slice2.size() == 0) {
         return;
       }
@@ -433,8 +433,8 @@ class PairTrackV0Builder
   template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
   void processSameEvent(T1 const& col, T2& trackTable, T3& trackPartition, T4& /*v0table*/, T5& v0Partition, T6& cache)
   {
-    auto trackSlice = trackPartition->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache);
-    auto v0Slice = v0Partition->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache);
+    auto trackSlice = trackPartition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
+    auto v0Slice = v0Partition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
     if (trackSlice.size() == 0 || v0Slice.size() == 0) {
       return;
     }
@@ -538,8 +538,8 @@ class PairTrackTwoTrackResonanceBuilder
   template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
   void processSameEvent(T1 const& col, T2& trackTable, T3& trackPartition, T4& /*resonanceTable*/, T5& resonancePartition, T6& cache)
   {
-    auto trackSlice = trackPartition->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache);
-    auto v0Slice = resonancePartition->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache);
+    auto trackSlice = trackPartition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
+    auto v0Slice = resonancePartition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
     if (trackSlice.size() == 0 || v0Slice.size() == 0) {
       return;
     }
@@ -624,12 +624,12 @@ class PairTrackKinkBuilder
 
     mPairHistManagerSe.init(registry, pairHistSpec);
     mPairHistManagerSe.setMass(confTrackSelection.pdgCode.value, confKinkSelection.pdgCode.value);
-    mPairHistManagerSe.setCharge(confTrackSelection.chargeAbs.value, confKinkSelection.sign.value);
+    mPairHistManagerSe.setCharge(confTrackSelection.chargeAbs.value, 1); // abs charge of kink daughter is always 1
     mCprSe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection.chargeAbs.value, confCpr.on.value);
 
     mPairHistManagerMe.init(registry, pairHistSpec);
     mPairHistManagerMe.setMass(confTrackSelection.pdgCode.value, confKinkSelection.pdgCode.value);
-    mPairHistManagerMe.setCharge(confTrackSelection.chargeAbs.value, confKinkSelection.sign.value);
+    mPairHistManagerMe.setCharge(confTrackSelection.chargeAbs.value, 1); // abs charge of kink daughter is always 1
     mCprMe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection.chargeAbs.value, confCpr.on.value);
 
     // setup mixing
@@ -640,8 +640,8 @@ class PairTrackKinkBuilder
   template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
   void processSameEvent(T1 const& col, T2& trackTable, T3& trackPartition, T4& /*kinktable*/, T5& kinkPartition, T6& cache)
   {
-    auto trackSlice = trackPartition->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache);
-    auto kinkSlice = kinkPartition->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache);
+    auto trackSlice = trackPartition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
+    auto kinkSlice = kinkPartition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
     if (trackSlice.size() == 0 || kinkSlice.size() == 0) {
       return;
     }
@@ -732,12 +732,12 @@ class PairTrackCascadeBuilder
 
     mPairHistManagerSe.init(registry, pairHistSpec);
     mPairHistManagerSe.setMass(confTrackSelection.pdgCode.value, confCascadeSelection.pdgCode.value);
-    mPairHistManagerSe.setCharge(confTrackSelection.chargeAbs.value, confCascadeSelection.sign.value);
+    mPairHistManagerSe.setCharge(confTrackSelection.chargeAbs.value, 1);
     mCprSe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection.chargeAbs.value, confCpr.on.value);
 
     mPairHistManagerMe.init(registry, pairHistSpec);
     mPairHistManagerMe.setMass(confTrackSelection.pdgCode.value, confCascadeSelection.pdgCode.value);
-    mPairHistManagerMe.setCharge(confTrackSelection.chargeAbs.value, confCascadeSelection.sign.value);
+    mPairHistManagerMe.setCharge(confTrackSelection.chargeAbs.value, 1);
     mCprMe.init(registry, cprHistSpec, confCpr.detaMax.value, confCpr.dphistarMax.value, confTrackSelection.chargeAbs.value, confCpr.on.value);
 
     // setup mixing
@@ -748,8 +748,8 @@ class PairTrackCascadeBuilder
   template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
   void processSameEvent(T1 const& col, T2& trackTable, T3& trackPartition, T4& /*cascadeTable*/, T5& v0Partition, T6& cache)
   {
-    auto trackSlice = trackPartition->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache);
-    auto v0Slice = v0Partition->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache);
+    auto trackSlice = trackPartition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
+    auto v0Slice = v0Partition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
     if (trackSlice.size() == 0 || v0Slice.size() == 0) {
       return;
     }
diff --git a/PWGCF/Femto/Core/pairHistManager.h b/PWGCF/Femto/Core/pairHistManager.h
index 8a4f58b44b1..6b296d0af9e 100644
--- a/PWGCF/Femto/Core/pairHistManager.h
+++ b/PWGCF/Femto/Core/pairHistManager.h
@@ -171,10 +171,10 @@ class PairHistManager
   }
   void setCharge(int chargeAbsParticle1, int chargeAbsParticle2)
   {
-    // the pt stored is actually pt/z, so in case of particles with z > 1, we have to rescale the pt (this is so far only for He3 the case)
+    // the pt stored is actually as pt/z for tracks, so in case of particles with z > 1, we have to rescale the pt (this is so far only for He3 the case)
     // similarly, for neutral particles, no reason to rescale so we just set absolute charge to 1
-    mAbsCharge1 = chargeAbsParticle1;
-    mAbsCharge2 = chargeAbsParticle2;
+    mAbsCharge1 = std::abs(chargeAbsParticle1);
+    mAbsCharge2 = std::abs(chargeAbsParticle2);
   }
 
   template <typename T1, typename T2>
diff --git a/PWGCF/Femto/Core/pairProcessHelpers.h b/PWGCF/Femto/Core/pairProcessHelpers.h
index 2d4a6f38bdd..ebcc6ec969d 100644
--- a/PWGCF/Femto/Core/pairProcessHelpers.h
+++ b/PWGCF/Femto/Core/pairProcessHelpers.h
@@ -112,51 +112,6 @@ void processSameEvent(T1 const& SliceParticle1,
   }
 }
 
-// process same event for tracks and particles decaying into tracks
-// template <typename T1,
-//           typename T2,
-//           typename T3,
-//           typename T4,
-//           typename T5,
-//           typename T6,
-//           typename T7,
-//           typename T8>
-// void processSameEvent(T1& SliceParticle1,
-//                       T2& SliceParticle2,
-//                       T3& TrackTable,
-//                       T4& ParticleHistManager1,
-//                       T5& ParticleHistManager2,
-//                       T6& PairHistManager,
-//                       T7& CprManager,
-//                       T8& PcManager)
-// {
-//   // Fill single particle histograms
-//   for (auto const& part : SliceParticle1) {
-//     ParticleHistManager1.fill(part);
-//   }
-//
-//   for (auto const& part : SliceParticle2) {
-//     ParticleHistManager2.fill(part, TrackTable);
-//   }
-//
-//   for (auto const& [p1, p2] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(SliceParticle1, SliceParticle2))) {
-//     // pair cleaning
-//     if (!PcManager.isCleanPair(p1, p2, TrackTable)) {
-//       continue;
-//     }
-//     // Close pair rejection
-//     if (CprManager.isActivated()) {
-//       CprManager.setPair(p1, p2, TrackTable);
-//       if (CprManager.isClosePair()) {
-//         continue;
-//       }
-//     }
-//     CprManager.fill();
-//     PairHistManager.setPair(p1, p2);
-//     PairHistManager.fill();
-//   }
-// }
-
 // process mixed event for identical particles
 template <typename T1,
           typename T2,
@@ -182,8 +137,8 @@ void processMixedEvent(T1& Collisions,
       continue;
     }
     CprManager.setMagField(collision1.magField());
-    auto sliceParticle1 = Partition->sliceByCached(o2::aod::femtobase::stored::collisionId, collision1.globalIndex(), cache);
-    auto sliceParticle2 = Partition->sliceByCached(o2::aod::femtobase::stored::collisionId, collision2.globalIndex(), cache);
+    auto sliceParticle1 = Partition->sliceByCached(o2::aod::femtobase::stored::fColId, collision1.globalIndex(), cache);
+    auto sliceParticle2 = Partition->sliceByCached(o2::aod::femtobase::stored::fColId, collision2.globalIndex(), cache);
     if (sliceParticle1.size() == 0 || sliceParticle2.size() == 0) {
       continue;
     }
@@ -233,8 +188,8 @@ void processMixedEvent(T1& Collisions,
       continue;
     }
     CprManager.setMagField(collision1.magField());
-    auto sliceParticle1 = Partition1->sliceByCached(o2::aod::femtobase::stored::collisionId, collision1.globalIndex(), cache);
-    auto sliceParticle2 = Partition2->sliceByCached(o2::aod::femtobase::stored::collisionId, collision2.globalIndex(), cache);
+    auto sliceParticle1 = Partition1->sliceByCached(o2::aod::femtobase::stored::fColId, collision1.globalIndex(), cache);
+    auto sliceParticle2 = Partition2->sliceByCached(o2::aod::femtobase::stored::fColId, collision2.globalIndex(), cache);
     if (sliceParticle1.size() == 0 || sliceParticle2.size() == 0) {
       continue;
     }
@@ -256,57 +211,6 @@ void processMixedEvent(T1& Collisions,
     }
   }
 }
-
-// // process mixed event for track and particles decaying into tracks
-// template <typename T1,
-//           typename T2,
-//           typename T3,
-//           typename T4,
-//           typename T5,
-//           typename T6,
-//           typename T7,
-//           typename T8,
-//           typename T9,
-//           typename T10>
-// void processMixedEvent(T1& Collisions,
-//                        T2& Partition1,
-//                        T3& Partition2,
-//                        T4& TrackTable,
-//                        T5& cache,
-//                        T6& policy,
-//                        T7& depth,
-//                        T8& PairHistManager,
-//                        T9& CprManager,
-//                        T10& PcManager)
-// {
-//   for (auto const& [collision1, collision2] : o2::soa::selfCombinations(policy, depth, -1, Collisions, Collisions)) {
-//     if (!(std::fabs(collision1.magField() - collision2.magField()) < o2::constants::math::Epsilon)) {
-//       continue;
-//     }
-//     CprManager.setMagField(collision1.magField());
-//     auto sliceParticle1 = Partition1->sliceByCached(o2::aod::femtobase::stored::collisionId, collision1.globalIndex(), cache);
-//     auto sliceParticle2 = Partition2->sliceByCached(o2::aod::femtobase::stored::collisionId, collision2.globalIndex(), cache);
-//     if (sliceParticle1.size() == 0 || sliceParticle2.size() == 0) {
-//       continue;
-//     }
-//     for (auto const& [p1, p2] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(sliceParticle1, sliceParticle2))) {
-//       // pair cleaning
-//       if (!PcManager.isCleanPair(p1, p2, TrackTable)) {
-//         continue;
-//       }
-//       // Close pair rejection
-//       if (CprManager.isActivated()) {
-//         CprManager.setPair(p1, p2, TrackTable);
-//         if (CprManager.isClosePair()) {
-//           continue;
-//         }
-//       }
-//       CprManager.fill();
-//       PairHistManager.setPair(p1, p2);
-//       PairHistManager.fill();
-//     }
-//   }
-// }
 } // namespace pairprocesshelpers
 } // namespace o2::analysis::femto
 
diff --git a/PWGCF/Femto/Core/partitions.h b/PWGCF/Femto/Core/partitions.h
index f1d3775cfd0..6d5cf0dac81 100644
--- a/PWGCF/Femto/Core/partitions.h
+++ b/PWGCF/Femto/Core/partitions.h
@@ -22,7 +22,7 @@
     (femtocollisions::mult >= selection.multMin && femtocollisions::mult <= selection.multMax) &&                                                           \
     (femtocollisions::cent >= selection.centMin && femtocollisions::cent <= selection.centMax) &&                                                           \
     (femtocollisions::magField >= static_cast<int8_t>(selection.magFieldMin) && femtocollisions::magField <= static_cast<int8_t>(selection.magFieldMax)) && \
-    ncheckbit(femtocollisions::collisionMask, selection.collisionMask)
+    ncheckbit(femtocollisions::mask, selection.collisionMask)
 
 // standard track partition
 #define MAKE_TRACK_PARTITION(selection)                                                                                                                                         \
@@ -34,8 +34,8 @@
     (femtobase::stored::phi > selection.phiMin) &&                                                                                                                              \
     (femtobase::stored::phi < selection.phiMax) &&                                                                                                                              \
     ifnode(nabs(selection.chargeAbs.node() * femtobase::stored::signedPt) * (nexp(femtobase::stored::eta) + nexp(-1.f * femtobase::stored::eta)) / (2.f) <= selection.pidThres, \
-           ncheckbit(femtotracks::trackMask, selection.maskLowMomentum),                                                                                                        \
-           ncheckbit(femtotracks::trackMask, selection.maskHighMomentum))
+           ncheckbit(femtotracks::mask, selection.maskLowMomentum),                                                                                                             \
+           ncheckbit(femtotracks::mask, selection.maskHighMomentum))
 
 // partition for phis and rhos, i.e. resonance that are their own antiparticle
 #define MAKE_RESONANCE_0_PARTITON(selection)                                            \
diff --git a/PWGCF/Femto/Core/trackBuilder.h b/PWGCF/Femto/Core/trackBuilder.h
index dbf670459eb..6a343d2ebbb 100644
--- a/PWGCF/Femto/Core/trackBuilder.h
+++ b/PWGCF/Femto/Core/trackBuilder.h
@@ -640,8 +640,8 @@ class TrackBuilderDerivedToDerived
   template <typename T1, typename T2, typename T3, typename T4, typename T5>
   bool collisionHasTooFewTracks(T1& col, T2& /*trackTable*/, T3& partitionTrack1, T4& partitionTrack2, T5& cache)
   {
-    auto trackSlice1 = partitionTrack1->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache);
-    auto trackSlice2 = partitionTrack2->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache);
+    auto trackSlice1 = partitionTrack1->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
+    auto trackSlice2 = partitionTrack2->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
     if (trackSlice1.size() >= mLimitTrack1 && trackSlice2.size() >= mLimitTrack2) {
       return false;
     }
@@ -651,8 +651,8 @@ class TrackBuilderDerivedToDerived
   template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
   void processTracks(T1& col, T2& /*trackTable*/, T3& partitionTrack1, T4& partitionTrack2, T5& indexMap, T6& cache, T7& newTrackTable, T8& newCollisionTable)
   {
-    auto trackSlice1 = partitionTrack1->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache);
-    auto trackSlice2 = partitionTrack2->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache);
+    auto trackSlice1 = partitionTrack1->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
+    auto trackSlice2 = partitionTrack2->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
 
     for (auto const& track : trackSlice1) {
       this->fillTrack(track, newTrackTable, newCollisionTable, indexMap);
@@ -669,7 +669,7 @@ class TrackBuilderDerivedToDerived
                                  track.signedPt(),
                                  track.eta(),
                                  track.phi());
-    trackProducts.producedTrackMasks(track.trackMask());
+    trackProducts.producedTrackMasks(track.mask());
     indexMap.emplace(track.globalIndex(), trackProducts.producedTracks.lastIndex());
   }
 
diff --git a/PWGCF/Femto/Core/twoTrackResonanceBuilder.h b/PWGCF/Femto/Core/twoTrackResonanceBuilder.h
index 185611e12f1..28d62a7c932 100644
--- a/PWGCF/Femto/Core/twoTrackResonanceBuilder.h
+++ b/PWGCF/Femto/Core/twoTrackResonanceBuilder.h
@@ -464,8 +464,8 @@ template <modes::TwoTrackResonance resoType>
 class TwoTrackResonanceBuilder
 {
  public:
-  TwoTrackResonanceBuilder() {}
-  virtual ~TwoTrackResonanceBuilder() = default;
+  TwoTrackResonanceBuilder() = default;
+  ~TwoTrackResonanceBuilder() = default;
 
   template <typename T1, typename T2, typename T3, typename T4, typename T5>
   void init(T1& config, T2& filter, T3& daughterFilter, T4& table, T5 initContext)
diff --git a/PWGCF/Femto/Core/twoTrackResonanceHistManager.h b/PWGCF/Femto/Core/twoTrackResonanceHistManager.h
index 38e4c6e3460..895a3ba83c4 100644
--- a/PWGCF/Femto/Core/twoTrackResonanceHistManager.h
+++ b/PWGCF/Femto/Core/twoTrackResonanceHistManager.h
@@ -162,9 +162,12 @@ class TwoTrackResonanceHistManager
   template <typename T1, typename T2>
   void fill(T1 const& resonance, T2 const& tracks)
   {
-    auto posDaughter = resonance.template posDau_as<T2>();
+    // this used to work, still under investigation
+    // auto posDaughter = resonance.template posDau_as<T2>();
+    // auto negDaughter = resonance.template negDau_as<T2>();
+    auto posDaughter = tracks.rawIteratorAt(resonance.posDauId() - tracks.offset());
     mPosDauManager.fill(posDaughter, tracks);
-    auto negDaughter = resonance.template negDau_as<T2>();
+    auto negDaughter = tracks.rawIteratorAt(resonance.negDauId() - tracks.offset());
     mNegDauManager.fill(negDaughter, tracks);
 
     if constexpr (modes::isFlagSet(mode, modes::Mode::kAnalysis)) {
diff --git a/PWGCF/Femto/Core/v0Builder.h b/PWGCF/Femto/Core/v0Builder.h
index 0364c3c5a0a..7013e2c5722 100644
--- a/PWGCF/Femto/Core/v0Builder.h
+++ b/PWGCF/Femto/Core/v0Builder.h
@@ -500,7 +500,7 @@ class V0BuilderDerivedToDerived
   template <typename T1, typename T2, typename T3, typename T4>
   bool collisionHasTooFewLambdas(T1& col, T2& /*lambdaTable*/, T3& partitionLambda, T4& cache)
   {
-    auto lambdaSlice = partitionLambda->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache);
+    auto lambdaSlice = partitionLambda->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
     if (lambdaSlice.size() >= mLimitLambda) {
       return false;
     }
@@ -510,7 +510,7 @@ class V0BuilderDerivedToDerived
   template <typename T1, typename T2, typename T3, typename T4>
   bool collisionHasTooFewK0shorts(T1& col, T2& /*k0shortTable*/, T3& partitionK0short, T4& cache)
   {
-    auto k0shortSlice = partitionK0short->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache);
+    auto k0shortSlice = partitionK0short->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
     if (k0shortSlice.size() >= mLimitK0short) {
       return false;
     }
@@ -520,7 +520,7 @@ class V0BuilderDerivedToDerived
   template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
   void processLambdas(T1& col, T2& /*lambdaTable*/, T3& /*oldTrackTable*/, T4& partitionLambda, T5& trackBuilder, T6& indexMap, T7& cache, T8& newLambdaTable, T9& newTrackTable, T10& newCollisionTable)
   {
-    auto lambdaSlice = partitionLambda->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache);
+    auto lambdaSlice = partitionLambda->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
 
     for (auto const& lambda : lambdaSlice) {
 
@@ -544,7 +544,7 @@ class V0BuilderDerivedToDerived
   template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
   void processK0shorts(T1& col, T2& /*k0shortTable*/, T3& /*oldTrackTable*/, T4& partitionK0short, T5& trackBuilder, T6& indexMap, T7& cache, T8& newK0shortTable, T9& newTrackTable, T10& newCollisionTable)
   {
-    auto k0shortSlice = partitionK0short->sliceByCached(o2::aod::femtobase::stored::collisionId, col.globalIndex(), cache);
+    auto k0shortSlice = partitionK0short->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
 
     for (auto const& k0short : k0shortSlice) {
 
diff --git a/PWGCF/Femto/Core/v0HistManager.h b/PWGCF/Femto/Core/v0HistManager.h
index f402b8e0fab..fe0cb31b04e 100644
--- a/PWGCF/Femto/Core/v0HistManager.h
+++ b/PWGCF/Femto/Core/v0HistManager.h
@@ -259,9 +259,12 @@ class V0HistManager
   template <typename T1, typename T2>
   void fill(T1 const& v0candidate, T2 const& tracks)
   {
-    auto posDaughter = v0candidate.template posDau_as<T2>();
+    // this used to work, still under investigation
+    // auto posDaughter = v0candidate.template posDau_as<T2>();
+    // auto negDaughter = v0candidate.template negDau_as<T2>();
+    auto posDaughter = tracks.rawIteratorAt(v0candidate.posDauId() - tracks.offset());
     mPosDauManager.fill(posDaughter, tracks);
-    auto negDaughter = v0candidate.template negDau_as<T2>();
+    auto negDaughter = tracks.rawIteratorAt(v0candidate.negDauId() - tracks.offset());
     mNegDauManager.fill(negDaughter, tracks);
 
     if constexpr (modes::isFlagSet(mode, modes::Mode::kAnalysis)) {
diff --git a/PWGCF/Femto/DataModel/FemtoTables.h b/PWGCF/Femto/DataModel/FemtoTables.h
index fb0d7d85a47..f17d7c3d1ae 100644
--- a/PWGCF/Femto/DataModel/FemtoTables.h
+++ b/PWGCF/Femto/DataModel/FemtoTables.h
@@ -33,8 +33,8 @@ namespace o2::aod
 {
 namespace femtocollisions
 {
-DECLARE_SOA_COLUMN(CollisionMask, collisionMask, femtodatatypes::CollisionMaskType); //! Bitmask for collision selections
-DECLARE_SOA_COLUMN(CollisionTag, collisionTag, femtodatatypes::CollisionTagType);    //! Bitmask for collision selections
+DECLARE_SOA_COLUMN(Mask, mask, femtodatatypes::CollisionMaskType);                //! Bitmask for collision selections
+DECLARE_SOA_COLUMN(CollisionTag, collisionTag, femtodatatypes::CollisionTagType); //! Bitmask for collision selections
 
 DECLARE_SOA_COLUMN(PosX, posX, float);             //! x coordinate of vertex
 DECLARE_SOA_COLUMN(PosY, posY, float);             //! y coordinate of vertex
@@ -59,7 +59,7 @@ using StoredFCols = StoredFCols_001;
 
 // table for collisions selections
 DECLARE_SOA_TABLE_STAGED_VERSIONED(FColMasks_001, "FCOLMASK", 1, //! track masks
-                                   femtocollisions::CollisionMask);
+                                   femtocollisions::Mask);
 using FColMasks = FColMasks_001;
 using StoredFColMasks = StoredFColMasks_001;
 
@@ -100,14 +100,13 @@ namespace femtobase
 namespace stored
 {
 // static columns
-//
-DECLARE_SOA_INDEX_COLUMN(Collision, collision); //! collision index of femto collision table
-DECLARE_SOA_COLUMN(SignedPt, signedPt, float);  //! signed pt
-DECLARE_SOA_COLUMN(Pt, pt, float);              //! pt
-DECLARE_SOA_COLUMN(Eta, eta, float);            //! eta
-DECLARE_SOA_COLUMN(Phi, phi, float);            //! phi
-DECLARE_SOA_COLUMN(Mass, mass, float);          //! mass of particle
-DECLARE_SOA_COLUMN(MassAnti, massAnti, float);  //! mass of antiparticle
+DECLARE_SOA_INDEX_COLUMN(FCol, fCol);          //! collision index of femto collision table
+DECLARE_SOA_COLUMN(SignedPt, signedPt, float); //! signed pt
+DECLARE_SOA_COLUMN(Pt, pt, float);             //! pt
+DECLARE_SOA_COLUMN(Eta, eta, float);           //! eta
+DECLARE_SOA_COLUMN(Phi, phi, float);           //! phi
+DECLARE_SOA_COLUMN(Mass, mass, float);         //! mass of particle
+DECLARE_SOA_COLUMN(MassAnti, massAnti, float); //! mass of antiparticle
 } // namespace stored
 
 namespace dynamic
@@ -148,7 +147,7 @@ DECLARE_SOA_DYNAMIC_COLUMN(Theta, theta, //! theta
 namespace femtotracks
 {
 // columns for track selections
-DECLARE_SOA_COLUMN(TrackMask, trackMask, femtodatatypes::TrackMaskType); //! Bitmask for track selections
+DECLARE_SOA_COLUMN(Mask, mask, femtodatatypes::TrackMaskType); //! Bitmask for track selections
 
 // columns for DCA
 DECLARE_SOA_COLUMN(DcaXY, dcaXY, float);                                                                        //! Dca in XY plane
@@ -227,7 +226,7 @@ DECLARE_SOA_DYNAMIC_COLUMN(TpctofNSigmaHe, tpctofNSigmaHe, [](float tpc, float t
 // table for basic track information
 DECLARE_SOA_TABLE_STAGED_VERSIONED(FTracks_001, "FTRACK", 1, //! femto tracks
                                    o2::soa::Index<>,
-                                   femtobase::stored::CollisionId,
+                                   femtobase::stored::FColId,
                                    femtobase::stored::SignedPt,
                                    femtobase::stored::Eta,
                                    femtobase::stored::Phi,
@@ -244,7 +243,7 @@ using StoredFTracks = StoredFTracks_001;
 
 // table for track selections and PID selections
 DECLARE_SOA_TABLE_STAGED_VERSIONED(FTrackMasks_001, "FTRACKMASK", 1, //! track masks
-                                   femtotracks::TrackMask);
+                                   femtotracks::Mask);
 using FTrackMasks = FTrackMasks_001;
 using StoredFTrackMasks = StoredFTrackMasks_001;
 
@@ -338,7 +337,7 @@ DECLARE_SOA_INDEX_COLUMN_FULL(NegDau, negDau, int32_t, FTracks, "_NegDau"); //!
 // table for phis
 DECLARE_SOA_TABLE_STAGED_VERSIONED(FPhis_001, "FPHI", 1, //! femto phis
                                    o2::soa::Index<>,
-                                   femtobase::stored::CollisionId,
+                                   femtobase::stored::FColId,
                                    femtobase::stored::Pt,
                                    femtobase::stored::Eta,
                                    femtobase::stored::Phi,
@@ -358,7 +357,7 @@ using FPhiMasks = FPhiMasks_001;
 // table for kstars
 DECLARE_SOA_TABLE_STAGED_VERSIONED(FKstar0s_001, "FKSTAR0", 1, //! femto k0star
                                    o2::soa::Index<>,
-                                   femtobase::stored::CollisionId,
+                                   femtobase::stored::FColId,
                                    femtobase::stored::SignedPt, //! +1 for k0star and -1 for k0starbar
                                    femtobase::stored::Eta,
                                    femtobase::stored::Phi,
@@ -379,7 +378,7 @@ using FKstar0Masks = FKstar0Masks_001;
 
 DECLARE_SOA_TABLE_STAGED_VERSIONED(FRho0s_001, "FRHO0", 1, //! femto rho0s
                                    o2::soa::Index<>,
-                                   femtobase::stored::CollisionId,
+                                   femtobase::stored::FColId,
                                    femtobase::stored::Pt,
                                    femtobase::stored::Eta,
                                    femtobase::stored::Phi,
@@ -425,7 +424,7 @@ DECLARE_SOA_INDEX_COLUMN_FULL(NegDau, negDau, int32_t, FTracks, "_NegDau"); //!
 // table for basic lambda information
 DECLARE_SOA_TABLE_STAGED_VERSIONED(FLambdas_001, "FLAMBDA", 1, //! femto lambdas
                                    o2::soa::Index<>,
-                                   femtobase::stored::CollisionId,
+                                   femtobase::stored::FColId,
                                    femtobase::stored::SignedPt, // use sign to differentiate between lambda (+1) and antilambda (-1)
                                    femtobase::stored::Eta,
                                    femtobase::stored::Phi,
@@ -463,7 +462,7 @@ using FLambdaExtras = FLambdaExtras_001;
 // table for basic k0short information
 DECLARE_SOA_TABLE_STAGED_VERSIONED(FK0shorts_001, "FK0SHORT", 1, //! femto k0shorts
                                    o2::soa::Index<>,
-                                   femtobase::stored::CollisionId,
+                                   femtobase::stored::FColId,
                                    femtobase::stored::Pt,
                                    femtobase::stored::Eta,
                                    femtobase::stored::Phi,
@@ -517,7 +516,7 @@ DECLARE_SOA_INDEX_COLUMN_FULL(ChaDau, chaDau, int32_t, FTracks, "_ChaDau"); //!
 // table for basic sigma minus information
 DECLARE_SOA_TABLE_STAGED_VERSIONED(FSigmas_001, "FSIGMA", 1,
                                    o2::soa::Index<>,
-                                   femtobase::stored::CollisionId, // use sign to differentiate between sigma minus (-1) and anti sigma minus (+1)
+                                   femtobase::stored::FColId, // use sign to differentiate between sigma minus (-1) and anti sigma minus (+1)
                                    femtobase::stored::SignedPt,
                                    femtobase::stored::Eta,
                                    femtobase::stored::Phi,
@@ -571,7 +570,7 @@ DECLARE_SOA_INDEX_COLUMN_FULL(Bachelor, bachelor, int32_t, FTracks, "_Bachelor")
 
 DECLARE_SOA_TABLE_STAGED_VERSIONED(FXis_001, "FXI", 1, //! femto xis
                                    o2::soa::Index<>,
-                                   femtobase::stored::CollisionId,
+                                   femtobase::stored::FColId,
                                    femtobase::stored::SignedPt,
                                    femtobase::stored::Eta,
                                    femtobase::stored::Phi,
@@ -605,7 +604,7 @@ using FXiExtras = FXiExtras_001;
 
 DECLARE_SOA_TABLE_STAGED_VERSIONED(FOmegas_001, "FOMEGA", 1, //! femto omegas
                                    o2::soa::Index<>,
-                                   femtobase::stored::CollisionId,
+                                   femtobase::stored::FColId,
                                    femtobase::stored::SignedPt,
                                    femtobase::stored::Eta,
                                    femtobase::stored::Phi,
diff --git a/PWGCF/Femto/TableProducer/femtoProducer.cxx b/PWGCF/Femto/TableProducer/femtoProducer.cxx
index 457706ac058..561963ce797 100644
--- a/PWGCF/Femto/TableProducer/femtoProducer.cxx
+++ b/PWGCF/Femto/TableProducer/femtoProducer.cxx
@@ -126,7 +126,7 @@ struct FemtoProducer {
   twotrackresonancebuilder::ConfTwoTrackResonanceDaughterFilters confResonanceDaughterFilters;
   // caching and preslicing
   SliceCache cache;
-  Preslice<Tracks> perColTracks = o2::aod::track::collisionId;
+  Preslice<Tracks> perColTracks = track::collisionId;
   Partition<consumeddata::Run3FullPidTracks> partitionPositiveDaughters =
     (track::signed1Pt > 0.f) &&
     (track::pt > confResonanceDaughterFilters.ptMin && track::pt < confResonanceDaughterFilters.ptMax) &&
@@ -226,8 +226,8 @@ struct FemtoProducer {
   template <typename T1, typename T2>
   void processResonances(T1 const& col, T2 const& /*tracks*/)
   {
-    auto groupPositiveTracks = partitionPositiveDaughters->sliceByCached(o2::aod::track::collisionId, col.globalIndex(), cache);
-    auto groupNegativeTracks = partitionNegativeDaughters->sliceByCached(o2::aod::track::collisionId, col.globalIndex(), cache);
+    auto groupPositiveTracks = partitionPositiveDaughters->sliceByCached(track::collisionId, col.globalIndex(), cache);
+    auto groupNegativeTracks = partitionNegativeDaughters->sliceByCached(track::collisionId, col.globalIndex(), cache);
     rho0Builder.fillResonances(collisionBuilderProducts, trackBuilderProducts, twoTrackResonanceBuilderProducts, groupPositiveTracks, groupNegativeTracks, trackBuilder, indexMapTracks);
     phiBuilder.fillResonances(collisionBuilderProducts, trackBuilderProducts, twoTrackResonanceBuilderProducts, groupPositiveTracks, groupNegativeTracks, trackBuilder, indexMapTracks);
     kstar0Builder.fillResonances(collisionBuilderProducts, trackBuilderProducts, twoTrackResonanceBuilderProducts, groupPositiveTracks, groupNegativeTracks, trackBuilder, indexMapTracks);
diff --git a/PWGCF/Femto/TableProducer/femtoProducerDerivedToDerived.cxx b/PWGCF/Femto/TableProducer/femtoProducerDerivedToDerived.cxx
index bbeac637531..d3806ae5f78 100644
--- a/PWGCF/Femto/TableProducer/femtoProducerDerivedToDerived.cxx
+++ b/PWGCF/Femto/TableProducer/femtoProducerDerivedToDerived.cxx
@@ -67,7 +67,7 @@ struct FemtoProducerDerivedToDerived {
 
   Partition<Tracks> trackPartition1 = MAKE_TRACK_PARTITION(trackSelections1);
   Partition<Tracks> trackPartition2 = MAKE_TRACK_PARTITION(trackSelections2);
-  Preslice<Tracks> perColTracks = femtobase::stored::collisionId;
+  Preslice<Tracks> perColTracks = femtobase::stored::fColId;
 
   // v0 builder
   v0builder::V0BuilderDerivedToDerived v0Builder;
@@ -76,11 +76,11 @@ struct FemtoProducerDerivedToDerived {
 
   v0builder::ConfLambdaSelection1 lambdaSelection1;
   Partition<Lambdas> lambdaPartition = MAKE_LAMBDA_PARTITION(lambdaSelection1);
-  Preslice<Lambdas> perColLambdas = femtobase::stored::collisionId;
+  Preslice<Lambdas> perColLambdas = femtobase::stored::fColId;
 
   v0builder::ConfK0shortSelection1 k0shortSelection1;
   Partition<K0shorts> k0shortPartition = MAKE_K0SHORT_PARTITION(k0shortSelection1);
-  Preslice<K0shorts> perColK0shorts = femtobase::stored::collisionId;
+  Preslice<K0shorts> perColK0shorts = femtobase::stored::fColId;
 
   std::unordered_map<int64_t, int64_t>
     indexMapTracks; // for mapping tracks to lambdas, cascades and resonances
diff --git a/PWGCF/Femto/Tasks/femtoCascadeQa.cxx b/PWGCF/Femto/Tasks/femtoCascadeQa.cxx
index a9cfcc78b9d..4b953363dae 100644
--- a/PWGCF/Femto/Tasks/femtoCascadeQa.cxx
+++ b/PWGCF/Femto/Tasks/femtoCascadeQa.cxx
@@ -36,9 +36,7 @@
 #include <string>
 #include <vector>
 
-using namespace o2;
 using namespace o2::aod;
-using namespace o2::soa;
 using namespace o2::framework;
 using namespace o2::framework::expressions;
 using namespace o2::analysis::femto;
@@ -46,15 +44,15 @@ using namespace o2::analysis::femto;
 struct FemtoCascadeQa {
 
   // setup tables
-  using Collisions = Join<FCols, FColMasks, FColPos, FColSphericities, FColMults>;
-  using Collision = Collisions::iterator;
+  using FemtoCollisions = o2::soa::Join<FCols, FColMasks, FColPos, FColSphericities, FColMults>;
+  using FemtoCollision = FemtoCollisions::iterator;
 
-  using FilteredCollisions = o2::soa::Filtered<Collisions>;
-  using FilteredCollision = FilteredCollisions::iterator;
+  using FilteredFemtoCollisions = o2::soa::Filtered<FemtoCollisions>;
+  using FilteredFemtoCollision = FilteredFemtoCollisions::iterator;
 
-  using Xis = o2::soa::Join<FXis, FXiMasks, FXiExtras>;
-  using Omegas = o2::soa::Join<FOmegas, FOmegaMasks, FOmegaExtras>;
-  using Tracks = o2::soa::Join<FTracks, FTrackDcas, FTrackExtras, FTrackPids>;
+  using FemtoXis = o2::soa::Join<FXis, FXiMasks, FXiExtras>;
+  using FemtoOmegas = o2::soa::Join<FOmegas, FOmegaMasks, FOmegaExtras>;
+  using FemtoTracks = o2::soa::Join<FTracks, FTrackDcas, FTrackExtras, FTrackPids>;
 
   SliceCache cache;
 
@@ -67,8 +65,8 @@ struct FemtoCascadeQa {
 
   // setup for xis
   cascadebuilder::ConfXiSelection confXiSelection;
-  Partition<Xis> xiPartition = MAKE_CASCADE_PARTITION(confXiSelection);
-  Preslice<Xis> preColXis = aod::femtobase::stored::collisionId;
+  Partition<FemtoXis> xiPartition = MAKE_CASCADE_PARTITION(confXiSelection);
+  Preslice<FemtoXis> preColXis = femtobase::stored::fColId;
 
   cascadehistmanager::ConfXiBinning confXiBinning;
   cascadehistmanager::ConfXiQaBinning confXiQaBinning;
@@ -83,8 +81,8 @@ struct FemtoCascadeQa {
 
   // setup for omegas
   cascadebuilder::ConfOmegaSelection confOmegaSelection;
-  Partition<Omegas> omegaPartition = MAKE_CASCADE_PARTITION(confOmegaSelection);
-  Preslice<Omegas> preColOmegas = aod::femtobase::stored::collisionId;
+  Partition<FemtoOmegas> omegaPartition = MAKE_CASCADE_PARTITION(confOmegaSelection);
+  Preslice<FemtoOmegas> preColOmegas = femtobase::stored::fColId;
 
   cascadehistmanager::ConfOmegaBinning confOmegaBinning;
   cascadehistmanager::ConfOmegaQaBinning confOmegaQaBinning;
@@ -132,20 +130,20 @@ struct FemtoCascadeQa {
     }
   };
 
-  void processXis(FilteredCollision const& col, Xis const& /*xis*/, Tracks const& tracks)
+  void processXis(FilteredFemtoCollision const& col, FemtoXis const& /*xis*/, FemtoTracks const& tracks)
   {
     colHistManager.fill(col);
-    auto xiSlice = xiPartition->sliceByCached(femtobase::stored::collisionId, col.globalIndex(), cache);
+    auto xiSlice = xiPartition->sliceByCached(femtobase::stored::fColId, col.globalIndex(), cache);
     for (auto const& xi : xiSlice) {
       xiHistManager.fill(xi, tracks);
     }
   }
   PROCESS_SWITCH(FemtoCascadeQa, processXis, "Process Xis", true);
 
-  void processOmegas(FilteredCollision const& col, Omegas const& /*omegas*/, Tracks const& tracks)
+  void processOmegas(FilteredFemtoCollision const& col, FemtoOmegas const& /*omegas*/, FemtoTracks const& tracks)
   {
     colHistManager.fill(col);
-    auto omegaSlice = omegaPartition->sliceByCached(femtobase::stored::collisionId, col.globalIndex(), cache);
+    auto omegaSlice = omegaPartition->sliceByCached(femtobase::stored::fColId, col.globalIndex(), cache);
     for (auto const& omega : omegaSlice) {
       omegaHistManager.fill(omega, tracks);
     }
diff --git a/PWGCF/Femto/Tasks/femtoKinkQa.cxx b/PWGCF/Femto/Tasks/femtoKinkQa.cxx
index 4d797d0be01..2b900fa417d 100644
--- a/PWGCF/Femto/Tasks/femtoKinkQa.cxx
+++ b/PWGCF/Femto/Tasks/femtoKinkQa.cxx
@@ -38,9 +38,7 @@
 #include <string>
 #include <vector>
 
-using namespace o2;
 using namespace o2::aod;
-using namespace o2::soa;
 using namespace o2::framework;
 using namespace o2::framework::expressions;
 using namespace o2::analysis::femto;
@@ -55,24 +53,23 @@ struct FemtoKinkQa {
   colhistmanager::ConfCollisionBinning confCollisionBinning;
   colhistmanager::ConfCollisionQaBinning confCollisionQaBinning;
 
-  // using Collisions = o2::soa::Join<FUCols, FUColPos, FUColMults, FUColCents>;
-  using Collisions = Join<FCols, FColMasks, FColPos, FColSphericities, FColMults>;
-  using Collision = Collisions::iterator;
+  using FemtoCollisions = o2::soa::Join<FCols, FColMasks, FColPos, FColSphericities, FColMults>;
+  using FemtoCollision = FemtoCollisions::iterator;
 
-  using FilteredCollisions = o2::soa::Filtered<Collisions>;
-  using FilteredCollision = FilteredCollisions::iterator;
+  using FilteredFemtoCollisions = o2::soa::Filtered<FemtoCollisions>;
+  using FilteredFemtoCollision = FilteredFemtoCollisions::iterator;
 
   // Define kink/sigma tables (joining tables for comprehensive information)
-  using Sigmas = o2::soa::Join<FSigmas, FSigmaMasks, FSigmaExtras>;
-  using Tracks = o2::soa::Join<FTracks, FTrackDcas, FTrackExtras, FTrackPids>;
+  using FemtoSigmas = o2::soa::Join<FSigmas, FSigmaMasks, FSigmaExtras>;
+  using FemtoTracks = o2::soa::Join<FTracks, FTrackDcas, FTrackExtras, FTrackPids>;
 
   SliceCache cache;
 
   // setup for sigmas
   kinkbuilder::ConfSigmaSelection1 confSigmaSelection;
 
-  Partition<Sigmas> sigmaPartition = MAKE_SIGMA_PARTITION(confSigmaSelection);
-  Preslice<Sigmas> perColSigmas = aod::femtobase::stored::collisionId;
+  Partition<FemtoSigmas> sigmaPartition = MAKE_SIGMA_PARTITION(confSigmaSelection);
+  Preslice<FemtoSigmas> perColSigmas = femtobase::stored::fColId;
 
   kinkhistmanager::ConfSigmaBinning1 confSigmaBinning;
   kinkhistmanager::ConfSigmaQaBinning1 confSigmaQaBinning;
@@ -101,10 +98,10 @@ struct FemtoKinkQa {
   };
 
   // Process function for sigma particles from femto tables
-  void processSigma(FilteredCollision const& col, Sigmas const& /*sigmas*/, Tracks const& tracks)
+  void processSigma(FilteredFemtoCollision const& col, FemtoSigmas const& /*sigmas*/, FemtoTracks const& tracks)
   {
     colHistManager.fill(col);
-    auto sigmaSlice = sigmaPartition->sliceByCached(femtobase::stored::collisionId, col.globalIndex(), cache);
+    auto sigmaSlice = sigmaPartition->sliceByCached(femtobase::stored::fColId, col.globalIndex(), cache);
     for (auto const& sigma : sigmaSlice) {
       sigmaHistManager.fill(sigma, tracks);
     }
diff --git a/PWGCF/Femto/Tasks/femtoPairTrackCascade.cxx b/PWGCF/Femto/Tasks/femtoPairTrackCascade.cxx
index f033eca7dc8..ee7d9d5e409 100644
--- a/PWGCF/Femto/Tasks/femtoPairTrackCascade.cxx
+++ b/PWGCF/Femto/Tasks/femtoPairTrackCascade.cxx
@@ -71,7 +71,7 @@ struct FemtoPairTrackCascade {
   trackbuilder::ConfTrackSelection1 trackSelection;
   trackhistmanager::ConfTrackBinning1 confTrackBinning;
   Partition<Tracks> trackPartition = MAKE_TRACK_PARTITION(trackSelection);
-  Preslice<Tracks> perColTracks = aod::femtobase::stored::collisionId;
+  Preslice<Tracks> perColTracks = aod::femtobase::stored::fColId;
 
   // setup for daughters/bachelor
   trackhistmanager::ConfCascadePosDauBinning confPosDauBinning;
@@ -82,13 +82,13 @@ struct FemtoPairTrackCascade {
   cascadebuilder::ConfXiSelection xiSelection;
   cascadehistmanager::ConfXiBinning confXiBinning;
   Partition<Xis> xiPartition = MAKE_CASCADE_PARTITION(xiSelection);
-  Preslice<Xis> perColXis = aod::femtobase::stored::collisionId;
+  Preslice<Xis> perColXis = aod::femtobase::stored::fColId;
 
   // setup omegas
   cascadebuilder::ConfOmegaSelection omegaSelection;
   cascadehistmanager::ConfOmegaBinning confOmegaBinning;
   Partition<Omegas> omegaPartition = MAKE_CASCADE_PARTITION(omegaSelection);
-  Preslice<Omegas> perColOmegas = aod::femtobase::stored::collisionId;
+  Preslice<Omegas> perColOmegas = aod::femtobase::stored::fColId;
 
   // setup pairs
   pairhistmanager::ConfPairBinning confPairBinning;
diff --git a/PWGCF/Femto/Tasks/femtoPairTrackKink.cxx b/PWGCF/Femto/Tasks/femtoPairTrackKink.cxx
index e5a049824d6..d0fd689fe21 100644
--- a/PWGCF/Femto/Tasks/femtoPairTrackKink.cxx
+++ b/PWGCF/Femto/Tasks/femtoPairTrackKink.cxx
@@ -71,7 +71,7 @@ struct FemtoPairTrackKink {
   trackbuilder::ConfTrackSelection1 trackSelection;
   trackhistmanager::ConfTrackBinning1 confTrackBinning;
   Partition<Tracks> trackPartition = MAKE_TRACK_PARTITION(trackSelection);
-  Preslice<Tracks> perColTracks = aod::femtobase::stored::collisionId;
+  Preslice<Tracks> perColTracks = aod::femtobase::stored::fColId;
 
   // setup for daughters
   trackhistmanager::ConfKinkChaDauBinning confChaDauBinning;
@@ -80,7 +80,7 @@ struct FemtoPairTrackKink {
   kinkbuilder::ConfSigmaSelection1 sigmaSelection;
   kinkhistmanager::ConfSigmaBinning1 confSigmaBinning;
   Partition<Sigmas> sigmaPartition = MAKE_SIGMA_PARTITION(sigmaSelection);
-  Preslice<Sigmas> perColSigmas = aod::femtobase::stored::collisionId;
+  Preslice<Sigmas> perColSigmas = aod::femtobase::stored::fColId;
 
   // setup pairs
   pairhistmanager::ConfPairBinning confPairBinning;
diff --git a/PWGCF/Femto/Tasks/femtoPairTrackTrack.cxx b/PWGCF/Femto/Tasks/femtoPairTrackTrack.cxx
index 1e96f2617d5..517478ed117 100644
--- a/PWGCF/Femto/Tasks/femtoPairTrackTrack.cxx
+++ b/PWGCF/Femto/Tasks/femtoPairTrackTrack.cxx
@@ -72,7 +72,7 @@ struct FemtoPairTrackTrack {
   Partition<Tracks> trackPartition1 = MAKE_TRACK_PARTITION(trackSelections1);
   Partition<Tracks> trackPartition2 = MAKE_TRACK_PARTITION(trackSelections2);
 
-  Preslice<Tracks> perColReco = aod::femtobase::stored::collisionId;
+  Preslice<Tracks> perColReco = aod::femtobase::stored::fColId;
 
   // setup pairs
   pairhistmanager::ConfPairBinning confPairBinning;
diff --git a/PWGCF/Femto/Tasks/femtoPairTrackTwoTrackResonance.cxx b/PWGCF/Femto/Tasks/femtoPairTrackTwoTrackResonance.cxx
index 516499cd801..73a340cde8a 100644
--- a/PWGCF/Femto/Tasks/femtoPairTrackTwoTrackResonance.cxx
+++ b/PWGCF/Femto/Tasks/femtoPairTrackTwoTrackResonance.cxx
@@ -72,7 +72,7 @@ struct FemtoPairTrackTwoTrackResonance {
   trackbuilder::ConfTrackSelection1 trackSelection;
   trackhistmanager::ConfTrackBinning1 confTrackBinning;
   Partition<Tracks> trackPartition = MAKE_TRACK_PARTITION(trackSelection);
-  Preslice<Tracks> perColTracks = aod::femtobase::stored::collisionId;
+  Preslice<Tracks> perColTracks = aod::femtobase::stored::fColId;
 
   // setup for daughters
   trackhistmanager::ConfResonancePosDauBinning confPosDauBinning;
@@ -82,19 +82,19 @@ struct FemtoPairTrackTwoTrackResonance {
   twotrackresonancebuilder::ConfPhiSelection phiSelection;
   twotrackresonancehistmanager::ConfPhiBinning confPhiBinning;
   Partition<Phis> phiPartition = MAKE_RESONANCE_0_PARTITON(phiSelection);
-  Preslice<Phis> perColPhis = aod::femtobase::stored::collisionId;
+  Preslice<Phis> perColPhis = aod::femtobase::stored::fColId;
 
   // setup kstar0
   twotrackresonancebuilder::ConfKstar0Selection kstar0Selection;
   twotrackresonancehistmanager::ConfKstar0Binning confKstar0Binning;
   Partition<Kstar0s> kstar0Partition = MAKE_RESONANCE_1_PARTITON(kstar0Selection);
-  Preslice<Kstar0s> perColKstar0s = aod::femtobase::stored::collisionId;
+  Preslice<Kstar0s> perColKstar0s = aod::femtobase::stored::fColId;
 
   // rho0s
   twotrackresonancebuilder::ConfRho0Selection rho0Selection;
   twotrackresonancehistmanager::ConfRho0Binning confRho0Binning;
   Partition<Rho0s> rho0Partition = MAKE_RESONANCE_0_PARTITON(rho0Selection);
-  Preslice<Rho0s> perColRho0s = aod::femtobase::stored::collisionId;
+  Preslice<Rho0s> perColRho0s = aod::femtobase::stored::fColId;
 
   // setup pairs
   pairhistmanager::ConfPairBinning confPairBinning;
diff --git a/PWGCF/Femto/Tasks/femtoPairTrackV0.cxx b/PWGCF/Femto/Tasks/femtoPairTrackV0.cxx
index b792421c058..64fcb671314 100644
--- a/PWGCF/Femto/Tasks/femtoPairTrackV0.cxx
+++ b/PWGCF/Femto/Tasks/femtoPairTrackV0.cxx
@@ -71,7 +71,7 @@ struct FemtoPairTrackV0 {
   trackbuilder::ConfTrackSelection1 trackSelection;
   trackhistmanager::ConfTrackBinning1 confTrackBinning;
   Partition<Tracks> trackPartition = MAKE_TRACK_PARTITION(trackSelection);
-  Preslice<Tracks> perColTracks = aod::femtobase::stored::collisionId;
+  Preslice<Tracks> perColTracks = aod::femtobase::stored::fColId;
 
   // setup for daughters
   trackhistmanager::ConfV0PosDauBinning confPosDauBinning;
@@ -81,13 +81,13 @@ struct FemtoPairTrackV0 {
   v0builder::ConfLambdaSelection1 lambdaSelection;
   v0histmanager::ConfLambdaBinning1 confLambdaBinning;
   Partition<Lambdas> lambdaPartition = MAKE_LAMBDA_PARTITION(lambdaSelection);
-  Preslice<Lambdas> perColLambdas = aod::femtobase::stored::collisionId;
+  Preslice<Lambdas> perColLambdas = aod::femtobase::stored::fColId;
 
   // setup k0shorts
   v0builder::ConfK0shortSelection1 k0shortSelection;
   v0histmanager::ConfK0shortBinning1 confK0shortBinning;
   Partition<K0shorts> k0shortPartition = MAKE_K0SHORT_PARTITION(k0shortSelection);
-  Preslice<K0shorts> perColk0shorts = aod::femtobase::stored::collisionId;
+  Preslice<K0shorts> perColk0shorts = aod::femtobase::stored::fColId;
 
   // setup pairs
   pairhistmanager::ConfPairBinning confPairBinning;
diff --git a/PWGCF/Femto/Tasks/femtoPairV0V0.cxx b/PWGCF/Femto/Tasks/femtoPairV0V0.cxx
index 0f2da302f7e..bda347ad110 100644
--- a/PWGCF/Femto/Tasks/femtoPairV0V0.cxx
+++ b/PWGCF/Femto/Tasks/femtoPairV0V0.cxx
@@ -75,13 +75,13 @@ struct FemtoPairV0V0 {
   v0builder::ConfLambdaSelection1 lambdaSelection;
   v0histmanager::ConfLambdaBinning1 confLambdaBinning;
   Partition<Lambdas> lambdaPartition = MAKE_LAMBDA_PARTITION(lambdaSelection);
-  Preslice<Lambdas> perColLambdas = aod::femtobase::stored::collisionId;
+  Preslice<Lambdas> perColLambdas = aod::femtobase::stored::fColId;
 
   // setup k0shorts
   v0builder::ConfK0shortSelection1 k0shortSelection;
   v0histmanager::ConfK0shortBinning1 confK0shortBinning;
   Partition<K0shorts> k0shortPartition = MAKE_K0SHORT_PARTITION(k0shortSelection);
-  Preslice<K0shorts> perColk0shorts = aod::femtobase::stored::collisionId;
+  Preslice<K0shorts> perColk0shorts = aod::femtobase::stored::fColId;
 
   // setup pairs
   pairhistmanager::ConfPairBinning confPairBinning;
diff --git a/PWGCF/Femto/Tasks/femtoTrackQa.cxx b/PWGCF/Femto/Tasks/femtoTrackQa.cxx
index 4ae2deb4cc9..d78679ccf1b 100644
--- a/PWGCF/Femto/Tasks/femtoTrackQa.cxx
+++ b/PWGCF/Femto/Tasks/femtoTrackQa.cxx
@@ -33,9 +33,7 @@
 #include <map>
 #include <vector>
 
-using namespace o2;
 using namespace o2::aod;
-using namespace o2::soa;
 using namespace o2::framework;
 using namespace o2::framework::expressions;
 using namespace o2::analysis::femto;
@@ -43,13 +41,13 @@ using namespace o2::analysis::femto;
 struct FemtoTrackQa {
 
   // setup tables
-  using Collisions = o2::soa::Join<FCols, FColMasks, FColPos, FColSphericities, FColMults>;
-  using Collision = Collisions::iterator;
+  using FemtoCollisions = o2::soa::Join<FCols, FColMasks, FColPos, FColSphericities, FColMults>;
+  using FemtoCollision = FemtoCollisions::iterator;
 
-  using FilteredCollisions = o2::soa::Filtered<Collisions>;
-  using FilteredCollision = FilteredCollisions::iterator;
+  using FilteredFemtoCollisions = o2::soa::Filtered<FemtoCollisions>;
+  using FilteredFemtoCollision = FilteredFemtoCollisions::iterator;
 
-  using Tracks = o2::soa::Join<FTracks, FTrackMasks, FTrackDcas, FTrackExtras, FTrackPids>;
+  using FemtoTracks = o2::soa::Join<FTracks, FTrackMasks, FTrackDcas, FTrackExtras, FTrackPids>;
 
   SliceCache cache;
 
@@ -66,8 +64,8 @@ struct FemtoTrackQa {
   trackhistmanager::ConfTrackQaBinning1 confTrackQaBinning;
   trackhistmanager::TrackHistManager<trackhistmanager::PrefixTrackQa, modes::Mode::kAnalysis_Qa> trackHistManager;
 
-  Partition<Tracks> trackPartition = MAKE_TRACK_PARTITION(trackSelections);
-  Preslice<Tracks> perColReco = aod::femtobase::stored::collisionId;
+  Partition<FemtoTracks> trackPartition = MAKE_TRACK_PARTITION(trackSelections);
+  Preslice<FemtoTracks> perColReco = femtobase::stored::fColId;
 
   HistogramRegistry hRegistry{"FemtoTrackQA", {}, OutputObjHandlingPolicy::AnalysisObject};
 
@@ -80,10 +78,10 @@ struct FemtoTrackQa {
     trackHistManager.init(&hRegistry, trackHistSpec, trackSelections.chargeAbs.value, confTrackQaBinning.momentumType.value);
   };
 
-  void process(FilteredCollision const& col, Tracks const& tracks)
+  void process(FilteredFemtoCollision const& col, FemtoTracks const& tracks)
   {
     colHistManager.fill(col);
-    auto trackSlice = trackPartition->sliceByCached(femtobase::stored::collisionId, col.globalIndex(), cache);
+    auto trackSlice = trackPartition->sliceByCached(femtobase::stored::fColId, col.globalIndex(), cache);
     for (auto const& track : trackSlice) {
       trackHistManager.fill(track, tracks);
     }
diff --git a/PWGCF/Femto/Tasks/femtoTwotrackresonanceQa.cxx b/PWGCF/Femto/Tasks/femtoTwotrackresonanceQa.cxx
index fdc2d45accc..c92d6537170 100644
--- a/PWGCF/Femto/Tasks/femtoTwotrackresonanceQa.cxx
+++ b/PWGCF/Femto/Tasks/femtoTwotrackresonanceQa.cxx
@@ -36,9 +36,7 @@
 #include <string>
 #include <vector>
 
-using namespace o2;
 using namespace o2::aod;
-using namespace o2::soa;
 using namespace o2::framework;
 using namespace o2::framework::expressions;
 using namespace o2::analysis::femto;
@@ -46,16 +44,16 @@ using namespace o2::analysis::femto;
 struct FemtoTwotrackresonanceQa {
 
   // setup tables
-  using Collisions = Join<FCols, FColMasks, FColPos, FColSphericities, FColMults>;
-  using Collision = Collisions::iterator;
+  using FemtoCollisions = o2::soa::Join<FCols, FColMasks, FColPos, FColSphericities, FColMults>;
+  using FemtoCollision = FemtoCollisions::iterator;
 
-  using FilteredCollisions = o2::soa::Filtered<Collisions>;
-  using FilteredCollision = FilteredCollisions::iterator;
+  using FilteredFemtoCollisions = o2::soa::Filtered<FemtoCollisions>;
+  using FilteredFemtoCollision = FilteredFemtoCollisions::iterator;
 
-  using Phis = o2::soa::Join<FPhis, FPhiMasks>;
-  using Rho0s = o2::soa::Join<FRho0s, FRho0Masks>;
-  using Kstar0s = o2::soa::Join<FKstar0s, FKstar0Masks>;
-  using Tracks = o2::soa::Join<FTracks, FTrackDcas, FTrackExtras, FTrackPids>;
+  using FemtoPhis = o2::soa::Join<FPhis, FPhiMasks>;
+  using FemtoRho0s = o2::soa::Join<FRho0s, FRho0Masks>;
+  using FemtoKstar0s = o2::soa::Join<FKstar0s, FKstar0Masks>;
+  using FemtoTracks = o2::soa::Join<FTracks, FTrackDcas, FTrackExtras, FTrackPids>;
 
   SliceCache cache;
 
@@ -68,8 +66,8 @@ struct FemtoTwotrackresonanceQa {
 
   // setup for phis
   twotrackresonancebuilder::ConfPhiSelection confPhiSelection;
-  Partition<Phis> phiPartition = MAKE_RESONANCE_0_PARTITON(confPhiSelection);
-  Preslice<Phis> perColPhis = aod::femtobase::stored::collisionId;
+  Partition<FemtoPhis> phiPartition = MAKE_RESONANCE_0_PARTITON(confPhiSelection);
+  Preslice<FemtoPhis> perColPhis = femtobase::stored::fColId;
 
   twotrackresonancehistmanager::ConfPhiBinning confPhiBinning;
   twotrackresonancehistmanager::TwoTrackResonanceHistManager<
@@ -82,8 +80,8 @@ struct FemtoTwotrackresonanceQa {
 
   // setup for rho0s
   twotrackresonancebuilder::ConfRho0Selection confRho0Selection;
-  Partition<Rho0s> rho0Partition = MAKE_RESONANCE_0_PARTITON(confRho0Selection);
-  Preslice<Rho0s> perColRhos = aod::femtobase::stored::collisionId;
+  Partition<FemtoRho0s> rho0Partition = MAKE_RESONANCE_0_PARTITON(confRho0Selection);
+  Preslice<FemtoRho0s> perColRhos = femtobase::stored::fColId;
 
   twotrackresonancehistmanager::ConfRho0Binning confRho0Binning;
   twotrackresonancehistmanager::TwoTrackResonanceHistManager<
@@ -96,8 +94,8 @@ struct FemtoTwotrackresonanceQa {
 
   //  setup for kstar0s
   twotrackresonancebuilder::ConfKstar0Selection confKstar0Selection;
-  Partition<Kstar0s> kstar0Partition = MAKE_RESONANCE_1_PARTITON(confKstar0Selection);
-  Preslice<Kstar0s> perColKstars = aod::femtobase::stored::collisionId;
+  Partition<FemtoKstar0s> kstar0Partition = MAKE_RESONANCE_1_PARTITON(confKstar0Selection);
+  Preslice<FemtoKstar0s> perColKstars = femtobase::stored::fColId;
 
   twotrackresonancehistmanager::ConfKstar0Binning confKstar0Binning;
   twotrackresonancehistmanager::TwoTrackResonanceHistManager<
@@ -144,30 +142,30 @@ struct FemtoTwotrackresonanceQa {
     }
   };
 
-  void processPhis(FilteredCollision const& col, Phis const& /*phis*/, Tracks const& tracks)
+  void processPhis(FilteredFemtoCollision const& col, FemtoPhis const& /*phis*/, FemtoTracks const& tracks)
   {
     colHistManager.fill(col);
-    auto phiSlice = phiPartition->sliceByCached(femtobase::stored::collisionId, col.globalIndex(), cache);
+    auto phiSlice = phiPartition->sliceByCached(femtobase::stored::fColId, col.globalIndex(), cache);
     for (auto const& phi : phiSlice) {
       phiHistManager.fill(phi, tracks);
     }
   };
   PROCESS_SWITCH(FemtoTwotrackresonanceQa, processPhis, "Process Phis", true);
 
-  void processRho0s(FilteredCollision const& col, Rho0s const& /*rho0s*/, Tracks const& tracks)
+  void processRho0s(FilteredFemtoCollision const& col, FemtoRho0s const& /*rho0s*/, FemtoTracks const& tracks)
   {
     colHistManager.fill(col);
-    auto rho0Slice = rho0Partition->sliceByCached(femtobase::stored::collisionId, col.globalIndex(), cache);
+    auto rho0Slice = rho0Partition->sliceByCached(femtobase::stored::fColId, col.globalIndex(), cache);
     for (auto const& rho0 : rho0Slice) {
       rho0HistManager.fill(rho0, tracks);
     }
   };
   PROCESS_SWITCH(FemtoTwotrackresonanceQa, processRho0s, "Process Rho0s", false);
 
-  void processKstar0s(FilteredCollision const& col, Kstar0s const& /*kstar0s*/, Tracks const& tracks)
+  void processKstar0s(FilteredFemtoCollision const& col, FemtoKstar0s const& /*kstar0s*/, FemtoTracks const& tracks)
   {
     colHistManager.fill(col);
-    auto kstar0Slice = kstar0Partition->sliceByCached(femtobase::stored::collisionId, col.globalIndex(), cache);
+    auto kstar0Slice = kstar0Partition->sliceByCached(femtobase::stored::fColId, col.globalIndex(), cache);
     for (auto const& kstar0 : kstar0Slice) {
       kstar0HistManager.fill(kstar0, tracks);
     }
diff --git a/PWGCF/Femto/Tasks/femtoV0Qa.cxx b/PWGCF/Femto/Tasks/femtoV0Qa.cxx
index 27cafaa761c..1249664fa4c 100644
--- a/PWGCF/Femto/Tasks/femtoV0Qa.cxx
+++ b/PWGCF/Femto/Tasks/femtoV0Qa.cxx
@@ -36,23 +36,21 @@
 #include <string>
 #include <vector>
 
-using namespace o2;
 using namespace o2::aod;
-using namespace o2::soa;
 using namespace o2::framework;
 using namespace o2::framework::expressions;
 using namespace o2::analysis::femto;
 
 struct FemtoV0Qa {
 
-  using Collisions = o2::soa::Join<FCols, FColMasks, FColPos, FColSphericities, FColMults>;
+  using FemtoCollisions = o2::soa::Join<FCols, FColMasks, FColPos, FColSphericities, FColMults>;
 
-  using FilteredCollisions = o2::soa::Filtered<Collisions>;
-  using FilteredCollision = FilteredCollisions::iterator;
+  using FilteredFemtoCollisions = o2::soa::Filtered<FemtoCollisions>;
+  using FilteredFemtoCollision = FilteredFemtoCollisions::iterator;
 
-  using Lambdas = o2::soa::Join<FLambdas, FLambdaMasks, FLambdaExtras>;
-  using K0shorts = o2::soa::Join<FK0shorts, FK0shortMasks, FK0shortExtras>;
-  using Tracks = o2::soa::Join<FTracks, FTrackDcas, FTrackExtras, FTrackPids>;
+  using FemtoLambdas = o2::soa::Join<FLambdas, FLambdaMasks, FLambdaExtras>;
+  using FemtoK0shorts = o2::soa::Join<FK0shorts, FK0shortMasks, FK0shortExtras>;
+  using FemtoTracks = o2::soa::Join<FTracks, FTrackDcas, FTrackExtras, FTrackPids>;
 
   SliceCache cache;
 
@@ -66,8 +64,8 @@ struct FemtoV0Qa {
   // setup for lambdas
   v0builder::ConfLambdaSelection1 confLambdaSelection;
 
-  Partition<Lambdas> lambdaPartition = MAKE_LAMBDA_PARTITION(confLambdaSelection);
-  Preslice<Lambdas> perColLambdas = aod::femtobase::stored::collisionId;
+  Partition<FemtoLambdas> lambdaPartition = MAKE_LAMBDA_PARTITION(confLambdaSelection);
+  Preslice<FemtoLambdas> perColLambdas = femtobase::stored::fColId;
 
   v0histmanager::ConfLambdaBinning1 confLambdaBinning;
   v0histmanager::ConfLambdaQaBinning1 confLambdaQaBinning;
@@ -82,8 +80,8 @@ struct FemtoV0Qa {
   // setup for k0shorts
   v0builder::ConfK0shortSelection1 confK0shortSelection;
 
-  Partition<K0shorts> k0shortPartition = MAKE_K0SHORT_PARTITION(confK0shortSelection);
-  Preslice<K0shorts> perColK0shorts = aod::femtobase::stored::collisionId;
+  Partition<FemtoK0shorts> k0shortPartition = MAKE_K0SHORT_PARTITION(confK0shortSelection);
+  Preslice<FemtoK0shorts> perColK0shorts = femtobase::stored::fColId;
 
   v0histmanager::ConfK0shortBinning1 confK0shortBinning;
   v0histmanager::ConfK0shortQaBinning1 confK0shortQaBinning;
@@ -128,20 +126,20 @@ struct FemtoV0Qa {
     }
   };
 
-  void processK0short(FilteredCollision const& col, Tracks const& tracks, K0shorts const& /*k0shorts*/)
+  void processK0short(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoK0shorts const& /*k0shorts*/)
   {
     colHistManager.fill(col);
-    auto k0shortSlice = k0shortPartition->sliceByCached(femtobase::stored::collisionId, col.globalIndex(), cache);
+    auto k0shortSlice = k0shortPartition->sliceByCached(femtobase::stored::fColId, col.globalIndex(), cache);
     for (auto const& k0short : k0shortSlice) {
       k0shortHistManager.fill(k0short, tracks);
     }
   }
   PROCESS_SWITCH(FemtoV0Qa, processK0short, "Process k0shorts", false);
 
-  void processLambda(FilteredCollision const& col, Tracks const& tracks, Lambdas const& /*lambdas*/)
+  void processLambda(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoLambdas const& /*lambdas*/)
   {
     colHistManager.fill(col);
-    auto lambdaSlice = lambdaPartition->sliceByCached(femtobase::stored::collisionId, col.globalIndex(), cache);
+    auto lambdaSlice = lambdaPartition->sliceByCached(femtobase::stored::fColId, col.globalIndex(), cache);
     for (auto const& lambda : lambdaSlice) {
       lambdaHistManager.fill(lambda, tracks);
     }