diff --git a/PWGCF/FemtoDream/Core/femtoDreamCascadeSelection.h b/PWGCF/FemtoDream/Core/femtoDreamCascadeSelection.h
index 2a07c851d09..f9b52686567 100644
--- a/PWGCF/FemtoDream/Core/femtoDreamCascadeSelection.h
+++ b/PWGCF/FemtoDream/Core/femtoDreamCascadeSelection.h
@@ -22,21 +22,23 @@
 #ifndef PWGCF_FEMTODREAM_CORE_FEMTODREAMCASCADESELECTION_H_
 #define PWGCF_FEMTODREAM_CORE_FEMTODREAMCASCADESELECTION_H_
 
-#include <iostream>
-#include <string>
-#include <vector>
-
-#include <TDatabasePDG.h> // FIXME
-
 #include "PWGCF/FemtoDream/Core/femtoDreamObjectSelection.h"
 #include "PWGCF/FemtoDream/Core/femtoDreamSelection.h"
 #include "PWGCF/FemtoDream/Core/femtoDreamTrackSelection.h"
 
 #include "Common/Core/RecoDecay.h"
+
 #include "Framework/HistogramRegistry.h"
 #include "ReconstructionDataFormats/PID.h"
 
+#include <TDatabasePDG.h> // FIXME
+
+#include <iostream>
+#include <string>
+#include <vector>
+
 using namespace o2::framework;
+using namespace o2::analysis::femtoDream::femtoDreamSelection;
 
 namespace o2::analysis::femtoDream
 {
@@ -346,8 +348,8 @@ class FemtoDreamCascadeSelection
   }; ///< Helper information for the
      ///< different selections
 
-  static constexpr int kNcutStages = 2;
-  static constexpr std::string_view mCutStage[kNcutStages] = {"BeforeSel", "AfterSel"};
+  // static constexpr int kNcutStages = 2;
+  // static constexpr std::string_view mCutStage[kNcutStages] = {"BeforeSel", "AfterSel"};
 }; // namespace femtoDream
 
 template <o2::aod::femtodreamparticle::ParticleType part, o2::aod::femtodreamparticle::ParticleType daugh, o2::aod::femtodreamparticle::ParticleType bach, typename cutContainerType>
@@ -663,6 +665,8 @@ void FemtoDreamCascadeSelection::fillQA(Col const& col, Casc const& casc, Track
   const float cpaCasc = casc.casccosPA(col.posX(), col.posY(), col.posZ());
   const float cpav0 = casc.v0cosPA(col.posX(), col.posY(), col.posZ());
   const float v0dcatopv = casc.dcav0topv(col.posX(), col.posY(), col.posZ());
+  const float invMass = isCascOmega ? casc.mOmega() : casc.mXi();
+
   if (mQAHistogramRegistry) {
     mQAHistogramRegistry->fill(HIST(o2::aod::femtodreamparticle::ParticleTypeName[part]) + HIST("/") + HIST(mCutStage[cutstage]) + HIST("/hSign"), casc.sign());
     mQAHistogramRegistry->fill(HIST(o2::aod::femtodreamparticle::ParticleTypeName[part]) + HIST("/") + HIST(mCutStage[cutstage]) + HIST("/hPt"), casc.pt());
@@ -674,7 +678,7 @@ void FemtoDreamCascadeSelection::fillQA(Col const& col, Casc const& casc, Track
     mQAHistogramRegistry->fill(HIST(o2::aod::femtodreamparticle::ParticleTypeName[part]) + HIST("/") + HIST(mCutStage[cutstage]) + HIST("/hDecVtxX"), decVtx.at(0));
     mQAHistogramRegistry->fill(HIST(o2::aod::femtodreamparticle::ParticleTypeName[part]) + HIST("/") + HIST(mCutStage[cutstage]) + HIST("/hDecVtxY"), decVtx.at(1));
     mQAHistogramRegistry->fill(HIST(o2::aod::femtodreamparticle::ParticleTypeName[part]) + HIST("/") + HIST(mCutStage[cutstage]) + HIST("/hDecVtxZ"), decVtx.at(2));
-    mQAHistogramRegistry->fill(HIST(o2::aod::femtodreamparticle::ParticleTypeName[part]) + HIST("/") + HIST(mCutStage[cutstage]) + HIST("/hInvMass"), casc.mXi());
+    mQAHistogramRegistry->fill(HIST(o2::aod::femtodreamparticle::ParticleTypeName[part]) + HIST("/") + HIST(mCutStage[cutstage]) + HIST("/hInvMass"), invMass);
     mQAHistogramRegistry->fill(HIST(o2::aod::femtodreamparticle::ParticleTypeName[part]) + HIST("/") + HIST(mCutStage[cutstage]) + HIST("/hV0DCADaugh"), casc.dcaV0daughters());
     mQAHistogramRegistry->fill(HIST(o2::aod::femtodreamparticle::ParticleTypeName[part]) + HIST("/") + HIST(mCutStage[cutstage]) + HIST("/hV0CPA"), cpav0);
     mQAHistogramRegistry->fill(HIST(o2::aod::femtodreamparticle::ParticleTypeName[part]) + HIST("/") + HIST(mCutStage[cutstage]) + HIST("/hV0TranRad"), casc.v0radius());
diff --git a/PWGCF/FemtoDream/Core/femtoDreamParticleHisto.h b/PWGCF/FemtoDream/Core/femtoDreamParticleHisto.h
index 4148e8b3efc..af1caf11879 100644
--- a/PWGCF/FemtoDream/Core/femtoDreamParticleHisto.h
+++ b/PWGCF/FemtoDream/Core/femtoDreamParticleHisto.h
@@ -18,11 +18,14 @@
 #ifndef PWGCF_FEMTODREAM_CORE_FEMTODREAMPARTICLEHISTO_H_
 #define PWGCF_FEMTODREAM_CORE_FEMTODREAMPARTICLEHISTO_H_
 
-#include <TMath.h>
-#include <string>
 #include "PWGCF/DataModel/FemtoDerived.h"
-#include "Framework/HistogramRegistry.h"
+
 #include "CommonConstants/PhysicsConstants.h"
+#include "Framework/HistogramRegistry.h"
+
+#include <TMath.h>
+
+#include <string>
 
 using namespace o2::framework;
 
@@ -690,11 +693,13 @@ class FemtoDreamParticleHisto
   }
 
  private:
-  HistogramRegistry* mHistogramRegistry;                                                                                                                      ///< For QA output
-  static constexpr o2::aod::femtodreamparticle::ParticleType mParticleType = particleType;                                                                    ///< Type of the particle under analysis
-  static constexpr int mFolderSuffixType = suffixType;                                                                                                        ///< Counter for the folder suffix specified below
-  static constexpr std::string_view mFolderSuffix[9] = {"", "_one", "_two", "_pos", "_neg", "_allSelected", "_allSelected_pos", "_allSelected_neg", "_bach"}; ///< Suffix for the folder name in case of analyses of pairs of the same kind (T-T, V-V, C-C)
-  int mPDG = 0;                                                                                                                                               ///< PDG code of the selected particle
+  HistogramRegistry* mHistogramRegistry;                                                   ///< For QA output
+  static constexpr o2::aod::femtodreamparticle::ParticleType mParticleType = particleType; ///< Type of the particle under analysis
+  static constexpr int mFolderSuffixType = suffixType;                                     ///< Counter for the folder suffix specified below
+  static constexpr std::string_view mFolderSuffix[12] = {"", "_one", "_two", "_pos", "_neg",
+                                                         "_allSelected", "_allSelected_pos", "_allSelected_neg", "_bach",
+                                                         "_two_pos", "_two_neg", "_two_bach"}; ///< Suffix for the folder name in case of analyses of pairs of the same kind (T-T, V-V, C-C)
+  int mPDG = 0;                                                                                ///< PDG code of the selected particle
 };
 } // namespace o2::analysis::femtoDream
 
diff --git a/PWGCF/FemtoDream/Core/femtoDreamSelection.h b/PWGCF/FemtoDream/Core/femtoDreamSelection.h
index 0e3592bf650..90fd8f58046 100644
--- a/PWGCF/FemtoDream/Core/femtoDreamSelection.h
+++ b/PWGCF/FemtoDream/Core/femtoDreamSelection.h
@@ -16,10 +16,12 @@
 #ifndef PWGCF_FEMTODREAM_CORE_FEMTODREAMSELECTION_H_
 #define PWGCF_FEMTODREAM_CORE_FEMTODREAMSELECTION_H_
 
-#include <cmath>
-#include "Framework/HistogramRegistry.h"
 #include "PWGCF/DataModel/FemtoDerived.h"
 
+#include "Framework/HistogramRegistry.h"
+
+#include <cmath>
+
 using namespace o2;
 using namespace o2::framework;
 
@@ -36,6 +38,9 @@ enum SelectionType { kUpperLimit,    ///< simple upper limit for the value, e.g.
                      kEqual          ///< values need to be equal, e.g. sign = 1
 };
 
+static constexpr int kNcutStages = 2;
+static constexpr std::string_view mCutStage[kNcutStages] = {"BeforeSel", "AfterSel"};
+
 } // namespace femtoDreamSelection
 
 /// Simple class taking care of individual selections
diff --git a/PWGCF/FemtoDream/Core/femtoDreamTrackSelection.h b/PWGCF/FemtoDream/Core/femtoDreamTrackSelection.h
index 9cab0f9e78b..13d1ba5280b 100644
--- a/PWGCF/FemtoDream/Core/femtoDreamTrackSelection.h
+++ b/PWGCF/FemtoDream/Core/femtoDreamTrackSelection.h
@@ -17,22 +17,25 @@
 #ifndef PWGCF_FEMTODREAM_CORE_FEMTODREAMTRACKSELECTION_H_
 #define PWGCF_FEMTODREAM_CORE_FEMTODREAMTRACKSELECTION_H_
 
-#include <string>
-#include <vector>
-#include <cmath>
-#include <iostream>
-
 #include "PWGCF/DataModel/FemtoDerived.h"
-#include "Common/DataModel/TrackSelectionTables.h"
-#include "Common/DataModel/PIDResponse.h"
-#include "Common/DataModel/PIDResponseITS.h"
+#include "PWGCF/FemtoDream/Core/femtoDreamObjectSelection.h"
+
 #include "Common/Core/TrackSelection.h"
 #include "Common/Core/TrackSelectionDefaults.h"
-#include "PWGCF/FemtoDream/Core/femtoDreamObjectSelection.h"
-#include "ReconstructionDataFormats/PID.h"
+#include "Common/DataModel/PIDResponse.h"
+#include "Common/DataModel/PIDResponseITS.h"
+#include "Common/DataModel/TrackSelectionTables.h"
+
 #include "Framework/HistogramRegistry.h"
+#include "ReconstructionDataFormats/PID.h"
+
+#include <cmath>
+#include <iostream>
+#include <string>
+#include <vector>
 
 using namespace o2::framework;
+using namespace o2::analysis::femtoDream::femtoDreamSelection;
 
 namespace o2::analysis::femtoDream
 {
@@ -301,8 +304,6 @@ class FemtoDreamTrackSelection : public FemtoDreamObjectSelection<float, femtoDr
                                                                           "Maximal DCA_z (cm)",
                                                                           "Minimal DCA (cm)",
                                                                           "Maximal PID (nSigma)"}; ///< Helper information for the different selections
-  static constexpr int kNcutStages = 2;
-  static constexpr std::string_view mCutStage[kNcutStages] = {"BeforeSel", "AfterSel"};
 }; // namespace femtoDream
 
 template <o2::aod::femtodreamparticle::ParticleType part, o2::aod::femtodreamparticle::TrackType tracktype, typename cutContainerType>
diff --git a/PWGCF/FemtoDream/Core/femtoDreamUtils.h b/PWGCF/FemtoDream/Core/femtoDreamUtils.h
index f9bb60633f3..3030a1b45ef 100644
--- a/PWGCF/FemtoDream/Core/femtoDreamUtils.h
+++ b/PWGCF/FemtoDream/Core/femtoDreamUtils.h
@@ -16,11 +16,13 @@
 #ifndef PWGCF_FEMTODREAM_CORE_FEMTODREAMUTILS_H_
 #define PWGCF_FEMTODREAM_CORE_FEMTODREAMUTILS_H_
 
-#include <vector>
-#include <string>
-#include "CommonConstants/PhysicsConstants.h"
 #include "PWGCF/DataModel/FemtoDerived.h"
 
+#include "CommonConstants/PhysicsConstants.h"
+
+#include <string>
+#include <vector>
+
 namespace o2::analysis::femtoDream
 {
 
@@ -67,8 +69,12 @@ inline float getMass(int pdgCode)
     case o2::constants::physics::Pdg::kHelium3:
       mass = o2::constants::physics::MassHelium3;
       break;
+    // case o2::constants::physics::Pdg::kOmegaMinus:
+    case kOmegaMinus:
+      mass = o2::constants::physics::MassOmegaMinus;
+      break;
     default:
-      LOG(fatal) << "PDG code is not suppored";
+      LOG(fatal) << "PDG code is not supported";
   }
   return mass;
 }
diff --git a/PWGCF/FemtoDream/Core/femtoDreamV0Selection.h b/PWGCF/FemtoDream/Core/femtoDreamV0Selection.h
index 40158105a5b..3cd52ebd219 100644
--- a/PWGCF/FemtoDream/Core/femtoDreamV0Selection.h
+++ b/PWGCF/FemtoDream/Core/femtoDreamV0Selection.h
@@ -18,19 +18,21 @@
 #ifndef PWGCF_FEMTODREAM_CORE_FEMTODREAMV0SELECTION_H_
 #define PWGCF_FEMTODREAM_CORE_FEMTODREAMV0SELECTION_H_
 
-#include <iostream>
-#include <string>
-#include <vector>
-
 #include "PWGCF/FemtoDream/Core/femtoDreamObjectSelection.h"
 #include "PWGCF/FemtoDream/Core/femtoDreamSelection.h"
 #include "PWGCF/FemtoDream/Core/femtoDreamTrackSelection.h"
 
 #include "Common/Core/RecoDecay.h"
+
 #include "Framework/HistogramRegistry.h"
 #include "ReconstructionDataFormats/PID.h"
 
+#include <iostream>
+#include <string>
+#include <vector>
+
 using namespace o2::framework;
+using namespace o2::analysis::femtoDream::femtoDreamSelection;
 
 namespace o2::analysis::femtoDream
 {
@@ -91,7 +93,8 @@ class FemtoDreamV0Selection
                                                   T const& posTrack,
                                                   T const& negTrack);
 
-  template <o2::aod::femtodreamparticle::ParticleType part,
+  template <int cutstage,
+            o2::aod::femtodreamparticle::ParticleType part,
             o2::aod::femtodreamparticle::ParticleType daugh, typename C,
             typename V, typename T>
   void fillQA(C const& col, V const& v0, T const& posTrack, T const& negTrack);
@@ -296,43 +299,46 @@ void FemtoDreamV0Selection::init(HistogramRegistry* QAregistry, HistogramRegistr
       LOG(fatal) << "FemtoDreamV0Cuts: Number of selections to large for your "
                     "container - quitting!";
     }
-    std::string folderName = static_cast<std::string>(
-      o2::aod::femtodreamparticle::ParticleTypeName[part]);
-    /// \todo initialize histograms for children tracks of v0s
-    mQAHistogramRegistry->add((folderName + "/hPt").c_str(),
-                              "; #it{p}_{T} (GeV/#it{c}); Entries", kTH1F,
-                              {{1000, 0, 10}});
-    mQAHistogramRegistry->add((folderName + "/hEta").c_str(), "; #eta; Entries",
-                              kTH1F, {{1000, -1, 1}});
-    mQAHistogramRegistry->add((folderName + "/hPhi").c_str(), "; #phi; Entries",
-                              kTH1F, {{1000, 0, 2. * M_PI}});
-    mQAHistogramRegistry->add((folderName + "/hDaughDCA").c_str(),
-                              "; DCA^{daugh} (cm); Entries", kTH1F,
-                              {{1000, 0, 10}});
-    mQAHistogramRegistry->add((folderName + "/hTransRadius").c_str(),
-                              "; #it{r}_{xy} (cm); Entries", kTH1F,
-                              {{1500, 0, 150}});
-    mQAHistogramRegistry->add((folderName + "/hDecayVtxX").c_str(),
-                              "; #it{Vtx}_{x} (cm); Entries", kTH1F,
-                              {{2000, 0, 200}});
-    mQAHistogramRegistry->add((folderName + "/hDecayVtxY").c_str(),
-                              "; #it{Vtx}_{y} (cm)); Entries", kTH1F,
-                              {{2000, 0, 200}});
-    mQAHistogramRegistry->add((folderName + "/hDecayVtxZ").c_str(),
-                              "; #it{Vtx}_{z} (cm); Entries", kTH1F,
-                              {{2000, 0, 200}});
-    mQAHistogramRegistry->add((folderName + "/hCPA").c_str(),
-                              "; #it{cos #theta_{p}}; Entries", kTH1F,
-                              {{1000, 0.9, 1.}});
-    mQAHistogramRegistry->add((folderName + "/hCPAvsPt").c_str(),
-                              "; #it{p}_{T} (GeV/#it{c}); #it{cos #theta_{p}}",
-                              kTH2F, {{8, 0.3, 4.3}, {1000, 0.9, 1.}});
-    mQAHistogramRegistry->add((folderName + "/hInvMassLambda").c_str(), "", kTH1F,
-                              {massAxisLambda});
-    mQAHistogramRegistry->add((folderName + "/hInvMassAntiLambda").c_str(), "",
-                              kTH1F, {massAxisAntiLambda});
-    mQAHistogramRegistry->add((folderName + "/hInvMassLambdaAntiLambda").c_str(),
-                              "", kTH2F, {massAxisLambda, massAxisAntiLambda});
+    for (int istage = 0; istage < kNcutStages; istage++) {
+      std::string folderName =
+        static_cast<std::string>(o2::aod::femtodreamparticle::ParticleTypeName[part]) + "/" +
+        static_cast<std::string>(mCutStage[istage]);
+      /// \todo initialize histograms for children tracks of v0s
+      mQAHistogramRegistry->add((folderName + "/hPt").c_str(),
+                                "; #it{p}_{T} (GeV/#it{c}); Entries", kTH1F,
+                                {{1000, 0, 10}});
+      mQAHistogramRegistry->add((folderName + "/hEta").c_str(), "; #eta; Entries",
+                                kTH1F, {{1000, -1, 1}});
+      mQAHistogramRegistry->add((folderName + "/hPhi").c_str(), "; #phi; Entries",
+                                kTH1F, {{1000, 0, 2. * M_PI}});
+      mQAHistogramRegistry->add((folderName + "/hDaughDCA").c_str(),
+                                "; DCA^{daugh} (cm); Entries", kTH1F,
+                                {{1000, 0, 10}});
+      mQAHistogramRegistry->add((folderName + "/hTransRadius").c_str(),
+                                "; #it{r}_{xy} (cm); Entries", kTH1F,
+                                {{1500, 0, 150}});
+      mQAHistogramRegistry->add((folderName + "/hDecayVtxX").c_str(),
+                                "; #it{Vtx}_{x} (cm); Entries", kTH1F,
+                                {{2000, 0, 200}});
+      mQAHistogramRegistry->add((folderName + "/hDecayVtxY").c_str(),
+                                "; #it{Vtx}_{y} (cm)); Entries", kTH1F,
+                                {{2000, 0, 200}});
+      mQAHistogramRegistry->add((folderName + "/hDecayVtxZ").c_str(),
+                                "; #it{Vtx}_{z} (cm); Entries", kTH1F,
+                                {{2000, 0, 200}});
+      mQAHistogramRegistry->add((folderName + "/hCPA").c_str(),
+                                "; #it{cos #theta_{p}}; Entries", kTH1F,
+                                {{1000, 0.9, 1.}});
+      mQAHistogramRegistry->add((folderName + "/hCPAvsPt").c_str(),
+                                "; #it{p}_{T} (GeV/#it{c}); #it{cos #theta_{p}}",
+                                kTH2F, {{8, 0.3, 4.3}, {1000, 0.9, 1.}});
+      mQAHistogramRegistry->add((folderName + "/hInvMassLambda").c_str(), "", kTH1F,
+                                {massAxisLambda});
+      mQAHistogramRegistry->add((folderName + "/hInvMassAntiLambda").c_str(), "",
+                                kTH1F, {massAxisAntiLambda});
+      mQAHistogramRegistry->add((folderName + "/hInvMassLambdaAntiLambda").c_str(),
+                                "", kTH2F, {massAxisLambda, massAxisAntiLambda});
+    }
 
     PosDaughTrack.init<aod::femtodreamparticle::ParticleType::kV0Child,
                        aod::femtodreamparticle::TrackType::kPosChild,
@@ -636,7 +642,8 @@ std::array<cutContainerType, 5>
     outputNegTrack.at(femtoDreamTrackSelection::TrackContainerPosition::kPID)};
 }
 
-template <o2::aod::femtodreamparticle::ParticleType part,
+template <int cutstage,
+          o2::aod::femtodreamparticle::ParticleType part,
           o2::aod::femtodreamparticle::ParticleType daugh, typename C,
           typename V, typename T>
 void FemtoDreamV0Selection::fillQA(C const& /*col*/, V const& v0, T const& posTrack,
@@ -645,62 +652,62 @@ void FemtoDreamV0Selection::fillQA(C const& /*col*/, V const& v0, T const& posTr
   if (mQAHistogramRegistry) {
     mQAHistogramRegistry->fill(
       HIST(o2::aod::femtodreamparticle::ParticleTypeName[part]) +
-        HIST("/hPt"),
+        HIST("/") + HIST(mCutStage[cutstage]) + HIST("/hPt"),
       v0.pt());
     mQAHistogramRegistry->fill(
       HIST(o2::aod::femtodreamparticle::ParticleTypeName[part]) +
-        HIST("/hEta"),
+        HIST("/") + HIST(mCutStage[cutstage]) + HIST("/hEta"),
       v0.eta());
     mQAHistogramRegistry->fill(
       HIST(o2::aod::femtodreamparticle::ParticleTypeName[part]) +
-        HIST("/hPhi"),
+        HIST("/") + HIST(mCutStage[cutstage]) + HIST("/hPhi"),
       v0.phi());
     mQAHistogramRegistry->fill(
       HIST(o2::aod::femtodreamparticle::ParticleTypeName[part]) +
-        HIST("/hDaughDCA"),
+        HIST("/") + HIST(mCutStage[cutstage]) + HIST("/hDaughDCA"),
       v0.dcaV0daughters());
     mQAHistogramRegistry->fill(
       HIST(o2::aod::femtodreamparticle::ParticleTypeName[part]) +
-        HIST("/hTransRadius"),
+        HIST("/") + HIST(mCutStage[cutstage]) + HIST("/hTransRadius"),
       v0.v0radius());
     mQAHistogramRegistry->fill(
       HIST(o2::aod::femtodreamparticle::ParticleTypeName[part]) +
-        HIST("/hDecayVtxX"),
+        HIST("/") + HIST(mCutStage[cutstage]) + HIST("/hDecayVtxX"),
       v0.x());
     mQAHistogramRegistry->fill(
       HIST(o2::aod::femtodreamparticle::ParticleTypeName[part]) +
-        HIST("/hDecayVtxY"),
+        HIST("/") + HIST(mCutStage[cutstage]) + HIST("/hDecayVtxY"),
       v0.y());
     mQAHistogramRegistry->fill(
       HIST(o2::aod::femtodreamparticle::ParticleTypeName[part]) +
-        HIST("/hDecayVtxZ"),
+        HIST("/") + HIST(mCutStage[cutstage]) + HIST("/hDecayVtxZ"),
       v0.z());
     mQAHistogramRegistry->fill(
       HIST(o2::aod::femtodreamparticle::ParticleTypeName[part]) +
-        HIST("/hCPA"),
+        HIST("/") + HIST(mCutStage[cutstage]) + HIST("/hCPA"),
       v0.v0cosPA());
     mQAHistogramRegistry->fill(
       HIST(o2::aod::femtodreamparticle::ParticleTypeName[part]) +
-        HIST("/hCPAvsPt"),
+        HIST("/") + HIST(mCutStage[cutstage]) + HIST("/hCPAvsPt"),
       v0.pt(), v0.v0cosPA());
     mQAHistogramRegistry->fill(
       HIST(o2::aod::femtodreamparticle::ParticleTypeName[part]) +
-        HIST("/hInvMassLambda"),
+        HIST("/") + HIST(mCutStage[cutstage]) + HIST("/hInvMassLambda"),
       v0.mLambda());
     mQAHistogramRegistry->fill(
       HIST(o2::aod::femtodreamparticle::ParticleTypeName[part]) +
-        HIST("/hInvMassAntiLambda"),
+        HIST("/") + HIST(mCutStage[cutstage]) + HIST("/hInvMassAntiLambda"),
       v0.mAntiLambda());
     mQAHistogramRegistry->fill(
       HIST(o2::aod::femtodreamparticle::ParticleTypeName[part]) +
-        HIST("/hInvMassLambdaAntiLambda"),
+        HIST("/") + HIST(mCutStage[cutstage]) + HIST("/hInvMassLambdaAntiLambda"),
       v0.mLambda(), v0.mAntiLambda());
   }
 
   PosDaughTrack.fillQA<aod::femtodreamparticle::ParticleType::kV0Child,
-                       aod::femtodreamparticle::TrackType::kPosChild>(posTrack);
+                       aod::femtodreamparticle::TrackType::kPosChild, cutstage>(posTrack);
   NegDaughTrack.fillQA<aod::femtodreamparticle::ParticleType::kV0Child,
-                       aod::femtodreamparticle::TrackType::kNegChild>(negTrack);
+                       aod::femtodreamparticle::TrackType::kNegChild, cutstage>(negTrack);
 }
 
 } // namespace o2::analysis::femtoDream
diff --git a/PWGCF/FemtoDream/TableProducer/CMakeLists.txt b/PWGCF/FemtoDream/TableProducer/CMakeLists.txt
index 3af1c541683..6085904e73e 100644
--- a/PWGCF/FemtoDream/TableProducer/CMakeLists.txt
+++ b/PWGCF/FemtoDream/TableProducer/CMakeLists.txt
@@ -22,4 +22,4 @@ o2physics_add_dpl_workflow(femtodream-producer-reduced
 o2physics_add_dpl_workflow(femtodream-producer-for-specific-analysis
           SOURCES femtoDreamProducerTaskForSpecificAnalysis.cxx
           PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore
-          COMPONENT_NAME Analysis)
+          COMPONENT_NAME Analysis)
\ No newline at end of file
diff --git a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx
index f311518c56b..2103cf6f305 100644
--- a/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx
+++ b/PWGCF/FemtoDream/TableProducer/femtoDreamProducerTask.cxx
@@ -131,6 +131,7 @@ struct femtoDreamProducerTask {
   Configurable<bool> ConfEvtAddOfflineCheck{"ConfEvtAddOfflineCheck", false, "Evt sel: additional checks for offline selection (not part of sel8 yet)"};
   Configurable<bool> ConfIsActivateV0{"ConfIsActivateV0", true, "Activate filling of V0 into femtodream tables"};
   Configurable<bool> ConfIsActivateReso{"ConfIsActivateReso", false, "Activate filling of sl Resonances into femtodream tables"};
+  Configurable<bool> ConfIsActivateCascade{"ConfIsActivateCascade", false, "Activate filling of Cascades into femtodream tables"};
   Configurable<float> ConfEvtMinSphericity{"ConfEvtMinSphericity", 0.0f, "Evt sel: Min. sphericity of event"};
   Configurable<float> ConfEvtSphericityPtmin{"ConfEvtSphericityPtmin", 0.0f, "Evt sel: Min. Pt for sphericity calculation"};
 
@@ -179,22 +180,72 @@ struct femtoDreamProducerTask {
   Configurable<std::vector<float>> ConfChildPIDnSigmaMax{"ConfChildPIDnSigmaMax", std::vector<float>{5.f, 4.f}, "V0 Child sel: Max. PID nSigma TPC"};
   Configurable<std::vector<int>> ConfChildPIDspecies{"ConfChildPIDspecies", std::vector<int>{o2::track::PID::Pion, o2::track::PID::Proton}, "V0 Child sel: Particles species for PID"};
 
+  FemtoDreamCascadeSelection cascadeCuts;
+  struct : o2::framework::ConfigurableGroup {
+    Configurable<float> ConfCascInvMassLowLimit{"ConfCascInvMassLowLimit", 1.2, "Lower limit of the Cascade invariant mass"};
+    Configurable<float> ConfCascInvMassUpLimit{"ConfCascInvMassUpLimit", 1.5, "Upper limit of the Cascade invariant mass"};
+    Configurable<bool> ConfCascIsSelectedOmega{"ConfCascIsSelectedOmega", false, "Select Omegas instead of Xis (invariant mass)"};
+    // Cascade
+    Configurable<std::vector<float>> ConfCascadeSign{FemtoDreamCascadeSelection::getSelectionName(femtoDreamCascadeSelection::kCascadeSign, "ConfCascade"), std::vector<float>{-1, 1}, FemtoDreamCascadeSelection::getSelectionHelper(femtoDreamCascadeSelection::kCascadeSign, "Cascade selection: ")};
+    Configurable<std::vector<float>> ConfCascadePtMin{FemtoDreamCascadeSelection::getSelectionName(femtoDreamCascadeSelection::kCascadePtMin, "ConfCascade"), std::vector<float>{0.3f, 0.4f}, FemtoDreamCascadeSelection::getSelectionHelper(femtoDreamCascadeSelection::kCascadePtMin, "Cascade selection: ")};
+    Configurable<std::vector<float>> ConfCascadePtMax{FemtoDreamCascadeSelection::getSelectionName(femtoDreamCascadeSelection::kCascadePtMax, "ConfCascade"), std::vector<float>{5.5f, 6.0f}, FemtoDreamCascadeSelection::getSelectionHelper(femtoDreamCascadeSelection::kCascadePtMax, "Cascade selection: ")};
+    Configurable<std::vector<float>> ConfCascadeEtaMax{FemtoDreamCascadeSelection::getSelectionName(femtoDreamCascadeSelection::kCascadeEtaMax, "ConfCascade"), std::vector<float>{0.8f}, FemtoDreamCascadeSelection::getSelectionHelper(femtoDreamCascadeSelection::kCascadeEtaMax, "Cascade selection: ")};
+    Configurable<std::vector<float>> ConfCascadeDCADaughMax{FemtoDreamCascadeSelection::getSelectionName(femtoDreamCascadeSelection::kCascadeDCADaughMax, "ConfCascade"), std::vector<float>{1.f, 1.2f}, FemtoDreamCascadeSelection::getSelectionHelper(femtoDreamCascadeSelection::kCascadeDCADaughMax, "Cascade selection: ")};
+    Configurable<std::vector<float>> ConfCascadeCPAMin{FemtoDreamCascadeSelection::getSelectionName(femtoDreamCascadeSelection::kCascadeCPAMin, "ConfCascade"), std::vector<float>{0.99f, 0.95f}, FemtoDreamCascadeSelection::getSelectionHelper(femtoDreamCascadeSelection::kCascadeCPAMin, "Cascade selection: ")};
+    Configurable<std::vector<float>> ConfCascadeTranRadMin{FemtoDreamCascadeSelection::getSelectionName(femtoDreamCascadeSelection::kCascadeTranRadMin, "ConfCascade"), std::vector<float>{0.2f, 0.5f}, FemtoDreamCascadeSelection::getSelectionHelper(femtoDreamCascadeSelection::kCascadeTranRadMin, "Cascade selection: ")};
+    Configurable<std::vector<float>> ConfCascadeTranRadMax{FemtoDreamCascadeSelection::getSelectionName(femtoDreamCascadeSelection::kCascadeTranRadMax, "ConfCascade"), std::vector<float>{100.f}, FemtoDreamCascadeSelection::getSelectionHelper(femtoDreamCascadeSelection::kCascadeTranRadMax, "Cascade selection: ")};
+    Configurable<std::vector<float>> ConfCascadeDecVtxMax{FemtoDreamCascadeSelection::getSelectionName(femtoDreamCascadeSelection::kCascadeDecVtxMax, "ConfCascade"), std::vector<float>{100.f}, FemtoDreamCascadeSelection::getSelectionHelper(femtoDreamCascadeSelection::kCascadeDecVtxMax, "Cascade selection: ")};
+
+    // Cascade v0 daughters
+    Configurable<std::vector<float>> ConfCascadeV0DCADaughMax{FemtoDreamCascadeSelection::getSelectionName(femtoDreamCascadeSelection::kCascadeV0DCADaughMax, "ConfCascade"), std::vector<float>{1.2f, 1.5f}, FemtoDreamCascadeSelection::getSelectionHelper(femtoDreamCascadeSelection::kCascadeV0DCADaughMax, "CascV0 selection: ")};
+    Configurable<std::vector<float>> ConfCascadeV0CPAMin{FemtoDreamCascadeSelection::getSelectionName(femtoDreamCascadeSelection::kCascadeV0CPAMin, "ConfCascade"), std::vector<float>{0.99f, 0.995f}, FemtoDreamCascadeSelection::getSelectionHelper(femtoDreamCascadeSelection::kCascadeV0CPAMin, "CascV0 selection: ")};
+    Configurable<std::vector<float>> ConfCascadeV0TranRadMin{FemtoDreamCascadeSelection::getSelectionName(femtoDreamCascadeSelection::kCascadeV0TranRadMin, "ConfCascade"), std::vector<float>{0.2f}, FemtoDreamCascadeSelection::getSelectionHelper(femtoDreamCascadeSelection::kCascadeV0TranRadMin, "CascV0 selection: ")};
+    Configurable<std::vector<float>> ConfCascadeV0TranRadMax{FemtoDreamCascadeSelection::getSelectionName(femtoDreamCascadeSelection::kCascadeV0TranRadMax, "ConfCascade"), std::vector<float>{100.f}, FemtoDreamCascadeSelection::getSelectionHelper(femtoDreamCascadeSelection::kCascadeV0TranRadMax, "CascV0 selection: ")};
+    Configurable<std::vector<float>> ConfCascadeV0DCAtoPVMin{FemtoDreamCascadeSelection::getSelectionName(femtoDreamCascadeSelection::kCascadeV0DCAtoPVMin, "ConfCascade"), std::vector<float>{100.f}, FemtoDreamCascadeSelection::getSelectionHelper(femtoDreamCascadeSelection::kCascadeV0DCAtoPVMin, "CascV0 selection: ")};
+    Configurable<std::vector<float>> ConfCascadeV0DCAtoPVMax{FemtoDreamCascadeSelection::getSelectionName(femtoDreamCascadeSelection::kCascadeV0DCAtoPVMax, "ConfCascade"), std::vector<float>{100.f}, FemtoDreamCascadeSelection::getSelectionHelper(femtoDreamCascadeSelection::kCascadeV0DCAtoPVMax, "CascV0 selection: ")};
+    Configurable<float> ConfCascV0InvMassLowLimit{"ConfCascV0InvMassLowLimit", 1.011461, "Lower limit of the Cascade invariant mass"};
+    Configurable<float> ConfCascV0InvMassUpLimit{"ConfCascV0InvMassUpLimit", 1.027461, "Upper limit of the Cascade invariant mass"};
+    // Cascade Daughter Tracks
+    Configurable<std::vector<float>> ConfCascV0ChildCharge{"ConfCascV0ChildSign", std::vector<float>{-1, 1}, "CascV0 Child sel: Charge"};
+    Configurable<std::vector<float>> ConfCascV0ChildPtMin{"ConfCascV0ChildPtMin", std::vector<float>{0.8f}, "CascV0 Child sel: min pt"};
+    Configurable<std::vector<float>> ConfCascV0ChildEtaMax{"ConfCascV0ChildEtaMax", std::vector<float>{0.8f}, "CascV0 Child sel: max eta"};
+    Configurable<std::vector<float>> ConfCascV0ChildTPCnClsMin{"ConfCascV0ChildTPCnClsMin", std::vector<float>{80.f, 70.f, 60.f}, "CascV0 Child sel: Min. nCls TPC"};
+    Configurable<std::vector<float>> ConfCascV0ChildDCAMin{"ConfCascV0ChildDCAMin", std::vector<float>{0.05f, 0.06f}, "CascV0 Child sel:  Max. DCA Daugh to PV (cm)"};
+    Configurable<std::vector<float>> ConfCascV0ChildPIDnSigmaMax{"ConfCascV0ChildPIDnSigmaMax", std::vector<float>{5.f, 4.f}, "CascV0 Child sel: Max. PID nSigma TPC"};
+    Configurable<std::vector<int>> ConfCascV0ChildPIDspecies{"ConfCascV0ChildPIDspecies", std::vector<int>{o2::track::PID::Pion, o2::track::PID::Proton}, "CascV0 Child sel: Particles species for PID"};
+    // Cascade Bachelor Track
+    Configurable<std::vector<float>> ConfCascBachelorCharge{"ConfCascBachelorSign", std::vector<float>{-1, 1}, "Cascade Bachelor sel: Charge"};
+    Configurable<std::vector<float>> ConfCascBachelorPtMin{"ConfCascBachelorPtMin", std::vector<float>{0.8f}, "Cascade Bachelor sel: min pt"};
+    Configurable<std::vector<float>> ConfCascBachelorEtaMax{"ConfCascBachelorEtaMax", std::vector<float>{0.8f}, "Cascade Bachelor sel: max eta"};
+    Configurable<std::vector<float>> ConfCascBachelorTPCnClsMin{"ConfCascBachelorTPCnClsMin", std::vector<float>{80.f, 70.f, 60.f}, "Cascade Bachelor sel: Min. nCls TPC"};
+    Configurable<std::vector<float>> ConfCascBachelorDCAMin{"ConfCascBachelorDCAMin", std::vector<float>{0.05f, 0.06f}, "Cascade Bachelor sel:  Max. DCA Daugh to PV (cm)"};
+    Configurable<std::vector<float>> ConfCascBachelorPIDnSigmaMax{"ConfCascBachelorPIDnSigmaMax", std::vector<float>{5.f, 4.f}, "Cascade Bachelor sel: Max. PID nSigma TPC"};
+    Configurable<std::vector<int>> ConfCascBachelorPIDspecies{"ConfCascBachelorPIDspecies", std::vector<int>{o2::track::PID::Pion}, "Cascade Bachelor sel: Particles species for PID"};
+
+    Configurable<bool> ConfCascRejectCompetingMass{"ConfCascRejectCompetingMass", false, "Switch on to reject Omegas (for Xi) or Xis (for Omegas)"};
+    Configurable<float> ConfCascInvCompetingMassLowLimit{"ConfCascInvCompetingMassLowLimit", 1.66, "Lower limit of the cascade invariant mass for competing mass rejection"};
+    Configurable<float> ConfCascInvCompetingMassUpLimit{"ConfCascInvCompetingMassUpLimit", 1.68, "Upper limit of the cascade invariant mass for competing mass rejection"};
+
+  } ConfCascSel;
+
   // Resonances
-  Configurable<float> ConfResoInvMassLowLimit{"ConfResoInvMassLowLimit", 1.011461, "Lower limit of the Reso invariant mass"};
-  Configurable<float> ConfResoInvMassUpLimit{"ConfResoInvMassUpLimit", 1.027461, "Upper limit of the Reso invariant mass"};
-  Configurable<std::vector<float>> ConfDaughterCharge{"ConfDaughterCharge", std::vector<float>{1, -1}, "Reso Daughter sel: Charge"};
-  Configurable<std::vector<float>> ConfDaughterEta{"ConfDaughterEta", std::vector<float>{0.8, 0.8}, "Reso Daughter sel: Eta"};         // 0.8
-  Configurable<std::vector<float>> ConfDaughterDCAxy{"ConfDaughterDCAxy", std::vector<float>{0.1, 0.1}, "Reso Daughter sel: DCAxy"};   // 0.1
-  Configurable<std::vector<float>> ConfDaughterDCAz{"ConfDaughterDCAz", std::vector<float>{0.2, 0.2}, "Reso Daughter sel: DCAz"};      // 0.2
-  Configurable<std::vector<float>> ConfDaughterNClus{"ConfDaughterNClus", std::vector<float>{80, 80}, "Reso Daughter sel: NClusters"}; // 0.2
-  Configurable<std::vector<float>> ConfDaughterNCrossed{"ConfDaughterNCrossed", std::vector<float>{70, 70}, "Reso Daughter sel: NCrossedRowss"};
-  Configurable<std::vector<float>> ConfDaughterTPCfCls{"ConfDaughterTPCfCls", std::vector<float>{0.8, 0.8}, "Reso Daughter sel: Minimum fraction of crossed rows over findable cluster"}; // 0.2
-  Configurable<std::vector<float>> ConfDaughterPtUp{"ConfDaughterPtUp", std::vector<float>{2.0, 2.0}, "Reso Daughter sel: Upper limit pT"};                                               // 2.0
-  Configurable<std::vector<float>> ConfDaughterPtLow{"ConfDaughterPtLow", std::vector<float>{0.15, 0.15}, "Reso Daughter sel: Lower limit pT"};                                           // 0.15
-  Configurable<std::vector<float>> ConfDaughterPTPCThr{"ConfDaughterPTPCThr", std::vector<float>{0.40, 0.40}, "Reso Daughter sel: momentum threshold TPC only PID, p_TPC,Thr"};           // 0.4
-  Configurable<std::vector<float>> ConfDaughterPIDnSigmaMax{"ConfDaughterPIDnSigmaMax", std::vector<float>{3.00, 3.00}, "Reso Daughter sel: Max. PID nSigma TPC"};                        // 3.0
-  Configurable<std::vector<int>> ConfDaughterPIDspecies{"ConfDaughterPIDspecies", std::vector<int>{o2::track::PID::Kaon, o2::track::PID::Kaon}, "Reso Daughter sel: Particles species for PID"};
-  Configurable<std::vector<float>> ConfDaug1Daugh2ResoMass{"ConfDaug1Daugh2ResoMass", std::vector<float>{o2::constants::physics::MassKPlus, o2::constants::physics::MassKMinus, o2::constants::physics::MassPhi}, "Masses: Daughter1 - Daughter2 - Resonance"};
+  struct : o2::framework::ConfigurableGroup {
+    Configurable<float> ConfResoInvMassLowLimit{"ConfResoInvMassLowLimit", 1.011461, "Lower limit of the Reso invariant mass"};
+    Configurable<float> ConfResoInvMassUpLimit{"ConfResoInvMassUpLimit", 1.027461, "Upper limit of the Reso invariant mass"};
+    Configurable<std::vector<float>> ConfDaughterCharge{"ConfDaughterCharge", std::vector<float>{1, -1}, "Reso Daughter sel: Charge"};
+    Configurable<std::vector<float>> ConfDaughterEta{"ConfDaughterEta", std::vector<float>{0.8, 0.8}, "Reso Daughter sel: Eta"};         // 0.8
+    Configurable<std::vector<float>> ConfDaughterDCAxy{"ConfDaughterDCAxy", std::vector<float>{0.1, 0.1}, "Reso Daughter sel: DCAxy"};   // 0.1
+    Configurable<std::vector<float>> ConfDaughterDCAz{"ConfDaughterDCAz", std::vector<float>{0.2, 0.2}, "Reso Daughter sel: DCAz"};      // 0.2
+    Configurable<std::vector<float>> ConfDaughterNClus{"ConfDaughterNClus", std::vector<float>{80, 80}, "Reso Daughter sel: NClusters"}; // 0.2
+    Configurable<std::vector<float>> ConfDaughterNCrossed{"ConfDaughterNCrossed", std::vector<float>{70, 70}, "Reso Daughter sel: NCrossedRowss"};
+    Configurable<std::vector<float>> ConfDaughterTPCfCls{"ConfDaughterTPCfCls", std::vector<float>{0.8, 0.8}, "Reso Daughter sel: Minimum fraction of crossed rows over findable cluster"}; // 0.2
+    Configurable<std::vector<float>> ConfDaughterPtUp{"ConfDaughterPtUp", std::vector<float>{2.0, 2.0}, "Reso Daughter sel: Upper limit pT"};                                               // 2.0
+    Configurable<std::vector<float>> ConfDaughterPtLow{"ConfDaughterPtLow", std::vector<float>{0.15, 0.15}, "Reso Daughter sel: Lower limit pT"};                                           // 0.15
+    Configurable<std::vector<float>> ConfDaughterPTPCThr{"ConfDaughterPTPCThr", std::vector<float>{0.40, 0.40}, "Reso Daughter sel: momentum threshold TPC only PID, p_TPC,Thr"};           // 0.4
+    Configurable<std::vector<float>> ConfDaughterPIDnSigmaMax{"ConfDaughterPIDnSigmaMax", std::vector<float>{3.00, 3.00}, "Reso Daughter sel: Max. PID nSigma TPC"};                        // 3.0
+    Configurable<std::vector<int>> ConfDaughterPIDspecies{"ConfDaughterPIDspecies", std::vector<int>{o2::track::PID::Kaon, o2::track::PID::Kaon}, "Reso Daughter sel: Particles species for PID"};
+    Configurable<std::vector<float>> ConfDaug1Daugh2ResoMass{"ConfDaug1Daugh2ResoMass", std::vector<float>{o2::constants::physics::MassKPlus, o2::constants::physics::MassKMinus, o2::constants::physics::MassPhi}, "Masses: Daughter1 - Daughter2 - Resonance"};
+  } ConfResoSel;
 
   /// \todo should we add filter on min value pT/eta of V0 and daughters?
   /*Filter v0Filter = (nabs(aod::v0data::x) < V0DecVtxMax.value) &&
@@ -223,6 +274,7 @@ struct femtoDreamProducerTask {
   HistogramRegistry TrackRegistry{"Tracks", {}, OutputObjHandlingPolicy::AnalysisObject};
   HistogramRegistry V0Registry{"V0", {}, OutputObjHandlingPolicy::AnalysisObject};
   HistogramRegistry ResoRegistry{"Reso", {}, OutputObjHandlingPolicy::AnalysisObject};
+  HistogramRegistry CascadeRegistry{"Cascade", {}, OutputObjHandlingPolicy::AnalysisObject};
 
   int mRunNumber;
   float mMagField;
@@ -250,6 +302,7 @@ struct femtoDreamProducerTask {
     TrackRegistry.add("AnalysisQA/Mother", "; Bit; Entries", kTH1F, {{4000, -4000, 4000}});
     TrackRegistry.add("AnalysisQA/Particle", "; Bit; Entries", kTH1F, {{4000, -4000, 4000}});
     V0Registry.add("AnalysisQA/CutCounter", "; Bit; Counter", kTH1F, {{CutBits + 1, -0.5, CutBits + 0.5}});
+    CascadeRegistry.add("AnalysisQA/CutCounter", "; Bit; Counter", kTH1F, {{CutBits + 1, -0.5, CutBits + 0.5}});
     ResoRegistry.add("AnalysisQA/Reso/InvMass", "Invariant mass V0s;M_{KK};Entries", HistType::kTH1F, {{7000, 0.8, 1.5}});
     ResoRegistry.add("AnalysisQA/Reso/InvMass_selected", "Invariant mass V0s;M_{KK};Entries", HistType::kTH1F, {{7000, 0.8, 1.5}});
     ResoRegistry.add("AnalysisQA/Reso/Daughter1/Pt", "Transverse momentum of all processed tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{1000, 0, 10}});
@@ -333,6 +386,58 @@ struct femtoDreamProducerTask {
         v0Cuts.setKaonInvMassLimits(ConfV0InvKaonMassLowLimit, ConfV0InvKaonMassUpLimit);
       }
     }
+    if (ConfIsActivateCascade) {
+      // Cascades
+      cascadeCuts.setSelection(ConfCascSel.ConfCascadeSign, femtoDreamCascadeSelection::kCascadeSign, FemtoDreamCascadeSelection::getSelectionType(femtoDreamCascadeSelection::kCascadeSign));
+      cascadeCuts.setSelection(ConfCascSel.ConfCascadePtMin, femtoDreamCascadeSelection::kCascadePtMin, FemtoDreamCascadeSelection::getSelectionType(femtoDreamCascadeSelection::kCascadePtMin));
+      cascadeCuts.setSelection(ConfCascSel.ConfCascadePtMax, femtoDreamCascadeSelection::kCascadePtMax, FemtoDreamCascadeSelection::getSelectionType(femtoDreamCascadeSelection::kCascadePtMax));
+      cascadeCuts.setSelection(ConfCascSel.ConfCascadeEtaMax, femtoDreamCascadeSelection::kCascadeEtaMax, FemtoDreamCascadeSelection::getSelectionType(femtoDreamCascadeSelection::kCascadeEtaMax));
+      cascadeCuts.setSelection(ConfCascSel.ConfCascadeDCADaughMax, femtoDreamCascadeSelection::kCascadeDCADaughMax, FemtoDreamCascadeSelection::getSelectionType(femtoDreamCascadeSelection::kCascadeDCADaughMax));
+      cascadeCuts.setSelection(ConfCascSel.ConfCascadeCPAMin, femtoDreamCascadeSelection::kCascadeCPAMin, FemtoDreamCascadeSelection::getSelectionType(femtoDreamCascadeSelection::kCascadeCPAMin));
+      cascadeCuts.setSelection(ConfCascSel.ConfCascadeTranRadMin, femtoDreamCascadeSelection::kCascadeTranRadMin, FemtoDreamCascadeSelection::getSelectionType(femtoDreamCascadeSelection::kCascadeTranRadMin));
+      cascadeCuts.setSelection(ConfCascSel.ConfCascadeTranRadMax, femtoDreamCascadeSelection::kCascadeTranRadMax, FemtoDreamCascadeSelection::getSelectionType(femtoDreamCascadeSelection::kCascadeTranRadMax));
+      cascadeCuts.setSelection(ConfCascSel.ConfCascadeDecVtxMax, femtoDreamCascadeSelection::kCascadeDecVtxMax, FemtoDreamCascadeSelection::getSelectionType(femtoDreamCascadeSelection::kCascadeDecVtxMax));
+      // Cascade v0
+      cascadeCuts.setSelection(ConfCascSel.ConfCascadeV0DCADaughMax, femtoDreamCascadeSelection::kCascadeV0DCADaughMax, FemtoDreamCascadeSelection::getSelectionType(femtoDreamCascadeSelection::kCascadeV0DCADaughMax));
+      cascadeCuts.setSelection(ConfCascSel.ConfCascadeV0CPAMin, femtoDreamCascadeSelection::kCascadeV0CPAMin, FemtoDreamCascadeSelection::getSelectionType(femtoDreamCascadeSelection::kCascadeV0CPAMin));
+      cascadeCuts.setSelection(ConfCascSel.ConfCascadeV0TranRadMin, femtoDreamCascadeSelection::kCascadeV0TranRadMin, FemtoDreamCascadeSelection::getSelectionType(femtoDreamCascadeSelection::kCascadeV0TranRadMin));
+      cascadeCuts.setSelection(ConfCascSel.ConfCascadeV0TranRadMax, femtoDreamCascadeSelection::kCascadeV0TranRadMax, FemtoDreamCascadeSelection::getSelectionType(femtoDreamCascadeSelection::kCascadeV0TranRadMax));
+      cascadeCuts.setSelection(ConfCascSel.ConfCascadeV0DCAtoPVMin, femtoDreamCascadeSelection::kCascadeV0DCAtoPVMin, FemtoDreamCascadeSelection::getSelectionType(femtoDreamCascadeSelection::kCascadeV0DCAtoPVMin));
+      cascadeCuts.setSelection(ConfCascSel.ConfCascadeV0DCAtoPVMax, femtoDreamCascadeSelection::kCascadeV0DCAtoPVMax, FemtoDreamCascadeSelection::getSelectionType(femtoDreamCascadeSelection::kCascadeV0DCAtoPVMax));
+
+      // Cascade Daughter Tracks
+      cascadeCuts.setChildCuts(femtoDreamCascadeSelection::kPosTrack, ConfCascSel.ConfCascV0ChildCharge, femtoDreamTrackSelection::kSign, femtoDreamSelection::kEqual);
+      cascadeCuts.setChildCuts(femtoDreamCascadeSelection::kPosTrack, ConfCascSel.ConfCascV0ChildPtMin, femtoDreamTrackSelection::kpTMin, femtoDreamSelection::kLowerLimit);
+      cascadeCuts.setChildCuts(femtoDreamCascadeSelection::kPosTrack, ConfCascSel.ConfCascV0ChildEtaMax, femtoDreamTrackSelection::kEtaMax, femtoDreamSelection::kAbsUpperLimit);
+      cascadeCuts.setChildCuts(femtoDreamCascadeSelection::kPosTrack, ConfCascSel.ConfCascV0ChildTPCnClsMin, femtoDreamTrackSelection::kTPCnClsMin, femtoDreamSelection::kLowerLimit);
+      cascadeCuts.setChildCuts(femtoDreamCascadeSelection::kPosTrack, ConfCascSel.ConfCascV0ChildDCAMin, femtoDreamTrackSelection::kDCAMin, femtoDreamSelection::kAbsLowerLimit);
+      cascadeCuts.setChildCuts(femtoDreamCascadeSelection::kPosTrack, ConfCascSel.ConfCascV0ChildPIDnSigmaMax, femtoDreamTrackSelection::kPIDnSigmaMax, femtoDreamSelection::kAbsUpperLimit);
+      cascadeCuts.setChildPIDSpecies(femtoDreamCascadeSelection::kPosTrack, ConfCascSel.ConfCascV0ChildPIDspecies);
+
+      cascadeCuts.setChildCuts(femtoDreamCascadeSelection::kNegTrack, ConfCascSel.ConfCascV0ChildCharge, femtoDreamTrackSelection::kSign, femtoDreamSelection::kEqual);
+      cascadeCuts.setChildCuts(femtoDreamCascadeSelection::kNegTrack, ConfCascSel.ConfCascV0ChildPtMin, femtoDreamTrackSelection::kpTMin, femtoDreamSelection::kLowerLimit);
+      cascadeCuts.setChildCuts(femtoDreamCascadeSelection::kNegTrack, ConfCascSel.ConfCascV0ChildEtaMax, femtoDreamTrackSelection::kEtaMax, femtoDreamSelection::kAbsUpperLimit);
+      cascadeCuts.setChildCuts(femtoDreamCascadeSelection::kNegTrack, ConfCascSel.ConfCascV0ChildTPCnClsMin, femtoDreamTrackSelection::kTPCnClsMin, femtoDreamSelection::kLowerLimit);
+      cascadeCuts.setChildCuts(femtoDreamCascadeSelection::kNegTrack, ConfCascSel.ConfCascV0ChildDCAMin, femtoDreamTrackSelection::kDCAMin, femtoDreamSelection::kAbsLowerLimit);
+      cascadeCuts.setChildCuts(femtoDreamCascadeSelection::kNegTrack, ConfCascSel.ConfCascV0ChildPIDnSigmaMax, femtoDreamTrackSelection::kPIDnSigmaMax, femtoDreamSelection::kAbsUpperLimit);
+      cascadeCuts.setChildPIDSpecies(femtoDreamCascadeSelection::kNegTrack, ConfCascSel.ConfCascV0ChildPIDspecies);
+
+      // Cascade Bachelor Track
+      cascadeCuts.setChildCuts(femtoDreamCascadeSelection::kBachTrack, ConfCascSel.ConfCascBachelorCharge, femtoDreamTrackSelection::kSign, femtoDreamSelection::kEqual);
+      cascadeCuts.setChildCuts(femtoDreamCascadeSelection::kBachTrack, ConfCascSel.ConfCascBachelorPtMin, femtoDreamTrackSelection::kpTMin, femtoDreamSelection::kLowerLimit);
+      cascadeCuts.setChildCuts(femtoDreamCascadeSelection::kBachTrack, ConfCascSel.ConfCascBachelorEtaMax, femtoDreamTrackSelection::kEtaMax, femtoDreamSelection::kAbsUpperLimit);
+      cascadeCuts.setChildCuts(femtoDreamCascadeSelection::kBachTrack, ConfCascSel.ConfCascBachelorTPCnClsMin, femtoDreamTrackSelection::kTPCnClsMin, femtoDreamSelection::kLowerLimit);
+      cascadeCuts.setChildCuts(femtoDreamCascadeSelection::kBachTrack, ConfCascSel.ConfCascBachelorDCAMin, femtoDreamTrackSelection::kDCAMin, femtoDreamSelection::kAbsLowerLimit);
+      cascadeCuts.setChildCuts(femtoDreamCascadeSelection::kBachTrack, ConfCascSel.ConfCascBachelorPIDnSigmaMax, femtoDreamTrackSelection::kPIDnSigmaMax, femtoDreamSelection::kAbsUpperLimit);
+      cascadeCuts.setChildPIDSpecies(femtoDreamCascadeSelection::kBachTrack, ConfCascSel.ConfCascBachelorPIDspecies);
+
+      cascadeCuts.init<aod::femtodreamparticle::ParticleType::kCascade, aod::femtodreamparticle::ParticleType::kCascadeV0Child, aod::femtodreamparticle::ParticleType::kCascadeBachelor, aod::femtodreamparticle::cutContainerType>(&qaRegistry, &CascadeRegistry, ConfCascSel.ConfCascIsSelectedOmega);
+      cascadeCuts.setInvMassLimits(ConfCascSel.ConfCascInvMassLowLimit, ConfCascSel.ConfCascInvMassUpLimit);
+      cascadeCuts.setV0InvMassLimits(ConfCascSel.ConfCascV0InvMassLowLimit, ConfCascSel.ConfCascV0InvMassUpLimit);
+      if (ConfCascSel.ConfCascRejectCompetingMass) {
+        cascadeCuts.setCompetingInvMassLimits(ConfCascSel.ConfCascInvCompetingMassLowLimit, ConfCascSel.ConfCascInvCompetingMassUpLimit);
+      }
+    }
 
     mRunNumber = 0;
     mMagField = 0.0;
@@ -474,6 +579,29 @@ struct femtoDreamProducerTask {
     }
   }
 
+  template <typename ParticleType, typename CollisionType>
+  void fillDebugCascade(ParticleType const& cascade, CollisionType const& col)
+  {
+    outputDebugParts(cascade.sign(),                                                // sign
+                     -999., -999., -999., -999., -999., -999., -999., -999., -999., // track properties (DCA, NCls, crossed rows, etc.)
+                     -999., -999., -999., -999., -999., -999., -999., -999.,        // TPC PID (TPC signal + particle hypothesis)
+                     -999., -999., -999., -999., -999., -999., -999.,               // TOF PID
+                     -999., -999., -999., -999., -999., -999., -999., -999.,        // ITS PID
+                     cascade.dcaV0daughters(),
+                     cascade.v0radius(),
+                     -999., // DecVtxV0 x
+                     -999., // DecVtxV0 y
+                     -999., // DecVtxV0 z
+                     -999., // mKaon
+                     cascade.dcav0topv(col.posX(), col.posY(), col.posZ()),
+                     cascade.dcacascdaughters(),
+                     cascade.cascradius(),
+                     cascade.x(),
+                     cascade.y(),
+                     cascade.z(),
+                     cascade.mOmega()); // QA for Reso
+  }
+
   template <typename CollisionType, typename ParticleType>
   void fillMCParticle(CollisionType const& col, ParticleType const& particle, o2::aod::femtodreamparticle::ParticleType fdparttype)
   {
@@ -547,8 +675,8 @@ struct femtoDreamProducerTask {
       outputCollsMCLabels(-1);
     }
   }
-  template <bool isMC, bool hasItsPid, bool useCentrality, bool analysePbPb, typename V0Type, typename TrackType, typename TrackTypeWithItsPid, typename CollisionType>
-  void fillCollisionsAndTracksAndV0(CollisionType const& col, TrackType const& tracks, TrackTypeWithItsPid const& tracksWithItsPid, V0Type const& fullV0s)
+  template <bool isMC, bool hasItsPid, bool useCentrality, bool analysePbPb, typename CascadeType, typename V0Type, typename TrackType, typename TrackTypeWithItsPid, typename CollisionType>
+  void fillCollisionsAndTracksAndV0AndCascade(CollisionType const& col, TrackType const& tracks, TrackTypeWithItsPid const& tracksWithItsPid, V0Type const& fullV0s, CascadeType const& fullCascades)
   {
     // If triggering is enabled, select only events which were triggered wit our triggers
     if (ConfEnableTriggerSelection) {
@@ -585,7 +713,12 @@ struct femtoDreamProducerTask {
     if (!colCuts.isSelectedCollision(col)) {
       return;
     }
-
+    // bool emptyCollision = false;
+    if (ConfIsActivateCascade.value) {
+      if (colCuts.isEmptyCollision(col, tracks, trackCuts) && colCuts.isCollisionWithoutTrkCasc(col, fullCascades, cascadeCuts, tracks)) {
+        return;
+      }
+    }
     if (ConfIsActivateV0.value) {
       if (colCuts.isEmptyCollision(col, tracks, trackCuts) && colCuts.isEmptyCollision(col, fullV0s, v0Cuts, tracks)) {
         return;
@@ -605,14 +738,15 @@ struct femtoDreamProducerTask {
       fillMCCollision(col);
     }
 
-    std::vector<int> childIDs = {0, 0}; // these IDs are necessary to keep track of the children
-    std::vector<int> tmpIDtrack;        // this vector keeps track of the matching of the primary track table row <-> aod::track table global index
+    std::vector<int> childIDs = {0, 0};           // these IDs are necessary to keep track of the children
+    std::vector<int> cascadechildIDs = {0, 0, 0}; // these IDs are necessary to keep track of the children
+    std::vector<int> tmpIDtrack;                  // this vector keeps track of the matching of the primary track table row <-> aod::track table global index
     std::vector<typename TrackTypeWithItsPid::iterator> Daughter1, Daughter2;
 
     for (auto& track : tracksWithItsPid) {
       /// if the most open selection criteria are not fulfilled there is no
       /// point looking further at the track
-      trackCuts.fillQA<aod::femtodreamparticle::ParticleType::kTrack, aod::femtodreamparticle::TrackType::kNoChild, 0>(track);
+      trackCuts.fillQA<aod::femtodreamparticle::ParticleType::kTrack, aod::femtodreamparticle::TrackType::kNoChild, false, 0>(track);
 
       if (track.tpcChi2NCl() < OptionTrackSpecialSelections.ConfTrkMinChi2PerClusterTPC || track.tpcChi2NCl() > OptionTrackSpecialSelections.ConfTrkMaxChi2PerClusterTPC) {
         continue;
@@ -631,7 +765,7 @@ struct femtoDreamProducerTask {
       TrackRegistry.fill(HIST("AnalysisQA/Chi2ITSTPCperCluster"), track.itsChi2NCl(), track.tpcChi2NCl());
       TrackRegistry.fill(HIST("AnalysisQA/RefitITSTPC"), track.hasITS(), track.hasTPC());
 
-      trackCuts.fillQA<aod::femtodreamparticle::ParticleType::kTrack, aod::femtodreamparticle::TrackType::kNoChild, 1>(track);
+      trackCuts.fillQA<aod::femtodreamparticle::ParticleType::kTrack, aod::femtodreamparticle::TrackType::kNoChild, false, 1>(track);
       // the bit-wise container of the systematic variations is obtained
       std::array<o2::aod::femtodreamparticle::cutContainerType, 2> cutContainer;
       cutContainer = trackCuts.getCutContainer<hasItsPid, aod::femtodreamparticle::cutContainerType>(track, track.pt(), track.eta(), sqrtf(powf(track.dcaXY(), 2.f) + powf(track.dcaZ(), 2.f)));
@@ -659,9 +793,9 @@ struct femtoDreamProducerTask {
         // TO DO: change TTV0 task to apply there the strict selection and have here only loose selection
 
         // select daugher 1
-        if (track.sign() == ConfDaughterCharge.value[0] && track.pt() <= ConfDaughterPtUp.value[0] && track.pt() >= ConfDaughterPtLow.value[0] && std::abs(track.eta()) <= ConfDaughterEta.value[0] && std::abs(track.dcaXY()) <= ConfDaughterDCAxy.value[0] && std::abs(track.dcaZ()) <= ConfDaughterDCAz.value[0] && track.tpcNClsCrossedRows() >= ConfDaughterNCrossed.value[0] && track.tpcNClsFound() >= ConfDaughterNClus.value[0] && track.tpcCrossedRowsOverFindableCls() >= ConfDaughterTPCfCls.value[0]) {
-          if ((track.tpcInnerParam() < ConfDaughterPTPCThr.value[0] && std::abs(o2::aod::pidutils::tpcNSigma(ConfDaughterPIDspecies.value[0], track)) <= ConfDaughterPIDnSigmaMax.value[0]) ||
-              (track.tpcInnerParam() >= ConfDaughterPTPCThr.value[0] && std::abs(std::sqrt(o2::aod::pidutils::tpcNSigma(ConfDaughterPIDspecies.value[0], track) * o2::aod::pidutils::tpcNSigma(ConfDaughterPIDspecies.value[0], track) + o2::aod::pidutils::tofNSigma(ConfDaughterPIDspecies.value[0], track) * o2::aod::pidutils::tofNSigma(ConfDaughterPIDspecies.value[0], track))) <= ConfDaughterPIDnSigmaMax.value[0])) {
+        if (track.sign() == ConfResoSel.ConfDaughterCharge.value[0] && track.pt() <= ConfResoSel.ConfDaughterPtUp.value[0] && track.pt() >= ConfResoSel.ConfDaughterPtLow.value[0] && std::abs(track.eta()) <= ConfResoSel.ConfDaughterEta.value[0] && std::abs(track.dcaXY()) <= ConfResoSel.ConfDaughterDCAxy.value[0] && std::abs(track.dcaZ()) <= ConfResoSel.ConfDaughterDCAz.value[0] && track.tpcNClsCrossedRows() >= ConfResoSel.ConfDaughterNCrossed.value[0] && track.tpcNClsFound() >= ConfResoSel.ConfDaughterNClus.value[0] && track.tpcCrossedRowsOverFindableCls() >= ConfResoSel.ConfDaughterTPCfCls.value[0]) {
+          if ((track.tpcInnerParam() < ConfResoSel.ConfDaughterPTPCThr.value[0] && std::abs(o2::aod::pidutils::tpcNSigma(ConfResoSel.ConfDaughterPIDspecies.value[0], track)) <= ConfResoSel.ConfDaughterPIDnSigmaMax.value[0]) ||
+              (track.tpcInnerParam() >= ConfResoSel.ConfDaughterPTPCThr.value[0] && std::abs(std::sqrt(o2::aod::pidutils::tpcNSigma(ConfResoSel.ConfDaughterPIDspecies.value[0], track) * o2::aod::pidutils::tpcNSigma(ConfResoSel.ConfDaughterPIDspecies.value[0], track) + o2::aod::pidutils::tofNSigma(ConfResoSel.ConfDaughterPIDspecies.value[0], track) * o2::aod::pidutils::tofNSigma(ConfResoSel.ConfDaughterPIDspecies.value[0], track))) <= ConfResoSel.ConfDaughterPIDnSigmaMax.value[0])) {
             Daughter1.push_back(track);
             ResoRegistry.fill(HIST("AnalysisQA/Reso/Daughter1/Pt"), track.pt());
             ResoRegistry.fill(HIST("AnalysisQA/Reso/Daughter1/Eta"), track.eta());
@@ -669,9 +803,9 @@ struct femtoDreamProducerTask {
           }
         }
         // select daugher 2
-        if (track.sign() == ConfDaughterCharge.value[1] && track.pt() <= ConfDaughterPtUp.value[1] && track.pt() >= ConfDaughterPtLow.value[1] && std::abs(track.eta()) <= ConfDaughterEta.value[1] && std::abs(track.dcaXY()) <= ConfDaughterDCAxy.value[1] && std::abs(track.dcaZ()) <= ConfDaughterDCAz.value[1] && track.tpcNClsCrossedRows() >= ConfDaughterNCrossed.value[1] && track.tpcNClsFound() >= ConfDaughterNClus.value[1] && track.tpcCrossedRowsOverFindableCls() >= ConfDaughterTPCfCls.value[1]) {
-          if ((track.tpcInnerParam() < ConfDaughterPTPCThr.value[1] && std::abs(o2::aod::pidutils::tpcNSigma(ConfDaughterPIDspecies.value[1], track)) <= ConfDaughterPIDnSigmaMax.value[1]) ||
-              (track.tpcInnerParam() >= ConfDaughterPTPCThr.value[1] && std::abs(std::sqrt(o2::aod::pidutils::tpcNSigma(ConfDaughterPIDspecies.value[1], track) * o2::aod::pidutils::tpcNSigma(ConfDaughterPIDspecies.value[1], track) + o2::aod::pidutils::tofNSigma(ConfDaughterPIDspecies.value[1], track) * o2::aod::pidutils::tofNSigma(ConfDaughterPIDspecies.value[1], track))) <= ConfDaughterPIDnSigmaMax.value[1])) {
+        if (track.sign() == ConfResoSel.ConfDaughterCharge.value[1] && track.pt() <= ConfResoSel.ConfDaughterPtUp.value[1] && track.pt() >= ConfResoSel.ConfDaughterPtLow.value[1] && std::abs(track.eta()) <= ConfResoSel.ConfDaughterEta.value[1] && std::abs(track.dcaXY()) <= ConfResoSel.ConfDaughterDCAxy.value[1] && std::abs(track.dcaZ()) <= ConfResoSel.ConfDaughterDCAz.value[1] && track.tpcNClsCrossedRows() >= ConfResoSel.ConfDaughterNCrossed.value[1] && track.tpcNClsFound() >= ConfResoSel.ConfDaughterNClus.value[1] && track.tpcCrossedRowsOverFindableCls() >= ConfResoSel.ConfDaughterTPCfCls.value[1]) {
+          if ((track.tpcInnerParam() < ConfResoSel.ConfDaughterPTPCThr.value[1] && std::abs(o2::aod::pidutils::tpcNSigma(ConfResoSel.ConfDaughterPIDspecies.value[1], track)) <= ConfResoSel.ConfDaughterPIDnSigmaMax.value[1]) ||
+              (track.tpcInnerParam() >= ConfResoSel.ConfDaughterPTPCThr.value[1] && std::abs(std::sqrt(o2::aod::pidutils::tpcNSigma(ConfResoSel.ConfDaughterPIDspecies.value[1], track) * o2::aod::pidutils::tpcNSigma(ConfResoSel.ConfDaughterPIDspecies.value[1], track) + o2::aod::pidutils::tofNSigma(ConfResoSel.ConfDaughterPIDspecies.value[1], track) * o2::aod::pidutils::tofNSigma(ConfResoSel.ConfDaughterPIDspecies.value[1], track))) <= ConfResoSel.ConfDaughterPIDnSigmaMax.value[1])) {
             Daughter2.push_back(track);
             ResoRegistry.fill(HIST("AnalysisQA/Reso/Daughter2/Pt"), track.pt());
             ResoRegistry.fill(HIST("AnalysisQA/Reso/Daughter2/Eta"), track.eta());
@@ -691,6 +825,8 @@ struct femtoDreamProducerTask {
         // const auto dcaXYpos = postrack.dcaXY();
         // const auto dcaZpos = postrack.dcaZ();
         // const auto dcapos = std::sqrt(pow(dcaXYpos, 2.) + pow(dcaZpos, 2.));
+
+        v0Cuts.fillQA<0, aod::femtodreamparticle::ParticleType::kV0, aod::femtodreamparticle::ParticleType::kV0Child>(col, v0, postrack, negtrack);
         v0Cuts.fillLambdaQA(col, v0, postrack, negtrack);
 
         if (!v0Cuts.isSelectedMinimal(col, v0, postrack, negtrack)) {
@@ -705,7 +841,7 @@ struct femtoDreamProducerTask {
         // TrackSelection::TrackCuts::kITSHits);
         // }
 
-        v0Cuts.fillQA<aod::femtodreamparticle::ParticleType::kV0, aod::femtodreamparticle::ParticleType::kV0Child>(col, v0, postrack, negtrack); ///\todo fill QA also for daughters
+        v0Cuts.fillQA<1, aod::femtodreamparticle::ParticleType::kV0, aod::femtodreamparticle::ParticleType::kV0Child>(col, v0, postrack, negtrack); ///\todo fill QA also for daughters
         auto cutContainerV0 = v0Cuts.getCutContainer<aod::femtodreamparticle::cutContainerType>(col, v0, postrack, negtrack);
 
         int postrackID = v0.posTrackId();
@@ -768,6 +904,113 @@ struct femtoDreamProducerTask {
         }
       }
     }
+    if (ConfIsActivateCascade.value) {
+      for (auto& casc : fullCascades) {
+        // get the daughter tracks
+        const auto& posTrackCasc = casc.template posTrack_as<TrackType>();
+        const auto& negTrackCasc = casc.template negTrack_as<TrackType>();
+        const auto& bachTrackCasc = casc.template bachelor_as<TrackType>();
+
+        cascadeCuts.fillQA<0, aod::femtodreamparticle::ParticleType::kCascade>(col, casc, posTrackCasc, negTrackCasc, bachTrackCasc);
+        if (!cascadeCuts.isSelectedMinimal(col, casc, posTrackCasc, negTrackCasc, bachTrackCasc)) {
+          continue;
+        }
+        cascadeCuts.fillQA<1, aod::femtodreamparticle::ParticleType::kCascade>(col, casc, posTrackCasc, negTrackCasc, bachTrackCasc);
+
+        // auto cutContainerCasc = cascadeCuts.getCutContainer<aod::femtodreamparticle::cutContainerType>(col, casc, v0daugh, posTrackCasc, negTrackCasc, bachTrackCasc);
+        auto cutContainerCasc = cascadeCuts.getCutContainer<aod::femtodreamparticle::cutContainerType>(col, casc, posTrackCasc, negTrackCasc, bachTrackCasc);
+
+        // Fill positive child
+        int poscasctrackID = casc.posTrackId();
+        int rowInPrimaryTrackTablePosCasc = -1;
+        rowInPrimaryTrackTablePosCasc = getRowDaughters(poscasctrackID, tmpIDtrack);
+        cascadechildIDs[0] = rowInPrimaryTrackTablePosCasc;
+        cascadechildIDs[1] = 0;
+        cascadechildIDs[2] = 0;
+        outputParts(outputCollision.lastIndex(),
+                    posTrackCasc.pt(),
+                    posTrackCasc.eta(),
+                    posTrackCasc.phi(),
+                    aod::femtodreamparticle::ParticleType::kCascadeV0Child,
+                    cutContainerCasc.at(femtoDreamCascadeSelection::CascadeContainerPosition::kPosCuts),
+                    cutContainerCasc.at(femtoDreamCascadeSelection::CascadeContainerPosition::kPosPID),
+                    posTrackCasc.dcaXY(),
+                    cascadechildIDs,
+                    0,
+                    0);
+        const int rowOfPosCascadeTrack = outputParts.lastIndex();
+        // TODO: include here MC filling
+        //------
+
+        // Fill negative child
+        int negcasctrackID = casc.negTrackId();
+        int rowInPrimaryTrackTableNegCasc = -1;
+        rowInPrimaryTrackTableNegCasc = getRowDaughters(negcasctrackID, tmpIDtrack);
+        cascadechildIDs[0] = 0;
+        cascadechildIDs[1] = rowInPrimaryTrackTableNegCasc;
+        cascadechildIDs[2] = 0;
+        outputParts(outputCollision.lastIndex(),
+                    negTrackCasc.pt(),
+                    negTrackCasc.eta(),
+                    negTrackCasc.phi(),
+                    aod::femtodreamparticle::ParticleType::kCascadeV0Child,
+                    cutContainerCasc.at(femtoDreamCascadeSelection::CascadeContainerPosition::kNegCuts),
+                    cutContainerCasc.at(femtoDreamCascadeSelection::CascadeContainerPosition::kNegPID),
+                    negTrackCasc.dcaXY(),
+                    cascadechildIDs,
+                    0,
+                    0);
+        const int rowOfNegCascadeTrack = outputParts.lastIndex();
+        // TODO: include here MC filling
+        //------
+
+        // Fill bachelor child
+        int bachelorcasctrackID = casc.bachelorId();
+        int rowInPrimaryTrackTableBachelorCasc = -1;
+        rowInPrimaryTrackTableBachelorCasc = getRowDaughters(bachelorcasctrackID, tmpIDtrack);
+        cascadechildIDs[0] = 0;
+        cascadechildIDs[1] = 0;
+        cascadechildIDs[2] = rowInPrimaryTrackTableBachelorCasc;
+        outputParts(outputCollision.lastIndex(),
+                    bachTrackCasc.pt(),
+                    bachTrackCasc.eta(),
+                    bachTrackCasc.phi(),
+                    aod::femtodreamparticle::ParticleType::kCascadeBachelor,
+                    cutContainerCasc.at(femtoDreamCascadeSelection::CascadeContainerPosition::kBachCuts),
+                    cutContainerCasc.at(femtoDreamCascadeSelection::CascadeContainerPosition::kBachPID),
+                    bachTrackCasc.dcaXY(),
+                    cascadechildIDs,
+                    0,
+                    0);
+        const int rowOfBachelorCascadeTrack = outputParts.lastIndex();
+        // TODO: include here MC filling
+        //------
+
+        // Fill cascades
+        float invMassCasc = ConfCascSel.ConfCascIsSelectedOmega ? casc.mOmega() : casc.mXi();
+        std::vector<int> indexCascadeChildID = {rowOfPosCascadeTrack, rowOfNegCascadeTrack, rowOfBachelorCascadeTrack};
+        outputParts(outputCollision.lastIndex(),
+                    casc.pt(),
+                    casc.eta(),
+                    casc.phi(),
+                    aod::femtodreamparticle::ParticleType::kCascade,
+                    cutContainerCasc.at(femtoDreamCascadeSelection::CascadeContainerPosition::kCascade),
+                    0,
+                    casc.casccosPA(col.posX(), col.posY(), col.posZ()),
+                    indexCascadeChildID,
+                    invMassCasc,
+                    casc.mLambda());
+        // TODO: include here MC filling
+        //------
+
+        if (ConfIsDebug.value) {
+          fillDebugParticle<true, false>(posTrackCasc);  // QA for positive daughter
+          fillDebugParticle<true, false>(negTrackCasc);  // QA for negative daughter
+          fillDebugParticle<true, false>(bachTrackCasc); // QA for negative daughter
+          fillDebugCascade(casc, col);                   // QA for Cascade
+        }
+      }
+    }
 
     if (ConfIsActivateReso.value) {
       for (std::size_t iDaug1 = 0; iDaug1 < Daughter1.size(); ++iDaug1) {
@@ -775,14 +1018,14 @@ struct femtoDreamProducerTask {
           // MC stuff is still missing, also V0 QA
           // ALSO: fix indices and other table entries which are now set to 0 as deflaut as not needed for p-p-phi cf ana
 
-          ROOT::Math::PtEtaPhiMVector tempD1(Daughter1.at(iDaug1).pt(), Daughter1.at(iDaug1).eta(), Daughter1.at(iDaug1).phi(), ConfDaug1Daugh2ResoMass.value[0]);
-          ROOT::Math::PtEtaPhiMVector tempD2(Daughter2.at(iDaug2).pt(), Daughter2.at(iDaug2).eta(), Daughter2.at(iDaug2).phi(), ConfDaug1Daugh2ResoMass.value[1]);
+          ROOT::Math::PtEtaPhiMVector tempD1(Daughter1.at(iDaug1).pt(), Daughter1.at(iDaug1).eta(), Daughter1.at(iDaug1).phi(), ConfResoSel.ConfDaug1Daugh2ResoMass.value[0]);
+          ROOT::Math::PtEtaPhiMVector tempD2(Daughter2.at(iDaug2).pt(), Daughter2.at(iDaug2).eta(), Daughter2.at(iDaug2).phi(), ConfResoSel.ConfDaug1Daugh2ResoMass.value[1]);
 
           ROOT::Math::PtEtaPhiMVector tempPhi = tempD1 + tempD2;
 
           ResoRegistry.fill(HIST("AnalysisQA/Reso/InvMass"), tempPhi.M());
 
-          if ((tempPhi.M() >= ConfResoInvMassLowLimit.value) && (tempPhi.M() <= ConfResoInvMassUpLimit.value)) {
+          if ((tempPhi.M() >= ConfResoSel.ConfResoInvMassLowLimit.value) && (tempPhi.M() <= ConfResoSel.ConfResoInvMassUpLimit.value)) {
 
             ResoRegistry.fill(HIST("AnalysisQA/Reso/InvMass_selected"), tempPhi.M());
             ResoRegistry.fill(HIST("AnalysisQA/Reso/PtD1_selected"), Daughter1.at(iDaug1).pt());
@@ -841,7 +1084,8 @@ struct femtoDreamProducerTask {
     processData(aod::FemtoFullCollision const& col,
                 aod::BCsWithTimestamps const&,
                 aod::FemtoFullTracks const& tracks,
-                o2::aod::V0Datas const& fullV0s)
+                o2::aod::V0Datas const& fullV0s,
+                o2::aod::CascDatas const& fullCascades)
   {
     // get magnetic field for run
     initCCDB_Mag_Trig(col.bc_as<aod::BCsWithTimestamps>());
@@ -849,9 +1093,9 @@ struct femtoDreamProducerTask {
     auto tracksWithItsPid = soa::Attach<aod::FemtoFullTracks, aod::pidits::ITSNSigmaEl, aod::pidits::ITSNSigmaPi, aod::pidits::ITSNSigmaKa,
                                         aod::pidits::ITSNSigmaPr, aod::pidits::ITSNSigmaDe, aod::pidits::ITSNSigmaTr, aod::pidits::ITSNSigmaHe>(tracks);
     if (ConfUseItsPid.value) {
-      fillCollisionsAndTracksAndV0<false, true, true, false>(col, tracks, tracksWithItsPid, fullV0s);
+      fillCollisionsAndTracksAndV0AndCascade<false, true, true, false>(col, tracks, tracksWithItsPid, fullV0s, fullCascades);
     } else {
-      fillCollisionsAndTracksAndV0<false, false, true, false>(col, tracks, tracks, fullV0s);
+      fillCollisionsAndTracksAndV0AndCascade<false, false, true, false>(col, tracks, tracks, fullV0s, fullCascades);
     }
   }
   PROCESS_SWITCH(femtoDreamProducerTask, processData,
@@ -861,7 +1105,8 @@ struct femtoDreamProducerTask {
     processData_noCentrality(aod::FemtoFullCollision_noCent const& col,
                              aod::BCsWithTimestamps const&,
                              aod::FemtoFullTracks const& tracks,
-                             o2::aod::V0Datas const& fullV0s)
+                             o2::aod::V0Datas const& fullV0s,
+                             o2::aod::CascDatas const& fullCascades)
   {
     // get magnetic field for run
     initCCDB_Mag_Trig(col.bc_as<aod::BCsWithTimestamps>());
@@ -869,9 +1114,9 @@ struct femtoDreamProducerTask {
     auto tracksWithItsPid = soa::Attach<aod::FemtoFullTracks, aod::pidits::ITSNSigmaEl, aod::pidits::ITSNSigmaPi, aod::pidits::ITSNSigmaKa,
                                         aod::pidits::ITSNSigmaPr, aod::pidits::ITSNSigmaDe, aod::pidits::ITSNSigmaTr, aod::pidits::ITSNSigmaHe>(tracks);
     if (ConfUseItsPid.value) {
-      fillCollisionsAndTracksAndV0<false, true, false, false>(col, tracks, tracksWithItsPid, fullV0s);
+      fillCollisionsAndTracksAndV0AndCascade<false, true, false, false>(col, tracks, tracksWithItsPid, fullV0s, fullCascades);
     } else {
-      fillCollisionsAndTracksAndV0<false, false, false, false>(col, tracks, tracks, fullV0s);
+      fillCollisionsAndTracksAndV0AndCascade<false, false, false, false>(col, tracks, tracks, fullV0s, fullCascades);
     }
   }
   PROCESS_SWITCH(femtoDreamProducerTask, processData_noCentrality,
@@ -880,7 +1125,8 @@ struct femtoDreamProducerTask {
   void processData_CentPbPb(aod::FemtoFullCollision_CentPbPb const& col,
                             aod::BCsWithTimestamps const&,
                             aod::FemtoFullTracks const& tracks,
-                            o2::aod::V0Datas const& fullV0s)
+                            o2::aod::V0Datas const& fullV0s,
+                            o2::aod::CascDatas const& fullCascades)
   {
     // get magnetic field for run
     initCCDB_Mag_Trig(col.bc_as<aod::BCsWithTimestamps>());
@@ -888,9 +1134,9 @@ struct femtoDreamProducerTask {
     auto tracksWithItsPid = soa::Attach<aod::FemtoFullTracks, aod::pidits::ITSNSigmaEl, aod::pidits::ITSNSigmaPi, aod::pidits::ITSNSigmaKa,
                                         aod::pidits::ITSNSigmaPr, aod::pidits::ITSNSigmaDe, aod::pidits::ITSNSigmaTr, aod::pidits::ITSNSigmaHe>(tracks);
     if (ConfUseItsPid.value) {
-      fillCollisionsAndTracksAndV0<false, true, true, true>(col, tracks, tracksWithItsPid, fullV0s);
+      fillCollisionsAndTracksAndV0AndCascade<false, true, true, true>(col, tracks, tracksWithItsPid, fullV0s, fullCascades);
     } else {
-      fillCollisionsAndTracksAndV0<false, false, true, true>(col, tracks, tracks, fullV0s);
+      fillCollisionsAndTracksAndV0AndCascade<false, false, true, true>(col, tracks, tracks, fullV0s, fullCascades);
     }
   }
   PROCESS_SWITCH(femtoDreamProducerTask, processData_CentPbPb,
@@ -901,12 +1147,13 @@ struct femtoDreamProducerTask {
                  soa::Join<aod::FemtoFullTracks, aod::McTrackLabels> const& tracks,
                  aod::FemtoFullMCgenCollisions const&,
                  aod::McParticles const&,
-                 soa::Join<o2::aod::V0Datas, aod::McV0Labels> const& fullV0s) /// \todo with FilteredFullV0s
+                 soa::Join<o2::aod::V0Datas, aod::McV0Labels> const& fullV0s, /// \todo with FilteredFullV0s
+                 soa::Join<o2::aod::CascDatas, aod::McCascLabels> const& fullCascades)
   {
     // get magnetic field for run
     initCCDB_Mag_Trig(col.bc_as<aod::BCsWithTimestamps>());
     // fill the tables
-    fillCollisionsAndTracksAndV0<false, false, true, false>(col, tracks, tracks, fullV0s);
+    fillCollisionsAndTracksAndV0AndCascade<false, false, true, false>(col, tracks, tracks, fullV0s, fullCascades);
   }
   PROCESS_SWITCH(femtoDreamProducerTask, processMC, "Provide MC data", false);
 
@@ -915,12 +1162,13 @@ struct femtoDreamProducerTask {
                               soa::Join<aod::FemtoFullTracks, aod::McTrackLabels> const& tracks,
                               aod::FemtoFullMCgenCollisions const&,
                               aod::McParticles const&,
-                              soa::Join<o2::aod::V0Datas, aod::McV0Labels> const& fullV0s) /// \todo with FilteredFullV0s
+                              soa::Join<o2::aod::V0Datas, aod::McV0Labels> const& fullV0s, /// \todo with FilteredFullV0s
+                              soa::Join<o2::aod::CascDatas, aod::McCascLabels> const& fullCascades)
   {
     // get magnetic field for run
     initCCDB_Mag_Trig(col.bc_as<aod::BCsWithTimestamps>());
     // fill the tables
-    fillCollisionsAndTracksAndV0<true, false, false, false>(col, tracks, tracks, fullV0s);
+    fillCollisionsAndTracksAndV0AndCascade<true, false, false, false>(col, tracks, tracks, fullV0s, fullCascades);
   }
   PROCESS_SWITCH(femtoDreamProducerTask, processMC_noCentrality, "Provide MC data without requiring a centrality calibration", false);
 
@@ -929,12 +1177,13 @@ struct femtoDreamProducerTask {
                           soa::Join<aod::FemtoFullTracks, aod::McTrackLabels> const& tracks,
                           aod::FemtoFullMCgenCollisions const&,
                           aod::McParticles const&,
-                          soa::Join<o2::aod::V0Datas, aod::McV0Labels> const& fullV0s) /// \todo with FilteredFullV0s
+                          soa::Join<o2::aod::V0Datas, aod::McV0Labels> const& fullV0s, /// \todo with FilteredFullV0s
+                          soa::Join<o2::aod::CascDatas, aod::McCascLabels> const& fullCascades)
   {
     // get magnetic field for run
     initCCDB_Mag_Trig(col.bc_as<aod::BCsWithTimestamps>());
     // fill the tables
-    fillCollisionsAndTracksAndV0<true, false, true, true>(col, tracks, tracks, fullV0s);
+    fillCollisionsAndTracksAndV0AndCascade<true, false, true, true>(col, tracks, tracks, fullV0s, fullCascades);
   }
   PROCESS_SWITCH(femtoDreamProducerTask, processMC_CentPbPb, "Provide MC data with centrality information for PbPb collisions", false);
 };
diff --git a/PWGCF/FemtoDream/Tasks/CMakeLists.txt b/PWGCF/FemtoDream/Tasks/CMakeLists.txt
index 933d50035a9..95c4f8cdaa0 100644
--- a/PWGCF/FemtoDream/Tasks/CMakeLists.txt
+++ b/PWGCF/FemtoDream/Tasks/CMakeLists.txt
@@ -29,6 +29,11 @@ o2physics_add_dpl_workflow(femtodream-pair-track-cascade
           PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore
           COMPONENT_NAME Analysis)
 
+o2physics_add_dpl_workflow(femtodream-pair-casdcade-cascade
+          SOURCES femtodreamPairCascadeCascade.cxx
+          PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore
+          COMPONENT_NAME Analysis)
+
 o2physics_add_dpl_workflow(femtodream-triplet-track-track-v0
           SOURCES femtoDreamTripletTaskTrackTrackV0.cxx
           PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore
diff --git a/PWGCF/FemtoDream/Tasks/femtodreamPairCascadeCascade.cxx b/PWGCF/FemtoDream/Tasks/femtodreamPairCascadeCascade.cxx
new file mode 100644
index 00000000000..fbf164378a1
--- /dev/null
+++ b/PWGCF/FemtoDream/Tasks/femtodreamPairCascadeCascade.cxx
@@ -0,0 +1,448 @@
+// Copyright 2019-2022 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.
+
+/// \file femtoDreamPairCascadeCascade.cxx
+/// \brief Tasks that reads the track tables used for the pairing and builds pairs of two cascades
+/// \author Andi Mathis, Anton Riedel, Georgios Mantzaridis, Oton Vazquez Doce.
+
+#include "PWGCF/DataModel/FemtoDerived.h"
+#include "PWGCF/FemtoDream/Core/femtoDreamContainer.h"
+#include "PWGCF/FemtoDream/Core/femtoDreamDetaDphiStar.h"
+#include "PWGCF/FemtoDream/Core/femtoDreamEventHisto.h"
+#include "PWGCF/FemtoDream/Core/femtoDreamPairCleaner.h"
+#include "PWGCF/FemtoDream/Core/femtoDreamParticleHisto.h"
+#include "PWGCF/FemtoDream/Core/femtoDreamUtils.h"
+
+#include "Framework/ASoAHelpers.h"
+#include "Framework/AnalysisTask.h"
+#include "Framework/Expressions.h"
+#include "Framework/HistogramRegistry.h"
+#include "Framework/RunningWorkflowInfo.h"
+#include "Framework/runDataProcessing.h"
+
+#include <sys/stat.h>
+
+#include <cstdint>
+#include <string>
+#include <vector>
+using namespace o2;
+using namespace o2::aod;
+using namespace o2::soa;
+using namespace o2::framework;
+using namespace o2::framework::expressions;
+using namespace o2::analysis::femtoDream;
+struct FemtoDreamPairCascadeCascade {
+  SliceCache cache;
+  Preslice<aod::FDParticles> perCol = aod::femtodreamparticle::fdCollisionId;
+
+  /// General options
+  struct : ConfigurableGroup {
+    std::string prefix = std::string("Option");
+    Configurable<bool> sameSpecies{"sameSpecies", false, "Set to true if particle 1 and particle 2 are the same species"};
+    Configurable<bool> isMC{"isMC", false, "Enable additional Histogramms in the case of a MonteCarlo Run"};
+    Configurable<bool> use4D{"use4D", false, "Enable four dimensional histogramms (to be used only for analysis with high statistics): k* vs multiplicity vs multiplicity percentil vs mT"};
+    Configurable<bool> extendedPlots{"extendedPlots", false, "Enable additional three dimensional histogramms. High memory consumption. Use for debugging"};
+    Configurable<float> highkstarCut{"highkstarCut", -1., "Set a cut for high k*, above which the pairs are rejected. Set it to -1 to deactivate it"};
+    Configurable<bool> cprOn{"cprOn", true, "Close Pair Rejection"};
+    Configurable<bool> cprOld{"cprOld", false, "Set to FALSE to use fixed version of CPR (for testing now, will be default soon)"};
+    Configurable<bool> cprPlotPerRadii{"cprPlotPerRadii", false, "Plot CPR per radii"};
+    Configurable<float> cprDeltaPhiMax{"cprDeltaPhiMax", 0.01, "Max. Delta Phi for Close Pair Rejection"};
+    Configurable<float> cprDeltaEtaMax{"cprDeltaEtaMax", 0.01, "Max. Delta Eta for Close Pair Rejection"};
+    Configurable<bool> dcaCutPtDep{"dcaCutPtDep", false, "Use pt dependent dca cut"};
+    Configurable<bool> mixEventWithPairs{"mixEventWithPairs", false, "Only use events that contain particle 1 and partile 2 for the event mixing"};
+    Configurable<bool> smearingByOrigin{"smearingByOrigin", false, "Obtain the smearing matrix differential in the MC origin of particle 1 and particle 2. High memory consumption. Use with care!"};
+    ConfigurableAxis dummy{"dummy", {1, 0, 1}, "dummy axis"};
+  } Option;
+
+  /// Event selection
+  struct : ConfigurableGroup {
+    std::string prefix = std::string("EventSel");
+    Configurable<int> multMin{"multMin", 0, "Minimum Multiplicity (MultNtr)"};
+    Configurable<int> multMax{"multMax", 99999, "Maximum Multiplicity (MultNtr)"};
+    Configurable<float> multPercentileMin{"multPercentileMin", 0, "Minimum Multiplicity Percentile"};
+    Configurable<float> multPercentileMax{"multPercentileMax", 100, "Maximum Multiplicity Percentile"};
+  } EventSel;
+
+  // Filter EventMultiplicity = aod::femtodreamcollision::multNtr >= EventSel.multMin && aod::femtodreamcollision::multNtr <= EventSel.multMax;
+  // Filter EventMultiplicityPercentile = aod::femtodreamcollision::multV0M >= EventSel.multPercentileMin && aod::femtodreamcollision::multV0M <= EventSel.multPercentileMax;
+
+  /// Histogramming for Event
+  FemtoDreamEventHisto eventHisto;
+  // using FilteredCollisions = soa::Filtered<FDCollisions>;
+  using FilteredCollisions = FDCollisions;
+  using FilteredCollision = FilteredCollisions::iterator;
+  using FDMCParts = soa::Join<aod::FDParticles, aod::FDMCLabels>;
+  using FDMCPart = FDMCParts::iterator;
+  femtodreamcollision::BitMaskType bitMask = 1; //???????????????????
+
+  /// Cascade 1 (Cascade)
+  struct : ConfigurableGroup {
+    std::string prefix = std::string("Cascade1");
+    Configurable<int> pdgCode{"pdgCode", 3334, "PDG code of Particle 1 (Cascade)"};
+    Configurable<femtodreamparticle::cutContainerType> cutBit{"cutBit", 5542474, "Particle 1 (Cascade) - Selection bit from cutCulator"};
+    Configurable<femtodreamparticle::cutContainerType> childPosCutBit{"childPosCutBit", 278, "Selection bit for positive child of Cascade"};
+    Configurable<femtodreamparticle::cutContainerType> childPosTPCBit{"childPosTPCBit", 1024, "PID TPC bit for positive child of Cascade"};
+    Configurable<femtodreamparticle::cutContainerType> childNegCutBit{"childNegCutBit", 277, "Selection bit for negative child of Cascade"};
+    Configurable<femtodreamparticle::cutContainerType> childNegTPCBit{"childNegTPCBit", 4096, "PID TPC bit for negative child of Cascade"};
+    Configurable<femtodreamparticle::cutContainerType> childBachCutBit{"childBachCutBit", 277, "Selection bit for bachelor child of Cascade"};
+    Configurable<femtodreamparticle::cutContainerType> childBachTPCBit{"childBachTPCBit", 64, "PID TPC bit for bachelor child of Cascade"};
+
+    Configurable<float> invMassMin{"invMassMin", 1.6, "Minimum invariant mass of Partricle 1 (Cascade)"};
+    Configurable<float> invMassMax{"invMassMax", 1.8, "Maximum invariant mass of Partricle 1 (Cascade)"};
+    Configurable<float> invMassV0DaughMin{"invMassV0DaughMin", 0., "Minimum invariant mass of the V0 Daughter"};
+    Configurable<float> invMassV0DaughMax{"invMassV0DaughMax", 999., "Maximum invariant mass of the V0 Daughter"};
+    Configurable<float> ptMin{"ptMin", 0., "Minimum pT of Particle 2 (Cascade)"};
+    Configurable<float> ptMax{"ptMax", 999., "Maximum pT of Particle 2 (Cascade)"};
+    Configurable<float> etaMin{"etaMin", -10., "Minimum eta of Particle 2 (Cascade)"};
+    Configurable<float> etaMax{"etaMax", 10., "Maximum eta of Particle 2 (Cascade)"};
+    Configurable<bool> useChildCuts{"useChildCuts", true, "Use cuts on the children of the Cascades additional to those of the selection of the cascade builder (for debugging purposes)"};
+    Configurable<bool> useChildPIDCuts{"useChildPIDCuts", true, "Use PID cuts on the children of the Cascades additional to those of the selection of the cascade builder (for debugging purposes)"};
+  } Cascade1;
+
+  /// Partition for particle 1
+  Partition<FDParticles> partitionCascade1 = (aod::femtodreamparticle::partType == uint8_t(aod::femtodreamparticle::ParticleType::kCascade)) &&
+                                             ((aod::femtodreamparticle::cut & Cascade1.cutBit) == Cascade1.cutBit) &&
+                                             (aod::femtodreamparticle::pt > Cascade1.ptMin) &&
+                                             (aod::femtodreamparticle::pt < Cascade1.ptMax) &&
+                                             (aod::femtodreamparticle::eta > Cascade1.etaMin) &&
+                                             (aod::femtodreamparticle::eta < Cascade1.etaMax) &&
+                                             (aod::femtodreamparticle::mLambda > Cascade1.invMassMin) &&
+                                             (aod::femtodreamparticle::mLambda < Cascade1.invMassMax) &&
+                                             (aod::femtodreamparticle::mAntiLambda > Cascade1.invMassV0DaughMin) &&
+                                             (aod::femtodreamparticle::mAntiLambda < Cascade1.invMassV0DaughMax);
+  /// Histogramming for particle 1
+  FemtoDreamParticleHisto<aod::femtodreamparticle::ParticleType::kCascade, 1> cascHistoPartOne;
+  FemtoDreamParticleHisto<aod::femtodreamparticle::ParticleType::kCascadeV0Child, 3> posChildHistosPartOne;
+  FemtoDreamParticleHisto<aod::femtodreamparticle::ParticleType::kCascadeV0Child, 4> negChildHistosPartOne;
+  FemtoDreamParticleHisto<aod::femtodreamparticle::ParticleType::kCascadeBachelor, 8> bachChildHistosPartOne;
+
+  /// Particle 2 (Cascade)
+  struct : ConfigurableGroup {
+    std::string prefix = std::string("Cascade2");
+    Configurable<int> pdgCode{"pdgCode", 3334, "PDG code of particle 2 (Cascade)"};
+    Configurable<femtodreamparticle::cutContainerType> cutBit{"cutBit", 32221874, "Selection bit for particle 2 (Cascade)"};
+    Configurable<femtodreamparticle::cutContainerType> childPosCutBit{"childPosCutBit", 278, "Selection bit for positive child of Cascade"};
+    Configurable<femtodreamparticle::cutContainerType> childPosTPCBit{"childPosTPCBit", 1024, "PID TPC bit for positive child of Cascade"};
+    Configurable<femtodreamparticle::cutContainerType> childNegCutBit{"childNegCutBit", 277, "Selection bit for negative child of Cascade"};
+    Configurable<femtodreamparticle::cutContainerType> childNegTPCBit{"childNegTPCBit", 4096, "PID TPC bit for negative child of Cascade"};
+    Configurable<femtodreamparticle::cutContainerType> childBachCutBit{"childBachCutBit", 277, "Selection bit for negative child of Cascade"};
+    Configurable<femtodreamparticle::cutContainerType> childBachTPCBit{"childBachTPCBit", 64, "PID TPC bit for bachelor child of Cascade"};
+    Configurable<float> invMassMin{"invMassMin", 1.2, "Minimum invariant mass of Particle 2 (Cascade)"};
+    Configurable<float> invMassMax{"invMassMax", 1.4, "Maximum invariant mass of Particle 2 (Cascade)"};
+    Configurable<float> invMassV0DaughMin{"invMassV0DaughMin", 0., "Minimum invariant mass of the V0 Daughter"};   // (???????)
+    Configurable<float> invMassV0DaughMax{"invMassV0DaughMax", 999., "Maximum invariant mass of the V0 Daughter"}; // (???????)
+    Configurable<float> ptMin{"ptMin", 0., "Minimum pT of Particle 2 (Cascade)"};
+    Configurable<float> ptMax{"ptMax", 999., "Maximum pT of Particle 2 (Cascade)"};
+    Configurable<float> etaMin{"etaMin", -10., "Minimum eta of Particle 2 (Cascade)"};
+    Configurable<float> etaMax{"etaMax", 10., "Maximum eta of Particle 2 (Cascade)"};
+    Configurable<bool> useChildCuts{"useChildCuts", true, "Use cuts on the children of the Cascades additional to those of the selection of the cascade builder (for debugging purposes)"};
+    Configurable<bool> useChildPIDCuts{"useChildPIDCuts", true, "Use PID cuts on the children of the Cascades additional to those of the selection of the cascade builder (for debugging purposes)"};
+  } Cascade2;
+
+  /// Partition for particle 2
+  Partition<FDParticles> partitionCascade2 = (aod::femtodreamparticle::partType == uint8_t(aod::femtodreamparticle::ParticleType::kCascade)) &&
+                                             ((aod::femtodreamparticle::cut & Cascade2.cutBit) == Cascade2.cutBit) &&
+                                             (aod::femtodreamparticle::pt > Cascade2.ptMin) &&
+                                             (aod::femtodreamparticle::pt < Cascade2.ptMax) &&
+                                             (aod::femtodreamparticle::eta > Cascade2.etaMin) &&
+                                             (aod::femtodreamparticle::eta < Cascade2.etaMax) &&
+                                             (aod::femtodreamparticle::mLambda > Cascade2.invMassMin) &&
+                                             (aod::femtodreamparticle::mLambda < Cascade2.invMassMax) &&
+                                             (aod::femtodreamparticle::mAntiLambda > Cascade2.invMassV0DaughMin) &&
+                                             (aod::femtodreamparticle::mAntiLambda < Cascade2.invMassV0DaughMax);
+  /// Histogramming for particle 2
+  FemtoDreamParticleHisto<aod::femtodreamparticle::ParticleType::kCascade, 2> cascHistoPartTwo;
+  FemtoDreamParticleHisto<aod::femtodreamparticle::ParticleType::kCascadeV0Child, 9> posChildHistosPartTwo;
+  FemtoDreamParticleHisto<aod::femtodreamparticle::ParticleType::kCascadeV0Child, 10> negChildHistosPartTwo;
+  FemtoDreamParticleHisto<aod::femtodreamparticle::ParticleType::kCascadeBachelor, 11> bachChildHistosPartTwo;
+
+  /// Binning configurables
+  struct : ConfigurableGroup {
+    std::string prefix = std::string("Binning");
+    ConfigurableAxis tempFitVarCascade{"tempFitVarCascade", {300, 0.9, 1}, "binning of the TempFitVar in the pT vs. TempFitVar plot (Cascade)"};
+    ConfigurableAxis tempFitVarCascadeChild{"tempFitVarCascadeChild", {300, -0.15, 0.15}, "binning of the TempFitVar in the pT vs. TempFitVar plot (Cascade child)"};
+    ConfigurableAxis invMass{"invMass", {200, 1.22, 1.42}, "invMass binning"};
+    ConfigurableAxis pTCascade{"pTCascade", {20, 0.5, 4.05}, "pT binning of the pT vs. TempFitVar plot (Cascade)"};
+    ConfigurableAxis pTCascadeChild{"pTCascadeChild", {20, 0.5, 4.05}, "pT binning of the pT vs. TempFitVar plot (Cascade)"};
+    ConfigurableAxis pT{"pT", {20, 0.5, 4.05}, "pT binning"};
+    ConfigurableAxis kstar{"kstar", {1500, 0., 6.}, "binning kstar"};
+    ConfigurableAxis kT{"kT", {150, 0., 9.}, "binning kT"};
+    ConfigurableAxis mT{"mT", {225, 0., 7.5}, "binning mT"};
+    ConfigurableAxis multTempFit{"multTempFit", {1, 0, 1}, "multiplicity for the TempFitVar plot"};
+  } Binning;
+  struct : ConfigurableGroup {
+    std::string prefix = std::string("Binning4D");
+    ConfigurableAxis kstar{"kstar", {1500, 0., 6.}, "binning kstar for the 4Dimensional plot: k* vs multiplicity vs multiplicity percentile vs mT (set <<ConfUse4D>> to true in order to use)"};
+    ConfigurableAxis mT{"mT", {VARIABLE_WIDTH, 1.02f, 1.14f, 1.20f, 1.26f, 1.38f, 1.56f, 1.86f, 4.50f}, "mT Binning for the 4Dimensional plot: k* vs multiplicity vs multiplicity percentile vs mT (set <<ConfUse4D>> to true in order to use)"};
+    ConfigurableAxis mult{"mult", {VARIABLE_WIDTH, 0.0f, 4.0f, 8.0f, 12.0f, 16.0f, 20.0f, 24.0f, 28.0f, 32.0f, 36.0f, 40.0f, 44.0f, 48.0f, 52.0f, 56.0f, 60.0f, 64.0f, 68.0f, 72.0f, 76.0f, 80.0f, 84.0f, 88.0f, 92.0f, 96.0f, 100.0f, 200.0f}, "multiplicity Binning for the 4Dimensional plot: k* vs multiplicity vs multiplicity percentile vs mT (set <<ConfUse4D>> to true in order to use)"};
+    ConfigurableAxis multPercentile{"multPercentile", {10, 0.0f, 100.0f}, "multiplicity percentile Binning for the 4Dimensional plot: k* vs multiplicity vs multiplicity percentile vs mT (set <<ConfUse4D>> to true in order to use)"};
+  } Binning4D;
+
+  // Mixing configurables
+  struct : ConfigurableGroup {
+    std::string prefix = std::string("Mixing");
+    ConfigurableAxis binMult{"binMult", {VARIABLE_WIDTH, 0.0f, 4.0f, 8.0f, 12.0f, 16.0f, 20.0f, 24.0f, 28.0f, 32.0f, 36.0f, 40.0f, 44.0f, 48.0f, 52.0f, 56.0f, 60.0f, 64.0f, 68.0f, 72.0f, 76.0f, 80.0f, 84.0f, 88.0f, 92.0f, 96.0f, 100.0f, 200.0f}, "bins - multiplicity"};
+    ConfigurableAxis binMultPercentile{"binMultPercentile", {VARIABLE_WIDTH, 0.0f, 10.0f, 20.0f, 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, 80.0f, 90.0f, 100.f}, "bins - multiplicity percentile"};
+    ConfigurableAxis binVztx{"binVztx", {VARIABLE_WIDTH, -10.0f, -8.f, -6.f, -4.f, -2.f, 0.f, 2.f, 4.f, 6.f, 8.f, 10.f}, "bins - z-vertex"};
+    Configurable<int> depth{"depth", 5, "Number of events for mixing"};
+    Configurable<int> binPolicy{"binPolicy", 0, "Binning binPolicy for mixing - 0: multiplicity, 1: multipliciy percentile, 2: both"};
+  } Mixing;
+  ColumnBinningPolicy<aod::collision::PosZ, aod::femtodreamcollision::MultNtr> colBinningMult{{Mixing.binVztx, Mixing.binMult}, true};
+  ColumnBinningPolicy<aod::collision::PosZ, aod::femtodreamcollision::MultV0M> colBinningMultPercentile{{Mixing.binVztx, Mixing.binMultPercentile}, true};
+  ColumnBinningPolicy<aod::collision::PosZ, aod::femtodreamcollision::MultNtr, aod::femtodreamcollision::MultV0M> colBinningMultMultPercentile{{Mixing.binVztx, Mixing.binMult, Mixing.binMultPercentile}, true};
+  FemtoDreamContainer<femtoDreamContainer::EventType::same, femtoDreamContainer::Observable::kstar> sameEventCont;
+  FemtoDreamContainer<femtoDreamContainer::EventType::mixed, femtoDreamContainer::Observable::kstar> mixedEventCont;
+  FemtoDreamPairCleaner<aod::femtodreamparticle::ParticleType::kCascade, aod::femtodreamparticle::ParticleType::kCascade> pairCleaner;
+  FemtoDreamDetaDphiStar<aod::femtodreamparticle::ParticleType::kCascadeV0Child, aod::femtodreamparticle::ParticleType::kCascadeV0Child> pairCloseRejectionSE;
+  FemtoDreamDetaDphiStar<aod::femtodreamparticle::ParticleType::kCascadeV0Child, aod::femtodreamparticle::ParticleType::kCascadeV0Child> pairCloseRejectionME;
+
+  static constexpr uint32_t kSignPlusMask = 1 << 1;
+
+  /// Histogram output
+  HistogramRegistry registry{"Output", {}, OutputObjHandlingPolicy::AnalysisObject};
+  void init(InitContext&)
+  {
+    // setup binnnig binPolicy for mixing
+    colBinningMult = {{Mixing.binVztx, Mixing.binMult}, true};
+    colBinningMultPercentile = {{Mixing.binVztx, Mixing.binMultPercentile}, true};
+    colBinningMultMultPercentile = {{Mixing.binVztx, Mixing.binMult, Mixing.binMultPercentile}, true};
+    eventHisto.init(&registry, Option.isMC);
+
+    cascHistoPartOne.init(&registry, Binning.multTempFit, Option.dummy, Binning.pTCascade, Option.dummy, Option.dummy, Binning.tempFitVarCascade, Option.dummy, Option.dummy, Option.dummy, Option.dummy, Option.dummy, Option.dummy, Option.isMC, Cascade1.pdgCode);
+    posChildHistosPartOne.init(&registry, Binning.multTempFit, Option.dummy, Binning.pTCascadeChild, Option.dummy, Option.dummy, Binning.tempFitVarCascadeChild, Option.dummy, Option.dummy, Option.dummy, Option.dummy, Option.dummy, Option.dummy, false, 0);
+    negChildHistosPartOne.init(&registry, Binning.multTempFit, Option.dummy, Binning.pTCascadeChild, Option.dummy, Option.dummy, Binning.tempFitVarCascadeChild, Option.dummy, Option.dummy, Option.dummy, Option.dummy, Option.dummy, Option.dummy, false, 0);
+    bachChildHistosPartOne.init(&registry, Binning.multTempFit, Option.dummy, Binning.pTCascadeChild, Option.dummy, Option.dummy, Binning.tempFitVarCascadeChild, Option.dummy, Option.dummy, Option.dummy, Option.dummy, Option.dummy, Option.dummy, false, 0);
+
+    if (!Option.sameSpecies) {
+      cascHistoPartTwo.init(&registry, Binning.multTempFit, Option.dummy, Binning.pTCascade, Option.dummy, Option.dummy, Binning.tempFitVarCascade, Option.dummy, Option.dummy, Option.dummy, Option.dummy, Binning.invMass, Option.dummy, Option.isMC, Cascade2.pdgCode);
+      posChildHistosPartTwo.init(&registry, Binning.multTempFit, Option.dummy, Binning.pTCascadeChild, Option.dummy, Option.dummy, Binning.tempFitVarCascadeChild, Option.dummy, Option.dummy, Option.dummy, Option.dummy, Option.dummy, Option.dummy, false, 0);
+      negChildHistosPartTwo.init(&registry, Binning.multTempFit, Option.dummy, Binning.pTCascadeChild, Option.dummy, Option.dummy, Binning.tempFitVarCascadeChild, Option.dummy, Option.dummy, Option.dummy, Option.dummy, Option.dummy, Option.dummy, false, 0);
+      bachChildHistosPartTwo.init(&registry, Binning.multTempFit, Option.dummy, Binning.pTCascadeChild, Option.dummy, Option.dummy, Binning.tempFitVarCascadeChild, Option.dummy, Option.dummy, Option.dummy, Option.dummy, Option.dummy, Option.dummy, false, 0);
+    }
+
+    sameEventCont.init(&registry,
+                       Binning.kstar, Binning.pT, Binning.kT, Binning.mT, Mixing.binMult, Mixing.binMultPercentile,
+                       Binning4D.kstar, Binning4D.mT, Binning4D.mult, Binning4D.multPercentile,
+                       Option.isMC, Option.use4D, Option.extendedPlots,
+                       Option.highkstarCut,
+                       Option.smearingByOrigin);
+
+    sameEventCont.setPDGCodes(Cascade1.pdgCode, Cascade2.pdgCode);
+
+    mixedEventCont.init(&registry,
+                        Binning.kstar, Binning.pT, Binning.kT, Binning.mT, Mixing.binMult, Mixing.binMultPercentile,
+                        Binning4D.kstar, Binning4D.mT, Binning4D.mult, Binning4D.multPercentile,
+                        Option.isMC, Option.use4D, Option.extendedPlots,
+                        Option.highkstarCut,
+                        Option.smearingByOrigin);
+
+    mixedEventCont.setPDGCodes(Cascade1.pdgCode, Cascade2.pdgCode);
+
+    pairCleaner.init(&registry);
+    if (Option.cprOn.value) {
+      pairCloseRejectionSE.init(&registry, &registry, Option.cprDeltaPhiMax.value, Option.cprDeltaEtaMax.value, Option.cprPlotPerRadii.value, 1, Option.cprOld.value);
+      pairCloseRejectionME.init(&registry, &registry, Option.cprDeltaPhiMax.value, Option.cprDeltaEtaMax.value, Option.cprPlotPerRadii.value, 2, Option.cprOld.value, 99, true);
+    }
+  }
+
+  /// This function processes the same event and takes care of all the histogramming
+  template <bool isMC, typename PartitionType, typename TableTracks, typename Collision>
+  void doSameEvent(PartitionType& sliceCascade1, PartitionType& sliceCascade2, TableTracks const& parts, Collision const& col)
+  {
+    /// Histogramming same event
+    for (auto const& casc : sliceCascade1) {
+      const auto& posChild1 = parts.iteratorAt(casc.index() - 3);
+      const auto& negChild1 = parts.iteratorAt(casc.index() - 2);
+      const auto& bachChild1 = parts.iteratorAt(casc.index() - 1);
+
+      // check cuts on V0 children
+      if (Cascade1.useChildCuts) {
+        if (!(((posChild1.cut() & Cascade1.childPosCutBit) == Cascade1.childPosCutBit) &&
+              ((negChild1.cut() & Cascade1.childNegCutBit) == Cascade1.childNegCutBit) &&
+              ((bachChild1.cut() & Cascade1.childBachCutBit) == Cascade1.childBachCutBit))) {
+          continue;
+        }
+      }
+      if (Cascade1.useChildPIDCuts) {
+        if (!(((posChild1.pidcut() & Cascade1.childPosTPCBit) == Cascade1.childPosTPCBit) &&
+              ((negChild1.pidcut() & Cascade1.childNegTPCBit) == Cascade1.childNegTPCBit) &&
+              ((bachChild1.pidcut() & Cascade1.childBachTPCBit) == Cascade1.childBachTPCBit))) {
+          continue;
+        }
+      }
+      cascHistoPartOne.fillQA<isMC, false>(casc, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M());
+      posChildHistosPartOne.fillQA<false, false>(posChild1, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M());
+      negChildHistosPartOne.fillQA<false, false>(negChild1, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M());
+      bachChildHistosPartOne.fillQA<false, false>(bachChild1, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M());
+    }
+    if (!Option.sameSpecies) {
+      for (auto const& casc : sliceCascade2) {
+        const auto& posChild2 = parts.iteratorAt(casc.index() - 3);
+        const auto& negChild2 = parts.iteratorAt(casc.index() - 2);
+        const auto& bachChild2 = parts.iteratorAt(casc.index() - 1);
+
+        // check cuts on V0 children
+        if (Cascade2.useChildCuts) {
+          if (!(((posChild2.cut() & Cascade2.childPosCutBit) == Cascade2.childPosCutBit) &&
+                ((negChild2.cut() & Cascade2.childNegCutBit) == Cascade2.childNegCutBit) &&
+                ((bachChild2.cut() & Cascade2.childBachCutBit) == Cascade2.childBachCutBit))) {
+            continue;
+          }
+        }
+        if (Cascade2.useChildPIDCuts) {
+          if (!(((posChild2.pidcut() & Cascade2.childPosTPCBit) == Cascade2.childPosTPCBit) &&
+                ((negChild2.pidcut() & Cascade2.childNegTPCBit) == Cascade2.childNegTPCBit) &&
+                ((bachChild2.pidcut() & Cascade2.childBachTPCBit) == Cascade2.childBachTPCBit))) {
+            continue;
+          }
+        }
+        cascHistoPartTwo.fillQA<isMC, false>(casc, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M());
+        posChildHistosPartTwo.fillQA<false, false>(posChild2, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M());
+        negChildHistosPartTwo.fillQA<false, false>(negChild2, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M());
+        bachChildHistosPartTwo.fillQA<false, false>(bachChild2, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M());
+      }
+    }
+
+    /// Now build particle combinations
+    for (auto const& [p1, p2] : combinations(CombinationsStrictlyUpperIndexPolicy(sliceCascade1, sliceCascade2))) {
+      const auto& posChild1 = parts.iteratorAt(p1.index() - 3);
+      const auto& negChild1 = parts.iteratorAt(p1.index() - 2);
+      const auto& bachChild1 = parts.iteratorAt(p1.index() - 1);
+      const auto& posChild2 = parts.iteratorAt(p2.index() - 3);
+      const auto& negChild2 = parts.iteratorAt(p2.index() - 2);
+      const auto& bachChild2 = parts.iteratorAt(p2.index() - 1);
+
+      // cuts on Cascade children still need to be applied
+      if (Cascade1.useChildCuts) {
+        if (!(((posChild1.cut() & Cascade1.childPosCutBit) == Cascade1.childPosCutBit) &&
+              ((negChild1.cut() & Cascade1.childNegCutBit) == Cascade1.childNegCutBit) &&
+              ((bachChild1.cut() & Cascade1.childBachCutBit) == Cascade1.childBachCutBit))) {
+          continue;
+        }
+      }
+      if (Cascade1.useChildPIDCuts) {
+        if (!(((posChild1.pidcut() & Cascade1.childPosTPCBit) == Cascade1.childPosTPCBit) &&
+              ((negChild1.pidcut() & Cascade1.childNegTPCBit) == Cascade1.childNegTPCBit) &&
+              ((bachChild1.pidcut() & Cascade1.childBachTPCBit) == Cascade1.childBachTPCBit))) {
+          continue;
+        }
+      }
+
+      if (Cascade2.useChildCuts) {
+        if (!(((posChild2.cut() & Cascade2.childPosCutBit) == Cascade2.childPosCutBit) &&
+              ((negChild2.cut() & Cascade2.childNegCutBit) == Cascade2.childNegCutBit) &&
+              ((bachChild2.cut() & Cascade2.childBachCutBit) == Cascade2.childBachCutBit))) {
+          continue;
+        }
+      }
+      if (Cascade2.useChildPIDCuts) {
+        if (!(((posChild2.pidcut() & Cascade2.childPosTPCBit) == Cascade2.childPosTPCBit) &&
+              ((negChild2.pidcut() & Cascade2.childNegTPCBit) == Cascade2.childNegTPCBit) &&
+              ((bachChild2.pidcut() & Cascade2.childBachTPCBit) == Cascade2.childBachTPCBit))) {
+          continue;
+        }
+      }
+
+      // SE pair set:
+      sameEventCont.setPair<isMC>(p1, p2, col.multNtr(), col.multV0M(), Option.use4D, Option.extendedPlots, Option.smearingByOrigin);
+    }
+  }
+
+  // process Same Event
+  void processSameEvent(FilteredCollision const& col, FDParticles const& parts)
+  {
+    eventHisto.fillQA<false>(col);
+    auto sliceCascade1 = partitionCascade1->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache);
+    auto sliceCascade2 = partitionCascade2->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache);
+    doSameEvent<false>(sliceCascade1, sliceCascade2, parts, col);
+  }
+  PROCESS_SWITCH(FemtoDreamPairCascadeCascade, processSameEvent, "Enable processing same event", true);
+
+  // Mixed events
+  template <bool isMC, typename CollisionType, typename PartType, typename PartitionType, typename BinningType>
+  void doMixedEvent(CollisionType const& cols, PartType const& parts, PartitionType& part1, PartitionType& part2, BinningType binPolicy)
+  {
+    for (auto const& [collision1, collision2] : soa::selfCombinations(binPolicy, Mixing.depth.value, -1, cols, cols)) {
+      // make sure that tracks in same events are not mixed
+      if (collision1.globalIndex() == collision2.globalIndex()) {
+        continue;
+      }
+      auto sliceCasc1 = part1->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision1.globalIndex(), cache);
+      auto sliceCasc2 = part2->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision2.globalIndex(), cache);
+      for (auto const& [p1, p2] : combinations(CombinationsFullIndexPolicy(sliceCasc1, sliceCasc2))) {
+        const auto& posChild1 = parts.iteratorAt(p1.index() - 3);
+        const auto& negChild1 = parts.iteratorAt(p1.index() - 2);
+        const auto& bachChild1 = parts.iteratorAt(p1.index() - 1);
+        const auto& posChild2 = parts.iteratorAt(p2.index() - 3);
+        const auto& negChild2 = parts.iteratorAt(p2.index() - 2);
+        const auto& bachChild2 = parts.iteratorAt(p2.index() - 1);
+        // check cuts on Cascade children
+        if (Cascade1.useChildCuts) {
+          if (!(((posChild1.cut() & Cascade1.childPosCutBit) == Cascade1.childPosCutBit) &&
+                ((negChild1.cut() & Cascade1.childNegCutBit) == Cascade1.childNegCutBit) &&
+                ((bachChild1.cut() & Cascade1.childBachCutBit) == Cascade1.childBachCutBit))) {
+            continue;
+          }
+        }
+        if (Cascade1.useChildPIDCuts) {
+          if (!(((posChild1.pidcut() & Cascade1.childPosTPCBit) == Cascade1.childPosTPCBit) &&
+                ((negChild1.pidcut() & Cascade1.childNegTPCBit) == Cascade1.childNegTPCBit) &&
+                ((bachChild1.pidcut() & Cascade1.childBachTPCBit) == Cascade1.childBachTPCBit))) {
+            continue;
+          }
+        }
+
+        if (Cascade2.useChildCuts) {
+          if (!(((posChild2.cut() & Cascade2.childPosCutBit) == Cascade2.childPosCutBit) &&
+                ((negChild2.cut() & Cascade2.childNegCutBit) == Cascade2.childNegCutBit) &&
+                ((bachChild2.cut() & Cascade2.childBachCutBit) == Cascade2.childBachCutBit))) {
+            continue;
+          }
+        }
+        if (Cascade2.useChildPIDCuts) {
+          if (!(((posChild2.pidcut() & Cascade2.childPosTPCBit) == Cascade2.childPosTPCBit) &&
+                ((negChild2.pidcut() & Cascade2.childNegTPCBit) == Cascade2.childNegTPCBit) &&
+                ((bachChild2.pidcut() & Cascade2.childBachTPCBit) == Cascade2.childBachTPCBit))) {
+            continue;
+          }
+        }
+
+        mixedEventCont.setPair<isMC>(p1, p2, collision1.multNtr(), collision1.multV0M(), Option.use4D, Option.extendedPlots, Option.smearingByOrigin);
+      }
+    }
+  }
+
+  // process Mixed Event
+  void processMixedEvent(FilteredCollisions const& cols, FDParticles const& parts)
+  {
+    switch (Mixing.binPolicy.value) {
+      case femtodreamcollision::kMult:
+        doMixedEvent<false>(cols, parts, partitionCascade1, partitionCascade2, colBinningMult);
+        break;
+      case femtodreamcollision::kMultPercentile:
+        doMixedEvent<false>(cols, parts, partitionCascade1, partitionCascade2, colBinningMultPercentile);
+        break;
+      case femtodreamcollision::kMultMultPercentile:
+        doMixedEvent<false>(cols, parts, partitionCascade1, partitionCascade2, colBinningMultMultPercentile);
+        break;
+      default:
+        LOG(fatal) << "Invalid binning policiy specifed. Breaking...";
+    }
+  }
+  PROCESS_SWITCH(FemtoDreamPairCascadeCascade, processMixedEvent, "Enable processing mixed events", true);
+};
+WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
+{
+  WorkflowSpec workflow{
+    adaptAnalysisTask<FemtoDreamPairCascadeCascade>(cfgc),
+  };
+  return workflow;
+}