diff --git a/PWGCF/Femto/FemtoNuclei/TableProducer/HadNucleiFemto.cxx b/PWGCF/Femto/FemtoNuclei/TableProducer/HadNucleiFemto.cxx
index 7d1b8580535..2d7b4310774 100644
--- a/PWGCF/Femto/FemtoNuclei/TableProducer/HadNucleiFemto.cxx
+++ b/PWGCF/Femto/FemtoNuclei/TableProducer/HadNucleiFemto.cxx
@@ -176,78 +176,135 @@ struct HadNucleiFemto {
   Produces<aod::HadronHyperTable> mOutputHyperDataTable;
   Produces<aod::HadronNucleiMult> mOutputMultiplicityTable;
 
-  // Particle species configuration
-  Configurable<int> settingNuPDGCode{"settingNuPDGCode", static_cast<int>(DeuteronPDG), "Nucleus - PDG code"};
-  Configurable<int> settingHadPDGCode{"settingHadPDGCode", 211, "Hadron - PDG code"};
-  // Event selection and mixing configuration
-  Configurable<float> settingCutVertex{"settingCutVertex", 10.0f, "Accepted z-vertex range"};
-  Configurable<int> settingNoMixedEvents{"settingNoMixedEvents", 5, "Number of mixed events per event"};
-  Configurable<bool> settingEnableBkgUS{"settingEnableBkgUS", false, "Enable US background"};
-  Configurable<bool> settingSaveUSandLS{"settingSaveUSandLS", true, "Save All Pairs"};
-  // Common track-quality cuts
-  Configurable<float> settingCutEta{"settingCutEta", 0.8f, "Eta cut on daughter track"};
-  Configurable<float> settingCutNCls{"settingCutNCls", 5.0f, "Minimum ITS Ncluster for tracks"};
-  Configurable<float> settingCutChi2tpcLow{"settingCutChi2tpcLow", 0.5f, "Low cut on TPC chi2"};
-  Configurable<float> settingCutChi2tpcHigh{"settingCutChi2tpcHigh", 4.f, "High cut on TPC chi2"};
-  Configurable<float> settingCutChi2NClITS{"settingCutChi2NClITS", 36.f, "Maximum ITS Chi2 for tracks"};
-  // Hadron purity and PID cuts
-  Configurable<float> settingCutPinMinTOFHad{"settingCutPinMinTOFHad", 0.5f, "Minimum Pin to apply the TOF cut on hadrons"};
-  Configurable<float> settingCutNsigmaTPCHad{"settingCutNsigmaTPCHad", 3.0f, "Value of the TPC Nsigma cut on Had"};
-  Configurable<float> settingCutNsigmaTOFHad{"settingCutNsigmaTOFHad", 3.0f, "Value of the hsdron TOF Nsigma cut"};
-  Configurable<float> settingCutNsigTPCPrMin{"settingCutNsigTPCPrMin", 3.0f, "Minimum TPC Pr Nsigma cut for rejection"};
-  Configurable<float> settingCutNsigTPCPiMin{"settingCutNsigTPCPiMin", 3.0f, "Minimum TPC Pi Nsigma cut for rejection"};
-  Configurable<float> settingCutNsigTOFPrMin{"settingCutNsigTOFPrMin", 3.0f, "Minimum TOF Pr Nsigma cut for rejection"};
-  Configurable<float> settingCutNsigTOFPiMin{"settingCutNsigTOFPiMin", 3.0f, "Minimum TOF Pi Nsigma cut for rejection"};
-  Configurable<float> settingHadptMin{"settingHadptMin", 0.14f, "Minimum pT for the reference pion track cuts"};
-  Configurable<float> settingHadptMax{"settingHadptMax", 2.5f, "Maximum pT for the reference pion track cuts"};
-  Configurable<int> settingPionITSInnerBarrelMin{"settingPionITSInnerBarrelMin", 3, "Minimum ITS inner barrel clusters for the reference pion track cuts"};
-  Configurable<int> settingPionITSNClsMin{"settingPionITSNClsMin", 7, "Minimum ITS clusters for the reference pion track cuts"};
-  Configurable<int> settingPionTPCNClsFoundMin{"settingPionTPCNClsFoundMin", 80, "Minimum found TPC clusters for the reference pion track cuts"};
-  Configurable<int> settingPionTPCCrossedRowsMin{"settingPionTPCCrossedRowsMin", 90, "Minimum crossed TPC rows for the reference pion track cuts"};
-  Configurable<float> settingPionDCAxyOffset{"settingPionDCAxyOffset", 0.004f, "DCAxy offset for the reference pion track cuts"};
-  Configurable<float> settingPionDCAxyPtCoeff{"settingPionDCAxyPtCoeff", 0.013f, "DCAxy 1/pT coefficient for the reference pion track cuts"};
-  Configurable<float> settingPionDCAzOffset{"settingPionDCAzOffset", 0.004f, "DCAz offset for the reference pion track cuts"};
-  Configurable<float> settingPionDCAzPtCoeff{"settingPionDCAzPtCoeff", 0.013f, "DCAz 1/pT coefficient for the reference pion track cuts"};
-  Configurable<float> settingPionMomCombMin{"settingPionMomCombMin", 0.5f, "Minimum momentum to use combined TPC+TOF PID for reference pions"};
-  Configurable<float> settingPionTPCNsigMax{"settingPionTPCNsigMax", 3.0f, "Maximum TPC n-sigma for reference pions below the TOF threshold"};
-  Configurable<float> settingPionCombNsigMax{"settingPionCombNsigMax", 3.0f, "Maximum combined TPC+TOF n-sigma for reference pions"};
-  // Deuteron purity and PID cuts
-  Configurable<float> settingCutPinMinDe{"settingCutPinMinDe", 0.0f, "Minimum Pin for De"};
-  Configurable<float> settingCutClSizeItsDe{"settingCutClSizeItsDe", 4.0f, "Minimum ITS cluster size for De"};
-  Configurable<float> settingCutDeptMin{"settingCutDeptMin", 0.6f, "Minimum PT cut on De"};
-  Configurable<float> settingCutDeptMax{"settingCutDeptMax", 1.6f, "Maximum PT cut on De"};
-  Configurable<float> settingCutPinMinTOFITSDe{"settingCutPinMinTOFITSDe", 1.2f, "Minimum p to apply the TOF ITS cut on De"};
-  Configurable<float> settingCutNsigmaTPCDe{"settingCutNsigmaTPCDe", 2.5f, "Value of the TPC Nsigma cut on De"};
-  Configurable<float> settingCutNsigmaITSDe{"settingCutNsigmaITSDe", 2.5f, "Value of the ITD Nsigma cut on De"};
-  Configurable<float> settingCutNsigmaTOFTPCDe{"settingCutNsigmaTOFTPCDe", 2.5f, "Value of the De TOF TPC combNsigma cut"};
-  Configurable<bool> settingReqSingleNsig{"settingReqSingleNsig", false, "If true, also require individual TPC and TOF n-sigma cuts in branches using combined TPC+TOF PID"};
-  Configurable<bool> settingUseProtonMassForKstarMt{"settingUseProtonMassForKstarMt", false, "If true, use proton mass instead of deuteron mass for kstar and mT"};
-  Configurable<bool> settingEnableClosePairRejection{"settingEnableClosePairRejection", false, "Enable close pair rejection for nucleus-hadron track pairs"};
-  Configurable<float> settingClosePairDeltaPhiMax{"settingClosePairDeltaPhiMax", 0.01f, "Maximum delta phi star for close pair rejection"};
-  Configurable<float> settingClosePairDeltaEtaMax{"settingClosePairDeltaEtaMax", 0.01f, "Maximum delta eta for close pair rejection"};
-  Configurable<int> settingClosePairRadiusMode{"settingClosePairRadiusMode", 1, "Close pair rejection mode: 0 = PV, 1 = average phi star, 2 = specific TPC radius"};
-  Configurable<float> settingClosePairSpecificRadius{"settingClosePairSpecificRadius", 85.f, "TPC radius in cm used when close pair rejection mode is 2"};
-  // Hypertriton-specific cuts
-  Configurable<float> settingCutTPCChi2He{"settingCutTPCChi2He", 0.0f, "Minimum tpcChi2He for Hyper He3"};
-  Configurable<float> settingCutAverClsSizeHe{"settingCutAverClsSizeHe", 0.0f, "Minimum averClusSizeHe for Hyper He3"};
-  // Output and QA controls
-  Configurable<bool> settingFillTable{"settingFillTable", false, "Enable table filling"};
-  Configurable<bool> settingFillMultiplicity{"settingFillMultiplicity", false, "Fill multiplicity table"};
-  Configurable<bool> settingUseBBcomputeDeNsigma{"settingUseBBcomputeDeNsigma", false, "Use BB params to compute De TPC Nsigma"};
-  // Zorro
-  Configurable<bool> settingSkimmedProcessing{"settingSkimmedProcessing", false, "Skimmed dataset processing"};
-  // CCDB options
-  Configurable<double> settingDbz{"settingDbz", -999, "bz field, -999 is automatic"};
-  Configurable<std::string> settingCcdburl{"settingCcdburl", "http://alice-ccdb.cern.ch", "url of the ccdb repository"};
-  Configurable<std::string> settingGrpPath{"settingGrpPath", "GLO/GRP/GRP", "Path of the grp file"};
-  Configurable<std::string> settingGrpmagPath{"settingGrpmagPath", "GLO/Config/GRPMagField", "CCDB path of the GRPMagField object"};
-  Configurable<std::string> settingLutPath{"settingLutPath", "GLO/Param/MatLUT", "Path of the Lut parametrization"};
-  Configurable<std::string> settingGeoPath{"settingGeoPath", "GLO/Config/GeometryAligned", "Path of the geometry file"};
-  Configurable<std::string> settingPidPath{"settingPidPath", "", "Path to the PID response object"};
-
-  Configurable<LabeledArray<double>> settingBetheBlochParams{"settingBetheBlochParams", {BetheBlochDefault.data(), 2, 6, betheBlochParticleNames, betheBlochParNames}, "TPC Bethe-Bloch parameterisation for the selected nucleus"};
-  Configurable<bool> settingCompensatePIDinTracking{"settingCompensatePIDinTracking", false, "If true, divide tpcInnerParam by the electric charge"};
-  Configurable<int> settingMaterialCorrection{"settingMaterialCorrection", static_cast<int>(o2::base::Propagator::MatCorrType::USEMatCorrNONE), "Material correction type"};
+  struct : o2::framework::ConfigurableGroup {
+    // cppcheck-suppress unusedStructMember
+    std::string prefix{"species"};
+    // Particle species configuration
+    Configurable<int> settingNuPDGCode{"settingNuPDGCode", static_cast<int>(DeuteronPDG), "Nucleus - PDG code"};
+    Configurable<int> settingHadPDGCode{"settingHadPDGCode", 211, "Hadron - PDG code"};
+  } species;
+
+  struct : o2::framework::ConfigurableGroup {
+    // cppcheck-suppress unusedStructMember
+    std::string prefix{"eventMixing"};
+    // Event selection and mixing configuration
+    Configurable<float> settingCutVertex{"settingCutVertex", 10.0f, "Accepted z-vertex range"};
+    Configurable<int> settingNoMixedEvents{"settingNoMixedEvents", 5, "Number of mixed events per event"};
+    Configurable<bool> settingEnableBkgUS{"settingEnableBkgUS", false, "Enable US background"};
+    Configurable<bool> settingSaveUSandLS{"settingSaveUSandLS", true, "Save All Pairs"};
+  } eventMixing;
+
+  struct : o2::framework::ConfigurableGroup {
+    // cppcheck-suppress unusedStructMember
+    std::string prefix{"trackCut"};
+    // Common track-quality cuts
+    Configurable<float> settingCutEta{"settingCutEta", 0.8f, "Eta cut on daughter track"};
+    Configurable<float> settingCutNCls{"settingCutNCls", 5.0f, "Minimum ITS Ncluster for tracks"};
+    Configurable<float> settingCutChi2tpcLow{"settingCutChi2tpcLow", 0.5f, "Low cut on TPC chi2"};
+    Configurable<float> settingCutChi2tpcHigh{"settingCutChi2tpcHigh", 4.f, "High cut on TPC chi2"};
+    Configurable<float> settingCutChi2NClITS{"settingCutChi2NClITS", 36.f, "Maximum ITS Chi2 for tracks"};
+  } trackCut;
+
+  struct : o2::framework::ConfigurableGroup {
+    // cppcheck-suppress unusedStructMember
+    std::string prefix{"hadronPid"};
+    // Hadron purity and PID cuts
+    Configurable<float> settingCutPinMinTOFHad{"settingCutPinMinTOFHad", 0.5f, "Minimum Pin to apply the TOF cut on hadrons"};
+    Configurable<float> settingCutNsigmaTPCHad{"settingCutNsigmaTPCHad", 3.0f, "Value of the TPC Nsigma cut on Had"};
+    Configurable<float> settingCutNsigmaTOFHad{"settingCutNsigmaTOFHad", 3.0f, "Value of the hsdron TOF Nsigma cut"};
+    Configurable<float> settingCutNsigTPCPrMin{"settingCutNsigTPCPrMin", 3.0f, "Minimum TPC Pr Nsigma cut for rejection"};
+    Configurable<float> settingCutNsigTPCPiMin{"settingCutNsigTPCPiMin", 3.0f, "Minimum TPC Pi Nsigma cut for rejection"};
+    Configurable<float> settingCutNsigTOFPrMin{"settingCutNsigTOFPrMin", 3.0f, "Minimum TOF Pr Nsigma cut for rejection"};
+    Configurable<float> settingCutNsigTOFPiMin{"settingCutNsigTOFPiMin", 3.0f, "Minimum TOF Pi Nsigma cut for rejection"};
+    Configurable<float> settingHadptMin{"settingHadptMin", 0.14f, "Minimum pT for the reference pion track cuts"};
+    Configurable<float> settingHadptMax{"settingHadptMax", 2.5f, "Maximum pT for the reference pion track cuts"};
+    Configurable<int> settingPionITSInnerBarrelMin{"settingPionITSInnerBarrelMin", 3, "Minimum ITS inner barrel clusters for the reference pion track cuts"};
+    Configurable<int> settingPionITSNClsMin{"settingPionITSNClsMin", 7, "Minimum ITS clusters for the reference pion track cuts"};
+    Configurable<int> settingPionTPCNClsFoundMin{"settingPionTPCNClsFoundMin", 80, "Minimum found TPC clusters for the reference pion track cuts"};
+    Configurable<int> settingPionTPCCrossedRowsMin{"settingPionTPCCrossedRowsMin", 90, "Minimum crossed TPC rows for the reference pion track cuts"};
+    Configurable<float> settingPionDCAxyOffset{"settingPionDCAxyOffset", 0.004f, "DCAxy offset for the reference pion track cuts"};
+    Configurable<float> settingPionDCAxyPtCoeff{"settingPionDCAxyPtCoeff", 0.013f, "DCAxy 1/pT coefficient for the reference pion track cuts"};
+    Configurable<float> settingPionDCAzOffset{"settingPionDCAzOffset", 0.004f, "DCAz offset for the reference pion track cuts"};
+    Configurable<float> settingPionDCAzPtCoeff{"settingPionDCAzPtCoeff", 0.013f, "DCAz 1/pT coefficient for the reference pion track cuts"};
+    Configurable<float> settingPionMomCombMin{"settingPionMomCombMin", 0.5f, "Minimum momentum to use combined TPC+TOF PID for reference pions"};
+    Configurable<float> settingPionTPCNsigMax{"settingPionTPCNsigMax", 3.0f, "Maximum TPC n-sigma for reference pions below the TOF threshold"};
+    Configurable<float> settingPionCombNsigMax{"settingPionCombNsigMax", 3.0f, "Maximum combined TPC+TOF n-sigma for reference pions"};
+  } hadronPid;
+
+  struct : o2::framework::ConfigurableGroup {
+    // cppcheck-suppress unusedStructMember
+    std::string prefix{"deuteronPid"};
+    // Deuteron purity and PID cuts
+    Configurable<float> settingCutPinMinDe{"settingCutPinMinDe", 0.0f, "Minimum Pin for De"};
+    Configurable<float> settingCutClSizeItsDe{"settingCutClSizeItsDe", 4.0f, "Minimum ITS cluster size for De"};
+    Configurable<float> settingCutDeptMin{"settingCutDeptMin", 0.6f, "Minimum PT cut on De"};
+    Configurable<float> settingCutDeptMax{"settingCutDeptMax", 1.6f, "Maximum PT cut on De"};
+    Configurable<float> settingCutPinMinTOFITSDe{"settingCutPinMinTOFITSDe", 1.2f, "Minimum p to apply the TOF ITS cut on De"};
+    Configurable<float> settingCutNsigmaTPCDe{"settingCutNsigmaTPCDe", 2.5f, "Value of the TPC Nsigma cut on De"};
+    Configurable<float> settingCutNsigmaITSDe{"settingCutNsigmaITSDe", 2.5f, "Value of the ITD Nsigma cut on De"};
+    Configurable<float> settingCutNsigmaTOFTPCDe{"settingCutNsigmaTOFTPCDe", 2.5f, "Value of the De TOF TPC combNsigma cut"};
+    Configurable<bool> settingReqSingleNsig{"settingReqSingleNsig", false, "If true, also require individual TPC and TOF n-sigma cuts in branches using combined TPC+TOF PID"};
+    Configurable<bool> settingUseProtonMassForKstarMt{"settingUseProtonMassForKstarMt", false, "If true, use proton mass instead of deuteron mass for kstar and mT"};
+  } deuteronPid;
+
+  struct : o2::framework::ConfigurableGroup {
+    // cppcheck-suppress unusedStructMember
+    std::string prefix{"CPR"};
+    // Close pair rejection controls
+    Configurable<bool> settingEnableClosePairRejection{"settingEnableClosePairRejection", false, "Enable close pair rejection for nucleus-hadron track pairs"};
+    Configurable<float> settingClosePairDeltaPhiMax{"settingClosePairDeltaPhiMax", 0.01f, "Maximum delta phi star for close pair rejection"};
+    Configurable<float> settingClosePairDeltaEtaMax{"settingClosePairDeltaEtaMax", 0.01f, "Maximum delta eta for close pair rejection"};
+    Configurable<int> settingClosePairRadiusMode{"settingClosePairRadiusMode", 1, "Close pair rejection mode: 0 = PV, 1 = average phi star, 2 = specific TPC radius"};
+    Configurable<float> settingClosePairSpecificRadius{"settingClosePairSpecificRadius", 85.f, "TPC radius in cm used when close pair rejection mode is 2"};
+  } CPR;
+
+  struct : o2::framework::ConfigurableGroup {
+    // cppcheck-suppress unusedStructMember
+    std::string prefix{"hypertriton"};
+    // Hypertriton-specific cuts
+    Configurable<float> settingCutTPCChi2He{"settingCutTPCChi2He", 0.0f, "Minimum tpcChi2He for Hyper He3"};
+    Configurable<float> settingCutAverClsSizeHe{"settingCutAverClsSizeHe", 0.0f, "Minimum averClusSizeHe for Hyper He3"};
+  } hypertriton;
+
+  struct : o2::framework::ConfigurableGroup {
+    // cppcheck-suppress unusedStructMember
+    std::string prefix{"output"};
+    // Output and QA controls
+    Configurable<bool> settingFillTable{"settingFillTable", false, "Enable table filling"};
+    Configurable<bool> settingFillTableLowKstarOnly{"settingFillTableLowKstarOnly", false, "If true, fill the output table only for pion-deuteron pairs below the kstar threshold"};
+    Configurable<float> settingFillTablePiDeKstarMax{"settingFillTablePiDeKstarMax", 0.1f, "Maximum kstar for pion-deuteron pairs written to the output table"};
+    Configurable<bool> settingFillMultiplicity{"settingFillMultiplicity", false, "Fill multiplicity table"};
+    Configurable<bool> settingUseBBcomputeDeNsigma{"settingUseBBcomputeDeNsigma", false, "Use BB params to compute De TPC Nsigma"};
+  } output;
+
+  struct : o2::framework::ConfigurableGroup {
+    // cppcheck-suppress unusedStructMember
+    std::string prefix{"zorro"};
+    // Zorro
+    Configurable<bool> settingSkimmedProcessing{"settingSkimmedProcessing", false, "Skimmed dataset processing"};
+  } zorro;
+
+  struct : o2::framework::ConfigurableGroup {
+    // cppcheck-suppress unusedStructMember
+    std::string prefix{"ccdb"};
+    // CCDB options
+    Configurable<double> settingDbz{"settingDbz", -999, "bz field, -999 is automatic"};
+    Configurable<std::string> settingCcdburl{"settingCcdburl", "http://alice-ccdb.cern.ch", "url of the ccdb repository"};
+    Configurable<std::string> settingGrpPath{"settingGrpPath", "GLO/GRP/GRP", "Path of the grp file"};
+    Configurable<std::string> settingGrpmagPath{"settingGrpmagPath", "GLO/Config/GRPMagField", "CCDB path of the GRPMagField object"};
+    Configurable<std::string> settingLutPath{"settingLutPath", "GLO/Param/MatLUT", "Path of the Lut parametrization"};
+    Configurable<std::string> settingGeoPath{"settingGeoPath", "GLO/Config/GeometryAligned", "Path of the geometry file"};
+    Configurable<std::string> settingPidPath{"settingPidPath", "", "Path to the PID response object"};
+  } ccdb;
+
+  struct : o2::framework::ConfigurableGroup {
+    // cppcheck-suppress unusedStructMember
+    std::string prefix{"pidCalibration"};
+    // PID calibration and material correction controls
+    Configurable<LabeledArray<double>> settingBetheBlochParams{"settingBetheBlochParams", {BetheBlochDefault.data(), 2, 6, betheBlochParticleNames, betheBlochParNames}, "TPC Bethe-Bloch parameterisation for the selected nucleus"};
+    Configurable<bool> settingCompensatePIDinTracking{"settingCompensatePIDinTracking", false, "If true, divide tpcInnerParam by the electric charge"};
+    Configurable<int> settingMaterialCorrection{"settingMaterialCorrection", static_cast<int>(o2::base::Propagator::MatCorrType::USEMatCorrNONE), "Material correction type"};
+  } pidCalibration;
 
   Preslice<TrackCandidates> mPerCol = aod::track::collisionId;
   PresliceUnsorted<o2::aod::DataHypCandsWColl> hypPerCol = o2::aod::hyperrec::collisionId;
@@ -258,8 +315,8 @@ struct HadNucleiFemto {
   using BinningType = ColumnBinningPolicy<aod::collision::PosZ, aod::cent::CentFT0C>;
   BinningType binningPolicy{{axisVertex, axisCentrality}, true};
   SliceCache cache;
-  SameKindPair<CollisionsFull, TrackCandidates, BinningType> mPair{binningPolicy, settingNoMixedEvents, -1, &cache};
-  // Pair<CollisionsFull, TrackCandidates, o2::aod::DataHypCandsWColl, BinningType> hyperPair{binningPolicy, settingNoMixedEvents, -1, &cache};
+  SameKindPair<CollisionsFull, TrackCandidates, BinningType> mPair{binningPolicy, eventMixing.settingNoMixedEvents, -1, &cache};
+  // Pair<CollisionsFull, TrackCandidates, o2::aod::DataHypCandsWColl, BinningType> hyperPair{binningPolicy, eventMixing.settingNoMixedEvents, -1, &cache};
 
   std::array<float, 6> mBBparamsNucleus{};
   float mMassHad{0.f};
@@ -379,7 +436,7 @@ struct HadNucleiFemto {
     mZorroSummary.setObject(mZorro.getZorroSummary());
     mRunNumber = 0;
 
-    mCcdb->setURL(settingCcdburl);
+    mCcdb->setURL(ccdb.settingCcdburl);
     mCcdb->setCaching(true);
     mCcdb->setLocalObjectValidityChecking();
     mCcdb->setFatalWhenNull(false);
@@ -391,15 +448,15 @@ struct HadNucleiFemto {
     mFitter.setMaxDZIni(1e9);
     mFitter.setMaxChi2(1e9);
     mFitter.setUseAbsDCA(true);
-    int mat{static_cast<int>(settingMaterialCorrection)};
+    int mat{static_cast<int>(pidCalibration.settingMaterialCorrection)};
     mFitter.setMatCorrType(static_cast<o2::base::Propagator::MatCorrType>(mat));
 
     const int numParticles = 5;
     const char* betheBlochLabel = nucleusBetheBlochLabel();
     for (int i = 0; i < numParticles; i++) {
-      mBBparamsNucleus[i] = settingBetheBlochParams->get(betheBlochLabel, Form("p%i", i));
+      mBBparamsNucleus[i] = pidCalibration.settingBetheBlochParams->get(betheBlochLabel, Form("p%i", i));
     }
-    mBBparamsNucleus[5] = settingBetheBlochParams->get(betheBlochLabel, "resolution");
+    mBBparamsNucleus[5] = pidCalibration.settingBetheBlochParams->get(betheBlochLabel, "resolution");
 
     std::vector<std::string> selectionLabels = {"All", "Track selection", "PID"};
     for (int i = 0; i < Selections::kAll; i++) {
@@ -418,36 +475,36 @@ struct HadNucleiFemto {
     if (mRunNumber == bc.runNumber()) {
       return;
     }
-    if (settingSkimmedProcessing) {
+    if (zorro.settingSkimmedProcessing) {
       mZorro.initCCDB(mCcdb.service, bc.runNumber(), bc.timestamp(), useHelium3Nucleus() ? "fHe" : "fDe");
       mZorro.populateHistRegistry(mQaRegistry, bc.runNumber());
     }
     mRunNumber = bc.runNumber();
     const float defaultBzValue = -999.0f;
     auto run3GrpTimestamp = bc.timestamp();
-    auto* grpo = mCcdb->getForTimeStamp<o2::parameters::GRPObject>(settingGrpPath, run3GrpTimestamp);
+    auto* grpo = mCcdb->getForTimeStamp<o2::parameters::GRPObject>(ccdb.settingGrpPath, run3GrpTimestamp);
     o2::parameters::GRPMagField* grpmag = nullptr;
     if (grpo) {
       o2::base::Propagator::initFieldFromGRP(grpo);
-      if (settingDbz < defaultBzValue) {
+      if (ccdb.settingDbz < defaultBzValue) {
         // Fetch magnetic field from ccdb for current collision
         mDbz = grpo->getNominalL3Field();
         LOG(info) << "Retrieved GRP for timestamp " << run3GrpTimestamp << " with magnetic field of " << mDbz << " kZG";
       } else {
-        mDbz = settingDbz;
+        mDbz = ccdb.settingDbz;
       }
     } else {
-      grpmag = mCcdb->getForTimeStamp<o2::parameters::GRPMagField>(settingGrpmagPath, run3GrpTimestamp);
+      grpmag = mCcdb->getForTimeStamp<o2::parameters::GRPMagField>(ccdb.settingGrpmagPath, run3GrpTimestamp);
       if (!grpmag) {
-        LOG(fatal) << "Got nullptr from CCDB for path " << settingGrpmagPath << " of object GRPMagField and " << settingGrpPath << " of object GRPObject for timestamp " << run3GrpTimestamp;
+        LOG(fatal) << "Got nullptr from CCDB for path " << ccdb.settingGrpmagPath << " of object GRPMagField and " << ccdb.settingGrpPath << " of object GRPObject for timestamp " << run3GrpTimestamp;
       }
       o2::base::Propagator::initFieldFromGRP(grpmag);
-      if (settingDbz < defaultBzValue) {
+      if (ccdb.settingDbz < defaultBzValue) {
         // Fetch magnetic field from ccdb for current collision
         mDbz = std::lround(5.f * grpmag->getL3Current() / 30000.f);
         LOG(info) << "Retrieved GRP for timestamp " << run3GrpTimestamp << " with magnetic field of " << mDbz << " kZG";
       } else {
-        mDbz = settingDbz;
+        mDbz = ccdb.settingDbz;
       }
     }
   }
@@ -460,17 +517,17 @@ struct HadNucleiFemto {
     mQaRegistry.fill(HIST("hEvents"), 0);
 
     if constexpr (isMC) {
-      if (/*!collision.sel8() ||*/ std::abs(collision.posZ()) > settingCutVertex) {
+      if (/*!collision.sel8() ||*/ std::abs(collision.posZ()) > eventMixing.settingCutVertex) {
         return false;
       }
     } else {
       auto bc = collision.template bc_as<aod::BCsWithTimestamps>();
       initCCDB(bc);
 
-      if (!collision.sel8() || std::abs(collision.posZ()) > settingCutVertex) {
+      if (!collision.sel8() || std::abs(collision.posZ()) > eventMixing.settingCutVertex) {
         return false;
       }
-      if (settingSkimmedProcessing) {
+      if (zorro.settingSkimmedProcessing) {
         bool zorroSelected = mZorro.isSelected(collision.template bc_as<aod::BCsWithTimestamps>().globalBC());
         if (zorroSelected) {
           mQaRegistry.fill(HIST("hEvents"), 2);
@@ -487,37 +544,37 @@ struct HadNucleiFemto {
   template <typename Ttrack>
   bool selectTrack(const Ttrack& candidate)
   {
-    if (std::abs(candidate.eta()) > settingCutEta) {
+    if (std::abs(candidate.eta()) > trackCut.settingCutEta) {
       return false;
     }
     const int minTPCNClsFound = 90;
     const int minTPCNClsCrossedRows = 70;
     const float crossedRowsToFindableRatio = 0.83f;
-    return !(candidate.itsNCls() < settingCutNCls ||
+    return !(candidate.itsNCls() < trackCut.settingCutNCls ||
              candidate.tpcNClsFound() < minTPCNClsFound ||
              candidate.tpcNClsCrossedRows() < minTPCNClsCrossedRows ||
              candidate.tpcNClsCrossedRows() < crossedRowsToFindableRatio * candidate.tpcNClsFindable() ||
-             candidate.tpcChi2NCl() > settingCutChi2tpcHigh ||
-             candidate.tpcChi2NCl() < settingCutChi2tpcLow ||
-             candidate.itsChi2NCl() > settingCutChi2NClITS);
+             candidate.tpcChi2NCl() > trackCut.settingCutChi2tpcHigh ||
+             candidate.tpcChi2NCl() < trackCut.settingCutChi2tpcLow ||
+             candidate.itsChi2NCl() > trackCut.settingCutChi2NClITS);
   }
 
   template <typename Ttrack>
   bool selectTrackPion(const Ttrack& candidate)
   {
-    if (std::abs(candidate.eta()) > settingCutEta) {
+    if (std::abs(candidate.eta()) > trackCut.settingCutEta) {
       return false;
     }
 
     const float absPt = std::abs(candidate.pt());
-    if (absPt < settingHadptMin || absPt > settingHadptMax) {
+    if (absPt < hadronPid.settingHadptMin || absPt > hadronPid.settingHadptMax) {
       return false;
     }
 
-    if (candidate.itsNClsInnerBarrel() < settingPionITSInnerBarrelMin ||
-        candidate.itsNCls() < settingPionITSNClsMin ||
-        candidate.tpcNClsFound() < settingPionTPCNClsFoundMin ||
-        candidate.tpcNClsCrossedRows() < settingPionTPCCrossedRowsMin) {
+    if (candidate.itsNClsInnerBarrel() < hadronPid.settingPionITSInnerBarrelMin ||
+        candidate.itsNCls() < hadronPid.settingPionITSNClsMin ||
+        candidate.tpcNClsFound() < hadronPid.settingPionTPCNClsFoundMin ||
+        candidate.tpcNClsCrossedRows() < hadronPid.settingPionTPCCrossedRowsMin) {
       return false;
     }
 
@@ -525,18 +582,18 @@ struct HadNucleiFemto {
       return false;
     }
 
-    const float pionDCAxyMax = settingPionDCAxyOffset + settingPionDCAxyPtCoeff / absPt;
-    const float pionDCAzMax = settingPionDCAzOffset + settingPionDCAzPtCoeff / absPt;
+    const float pionDCAxyMax = hadronPid.settingPionDCAxyOffset + hadronPid.settingPionDCAxyPtCoeff / absPt;
+    const float pionDCAzMax = hadronPid.settingPionDCAzOffset + hadronPid.settingPionDCAzPtCoeff / absPt;
     return !(std::abs(candidate.dcaXY()) > pionDCAxyMax || std::abs(candidate.dcaZ()) > pionDCAzMax);
   }
 
   template <typename Ttrack>
   bool selectTrackHadron(const Ttrack& candidate)
   {
-    if (settingHadPDGCode.value == static_cast<int>(PDG_t::kProton)) {
+    if (species.settingHadPDGCode.value == static_cast<int>(PDG_t::kProton)) {
       return selectTrackProton(candidate);
     }
-    if (settingHadPDGCode.value == static_cast<int>(PDG_t::kPiPlus)) {
+    if (species.settingHadPDGCode.value == static_cast<int>(PDG_t::kPiPlus)) {
       return selectTrackPion(candidate);
     }
     return selectTrack(candidate);
@@ -571,7 +628,7 @@ struct HadNucleiFemto {
   template <typename Ttrack>
   bool selectTrackDe(const Ttrack& candidate)
   {
-    if (std::abs(candidate.eta()) > settingCutEta) {
+    if (std::abs(candidate.eta()) > trackCut.settingCutEta) {
       return false;
     }
 
@@ -588,18 +645,18 @@ struct HadNucleiFemto {
              tpcCrossedRowsOverFound < minTPCCrossedRowsOverFound ||
              candidate.tpcNClsShared() > maxTPCNClsShared ||
              candidate.tpcFractionSharedCls() > maxSharedTPCFraction ||
-             candidate.itsNCls() < settingCutNCls ||
+             candidate.itsNCls() < trackCut.settingCutNCls ||
              candidate.itsNClsInnerBarrel() < minITSNClsInnerBarrel);
   }
 
   bool useDeuteronNucleus() const
   {
-    return settingNuPDGCode.value == DeuteronPDG;
+    return species.settingNuPDGCode.value == DeuteronPDG;
   }
 
   bool useHelium3Nucleus() const
   {
-    return settingNuPDGCode.value == He3PDG;
+    return species.settingNuPDGCode.value == He3PDG;
   }
 
   const char* nucleusBetheBlochLabel() const
@@ -623,19 +680,19 @@ struct HadNucleiFemto {
   template <typename Ttrack>
   bool selectTrackHe3(const Ttrack& candidate)
   {
-    if (std::abs(candidate.eta()) > settingCutEta) {
+    if (std::abs(candidate.eta()) > trackCut.settingCutEta) {
       return false;
     }
 
     constexpr int minTPCNClsCrossedRows = 70;
     constexpr float crossedRowsToFindableRatio = 0.8f;
-    return !(candidate.itsNCls() < settingCutNCls ||
+    return !(candidate.itsNCls() < trackCut.settingCutNCls ||
              candidate.tpcNClsFound() < He3TPCNClsFoundMin ||
              candidate.tpcNClsCrossedRows() < minTPCNClsCrossedRows ||
              candidate.tpcNClsCrossedRows() < crossedRowsToFindableRatio * candidate.tpcNClsFindable() ||
-             candidate.tpcChi2NCl() > settingCutChi2tpcHigh ||
+             candidate.tpcChi2NCl() > trackCut.settingCutChi2tpcHigh ||
              candidate.tpcChi2NCl() < He3TPCChi2NClMin ||
-             candidate.itsChi2NCl() > settingCutChi2NClITS);
+             candidate.itsChi2NCl() > trackCut.settingCutChi2NClITS);
   }
 
   template <typename Ttrack>
@@ -661,6 +718,19 @@ struct HadNucleiFemto {
     mQaRegistry.fill(HIST("hNuPairFlow"), step);
   }
 
+  bool isPionDeuteronPair() const
+  {
+    return species.settingHadPDGCode.value == static_cast<int>(PDG_t::kPiPlus) && useDeuteronNucleus();
+  }
+
+  bool shouldFillOutputTable(const HadNucandidate& hadNucand) const
+  {
+    if (!output.settingFillTableLowKstarOnly.value || !isPionDeuteronPair()) {
+      return true;
+    }
+    return hadNucand.kstar < output.settingFillTablePiDeKstarMax.value;
+  }
+
   template <typename Ttrack>
   float phiAtSpecificRadiiTPC(const Ttrack& track, float radius) const
   {
@@ -707,7 +777,7 @@ struct HadNucleiFemto {
     constexpr int closePairRadiusModePv = 0;
     constexpr int closePairRadiusModeSpecificTpc = 2;
     constexpr float invalidPhiStar = 999.f;
-    if (!settingEnableClosePairRejection.value) {
+    if (!CPR.settingEnableClosePairRejection.value) {
       return false;
     }
     if (firstTrack.sign() != secondTrack.sign()) {
@@ -716,13 +786,13 @@ struct HadNucleiFemto {
 
     const float deta = firstTrack.eta() - secondTrack.eta();
     const float dphiAtPV = wrapDeltaPhi(firstTrack.phi() - secondTrack.phi());
-    const float dphiAtSpecificRadius = wrapDeltaPhi(phiAtSpecificRadiiTPC(firstTrack, settingClosePairSpecificRadius.value) - phiAtSpecificRadiiTPC(secondTrack, settingClosePairSpecificRadius.value));
+    const float dphiAtSpecificRadius = wrapDeltaPhi(phiAtSpecificRadiiTPC(firstTrack, CPR.settingClosePairSpecificRadius.value) - phiAtSpecificRadiiTPC(secondTrack, CPR.settingClosePairSpecificRadius.value));
     const float dphiAvg = averagePhiStar(firstTrack, secondTrack);
 
     float dphiToCut = dphiAvg;
-    if (settingClosePairRadiusMode.value == closePairRadiusModePv) {
+    if (CPR.settingClosePairRadiusMode.value == closePairRadiusModePv) {
       dphiToCut = dphiAtPV;
-    } else if (settingClosePairRadiusMode.value == closePairRadiusModeSpecificTpc) {
+    } else if (CPR.settingClosePairRadiusMode.value == closePairRadiusModeSpecificTpc) {
       dphiToCut = dphiAtSpecificRadius;
     }
 
@@ -731,8 +801,8 @@ struct HadNucleiFemto {
     }
 
     mQaRegistry.fill(HIST("h2CPRBefore"), deta, dphiToCut);
-    const bool isRejected = std::pow(dphiToCut, 2.f) / std::pow(settingClosePairDeltaPhiMax.value, 2.f) +
-                              std::pow(deta, 2.f) / std::pow(settingClosePairDeltaEtaMax.value, 2.f) <
+    const bool isRejected = std::pow(dphiToCut, 2.f) / std::pow(CPR.settingClosePairDeltaPhiMax.value, 2.f) +
+                              std::pow(deta, 2.f) / std::pow(CPR.settingClosePairDeltaEtaMax.value, 2.f) <
                             1.f;
     if (!isRejected) {
       mQaRegistry.fill(HIST("h2CPRAfter"), deta, dphiToCut);
@@ -777,7 +847,7 @@ struct HadNucleiFemto {
     if (combNsigma > protonCombNsigmaMax) {
       return false;
     }
-    if (settingReqSingleNsig.value &&
+    if (deuteronPid.settingReqSingleNsig.value &&
         (std::abs(tpcNSigmaPr) > protonCombNsigmaMax || std::abs(tofNSigmaPr) > protonCombNsigmaMax)) {
       return false;
     }
@@ -800,34 +870,34 @@ struct HadNucleiFemto {
     }
 
     mQaRegistry.fill(HIST("h2NsigmaHadTPC_preselection"), candidate.tpcInnerParam(), tpcNSigmaKa);
-    if (std::abs(candidate.pt()) < settingHadptMin || std::abs(candidate.pt()) > settingHadptMax) {
+    if (std::abs(candidate.pt()) < hadronPid.settingHadptMin || std::abs(candidate.pt()) > hadronPid.settingHadptMax) {
       return false;
     }
 
     // reject protons and pions
-    if (std::abs(candidate.tpcNSigmaPr()) < settingCutNsigTPCPrMin || std::abs(candidate.tpcNSigmaPi()) < settingCutNsigTPCPiMin) {
+    if (std::abs(candidate.tpcNSigmaPr()) < hadronPid.settingCutNsigTPCPrMin || std::abs(candidate.tpcNSigmaPi()) < hadronPid.settingCutNsigTPCPiMin) {
       return false;
     }
     mQaRegistry.fill(HIST("h2NsigmaHadPrTPC"), candidate.tpcNSigmaPr());
     mQaRegistry.fill(HIST("h2NsigmaHadPiTPC"), candidate.tpcNSigmaPi());
-    if (candidate.hasTOF() && std::abs(candidate.tofNSigmaPr()) < settingCutNsigTOFPrMin) {
+    if (candidate.hasTOF() && std::abs(candidate.tofNSigmaPr()) < hadronPid.settingCutNsigTOFPrMin) {
       return false;
     }
-    if (candidate.hasTOF() && std::abs(candidate.tofNSigmaPi()) < settingCutNsigTOFPiMin) {
+    if (candidate.hasTOF() && std::abs(candidate.tofNSigmaPi()) < hadronPid.settingCutNsigTOFPiMin) {
       return false;
     }
     mQaRegistry.fill(HIST("h2NsigmaHadPrTOF"), candidate.tofNSigmaPr());
     mQaRegistry.fill(HIST("h2NsigmaHadPiTOF"), candidate.tofNSigmaPi());
     // rejection end
 
-    if (candidate.hasTOF() && candidate.tpcInnerParam() >= settingCutPinMinTOFHad) {
+    if (candidate.hasTOF() && candidate.tpcInnerParam() >= hadronPid.settingCutPinMinTOFHad) {
       auto tofNSigmaKa = candidate.tofNSigmaKa();
 
       mQaRegistry.fill(HIST("h2NsigmaHadTOF_preselection"), candidate.pt(), tofNSigmaKa);
-      if (std::abs(tofNSigmaKa) > settingCutNsigmaTOFHad) {
+      if (std::abs(tofNSigmaKa) > hadronPid.settingCutNsigmaTOFHad) {
         return false;
       }
-      if (std::abs(tpcNSigmaKa) > settingCutNsigmaTPCHad) {
+      if (std::abs(tpcNSigmaKa) > hadronPid.settingCutNsigmaTPCHad) {
         return false;
       }
       mQaRegistry.fill(HIST("h2NsigmaHadTPC"), candidate.sign() * candidate.pt(), tpcNSigmaKa);
@@ -835,8 +905,8 @@ struct HadNucleiFemto {
       mQaRegistry.fill(HIST("h2dEdxHadcandidates"), candidate.sign() * candidate.tpcInnerParam(), candidate.tpcSignal());
       return true;
     }
-    if (candidate.tpcInnerParam() < settingCutPinMinTOFHad) {
-      if (std::abs(tpcNSigmaKa) > settingCutNsigmaTPCHad) {
+    if (candidate.tpcInnerParam() < hadronPid.settingCutPinMinTOFHad) {
+      if (std::abs(tpcNSigmaKa) > hadronPid.settingCutNsigmaTPCHad) {
         return false;
       }
       mQaRegistry.fill(HIST("h2NsigmaHadTPC"), candidate.sign() * candidate.pt(), tpcNSigmaKa);
@@ -853,8 +923,8 @@ struct HadNucleiFemto {
     const float absP = std::abs(candidate.p());
     mQaRegistry.fill(HIST("h2NsigmaHadTPC_preselection"), candidate.sign() * candidate.tpcInnerParam(), tpcNSigmaPi);
 
-    if (absP <= settingPionMomCombMin) {
-      if (std::abs(tpcNSigmaPi) > settingPionTPCNsigMax) {
+    if (absP <= hadronPid.settingPionMomCombMin) {
+      if (std::abs(tpcNSigmaPi) > hadronPid.settingPionTPCNsigMax) {
         return false;
       }
       mQaRegistry.fill(HIST("h2NsigmaHadTPC"), candidate.sign() * candidate.pt(), tpcNSigmaPi);
@@ -870,11 +940,11 @@ struct HadNucleiFemto {
     const float combNsigma = std::sqrt(tofNSigmaPi * tofNSigmaPi + tpcNSigmaPi * tpcNSigmaPi);
     mQaRegistry.fill(HIST("h2NsigmaHadTOF_preselection"), candidate.sign() * candidate.pt(), tofNSigmaPi);
     mQaRegistry.fill(HIST("h2NsigmaHadComb_preselection"), candidate.sign() * candidate.pt(), combNsigma);
-    if (combNsigma > settingPionCombNsigMax) {
+    if (combNsigma > hadronPid.settingPionCombNsigMax) {
       return false;
     }
-    if (settingReqSingleNsig.value &&
-        (std::abs(tpcNSigmaPi) > settingPionCombNsigMax || std::abs(tofNSigmaPi) > settingPionCombNsigMax)) {
+    if (deuteronPid.settingReqSingleNsig.value &&
+        (std::abs(tpcNSigmaPi) > hadronPid.settingPionCombNsigMax || std::abs(tofNSigmaPi) > hadronPid.settingPionCombNsigMax)) {
       return false;
     }
 
@@ -889,13 +959,13 @@ struct HadNucleiFemto {
   bool selectionPIDHadron(const Ttrack& candidate)
   {
     bool PID = false;
-    if (settingHadPDGCode == PDG_t::kPiPlus) {
+    if (species.settingHadPDGCode == PDG_t::kPiPlus) {
       PID = selectionPIDPion(candidate);
       mMassHad = o2::constants::physics::MassPiPlus;
-    } else if (settingHadPDGCode == PDG_t::kKPlus) {
+    } else if (species.settingHadPDGCode == PDG_t::kKPlus) {
       PID = selectionPIDKaon(candidate);
       mMassHad = o2::constants::physics::MassKPlus;
-    } else if (settingHadPDGCode == PDG_t::kProton) {
+    } else if (species.settingHadPDGCode == PDG_t::kProton) {
       PID = selectionPIDProton(candidate);
       mMassHad = o2::constants::physics::MassProton;
     } else {
@@ -907,13 +977,13 @@ struct HadNucleiFemto {
   template <typename Ttrack>
   float getHadronTPCNSigma(const Ttrack& candidate) const
   {
-    if (settingHadPDGCode.value == static_cast<int>(PDG_t::kPiPlus)) {
+    if (species.settingHadPDGCode.value == static_cast<int>(PDG_t::kPiPlus)) {
       return candidate.tpcNSigmaPi();
     }
-    if (settingHadPDGCode.value == static_cast<int>(PDG_t::kKPlus)) {
+    if (species.settingHadPDGCode.value == static_cast<int>(PDG_t::kKPlus)) {
       return candidate.tpcNSigmaKa();
     }
-    if (settingHadPDGCode.value == static_cast<int>(PDG_t::kProton)) {
+    if (species.settingHadPDGCode.value == static_cast<int>(PDG_t::kProton)) {
       return candidate.tpcNSigmaPr();
     }
     return -10.f;
@@ -931,7 +1001,7 @@ struct HadNucleiFemto {
   float correctedTPCInnerParamHe3(const Ttrack& candidate) const
   {
     const bool heliumPID = candidate.pidForTracking() == o2::track::PID::Helium3 || candidate.pidForTracking() == o2::track::PID::Alpha;
-    return (heliumPID && settingCompensatePIDinTracking.value) ? candidate.tpcInnerParam() / 2.f : candidate.tpcInnerParam();
+    return (heliumPID && pidCalibration.settingCompensatePIDinTracking.value) ? candidate.tpcInnerParam() / 2.f : candidate.tpcInnerParam();
   }
 
   template <typename Ttrack>
@@ -949,11 +1019,11 @@ struct HadNucleiFemto {
     float tpcInnerParam = candidate.tpcInnerParam();
     mQaRegistry.fill(HIST("h2dEdx"), candidate.sign() * tpcInnerParam, candidate.tpcSignal());
 
-    if (std::abs(tpcInnerParam) < settingCutPinMinDe) {
+    if (std::abs(tpcInnerParam) < deuteronPid.settingCutPinMinDe) {
       return false;
     }
     float tpcNSigmaDe = 0.f;
-    if (settingUseBBcomputeDeNsigma) {
+    if (output.settingUseBBcomputeDeNsigma) {
       tpcNSigmaDe = computeNSigmaDe(candidate);
     } else {
       tpcNSigmaDe = candidate.tpcNSigmaDe();
@@ -961,7 +1031,7 @@ struct HadNucleiFemto {
 
     mQaRegistry.fill(HIST("h2NsigmaNuTPC_preselection"), candidate.sign() * candidate.pt(), tpcNSigmaDe);
     mQaRegistry.fill(HIST("h2NsigmaNuTPC_preselecComp"), candidate.sign() * candidate.pt(), candidate.tpcNSigmaDe());
-    if (std::abs(candidate.pt()) < settingCutDeptMin || std::abs(candidate.pt()) > settingCutDeptMax) {
+    if (std::abs(candidate.pt()) < deuteronPid.settingCutDeptMin || std::abs(candidate.pt()) > deuteronPid.settingCutDeptMax) {
       return false;
     }
     const float absPt = std::abs(candidate.pt());
@@ -974,15 +1044,15 @@ struct HadNucleiFemto {
       return false;
     }
 
-    if (candidate.hasTOF() && candidate.tpcInnerParam() > settingCutPinMinTOFITSDe) {
+    if (candidate.hasTOF() && candidate.tpcInnerParam() > deuteronPid.settingCutPinMinTOFITSDe) {
       auto tofNSigmaDe = candidate.tofNSigmaDe();
       auto combNsigma = std::sqrt(tofNSigmaDe * tofNSigmaDe + tpcNSigmaDe * tpcNSigmaDe);
       mQaRegistry.fill(HIST("h2NsigmaNuTOF_preselection"), candidate.sign() * candidate.pt(), tofNSigmaDe);
-      if (combNsigma > settingCutNsigmaTOFTPCDe) {
+      if (combNsigma > deuteronPid.settingCutNsigmaTOFTPCDe) {
         return false;
       }
-      if (settingReqSingleNsig.value &&
-          (std::abs(tpcNSigmaDe) > settingCutNsigmaTOFTPCDe || std::abs(tofNSigmaDe) > settingCutNsigmaTOFTPCDe)) {
+      if (deuteronPid.settingReqSingleNsig.value &&
+          (std::abs(tpcNSigmaDe) > deuteronPid.settingCutNsigmaTOFTPCDe || std::abs(tofNSigmaDe) > deuteronPid.settingCutNsigmaTOFTPCDe)) {
         return false;
       }
       mQaRegistry.fill(HIST("h2dEdxNucandidates"), candidate.sign() * tpcInnerParam, candidate.tpcSignal());
@@ -991,14 +1061,14 @@ struct HadNucleiFemto {
       mQaRegistry.fill(HIST("h2NsigmaNuTOF"), candidate.sign() * candidate.pt(), tofNSigmaDe);
       return true;
     }
-    if (candidate.tpcInnerParam() <= settingCutPinMinTOFITSDe) {
-      if (std::abs(tpcNSigmaDe) > settingCutNsigmaTPCDe) {
+    if (candidate.tpcInnerParam() <= deuteronPid.settingCutPinMinTOFITSDe) {
+      if (std::abs(tpcNSigmaDe) > deuteronPid.settingCutNsigmaTPCDe) {
         return false;
       }
       o2::aod::ITSResponse itsResponse;
       auto itsnSigmaDe = itsResponse.nSigmaITS<o2::track::PID::Deuteron>(candidate.itsClusterSizes(), candidate.p(), candidate.eta());
       mQaRegistry.fill(HIST("h2NSigmaNuITS_preselection"), candidate.sign() * candidate.pt(), itsnSigmaDe);
-      if (std::abs(itsnSigmaDe) > settingCutNsigmaITSDe) {
+      if (std::abs(itsnSigmaDe) > deuteronPid.settingCutNsigmaITSDe) {
         return false;
       }
       mQaRegistry.fill(HIST("h2NsigmaNuTPC"), candidate.sign() * candidate.pt(), tpcNSigmaDe);
@@ -1082,10 +1152,10 @@ struct HadNucleiFemto {
   {
     mQaRegistry.fill(HIST("hHe3P_preselected"), V0Hyper.tpcMomHe());
     float averClusSizeHe = averageClusterSizeCosl(V0Hyper.itsClusterSizesHe(), V0Hyper.etaHe3());
-    if (averClusSizeHe <= settingCutAverClsSizeHe) {
+    if (averClusSizeHe <= hypertriton.settingCutAverClsSizeHe) {
       return false;
     }
-    if (V0Hyper.tpcChi2He() <= settingCutTPCChi2He) {
+    if (V0Hyper.tpcChi2He() <= hypertriton.settingCutTPCChi2He) {
       return false;
     }
     mQaRegistry.fill(HIST("hHe3P"), V0Hyper.tpcMomHe());
@@ -1242,7 +1312,7 @@ struct HadNucleiFemto {
       hadNucand.massTOFHad = trackHad.tpcInnerParam() * std::sqrt(1.f / (beta * beta) - 1.f);
     }
 
-    const float massLightNucleusForKstarMt = useHelium3Nucleus() ? static_cast<float>(o2::constants::physics::MassHelium3) : (settingUseProtonMassForKstarMt ? static_cast<float>(o2::constants::physics::MassProton) : static_cast<float>(o2::constants::physics::MassDeuteron));
+    const float massLightNucleusForKstarMt = useHelium3Nucleus() ? static_cast<float>(o2::constants::physics::MassHelium3) : (deuteronPid.settingUseProtonMassForKstarMt ? static_cast<float>(o2::constants::physics::MassProton) : static_cast<float>(o2::constants::physics::MassDeuteron));
     hadNucand.kstar = computePairKstar(hadNucand.momHad, mMassHad, hadNucand.momNu, massLightNucleusForKstarMt);
     hadNucand.mT = computePairMT(hadNucand.momHad, mMassHad, hadNucand.momNu, massLightNucleusForKstarMt);
 
@@ -1346,11 +1416,11 @@ struct HadNucleiFemto {
           continue;
         }
 
-        if (!settingSaveUSandLS) {
-          if (!settingEnableBkgUS && (track0.sign() * track1.sign() < 0)) {
+        if (!eventMixing.settingSaveUSandLS) {
+          if (!eventMixing.settingEnableBkgUS && (track0.sign() * track1.sign() < 0)) {
             continue;
           }
-          if (settingEnableBkgUS && (track0.sign() * track1.sign() > 0)) {
+          if (eventMixing.settingEnableBkgUS && (track0.sign() * track1.sign() > 0)) {
             continue;
           }
         }
@@ -1477,7 +1547,7 @@ struct HadNucleiFemto {
       hadNucand.itsClSizeHad,
       hadNucand.sharedClustersNu,
       hadNucand.sharedClustersHad);
-    if (settingFillMultiplicity) {
+    if (output.settingFillMultiplicity) {
       mOutputMultiplicityTable(
         collision.globalIndex(),
         collision.posZ(),
@@ -1516,7 +1586,7 @@ struct HadNucleiFemto {
       hadNucand.trackIDHad,
       hadNucand.isBkgUS,
       hadNucand.isBkgEM);
-    if (settingFillMultiplicity) {
+    if (output.settingFillMultiplicity) {
       mOutputMultiplicityTable(
         collision.globalIndex(),
         collision.posZ(),
@@ -1592,7 +1662,7 @@ struct HadNucleiFemto {
       fillKstar(hadNucand, collision);
       fillHistograms(hadNucand);
 
-      if (settingFillTable) {
+      if (output.settingFillTable && shouldFillOutputTable(hadNucand)) {
         fillTable(hadNucand, collision);
       }
     }
@@ -1622,7 +1692,7 @@ struct HadNucleiFemto {
 
       auto collision = collisions.rawIteratorAt(hadNucand.collisionID);
 
-      if (settingFillTable) {
+      if (output.settingFillTable) {
         fillTableHyper(hadNucand, collision);
       }
     }
@@ -1737,25 +1807,25 @@ struct HadNucleiFemto {
           fillNucleusTrackSelection(Selections::kTrackCuts);
         }
 
-        if (passTrackHad && settingHadPDGCode == PDG_t::kPiPlus) {
+        if (passTrackHad && species.settingHadPDGCode == PDG_t::kPiPlus) {
           const float tpcNSigmaHad = track.tpcNSigmaPi();
           mQaRegistry.fill(HIST("purity/h2NsigmaHadTPC_preselection"), track.sign() * track.pt(), tpcNSigmaHad);
-          if (track.hasTOF() && std::abs(track.p()) > settingPionMomCombMin) {
+          if (track.hasTOF() && std::abs(track.p()) > hadronPid.settingPionMomCombMin) {
             const float tofNSigmaHad = track.tofNSigmaPi();
             const float combNsigmaHad = std::sqrt(tofNSigmaHad * tofNSigmaHad + tpcNSigmaHad * tpcNSigmaHad);
             mQaRegistry.fill(HIST("purity/h2NsigmaHadTOF_preselection"), track.sign() * track.pt(), tofNSigmaHad);
             mQaRegistry.fill(HIST("purity/h2NsigmaHadComb_preselection"), track.sign() * track.pt(), combNsigmaHad);
           }
-        } else if (passTrackHad && settingHadPDGCode == PDG_t::kKPlus) {
+        } else if (passTrackHad && species.settingHadPDGCode == PDG_t::kKPlus) {
           const float tpcNSigmaHad = track.tpcNSigmaKa();
           mQaRegistry.fill(HIST("purity/h2NsigmaHadTPC_preselection"), track.sign() * track.pt(), tpcNSigmaHad);
-          if (track.hasTOF() && track.tpcInnerParam() >= settingCutPinMinTOFHad) {
+          if (track.hasTOF() && track.tpcInnerParam() >= hadronPid.settingCutPinMinTOFHad) {
             const float tofNSigmaHad = track.tofNSigmaKa();
             const float combNsigmaHad = std::sqrt(tofNSigmaHad * tofNSigmaHad + tpcNSigmaHad * tpcNSigmaHad);
             mQaRegistry.fill(HIST("purity/h2NsigmaHadTOF_preselection"), track.sign() * track.pt(), tofNSigmaHad);
             mQaRegistry.fill(HIST("purity/h2NsigmaHadComb_preselection"), track.sign() * track.pt(), combNsigmaHad);
           }
-        } else if (passTrackHad && settingHadPDGCode == PDG_t::kProton) {
+        } else if (passTrackHad && species.settingHadPDGCode == PDG_t::kProton) {
           constexpr float protonPCombMin = 0.75f;
           const float tpcNSigmaHad = track.tpcNSigmaPr();
           mQaRegistry.fill(HIST("purity/h2NsigmaHadTPC_preselection"), track.sign() * track.pt(), tpcNSigmaHad);
@@ -1768,9 +1838,9 @@ struct HadNucleiFemto {
         }
 
         if (passTrackNu && useDeuteronNucleus()) {
-          const float tpcNSigmaDe = settingUseBBcomputeDeNsigma ? computeNSigmaDe(track) : track.tpcNSigmaDe();
+          const float tpcNSigmaDe = output.settingUseBBcomputeDeNsigma ? computeNSigmaDe(track) : track.tpcNSigmaDe();
           const float absTPCInnerParam = std::abs(track.tpcInnerParam());
-          if (absTPCInnerParam > settingCutPinMinTOFITSDe) {
+          if (absTPCInnerParam > deuteronPid.settingCutPinMinTOFITSDe) {
             mQaRegistry.fill(HIST("purity/h2NsigmaNuTPC_preselection"), track.sign() * track.pt(), tpcNSigmaDe);
             mQaRegistry.fill(HIST("purity/h2NsigmaNuTPC_preselecComp"), track.sign() * track.pt(), track.tpcNSigmaDe());
             if (track.hasTOF()) {
@@ -1783,7 +1853,7 @@ struct HadNucleiFemto {
             o2::aod::ITSResponse itsResponse;
             const float itsNSigmaDe = itsResponse.nSigmaITS<o2::track::PID::Deuteron>(track.itsClusterSizes(), track.p(), track.eta());
             mQaRegistry.fill(HIST("purity/h2NSigmaNuITS_preselection"), track.sign() * track.pt(), itsNSigmaDe);
-            if (std::abs(itsNSigmaDe) <= settingCutNsigmaITSDe) {
+            if (std::abs(itsNSigmaDe) <= deuteronPid.settingCutNsigmaITSDe) {
               mQaRegistry.fill(HIST("purity/h2NsigmaNuTPC_preselection"), track.sign() * track.pt(), tpcNSigmaDe);
               mQaRegistry.fill(HIST("purity/h2NsigmaNuTPC_preselecComp"), track.sign() * track.pt(), track.tpcNSigmaDe());
             }