diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 3ab63fea856dd..929c6d00dd9b9 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1018,7 +1018,7 @@ constexpr bool is_binding_compatible_v()
 }
 
 template <typename T, typename B>
-struct is_binding_compatible : std::conditional_t<is_binding_compatible_v<T,typename B::binding_t>(), std::true_type, std::false_type> {
+struct is_binding_compatible : std::conditional_t<is_binding_compatible_v<T, typename B::binding_t>(), std::true_type, std::false_type> {
 };
 
 //! Helper to check if a type T is an iterator
@@ -1203,11 +1203,12 @@ class Table
   }
 
   template <typename Key>
-  inline arrow::ChunkedArray* getIndexToKey() {
-    if constexpr (framework::has_type_conditional_v<is_binding_compatible,Key,external_index_columns_t>) {
-      using IC = framework::pack_element_t<framework::has_type_at_conditional<is_binding_compatible,Key>(external_index_columns_t{}),external_index_columns_t>;
+  inline arrow::ChunkedArray* getIndexToKey()
+  {
+    if constexpr (framework::has_type_conditional_v<is_binding_compatible, Key, external_index_columns_t>) {
+      using IC = framework::pack_element_t<framework::has_type_at_conditional<is_binding_compatible, Key>(external_index_columns_t{}), external_index_columns_t>;
       return mColumnChunks[framework::has_type_at<IC>(persistent_columns_t{})];
-    } else if constexpr (std::is_same_v<table_t,Key>) {
+    } else if constexpr (std::is_same_v<table_t, Key>) {
       return nullptr;
     } else {
       static_assert(framework::always_static_assert_v<Key>, "This table does not have an index to this type");
diff --git a/Framework/Core/include/Framework/AnalysisHelpers.h b/Framework/Core/include/Framework/AnalysisHelpers.h
index 0c349c91a4382..f2f34be386c36 100644
--- a/Framework/Core/include/Framework/AnalysisHelpers.h
+++ b/Framework/Core/include/Framework/AnalysisHelpers.h
@@ -224,87 +224,92 @@ struct Spawns : TableTransform<typename aod::MetadataTrait<framework::pack_head_
 /// Exclusive index: each entry in a row has a valid index
 /// Sparse index: values in a row can be (-1), index table is isomorphic (joinable)
 /// to T1
-struct Exclusive {};
-struct Sparse {};
+struct Exclusive {
+};
+struct Sparse {
+};
 
-namespace {
+namespace
+{
 template <typename T, typename Key>
-inline arrow::ChunkedArray* getIndexToKey(arrow::Table* table) {
-    using IC = framework::pack_element_t<framework::has_type_at_conditional<soa::is_binding_compatible,Key>(typename T::external_index_columns_t{}),typename T::external_index_columns_t>;
-    return table->column(framework::has_type_at<IC>(typename T::persistent_columns_t{})).get();
+inline arrow::ChunkedArray* getIndexToKey(arrow::Table* table)
+{
+  using IC = framework::pack_element_t<framework::has_type_at_conditional<soa::is_binding_compatible, Key>(typename T::external_index_columns_t{}), typename T::external_index_columns_t>;
+  return table->column(framework::has_type_at<IC>(typename T::persistent_columns_t{})).get();
 }
 
 template <typename C>
 struct ColumnTrait {
-  static_assert(framework::is_base_of_template_v<o2::soa::Column,C>, "Not a column type!");
+  static_assert(framework::is_base_of_template_v<o2::soa::Column, C>, "Not a column type!");
   using column_t = C;
 
-  static constexpr auto listSize(){
-      if constexpr (std::is_same_v<typename C::type, std::vector<int>>) {
-        return -1;
-      } else if constexpr (std::is_same_v<int[2],typename C::type>) {
-        return 2;
-      } else {
-        return 1;
-      }
+  static constexpr auto listSize()
+  {
+    if constexpr (std::is_same_v<typename C::type, std::vector<int>>) {
+      return -1;
+    } else if constexpr (std::is_same_v<int[2], typename C::type>) {
+      return 2;
+    } else {
+      return 1;
+    }
   }
 
   template <typename T, typename Key>
   static std::shared_ptr<SelfIndexColumnBuilder> makeColumnBuilder(arrow::Table* table, arrow::MemoryPool* pool)
   {
-    if constexpr (!std::is_same_v<T,Key>)  {
-      return std::make_shared<IndexColumnBuilder>(getIndexToKey<T,Key>(table), C::columnLabel(), listSize(), pool);
+    if constexpr (!std::is_same_v<T, Key>) {
+      return std::make_shared<IndexColumnBuilder>(getIndexToKey<T, Key>(table), C::columnLabel(), listSize(), pool);
     } else {
       return std::make_shared<SelfIndexColumnBuilder>(C::columnLabel(), pool);
     }
   }
 };
-}
+} // namespace
 
 template <typename Key, typename C>
 struct Reduction {
-  using type = typename std::conditional<soa::is_binding_compatible_v<Key,typename C::binding_t>(),SelfIndexColumnBuilder,IndexColumnBuilder>::type;
+  using type = typename std::conditional<soa::is_binding_compatible_v<Key, typename C::binding_t>(), SelfIndexColumnBuilder, IndexColumnBuilder>::type;
 };
 
 template <typename Kind>
 struct IndexBuilder {
   template <typename Key, typename C1, typename... Cs, typename T1, typename... Ts>
-  static auto indexBuilder(const char* label, std::vector<std::shared_ptr<arrow::Table>>&& tables, framework::pack<C1,Cs...>, framework::pack<T1,Ts...>)
+  static auto indexBuilder(const char* label, std::vector<std::shared_ptr<arrow::Table>>&& tables, framework::pack<C1, Cs...>, framework::pack<T1, Ts...>)
   {
     auto pool = arrow::default_memory_pool();
-    SelfIndexColumnBuilder self{C1::columnLabel(),pool};
+    SelfIndexColumnBuilder self{C1::columnLabel(), pool};
     std::unique_ptr<ChunkedArrayIterator> keyIndex = nullptr;
     int64_t counter = 0;
-    if constexpr (!std::is_same_v<T1,Key>) {
+    if constexpr (!std::is_same_v<T1, Key>) {
       keyIndex = std::make_unique<ChunkedArrayIterator>(getIndexToKey<T1, Key>(tables[0].get()));
     }
 
     std::array<std::shared_ptr<framework::SelfIndexColumnBuilder>, sizeof...(Cs)> columnBuilders{ColumnTrait<Cs>::template makeColumnBuilder<framework::pack_element_t<framework::has_type_at_v<Cs>(framework::pack<Cs...>{}), framework::pack<Ts...>>, Key>(
       tables[framework::has_type_at_v<Cs>(framework::pack<Cs...>{}) + 1].get(),
-        pool)...};
+      pool)...};
     std::array<bool, sizeof...(Cs)> finds;
 
     for (counter = 0; counter < tables[0]->num_rows(); ++counter) {
       auto idx = -1;
-      if constexpr (std::is_same_v<T1,Key>) {
+      if constexpr (std::is_same_v<T1, Key>) {
         idx = counter;
       } else {
         idx = keyIndex->valueAt(counter);
       }
-      finds = {std::static_pointer_cast<typename Reduction<Key,Cs>::type>(columnBuilders[framework::has_type_at_v<Cs>(framework::pack<Cs...>{})])->template find<Cs>(idx)...};
-      if constexpr (std::is_same_v<Kind,Sparse>) {
-        (std::static_pointer_cast<typename Reduction<Key,Cs>::type>(columnBuilders[framework::has_type_at_v<Cs>(framework::pack<Cs...>{})])->template fill<Cs>(idx),...);
+      finds = {std::static_pointer_cast<typename Reduction<Key, Cs>::type>(columnBuilders[framework::has_type_at_v<Cs>(framework::pack<Cs...>{})])->template find<Cs>(idx)...};
+      if constexpr (std::is_same_v<Kind, Sparse>) {
+        (std::static_pointer_cast<typename Reduction<Key, Cs>::type>(columnBuilders[framework::has_type_at_v<Cs>(framework::pack<Cs...>{})])->template fill<Cs>(idx), ...);
         self.fill<C1>(counter);
-      } else if constexpr (std::is_same_v<Kind,Exclusive>) {
-        if (std::none_of(finds.begin(),finds.end(),[](bool const x){ return x == false; })) {
-          (std::static_pointer_cast<typename Reduction<Key,Cs>::type>(columnBuilders[framework::has_type_at_v<Cs>(framework::pack<Cs...>{})])->template fill<Cs>(idx),...);
+      } else if constexpr (std::is_same_v<Kind, Exclusive>) {
+        if (std::none_of(finds.begin(), finds.end(), [](bool const x) { return x == false; })) {
+          (std::static_pointer_cast<typename Reduction<Key, Cs>::type>(columnBuilders[framework::has_type_at_v<Cs>(framework::pack<Cs...>{})])->template fill<Cs>(idx), ...);
           self.fill<C1>(counter);
         }
       }
     }
 
-    std::vector<std::shared_ptr<arrow::ChunkedArray>> columns{self.template result<C1>(), std::static_pointer_cast<typename Reduction<Key,Cs>::type>(columnBuilders[framework::has_type_at_v<Cs>(framework::pack<Cs...>{})])->template result<Cs>()...};
-    std::vector<std::shared_ptr<arrow::Field>> fields{self.field(), std::static_pointer_cast<typename Reduction<Key,Cs>::type>(columnBuilders[framework::has_type_at_v<Cs>(framework::pack<Cs...>{})])->field()...};
+    std::vector<std::shared_ptr<arrow::ChunkedArray>> columns{self.template result<C1>(), std::static_pointer_cast<typename Reduction<Key, Cs>::type>(columnBuilders[framework::has_type_at_v<Cs>(framework::pack<Cs...>{})])->template result<Cs>()...};
+    std::vector<std::shared_ptr<arrow::Field>> fields{self.field(), std::static_pointer_cast<typename Reduction<Key, Cs>::type>(columnBuilders[framework::has_type_at_v<Cs>(framework::pack<Cs...>{})])->field()...};
     auto schema = std::make_shared<arrow::Schema>(fields);
     schema->WithMetadata(
       std::make_shared<arrow::KeyValueMetadata>(
diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h
index 089c6a7d2bf28..4ccc217cd7369 100644
--- a/Framework/Core/include/Framework/AnalysisManagers.h
+++ b/Framework/Core/include/Framework/AnalysisManagers.h
@@ -378,8 +378,8 @@ struct OutputManager<Builds<T>> {
 
   static bool prepare(ProcessingContext& pc, Builds<T>& what)
   {
-    return what.template build<typename T::indexing_t>(what.pack(),what.originals_pack(),
-                                            extractOriginalsVector(what.originals_pack(), pc));
+    return what.template build<typename T::indexing_t>(what.pack(), what.originals_pack(),
+                                                       extractOriginalsVector(what.originals_pack(), pc));
   }
 
   static bool finalize(ProcessingContext& pc, Builds<T>& what)
diff --git a/Framework/Core/include/Framework/IndexBuilderHelpers.h b/Framework/Core/include/Framework/IndexBuilderHelpers.h
index 779156c492f73..0e688b8d32f80 100644
--- a/Framework/Core/include/Framework/IndexBuilderHelpers.h
+++ b/Framework/Core/include/Framework/IndexBuilderHelpers.h
@@ -20,7 +20,8 @@
 #include <memory>
 #include <type_traits>
 
-namespace o2::framework {
+namespace o2::framework
+{
 struct ChunkedArrayIterator {
   ChunkedArrayIterator(arrow::ChunkedArray* source);
   virtual ~ChunkedArrayIterator() {}
@@ -57,7 +58,10 @@ struct SelfIndexColumnBuilder {
   }
   std::shared_ptr<arrow::Field> field() const;
   template <typename C>
-  inline bool find(int) {return true;}
+  inline bool find(int)
+  {
+    return true;
+  }
 
   template <typename C>
   inline void fill(int idx)
@@ -65,14 +69,14 @@ struct SelfIndexColumnBuilder {
     (void)static_cast<arrow::Int32Builder*>(mBuilder.get())->Append(idx);
   }
 
-
   std::string mColumnName;
   std::unique_ptr<arrow::ArrayBuilder> mBuilder = nullptr;
 };
 
-class IndexColumnBuilder : public SelfIndexColumnBuilder, public ChunkedArrayIterator {
+class IndexColumnBuilder : public SelfIndexColumnBuilder, public ChunkedArrayIterator
+{
  public:
-  IndexColumnBuilder(arrow::ChunkedArray* source, const char *name, int listSize, arrow::MemoryPool* pool);
+  IndexColumnBuilder(arrow::ChunkedArray* source, const char* name, int listSize, arrow::MemoryPool* pool);
   virtual ~IndexColumnBuilder() {}
 
   template <typename C>
@@ -88,7 +92,8 @@ class IndexColumnBuilder : public SelfIndexColumnBuilder, public ChunkedArrayIte
   }
 
   template <typename C>
-  inline bool find(int idx) {
+  inline bool find(int idx)
+  {
     if constexpr (std::is_same_v<typename C::type, std::vector<int>>) {
       return findMulti(idx);
     } else if constexpr (std::is_same_v<typename C::type, int[2]>) {
@@ -99,7 +104,8 @@ class IndexColumnBuilder : public SelfIndexColumnBuilder, public ChunkedArrayIte
   }
 
   template <typename C>
-  inline void fill(int idx){
+  inline void fill(int idx)
+  {
     ++mResultSize;
     if constexpr (std::is_same_v<typename C::type, std::vector<int>>) {
       fillMulti(idx);
@@ -131,6 +137,6 @@ class IndexColumnBuilder : public SelfIndexColumnBuilder, public ChunkedArrayIte
   size_t mSourceSize = 0;
   size_t mResultSize = 0;
 };
-}
+} // namespace o2::framework
 
 #endif // O2_FRAMEWORK_INDEXBUILDERHELPERS_H_
diff --git a/Framework/Foundation/include/Framework/Pack.h b/Framework/Foundation/include/Framework/Pack.h
index fb4e822639daf..9d415efa85fd3 100644
--- a/Framework/Foundation/include/Framework/Pack.h
+++ b/Framework/Foundation/include/Framework/Pack.h
@@ -160,14 +160,14 @@ struct has_type<T, pack<Us...>> : std::disjunction<std::is_same<T, Us>...> {
 template <typename T, typename... Us>
 inline constexpr bool has_type_v = has_type<T, Us...>::value;
 
-template <template <typename,typename> typename Condition, typename T, typename Pack>
+template <template <typename, typename> typename Condition, typename T, typename Pack>
 struct has_type_conditional;
 
-template <template <typename,typename> typename Condition, typename T, typename... Us>
-struct has_type_conditional<Condition, T, pack<Us...>> : std::disjunction<Condition<T,Us>...> {
+template <template <typename, typename> typename Condition, typename T, typename... Us>
+struct has_type_conditional<Condition, T, pack<Us...>> : std::disjunction<Condition<T, Us>...> {
 };
 
-template <template <typename,typename> typename Condition, typename T, typename... Us>
+template <template <typename, typename> typename Condition, typename T, typename... Us>
 inline constexpr bool has_type_conditional_v = has_type_conditional<Condition, T, Us...>::value;
 
 template <typename T>
@@ -187,15 +187,16 @@ constexpr size_t has_type_at(pack<T1, Ts...> const&)
   return sizeof...(Ts) + 2;
 }
 
-template <template <typename,typename> typename Condition, typename T>
+template <template <typename, typename> typename Condition, typename T>
 constexpr size_t has_type_at_conditional(pack<>&&)
 {
   return static_cast<size_t>(-1);
 }
 
-template <template <typename,typename> typename Condition, typename T, typename T1, typename... Ts>
-constexpr size_t has_type_at_conditional(pack<T1,Ts...>&&) {
-  if constexpr (Condition<T,T1>::value) {
+template <template <typename, typename> typename Condition, typename T, typename T1, typename... Ts>
+constexpr size_t has_type_at_conditional(pack<T1, Ts...>&&)
+{
+  if constexpr (Condition<T, T1>::value) {
     return 0;
   } else if constexpr (has_type_conditional_v<Condition, T, pack<Ts...>>) {
     return 1 + has_type_at_conditional<Condition, T>(pack<Ts...>{});