diff --git a/PWGCF/Femto/Core/FemtoFlowAngularContainer.h b/PWGCF/Femto/Core/FemtoFlowAngularContainer.h
index a79ecf429ff..3d75109611a 100644
--- a/PWGCF/Femto/Core/FemtoFlowAngularContainer.h
+++ b/PWGCF/Femto/Core/FemtoFlowAngularContainer.h
@@ -20,17 +20,20 @@
 #ifndef PWGCF_FEMTOFLOW_CORE_FEMTOFLOWANGULARCONTAINER_H_
 #define PWGCF_FEMTOFLOW_CORE_FEMTOFLOWANGULARCONTAINER_H_
 
-#include <fairlogger/Logger.h>
-#include <vector>
-#include <string>
+#include "PWGCF/Femto/Core/FemtoFlowMath.h"
 
-#include "Framework/HistogramRegistry.h"
 #include "Common/Core/RecoDecay.h"
-#include "PWGCF/Femto/Core/FemtoFlowMath.h"
+
+#include "Framework/HistogramRegistry.h"
 
 #include "Math/Vector4D.h"
-#include "TMath.h"
 #include "TDatabasePDG.h"
+#include "TMath.h"
+
+#include <fairlogger/Logger.h>
+
+#include <string>
+#include <vector>
 
 using namespace o2::framework;
 
@@ -231,7 +234,7 @@ class FemtoFlowAngularContainer
  protected:
   HistogramRegistry* mHistogramRegistry = nullptr;                                 ///< For QA output
   static constexpr std::string_view FolderSuffix[2] = {"SameEvent", "MixedEvent"}; ///< Folder naming for the output according to EventType
-  static constexpr femto_flow_angular_container::Observable FemtoObs = obs;    ///< Femtoscopic observable to be computed (according to femto_flow_angular_container::Observable)
+  static constexpr femto_flow_angular_container::Observable FemtoObs = obs;        ///< Femtoscopic observable to be computed (according to femto_flow_angular_container::Observable)
   static constexpr int EventType = eventType;                                      ///< Type of the event (same/mixed, according to femto_flow_angular_container::EventType)
   float mMassOne = 0.f;                                                            ///< PDG mass of particle 1
   float mMassTwo = 0.f;                                                            ///< PDG mass of particle 2
diff --git a/PWGCF/Femto/Core/FemtoFlowCollisionSelection.h b/PWGCF/Femto/Core/FemtoFlowCollisionSelection.h
index 57fb8af8f02..6bae005a44c 100644
--- a/PWGCF/Femto/Core/FemtoFlowCollisionSelection.h
+++ b/PWGCF/Femto/Core/FemtoFlowCollisionSelection.h
@@ -17,13 +17,14 @@
 #ifndef PWGCF_FEMTOFLOW_CORE_FEMTOFLOWCOLLISIONSELECTION_H_
 #define PWGCF_FEMTOFLOW_CORE_FEMTOFLOWCOLLISIONSELECTION_H_
 
-#include <string>
 #include "Common/CCDB/TriggerAliases.h"
+#include "Common/Core/EventPlaneHelper.h"
+#include "Common/DataModel/Qvectors.h"
+
 #include "Framework/HistogramRegistry.h"
 #include "Framework/Logger.h"
 
-#include "Common/Core/EventPlaneHelper.h"
-#include "Common/DataModel/Qvectors.h"
+#include <string>
 
 using namespace o2;
 using namespace o2::framework;
@@ -143,7 +144,7 @@ class FemtoFlowCollisionSelection
   /// \param col Collision
   template <typename T>
   void fillQA(T const& col)
-  {    
+  {
 
     if (mHistogramRegistry) {
       mHistogramRegistry->fill(HIST("Event/zvtxhist"), col.posZ());
@@ -212,32 +213,34 @@ class FemtoFlowCollisionSelection
     return spher;
   }
 
-  //Qn-vector calculation
+  // Qn-vector calculation
   template <typename T>
   float computeqnVec(T const& col)
   {
     double qn = std::sqrt(col.qvecFT0CReVec()[0] * col.qvecFT0CReVec()[0] + col.qvecFT0CImVec()[0] * col.qvecFT0CImVec()[0]) * std::sqrt(col.sumAmplFT0C());
-    if (mHistogramRegistry){
-      mHistogramRegistry->fill(HIST("Event/qnvector"), col.centFT0C(), qn);  
-      mHistogramRegistry->fill(HIST("Event/SphrVsqn"), qn, mSphericity);  
+    if (mHistogramRegistry) {
+      mHistogramRegistry->fill(HIST("Event/qnvector"), col.centFT0C(), qn);
+      mHistogramRegistry->fill(HIST("Event/SphrVsqn"), qn, mSphericity);
     }
     return qn;
   }
 
-  //Qn-vector calculation
+  // Qn-vector calculation
   template <typename T>
-  int myqnBin(T const& col, float centBinLength=10.f)
-  { 
+  int myqnBin(T const& col, float centBinLength = 10.f)
+  {
     int qnBin = -999;
     float qn = computeqnVec(col);
     int mycentBin = (int)(col.centFT0C() / centBinLength);
-    if (mycentBin >= (int)(mCentMax / centBinLength)) return qnBin;
+    if (mycentBin >= (int)(mCentMax / centBinLength))
+      return qnBin;
 
-    for (int iqn(0); iqn < static_cast<int>(std::size(mqnBinSeparator[mycentBin]))-1; ++iqn){
-      if (qn>mqnBinSeparator[mycentBin][iqn] && qn<=mqnBinSeparator[mycentBin][iqn+1]){
+    for (int iqn(0); iqn < static_cast<int>(std::size(mqnBinSeparator[mycentBin])) - 1; ++iqn) {
+      if (qn > mqnBinSeparator[mycentBin][iqn] && qn <= mqnBinSeparator[mycentBin][iqn + 1]) {
         qnBin = iqn;
         break;
-      }else continue;
+      } else
+        continue;
     }
 
     return qnBin;
@@ -254,14 +257,13 @@ class FemtoFlowCollisionSelection
   float mCentMin = 0.0;                            ///< Minimum centrality value
   float mCentMax = 100.0;                          ///< Maximum centrality value
   float mSphericity = 2.;
-  float mqnBinSeparator [7][11] = {{ 0.0,  63.50,  92.50,  116.50,  139.50,  162.50,  185.50,  212.50,  245.50,  292.50,  877.50},
-                                   { 0.0,  57.50,  82.50,  102.50,  121.50,  139.50,  158.50,  178.50,  203.50,  238.50,  616.50},
-                                   { 0.0,  49.50,  70.50,  86.50,  102.50,  116.50,  131.50,  148.50,  168.50,  195.50,  483.50},
-                                   { 0.0,  38.50,  55.50,  69.50,  82.50,  94.50,  106.50,  120.50,  137.50,  160.50,  375.50},
-                                   { 0.0,  29.50,  42.50,  53.50,  63.50,  73.50,  83.50,  95.50,  109.50,  128.50,  322.50},
-                                   { 0.0,  21.50,  31.50,  39.50,  47.50,  55.50,  63.50,  72.50,  83.50,  99.50,  266.50},
-                                   { 0.0,  15.50,  22.50,  28.50,  33.50,  39.50,  45.50,  52.50,  60.50,  72.50,  232.50}
-                                  }; ///< qn bin edge from qn vector distributions, for per 10% centrality, 0-70%
+  float mqnBinSeparator[7][11] = {{0.0, 63.50, 92.50, 116.50, 139.50, 162.50, 185.50, 212.50, 245.50, 292.50, 877.50},
+                                  {0.0, 57.50, 82.50, 102.50, 121.50, 139.50, 158.50, 178.50, 203.50, 238.50, 616.50},
+                                  {0.0, 49.50, 70.50, 86.50, 102.50, 116.50, 131.50, 148.50, 168.50, 195.50, 483.50},
+                                  {0.0, 38.50, 55.50, 69.50, 82.50, 94.50, 106.50, 120.50, 137.50, 160.50, 375.50},
+                                  {0.0, 29.50, 42.50, 53.50, 63.50, 73.50, 83.50, 95.50, 109.50, 128.50, 322.50},
+                                  {0.0, 21.50, 31.50, 39.50, 47.50, 55.50, 63.50, 72.50, 83.50, 99.50, 266.50},
+                                  {0.0, 15.50, 22.50, 28.50, 33.50, 39.50, 45.50, 52.50, 60.50, 72.50, 232.50}}; ///< qn bin edge from qn vector distributions, for per 10% centrality, 0-70%
 };
 } // namespace o2::analysis::femto_flow
 
diff --git a/PWGCF/Femto/Core/FemtoFlowContainer.h b/PWGCF/Femto/Core/FemtoFlowContainer.h
index 49f8719bd47..ca63d3b815a 100644
--- a/PWGCF/Femto/Core/FemtoFlowContainer.h
+++ b/PWGCF/Femto/Core/FemtoFlowContainer.h
@@ -93,8 +93,8 @@ class FemtoFlowContainer
       mHistogramRegistry->add((folderName + "/relPairkstarmTMult").c_str(), ("; " + femtoObs + "; #it{m}_{T} (GeV/#it{c}^{2}); Multiplicity").c_str(), kTH3F, {femtoObsAxis, mTAxis3D, multAxis3D});
     }
 
-    if (useqnDivide){
-      for (int iqn(0); iqn<numqnBins; ++iqn){
+    if (useqnDivide) {
+      for (int iqn(0); iqn < numqnBins; ++iqn) {
         mHistogramRegistry->add((folderName + std::to_string(iqn) + "/relPairDist").c_str(), ("; " + femtoObs + "; Entries").c_str(), kTH1F, {femtoObsAxis});
         mHistogramRegistry->add((folderName + std::to_string(iqn) + "/relPairkstarmT").c_str(), ("; " + femtoObs + "; #it{m}_{T} (GeV/#it{c}^{2})").c_str(), kTH2F, {femtoObsAxis, mTAxis});
       }
@@ -208,9 +208,9 @@ class FemtoFlowContainer
       mHistogramRegistry->fill(HIST(FolderSuffix[EventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("/relPairkstarmTMult"), femtoObs, mT, mult, weight);
     }
 
-    if (useqnDivide && mybinNum < numqnBins && mybinNum>=0) {
+    if (useqnDivide && mybinNum < numqnBins && mybinNum >= 0) {
       mHistogramRegistry->fill(HIST(FolderSuffix[EventType]) + std::to_string(mybinNum) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("/relPairDist"), femtoObs, weight);
-      mHistogramRegistry->fill(HIST(FolderSuffix[EventType]) + std::to_string(mybinNum) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("/relPairkstarmT"), femtoObs, mT, weight);      
+      mHistogramRegistry->fill(HIST(FolderSuffix[EventType]) + std::to_string(mybinNum) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("/relPairkstarmT"), femtoObs, mT, weight);
     }
   }
 
@@ -287,7 +287,7 @@ class FemtoFlowContainer
  protected:
   HistogramRegistry* mHistogramRegistry = nullptr;                                 ///< For QA output
   static constexpr std::string_view FolderSuffix[2] = {"SameEvent", "MixedEvent"}; ///< Folder naming for the output according to EventType
-  static constexpr femto_flow_container::Observable FemtoObs = obs;            ///< Femtoscopic observable to be computed (according to femto_flow_container::Observable)
+  static constexpr femto_flow_container::Observable FemtoObs = obs;                ///< Femtoscopic observable to be computed (according to femto_flow_container::Observable)
   static constexpr int EventType = eventType;                                      ///< Type of the event (same/mixed, according to femto_flow_container::EventType)
   float mMassOne = 0.f;                                                            ///< PDG mass of particle 1
   float mMassTwo = 0.f;                                                            ///< PDG mass of particle 2
diff --git a/PWGCF/Femto/Core/FemtoFlowCutculator.h b/PWGCF/Femto/Core/FemtoFlowCutculator.h
index 98caebc6b1e..d4de0f96439 100644
--- a/PWGCF/Femto/Core/FemtoFlowCutculator.h
+++ b/PWGCF/Femto/Core/FemtoFlowCutculator.h
@@ -18,18 +18,19 @@
 #ifndef PWGCF_FEMTOFLOW_CORE_FEMTOFLOWCUTCULATOR_H_
 #define PWGCF_FEMTOFLOW_CORE_FEMTOFLOWCUTCULATOR_H_
 
+#include "PWGCF/Femto/Core/FemtoFlowSelection.h"
+#include "PWGCF/Femto/Core/FemtoFlowTrackSelection.h"
+
+#include <boost/property_tree/json_parser.hpp>
+#include <boost/property_tree/ptree.hpp>
+
+#include <algorithm>
 #include <bitset>
 #include <iostream>
+#include <iterator>
 #include <random>
 #include <string>
 #include <vector>
-#include <algorithm>
-#include <iterator>
-#include <boost/property_tree/json_parser.hpp>
-#include <boost/property_tree/ptree.hpp>
-
-#include "PWGCF/Femto/Core/FemtoFlowSelection.h"
-#include "PWGCF/Femto/Core/FemtoFlowTrackSelection.h"
 // #include "PWGCF/Femto/Core/FemtoFlowV0Selection.h"
 
 namespace o2::analysis::femto_flow
@@ -311,7 +312,7 @@ class FemtoFlowCutculator
   {
     aod::femtoflowparticle::CutContainerType output = -1;
     // if (choice == std::string("T")) {
-      output = iterateSelection(mTrackSel, SysChecks, sign);
+    output = iterateSelection(mTrackSel, SysChecks, sign);
     // } else if (choice == std::string("V")) {
     //   output = iterateSelection(mV0Sel, SysChecks, sign);
     // } else {
@@ -353,7 +354,7 @@ class FemtoFlowCutculator
   FemtoFlowTrackSelection
     mTrackSel; ///< for setting up the bit-wise selection container for tracks
   // FemtoFlowV0Selection
-    // mV0Sel; ///< for setting up the bit-wise selection container for V0s
+  // mV0Sel; ///< for setting up the bit-wise selection container for V0s
   std::vector<o2::track::PID::ID>
     mPIDspecies; ///< list of particle species for which PID is stored
   std::vector<float>
diff --git a/PWGCF/Femto/Core/FemtoFlowDetaDphiStar.h b/PWGCF/Femto/Core/FemtoFlowDetaDphiStar.h
index f467d69b55e..56c4ef2e071 100644
--- a/PWGCF/Femto/Core/FemtoFlowDetaDphiStar.h
+++ b/PWGCF/Femto/Core/FemtoFlowDetaDphiStar.h
@@ -19,17 +19,20 @@
 #ifndef PWGCF_FEMTOFLOW_CORE_FEMTOFLOWDETADPHISTAR_H_
 #define PWGCF_FEMTOFLOW_CORE_FEMTOFLOWDETADPHISTAR_H_
 
+#include "PWGCF/Femto/Core/FemtoFlowAngularContainer.h"
+#include "PWGCF/Femto/Core/FemtoFlowFemtoContainer.h"
+#include "PWGCF/Femto/DataModel/FemtoDerived.h"
+
+#include "TMath.h"
+
 #include <memory>
 #include <string>
 #include <vector>
-#include "TMath.h"
-#include "PWGCF/Femto/DataModel/FemtoDerived.h"
-#include "PWGCF/Femto/Core/FemtoFlowFemtoContainer.h"
-#include "PWGCF/Femto/Core/FemtoFlowAngularContainer.h"
 // #include "PWGCF/Femto/Core/FemtoFlowContainer.h"
-#include "Framework/HistogramRegistry.h"
 #include "PWGCF/Femto/Core/FemtoFlowTrackSelection.h"
 
+#include "Framework/HistogramRegistry.h"
+
 namespace o2::analysis
 {
 namespace femto_flow
diff --git a/PWGCF/Femto/Core/FemtoFlowEventHisto.h b/PWGCF/Femto/Core/FemtoFlowEventHisto.h
index f2d15456816..911868f3515 100644
--- a/PWGCF/Femto/Core/FemtoFlowEventHisto.h
+++ b/PWGCF/Femto/Core/FemtoFlowEventHisto.h
@@ -18,6 +18,7 @@
 #define PWGCF_FEMTOUFLOW_CORE_FEMTOUFLOWEVENTHISTO_H_
 
 #include "PWGCF/Femto/DataModel/FemtoDerived.h"
+
 #include "Framework/HistogramRegistry.h"
 
 using namespace o2::framework;
diff --git a/PWGCF/Femto/Core/FemtoFlowFemtoContainer.h b/PWGCF/Femto/Core/FemtoFlowFemtoContainer.h
index a8b22f2a830..4c3be6856af 100644
--- a/PWGCF/Femto/Core/FemtoFlowFemtoContainer.h
+++ b/PWGCF/Femto/Core/FemtoFlowFemtoContainer.h
@@ -20,16 +20,18 @@
 #ifndef PWGCF_FEMTOFLOW_CORE_FEMTOFLOWFEMTOCONTAINER_H_
 #define PWGCF_FEMTOFLOW_CORE_FEMTOFLOWFEMTOCONTAINER_H_
 
-#include <fairlogger/Logger.h>
-#include <vector>
-#include <string>
+#include "PWGCF/Femto/Core/FemtoFlowMath.h"
 
 #include "Framework/HistogramRegistry.h"
-#include "PWGCF/Femto/Core/FemtoFlowMath.h"
 
 #include "Math/Vector4D.h"
-#include "TMath.h"
 #include "TDatabasePDG.h"
+#include "TMath.h"
+
+#include <fairlogger/Logger.h>
+
+#include <string>
+#include <vector>
 
 using namespace o2::framework;
 
@@ -71,7 +73,7 @@ class FemtoFlowFemtoContainer
   /// \param kTAxis axis object for the kT axis
   /// \param mTAxis axis object for the mT axis
   template <typename T>
-  void initBase(std::string folderName, std::string femtoObs, T femtoObsAxis, T multAxis, T kTAxis, T mTAxis, T multAxis3D, T mTAxis3D, bool use3dplots,  bool useqnDivide)
+  void initBase(std::string folderName, std::string femtoObs, T femtoObsAxis, T multAxis, T kTAxis, T mTAxis, T multAxis3D, T mTAxis3D, bool use3dplots, bool useqnDivide)
   {
     kHistogramRegistry->add((folderName + "/relPairDist").c_str(), ("; " + femtoObs + "; Entries").c_str(), kTH1F, {femtoObsAxis});
     kHistogramRegistry->add((folderName + "/relPairkT").c_str(), "; #it{k}_{T} (GeV/#it{c}); Entries", kTH1F, {kTAxis});
@@ -86,8 +88,8 @@ class FemtoFlowFemtoContainer
     if (use3dplots) {
       kHistogramRegistry->add((folderName + "/relPairkstarmTMult").c_str(), ("; " + femtoObs + "; #it{m}_{T} (GeV/#it{c}^{2}); Multiplicity").c_str(), kTH3F, {femtoObsAxis, mTAxis3D, multAxis3D});
     }
-    if (useqnDivide){
-      for (int iqn(0); iqn<numqnBins; ++iqn){
+    if (useqnDivide) {
+      for (int iqn(0); iqn < numqnBins; ++iqn) {
         kHistogramRegistry->add((folderName + std::to_string(iqn) + "/relPairDist").c_str(), ("; " + femtoObs + "; Entries").c_str(), kTH1F, {femtoObsAxis});
         kHistogramRegistry->add((folderName + std::to_string(iqn) + "/relPairkstarmT").c_str(), ("; " + femtoObs + "; #it{m}_{T} (GeV/#it{c}^{2})").c_str(), kTH2F, {femtoObsAxis, mTAxis});
         kHistogramRegistry->add((folderName + std::to_string(iqn) + "/relPairkstarMult").c_str(), ("; " + femtoObs + "; Multiplicity").c_str(), kTH2F, {femtoObsAxis, multAxis});
@@ -183,62 +185,62 @@ class FemtoFlowFemtoContainer
     if (use3dplots) {
       kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("/relPairkstarmTMult"), femtoObs, mT, mult);
     }
-    if (useqnDivide && mybinNum>=0 && mybinNum < numqnBins ) {
+    if (useqnDivide && mybinNum >= 0 && mybinNum < numqnBins) {
       switch (mybinNum) {
-          case 0:
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("0") + HIST("/relPairDist"), femtoObs);
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("0") + HIST("/relPairkstarmT"), femtoObs, mT);
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("0") + HIST("/relPairkstarMult"), femtoObs, mult);
-              break;
-          case 1:
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("1") + HIST("/relPairDist"), femtoObs);
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("1") + HIST("/relPairkstarmT"), femtoObs, mT);
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("1") + HIST("/relPairkstarMult"), femtoObs, mult);
-              break;
-          case 2:
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("2") + HIST("/relPairDist"), femtoObs);
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("2") + HIST("/relPairkstarmT"), femtoObs, mT);
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("2") + HIST("/relPairkstarMult"), femtoObs, mult);
-              break;
-          case 3:
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("3") + HIST("/relPairDist"), femtoObs);
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("3") + HIST("/relPairkstarmT"), femtoObs, mT);
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("3") + HIST("/relPairkstarMult"), femtoObs, mult);
-              break;
-          case 4:
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("4") + HIST("/relPairDist"), femtoObs);
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("4") + HIST("/relPairkstarmT"), femtoObs, mT);
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("4") + HIST("/relPairkstarMult"), femtoObs, mult);
-              break;
-          case 5:
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("5") + HIST("/relPairDist"), femtoObs);
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("5") + HIST("/relPairkstarmT"), femtoObs, mT);
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("5") + HIST("/relPairkstarMult"), femtoObs, mult);
-              break;
-          case 6:
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("6") + HIST("/relPairDist"), femtoObs);
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("6") + HIST("/relPairkstarmT"), femtoObs, mT);
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("6") + HIST("/relPairkstarMult"), femtoObs, mult);
-              break;
-          case 7:
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("7") + HIST("/relPairDist"), femtoObs);
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("7") + HIST("/relPairkstarmT"), femtoObs, mT);
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("7") + HIST("/relPairkstarMult"), femtoObs, mult);
-              break;
-          case 8:
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("8") + HIST("/relPairDist"), femtoObs);
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("8") + HIST("/relPairkstarmT"), femtoObs, mT);
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("8") + HIST("/relPairkstarMult"), femtoObs, mult);
-              break;
-          case 9:
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("9") + HIST("/relPairDist"), femtoObs);
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("9") + HIST("/relPairkstarmT"), femtoObs, mT);
-              kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("9") + HIST("/relPairkstarMult"), femtoObs, mult);
-              break;
-          default:
-              return;  // invalid qn bin 
+        case 0:
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("0") + HIST("/relPairDist"), femtoObs);
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("0") + HIST("/relPairkstarmT"), femtoObs, mT);
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("0") + HIST("/relPairkstarMult"), femtoObs, mult);
+          break;
+        case 1:
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("1") + HIST("/relPairDist"), femtoObs);
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("1") + HIST("/relPairkstarmT"), femtoObs, mT);
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("1") + HIST("/relPairkstarMult"), femtoObs, mult);
+          break;
+        case 2:
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("2") + HIST("/relPairDist"), femtoObs);
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("2") + HIST("/relPairkstarmT"), femtoObs, mT);
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("2") + HIST("/relPairkstarMult"), femtoObs, mult);
+          break;
+        case 3:
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("3") + HIST("/relPairDist"), femtoObs);
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("3") + HIST("/relPairkstarmT"), femtoObs, mT);
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("3") + HIST("/relPairkstarMult"), femtoObs, mult);
+          break;
+        case 4:
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("4") + HIST("/relPairDist"), femtoObs);
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("4") + HIST("/relPairkstarmT"), femtoObs, mT);
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("4") + HIST("/relPairkstarMult"), femtoObs, mult);
+          break;
+        case 5:
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("5") + HIST("/relPairDist"), femtoObs);
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("5") + HIST("/relPairkstarmT"), femtoObs, mT);
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("5") + HIST("/relPairkstarMult"), femtoObs, mult);
+          break;
+        case 6:
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("6") + HIST("/relPairDist"), femtoObs);
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("6") + HIST("/relPairkstarmT"), femtoObs, mT);
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("6") + HIST("/relPairkstarMult"), femtoObs, mult);
+          break;
+        case 7:
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("7") + HIST("/relPairDist"), femtoObs);
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("7") + HIST("/relPairkstarmT"), femtoObs, mT);
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("7") + HIST("/relPairkstarMult"), femtoObs, mult);
+          break;
+        case 8:
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("8") + HIST("/relPairDist"), femtoObs);
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("8") + HIST("/relPairkstarmT"), femtoObs, mT);
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("8") + HIST("/relPairkstarMult"), femtoObs, mult);
+          break;
+        case 9:
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("9") + HIST("/relPairDist"), femtoObs);
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("9") + HIST("/relPairkstarmT"), femtoObs, mT);
+          kHistogramRegistry->fill(HIST(kFolderSuffix[kEventType]) + HIST(o2::aod::femtoflow_mc_particle::MCTypeName[mc]) + HIST("9") + HIST("/relPairkstarMult"), femtoObs, mult);
+          break;
+        default:
+          return; // invalid qn bin
       }
-    }    
+    }
   }
 
   /// Called by setPair only in case of Monte Carlo truth
@@ -302,16 +304,17 @@ class FemtoFlowFemtoContainer
       }
     }
   }
+
  protected:
   HistogramRegistry* kHistogramRegistry = nullptr;                                  ///< For QA output
   static constexpr std::string_view kFolderSuffix[2] = {"SameEvent", "MixedEvent"}; ///< Folder naming for the output according to kEventType
-  static constexpr femto_flow_femto_container::Observable kFemtoObs = obs;      ///< Femtoscopic observable to be computed (according to femto_flow_femto_container::Observable)
+  static constexpr femto_flow_femto_container::Observable kFemtoObs = obs;          ///< Femtoscopic observable to be computed (according to femto_flow_femto_container::Observable)
   static constexpr int kEventType = eventType;                                      ///< Type of the event (same/mixed, according to femto_flow_femto_container::EventType)
   float kMassOne = 0.f;                                                             ///< PDG mass of particle 1
   float kMassTwo = 0.f;                                                             ///< PDG mass of particle 2
   int kPDGOne = 0;                                                                  ///< PDG code of particle 1
-  int kPDGTwo = 0; 
-  int numqnBins = 10;                                                               ///< Max num of devided qn bins
+  int kPDGTwo = 0;
+  int numqnBins = 10; ///< Max num of devided qn bins
 };
 
 } // namespace o2::analysis::femto_flow
diff --git a/PWGCF/Femto/Core/FemtoFlowMath.h b/PWGCF/Femto/Core/FemtoFlowMath.h
index 883de611198..bca9dd13cd6 100644
--- a/PWGCF/Femto/Core/FemtoFlowMath.h
+++ b/PWGCF/Femto/Core/FemtoFlowMath.h
@@ -19,14 +19,14 @@
 #ifndef PWGCF_FEMTOFLOW_CORE_FEMTOFLOWMATH_H_
 #define PWGCF_FEMTOFLOW_CORE_FEMTOFLOWMATH_H_
 
-#include <vector>
-#include <algorithm>
-
-#include "Math/Vector4D.h"
 #include "Math/Boost.h"
+#include "Math/Vector4D.h"
 #include "TLorentzVector.h"
 #include "TMath.h"
 
+#include <algorithm>
+#include <vector>
+
 namespace o2::analysis::femto_flow
 {
 
diff --git a/PWGCF/Femto/Core/FemtoFlowObjectSelection.h b/PWGCF/Femto/Core/FemtoFlowObjectSelection.h
index 59019d86e60..70e9bdd6c3e 100644
--- a/PWGCF/Femto/Core/FemtoFlowObjectSelection.h
+++ b/PWGCF/Femto/Core/FemtoFlowObjectSelection.h
@@ -17,15 +17,16 @@
 #ifndef PWGCF_FEMTOFLOW_CORE_FEMTOFLOWOBJECTSELECTION_H_
 #define PWGCF_FEMTOFLOW_CORE_FEMTOFLOWOBJECTSELECTION_H_
 
+#include "PWGCF/Femto/Core/FemtoFlowSelection.h"
+#include "PWGCF/Femto/DataModel/FemtoDerived.h"
+
+#include "Framework/HistogramRegistry.h"
+#include "ReconstructionDataFormats/PID.h"
+
 #include <algorithm>
 #include <string>
 #include <vector>
 
-#include "PWGCF/Femto/Core/FemtoFlowSelection.h"
-#include "ReconstructionDataFormats/PID.h"
-#include "Framework/HistogramRegistry.h"
-#include "PWGCF/Femto/DataModel/FemtoDerived.h"
-
 using namespace o2;
 using namespace o2::framework;
 
@@ -189,7 +190,7 @@ class FemtoFlowObjectSelection
   }
 
  protected:
-  HistogramRegistry* mHistogramRegistry;                                        ///< For QA output
+  HistogramRegistry* mHistogramRegistry;                                    ///< For QA output
   std::vector<FemtoFlowSelection<selValDataType, selVariable>> mSelections; ///< Vector containing all selections
 };
 
diff --git a/PWGCF/Femto/Core/FemtoFlowPairCleaner.h b/PWGCF/Femto/Core/FemtoFlowPairCleaner.h
index 58f7b857cae..0fdd5a61337 100644
--- a/PWGCF/Femto/Core/FemtoFlowPairCleaner.h
+++ b/PWGCF/Femto/Core/FemtoFlowPairCleaner.h
@@ -20,6 +20,7 @@
 #define PWGCF_FEMTOFLOW_CORE_FEMTOFLOWPAIRCLEANER_H_
 
 #include "PWGCF/Femto/DataModel/FemtoDerived.h"
+
 #include "Framework/HistogramRegistry.h"
 
 namespace o2::analysis::femto_flow
@@ -184,7 +185,7 @@ class FemtoFlowPairCleaner
   }
 
  private:
-  HistogramRegistry* mHistogramRegistry;                                                ///< For QA output
+  HistogramRegistry* mHistogramRegistry;                                            ///< For QA output
   static constexpr o2::aod::femtoflowparticle::ParticleType kPartOneType = partOne; ///< Type of particle 1
   static constexpr o2::aod::femtoflowparticle::ParticleType kPartTwoType = partTwo; ///< Type of particle 2
 };
diff --git a/PWGCF/Femto/Core/FemtoFlowParticleHisto.h b/PWGCF/Femto/Core/FemtoFlowParticleHisto.h
index 4ebc8b3c482..b0a25d8c3bc 100644
--- a/PWGCF/Femto/Core/FemtoFlowParticleHisto.h
+++ b/PWGCF/Femto/Core/FemtoFlowParticleHisto.h
@@ -20,11 +20,13 @@
 #ifndef PWGCF_FEMTOFLOW_CORE_FEMTOFLOWPARTICLEHISTO_H_
 #define PWGCF_FEMTOFLOW_CORE_FEMTOFLOWPARTICLEHISTO_H_
 
-#include <string>
-#include <optional>
 #include "PWGCF/Femto/DataModel/FemtoDerived.h"
-#include "Framework/HistogramRegistry.h"
+
 #include "CommonConstants/MathConstants.h"
+#include "Framework/HistogramRegistry.h"
+
+#include <optional>
+#include <string>
 
 using namespace o2::framework; // o2-linter: disable=using-directive
 
@@ -241,7 +243,7 @@ class FemtoFlowParticleHisto
       // Fill here the actual histogramms by calling init_base and init_MC
       init_base<o2::aod::femtoflow_mc_particle::MCType::kRecon>(folderName, tempFitVarAxisTitle, tempFitVarpTAxis, tempFitVarAxis);
       if (isDebug) {
-        init_debug<o2::aod::femtoflow_mc_particle::MCType::kRecon>(folderName);       
+        init_debug<o2::aod::femtoflow_mc_particle::MCType::kRecon>(folderName);
       }
       if (isMC) {
         init_base<o2::aod::femtoflow_mc_particle::MCType::kTruth>(folderName, tempFitVarAxisTitle, tempFitVarpTAxis, tempFitVarAxis);
@@ -519,12 +521,12 @@ class FemtoFlowParticleHisto
   }
 
  private:
-  HistogramRegistry* mHistogramRegistry;                                                      ///< For QA output
-  static constexpr o2::aod::femtoflowparticle::ParticleType mParticleType = particleType; ///< Type of the particle under analysis // o2-linter: disable=name/constexpr-constant
-  static constexpr int mFolderSuffixType = suffixType;                                        ///< Counter for the folder suffix specified below // o2-linter: disable=name/constexpr-constant
-  static constexpr std::string_view mFolderSuffix[5] = {"_debug", "_one", "_two", "_pos", "_neg"};  ///< Suffix for the folder name in case of analyses of pairs of the same kind (T-T, V-V, C-C) // o2-linter: disable=name/constexpr-constant
-  int mConfPDGCodePart[4] = {211, 321, 2212, 9999};                                           ///< PDG code as per analysis
-  int mPDG = 0;                                                                               ///< PDG code of the selected particle
+  HistogramRegistry* mHistogramRegistry;                                                           ///< For QA output
+  static constexpr o2::aod::femtoflowparticle::ParticleType mParticleType = particleType;          ///< Type of the particle under analysis // o2-linter: disable=name/constexpr-constant
+  static constexpr int mFolderSuffixType = suffixType;                                             ///< Counter for the folder suffix specified below // o2-linter: disable=name/constexpr-constant
+  static constexpr std::string_view mFolderSuffix[5] = {"_debug", "_one", "_two", "_pos", "_neg"}; ///< Suffix for the folder name in case of analyses of pairs of the same kind (T-T, V-V, C-C) // o2-linter: disable=name/constexpr-constant
+  int mConfPDGCodePart[4] = {211, 321, 2212, 9999};                                                ///< PDG code as per analysis
+  int mPDG = 0;                                                                                    ///< PDG code of the selected particle
   int binPDG = 0;
 };
 } // namespace o2::analysis::femto_flow
diff --git a/PWGCF/Femto/Core/FemtoFlowSelection.h b/PWGCF/Femto/Core/FemtoFlowSelection.h
index e6ba1116f28..069ce4d8523 100644
--- a/PWGCF/Femto/Core/FemtoFlowSelection.h
+++ b/PWGCF/Femto/Core/FemtoFlowSelection.h
@@ -123,8 +123,8 @@ class FemtoFlowSelection
   }
 
  private:
-  selValDataType mSelVal{0.f};                      ///< Value used for the selection
-  selVariableDataType mSelVar;                      ///< Variable used for the selection
+  selValDataType mSelVal{0.f};                  ///< Value used for the selection
+  selVariableDataType mSelVar;                  ///< Variable used for the selection
   femto_flow_selection::SelectionType mSelType; ///< Type of selection employed
 };
 
diff --git a/PWGCF/Femto/Core/FemtoFlowTrackSelection.h b/PWGCF/Femto/Core/FemtoFlowTrackSelection.h
index 8713fa3a8dd..de7fba9588f 100644
--- a/PWGCF/Femto/Core/FemtoFlowTrackSelection.h
+++ b/PWGCF/Femto/Core/FemtoFlowTrackSelection.h
@@ -18,17 +18,19 @@
 #ifndef PWGCF_FEMTOFLOW_CORE_FEMTOFLOWTRACKSELECTION_H_
 #define PWGCF_FEMTOFLOW_CORE_FEMTOFLOWTRACKSELECTION_H_
 
-#include <string>
-#include <vector>
-#include <cmath>
-
+#include "PWGCF/Femto/Core/FemtoFlowObjectSelection.h"
 #include "PWGCF/Femto/DataModel/FemtoDerived.h"
-#include "Common/DataModel/TrackSelectionTables.h"
+
 #include "Common/Core/TrackSelection.h"
 #include "Common/Core/TrackSelectionDefaults.h"
-#include "PWGCF/Femto/Core/FemtoFlowObjectSelection.h"
-#include "ReconstructionDataFormats/PID.h"
+#include "Common/DataModel/TrackSelectionTables.h"
+
 #include "Framework/HistogramRegistry.h"
+#include "ReconstructionDataFormats/PID.h"
+
+#include <cmath>
+#include <string>
+#include <vector>
 
 // using namespace o2::framework;
 
@@ -67,33 +69,33 @@ class FemtoFlowTrackSelection : public FemtoFlowObjectSelection<float, femto_flo
 {
  public:
   FemtoFlowTrackSelection() : nRejectNotPropagatedTracks(false),
-                                  nPtMinSel(0),
-                                  nPtMaxSel(0),
-                                  nEtaSel(0),
-                                  nTPCnMinSel(0),
-                                  nTPCfMinSel(0),
-                                  nTPCcMinSel(0),
-                                  nTPCsMaxSel(0),
-                                  nITScMinSel(0),
-                                  nITScIbMinSel(0),
-                                  nDCAxyMaxSel(0),
-                                  nDCAzMaxSel(0),
-                                  nDCAMinSel(0),
-                                  nPIDnSigmaSel(0),
-                                  pTMin(9999999.),
-                                  pTMax(-9999999.),
-                                  etaMax(-9999999.),
-                                  nClsMin(9999999.),
-                                  fClsMin(9999999.),
-                                  cTPCMin(9999999.),
-                                  sTPCMax(-9999999.),
-                                  fracsTPCMax(-9999999.),
-                                  dcaXYMax(-9999999.),
-                                  dcaZMax(-9999999.),
-                                  dcaMin(9999999.),
-                                  nSigmaPIDMax(9999999.),
-                                  nSigmaPIDOffsetTPC(0.),
-                                  nSigmaPIDOffsetTOF(0.) {}
+                              nPtMinSel(0),
+                              nPtMaxSel(0),
+                              nEtaSel(0),
+                              nTPCnMinSel(0),
+                              nTPCfMinSel(0),
+                              nTPCcMinSel(0),
+                              nTPCsMaxSel(0),
+                              nITScMinSel(0),
+                              nITScIbMinSel(0),
+                              nDCAxyMaxSel(0),
+                              nDCAzMaxSel(0),
+                              nDCAMinSel(0),
+                              nPIDnSigmaSel(0),
+                              pTMin(9999999.),
+                              pTMax(-9999999.),
+                              etaMax(-9999999.),
+                              nClsMin(9999999.),
+                              fClsMin(9999999.),
+                              cTPCMin(9999999.),
+                              sTPCMax(-9999999.),
+                              fracsTPCMax(-9999999.),
+                              dcaXYMax(-9999999.),
+                              dcaZMax(-9999999.),
+                              dcaMin(9999999.),
+                              nSigmaPIDMax(9999999.),
+                              nSigmaPIDOffsetTPC(0.),
+                              nSigmaPIDOffsetTOF(0.) {}
 
   /// Initializes histograms for the task
   /// \tparam part Type of the particle for proper naming of the folders for QA
@@ -264,20 +266,20 @@ class FemtoFlowTrackSelection : public FemtoFlowObjectSelection<float, femto_flo
                                                                          "PIDnSigmaMax"}; ///< Name of the different selections
 
   static constexpr femto_flow_selection::SelectionType kSelectionTypes[kNtrackSelection]{femto_flow_selection::kEqual,
-                                                                                             femto_flow_selection::kLowerLimit,
-                                                                                             femto_flow_selection::kUpperLimit,
-                                                                                             femto_flow_selection::kAbsUpperLimit,
-                                                                                             femto_flow_selection::kLowerLimit,
-                                                                                             femto_flow_selection::kLowerLimit,
-                                                                                             femto_flow_selection::kLowerLimit,
-                                                                                             femto_flow_selection::kUpperLimit,
-                                                                                             femto_flow_selection::kUpperLimit,
-                                                                                             femto_flow_selection::kLowerLimit,
-                                                                                             femto_flow_selection::kLowerLimit,
-                                                                                             femto_flow_selection::kAbsUpperLimit,
-                                                                                             femto_flow_selection::kAbsUpperLimit,
-                                                                                             femto_flow_selection::kAbsUpperLimit,
-                                                                                             femto_flow_selection::kAbsUpperLimit}; ///< Map to match a variable with its type
+                                                                                         femto_flow_selection::kLowerLimit,
+                                                                                         femto_flow_selection::kUpperLimit,
+                                                                                         femto_flow_selection::kAbsUpperLimit,
+                                                                                         femto_flow_selection::kLowerLimit,
+                                                                                         femto_flow_selection::kLowerLimit,
+                                                                                         femto_flow_selection::kLowerLimit,
+                                                                                         femto_flow_selection::kUpperLimit,
+                                                                                         femto_flow_selection::kUpperLimit,
+                                                                                         femto_flow_selection::kLowerLimit,
+                                                                                         femto_flow_selection::kLowerLimit,
+                                                                                         femto_flow_selection::kAbsUpperLimit,
+                                                                                         femto_flow_selection::kAbsUpperLimit,
+                                                                                         femto_flow_selection::kAbsUpperLimit,
+                                                                                         femto_flow_selection::kAbsUpperLimit}; ///< Map to match a variable with its type
 
   static constexpr std::string_view kSelectionHelper[kNtrackSelection] = {"Sign of the track",
                                                                           "Minimal pT (GeV/c)",
diff --git a/PWGCF/Femto/Core/femtoUtils.h b/PWGCF/Femto/Core/femtoUtils.h
index ecb2bc3cf3d..646fb3ef191 100644
--- a/PWGCF/Femto/Core/femtoUtils.h
+++ b/PWGCF/Femto/Core/femtoUtils.h
@@ -17,12 +17,14 @@
 #ifndef PWGCF_FEMTOFLOW_CORE_FEMTOUTILS_H_
 #define PWGCF_FEMTOFLOW_CORE_FEMTOUTILS_H_
 
-#include <vector>
-#include <functional>
-#include <algorithm>
-#include "Framework/ASoAHelpers.h"
 #include "PWGCF/Femto/DataModel/FemtoDerived.h"
 
+#include "Framework/ASoAHelpers.h"
+
+#include <algorithm>
+#include <functional>
+#include <vector>
+
 namespace o2::analysis::femto_flow
 {
 
diff --git a/PWGCF/Femto/DataModel/FemtoDerived.h b/PWGCF/Femto/DataModel/FemtoDerived.h
index 22af1df54ed..3fe68a26f91 100644
--- a/PWGCF/Femto/DataModel/FemtoDerived.h
+++ b/PWGCF/Femto/DataModel/FemtoDerived.h
@@ -16,15 +16,17 @@
 #ifndef PWGCF_FEMTOFLOW_DATAMODEL_FEMTODERIVED_H_
 #define PWGCF_FEMTOFLOW_DATAMODEL_FEMTODERIVED_H_
 
-#include <cmath>
-#include "Framework/ASoA.h"
-#include "MathUtils/Utils.h"
-#include "Framework/DataTypes.h"
 #include "Common/DataModel/Multiplicity.h"
+#include "Common/DataModel/PIDResponse.h"
+#include "Common/DataModel/TrackSelectionTables.h"
+
+#include "Framework/ASoA.h"
 #include "Framework/AnalysisDataModel.h"
+#include "Framework/DataTypes.h"
 #include "Framework/Expressions.h"
-#include "Common/DataModel/TrackSelectionTables.h"
-#include "Common/DataModel/PIDResponse.h"
+#include "MathUtils/Utils.h"
+
+#include <cmath>
 
 namespace o2::aod
 {
diff --git a/PWGCF/Femto/TableProducer/femtoFlowCutCulator.cxx b/PWGCF/Femto/TableProducer/femtoFlowCutCulator.cxx
index c803d905559..4ca77a75de7 100644
--- a/PWGCF/Femto/TableProducer/femtoFlowCutCulator.cxx
+++ b/PWGCF/Femto/TableProducer/femtoFlowCutCulator.cxx
@@ -14,14 +14,16 @@
 /// \author Andi Mathis, TU München, andreas.mathis@ph.tum.de
 /// \author Zuzanna Chochulska, WUT Warsaw & CTU Prague, zchochul@cern.ch
 
-#include <filesystem>
-#include <iostream>
-#include <random>
 #include "PWGCF/Femto/Core/FemtoFlowCutculator.h"
+
 #include "PWGCF/Femto/Core/FemtoFlowSelection.h"
 #include "PWGCF/Femto/Core/FemtoFlowTrackSelection.h"
 #include "PWGCF/Femto/DataModel/FemtoDerived.h"
 
+#include <filesystem>
+#include <iostream>
+#include <random>
+
 using namespace o2::analysis::femto_flow;
 
 /// The function takes the path to the dpl-config.json as a argument and the
@@ -42,8 +44,8 @@ int main(int /*argc*/, char* argv[])
     std::cin >> choice;
 
     // if (choice == std::string("T")) {
-      cut.setTrackSelectionFromFile("ConfTrk");
-      cut.setPIDSelectionFromFile("ConfTrk");
+    cut.setTrackSelectionFromFile("ConfTrk");
+    cut.setPIDSelectionFromFile("ConfTrk");
     // } else if (choice == std::string("V")) {
     //   std::cout << "Do you want to select V0s or one of its children (V/T)? >";
     //   std::cin >> choice;
diff --git a/PWGCF/Femto/TableProducer/femtoFlowProducerTask.cxx b/PWGCF/Femto/TableProducer/femtoFlowProducerTask.cxx
index d77b19f0d4b..2127959b949 100644
--- a/PWGCF/Femto/TableProducer/femtoFlowProducerTask.cxx
+++ b/PWGCF/Femto/TableProducer/femtoFlowProducerTask.cxx
@@ -73,7 +73,7 @@ namespace o2::aod
 
 using FemtoFullCollision =
   soa::Join<aod::Collisions, aod::EvSels, aod::Mults>::iterator;
-using FemtoFullCollision_CentPbPb = 
+using FemtoFullCollision_CentPbPb =
   soa::Join<aod::Collisions, aod::EvSels, aod::Mults, aod::CentFT0Cs, aod::CentFV0As, aod::QvectorFT0CVecs>::iterator;
 using FemtoFullTracks =
   soa::Join<aod::FullTracks, aod::TracksDCA, aod::TOFSignal, aod::pidTOFbeta, aod::pidTPCEl, aod::TrackSelection,
@@ -169,7 +169,7 @@ struct FemtoFlowProducerTask {
     Configurable<bool> ConfDcaXYCustom1Cut{"ConfDcaXYCustom1Cut", true, "Enable Custom |DCAxy| < [1] + [2]/pt cut."};
     Configurable<float> ConfDcaXYCustom11FilterCut{"ConfDcaXYCustom11FilterCut", 0.004, "Value for [1] custom DCAxy cut -> |DCAxy| < [1] + [2]/pT"};
     Configurable<float> ConfDcaXYCustom12FilterCut{"ConfDcaXYCustom12FilterCut", 0.013, "Value for [2] custom DCAxy cut -> |DCAxy| < [1] + [2]/pT"};
-    Configurable<float> ConfDcaZFilterCut{"ConfDcaZFilterCut", 3.2, "Value for DCA_Z for the global track"};    // max dca to vertex Z
+    Configurable<float> ConfDcaZFilterCut{"ConfDcaZFilterCut", 3.2, "Value for DCA_Z for the global track"}; // max dca to vertex Z
     Configurable<float> ConfTrkMinChi2PerClusterTPC{"ConfTrkMinChi2PerClusterTPC", 0.f, "Lower limit for chi2 of TPC; currently for testing only"};
     Configurable<float> ConfTrkMaxChi2PerClusterTPC{"ConfTrkMaxChi2PerClusterTPC", 4.f, "Upper limit for chi2 of TPC; currently for testing only"};
     Configurable<float> ConfTrkMaxChi2PerClusterITS{"ConfTrkMaxChi2PerClusterITS", 10.0f, "Minimal track selection: max allowed chi2 per ITS cluster"}; // 36.0 is default
@@ -182,7 +182,7 @@ struct FemtoFlowProducerTask {
 
   int mRunNumber = 0;
   float mMagField;
-  std::string zorroTriggerNames = "";  
+  std::string zorroTriggerNames = "";
   Service<o2::ccdb::BasicCCDBManager> ccdb; /// Accessing the CCDB
 
   void init(InitContext&)
@@ -258,18 +258,18 @@ struct FemtoFlowProducerTask {
   template <typename ParticleType>
   void fillDebugParticle(ParticleType const& particle)
   {
-      outputDebugParts(particle.sign(), (uint8_t)particle.tpcNClsFound(),
-                       particle.tpcNClsFindable(),
-                       (uint8_t)particle.tpcNClsCrossedRows(),
-                       particle.tpcNClsShared(), particle.tpcFractionSharedCls(), particle.tpcInnerParam(),
-                       particle.itsNCls(), particle.itsNClsInnerBarrel(),
-                       particle.dcaXY(), particle.dcaZ(), particle.tpcSignal(), particle.beta(),
-                       particle.tpcNSigmaStoreEl(), particle.tpcNSigmaStorePi(),
-                       particle.tpcNSigmaStoreKa(), particle.tpcNSigmaStorePr(),
-                       particle.tpcNSigmaStoreDe(), particle.tofNSigmaStoreEl(),
-                       particle.tofNSigmaStorePi(), particle.tofNSigmaStoreKa(),
-                       particle.tofNSigmaStorePr(), particle.tofNSigmaStoreDe(),
-                       -999., -999., -999., -999., -999., -999.);
+    outputDebugParts(particle.sign(), (uint8_t)particle.tpcNClsFound(),
+                     particle.tpcNClsFindable(),
+                     (uint8_t)particle.tpcNClsCrossedRows(),
+                     particle.tpcNClsShared(), particle.tpcFractionSharedCls(), particle.tpcInnerParam(),
+                     particle.itsNCls(), particle.itsNClsInnerBarrel(),
+                     particle.dcaXY(), particle.dcaZ(), particle.tpcSignal(), particle.beta(),
+                     particle.tpcNSigmaStoreEl(), particle.tpcNSigmaStorePi(),
+                     particle.tpcNSigmaStoreKa(), particle.tpcNSigmaStorePr(),
+                     particle.tpcNSigmaStoreDe(), particle.tofNSigmaStoreEl(),
+                     particle.tofNSigmaStorePi(), particle.tofNSigmaStoreKa(),
+                     particle.tofNSigmaStorePr(), particle.tofNSigmaStoreDe(),
+                     -999., -999., -999., -999., -999., -999.);
   }
 
   template <bool isMC, typename CollisionType, typename TrackType>
@@ -304,18 +304,13 @@ struct FemtoFlowProducerTask {
     int qnbin = colCuts.myqnBin(col);
 
     if (!confIsUsePileUp) {
-      outputCollision(vtxZ, mult, multNtr, confDoSpher ? sphericity : 2, (confDoqnVec && qnbin>=0 && qnbin<10)? qnbin: -999, mMagField); 
+      outputCollision(vtxZ, mult, multNtr, confDoSpher ? sphericity : 2, (confDoqnVec && qnbin >= 0 && qnbin < 10) ? qnbin : -999, mMagField);
       colCuts.fillQA(col);
       return true;
-    } else if ((!confEvNoSameBunchPileup || col.selection_bit(aod::evsel::kNoSameBunchPileup)) 
-            && (!confEvIsGoodZvtxFT0vsPV || col.selection_bit(aod::evsel::kIsGoodZvtxFT0vsPV)) 
-            && (!confEvIsGoodITSLayersAll || col.selection_bit(aod::evsel::kIsGoodITSLayersAll))
-            && (!confEvNoCollInRofStandard || col.selection_bit(aod::evsel::kNoCollInRofStandard))
-            && (!confEvNoHighMultCollInPrevRof || col.selection_bit(aod::evsel::kNoHighMultCollInPrevRof))
-            && (!confEvNoCollInTimeRangeStandard || col.selection_bit(aod::evsel::kNoCollInTimeRangeStandard))
-            // && (!confEvIsVertexITSTPC || col.selection_bit(aod::evsel::kIsVertexITSTPC))
-                ) {
-      outputCollision(vtxZ, mult, multNtr, confDoSpher ? sphericity : 2, (confDoqnVec && qnbin>=0 && qnbin<10)? qnbin: -999, mMagField); 
+    } else if ((!confEvNoSameBunchPileup || col.selection_bit(aod::evsel::kNoSameBunchPileup)) && (!confEvIsGoodZvtxFT0vsPV || col.selection_bit(aod::evsel::kIsGoodZvtxFT0vsPV)) && (!confEvIsGoodITSLayersAll || col.selection_bit(aod::evsel::kIsGoodITSLayersAll)) && (!confEvNoCollInRofStandard || col.selection_bit(aod::evsel::kNoCollInRofStandard)) && (!confEvNoHighMultCollInPrevRof || col.selection_bit(aod::evsel::kNoHighMultCollInPrevRof)) && (!confEvNoCollInTimeRangeStandard || col.selection_bit(aod::evsel::kNoCollInTimeRangeStandard))
+               // && (!confEvIsVertexITSTPC || col.selection_bit(aod::evsel::kIsVertexITSTPC))
+    ) {
+      outputCollision(vtxZ, mult, multNtr, confDoSpher ? sphericity : 2, (confDoqnVec && qnbin >= 0 && qnbin < 10) ? qnbin : -999, mMagField);
       colCuts.fillQA(col);
       return true;
     } else {
@@ -369,13 +364,13 @@ struct FemtoFlowProducerTask {
           continue;
         }
       }
-      if (ConfTrackSpecialFilters.ConfDcaXYCustom0Cut && fabs(track.dcaXY())>ConfTrackSpecialFilters.ConfDcaXYFilterCut){
+      if (ConfTrackSpecialFilters.ConfDcaXYCustom0Cut && fabs(track.dcaXY()) > ConfTrackSpecialFilters.ConfDcaXYFilterCut) {
         continue;
       }
-      if (ConfTrackSpecialFilters.ConfDcaXYCustom1Cut && fabs(track.dcaXY())>ConfTrackSpecialFilters.ConfDcaXYCustom11FilterCut + ConfTrackSpecialFilters.ConfDcaXYCustom12FilterCut / track.pt() ){
+      if (ConfTrackSpecialFilters.ConfDcaXYCustom1Cut && fabs(track.dcaXY()) > ConfTrackSpecialFilters.ConfDcaXYCustom11FilterCut + ConfTrackSpecialFilters.ConfDcaXYCustom12FilterCut / track.pt()) {
         continue;
       }
-      if(fabs(track.dcaZ())>ConfTrackSpecialFilters.ConfDcaZFilterCut){
+      if (fabs(track.dcaZ()) > ConfTrackSpecialFilters.ConfDcaZFilterCut) {
         continue;
       }
       if (track.tpcChi2NCl() < ConfTrackSpecialFilters.ConfTrkMinChi2PerClusterTPC || track.tpcChi2NCl() > ConfTrackSpecialFilters.ConfTrkMaxChi2PerClusterTPC) {
@@ -391,7 +386,6 @@ struct FemtoFlowProducerTask {
         continue;
       }
 
-
       trackCuts.fillQA<aod::femtoflowparticle::ParticleType::kTrack,
                        aod::femtoflowparticle::TrackType::kNoChild>(track);
 
@@ -420,7 +414,8 @@ struct FemtoFlowProducerTask {
   void fillCollisionsAndTracks(CollisionType const& col, TrackType const& tracks)
   {
     const auto colcheck = fillCollisions<isMC>(col, tracks);
-    if (colcheck) fillTracks<isMC>(tracks);
+    if (colcheck)
+      fillTracks<isMC>(tracks);
   }
 
   void processFullData(aod::FemtoFullCollision_CentPbPb const& col,
diff --git a/PWGCF/Femto/Tasks/femtoFlowPairTaskTrackTrack.cxx b/PWGCF/Femto/Tasks/femtoFlowPairTaskTrackTrack.cxx
index 88d8c50ebbf..b59569b1b7b 100644
--- a/PWGCF/Femto/Tasks/femtoFlowPairTaskTrackTrack.cxx
+++ b/PWGCF/Femto/Tasks/femtoFlowPairTaskTrackTrack.cxx
@@ -18,24 +18,25 @@
 /// \author Wenya Wu, TUM, wenya.wu@cern.ch
 /// \NOTE:  The femtoflow framework borrows and copies the framework of femtouniverse and femtodream
 
-#include <vector>
+#include "PWGCF/Femto/Core/FemtoFlowAngularContainer.h"
+#include "PWGCF/Femto/Core/FemtoFlowDetaDphiStar.h"
+#include "PWGCF/Femto/Core/FemtoFlowEventHisto.h"
+#include "PWGCF/Femto/Core/FemtoFlowFemtoContainer.h"
+#include "PWGCF/Femto/Core/FemtoFlowPairCleaner.h"
+#include "PWGCF/Femto/Core/FemtoFlowParticleHisto.h"
+#include "PWGCF/Femto/Core/FemtoFlowTrackSelection.h"
+#include "PWGCF/Femto/Core/femtoUtils.h"
+#include "PWGCF/Femto/DataModel/FemtoDerived.h"
+
+#include "Framework/ASoAHelpers.h"
 #include "Framework/AnalysisTask.h"
-#include "Framework/runDataProcessing.h"
 #include "Framework/HistogramRegistry.h"
-#include "Framework/ASoAHelpers.h"
+#include "Framework/O2DatabasePDGPlugin.h"
 #include "Framework/RunningWorkflowInfo.h"
 #include "Framework/StepTHn.h"
-#include "Framework/O2DatabasePDGPlugin.h"
+#include "Framework/runDataProcessing.h"
 
-#include "PWGCF/Femto/DataModel/FemtoDerived.h"
-#include "PWGCF/Femto/Core/FemtoFlowParticleHisto.h"
-#include "PWGCF/Femto/Core/FemtoFlowEventHisto.h"
-#include "PWGCF/Femto/Core/FemtoFlowPairCleaner.h"
-#include "PWGCF/Femto/Core/FemtoFlowFemtoContainer.h"
-#include "PWGCF/Femto/Core/FemtoFlowAngularContainer.h"
-#include "PWGCF/Femto/Core/FemtoFlowDetaDphiStar.h"
-#include "PWGCF/Femto/Core/femtoUtils.h"
-#include "PWGCF/Femto/Core/FemtoFlowTrackSelection.h"
+#include <vector>
 
 using namespace o2;
 using namespace o2::analysis::femto_flow;
@@ -102,12 +103,12 @@ struct FemtoFlowPairTaskTrackTrack {
   FemtoFlowParticleHisto<aod::femtoflowparticle::ParticleType::kTrack, 2> trackHistoPartTwo;
 
   // Particle for debug
-  Partition<FemtoFullParticles> partsDebug = (aod::femtoflowparticle::partType == uint8_t(aod::femtoflowparticle::ParticleType::kTrack)) && 
+  Partition<FemtoFullParticles> partsDebug = (aod::femtoflowparticle::partType == uint8_t(aod::femtoflowparticle::ParticleType::kTrack)) &&
                                              (aod::femtoflowparticle::sign == int8_t(1)) &&
                                              ((aod::femtoflowparticle::cut & confCutPartOne) == confCutPartOne); // Bit_mask for partOne or partTwo
 
-  /// Histogramming for debug particle 
-  FemtoFlowParticleHisto<aod::femtoflowparticle::ParticleType::kTrack> trackHistoPartDebug; //FolderSuffixType name set as 0 = "_debug"
+  /// Histogramming for debug particle
+  FemtoFlowParticleHisto<aod::femtoflowparticle::ParticleType::kTrack> trackHistoPartDebug; // FolderSuffixType name set as 0 = "_debug"
 
   /// Histogramming for Event
   FemtoFlowEventHisto eventHisto;
@@ -164,7 +165,8 @@ struct FemtoFlowPairTaskTrackTrack {
       trackHistoPartTwo.init(&qaRegistry, confTempFitVarpTBins, confTempFitVarBins, confIsMC, confPDGCodePartTwo, false);
     }
 
-    if (confIsDebug) trackHistoPartDebug.init(&qaRegistry, confTempFitVarpTBins, confTempFitVarBins, confIsMC, confPDGCodePartOne, true);
+    if (confIsDebug)
+      trackHistoPartDebug.init(&qaRegistry, confTempFitVarpTBins, confTempFitVarBins, confIsMC, confPDGCodePartOne, true);
 
     mixQaRegistry.add("MixingQA/hSECollisionBins", ";bin;Entries", kTH1F, {{120, -0.5, 119.5}});
     mixQaRegistry.add("MixingQA/hMECollisionBins", ";bin;Entries", kTH1F, {{120, -0.5, 119.5}});
@@ -299,8 +301,8 @@ struct FemtoFlowPairTaskTrackTrack {
     auto thegroupPartsTwo = partsTwo->sliceByCached(aod::femtoflowparticle::fdCollisionId, col.globalIndex(), cache);
 
     doSameEvent<false>(thegroupPartsOne, thegroupPartsTwo, parts, col.magField(), col.multNtr(), col.qnbin());
-  
-    if(confIsDebug){   
+
+    if (confIsDebug) {
       auto thegroupPartsDebug = partsDebug->sliceByCached(aod::femtoflowparticle::fdCollisionId, col.globalIndex(), cache);
       for (const auto& partDebug : thegroupPartsDebug) {
         if (partDebug.p() > confCutTable->get("PartTwo", "MaxP") || partDebug.pt() > confCutTable->get("PartTwo", "MaxPt")) {