Migrate to CCDB tables for analysis

Author: ktf

Common/TableProducer/trackPropagationV2.cxx

@@ -11,6 +11,7 @@
 
 //
 // Task to add a table of track parameters propagated to the primary vertex
+// V2: GRPMagField and MeanVertexObject migrated to declarative CCDB columns.
 //
 
 #include "Common/Core/TableHelper.h"
@@ -19,7 +20,6 @@
 #include "Common/Tools/TrackTuner.h"
 
 #include <CCDB/BasicCCDBManager.h>
-#include <CommonConstants/GeomConstants.h>
 #include <DataFormatsCalibration/MeanVertexObject.h>
 #include <DataFormatsParameters/GRPMagField.h>
 #include <DetectorsBase/MatLayerCylSet.h>
@@ -48,19 +48,27 @@
 #include <cmath>
 #include <string>
 
-// The Run 3 AO2D stores the tracks at the point of innermost update. For a track with ITS this is the innermost (or second innermost)
-// ITS layer. For a track without ITS, this is the TPC inner wall or for loopers in the TPC even a radius beyond that.
-// In order to use the track parameters, the tracks have to be propagated to the collision vertex which is done by this task.
-// The task consumes the TracksIU and TracksCovIU tables and produces Tracks and TracksCov to which then the user analysis can subscribe.
-//
-// This task is not needed for Run 2 converted data.
-// There are two versions of the task (see process flags), one producing also the covariance matrix and the other only the tracks table.
+// Declarative CCDB columns for GRPMagField and MeanVertexObject.
+// MatLayerCylSet is intentionally excluded: it requires
+// MatLayerCylSet::rectifyPtrFromFile() after deserialisation, a type-specific
+// fixup the CCDB column mechanism does not perform.  It continues to be fetched
+// via Service<BasicCCDBManager> below.
+namespace o2::aod
+{
+namespace trackpropv2
+{
+DECLARE_SOA_CCDB_COLUMN(GRPMagField, grpMagField, o2::parameters::GRPMagField, "GLO/Config/GRPMagField");   //!
+DECLARE_SOA_CCDB_COLUMN(MeanVertex, meanVertex, o2::dataformats::MeanVertexObject, "GLO/Calib/MeanVertex"); //!
+} // namespace trackpropv2
+
+DECLARE_SOA_TIMESTAMPED_TABLE(TrackPropV2CCDBObjects, aod::Timestamps, o2::aod::timestamp::Timestamp, 1, "TRKPROPV2CC", //!
+                              trackpropv2::GRPMagField, trackpropv2::MeanVertex);
+} // namespace o2::aod
 
 using namespace o2;
 using namespace o2::framework;
-// using namespace o2::framework::expressions;
 
-struct TrackPropagation {
+struct TrackPropagationV2 {
   Produces<aod::StoredTracks> tracksParPropagated;
   Produces<aod::TracksExtension> tracksParExtensionPropagated;
 
@@ -72,25 +80,28 @@ struct TrackPropagation {
 
   Produces<aod::TrackTunerTable> tunertable;
 
+  // MatLUT still fetched via BasicCCDBManager (requires rectifyPtrFromFile).
+  // GRPMagField and MeanVertex are now sourced from CCDB columns on the BC.
   Service<o2::ccdb::BasicCCDBManager> ccdb;
 
   bool fillTracksDCA = false;
   bool fillTracksDCACov = false;
-  int runNumber = -1;
+  int runNumber = -1; // tracks current run for per-run B-field re-initialisation
 
   o2::base::Propagator::MatCorrType matCorr = o2::base::Propagator::MatCorrType::USEMatCorrLUT;
 
-  const o2::dataformats::MeanVertexObject* mMeanVtx = nullptr;
-  o2::parameters::GRPMagField* grpmag = nullptr;
   o2::base::MatLayerCylSet* lut = nullptr;
   TrackTuner trackTunerObj;
 
+  // MatLUT path: still fetched manually (see note above)
   Configurable<std::string> ccdburl{"ccdb-url", "http://alice-ccdb.cern.ch", "url of the ccdb repository"};
   Configurable<std::string> lutPath{"lutPath", "GLO/Param/MatLUT", "Path of the Lut parametrization"};
   Configurable<std::string> geoPath{"geoPath", "GLO/Config/GeometryAligned", "Path of the geometry file"};
-  Configurable<std::string> grpmagPath{"grpmagPath", "GLO/Config/GRPMagField", "CCDB path of the GRPMagField object"};
-  Configurable<std::string> mVtxPath{"mVtxPath", "GLO/Calib/MeanVertex", "Path of the mean vertex file"};
-  Configurable<float> minPropagationRadius{"minPropagationDistance", o2::constants::geom::XTPCInnerRef + 0.1, "Only tracks which are at a smaller radius will be propagated, defaults to TPC inner wall"};
+  // Declarative CCDB path overrides — replace the old grpmagPath / mVtxPath Configurables.
+  // Option names: "ccdb:fGRPMagField" and "ccdb:fMeanVertex" respectively.
+  ConfigurableCCDBPath<trackpropv2::GRPMagField> grpmagPath;
+  ConfigurableCCDBPath<trackpropv2::MeanVertex> mVtxPath;
+
   // for TrackTuner only (MC smearing)
   Configurable<bool> useTrackTuner{"useTrackTuner", false, "Apply track tuner corrections to MC"};
   Configurable<bool> fillTrackTunerTable{"fillTrackTunerTable", false, "flag to fill track tuner table"};
@@ -99,10 +110,8 @@ struct TrackPropagation {
   ConfigurableAxis axisPtQA{"axisPtQA", {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}, "pt axis for QA histograms"};
   OutputObj<TH1D> trackTunedTracks{TH1D("trackTunedTracks", "", 1, 0.5, 1.5), OutputObjHandlingPolicy::AnalysisObject};
 
-  // OutputObj<TH2F> hDCAxyVsPtRec{TH2F("hDCAxyVsPtRec", ";DCAxy;PtRec", 600, -0.15, 0.15, axisPtQA)};
-  // OutputObj<TH2F> hDCAxyVsPtMC{TH2F("hDCAxyVsPtMC", ";DCAxy;PtMC", 600, -0.15, 0.15, axisPtQA)};
-
   using TracksIUWithMc = soa::Join<aod::StoredTracksIU, aod::McTrackLabels, aod::TracksCovIU>;
+  using MyBCs = soa::Join<aod::BCsWithTimestamps, aod::TrackPropV2CCDBObjects>;
 
   HistogramRegistry registry{"registry"};
 
@@ -117,12 +126,10 @@ struct TrackPropagation {
       LOG(info) << "Enabling processCovarianceMc";
       nEnabledProcesses++;
     }
-
     if (doprocessCovariance) {
       LOG(info) << "Enabling processCovariance";
       nEnabledProcesses++;
     }
-
     if (doprocessStandardWithPID) {
       LOG(info) << "Enabling processStandardWithPID";
       nEnabledProcesses++;
@@ -138,6 +145,7 @@ struct TrackPropagation {
     fillTracksDCA = o2::common::core::isTableRequiredInWorkflow(initContext, "TracksDCA");
     fillTracksDCACov = o2::common::core::isTableRequiredInWorkflow(initContext, "TracksDCACov");
 
+    // Only needed for the MatLUT fetch; GRPMagField and MeanVertex use CCDB columns
     ccdb->setURL(ccdburl);
     ccdb->setCaching(true);
     ccdb->setLocalObjectValidityChecking();
@@ -159,37 +167,33 @@ struct TrackPropagation {
         case aod::track_tuner::Configurables:
           outputStringParams = trackTunerObj.configParams();
           break;
-
         default:
           LOG(fatal) << "TrackTuner configuration source not defined. Fix it! (Supported options: input string (1); Configurables (2))";
           break;
       }
-
       trackTunerObj.getDcaGraphs();
       trackTunedTracks->SetTitle(outputStringParams.c_str());
       trackTunedTracks->GetXaxis()->SetBinLabel(1, "all tracks");
     }
   }
 
-  void initCCDB(aod::BCsWithTimestamps::iterator const& bc)
+  // Initialises the MatLUT (once per job) and the B-field (once per run).
+  // GRPMagField is now read directly from the CCDB column on the BC row;
+  // only the MatLUT still requires a manual fetch + rectifyPtrFromFile.
+  template <typename TBC>
+  void initCCDB(TBC const& bc)
   {
-    if (runNumber == bc.runNumber()) {
-      return;
-    }
-
-    // load matLUT for this timestamp
     if (!lut) {
       LOG(info) << "Loading material look-up table for timestamp: " << bc.timestamp();
       lut = o2::base::MatLayerCylSet::rectifyPtrFromFile(ccdb->getForTimeStamp<o2::base::MatLayerCylSet>(lutPath, bc.timestamp()));
-    } else {
-      LOG(info) << "Material look-up table already in place. Not reloading.";
+      o2::base::Propagator::Instance()->setMatLUT(lut);
     }
-
-    grpmag = ccdb->getForTimeStamp<o2::parameters::GRPMagField>(grpmagPath, bc.timestamp());
-    LOG(info) << "Setting magnetic field to current " << grpmag->getL3Current() << " A for run " << bc.runNumber() << " from its GRPMagField CCDB object";
-    o2::base::Propagator::initFieldFromGRP(grpmag);
-    o2::base::Propagator::Instance()->setMatLUT(lut);
-    mMeanVtx = ccdb->getForTimeStamp<o2::dataformats::MeanVertexObject>(mVtxPath, bc.timestamp());
+    if (runNumber == bc.runNumber()) {
+      return;
+    }
+    const auto& grpmag = bc.grpMagField(); // from declarative CCDB column
+    LOG(info) << "Setting magnetic field to current " << grpmag.getL3Current() << " A for run " << bc.runNumber() << " from its GRPMagField CCDB column";
+    o2::base::Propagator::initFieldFromGRP(&grpmag);
     runNumber = bc.runNumber();
   }
 
@@ -200,16 +204,20 @@ struct TrackPropagation {
   o2::track::TrackParametrization<float> mTrackPar;
   o2::track::TrackParametrizationWithError<float> mTrackParCov;
 
+  Configurable<float> minPropagationRadius{"minPropagationDistance", o2::constants::geom::XTPCInnerRef + 0.1, "Only tracks which are at a smaller radius will be propagated, defaults to TPC inner wall"};
+
   template <typename TTrack, typename TParticle, bool isMc, bool fillCovMat = false, bool useTrkPid = false>
   void fillTrackTables(TTrack const& tracks,
                        TParticle const&,
                        aod::Collisions const&,
-                       aod::BCsWithTimestamps const& bcs)
+                       MyBCs const& bcs)
   {
     if (bcs.size() == 0) {
       return;
     }
-    initCCDB(bcs.begin());
+    auto bc0 = bcs.begin();
+    initCCDB(bc0);
+    const auto& meanVertex = bc0.meanVertex(); // from declarative CCDB column
 
     if constexpr (fillCovMat) {
       tracksParCovPropagated.reserve(tracks.size());
@@ -244,15 +252,11 @@ struct TrackPropagation {
           mTrackPar.setPID(track.pidForTracking());
         }
       }
-      // auto trackParCov = getTrackParCov(track);
       aod::track::TrackTypeEnum trackType = (aod::track::TrackTypeEnum)track.trackType();
-      // std::array<float, 3> trackPxPyPz;
-      // std::array<float, 3> trackPxPyPzTuned = {0.0, 0.0, 0.0};
       double q2OverPtNew = -9999.;
       // Only propagate tracks which have passed the innermost wall of the TPC (e.g. skipping loopers etc). Others fill unpropagated.
       if (track.trackType() == aod::track::TrackIU && track.x() < minPropagationRadius) {
         if constexpr (isMc && fillCovMat) { // checking MC and fillCovMat block begins
-          // bool hasMcParticle = track.has_mcParticle();
           if (useTrackTuner) {
             trackTunedTracks->Fill(1); // all tracks
             bool hasMcParticle = track.has_mcParticle();
@@ -276,11 +280,11 @@ struct TrackPropagation {
           }
         } else {
           if constexpr (fillCovMat) {
-            mVtx.setPos({mMeanVtx->getX(), mMeanVtx->getY(), mMeanVtx->getZ()});
-            mVtx.setCov(mMeanVtx->getSigmaX() * mMeanVtx->getSigmaX(), 0.0f, mMeanVtx->getSigmaY() * mMeanVtx->getSigmaY(), 0.0f, 0.0f, mMeanVtx->getSigmaZ() * mMeanVtx->getSigmaZ());
+            mVtx.setPos({meanVertex.getX(), meanVertex.getY(), meanVertex.getZ()});
+            mVtx.setCov(meanVertex.getSigmaX() * meanVertex.getSigmaX(), 0.0f, meanVertex.getSigmaY() * meanVertex.getSigmaY(), 0.0f, 0.0f, meanVertex.getSigmaZ() * meanVertex.getSigmaZ());
             isPropagationOK = o2::base::Propagator::Instance()->propagateToDCABxByBz(mVtx, mTrackParCov, 2.f, matCorr, &mDcaInfoCov);
           } else {
-            isPropagationOK = o2::base::Propagator::Instance()->propagateToDCABxByBz({mMeanVtx->getX(), mMeanVtx->getY(), mMeanVtx->getZ()}, mTrackPar, 2.f, matCorr, &mDcaInfo);
+            isPropagationOK = o2::base::Propagator::Instance()->propagateToDCABxByBz({meanVertex.getX(), meanVertex.getY(), meanVertex.getZ()}, mTrackPar, 2.f, matCorr, &mDcaInfo);
           }
         }
         if (isPropagationOK) {
@@ -290,7 +294,6 @@ struct TrackPropagation {
         if constexpr (isMc && fillCovMat) { // checking MC and fillCovMat block begins
           if (track.has_mcParticle() && isPropagationOK) {
             auto mcParticle1 = track.mcParticle();
-            // && abs(mcParticle1.pdgCode())==211
             if (mcParticle1.isPhysicalPrimary()) {
               registry.fill(HIST("hDCAxyVsPtRec"), mDcaInfoCov.getY(), mTrackParCov.getPt());
               registry.fill(HIST("hDCAxyVsPtMC"), mDcaInfoCov.getY(), mcParticle1.pt());
@@ -304,7 +307,6 @@ struct TrackPropagation {
       if (useTrackTuner && fillTrackTunerTable) {
         tunertable(q2OverPtNew);
       }
-      // LOG(info) <<  " trackPropagation (this value filled in tuner table)--> "  << q2OverPtNew;
       if constexpr (fillCovMat) {
         tracksParPropagated(track.collisionId(), trackType, mTrackParCov.getX(), mTrackParCov.getAlpha(), mTrackParCov.getY(), mTrackParCov.getZ(), mTrackParCov.getSnp(), mTrackParCov.getTgl(), mTrackParCov.getQ2Pt());
         tracksParExtensionPropagated(mTrackParCov.getPt(), mTrackParCov.getP(), mTrackParCov.getEta(), mTrackParCov.getPhi());
@@ -331,38 +333,35 @@ struct TrackPropagation {
     }
   }
 
-  void processStandard(aod::StoredTracksIU const& tracks, aod::Collisions const& collisions, aod::BCsWithTimestamps const& bcs)
+  void processStandard(aod::StoredTracksIU const& tracks, aod::Collisions const& collisions, MyBCs const& bcs)
   {
     fillTrackTables</*TTrack*/ aod::StoredTracksIU, /*Particle*/ aod::StoredTracksIU, /*isMc = */ false, /*fillCovMat =*/false, /*useTrkPid =*/false>(tracks, tracks, collisions, bcs);
   }
-  PROCESS_SWITCH(TrackPropagation, processStandard, "Process without covariance", true);
+  PROCESS_SWITCH(TrackPropagationV2, processStandard, "Process without covariance", true);
 
-  void processStandardWithPID(soa::Join<aod::StoredTracksIU, aod::TracksExtra> const& tracks, aod::Collisions const& collisions, aod::BCsWithTimestamps const& bcs)
+  void processStandardWithPID(soa::Join<aod::StoredTracksIU, aod::TracksExtra> const& tracks, aod::Collisions const& collisions, MyBCs const& bcs)
   {
     fillTrackTables</*TTrack*/ soa::Join<aod::StoredTracksIU, aod::TracksExtra>, /*Particle*/ soa::Join<aod::StoredTracksIU, aod::TracksExtra>, /*isMc = */ false, /*fillCovMat =*/false, /*useTrkPid =*/true>(tracks, tracks, collisions, bcs);
   }
-  PROCESS_SWITCH(TrackPropagation, processStandardWithPID, "Process without covariance and with PID in tracking", false);
+  PROCESS_SWITCH(TrackPropagationV2, processStandardWithPID, "Process without covariance and with PID in tracking", false);
 
-  // -----------------------
-  void processCovarianceMc(TracksIUWithMc const& tracks, aod::McParticles const& mcParticles, aod::Collisions const& collisions, aod::BCsWithTimestamps const& bcs)
+  void processCovarianceMc(TracksIUWithMc const& tracks, aod::McParticles const& mcParticles, aod::Collisions const& collisions, MyBCs const& bcs)
   {
-    // auto table_extension = soa::Extend<TracksIUWithMc, aod::extension::MomX>(tracks);
     fillTrackTables</*TTrack*/ TracksIUWithMc, /*Particle*/ aod::McParticles, /*isMc = */ true, /*fillCovMat =*/true, /*useTrkPid =*/false>(tracks, mcParticles, collisions, bcs);
   }
-  PROCESS_SWITCH(TrackPropagation, processCovarianceMc, "Process with covariance on MC", false);
+  PROCESS_SWITCH(TrackPropagationV2, processCovarianceMc, "Process with covariance on MC", false);
 
-  void processCovariance(soa::Join<aod::StoredTracksIU, aod::TracksCovIU> const& tracks, aod::Collisions const& collisions, aod::BCsWithTimestamps const& bcs)
+  void processCovariance(soa::Join<aod::StoredTracksIU, aod::TracksCovIU> const& tracks, aod::Collisions const& collisions, MyBCs const& bcs)
   {
     fillTrackTables</*TTrack*/ soa::Join<aod::StoredTracksIU, aod::TracksCovIU>, /*Particle*/ soa::Join<aod::StoredTracksIU, aod::TracksCovIU>, /*isMc = */ false, /*fillCovMat =*/true, /*useTrkPid =*/false>(tracks, tracks, collisions, bcs);
   }
-  PROCESS_SWITCH(TrackPropagation, processCovariance, "Process with covariance", false);
-  // ------------------------
+  PROCESS_SWITCH(TrackPropagationV2, processCovariance, "Process with covariance", false);
 
-  void processCovarianceWithPID(soa::Join<aod::StoredTracksIU, aod::TracksCovIU, aod::TracksExtra> const& tracks, aod::Collisions const& collisions, aod::BCsWithTimestamps const& bcs)
+  void processCovarianceWithPID(soa::Join<aod::StoredTracksIU, aod::TracksCovIU, aod::TracksExtra> const& tracks, aod::Collisions const& collisions, MyBCs const& bcs)
   {
     fillTrackTables</*TTrack*/ soa::Join<aod::StoredTracksIU, aod::TracksCovIU, aod::TracksExtra>, /*Particle*/ soa::Join<aod::StoredTracksIU, aod::TracksCovIU, aod::TracksExtra>, /*isMc = */ false, /*fillCovMat =*/true, /*useTrkPid =*/false>(tracks, tracks, collisions, bcs);
   }
-  PROCESS_SWITCH(TrackPropagation, processCovarianceWithPID, "Process with covariance and with PID in tracking", false);
+  PROCESS_SWITCH(TrackPropagationV2, processCovarianceWithPID, "Process with covariance and with PID in tracking", false);
 };
 
 //****************************************************************************************
@@ -372,6 +371,6 @@ struct TrackPropagation {
 //****************************************************************************************
 WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
 {
-  WorkflowSpec workflow{adaptAnalysisTask<TrackPropagation>(cfgc)};
+  WorkflowSpec workflow{adaptAnalysisTask<TrackPropagationV2>(cfgc)};
   return workflow;
 }