use multiple configs for one exec

jesgum · jesgum · commit ad1e5f3fa1eb · 2025-11-12T14:25:48.000+01:00
diff --git a/ALICE3/Core/DelphesO2TrackSmearer.cxx b/ALICE3/Core/DelphesO2TrackSmearer.cxx
@@ -48,6 +48,16 @@ namespace delphes
 {
 
 /*****************************************************************/
+// bool TrackSmearer::closeTable(int pdg, const char* filename)
+// {
+//   const std::string outPath = "/tmp/LUTs/";
+//   const std::string filePath = Form("%s/%s/snapshot.root", outPath.c_str(), filename);
+//   std::ifstream checkFile(filePath);
+//   if (!checkFile.is_open()) {
+//     LOG(warning) << "--- Could not find table to close.";
+//   }
+//   checkFile.close();
+// }
 
 bool TrackSmearer::loadTable(int pdg, const char* filename, bool forceReload)
 {
diff --git a/ALICE3/DataModel/OTFMulticharm.h b/ALICE3/DataModel/OTFMulticharm.h
@@ -36,6 +36,7 @@ DECLARE_SOA_INDEX_COLUMN_FULL(XiCCPion, xiCCPion, int, Tracks, "_PiXiCC");
 
 DECLARE_SOA_COLUMN(XicMass, xicMass, float);
 DECLARE_SOA_COLUMN(XiccMass, xiccMass, float);
+DECLARE_SOA_COLUMN(LUTConfigId, lutConfigId, int); //! Index for LUT configuration
 
 // kine vars
 DECLARE_SOA_COLUMN(XiccPt, xiccPt, float);
@@ -155,7 +156,8 @@ DECLARE_SOA_TABLE(MCharmCores, "AOD", "MCharmCores",
                   otfmulticharm::XiccProperLength,
                   otfmulticharm::Pi1cPt,
                   otfmulticharm::Pi2cPt,
-                  otfmulticharm::PiccPt);
+                  otfmulticharm::PiccPt,
+                  otfmulticharm::LUTConfigId);
 
 DECLARE_SOA_TABLE(MCharmPID, "AOD", "MCharmPID",
                   otfmulticharm::Pi1cTofDeltaInner,
diff --git a/ALICE3/DataModel/OTFTracks.h b/ALICE3/DataModel/OTFTracks.h
@@ -0,0 +1,35 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+///
+/// \file   OTFTracks.h
+/// \author Jesper Karlsson Gumprecht
+/// \since  11/11/2025
+/// \brief  Table to map track to LUT configuration
+///
+
+#ifndef ALICE3_DATAMODEL_OTFTRACKS_H_
+#define ALICE3_DATAMODEL_OTFTRACKS_H_
+
+// O2 includes
+#include "Framework/AnalysisDataModel.h"
+
+namespace o2::aod
+{
+namespace otftracks
+{
+DECLARE_SOA_COLUMN(LUTConfigId, lutConfigId, int); //! Index for LUT configuration
+} // namespace otftracks
+
+DECLARE_SOA_TABLE(OTFLUTConfigId, "AOD", "OTFLUTConfigId", otftracks::LUTConfigId);
+} // namespace o2::aod
+
+#endif // ALICE3_DATAMODEL_OTFMULTICHARM_H_
diff --git a/ALICE3/TableProducer/OTF/onTheFlyTracker.cxx b/ALICE3/TableProducer/OTF/onTheFlyTracker.cxx
@@ -28,6 +28,7 @@
 #include "ALICE3/Core/FastTracker.h"
 #include "ALICE3/Core/TrackUtilities.h"
 #include "ALICE3/DataModel/OTFStrangeness.h"
+#include "ALICE3/DataModel/OTFTracks.h"
 #include "ALICE3/DataModel/collisionAlice3.h"
 #include "ALICE3/DataModel/tracksAlice3.h"
 #include "Common/Core/RecoDecay.h"
@@ -64,6 +65,8 @@
 using namespace o2;
 using namespace o2::framework;
 using std::array;
+#define getHist(type, name) std::get<std::shared_ptr<type>>(histPointers[name])
+
 
 struct OnTheFlyTracker {
   Produces<aod::Collisions> tableCollisions;
@@ -79,6 +82,7 @@ struct OnTheFlyTracker {
   Produces<aod::TracksAlice3> tableTracksAlice3;
   Produces<aod::TracksExtraA3> tableTracksExtraA3;
   Produces<aod::UpgradeCascades> tableUpgradeCascades;
+  Produces<aod::OTFLUTConfigId> tableOTFLUTConfigId;
 
   // optionally produced, empty (to be tuned later)
   Produces<aod::StoredTracksExtra_002> tableStoredTracksExtra; // base table, extend later
@@ -106,15 +110,18 @@ struct OnTheFlyTracker {
   Configurable<bool> doExtraQA{"doExtraQA", false, "do extra 2D QA plots"};
   Configurable<bool> extraQAwithoutDecayDaughters{"extraQAwithoutDecayDaughters", false, "remove decay daughters from qa plots (yes/no)"};
 
-  Configurable<std::string> lutEl{"lutEl", "lutCovm.el.dat", "LUT for electrons (if emtpy no LUT is taken)"};
-  Configurable<std::string> lutMu{"lutMu", "lutCovm.mu.dat", "LUT for muons (if emtpy no LUT is taken)"};
-  Configurable<std::string> lutPi{"lutPi", "lutCovm.pi.dat", "LUT for pions (if emtpy no LUT is taken)"};
-  Configurable<std::string> lutKa{"lutKa", "lutCovm.ka.dat", "LUT for kaons (if emtpy no LUT is taken)"};
-  Configurable<std::string> lutPr{"lutPr", "lutCovm.pr.dat", "LUT for protons (if emtpy no LUT is taken)"};
-  Configurable<std::string> lutDe{"lutDe", "", "LUT for deuterons (if emtpy no LUT is taken)"};
-  Configurable<std::string> lutTr{"lutTr", "", "LUT for tritons (if emtpy no LUT is taken)"};
-  Configurable<std::string> lutHe3{"lutHe3", "", "LUT for Helium-3 (if emtpy no LUT is taken)"};
-  Configurable<std::string> lutAl{"lutAl", "", "LUT for Alphas (if emtpy no LUT is taken)"};
+  struct : ConfigurableGroup {
+    std::string prefix = "lookUpTables"; // JSON group name
+    Configurable<std::vector<std::string>> lutEl{"lutEl", std::vector<std::string>{"lutCovm.el.dat"}, "LUT for electrons (if emtpy no LUT is taken)"};
+    Configurable<std::vector<std::string>> lutMu{"lutMu", std::vector<std::string>{"lutCovm.mu.dat"}, "LUT for muons (if emtpy no LUT is taken)"};
+    Configurable<std::vector<std::string>> lutPi{"lutPi", std::vector<std::string>{"lutCovm.pi.dat"}, "LUT for pions (if emtpy no LUT is taken)"};
+    Configurable<std::vector<std::string>> lutKa{"lutKa", std::vector<std::string>{"lutCovm.ka.dat"}, "LUT for kaons (if emtpy no LUT is taken)"};
+    Configurable<std::vector<std::string>> lutPr{"lutPr", std::vector<std::string>{"lutCovm.pr.dat"}, "LUT for protons (if emtpy no LUT is taken)"};
+    Configurable<std::vector<std::string>> lutDe{"lutDe", std::vector<std::string>{""}, "LUT for deuterons (if emtpy no LUT is taken)"};
+    Configurable<std::vector<std::string>> lutTr{"lutTr", std::vector<std::string>{""}, "LUT for tritons (if emtpy no LUT is taken)"};
+    Configurable<std::vector<std::string>> lutHe3{"lutHe3", std::vector<std::string>{""}, "LUT for Helium-3 (if emtpy no LUT is taken)"};
+    Configurable<std::vector<std::string>> lutAl{"lutAl", std::vector<std::string>{""}, "LUT for Alphas (if emtpy no LUT is taken)"};
+  } lookUpTables;
 
   struct : ConfigurableGroup {
     ConfigurableAxis axisMomentum{"axisMomentum", {VARIABLE_WIDTH, 0.0f, 0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.6f, 1.7f, 1.8f, 1.9f, 2.0f, 2.2f, 2.4f, 2.6f, 2.8f, 3.0f, 3.2f, 3.4f, 3.6f, 3.8f, 4.0f, 4.4f, 4.8f, 5.2f, 5.6f, 6.0f, 6.5f, 7.0f, 7.5f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 30.0f, 35.0f, 40.0f, 50.0f}, "#it{p} (GeV/#it{c})"};
@@ -238,11 +245,12 @@ struct OnTheFlyTracker {
 
   // for handling basic QA histograms if requested
   HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject};
+  std::map<std::string, HistPtr> histPointers;
 
   o2::base::Propagator::MatCorrType matCorr = o2::base::Propagator::MatCorrType::USEMatCorrNONE;
 
   // Track smearer
-  o2::delphes::DelphesO2TrackSmearer mSmearer;
+  std::vector<std::unique_ptr<o2::delphes::DelphesO2TrackSmearer>> mSmearer;
 
   // For processing and vertexing
   std::vector<TrackAlice3> tracksAlice3;
@@ -255,37 +263,72 @@ struct OnTheFlyTracker {
   // For TGenPhaseSpace seed
   TRandom3 rand;
   Service<o2::ccdb::BasicCCDBManager> ccdb;
-
+  
+  static constexpr int kMaxLUTConfigs = 20;
   void init(o2::framework::InitContext&)
   {
-
+    
     ccdb->setURL("http://alice-ccdb.cern.ch");
     ccdb->setTimestamp(-1);
 
     if (enableLUT) {
-      mSmearer.setCcdbManager(ccdb.operator->());
-
-      auto loadLUT = [&](int pdg, const std::string& lutFile) {
-        bool success = mSmearer.loadTable(pdg, lutFile.c_str());
+      auto loadLUT = [&](int icfg, int pdg, const std::vector<std::string>& tables) {
+        const bool foundNewCfg = static_cast<size_t>(icfg) < tables.size();
+        const std::string& lutFile = foundNewCfg ? tables[icfg] : tables.front();
+        bool success = mSmearer[icfg]->loadTable(pdg, lutFile.c_str());
         if (!success && !lutFile.empty()) {
           LOG(fatal) << "Having issue with loading the LUT " << pdg << " " << lutFile;
         }
+
+        return foundNewCfg;
       };
-      loadLUT(kElectron, lutEl.value);
-      loadLUT(kMuonMinus, lutMu.value);
-      loadLUT(kPiPlus, lutPi.value);
-      loadLUT(kKPlus, lutKa.value);
-      loadLUT(kProton, lutPr.value);
-      loadLUT(o2::constants::physics::kDeuteron, lutDe.value);
-      loadLUT(o2::constants::physics::kTriton, lutTr.value);
-      loadLUT(o2::constants::physics::kHelium3, lutHe3.value);
-      loadLUT(o2::constants::physics::kAlpha, lutAl.value);
-
-      // interpolate efficiencies if requested to do so
-      mSmearer.interpolateEfficiency(static_cast<bool>(interpolateLutEfficiencyVsNch));
-
-      // smear un-reco'ed tracks if asked to do so
-      mSmearer.skipUnreconstructed(static_cast<bool>(!processUnreconstructedTracks));
+      
+      for (int icfg = 0; icfg < kMaxLUTConfigs; ++icfg) {
+        mSmearer.emplace_back(std::make_unique<o2::delphes::DelphesO2TrackSmearer>());
+        mSmearer[icfg]->setCcdbManager(ccdb.operator->());
+
+        // check if more configs were provided, fall back to first entry
+        bool newLUTLoaded = false;
+        newLUTLoaded |= loadLUT(icfg, kElectron, lookUpTables.lutEl.value);
+        newLUTLoaded |= loadLUT(icfg, kMuonMinus, lookUpTables.lutMu.value);
+        newLUTLoaded |= loadLUT(icfg, kPiPlus, lookUpTables.lutPi.value);
+        newLUTLoaded |= loadLUT(icfg, kKPlus, lookUpTables.lutKa.value);
+        newLUTLoaded |= loadLUT(icfg, kProton, lookUpTables.lutPr.value);
+        newLUTLoaded |= loadLUT(icfg, o2::constants::physics::kDeuteron, lookUpTables.lutDe.value);
+        newLUTLoaded |= loadLUT(icfg, o2::constants::physics::kTriton, lookUpTables.lutTr.value);
+        newLUTLoaded |= loadLUT(icfg, o2::constants::physics::kHelium3, lookUpTables.lutHe3.value);
+        newLUTLoaded |= loadLUT(icfg, o2::constants::physics::kAlpha, lookUpTables.lutAl.value);
+
+        if (!newLUTLoaded) {
+          mSmearer.pop_back();
+          break;
+        }
+    
+        // interpolate efficiencies if requested to do so
+        mSmearer[icfg]->interpolateEfficiency(static_cast<bool>(interpolateLutEfficiencyVsNch));
+  
+        // smear un-reco'ed tracks if asked to do so
+        mSmearer[icfg]->skipUnreconstructed(static_cast<bool>(!processUnreconstructedTracks));
+
+        std::string histPath = "Configuration_" + std::to_string(icfg) + "/";
+        histPointers.insert({histPath + "hPtGenerated", histos.add((histPath + "hPtGenerated").c_str(), "hPtGenerated", {kTH1D, {{axes.axisMomentum}}})});
+        histPointers.insert({histPath + "hPtGeneratedEl", histos.add((histPath + "hPtGeneratedEl").c_str(), "hPtGeneratedEl", {kTH1D, {{axes.axisMomentum}}})});
+        histPointers.insert({histPath + "hPtGeneratedPi", histos.add((histPath + "hPtGeneratedPi").c_str(), "hPtGeneratedPi", {kTH1D, {{axes.axisMomentum}}})});
+        histPointers.insert({histPath + "hPtGeneratedKa", histos.add((histPath + "hPtGeneratedKa").c_str(), "hPtGeneratedKa", {kTH1D, {{axes.axisMomentum}}})});
+        histPointers.insert({histPath + "hPtGeneratedPr", histos.add((histPath + "hPtGeneratedPr").c_str(), "hPtGeneratedPr", {kTH1D, {{axes.axisMomentum}}})});
+        histPointers.insert({histPath + "hPtReconstructed", histos.add((histPath + "hPtReconstructed").c_str(), "hPtReconstructed", {kTH1D, {{axes.axisMomentum}}})});
+        histPointers.insert({histPath + "hPtReconstructedEl", histos.add((histPath + "hPtReconstructedEl").c_str(), "hPtReconstructedEl", {kTH1D, {{axes.axisMomentum}}})});
+        histPointers.insert({histPath + "hPtReconstructedPi", histos.add((histPath + "hPtReconstructedPi").c_str(), "hPtReconstructedPi", {kTH1D, {{axes.axisMomentum}}})});
+        histPointers.insert({histPath + "hPtReconstructedKa", histos.add((histPath + "hPtReconstructedKa").c_str(), "hPtReconstructedKa", {kTH1D, {{axes.axisMomentum}}})});
+        histPointers.insert({histPath + "hPtReconstructedPr", histos.add((histPath + "hPtReconstructedPr").c_str(), "hPtReconstructedPr", {kTH1D, {{axes.axisMomentum}}})});
+        
+        // Collision QA
+        histPointers.insert({histPath + "hPVz", histos.add((histPath + "hPVz").c_str(), "hPVz", {kTH1D, {{axes.axisVertexZ}}})});
+        histPointers.insert({histPath + "hLUTMultiplicity", histos.add((histPath + "hLUTMultiplicity").c_str(), "hLUTMultiplicity", {kTH1D, {{axes.axisMultiplicity}}})});
+        histPointers.insert({histPath + "hSimMultiplicity", histos.add((histPath + "hSimMultiplicity").c_str(), "hSimMultiplicity", {kTH1D, {{axes.axisMultiplicity}}})});
+        histPointers.insert({histPath + "hRecoMultiplicity", histos.add((histPath + "hRecoMultiplicity").c_str(), "hRecoMultiplicity", {kTH1D, {{axes.axisMultiplicity}}})});
+
+      } // end config loop
     }
 
     // Basic QA
@@ -303,23 +346,6 @@ struct OnTheFlyTracker {
     hCovMatOK->GetXaxis()->SetBinLabel(1, "Not OK");
     hCovMatOK->GetXaxis()->SetBinLabel(2, "OK");
 
-    histos.add("hPtGenerated", "hPtGenerated", kTH1F, {axes.axisMomentum});
-    histos.add("hPtGeneratedEl", "hPtGeneratedEl", kTH1F, {axes.axisMomentum});
-    histos.add("hPtGeneratedPi", "hPtGeneratedPi", kTH1F, {axes.axisMomentum});
-    histos.add("hPtGeneratedKa", "hPtGeneratedKa", kTH1F, {axes.axisMomentum});
-    histos.add("hPtGeneratedPr", "hPtGeneratedPr", kTH1F, {axes.axisMomentum});
-    histos.add("hPtReconstructed", "hPtReconstructed", kTH1F, {axes.axisMomentum});
-    histos.add("hPtReconstructedEl", "hPtReconstructedEl", kTH1F, {axes.axisMomentum});
-    histos.add("hPtReconstructedPi", "hPtReconstructedPi", kTH1F, {axes.axisMomentum});
-    histos.add("hPtReconstructedKa", "hPtReconstructedKa", kTH1F, {axes.axisMomentum});
-    histos.add("hPtReconstructedPr", "hPtReconstructedPr", kTH1F, {axes.axisMomentum});
-
-    // Collision QA
-    histos.add("hPVz", "hPVz", kTH1F, {axes.axisVertexZ});
-    histos.add("hLUTMultiplicity", "hLUTMultiplicity", kTH1F, {axes.axisMultiplicity});
-    histos.add("hSimMultiplicity", "hSimMultiplicity", kTH1F, {axes.axisMultiplicity});
-    histos.add("hRecoMultiplicity", "hRecoMultiplicity", kTH1F, {axes.axisMultiplicity});
-
     if (doExtraQA) {
       histos.add("h2dVerticesVsContributors", "h2dVerticesVsContributors", kTH2F, {axes.axisMultiplicity, axes.axisNVertices});
       histos.add("hRecoVsSimMultiplicity", "hRecoVsSimMultiplicity", kTH2F, {axes.axisMultiplicity, axes.axisMultiplicity});
@@ -520,9 +546,10 @@ struct OnTheFlyTracker {
   }
 
   float dNdEta = 0.f; // Charged particle multiplicity to use in the efficiency evaluation
-  void process(aod::McCollision const& mcCollision, aod::McParticles const& mcParticles)
+  void processWithLUTs(aod::McCollision const& mcCollision, aod::McParticles const& mcParticles, int const& cfgId)
   {
     int lastTrackIndex = tableStoredTracksCov.lastIndex() + 1; // bookkeep the last added track
+    const std::string histPath = "Configuration_" + std::to_string(cfgId) + "/";
 
     tracksAlice3.clear();
     ghostTracksAlice3.clear();
@@ -579,7 +606,8 @@ struct OnTheFlyTracker {
 
     dNdEta /= (multEtaRange * 2.0f);
     uint32_t multiplicityCounter = 0;
-    histos.fill(HIST("hLUTMultiplicity"), dNdEta);
+    getHist(TH1, histPath + "hLUTMultiplicity")->Fill(dNdEta);
+
     gRandom->SetSeed(seed);
 
     for (const auto& mcParticle : mcParticles) {
@@ -613,15 +641,16 @@ struct OnTheFlyTracker {
         continue;
       }
 
-      histos.fill(HIST("hPtGenerated"), mcParticle.pt());
+      
+      getHist(TH1, histPath + "hPtGenerated")->Fill(mcParticle.pt());
       if (std::abs(mcParticle.pdgCode()) == kElectron)
-        histos.fill(HIST("hPtGeneratedEl"), mcParticle.pt());
+        getHist(TH1, histPath + "hPtGeneratedEl")->Fill(mcParticle.pt());
       if (std::abs(mcParticle.pdgCode()) == kPiPlus)
-        histos.fill(HIST("hPtGeneratedPi"), mcParticle.pt());
+        getHist(TH1, histPath + "hPtGeneratedPi")->Fill(mcParticle.pt());
       if (std::abs(mcParticle.pdgCode()) == kKPlus)
-        histos.fill(HIST("hPtGeneratedKa"), mcParticle.pt());
+        getHist(TH1, histPath + "hPtGeneratedKa")->Fill(mcParticle.pt());
       if (std::abs(mcParticle.pdgCode()) == kProton)
-        histos.fill(HIST("hPtGeneratedPr"), mcParticle.pt());
+        getHist(TH1, histPath + "hPtGeneratedPr")->Fill(mcParticle.pt());
 
       if (cascadeDecaySettings.doXiQA && mcParticle.pdgCode() == kXiMinus) {
         histos.fill(HIST("hGenXi"), xiDecayRadius2D, mcParticle.pt());
@@ -916,7 +945,7 @@ struct OnTheFlyTracker {
 
       bool reconstructed = true;
       if (enablePrimarySmearing && !fastPrimaryTrackerSettings.fastTrackPrimaries) {
-        reconstructed = mSmearer.smearTrack(trackParCov, mcParticle.pdgCode(), dNdEta);
+        reconstructed = mSmearer[cfgId]->smearTrack(trackParCov, mcParticle.pdgCode(), dNdEta);
       } else if (fastPrimaryTrackerSettings.fastTrackPrimaries) {
         o2::track::TrackParCov o2Track;
         o2::upgrade::convertMCParticleToO2Track(mcParticle, o2Track, pdgDB);
@@ -938,15 +967,15 @@ struct OnTheFlyTracker {
       }
 
       // Base QA (note: reco pT here)
-      histos.fill(HIST("hPtReconstructed"), trackParCov.getPt());
+      getHist(TH1, histPath + "hPtReconstructed")->Fill(trackParCov.getPt());
       if (std::abs(mcParticle.pdgCode()) == kElectron)
-        histos.fill(HIST("hPtReconstructedEl"), mcParticle.pt());
+        getHist(TH1, histPath + "hPtReconstructedEl")->Fill(trackParCov.getPt());
       if (std::abs(mcParticle.pdgCode()) == kPiPlus)
-        histos.fill(HIST("hPtReconstructedPi"), mcParticle.pt());
+        getHist(TH1, histPath + "hPtReconstructedPi")->Fill(trackParCov.getPt());
       if (std::abs(mcParticle.pdgCode()) == kKPlus)
-        histos.fill(HIST("hPtReconstructedKa"), mcParticle.pt());
+        getHist(TH1, histPath + "hPtReconstructedKa")->Fill(trackParCov.getPt());
       if (std::abs(mcParticle.pdgCode()) == kProton)
-        histos.fill(HIST("hPtReconstructedPr"), mcParticle.pt());
+        getHist(TH1, histPath + "hPtReconstructedPr")->Fill(trackParCov.getPt());
 
       if (doExtraQA) {
         histos.fill(HIST("hRecoTrackX"), trackParCov.getX());
@@ -1010,9 +1039,13 @@ struct OnTheFlyTracker {
     // *+~+*+~+*+~+*+~+*+~+*+~+*+~+*+~+*+~+*+~+*+~+*+~+*+~+*+~+*
 
     // debug / informational
-    histos.fill(HIST("hSimMultiplicity"), multiplicityCounter);
-    histos.fill(HIST("hRecoMultiplicity"), tracksAlice3.size());
-    histos.fill(HIST("hPVz"), primaryVertex.getZ());
+    // histos.fill(HIST("hSimMultiplicity"), multiplicityCounter);
+    // histos.fill(HIST("hRecoMultiplicity"), tracksAlice3.size());
+    // histos.fill(HIST("hPVz"), primaryVertex.getZ());
+    getHist(TH1, histPath + "hSimMultiplicity")->Fill(multiplicityCounter);
+    getHist(TH1, histPath + "hRecoMultiplicity")->Fill(tracksAlice3.size());
+    getHist(TH1, histPath + "hPVz")->Fill(primaryVertex.getZ());
+
 
     if (doExtraQA) {
       histos.fill(HIST("hRecoVsSimMultiplicity"), multiplicityCounter, tracksAlice3.size());
@@ -1071,6 +1104,7 @@ struct OnTheFlyTracker {
           tableTracksDCACov(dcaInfo.getSigmaY2(), dcaInfo.getSigmaZ2());
         }
       }
+      tableOTFLUTConfigId(cfgId);
       tableStoredTracks(tableCollisions.lastIndex(), trackType, trackParCov.getX(), trackParCov.getAlpha(), trackParCov.getY(), trackParCov.getZ(), trackParCov.getSnp(), trackParCov.getTgl(), trackParCov.getQ2Pt());
       tableTracksExtension(trackParCov.getPt(), trackParCov.getP(), trackParCov.getEta(), trackParCov.getPhi());
 
@@ -1168,6 +1202,16 @@ struct OnTheFlyTracker {
     histos.fill(HIST("hCovMatOK"), 0.0f, fastTracker.GetCovMatNotOK());
     histos.fill(HIST("hCovMatOK"), 1.0f, fastTracker.GetCovMatOK());
   } // end process
+
+  void process(aod::McCollision const& mcCollision, aod::McParticles const& mcParticles)
+  {
+    static int ievt = 0;
+    std::cout << "Proccesing event " << ievt << std::endl;
+    for (size_t icfg = 0; icfg < mSmearer.size(); ++icfg) {
+      processWithLUTs(mcCollision, mcParticles, static_cast<int>(icfg));
+    }
+    ievt++;
+  }
 };
 
 /// Extends TracksExtra if necessary
diff --git a/ALICE3/TableProducer/alice3-multicharmTable.cxx b/ALICE3/TableProducer/alice3-multicharmTable.cxx
diff --git a/ALICE3/Tasks/alice3-multicharm.cxx b/ALICE3/Tasks/alice3-multicharm.cxx
