diff --git a/Framework/Core/include/Framework/ASoAHelpers.h b/Framework/Core/include/Framework/ASoAHelpers.h
index dbdabcffb74f5..c9ca3ad3a8031 100644
--- a/Framework/Core/include/Framework/ASoAHelpers.h
+++ b/Framework/Core/include/Framework/ASoAHelpers.h
@@ -13,6 +13,8 @@
 #define O2_FRAMEWORK_ASOAHELPERS_H_
 
 #include "Framework/ASoA.h"
+#include "Framework/BinningPolicy.h"
+#include "Framework/Logger.h"
 #include "Framework/RuntimeError.h"
 #include <arrow/table.h>
 
@@ -63,7 +65,7 @@ inline bool diffCategory(std::pair<uint64_t, uint64_t> const& a, std::pair<uint6
 }
 
 template <typename T2, typename ARRAY, typename T>
-std::vector<std::pair<uint64_t, uint64_t>> doGroupTable(const T& table, const std::string& categoryColumnName, int minCatSize, const T2& outsider)
+std::vector<std::pair<uint64_t, uint64_t>> oldGroupTable(const T& table, const std::string& categoryColumnName, int minCatSize, const T2& outsider)
 {
   auto columnIndex = table.asArrowTable()->schema()->GetFieldIndex(categoryColumnName);
   auto chunkedArray = table.asArrowTable()->column(columnIndex);
@@ -139,30 +141,129 @@ std::vector<std::pair<uint64_t, uint64_t>> doGroupTable(const T& table, const st
   return groupedIndices;
 }
 
-// TODO: With arrow table we lose the filtered information!
-// Can we group directly on T? Otherwise we need to extract the selection vector from T
-template <typename T, typename T2>
-auto groupTable(const T& table, const std::string& categoryColumnName, int minCatSize, const T2& outsider)
+template <typename BinningPolicy, typename T>
+std::vector<std::pair<uint64_t, uint64_t>> doGroupTable(const T& table, const BinningPolicy& binningPolicy, int minCatSize, int outsider)
 {
-  auto columnIndex = table.asArrowTable()->schema()->GetFieldIndex(categoryColumnName);
-  auto dataType = table.asArrowTable()->column(columnIndex)->type();
-  if (dataType->id() == arrow::Type::UINT64) {
-    return doGroupTable<uint64_t, arrow::UInt64Array>(table, categoryColumnName, minCatSize, outsider);
+  arrow::Table* arrowTable = table.asArrowTable().get();
+
+  uint64_t ind = 0;
+  uint64_t selInd = 0;
+  gsl::span<int64_t const> selectedRows;
+  std::vector<std::pair<uint64_t, uint64_t>> groupedIndices;
+
+  // Separate check to account for Filtered size different from arrow table
+  if (table.size() == 0) {
+    return groupedIndices;
   }
-  if (dataType->id() == arrow::Type::INT64) {
-    return doGroupTable<int64_t, arrow::Int64Array>(table, categoryColumnName, minCatSize, outsider);
+
+  if constexpr (soa::is_soa_filtered_t<T>::value) {
+    selectedRows = table.getSelectedRows(); // vector<int64_t>
   }
-  if (dataType->id() == arrow::Type::UINT32) {
-    return doGroupTable<uint32_t, arrow::UInt32Array>(table, categoryColumnName, minCatSize, outsider);
+
+  auto binningColumns = binningPolicy.getColumns();
+  auto arrowColumns = o2::framework::binning_helpers::getArrowColumns(arrowTable, binningColumns);
+  auto chunksCount = arrowColumns[0]->num_chunks();
+  // TODO: Are such checks needed or can we safely assume chunks are always the same?
+  for (int i = 1; i < binningPolicy.mColumnsCount; i++) {
+    if (arrowColumns[i]->num_chunks() != chunksCount) {
+      throw o2::framework::runtime_error("Combinations: data size varies between selected columns");
+    }
   }
-  if (dataType->id() == arrow::Type::INT32) {
-    return doGroupTable<int32_t, arrow::Int32Array>(table, categoryColumnName, minCatSize, outsider);
+
+  for (uint64_t ci = 0; ci < chunksCount; ++ci) {
+    auto chunks = o2::framework::binning_helpers::getChunks(arrowTable, binningColumns, ci);
+    auto chunkLength = std::get<0>(chunks)->length();
+    // TODO: Are such checks needed or can we safely assume chunks are always the same?
+    //constexpr auto cn = binningPolicy.mColumnsCount - 1;
+    //for_<cn>([&chunks, &chunkLength](auto i) {
+    //  if (std::get<i.value + 1>(chunks)->length() != chunkLength) {
+    //    throw o2::framework::runtime_error("Combinations: data size varies between selected columns");
+    //  }
+    //});
+
+    if constexpr (soa::is_soa_filtered_t<T>::value) {
+      if (selectedRows[ind] >= selInd + chunkLength) {
+        selInd += chunkLength;
+        continue; // Go to the next chunk, no value selected in this chunk
+      }
+    }
+
+    uint64_t ai = 0;
+    while (ai < chunkLength) {
+      if constexpr (soa::is_soa_filtered_t<T>::value) {
+        ai += selectedRows[ind] - selInd;
+        selInd = selectedRows[ind];
+      }
+
+      auto rowData = o2::framework::binning_helpers::getRowData(arrowTable, binningColumns, ci, ai);
+      int val = binningPolicy.getBin(rowData);
+      if (val != outsider) {
+        groupedIndices.emplace_back(val, ind);
+      }
+      ind++;
+
+      if constexpr (soa::is_soa_filtered_t<T>::value) {
+        if (ind >= selectedRows.size()) {
+          break;
+        }
+      } else {
+        ai++;
+      }
+    }
+
+    if constexpr (soa::is_soa_filtered_t<T>::value) {
+      if (ind == selectedRows.size()) {
+        break;
+      }
+    }
   }
-  if (dataType->id() == arrow::Type::FLOAT) {
-    return doGroupTable<float, arrow::FloatArray>(table, categoryColumnName, minCatSize, outsider);
+
+  // Do a stable sort so that same categories entries are
+  // grouped together.
+  std::stable_sort(groupedIndices.begin(), groupedIndices.end());
+
+  // Remove categories of too small size
+  if (minCatSize > 1) {
+    auto catBegin = groupedIndices.begin();
+    while (catBegin != groupedIndices.end()) {
+      auto catEnd = std::upper_bound(catBegin, groupedIndices.end(), *catBegin, sameCategory);
+      if (std::distance(catBegin, catEnd) < minCatSize) {
+        catEnd = groupedIndices.erase(catBegin, catEnd);
+      }
+      catBegin = catEnd;
+    }
+  }
+
+  return groupedIndices;
+}
+
+namespace old_interface
+{
+template <typename T>
+struct is_string {
+  static const bool value = false;
+};
+
+template <class T, class Traits, class Alloc>
+struct is_string<std::basic_string<T, Traits, Alloc>> {
+  static const bool value = true;
+};
+
+template <std::size_t N>
+struct is_string<char[N]> {
+  static const bool value = true;
+};
+} // namespace old_interface
+
+template <typename BinningPolicy, typename T>
+std::vector<std::pair<uint64_t, uint64_t>> groupTable(const T& table, const BinningPolicy& binningPolicy, int minCatSize, int outsider)
+{
+  if constexpr (old_interface::is_string<BinningPolicy>::value) {
+    LOG(warn) << "You are using obsolete interface for block combinations / event mixing, please update";
+    return oldGroupTable<int, arrow::Int32Array>(table, binningPolicy, minCatSize, outsider);
+  } else {
+    return doGroupTable(table, binningPolicy, minCatSize, outsider);
   }
-  // FIXME: Should we support other types as well?
-  throw o2::framework::runtime_error("Combinations: category column must be of integral type");
 }
 
 // Synchronize categories so as groupedIndices contain elements only of categories common to all tables
@@ -411,19 +512,19 @@ struct CombinationsFullIndexPolicy : public CombinationsIndexPolicyBase<Ts...> {
 };
 
 // For upper and full only
-template <typename T, typename... Ts>
+template <typename BinningPolicy, typename T, typename... Ts>
 struct CombinationsBlockIndexPolicyBase : public CombinationsIndexPolicyBase<Ts...> {
   using CombinationType = typename CombinationsIndexPolicyBase<Ts...>::CombinationType;
   using IndicesType = typename NTupleType<uint64_t, sizeof...(Ts)>::type;
 
-  CombinationsBlockIndexPolicyBase(const std::string& categoryColumnName, int categoryNeighbours, const T& outsider) : CombinationsIndexPolicyBase<Ts...>(), mSlidingWindowSize(categoryNeighbours + 1), mCategoryColumnName(categoryColumnName), mCategoryNeighbours(categoryNeighbours), mOutsider(outsider) {}
-  CombinationsBlockIndexPolicyBase(const std::string& categoryColumnName, int categoryNeighbours, const T& outsider, const Ts&... tables) : CombinationsIndexPolicyBase<Ts...>(tables...), mSlidingWindowSize(categoryNeighbours + 1), mCategoryColumnName(categoryColumnName), mCategoryNeighbours(categoryNeighbours), mOutsider(outsider)
+  CombinationsBlockIndexPolicyBase(const BinningPolicy& binningPolicy, int categoryNeighbours, const T& outsider) : CombinationsIndexPolicyBase<Ts...>(), mSlidingWindowSize(categoryNeighbours + 1), mBinningPolicy(binningPolicy), mCategoryNeighbours(categoryNeighbours), mOutsider(outsider) {}
+  CombinationsBlockIndexPolicyBase(const BinningPolicy& binningPolicy, int categoryNeighbours, const T& outsider, const Ts&... tables) : CombinationsIndexPolicyBase<Ts...>(tables...), mSlidingWindowSize(categoryNeighbours + 1), mBinningPolicy(binningPolicy), mCategoryNeighbours(categoryNeighbours), mOutsider(outsider)
   {
     if (!this->mIsEnd) {
       setRanges(tables...);
     }
   }
-  CombinationsBlockIndexPolicyBase(const std::string& categoryColumnName, int categoryNeighbours, const T& outsider, Ts&&... tables) : CombinationsIndexPolicyBase<Ts...>(std::forward<Ts>(tables)...), mSlidingWindowSize(categoryNeighbours + 1)
+  CombinationsBlockIndexPolicyBase(const BinningPolicy& binningPolicy, int categoryNeighbours, const T& outsider, Ts&&... tables) : CombinationsIndexPolicyBase<Ts...>(std::forward<Ts>(tables)...), mSlidingWindowSize(categoryNeighbours + 1), mBinningPolicy(binningPolicy), mCategoryNeighbours(categoryNeighbours), mOutsider(outsider)
   {
     if (!this->mIsEnd) {
       setRanges();
@@ -450,7 +551,7 @@ struct CombinationsBlockIndexPolicyBase : public CombinationsIndexPolicyBase<Ts.
     }
 
     int tableIndex = 0;
-    ((this->mGroupedIndices[tableIndex++] = groupTable(tables, this->mCategoryColumnName, 1, this->mOutsider)), ...);
+    ((this->mGroupedIndices[tableIndex++] = groupTable(tables, this->mBinningPolicy, 1, this->mOutsider)), ...);
 
     // Synchronize categories across tables
     syncCategories(this->mGroupedIndices);
@@ -479,7 +580,7 @@ struct CombinationsBlockIndexPolicyBase : public CombinationsIndexPolicyBase<Ts.
 
     int tableIndex = 0;
     std::apply([&, this](auto&&... x) mutable {
-      ((this->mGroupedIndices[tableIndex++] = groupTable(x, mCategoryColumnName, 1, mOutsider)), ...);
+      ((this->mGroupedIndices[tableIndex++] = groupTable(x, this->mBinningPolicy, 1, this->mOutsider)), ...);
     },
                *this->mTables);
 
@@ -502,23 +603,23 @@ struct CombinationsBlockIndexPolicyBase : public CombinationsIndexPolicyBase<Ts.
   IndicesType mCurrentIndices;
   IndicesType mBeginIndices;
   uint64_t mSlidingWindowSize;
-  const std::string mCategoryColumnName;
+  const BinningPolicy mBinningPolicy;
   const int mCategoryNeighbours;
   const T mOutsider;
 };
 
-template <typename T, typename... Ts>
-struct CombinationsBlockUpperIndexPolicy : public CombinationsBlockIndexPolicyBase<T, Ts...> {
-  using CombinationType = typename CombinationsBlockIndexPolicyBase<T, Ts...>::CombinationType;
+template <typename BinningPolicy, typename T, typename... Ts>
+struct CombinationsBlockUpperIndexPolicy : public CombinationsBlockIndexPolicyBase<BinningPolicy, T, Ts...> {
+  using CombinationType = typename CombinationsBlockIndexPolicyBase<BinningPolicy, T, Ts...>::CombinationType;
 
-  CombinationsBlockUpperIndexPolicy(const std::string& categoryColumnName, int categoryNeighbours, const T& outsider) : CombinationsBlockIndexPolicyBase<T, Ts...>(categoryColumnName, categoryNeighbours, outsider) {}
-  CombinationsBlockUpperIndexPolicy(const std::string& categoryColumnName, int categoryNeighbours, const T& outsider, const Ts&... tables) : CombinationsBlockIndexPolicyBase<T, Ts...>(categoryColumnName, categoryNeighbours, outsider, tables...)
+  CombinationsBlockUpperIndexPolicy(const BinningPolicy& binningPolicy, int categoryNeighbours, const T& outsider) : CombinationsBlockIndexPolicyBase<BinningPolicy, T, Ts...>(binningPolicy, categoryNeighbours, outsider) {}
+  CombinationsBlockUpperIndexPolicy(const BinningPolicy& binningPolicy, int categoryNeighbours, const T& outsider, const Ts&... tables) : CombinationsBlockIndexPolicyBase<BinningPolicy, T, Ts...>(binningPolicy, categoryNeighbours, outsider, tables...)
   {
     if (!this->mIsEnd) {
       setRanges();
     }
   }
-  CombinationsBlockUpperIndexPolicy(const std::string& categoryColumnName, int categoryNeighbours, const T& outsider, Ts&&... tables) : CombinationsBlockIndexPolicyBase<T, Ts...>(categoryColumnName, categoryNeighbours, outsider, std::forward<Ts>(tables)...)
+  CombinationsBlockUpperIndexPolicy(const BinningPolicy& binningPolicy, int categoryNeighbours, const T& outsider, Ts&&... tables) : CombinationsBlockIndexPolicyBase<BinningPolicy, T, Ts...>(binningPolicy, categoryNeighbours, outsider, std::forward<Ts>(tables)...)
   {
     if (!this->mIsEnd) {
       setRanges();
@@ -527,12 +628,12 @@ struct CombinationsBlockUpperIndexPolicy : public CombinationsBlockIndexPolicyBa
 
   void setTables(const Ts&... tables)
   {
-    CombinationsBlockIndexPolicyBase<T, Ts...>::setTables(tables...);
+    CombinationsBlockIndexPolicyBase<BinningPolicy, T, Ts...>::setTables(tables...);
     setRanges();
   }
   void setTables(Ts&&... tables)
   {
-    CombinationsBlockIndexPolicyBase<T, Ts...>::setTables(std::forward<Ts>(tables)...);
+    CombinationsBlockIndexPolicyBase<BinningPolicy, T, Ts...>::setTables(std::forward<Ts>(tables)...);
     setRanges();
   }
 
@@ -619,19 +720,19 @@ struct CombinationsBlockUpperIndexPolicy : public CombinationsBlockIndexPolicyBa
   }
 };
 
-template <typename T, typename... Ts>
-struct CombinationsBlockFullIndexPolicy : public CombinationsBlockIndexPolicyBase<T, Ts...> {
-  using CombinationType = typename CombinationsBlockIndexPolicyBase<T, Ts...>::CombinationType;
+template <typename BinningPolicy, typename T, typename... Ts>
+struct CombinationsBlockFullIndexPolicy : public CombinationsBlockIndexPolicyBase<BinningPolicy, T, Ts...> {
+  using CombinationType = typename CombinationsBlockIndexPolicyBase<BinningPolicy, T, Ts...>::CombinationType;
   using IndicesType = typename NTupleType<uint64_t, sizeof...(Ts)>::type;
 
-  CombinationsBlockFullIndexPolicy(const std::string& categoryColumnName, int categoryNeighbours, const T& outsider) : CombinationsBlockIndexPolicyBase<T, Ts...>(categoryColumnName, categoryNeighbours, outsider), mCurrentlyFixed(0) {}
-  CombinationsBlockFullIndexPolicy(const std::string& categoryColumnName, int categoryNeighbours, const T& outsider, const Ts&... tables) : CombinationsBlockIndexPolicyBase<T, Ts...>(categoryColumnName, categoryNeighbours, outsider, tables...), mCurrentlyFixed(0)
+  CombinationsBlockFullIndexPolicy(const BinningPolicy& binningPolicy, int categoryNeighbours, const T& outsider) : CombinationsBlockIndexPolicyBase<BinningPolicy, T, Ts...>(binningPolicy, categoryNeighbours, outsider), mCurrentlyFixed(0) {}
+  CombinationsBlockFullIndexPolicy(const BinningPolicy& binningPolicy, int categoryNeighbours, const T& outsider, const Ts&... tables) : CombinationsBlockIndexPolicyBase<BinningPolicy, T, Ts...>(binningPolicy, categoryNeighbours, outsider, tables...), mCurrentlyFixed(0)
   {
     if (!this->mIsEnd) {
       setRanges();
     }
   }
-  CombinationsBlockFullIndexPolicy(const std::string& categoryColumnName, int categoryNeighbours, const T& outsider, Ts&&... tables) : CombinationsBlockIndexPolicyBase<T, Ts...>(categoryColumnName, categoryNeighbours, outsider, std::forward<Ts>(tables)...), mCurrentlyFixed(0)
+  CombinationsBlockFullIndexPolicy(const BinningPolicy& binningPolicy, int categoryNeighbours, const T& outsider, Ts&&... tables) : CombinationsBlockIndexPolicyBase<BinningPolicy, T, Ts...>(binningPolicy, categoryNeighbours, outsider, std::forward<Ts>(tables)...), mCurrentlyFixed(0)
   {
     if (!this->mIsEnd) {
       setRanges();
@@ -640,12 +741,12 @@ struct CombinationsBlockFullIndexPolicy : public CombinationsBlockIndexPolicyBas
 
   void setTables(const Ts&... tables)
   {
-    CombinationsBlockIndexPolicyBase<T, Ts...>::setTables(tables...);
+    CombinationsBlockIndexPolicyBase<BinningPolicy, T, Ts...>::setTables(tables...);
     setRanges();
   }
   void setTables(Ts&&... tables)
   {
-    CombinationsBlockIndexPolicyBase<T, Ts...>::setTables(std::forward<Ts>(tables)...);
+    CombinationsBlockIndexPolicyBase<BinningPolicy, T, Ts...>::setTables(std::forward<Ts>(tables)...);
     setRanges();
   }
 
@@ -751,19 +852,19 @@ struct CombinationsBlockFullIndexPolicy : public CombinationsBlockIndexPolicyBas
   uint64_t mCurrentlyFixed;
 };
 
-template <typename T1, typename T, typename... Ts>
+template <typename BinningPolicy, typename T1, typename T, typename... Ts>
 struct CombinationsBlockSameIndexPolicyBase : public CombinationsIndexPolicyBase<T, Ts...> {
   using CombinationType = typename CombinationsIndexPolicyBase<T, Ts...>::CombinationType;
   using IndicesType = typename NTupleType<uint64_t, sizeof...(Ts) + 1>::type;
 
-  CombinationsBlockSameIndexPolicyBase(const std::string& categoryColumnName, int categoryNeighbours, const T1& outsider, int minWindowSize) : CombinationsIndexPolicyBase<T, Ts...>(), mSlidingWindowSize(categoryNeighbours + 1), mCategoryColumnName(categoryColumnName), mCategoryNeighbours(categoryNeighbours), mOutsider(outsider), mMinWindowSize(minWindowSize) {}
-  CombinationsBlockSameIndexPolicyBase(const std::string& categoryColumnName, int categoryNeighbours, const T1& outsider, int minWindowSize, const T& table, const Ts&... tables) : CombinationsIndexPolicyBase<T, Ts...>(table, tables...), mSlidingWindowSize(categoryNeighbours + 1), mCategoryColumnName(categoryColumnName), mCategoryNeighbours(categoryNeighbours), mOutsider(outsider), mMinWindowSize(minWindowSize)
+  CombinationsBlockSameIndexPolicyBase(const BinningPolicy& binningPolicy, int categoryNeighbours, const T1& outsider, int minWindowSize) : CombinationsIndexPolicyBase<T, Ts...>(), mSlidingWindowSize(categoryNeighbours + 1), mBinningPolicy(binningPolicy), mCategoryNeighbours(categoryNeighbours), mOutsider(outsider), mMinWindowSize(minWindowSize) {}
+  CombinationsBlockSameIndexPolicyBase(const BinningPolicy& binningPolicy, int categoryNeighbours, const T1& outsider, int minWindowSize, const T& table, const Ts&... tables) : CombinationsIndexPolicyBase<T, Ts...>(table, tables...), mSlidingWindowSize(categoryNeighbours + 1), mBinningPolicy(binningPolicy), mCategoryNeighbours(categoryNeighbours), mOutsider(outsider), mMinWindowSize(minWindowSize)
   {
     if (!this->mIsEnd) {
       setRanges(table);
     }
   }
-  CombinationsBlockSameIndexPolicyBase(const std::string& categoryColumnName, int categoryNeighbours, const T1& outsider, int minWindowSize, T&& table, Ts&&... tables) : CombinationsIndexPolicyBase<T, Ts...>(std::forward<T>(table), std::forward<Ts>(tables)...), mSlidingWindowSize(categoryNeighbours + 1)
+  CombinationsBlockSameIndexPolicyBase(const BinningPolicy& binningPolicy, int categoryNeighbours, const T1& outsider, int minWindowSize, T&& table, Ts&&... tables) : CombinationsIndexPolicyBase<T, Ts...>(std::forward<T>(table), std::forward<Ts>(tables)...), mSlidingWindowSize(categoryNeighbours + 1), mBinningPolicy(binningPolicy), mCategoryNeighbours(categoryNeighbours), mOutsider(outsider), mMinWindowSize(minWindowSize)
   {
     if (!this->mIsEnd) {
       setRanges();
@@ -794,7 +895,7 @@ struct CombinationsBlockSameIndexPolicyBase : public CombinationsIndexPolicyBase
       return;
     }
 
-    this->mGroupedIndices = groupTable(table, mCategoryColumnName, mMinWindowSize, mOutsider);
+    this->mGroupedIndices = groupTable(table, mBinningPolicy, mMinWindowSize, mOutsider);
 
     if (this->mGroupedIndices.size() == 0) {
       this->mIsEnd = true;
@@ -812,7 +913,7 @@ struct CombinationsBlockSameIndexPolicyBase : public CombinationsIndexPolicyBase
       return;
     }
 
-    this->mGroupedIndices = groupTable(std::get<0>(*this->mTables), mCategoryColumnName, mMinWindowSize, mOutsider);
+    this->mGroupedIndices = groupTable(std::get<0>(*this->mTables), mBinningPolicy, mMinWindowSize, mOutsider);
 
     if (this->mGroupedIndices.size() == 0) {
       this->mIsEnd = true;
@@ -826,23 +927,23 @@ struct CombinationsBlockSameIndexPolicyBase : public CombinationsIndexPolicyBase
   IndicesType mCurrentIndices;
   const uint64_t mSlidingWindowSize;
   const int mMinWindowSize;
-  const std::string mCategoryColumnName;
+  const BinningPolicy mBinningPolicy;
   const int mCategoryNeighbours;
   const T1 mOutsider;
 };
 
-template <typename T1, typename... Ts>
-struct CombinationsBlockUpperSameIndexPolicy : public CombinationsBlockSameIndexPolicyBase<T1, Ts...> {
-  using CombinationType = typename CombinationsBlockSameIndexPolicyBase<T1, Ts...>::CombinationType;
+template <typename BinningPolicy, typename T1, typename... Ts>
+struct CombinationsBlockUpperSameIndexPolicy : public CombinationsBlockSameIndexPolicyBase<BinningPolicy, T1, Ts...> {
+  using CombinationType = typename CombinationsBlockSameIndexPolicyBase<BinningPolicy, T1, Ts...>::CombinationType;
 
-  CombinationsBlockUpperSameIndexPolicy(const std::string& categoryColumnName, int categoryNeighbours, const T1& outsider) : CombinationsBlockSameIndexPolicyBase<T1, Ts...>(categoryColumnName, categoryNeighbours, outsider, 1) {}
-  CombinationsBlockUpperSameIndexPolicy(const std::string& categoryColumnName, int categoryNeighbours, const T1& outsider, const Ts&... tables) : CombinationsBlockSameIndexPolicyBase<T1, Ts...>(categoryColumnName, categoryNeighbours, outsider, 1, tables...)
+  CombinationsBlockUpperSameIndexPolicy(const BinningPolicy& binningPolicy, int categoryNeighbours, const T1& outsider) : CombinationsBlockSameIndexPolicyBase<BinningPolicy, T1, Ts...>(binningPolicy, categoryNeighbours, outsider, 1) {}
+  CombinationsBlockUpperSameIndexPolicy(const BinningPolicy& binningPolicy, int categoryNeighbours, const T1& outsider, const Ts&... tables) : CombinationsBlockSameIndexPolicyBase<BinningPolicy, T1, Ts...>(binningPolicy, categoryNeighbours, outsider, 1, tables...)
   {
     if (!this->mIsEnd) {
       setRanges();
     }
   }
-  CombinationsBlockUpperSameIndexPolicy(const std::string& categoryColumnName, int categoryNeighbours, const T1& outsider, Ts&&... tables) : CombinationsBlockSameIndexPolicyBase<T1, Ts...>(categoryColumnName, categoryNeighbours, outsider, 1, std::forward<Ts>(tables)...)
+  CombinationsBlockUpperSameIndexPolicy(const BinningPolicy& binningPolicy, int categoryNeighbours, const T1& outsider, Ts&&... tables) : CombinationsBlockSameIndexPolicyBase<BinningPolicy, T1, Ts...>(binningPolicy, categoryNeighbours, outsider, 1, std::forward<Ts>(tables)...)
   {
     if (!this->mIsEnd) {
       setRanges();
@@ -851,12 +952,12 @@ struct CombinationsBlockUpperSameIndexPolicy : public CombinationsBlockSameIndex
 
   void setTables(const Ts&... tables)
   {
-    CombinationsBlockSameIndexPolicyBase<T1, Ts...>::setTables(tables...);
+    CombinationsBlockSameIndexPolicyBase<BinningPolicy, T1, Ts...>::setTables(tables...);
     setRanges();
   }
   void setTables(Ts&&... tables)
   {
-    CombinationsBlockSameIndexPolicyBase<T1, Ts...>::setTables(std::forward<Ts>(tables)...);
+    CombinationsBlockSameIndexPolicyBase<BinningPolicy, T1, Ts...>::setTables(std::forward<Ts>(tables)...);
     setRanges();
   }
 
@@ -927,18 +1028,19 @@ struct CombinationsBlockUpperSameIndexPolicy : public CombinationsBlockSameIndex
   }
 };
 
-template <typename T1, typename... Ts>
-struct CombinationsBlockStrictlyUpperSameIndexPolicy : public CombinationsBlockSameIndexPolicyBase<T1, Ts...> {
-  using CombinationType = typename CombinationsBlockSameIndexPolicyBase<T1, Ts...>::CombinationType;
+template <typename BinningPolicy, typename T1, typename... Ts>
+struct CombinationsBlockStrictlyUpperSameIndexPolicy : public CombinationsBlockSameIndexPolicyBase<BinningPolicy, T1, Ts...> {
+  using CombinationType = typename CombinationsBlockSameIndexPolicyBase<BinningPolicy, T1, Ts...>::CombinationType;
 
-  CombinationsBlockStrictlyUpperSameIndexPolicy(const std::string& categoryColumnName, int categoryNeighbours, const T1& outsider) : CombinationsBlockSameIndexPolicyBase<T1, Ts...>(categoryColumnName, categoryNeighbours, outsider, sizeof...(Ts)) {}
-  CombinationsBlockStrictlyUpperSameIndexPolicy(const std::string& categoryColumnName, int categoryNeighbours, const T1& outsider, const Ts&... tables) : CombinationsBlockSameIndexPolicyBase<T1, Ts...>(categoryColumnName, categoryNeighbours, outsider, sizeof...(Ts), tables...)
+  CombinationsBlockStrictlyUpperSameIndexPolicy(const BinningPolicy& binningPolicy, int categoryNeighbours, const T1& outsider) : CombinationsBlockSameIndexPolicyBase<BinningPolicy, T1, Ts...>(binningPolicy, categoryNeighbours, outsider, sizeof...(Ts)) {}
+  CombinationsBlockStrictlyUpperSameIndexPolicy(const BinningPolicy& binningPolicy, int categoryNeighbours, const T1& outsider, const Ts&... tables) : CombinationsBlockSameIndexPolicyBase<BinningPolicy, T1, Ts...>(binningPolicy, categoryNeighbours, outsider, sizeof...(Ts), tables...)
   {
     if (!this->mIsEnd) {
       setRanges();
     }
   }
-  CombinationsBlockStrictlyUpperSameIndexPolicy(const std::string& categoryColumnName, int categoryNeighbours, const T1& outsider, Ts&&... tables) : CombinationsBlockSameIndexPolicyBase<T1, Ts...>(categoryColumnName, categoryNeighbours, outsider, sizeof...(Ts) + 1, std::forward<Ts>(tables)...)
+
+  CombinationsBlockStrictlyUpperSameIndexPolicy(const BinningPolicy& binningPolicy, int categoryNeighbours, const T1& outsider, Ts&&... tables) : CombinationsBlockSameIndexPolicyBase<BinningPolicy, T1, Ts...>(binningPolicy, categoryNeighbours, outsider, sizeof...(Ts), std::forward<Ts>(tables)...)
   {
     if (!this->mIsEnd) {
       setRanges();
@@ -947,14 +1049,14 @@ struct CombinationsBlockStrictlyUpperSameIndexPolicy : public CombinationsBlockS
 
   void setTables(const Ts&... tables)
   {
-    CombinationsBlockSameIndexPolicyBase<T1, Ts...>::setTables(tables...);
+    CombinationsBlockSameIndexPolicyBase<BinningPolicy, T1, Ts...>::setTables(tables...);
     if (!this->mIsEnd) {
       setRanges();
     }
   }
   void setTables(Ts&&... tables)
   {
-    CombinationsBlockSameIndexPolicyBase<T1, Ts...>::setTables(std::forward<Ts>(tables)...);
+    CombinationsBlockSameIndexPolicyBase<BinningPolicy, T1, Ts...>::setTables(std::forward<Ts>(tables)...);
     if (!this->mIsEnd) {
       setRanges();
     }
@@ -1030,18 +1132,18 @@ struct CombinationsBlockStrictlyUpperSameIndexPolicy : public CombinationsBlockS
   }
 };
 
-template <typename T1, typename... Ts>
-struct CombinationsBlockFullSameIndexPolicy : public CombinationsBlockSameIndexPolicyBase<T1, Ts...> {
-  using CombinationType = typename CombinationsBlockSameIndexPolicyBase<T1, Ts...>::CombinationType;
+template <typename BinningPolicy, typename T1, typename... Ts>
+struct CombinationsBlockFullSameIndexPolicy : public CombinationsBlockSameIndexPolicyBase<BinningPolicy, T1, Ts...> {
+  using CombinationType = typename CombinationsBlockSameIndexPolicyBase<BinningPolicy, T1, Ts...>::CombinationType;
 
-  CombinationsBlockFullSameIndexPolicy(const std::string& categoryColumnName, int categoryNeighbours, const T1& outsider) : CombinationsBlockSameIndexPolicyBase<T1, Ts...>(categoryColumnName, categoryNeighbours, outsider, 1), mCurrentlyFixed(0) {}
-  CombinationsBlockFullSameIndexPolicy(const std::string& categoryColumnName, int categoryNeighbours, const T1& outsider, const Ts&... tables) : CombinationsBlockSameIndexPolicyBase<T1, Ts...>(categoryColumnName, categoryNeighbours, outsider, 1, tables...), mCurrentlyFixed(0)
+  CombinationsBlockFullSameIndexPolicy(const BinningPolicy& binningPolicy, int categoryNeighbours, const T1& outsider) : CombinationsBlockSameIndexPolicyBase<BinningPolicy, T1, Ts...>(binningPolicy, categoryNeighbours, outsider, 1), mCurrentlyFixed(0) {}
+  CombinationsBlockFullSameIndexPolicy(const BinningPolicy& binningPolicy, int categoryNeighbours, const T1& outsider, const Ts&... tables) : CombinationsBlockSameIndexPolicyBase<BinningPolicy, T1, Ts...>(binningPolicy, categoryNeighbours, outsider, 1, tables...), mCurrentlyFixed(0)
   {
     if (!this->mIsEnd) {
       setRanges();
     }
   }
-  CombinationsBlockFullSameIndexPolicy(const std::string& categoryColumnName, int categoryNeighbours, const T1& outsider, Ts&&... tables) : CombinationsBlockSameIndexPolicyBase<T1, Ts...>(categoryColumnName, categoryNeighbours, outsider, 1, std::forward<Ts>(tables)...), mCurrentlyFixed(0)
+  CombinationsBlockFullSameIndexPolicy(const BinningPolicy& binningPolicy, int categoryNeighbours, const T1& outsider, Ts&&... tables) : CombinationsBlockSameIndexPolicyBase<BinningPolicy, T1, Ts...>(binningPolicy, categoryNeighbours, outsider, 1, std::forward<Ts>(tables)...), mCurrentlyFixed(0)
   {
     if (!this->mIsEnd) {
       setRanges();
@@ -1050,12 +1152,12 @@ struct CombinationsBlockFullSameIndexPolicy : public CombinationsBlockSameIndexP
 
   void setTables(const Ts&... tables)
   {
-    CombinationsBlockSameIndexPolicyBase<T1, Ts...>::setTables(tables...);
+    CombinationsBlockSameIndexPolicyBase<BinningPolicy, T1, Ts...>::setTables(tables...);
     setRanges();
   }
   void setTables(Ts&&... tables)
   {
-    CombinationsBlockSameIndexPolicyBase<T1, Ts...>::setTables(std::forward<Ts>(tables)...);
+    CombinationsBlockSameIndexPolicyBase<BinningPolicy, T1, Ts...>::setTables(std::forward<Ts>(tables)...);
     setRanges();
   }
 
@@ -1246,54 +1348,97 @@ constexpr bool isSameType()
   return std::conjunction_v<std::is_same<T2, T2s>...>;
 }
 
-template <typename T1, typename... T2s>
-auto selfCombinations(const char* categoryColumnName, int categoryNeighbours, const T1& outsider, const T2s&... tables)
+template <typename BinningPolicy, typename T1, typename... T2s>
+auto selfCombinations(const BinningPolicy& binningPolicy, int categoryNeighbours, const T1& outsider, const T2s&... tables)
 {
   static_assert(isSameType<T2s...>(), "Tables must have the same type for self combinations");
-  return CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<T1, T2s...>>(CombinationsBlockStrictlyUpperSameIndexPolicy<T1, T2s...>(categoryColumnName, categoryNeighbours, outsider, tables...));
+  if constexpr (old_interface::is_string<BinningPolicy>::value) {
+    LOG(warn) << "You are using obsolete interface for block combinations / event mixing, please update";
+    return CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<std::string, T1, T2s...>>(CombinationsBlockStrictlyUpperSameIndexPolicy<std::string, T1, T2s...>(std::string(binningPolicy), categoryNeighbours, outsider, tables...));
+  } else {
+    return CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<BinningPolicy, T1, T2s...>>(CombinationsBlockStrictlyUpperSameIndexPolicy<BinningPolicy, T1, T2s...>(binningPolicy, categoryNeighbours, outsider, tables...));
+  }
 }
 
-template <typename T1, typename T2>
-auto selfPairCombinations(const char* categoryColumnName, int categoryNeighbours, const T1& outsider)
+template <typename BinningPolicy, typename T1, typename T2>
+auto selfPairCombinations(const BinningPolicy& binningPolicy, int categoryNeighbours, const T1& outsider)
 {
-  return CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<T1, T2, T2>>(CombinationsBlockStrictlyUpperSameIndexPolicy<T1, T2, T2>(categoryColumnName, categoryNeighbours, outsider));
+  if constexpr (old_interface::is_string<BinningPolicy>::value) {
+    LOG(warn) << "You are using obsolete interface for block combinations / event mixing, please update";
+    return CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<std::string, T1, T2, T2>>(CombinationsBlockStrictlyUpperSameIndexPolicy<std::string, T1, T2, T2>(std::string(binningPolicy), categoryNeighbours, outsider));
+  } else {
+    return CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<BinningPolicy, T1, T2, T2>>(CombinationsBlockStrictlyUpperSameIndexPolicy<BinningPolicy, T1, T2, T2>(binningPolicy, categoryNeighbours, outsider));
+  }
 }
 
-template <typename T1, typename T2>
-auto selfPairCombinations(const char* categoryColumnName, int categoryNeighbours, const T1& outsider, const T2& table)
+template <typename BinningPolicy, typename T1, typename T2>
+auto selfPairCombinations(const BinningPolicy& binningPolicy, int categoryNeighbours, const T1& outsider, const T2& table)
 {
-  return CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<T1, T2, T2>>(CombinationsBlockStrictlyUpperSameIndexPolicy<T1, T2, T2>(categoryColumnName, categoryNeighbours, outsider, table, table));
+  if constexpr (old_interface::is_string<BinningPolicy>::value) {
+    LOG(warn) << "You are using obsolete interface for block combinations / event mixing, please update";
+    return CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<std::string, T1, T2, T2>>(CombinationsBlockStrictlyUpperSameIndexPolicy<std::string, T1, T2, T2>(std::string(binningPolicy), categoryNeighbours, outsider, table, table));
+  } else {
+    return CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<BinningPolicy, T1, T2, T2>>(CombinationsBlockStrictlyUpperSameIndexPolicy<BinningPolicy, T1, T2, T2>(binningPolicy, categoryNeighbours, outsider, table, table));
+  }
 }
 
-template <typename T1, typename T2>
-auto selfTripleCombinations(const char* categoryColumnName, int categoryNeighbours, const T1& outsider)
+template <typename BinningPolicy, typename T1, typename T2>
+auto selfTripleCombinations(const BinningPolicy& binningPolicy, int categoryNeighbours, const T1& outsider)
 {
-  return CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<T1, T2, T2, T2>>(CombinationsBlockStrictlyUpperSameIndexPolicy<T1, T2, T2, T2>(categoryColumnName, categoryNeighbours, outsider));
+  if constexpr (old_interface::is_string<BinningPolicy>::value) {
+    LOG(warn) << "You are using obsolete interface for block combinations / event mixing, please update";
+    return CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<std::string, T1, T2, T2, T2>>(CombinationsBlockStrictlyUpperSameIndexPolicy<std::string, T1, T2, T2, T2>(std::string(binningPolicy), categoryNeighbours, outsider));
+  } else {
+    return CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<BinningPolicy, T1, T2, T2, T2>>(CombinationsBlockStrictlyUpperSameIndexPolicy<BinningPolicy, T1, T2, T2, T2>(binningPolicy, categoryNeighbours, outsider));
+  }
 }
 
-template <typename T1, typename T2>
-auto selfTripleCombinations(const char* categoryColumnName, int categoryNeighbours, const T1& outsider, const T2& table)
+template <typename BinningPolicy, typename T1, typename T2>
+auto selfTripleCombinations(const BinningPolicy& binningPolicy, int categoryNeighbours, const T1& outsider, const T2& table)
 {
-  return CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<T1, T2, T2, T2>>(CombinationsBlockStrictlyUpperSameIndexPolicy<T1, T2, T2, T2>(categoryColumnName, categoryNeighbours, outsider, table, table, table));
+  if constexpr (old_interface::is_string<BinningPolicy>::value) {
+    LOG(warn) << "You are using obsolete interface for block combinations / event mixing, please update";
+    return CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<std::string, T1, T2, T2, T2>>(CombinationsBlockStrictlyUpperSameIndexPolicy<std::string, T1, T2, T2, T2>(std::string(binningPolicy), categoryNeighbours, outsider, table, table, table));
+  } else {
+    return CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<BinningPolicy, T1, T2, T2, T2>>(CombinationsBlockStrictlyUpperSameIndexPolicy<BinningPolicy, T1, T2, T2, T2>(binningPolicy, categoryNeighbours, outsider, table, table, table));
+  }
 }
 
-template <typename T1, typename... T2s>
-auto combinations(const char* categoryColumnName, int categoryNeighbours, const T1& outsider, const T2s&... tables)
+template <typename BinningPolicy, typename T1, typename... T2s>
+auto combinations(const BinningPolicy& binningPolicy, int categoryNeighbours, const T1& outsider, const T2s&... tables)
 {
-  if constexpr (isSameType<T2s...>()) {
-    return CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<T1, T2s...>>(CombinationsBlockStrictlyUpperSameIndexPolicy<T1, T2s...>(categoryColumnName, categoryNeighbours, outsider, tables...));
+  if constexpr (old_interface::is_string<BinningPolicy>::value) {
+    LOG(warn) << "You are using obsolete interface for block combinations / event mixing, please update";
+    if constexpr (isSameType<T2s...>()) {
+      return CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<std::string, T1, T2s...>>(CombinationsBlockStrictlyUpperSameIndexPolicy<std::string, T1, T2s...>(std::string(binningPolicy), categoryNeighbours, outsider, tables...));
+    } else {
+      return CombinationsGenerator<CombinationsBlockUpperIndexPolicy<std::string, T1, T2s...>>(CombinationsBlockUpperIndexPolicy<std::string, T1, T2s...>(std::string(binningPolicy), categoryNeighbours, outsider, tables...));
+    }
   } else {
-    return CombinationsGenerator<CombinationsBlockUpperIndexPolicy<T1, T2s...>>(CombinationsBlockUpperIndexPolicy<T1, T2s...>(categoryColumnName, categoryNeighbours, outsider, tables...));
+    if constexpr (isSameType<T2s...>()) {
+      return CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<BinningPolicy, T1, T2s...>>(CombinationsBlockStrictlyUpperSameIndexPolicy<BinningPolicy, T1, T2s...>(binningPolicy, categoryNeighbours, outsider, tables...));
+    } else {
+      return CombinationsGenerator<CombinationsBlockUpperIndexPolicy<BinningPolicy, T1, T2s...>>(CombinationsBlockUpperIndexPolicy<BinningPolicy, T1, T2s...>(binningPolicy, categoryNeighbours, outsider, tables...));
+    }
   }
 }
 
-template <typename T1, typename... T2s>
-auto combinations(const char* categoryColumnName, int categoryNeighbours, const T1& outsider, const o2::framework::expressions::Filter& filter, const T2s&... tables)
+template <typename BinningPolicy, typename T1, typename... T2s>
+auto combinations(const BinningPolicy& binningPolicy, int categoryNeighbours, const T1& outsider, const o2::framework::expressions::Filter& filter, const T2s&... tables)
 {
-  if constexpr (isSameType<T2s...>()) {
-    return CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<T1, Filtered<T2s>...>>(CombinationsBlockStrictlyUpperSameIndexPolicy(categoryColumnName, categoryNeighbours, outsider, tables.select(filter)...));
+  if constexpr (old_interface::is_string<BinningPolicy>::value) {
+    LOG(warn) << "You are using obsolete interface for block combinations / event mixing, please update";
+    if constexpr (isSameType<T2s...>()) {
+      return CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<std::string, T1, Filtered<T2s>...>>(CombinationsBlockStrictlyUpperSameIndexPolicy(std::string(binningPolicy), categoryNeighbours, outsider, tables.select(filter)...));
+    } else {
+      return CombinationsGenerator<CombinationsBlockUpperIndexPolicy<std::string, T1, Filtered<T2s>...>>(CombinationsBlockUpperIndexPolicy(std::string(binningPolicy), categoryNeighbours, outsider, tables.select(filter)...));
+    }
   } else {
-    return CombinationsGenerator<CombinationsBlockUpperIndexPolicy<T1, Filtered<T2s>...>>(CombinationsBlockUpperIndexPolicy(categoryColumnName, categoryNeighbours, outsider, tables.select(filter)...));
+    if constexpr (isSameType<T2s...>()) {
+      return CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<BinningPolicy, T1, Filtered<T2s>...>>(CombinationsBlockStrictlyUpperSameIndexPolicy(binningPolicy, categoryNeighbours, outsider, tables.select(filter)...));
+    } else {
+      return CombinationsGenerator<CombinationsBlockUpperIndexPolicy<BinningPolicy, T1, Filtered<T2s>...>>(CombinationsBlockUpperIndexPolicy(binningPolicy, categoryNeighbours, outsider, tables.select(filter)...));
+    }
   }
 }
 
diff --git a/Framework/Core/include/Framework/BinningPolicy.h b/Framework/Core/include/Framework/BinningPolicy.h
new file mode 100644
index 0000000000000..420812bf8373e
--- /dev/null
+++ b/Framework/Core/include/Framework/BinningPolicy.h
@@ -0,0 +1,204 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef FRAMEWORK_BINNINGPOLICY_H
+#define FRAMEWORK_BINNINGPOLICY_H
+
+#include "Framework/HistogramSpec.h" // only for VARIABLE_WIDTH
+#include "Framework/ASoAHelpers.h"
+#include "Framework/Pack.h"
+#include "Framework/ArrowTypes.h"
+#include <optional>
+
+namespace o2::framework
+{
+
+namespace binning_helpers
+{
+template <typename... Cs>
+std::array<arrow::ChunkedArray*, sizeof...(Cs)> getArrowColumns(arrow::Table* table, pack<Cs...>)
+{
+  static_assert(std::conjunction_v<typename Cs::persistent...>, "BinningPolicy: only persistent columns accepted (not dynamic and not index ones");
+  return std::array<arrow::ChunkedArray*, sizeof...(Cs)>{o2::soa::getIndexFromLabel(table, Cs::columnLabel())...};
+}
+
+template <typename... Cs>
+std::array<std::shared_ptr<arrow::Array>, sizeof...(Cs)> getChunks(arrow::Table* table, pack<Cs...>, uint64_t ci)
+{
+  static_assert(std::conjunction_v<typename Cs::persistent...>, "BinningPolicy: only persistent columns accepted (not dynamic and not index ones");
+  return std::array<std::shared_ptr<arrow::Array>, sizeof...(Cs)>{o2::soa::getIndexFromLabel(table, Cs::columnLabel())->chunk(ci)...};
+}
+
+template <typename... Cs>
+std::tuple<typename Cs::type...> getRowData(arrow::Table* table, pack<Cs...>, uint64_t ci, uint64_t ai)
+{
+  static_assert(std::conjunction_v<typename Cs::persistent...>, "BinningPolicy: only persistent columns accepted (not dynamic and not index ones");
+  return std::make_tuple(std::static_pointer_cast<o2::soa::arrow_array_for_t<typename Cs::type>>(o2::soa::getIndexFromLabel(table, Cs::columnLabel())->chunk(ci))->raw_values()[ai]...);
+}
+} // namespace binning_helpers
+
+template <typename C, typename... Cs>
+struct BinningPolicy {
+  BinningPolicy(std::array<std::vector<double>, sizeof...(Cs) + 1> bins, bool ignoreOverflows = true) : mBins(bins), mIgnoreOverflows(ignoreOverflows)
+  {
+    static_assert(sizeof...(Cs) < 3, "No default binning for more than 3 columns, you need to implement a binning class yourself");
+    for (int i = 0; i < sizeof...(Cs) + 1; i++) {
+      expandConstantBinning(bins[i], i);
+    }
+  }
+
+  int getBin(std::tuple<typename C::type, typename Cs::type...> const& data) const
+  {
+    if (this->mIgnoreOverflows) {
+      // underflow
+      if (std::get<0>(data) < this->mBins[0][1]) { // xBins[0] is a dummy VARIABLE_WIDTH
+        return -1;
+      }
+      if constexpr (sizeof...(Cs) > 0) {
+        if (std::get<1>(data) < this->mBins[1][1]) { // this->mBins[1][0] is a dummy VARIABLE_WIDTH
+          return -1;
+        }
+      }
+      if constexpr (sizeof...(Cs) > 1) {
+        if (std::get<2>(data) < this->mBins[2][1]) { // this->mBins[2][0] is a dummy VARIABLE_WIDTH
+          return -1;
+        }
+      }
+    }
+
+    unsigned int i = 2, j = 2, k = 2;
+    for (; i < this->mBins[0].size(); i++) {
+      if (std::get<0>(data) < this->mBins[0][i]) {
+
+        if constexpr (sizeof...(Cs) > 0) {
+          for (; j < this->mBins[1].size(); j++) {
+            if (std::get<1>(data) < this->mBins[1][j]) {
+
+              if constexpr (sizeof...(Cs) > 1) {
+                for (; k < this->mBins[2].size(); k++) {
+                  if (std::get<2>(data) < this->mBins[2][k]) {
+                    return getBinAt(i, j, k);
+                  }
+                }
+                if (this->mIgnoreOverflows) {
+                  return -1;
+                }
+              }
+
+              // overflow for this->mBins[2] only
+              return getBinAt(i, j, k);
+            }
+          }
+
+          if (this->mIgnoreOverflows) {
+            return -1;
+          }
+
+          // overflow for this->mBins[1] only
+          if constexpr (sizeof...(Cs) > 1) {
+            for (k = 2; k < this->mBins[2].size(); k++) {
+              if (std::get<2>(data) < this->mBins[2][k]) {
+                return getBinAt(i, j, k);
+              }
+            }
+          }
+        }
+
+        // overflow for this->mBins[2] and this->mBins[1]
+        return getBinAt(i, j, k);
+      }
+    }
+
+    if (this->mIgnoreOverflows) {
+      // overflow
+      return -1;
+    }
+
+    // overflow for this->mBins[0] only
+    if constexpr (sizeof...(Cs) > 0) {
+      for (j = 2; j < this->mBins[1].size(); j++) {
+        if (std::get<1>(data) < this->mBins[1][j]) {
+
+          if constexpr (sizeof...(Cs) > 1) {
+            for (k = 2; k < this->mBins[2].size(); k++) {
+              if (std::get<2>(data) < this->mBins[2][k]) {
+                return getBinAt(i, j, k);
+              }
+            }
+          }
+
+          // overflow for this->mBins[0] and this->mBins[2]
+          return getBinAt(i, j, k);
+        }
+      }
+    }
+
+    // overflow for this->mBins[0] and this->mBins[1]
+    if constexpr (sizeof...(Cs) > 1) {
+      for (k = 2; k < this->mBins[2].size(); k++) {
+        if (std::get<2>(data) < this->mBins[2][k]) {
+          return getBinAt(i, j, k);
+        }
+      }
+    }
+
+    // overflow for all bins
+    return getBinAt(i, j, k);
+  }
+
+  pack<C, Cs...> getColumns() const { return pack<C, Cs...>{}; }
+  static constexpr int mColumnsCount = sizeof...(Cs) + 1;
+
+ private:
+  int getBinAt(unsigned int i, unsigned int j, unsigned int k) const
+  {
+    if constexpr (sizeof...(Cs) == 0) {
+      return i - 1;
+    } else if constexpr (sizeof...(Cs) == 1) {
+      return (i - 1) + (j - 1) * this->mBins[0].size();
+    } else if constexpr (sizeof...(Cs) == 2) {
+      return (i - 1) + (j - 1) * this->mBins[0].size() + (k - 1) * (this->mBins[0].size() + this->mBins[1].size());
+    } else {
+      return -1;
+    }
+  }
+
+  void expandConstantBinning(std::vector<double> const& bins, int ind)
+  {
+    if (bins[0] != VARIABLE_WIDTH) {
+      int nBins = static_cast<int>(bins[0]);
+      this->mBins[ind].clear();
+      this->mBins[ind].resize(nBins + 2);
+      this->mBins[ind][0] = VARIABLE_WIDTH;
+      std::iota(std::begin(this->mBins[ind]) + 1, std::end(this->mBins[ind]), bins[2] - bins[1] / nBins);
+    }
+  }
+
+  std::array<std::vector<double>, sizeof...(Cs) + 1> mBins;
+  bool mIgnoreOverflows;
+};
+
+template <typename C>
+struct NoBinningPolicy {
+  // Just take the bin number from the column data
+  NoBinningPolicy() = default;
+
+  int getBin(std::tuple<typename C::type> const& data) const
+  {
+    return std::get<0>(data);
+  }
+
+  pack<C> getColumns() const { return pack<C>{}; }
+  static constexpr int mColumnsCount = 1;
+};
+
+} // namespace o2::framework
+#endif // FRAMEWORK_BINNINGPOLICY_H_
diff --git a/Framework/Core/include/Framework/GroupedCombinations.h b/Framework/Core/include/Framework/GroupedCombinations.h
index a4f64e1a4d94e..6d1a918c44214 100644
--- a/Framework/Core/include/Framework/GroupedCombinations.h
+++ b/Framework/Core/include/Framework/GroupedCombinations.h
@@ -258,15 +258,15 @@ struct GroupedCombinationsGenerator<T1, GroupingPolicy, H, G, pack<Us...>, As...
 // 'Pair' and 'Triple' can be used for same kind pair/triple, too, just specify the same type twice
 template <typename H, typename G>
 using joinedCollisions = typename soa::Join<H, G>::table_t;
-template <typename H, typename G, typename A1, typename A2, typename T1 = int, typename GroupingPolicy = o2::soa::CombinationsBlockStrictlyUpperSameIndexPolicy<T1, joinedCollisions<H, G>, joinedCollisions<H, G>>>
+template <typename H, typename G, typename A1, typename A2, typename T1 = int, typename GroupingPolicy = o2::soa::CombinationsBlockStrictlyUpperSameIndexPolicy<std::string, T1, joinedCollisions<H, G>, joinedCollisions<H, G>>>
 using Pair = GroupedCombinationsGenerator<T1, GroupingPolicy, H, G, unique_pack_t<pack<A1, A2>>, A1, A2>;
-template <typename H, typename G, typename A, typename T1 = int, typename GroupingPolicy = o2::soa::CombinationsBlockStrictlyUpperSameIndexPolicy<T1, joinedCollisions<H, G>, joinedCollisions<H, G>>>
+template <typename H, typename G, typename A, typename T1 = int, typename GroupingPolicy = o2::soa::CombinationsBlockStrictlyUpperSameIndexPolicy<std::string, T1, joinedCollisions<H, G>, joinedCollisions<H, G>>>
 using SameKindPair = GroupedCombinationsGenerator<T1, GroupingPolicy, H, G, pack<A>, A, A>;
 
 // Aliases for 3-particle correlations
-template <typename H, typename G, typename A1, typename A2, typename A3, typename T1 = int, typename GroupingPolicy = o2::soa::CombinationsBlockStrictlyUpperSameIndexPolicy<T1, joinedCollisions<H, G>, joinedCollisions<H, G>, joinedCollisions<H, G>>>
+template <typename H, typename G, typename A1, typename A2, typename A3, typename T1 = int, typename GroupingPolicy = o2::soa::CombinationsBlockStrictlyUpperSameIndexPolicy<std::string, T1, joinedCollisions<H, G>, joinedCollisions<H, G>, joinedCollisions<H, G>>>
 using Triple = GroupedCombinationsGenerator<T1, GroupingPolicy, H, G, unique_pack_t<pack<A1, A2, A3>>, A1, A2, A3>;
-template <typename H, typename G, typename A, typename T1 = int, typename GroupingPolicy = o2::soa::CombinationsBlockStrictlyUpperSameIndexPolicy<T1, joinedCollisions<H, G>, joinedCollisions<H, G>, joinedCollisions<H, G>>>
+template <typename H, typename G, typename A, typename T1 = int, typename GroupingPolicy = o2::soa::CombinationsBlockStrictlyUpperSameIndexPolicy<std::string, T1, joinedCollisions<H, G>, joinedCollisions<H, G>, joinedCollisions<H, G>>>
 using SameKindTriple = GroupedCombinationsGenerator<T1, GroupingPolicy, H, G, pack<A>, A, A, A>;
 
 } // namespace o2::framework
diff --git a/Framework/Core/test/benchmark_ASoAHelpers.cxx b/Framework/Core/test/benchmark_ASoAHelpers.cxx
index 59775bf02ff01..3ee7c4a062293 100644
--- a/Framework/Core/test/benchmark_ASoAHelpers.cxx
+++ b/Framework/Core/test/benchmark_ASoAHelpers.cxx
@@ -454,12 +454,13 @@ static void BM_ASoAHelpersCombGenSimplePairsSameCategories(benchmark::State& sta
 
   using Test = o2::soa::Table<test::X>;
   Test tests{table};
+  NoBinningPolicy<test::X> noBinning;
 
   int64_t count = 0;
 
   for (auto _ : state) {
     count = 0;
-    for (auto& comb : combinations(CombinationsBlockUpperSameIndexPolicy("x", 2, -1, tests, tests))) {
+    for (auto& comb : combinations(CombinationsBlockUpperSameIndexPolicy(noBinning, 2, -1, tests, tests))) {
       count++;
     }
     benchmark::DoNotOptimize(count);
@@ -486,12 +487,13 @@ static void BM_ASoAHelpersCombGenSimpleFivesSameCategories(benchmark::State& sta
 
   using Test = o2::soa::Table<test::X>;
   Test tests{table};
+  NoBinningPolicy<test::X> noBinning;
 
   int64_t count = 0;
 
   for (auto _ : state) {
     count = 0;
-    for (auto& comb : combinations(CombinationsBlockUpperSameIndexPolicy("x", 5, -1, tests, tests, tests, tests, tests))) {
+    for (auto& comb : combinations(CombinationsBlockUpperSameIndexPolicy(noBinning, 5, -1, tests, tests, tests, tests, tests))) {
       count++;
     }
     benchmark::DoNotOptimize(count);
@@ -518,12 +520,13 @@ static void BM_ASoAHelpersCombGenSimplePairsCategories(benchmark::State& state)
 
   using Test = o2::soa::Table<test::X>;
   Test tests{table};
+  NoBinningPolicy<test::X> noBinning;
 
   int64_t count = 0;
 
   for (auto _ : state) {
     count = 0;
-    for (auto& comb : combinations(CombinationsBlockUpperIndexPolicy("x", 2, -1, tests, tests))) {
+    for (auto& comb : combinations(CombinationsBlockUpperIndexPolicy(noBinning, 2, -1, tests, tests))) {
       count++;
     }
     benchmark::DoNotOptimize(count);
@@ -550,12 +553,13 @@ static void BM_ASoAHelpersCombGenSimpleFivesCategories(benchmark::State& state)
 
   using Test = o2::soa::Table<test::X>;
   Test tests{table};
+  NoBinningPolicy<test::X> noBinning;
 
   int64_t count = 0;
 
   for (auto _ : state) {
     count = 0;
-    for (auto& comb : combinations(CombinationsBlockUpperIndexPolicy("x", 2, -1, tests, tests, tests, tests, tests))) {
+    for (auto& comb : combinations(CombinationsBlockUpperIndexPolicy(noBinning, 2, -1, tests, tests, tests, tests, tests))) {
       count++;
     }
     benchmark::DoNotOptimize(count);
@@ -587,12 +591,13 @@ static void BM_ASoAHelpersCombGenCollisionsPairsSameCategories(benchmark::State&
   auto table = builder.finalize();
 
   o2::aod::Collisions collisions{table};
+  NoBinningPolicy<o2::aod::collision::NumContrib> noBinning;
 
   int64_t count = 0;
 
   for (auto _ : state) {
     count = 0;
-    for (auto& comb : combinations(CombinationsBlockUpperSameIndexPolicy("fNumContrib", 2, -1, collisions, collisions))) {
+    for (auto& comb : combinations(CombinationsBlockUpperSameIndexPolicy(noBinning, 2, -1, collisions, collisions))) {
       count++;
     }
     benchmark::DoNotOptimize(count);
@@ -624,12 +629,13 @@ static void BM_ASoAHelpersCombGenCollisionsFivesSameCategories(benchmark::State&
   auto table = builder.finalize();
 
   o2::aod::Collisions collisions{table};
+  NoBinningPolicy<o2::aod::collision::NumContrib> noBinning;
 
   int64_t count = 0;
 
   for (auto _ : state) {
     count = 0;
-    for (auto& comb : combinations(CombinationsBlockUpperSameIndexPolicy("fNumContrib", 5, -1, collisions, collisions, collisions, collisions, collisions))) {
+    for (auto& comb : combinations(CombinationsBlockUpperSameIndexPolicy(noBinning, 5, -1, collisions, collisions, collisions, collisions, collisions))) {
       count++;
     }
     benchmark::DoNotOptimize(count);
@@ -661,12 +667,13 @@ static void BM_ASoAHelpersCombGenCollisionsPairsCategories(benchmark::State& sta
   auto table = builder.finalize();
 
   o2::aod::Collisions collisions{table};
+  NoBinningPolicy<o2::aod::collision::NumContrib> noBinning;
 
   int64_t count = 0;
 
   for (auto _ : state) {
     count = 0;
-    for (auto& comb : combinations(CombinationsBlockUpperIndexPolicy("fNumContrib", 2, -1, collisions, collisions))) {
+    for (auto& comb : combinations(CombinationsBlockUpperIndexPolicy(noBinning, 2, -1, collisions, collisions))) {
       count++;
     }
     benchmark::DoNotOptimize(count);
@@ -698,12 +705,13 @@ static void BM_ASoAHelpersCombGenCollisionsFivesCategories(benchmark::State& sta
   auto table = builder.finalize();
 
   o2::aod::Collisions collisions{table};
+  NoBinningPolicy<o2::aod::collision::NumContrib> noBinning;
 
   int64_t count = 0;
 
   for (auto _ : state) {
     count = 0;
-    for (auto& comb : combinations(CombinationsBlockUpperIndexPolicy("fNumContrib", 5, -1, collisions, collisions, collisions, collisions, collisions))) {
+    for (auto& comb : combinations(CombinationsBlockUpperIndexPolicy(noBinning, 5, -1, collisions, collisions, collisions, collisions, collisions))) {
       count++;
     }
     benchmark::DoNotOptimize(count);
diff --git a/Framework/Core/test/test_ASoAHelpers.cxx b/Framework/Core/test/test_ASoAHelpers.cxx
index 6dbbf7f3fa416..1e4c963c44011 100644
--- a/Framework/Core/test/test_ASoAHelpers.cxx
+++ b/Framework/Core/test/test_ASoAHelpers.cxx
@@ -31,42 +31,6 @@ DECLARE_SOA_COLUMN_FULL(FloatZ, floatZ, float, "floatZ");
 DECLARE_SOA_DYNAMIC_COLUMN(Sum, sum, [](int32_t x, int32_t y) { return x + y; });
 } // namespace test
 
-// Calculate hash for an element based on 2 properties and their bins.
-int32_t getHash(const std::vector<uint32_t>& yBins, const std::vector<float>& zBins, uint32_t colY, float colZ, bool ignoreOverflows = false)
-{
-  if (ignoreOverflows) {
-    if (colY < yBins[0] || colZ < zBins[0]) {
-      return -1;
-    }
-  }
-
-  for (int i = 0; i < yBins.size(); i++) {
-    if (colY < yBins[i]) {
-      for (int j = 0; j < zBins.size(); j++) {
-        if (colZ < zBins[j]) {
-          return i + j * (yBins.size() + 1);
-        }
-      }
-      // overflow for zBins only
-      return ignoreOverflows ? -1 : i + zBins.size() * (yBins.size() + 1);
-    }
-  }
-
-  if (ignoreOverflows) {
-    return -1;
-  }
-
-  // overflow for yBins only
-  for (int j = 0; j < zBins.size(); j++) {
-    if (colZ < zBins[j]) {
-      return yBins.size() + j * (yBins.size() + 1);
-    }
-  }
-
-  // overflow for both bins
-  return (zBins.size() + 1) * (yBins.size() + 1) - 1;
-}
-
 BOOST_AUTO_TEST_CASE(IteratorTuple)
 {
   TableBuilder builderA;
@@ -166,20 +130,10 @@ BOOST_AUTO_TEST_CASE(CombinationsGeneratorConstruction)
   // Grouped data:
   // [3, 5] [0, 4, 7], [1, 6], [2]
   // Assuming bins intervals: [ , )
-  std::vector<uint32_t> yBins{0, 5, 10, 20, 30, 40, 50, 101};
-  std::vector<float> zBins{-7.0f, -5.0f, -3.0f, -1.0f, 1.0f, 3.0f, 5.0f, 7.0f};
-
-  TableBuilder builderAux;
-  auto rowWriterAux = builderAux.persist<int32_t, int32_t>({"x", "y"});
-  for (auto it = testsA.begin(); it != testsA.end(); it++) {
-    auto& elem = *it;
-    rowWriterAux(0, elem.x(), getHash(yBins, zBins, elem.y(), elem.floatZ()));
-  }
-  auto tableAux = builderAux.finalize();
-  BOOST_REQUIRE_EQUAL(tableAux->num_rows(), 8);
-  using TestsAux = o2::soa::Table<o2::soa::Index<>, test::X, test::Y>;
-  TestsAux testAux{tableAux};
-  BOOST_REQUIRE_EQUAL(8, testAux.size());
+  std::vector<double> yBins{VARIABLE_WIDTH, 0, 5, 10, 20, 30, 40, 50, 101};
+  std::vector<double> zBins{VARIABLE_WIDTH, -7.0, -5.0, -3.0, -1.0, 1.0, 3.0, 5.0, 7.0};
+
+  BinningPolicy<test::Y, test::FloatZ> pairBinning{{yBins, zBins}, false};
 
   CombinationsGenerator<CombinationsStrictlyUpperIndexPolicy<TestA, TestA>>::CombinationsIterator combIt(CombinationsStrictlyUpperIndexPolicy(testsA, testsA));
   BOOST_REQUIRE_NE(static_cast<test::X>(std::get<0>(*(combIt))).getIterator().mCurrentPos, nullptr);
@@ -337,10 +291,10 @@ BOOST_AUTO_TEST_CASE(CombinationsGeneratorConstruction)
   BOOST_REQUIRE_EQUAL(*(static_cast<test::X>(std::get<4>(endBadCombination)).getIterator().mCurrentPos), 4);
   BOOST_REQUIRE_EQUAL(static_cast<test::X>(std::get<4>(endBadCombination)).getIterator().mCurrentChunk, 0);
 
-  auto combBlock = combinations(CombinationsBlockStrictlyUpperSameIndexPolicy("y", 2, -1, testAux, testAux));
+  auto combBlock = combinations(CombinationsBlockStrictlyUpperSameIndexPolicy(pairBinning, 2, -1, testsA, testsA));
 
-  static_assert(std::is_same_v<decltype(combBlock.begin()), CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<int32_t, TestsAux, TestsAux>>::CombinationsIterator>, "Wrong iterator type");
-  static_assert(std::is_same_v<decltype(*(combBlock.begin())), CombinationsBlockStrictlyUpperSameIndexPolicy<int32_t, TestsAux, TestsAux>::CombinationType&>, "Wrong combination type");
+  static_assert(std::is_same_v<decltype(combBlock.begin()), CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<BinningPolicy<test::Y, test::FloatZ>, int32_t, TestA, TestA>>::CombinationsIterator>, "Wrong iterator type");
+  static_assert(std::is_same_v<decltype(*(combBlock.begin())), CombinationsBlockStrictlyUpperSameIndexPolicy<BinningPolicy<test::Y, test::FloatZ>, int32_t, TestA, TestA>::CombinationType&>, "Wrong combination type");
 
   auto beginBlockCombination = *(combBlock.begin());
   BOOST_REQUIRE_NE(static_cast<test::X>(std::get<0>(beginBlockCombination)).getIterator().mCurrentPos, nullptr);
@@ -975,55 +929,33 @@ BOOST_AUTO_TEST_CASE(BlockCombinations)
   TestA testA{tableA};
   BOOST_REQUIRE_EQUAL(10, testA.size());
 
+  TableBuilder builderAHalf;
+  auto rowWriterAHalf = builderAHalf.persist<int32_t, int32_t, float>({"x", "y", "floatZ"});
+  rowWriterAHalf(0, 0, 25, -6.0f);
+  rowWriterAHalf(0, 1, 18, 0.0f);
+  rowWriterAHalf(0, 2, 48, 8.0f);
+  rowWriterAHalf(0, 3, 103, 2.0f);
+  rowWriterAHalf(0, 4, 28, -6.0f);
+  auto tableAHalf = builderAHalf.finalize();
+  BOOST_REQUIRE_EQUAL(tableAHalf->num_rows(), 5);
+
+  TestA testAHalf{tableAHalf};
+  BOOST_REQUIRE_EQUAL(5, testAHalf.size());
+
   // Grouped data:
   // [3, 5] [0, 4, 7], [1, 6], [2, 8, 9]
   // Assuming bins intervals: [ , )
-  std::vector<uint32_t> yBins{0, 5, 10, 20, 30, 40, 50, 101};
-  std::vector<float> zBins{-7.0f, -5.0f, -3.0f, -1.0f, 1.0f, 3.0f, 5.0f, 7.0f};
-
-  TableBuilder builderAux;
-  TableBuilder builderAuxHalf;
-  auto rowWriterAux = builderAux.persist<int32_t, int32_t>({"x", "y"});
-  auto rowWriterAuxHalf = builderAuxHalf.persist<int32_t, int32_t>({"x", "y"});
-  int size = 0;
-  for (auto it = testA.begin(); it != testA.end(); it++) {
-    auto& elem = *it;
-    rowWriterAux(0, elem.x(), getHash(yBins, zBins, elem.y(), elem.floatZ()));
-    if (size < 5) {
-      rowWriterAuxHalf(0, elem.x(), getHash(yBins, zBins, elem.y(), elem.floatZ()));
-    }
-    size++;
-  }
-  auto tableAux = builderAux.finalize();
-  auto tableAuxHalf = builderAuxHalf.finalize();
-  BOOST_REQUIRE_EQUAL(tableAux->num_rows(), 10);
-  BOOST_REQUIRE_EQUAL(tableAuxHalf->num_rows(), 5);
-
-  // Auxiliary table: testsAux with id and hash, hash is the category for grouping
-  using TestsAux = o2::soa::Table<o2::soa::Index<>, test::X, test::Y>;
-  TestsAux testAux{tableAux};
-  TestsAux testAuxHalf{tableAuxHalf};
-  BOOST_REQUIRE_EQUAL(10, testAux.size());
-  BOOST_REQUIRE_EQUAL(5, testAuxHalf.size());
-
-  // Omitting values outside bins
-  TableBuilder builderAuxNoOverflows;
-  auto rowWriterAux2 = builderAuxNoOverflows.persist<int32_t, int32_t>({"x", "y"});
-  for (auto it = testA.begin(); it != testA.end(); it++) {
-    auto& elem = *it;
-    rowWriterAux2(0, elem.x(), getHash(yBins, zBins, elem.y(), elem.floatZ(), true));
-  }
-  auto tableAuxNoOverflows = builderAuxNoOverflows.finalize();
-  BOOST_REQUIRE_EQUAL(tableAuxNoOverflows->num_rows(), 10);
+  std::vector<double> yBins{VARIABLE_WIDTH, 0, 5, 10, 20, 30, 40, 50, 101};
+  std::vector<double> zBins{VARIABLE_WIDTH, -7.0, -5.0, -3.0, -1.0, 1.0, 3.0, 5.0, 7.0};
 
-  TestsAux testAuxNoOverflows{tableAuxNoOverflows};
-  BOOST_REQUIRE_EQUAL(10, testAuxNoOverflows.size());
+  BinningPolicy<test::Y, test::FloatZ> pairBinning{{yBins, zBins}, false};
+  BinningPolicy<test::Y, test::FloatZ> pairBinningNoOverflows{{yBins, zBins}, true};
 
   // 2, 3, 5, 8, 9 have overflows in testA
   std::vector<std::tuple<int32_t, int32_t>> expectedFullPairsNoOverflows{
     {0, 0}, {0, 4}, {4, 0}, {4, 4}, {4, 7}, {7, 4}, {7, 7}, {1, 1}, {1, 6}, {6, 1}, {6, 6}};
   int count = 0;
-  for (auto& [c0, c1] : combinations(CombinationsBlockFullIndexPolicy("y", 1, -1, testAuxNoOverflows, testAuxNoOverflows))) {
+  for (auto& [c0, c1] : combinations(CombinationsBlockFullIndexPolicy(pairBinningNoOverflows, 1, -1, testA, testA))) {
     BOOST_CHECK_EQUAL(c0.x(), std::get<0>(expectedFullPairsNoOverflows[count]));
     BOOST_CHECK_EQUAL(c1.x(), std::get<1>(expectedFullPairsNoOverflows[count]));
     count++;
@@ -1033,7 +965,7 @@ BOOST_AUTO_TEST_CASE(BlockCombinations)
   std::vector<std::tuple<int32_t, int32_t>> expectedFullPairs{
     {0, 0}, {0, 4}, {0, 7}, {4, 0}, {7, 0}, {4, 4}, {4, 7}, {7, 4}, {7, 7}, {1, 1}, {1, 6}, {6, 1}, {6, 6}, {3, 3}, {3, 5}, {5, 3}, {5, 5}, {2, 2}, {2, 8}, {2, 9}, {8, 2}, {9, 2}, {8, 8}, {8, 9}, {9, 8}, {9, 9}};
   count = 0;
-  for (auto& [c0, c1] : combinations(CombinationsBlockFullIndexPolicy("y", 2, -1, testAux, testAux))) {
+  for (auto& [c0, c1] : combinations(CombinationsBlockFullIndexPolicy(pairBinning, 2, -1, testA, testA))) {
     BOOST_CHECK_EQUAL(c0.x(), std::get<0>(expectedFullPairs[count]));
     BOOST_CHECK_EQUAL(c1.x(), std::get<1>(expectedFullPairs[count]));
     count++;
@@ -1043,7 +975,7 @@ BOOST_AUTO_TEST_CASE(BlockCombinations)
   std::vector<std::tuple<int32_t, int32_t, int32_t>> expectedFullTriples{
     {0, 0, 0}, {0, 0, 4}, {0, 0, 7}, {0, 4, 0}, {0, 4, 4}, {0, 4, 7}, {0, 7, 0}, {0, 7, 4}, {0, 7, 7}, {4, 0, 0}, {4, 0, 4}, {4, 0, 7}, {7, 0, 0}, {7, 0, 4}, {7, 0, 7}, {4, 4, 0}, {4, 7, 0}, {7, 4, 0}, {7, 7, 0}, {4, 4, 4}, {4, 4, 7}, {4, 7, 4}, {4, 7, 7}, {7, 4, 4}, {7, 4, 7}, {7, 7, 4}, {7, 7, 7}, {1, 1, 1}, {1, 1, 6}, {1, 6, 1}, {1, 6, 6}, {6, 1, 1}, {6, 1, 6}, {6, 6, 1}, {6, 6, 6}, {3, 3, 3}, {3, 3, 5}, {3, 5, 3}, {3, 5, 5}, {5, 3, 3}, {5, 3, 5}, {5, 5, 3}, {5, 5, 5}, {2, 2, 2}, {2, 2, 8}, {2, 2, 9}, {2, 8, 2}, {2, 8, 8}, {2, 8, 9}, {2, 9, 2}, {2, 9, 8}, {2, 9, 9}, {8, 2, 2}, {8, 2, 8}, {8, 2, 9}, {9, 2, 2}, {9, 2, 8}, {9, 2, 9}, {8, 8, 2}, {8, 9, 2}, {9, 8, 2}, {9, 9, 2}, {8, 8, 8}, {8, 8, 9}, {8, 9, 8}, {8, 9, 9}, {9, 8, 8}, {9, 8, 9}, {9, 9, 8}, {9, 9, 9}};
   count = 0;
-  for (auto& [c0, c1, c2] : combinations(CombinationsBlockFullIndexPolicy("y", 2, -1, testAux, testAux, testAux))) {
+  for (auto& [c0, c1, c2] : combinations(CombinationsBlockFullIndexPolicy(pairBinning, 2, -1, testA, testA, testA))) {
     BOOST_CHECK_EQUAL(c0.x(), std::get<0>(expectedFullTriples[count]));
     BOOST_CHECK_EQUAL(c1.x(), std::get<1>(expectedFullTriples[count]));
     BOOST_CHECK_EQUAL(c2.x(), std::get<2>(expectedFullTriples[count]));
@@ -1054,7 +986,7 @@ BOOST_AUTO_TEST_CASE(BlockCombinations)
   std::vector<std::tuple<int32_t, int32_t>> expectedUpperPairs{
     {0, 0}, {0, 4}, {0, 7}, {4, 4}, {4, 7}, {7, 7}, {1, 1}, {1, 6}, {6, 6}, {3, 3}, {3, 5}, {5, 5}, {2, 2}, {2, 8}, {2, 9}, {8, 8}, {8, 9}, {9, 9}};
   count = 0;
-  for (auto& [c0, c1] : combinations(CombinationsBlockUpperIndexPolicy("y", 2, -1, testAux, testAux))) {
+  for (auto& [c0, c1] : combinations(CombinationsBlockUpperIndexPolicy(pairBinning, 2, -1, testA, testA))) {
     BOOST_CHECK_EQUAL(c0.x(), std::get<0>(expectedUpperPairs[count]));
     BOOST_CHECK_EQUAL(c1.x(), std::get<1>(expectedUpperPairs[count]));
     count++;
@@ -1064,7 +996,7 @@ BOOST_AUTO_TEST_CASE(BlockCombinations)
   std::vector<std::tuple<int32_t, int32_t, int32_t>> expectedUpperTriples{
     {0, 0, 0}, {0, 0, 4}, {0, 4, 4}, {4, 4, 4}, {4, 4, 7}, {4, 7, 7}, {7, 7, 7}, {1, 1, 1}, {1, 1, 6}, {1, 6, 6}, {6, 6, 6}, {3, 3, 3}, {3, 3, 5}, {3, 5, 5}, {5, 5, 5}, {2, 2, 2}, {2, 2, 8}, {2, 8, 8}, {8, 8, 8}, {8, 8, 9}, {8, 9, 9}, {9, 9, 9}};
   count = 0;
-  for (auto& [c0, c1, c2] : combinations(CombinationsBlockUpperIndexPolicy("y", 1, -1, testAux, testAux, testAux))) {
+  for (auto& [c0, c1, c2] : combinations(CombinationsBlockUpperIndexPolicy(pairBinning, 1, -1, testA, testA, testA))) {
     BOOST_CHECK_EQUAL(c0.x(), std::get<0>(expectedUpperTriples[count]));
     BOOST_CHECK_EQUAL(c1.x(), std::get<1>(expectedUpperTriples[count]));
     BOOST_CHECK_EQUAL(c2.x(), std::get<2>(expectedUpperTriples[count]));
@@ -1074,7 +1006,7 @@ BOOST_AUTO_TEST_CASE(BlockCombinations)
 
   std::vector<std::tuple<int32_t, int32_t, int32_t, int32_t, int32_t>> expectedUpperFives{{0, 0, 0, 0, 0}, {0, 0, 0, 0, 4}, {0, 0, 0, 0, 7}, {0, 0, 0, 4, 4}, {0, 0, 0, 4, 7}, {0, 0, 0, 7, 7}, {0, 0, 4, 4, 4}, {0, 0, 4, 4, 7}, {0, 0, 4, 7, 7}, {0, 0, 7, 7, 7}, {0, 4, 4, 4, 4}, {0, 4, 4, 4, 7}, {0, 4, 4, 7, 7}, {0, 4, 7, 7, 7}, {0, 7, 7, 7, 7}, {4, 4, 4, 4, 4}, {4, 4, 4, 4, 7}, {4, 4, 4, 7, 7}, {4, 4, 7, 7, 7}, {4, 7, 7, 7, 7}, {7, 7, 7, 7, 7}, {1, 1, 1, 1, 1}, {1, 1, 1, 1, 6}, {1, 1, 1, 6, 6}, {1, 1, 6, 6, 6}, {1, 6, 6, 6, 6}, {6, 6, 6, 6, 6}, {3, 3, 3, 3, 3}, {3, 3, 3, 3, 5}, {3, 3, 3, 5, 5}, {3, 3, 5, 5, 5}, {3, 5, 5, 5, 5}, {5, 5, 5, 5, 5}, {2, 2, 2, 2, 2}, {2, 2, 2, 2, 8}, {2, 2, 2, 2, 9}, {2, 2, 2, 8, 8}, {2, 2, 2, 8, 9}, {2, 2, 2, 9, 9}, {2, 2, 8, 8, 8}, {2, 2, 8, 8, 9}, {2, 2, 8, 9, 9}, {2, 2, 9, 9, 9}, {2, 8, 8, 8, 8}, {2, 8, 8, 8, 9}, {2, 8, 8, 9, 9}, {2, 8, 9, 9, 9}, {2, 9, 9, 9, 9}, {8, 8, 8, 8, 8}, {8, 8, 8, 8, 9}, {8, 8, 8, 9, 9}, {8, 8, 9, 9, 9}, {8, 9, 9, 9, 9}, {9, 9, 9, 9, 9}};
   count = 0;
-  for (auto& [c0, c1, c2, c3, c4] : combinations(CombinationsBlockUpperIndexPolicy("y", 2, -1, testAux, testAux, testAux, testAux, testAux))) {
+  for (auto& [c0, c1, c2, c3, c4] : combinations(CombinationsBlockUpperIndexPolicy(pairBinning, 2, -1, testA, testA, testA, testA, testA))) {
     BOOST_CHECK_EQUAL(c0.x(), std::get<0>(expectedUpperFives[count]));
     BOOST_CHECK_EQUAL(c1.x(), std::get<1>(expectedUpperFives[count]));
     BOOST_CHECK_EQUAL(c2.x(), std::get<2>(expectedUpperFives[count]));
@@ -1087,7 +1019,7 @@ BOOST_AUTO_TEST_CASE(BlockCombinations)
   std::vector<std::tuple<int32_t, int32_t>> expectedStrictlyUpperPairsSmaller{
     {0, 4}, {4, 7}, {1, 6}, {3, 5}, {2, 8}, {8, 9}};
   count = 0;
-  for (auto& [c0, c1] : combinations(CombinationsBlockStrictlyUpperSameIndexPolicy("y", 1, -1, testAux, testAux))) {
+  for (auto& [c0, c1] : combinations(CombinationsBlockStrictlyUpperSameIndexPolicy(pairBinning, 1, -1, testA, testA))) {
     BOOST_CHECK_EQUAL(c0.x(), std::get<0>(expectedStrictlyUpperPairsSmaller[count]));
     BOOST_CHECK_EQUAL(c1.x(), std::get<1>(expectedStrictlyUpperPairsSmaller[count]));
     count++;
@@ -1097,7 +1029,7 @@ BOOST_AUTO_TEST_CASE(BlockCombinations)
   std::vector<std::tuple<int32_t, int32_t>> expectedStrictlyUpperPairs{
     {0, 4}, {0, 7}, {4, 7}, {1, 6}, {3, 5}, {2, 8}, {2, 9}, {8, 9}};
   count = 0;
-  for (auto& [c0, c1] : combinations(CombinationsBlockStrictlyUpperSameIndexPolicy("y", 2, -1, testAux, testAux))) {
+  for (auto& [c0, c1] : combinations(CombinationsBlockStrictlyUpperSameIndexPolicy(pairBinning, 2, -1, testA, testA))) {
     BOOST_CHECK_EQUAL(c0.x(), std::get<0>(expectedStrictlyUpperPairs[count]));
     BOOST_CHECK_EQUAL(c1.x(), std::get<1>(expectedStrictlyUpperPairs[count]));
     count++;
@@ -1107,7 +1039,7 @@ BOOST_AUTO_TEST_CASE(BlockCombinations)
   std::vector<std::tuple<int32_t, int32_t, int32_t>> expectedStrictlyUpperTriples{
     {0, 4, 7}, {2, 8, 9}};
   count = 0;
-  for (auto& [c0, c1, c2] : combinations(CombinationsBlockStrictlyUpperSameIndexPolicy("y", 2, -1, testAux, testAux, testAux))) {
+  for (auto& [c0, c1, c2] : combinations(CombinationsBlockStrictlyUpperSameIndexPolicy(pairBinning, 2, -1, testA, testA, testA))) {
     BOOST_CHECK_EQUAL(c0.x(), std::get<0>(expectedStrictlyUpperTriples[count]));
     BOOST_CHECK_EQUAL(c1.x(), std::get<1>(expectedStrictlyUpperTriples[count]));
     BOOST_CHECK_EQUAL(c2.x(), std::get<2>(expectedStrictlyUpperTriples[count]));
@@ -1116,7 +1048,7 @@ BOOST_AUTO_TEST_CASE(BlockCombinations)
   BOOST_CHECK_EQUAL(count, expectedStrictlyUpperTriples.size());
 
   count = 0;
-  for (auto& [c0, c1, c2, c3, c4] : combinations(CombinationsBlockStrictlyUpperSameIndexPolicy("y", 1, -1, testAux, testAux, testAux, testAux, testAux))) {
+  for (auto& [c0, c1, c2, c3, c4] : combinations(CombinationsBlockStrictlyUpperSameIndexPolicy(pairBinning, 1, -1, testA, testA, testA, testA, testA))) {
     count++;
   }
   BOOST_CHECK_EQUAL(count, 0);
@@ -1125,7 +1057,7 @@ BOOST_AUTO_TEST_CASE(BlockCombinations)
   std::vector<std::tuple<int32_t, int32_t>> expectedFullPairsFirstSmaller{
     {0, 0}, {0, 4}, {4, 0}, {4, 4}, {4, 7}, {1, 1}, {1, 6}, {3, 3}, {3, 5}, {2, 2}, {2, 8}};
   count = 0;
-  for (auto& [x0, x1] : combinations(CombinationsBlockFullIndexPolicy("y", 1, -1, testAuxHalf, testAux))) {
+  for (auto& [x0, x1] : combinations(CombinationsBlockFullIndexPolicy(pairBinning, 1, -1, testAHalf, testA))) {
     BOOST_CHECK_EQUAL(x0.x(), std::get<0>(expectedFullPairsFirstSmaller[count]));
     BOOST_CHECK_EQUAL(x1.x(), std::get<1>(expectedFullPairsFirstSmaller[count]));
     count++;
@@ -1135,7 +1067,7 @@ BOOST_AUTO_TEST_CASE(BlockCombinations)
   count = 0;
   std::vector<std::tuple<int32_t, int32_t>> expectedFullPairsSecondSmaller{
     {0, 0}, {0, 4}, {4, 0}, {4, 4}, {7, 4}, {1, 1}, {6, 1}, {3, 3}, {5, 3}, {2, 2}, {8, 2}};
-  for (auto& [x0, x1] : combinations(CombinationsBlockFullIndexPolicy("y", 1, -1, testAux, testAuxHalf))) {
+  for (auto& [x0, x1] : combinations(CombinationsBlockFullIndexPolicy(pairBinning, 1, -1, testA, testAHalf))) {
     BOOST_CHECK_EQUAL(x0.x(), std::get<0>(expectedFullPairsSecondSmaller[count]));
     BOOST_CHECK_EQUAL(x1.x(), std::get<1>(expectedFullPairsSecondSmaller[count]));
     count++;
@@ -1145,7 +1077,7 @@ BOOST_AUTO_TEST_CASE(BlockCombinations)
   std::vector<std::tuple<int32_t, int32_t>> expectedUpperPairsFirstSmaller{
     {0, 0}, {0, 4}, {4, 4}, {4, 7}, {1, 1}, {1, 6}, {3, 3}, {3, 5}, {2, 2}, {2, 8}};
   count = 0;
-  for (auto& [x0, x1] : combinations(CombinationsBlockUpperIndexPolicy("y", 1, -1, testAuxHalf, testAux))) {
+  for (auto& [x0, x1] : combinations(CombinationsBlockUpperIndexPolicy(pairBinning, 1, -1, testAHalf, testA))) {
     BOOST_CHECK_EQUAL(x0.x(), std::get<0>(expectedUpperPairsFirstSmaller[count]));
     BOOST_CHECK_EQUAL(x1.x(), std::get<1>(expectedUpperPairsFirstSmaller[count]));
     count++;
@@ -1155,7 +1087,7 @@ BOOST_AUTO_TEST_CASE(BlockCombinations)
   count = 0;
   std::vector<std::tuple<int32_t, int32_t>> expectedUpperPairsSecondSmaller{
     {0, 0}, {0, 4}, {4, 4}, {1, 1}, {3, 3}, {2, 2}};
-  for (auto& [x0, x1] : combinations(CombinationsBlockUpperIndexPolicy("y", 1, -1, testAux, testAuxHalf))) {
+  for (auto& [x0, x1] : combinations(CombinationsBlockUpperIndexPolicy(pairBinning, 1, -1, testA, testAHalf))) {
     BOOST_CHECK_EQUAL(x0.x(), std::get<0>(expectedUpperPairsSecondSmaller[count]));
     BOOST_CHECK_EQUAL(x1.x(), std::get<1>(expectedUpperPairsSecondSmaller[count]));
     count++;
@@ -1164,7 +1096,7 @@ BOOST_AUTO_TEST_CASE(BlockCombinations)
 
   // Using same index combinations for better performance
   count = 0;
-  for (auto& [c0, c1] : combinations(CombinationsBlockFullSameIndexPolicy("y", 2, -1, testAux, testAux))) {
+  for (auto& [c0, c1] : combinations(CombinationsBlockFullSameIndexPolicy(pairBinning, 2, -1, testA, testA))) {
     BOOST_CHECK_EQUAL(c0.x(), std::get<0>(expectedFullPairs[count]));
     BOOST_CHECK_EQUAL(c1.x(), std::get<1>(expectedFullPairs[count]));
     count++;
@@ -1172,7 +1104,7 @@ BOOST_AUTO_TEST_CASE(BlockCombinations)
   BOOST_CHECK_EQUAL(count, expectedFullPairs.size());
 
   count = 0;
-  for (auto& [c0, c1, c2] : combinations(CombinationsBlockFullSameIndexPolicy("y", 2, -1, testAux, testAux, testAux))) {
+  for (auto& [c0, c1, c2] : combinations(CombinationsBlockFullSameIndexPolicy(pairBinning, 2, -1, testA, testA, testA))) {
     BOOST_CHECK_EQUAL(c0.x(), std::get<0>(expectedFullTriples[count]));
     BOOST_CHECK_EQUAL(c1.x(), std::get<1>(expectedFullTriples[count]));
     BOOST_CHECK_EQUAL(c2.x(), std::get<2>(expectedFullTriples[count]));
@@ -1181,7 +1113,7 @@ BOOST_AUTO_TEST_CASE(BlockCombinations)
   BOOST_CHECK_EQUAL(count, expectedFullTriples.size());
 
   count = 0;
-  for (auto& [c0, c1] : combinations(CombinationsBlockUpperSameIndexPolicy("y", 2, -1, testAux, testAux))) {
+  for (auto& [c0, c1] : combinations(CombinationsBlockUpperSameIndexPolicy(pairBinning, 2, -1, testA, testA))) {
     BOOST_CHECK_EQUAL(c0.x(), std::get<0>(expectedUpperPairs[count]));
     BOOST_CHECK_EQUAL(c1.x(), std::get<1>(expectedUpperPairs[count]));
     count++;
@@ -1189,7 +1121,7 @@ BOOST_AUTO_TEST_CASE(BlockCombinations)
   BOOST_CHECK_EQUAL(count, expectedUpperPairs.size());
 
   count = 0;
-  for (auto& [c0, c1, c2] : combinations(CombinationsBlockUpperSameIndexPolicy("y", 1, -1, testAux, testAux, testAux))) {
+  for (auto& [c0, c1, c2] : combinations(CombinationsBlockUpperSameIndexPolicy(pairBinning, 1, -1, testA, testA, testA))) {
     BOOST_CHECK_EQUAL(c0.x(), std::get<0>(expectedUpperTriples[count]));
     BOOST_CHECK_EQUAL(c1.x(), std::get<1>(expectedUpperTriples[count]));
     BOOST_CHECK_EQUAL(c2.x(), std::get<2>(expectedUpperTriples[count]));
@@ -1198,7 +1130,7 @@ BOOST_AUTO_TEST_CASE(BlockCombinations)
   BOOST_CHECK_EQUAL(count, expectedUpperTriples.size());
 
   count = 0;
-  for (auto& [c0, c1, c2, c3, c4] : combinations(CombinationsBlockUpperSameIndexPolicy("y", 2, -1, testAux, testAux, testAux, testAux, testAux))) {
+  for (auto& [c0, c1, c2, c3, c4] : combinations(CombinationsBlockUpperSameIndexPolicy(pairBinning, 2, -1, testA, testA, testA, testA, testA))) {
     BOOST_CHECK_EQUAL(c0.x(), std::get<0>(expectedUpperFives[count]));
     BOOST_CHECK_EQUAL(c1.x(), std::get<1>(expectedUpperFives[count]));
     BOOST_CHECK_EQUAL(c2.x(), std::get<2>(expectedUpperFives[count]));
@@ -1209,7 +1141,7 @@ BOOST_AUTO_TEST_CASE(BlockCombinations)
   BOOST_CHECK_EQUAL(count, expectedUpperFives.size());
 
   count = 0;
-  for (auto& [c0, c1] : selfCombinations("y", 2, -1, testAux, testAux)) {
+  for (auto& [c0, c1] : selfCombinations(pairBinning, 2, -1, testA, testA)) {
     BOOST_CHECK_EQUAL(c0.x(), std::get<0>(expectedStrictlyUpperPairs[count]));
     BOOST_CHECK_EQUAL(c1.x(), std::get<1>(expectedStrictlyUpperPairs[count]));
     count++;
@@ -1217,7 +1149,7 @@ BOOST_AUTO_TEST_CASE(BlockCombinations)
   BOOST_CHECK_EQUAL(count, expectedStrictlyUpperPairs.size());
 
   count = 0;
-  for (auto& [c0, c1, c2] : selfCombinations("y", 2, -1, testAux, testAux, testAux)) {
+  for (auto& [c0, c1, c2] : selfCombinations(pairBinning, 2, -1, testA, testA, testA)) {
     BOOST_CHECK_EQUAL(c0.x(), std::get<0>(expectedStrictlyUpperTriples[count]));
     BOOST_CHECK_EQUAL(c1.x(), std::get<1>(expectedStrictlyUpperTriples[count]));
     BOOST_CHECK_EQUAL(c2.x(), std::get<2>(expectedStrictlyUpperTriples[count]));
@@ -1226,10 +1158,39 @@ BOOST_AUTO_TEST_CASE(BlockCombinations)
   BOOST_CHECK_EQUAL(count, expectedStrictlyUpperTriples.size());
 
   count = 0;
-  for (auto& [c0, c1, c2, c3, c4] : selfCombinations("y", 2, -1, testAux, testAux, testAux, testAux, testAux)) {
+  for (auto& [c0, c1, c2, c3, c4] : selfCombinations(pairBinning, 2, -1, testA, testA, testA, testA, testA)) {
     count++;
   }
   BOOST_CHECK_EQUAL(count, 0);
+
+  // Testing bin calculations for triple binning
+  // Grouped data:
+  // [3, 5] [0, 4], [7], [1, 6], [2], [8, 9]
+  // Assuming bins intervals: [ , )
+  std::vector<double> xBins{VARIABLE_WIDTH, 0, 7, 10};
+  BinningPolicy<test::X, test::Y, test::FloatZ> tripleBinning{{xBins, yBins, zBins}, false};
+  BinningPolicy<test::X, test::Y, test::FloatZ> tripleBinningNoOverflows{{xBins, yBins, zBins}, true};
+
+  // 2, 3, 5, 8, 9 have overflows in testA
+  std::vector<std::tuple<int32_t, int32_t>> expectedFullPairsTripleBinningNoOverflows{
+    {0, 0}, {0, 4}, {4, 0}, {4, 4}, {7, 7}, {1, 1}, {1, 6}, {6, 1}, {6, 6}};
+  count = 0;
+  for (auto& [c0, c1] : combinations(CombinationsBlockFullIndexPolicy(tripleBinningNoOverflows, 1, -1, testA, testA))) {
+    BOOST_CHECK_EQUAL(c0.x(), std::get<0>(expectedFullPairsTripleBinningNoOverflows[count]));
+    BOOST_CHECK_EQUAL(c1.x(), std::get<1>(expectedFullPairsTripleBinningNoOverflows[count]));
+    count++;
+  }
+  BOOST_CHECK_EQUAL(count, expectedFullPairsTripleBinningNoOverflows.size());
+
+  std::vector<std::tuple<int32_t, int32_t>> expectedFullPairsTripleBinning{
+    {0, 0}, {0, 4}, {4, 0}, {4, 4}, {7, 7}, {1, 1}, {1, 6}, {6, 1}, {6, 6}, {3, 3}, {3, 5}, {5, 3}, {5, 5}, {2, 2}, {8, 8}, {8, 9}, {9, 8}, {9, 9}};
+  count = 0;
+  for (auto& [c0, c1] : combinations(CombinationsBlockFullIndexPolicy(tripleBinning, 2, -1, testA, testA))) {
+    BOOST_CHECK_EQUAL(c0.x(), std::get<0>(expectedFullPairsTripleBinning[count]));
+    BOOST_CHECK_EQUAL(c1.x(), std::get<1>(expectedFullPairsTripleBinning[count]));
+    count++;
+  }
+  BOOST_CHECK_EQUAL(count, expectedFullPairsTripleBinning.size());
 }
 
 BOOST_AUTO_TEST_CASE(CombinationsHelpers)
@@ -1312,27 +1273,15 @@ BOOST_AUTO_TEST_CASE(CombinationsHelpers)
   // Grouped data:
   // [3, 5] [0, 4, 7], [1, 6], [2, 8, 9]
   // Assuming bins intervals: [ , )
-  std::vector<uint32_t> yBins{0, 5, 10, 20, 30, 40, 50, 101};
-  std::vector<float> zBins{-7.0f, -5.0f, -3.0f, -1.0f, 1.0f, 3.0f, 5.0f, 7.0f};
-
-  TableBuilder builderAux;
-  auto rowWriterAux = builderAux.persist<int32_t, int32_t>({"x", "y"});
-  for (auto it = testB.begin(); it != testB.end(); it++) {
-    auto& elem = *it;
-    rowWriterAux(0, elem.x(), getHash(yBins, zBins, elem.y(), elem.floatZ()));
-  }
-  auto tableAux = builderAux.finalize();
-  BOOST_REQUIRE_EQUAL(tableAux->num_rows(), 10);
+  std::vector<double> yBins{VARIABLE_WIDTH, 0, 5, 10, 20, 30, 40, 50, 101};
+  std::vector<double> zBins{VARIABLE_WIDTH, -7.0, -5.0, -3.0, -1.0, 1.0, 3.0, 5.0, 7.0};
 
-  // Auxiliary table: testsAux with id and hash, hash is the category for grouping
-  using TestsAux = o2::soa::Table<o2::soa::Index<>, test::X, test::Y>;
-  TestsAux testAux{tableAux};
-  BOOST_REQUIRE_EQUAL(10, testAux.size());
+  BinningPolicy<test::Y, test::FloatZ> pairBinning{{yBins, zBins}, false};
 
   std::vector<std::tuple<int32_t, int32_t>> expectedStrictlyUpperPairs{
     {0, 4}, {0, 7}, {4, 7}, {1, 6}, {3, 5}, {2, 8}, {2, 9}, {8, 9}};
   count = 0;
-  for (auto& [c0, c1] : selfPairCombinations("y", 2, -1, testAux)) {
+  for (auto& [c0, c1] : selfPairCombinations(pairBinning, 2, -1, testB)) {
     BOOST_CHECK_EQUAL(c0.x(), std::get<0>(expectedStrictlyUpperPairs[count]));
     BOOST_CHECK_EQUAL(c1.x(), std::get<1>(expectedStrictlyUpperPairs[count]));
     count++;
@@ -1342,7 +1291,7 @@ BOOST_AUTO_TEST_CASE(CombinationsHelpers)
   std::vector<std::tuple<int32_t, int32_t, int32_t>> expectedStrictlyUpperTriples{
     {0, 4, 7}, {2, 8, 9}};
   count = 0;
-  for (auto& [c0, c1, c2] : selfTripleCombinations("y", 2, -1, testAux)) {
+  for (auto& [c0, c1, c2] : selfTripleCombinations(pairBinning, 2, -1, testB)) {
     BOOST_CHECK_EQUAL(c0.x(), std::get<0>(expectedStrictlyUpperTriples[count]));
     BOOST_CHECK_EQUAL(c1.x(), std::get<1>(expectedStrictlyUpperTriples[count]));
     BOOST_CHECK_EQUAL(c2.x(), std::get<2>(expectedStrictlyUpperTriples[count]));
@@ -1354,6 +1303,7 @@ BOOST_AUTO_TEST_CASE(CombinationsHelpers)
 BOOST_AUTO_TEST_CASE(ConstructorsWithoutTables)
 {
   using TestA = o2::soa::Table<o2::soa::Index<>, test::X, test::Y>;
+  NoBinningPolicy<test::Y> noBinning;
 
   int count = 0;
   for (auto& [t0, t1] : pairCombinations<TestA>()) {
@@ -1368,13 +1318,13 @@ BOOST_AUTO_TEST_CASE(ConstructorsWithoutTables)
   BOOST_CHECK_EQUAL(count, 0);
 
   count = 0;
-  for (auto& [c0, c1] : selfPairCombinations<int, TestA>("y", 2, -1)) {
+  for (auto& [c0, c1] : selfPairCombinations<NoBinningPolicy<test::Y>, int, TestA>(noBinning, 2, -1)) {
     count++;
   }
   BOOST_CHECK_EQUAL(count, 0);
 
   count = 0;
-  for (auto& [c0, c1, c2] : selfTripleCombinations<int, TestA>("y", 2, -1)) {
+  for (auto& [c0, c1, c2] : selfTripleCombinations<NoBinningPolicy<test::Y>, int, TestA>(noBinning, 2, -1)) {
     count++;
   }
   BOOST_CHECK_EQUAL(count, 0);