Work towards getting the TPC Tracking QA run standalone from a tracks ROOT file

Detectors/TPC/qc/include/TPCQC/Tracking.h

@@ -32,6 +32,7 @@ class MCCompLabel;
 namespace gpu
 {
 class GPUO2InterfaceQA;
+struct GPUO2InterfaceConfiguration;
 } // namespace gpu
 namespace tpc
 {
@@ -78,6 +79,7 @@ class Tracking
   void getHists(const std::vector<TH1F>*& h1, const std::vector<TH2F>*& h2, const std::vector<TH1D>*& h3) const;
 
  private:
+  std::unique_ptr<o2::gpu::GPUO2InterfaceConfiguration> mQAConfig; //!
   std::unique_ptr<o2::gpu::GPUO2InterfaceQA> mQA; //!
   outputModes mOutputMode;
 

Detectors/TPC/qc/src/Tracking.cxx

@@ -28,6 +28,8 @@
 #include "TPCQC/Tracking.h"
 #include "GPUO2InterfaceQA.h"
 #include "GPUO2InterfaceConfiguration.h"
+#include "DetectorsCommonDataFormats/NameConf.h"
+#include "DataFormatsParameters/GRPObject.h"
 
 ClassImp(o2::tpc::qc::Tracking);
 
@@ -37,15 +39,23 @@ using namespace o2::gpu;
 Tracking::Tracking() = default;
 Tracking::~Tracking() = default;
 
-static constexpr int QAMODE = 7;
+static constexpr int QAMODE = 7; // Efficiency (1) | Res (2) | Pull (3), others are not supported from external input!
 
 //______________________________________________________________________________
 void Tracking::initialize(outputModes outputMode, bool postprocessOnly)
 {
   mOutputMode = outputMode;
-  GPUO2InterfaceConfiguration config;
-  config.configQA.shipToQCAsCanvas = mOutputMode == outputLayout;
-  mQA = std::make_unique<GPUO2InterfaceQA>(&config.configQA);
+  mQAConfig = std::make_unique<GPUO2InterfaceConfiguration>();
+  const auto grp = o2::parameters::GRPObject::loadFrom(o2::base::NameConf::getGRPFileName());
+  if (grp) {
+    mQAConfig->configEvent.solenoidBz = 5.00668f * grp->getL3Current() / 30000.;
+    mQAConfig->configEvent.continuousMaxTimeBin = grp->isDetContinuousReadOut(o2::detectors::DetID::TPC) ? -1 : 0;
+  } else {
+    throw std::runtime_error("Failed to initialize run parameters from GRP");
+  }
+  mQAConfig->ReadConfigurableParam();
+  mQAConfig->configQA.shipToQCAsCanvas = mOutputMode == outputLayout;
+  mQA = std::make_unique<GPUO2InterfaceQA>(mQAConfig.get());
   if (!postprocessOnly) {
     mQA->initializeForProcessing(QAMODE);
   }

Detectors/TPC/workflow/src/CATrackerSpec.cxx

@@ -104,7 +104,7 @@ DataProcessorSpec getCATrackerSpec(CompletionPolicyData* policyData, ca::Config
     std::unique_ptr<TPCFastTransform> fastTransform;
     std::unique_ptr<TPCdEdxCalibrationSplines> dEdxSplines;
     std::unique_ptr<TPCPadGainCalib> tpcPadGainCalib;
-    std::unique_ptr<GPUSettingsQA> qaConfig;
+    std::unique_ptr<GPUO2InterfaceConfiguration> config;
     int qaTaskMask = 0;
     std::unique_ptr<GPUO2InterfaceQA> qa;
     std::vector<int> clusterOutputIds;
@@ -121,7 +121,8 @@ DataProcessorSpec getCATrackerSpec(CompletionPolicyData* policyData, ca::Config
     processAttributes->tpcSectorMask |= (1ul << s);
   }
   auto initFunction = [processAttributes, specconfig](InitContext& ic) {
-    GPUO2InterfaceConfiguration config;
+    processAttributes->config.reset(new GPUO2InterfaceConfiguration);
+    GPUO2InterfaceConfiguration& config = *processAttributes->config.get();
     GPUSettingsO2 confParam;
     {
       auto& parser = processAttributes->parser;
@@ -259,8 +260,7 @@ DataProcessorSpec getCATrackerSpec(CompletionPolicyData* policyData, ca::Config
         throw std::invalid_argument("GPUCATracking initialization failed");
       }
       if (specconfig.outputQA) {
-        processAttributes->qaConfig.reset(new GPUSettingsQA(config.configQA));
-        processAttributes->qa = std::make_unique<GPUO2InterfaceQA>(processAttributes->qaConfig.get());
+        processAttributes->qa = std::make_unique<GPUO2InterfaceQA>(processAttributes->config.get());
       }
       timer.Stop();
       timer.Reset();

GPU/GPUTracking/Interface/GPUO2InterfaceQA.cxx

@@ -11,14 +11,19 @@
 /// \file GPUO2InterfaceQA.cxx
 /// \author David Rohr
 
+#include "GPUParam.h"
 #include "GPUQA.h"
+#include "GPUO2InterfaceConfiguration.h"
 #include "GPUO2InterfaceQA.h"
 
 using namespace o2::gpu;
 using namespace o2::tpc;
 
-GPUO2InterfaceQA::GPUO2InterfaceQA(const GPUSettingsQA* config) : mQA(new GPUQA(nullptr, config))
+GPUO2InterfaceQA::GPUO2InterfaceQA(const GPUO2InterfaceConfiguration* config)
 {
+  mParam.reset(new GPUParam);
+  mParam->SetDefaults(&config->configEvent, &config->configReconstruction, &config->configProcessing, nullptr);
+  mQA.reset(new GPUQA(nullptr, &config->configQA, mParam.get()));
 }
 
 GPUO2InterfaceQA::~GPUO2InterfaceQA() = default;

GPU/GPUTracking/Interface/GPUO2InterfaceQA.h

@@ -46,11 +46,12 @@ struct ClusterNativeAccess;
 namespace o2::gpu
 {
 class GPUQA;
-class GPUSettingsQA;
+class GPUParam;
+class GPUO2InterfaceConfiguration;
 class GPUO2InterfaceQA
 {
  public:
-  GPUO2InterfaceQA(const GPUSettingsQA* config = nullptr);
+  GPUO2InterfaceQA(const GPUO2InterfaceConfiguration* config = nullptr);
   ~GPUO2InterfaceQA();
 
   int initializeForProcessing(int tasks); // only needed for processing, not for postprocessing
@@ -67,6 +68,7 @@ class GPUO2InterfaceQA
 
  private:
   std::unique_ptr<GPUQA> mQA;
+  std::unique_ptr<GPUParam> mParam;
 };
 } // namespace o2::gpu
 

GPU/GPUTracking/Standalone/qa/GPUQA.cxx

@@ -324,7 +324,7 @@ void GPUQA::clearGarbagageCollector()
   std::apply([](auto&&... args) { ((args.clear()), ...); }, mGarbageCollector->v);
 }
 
-GPUQA::GPUQA(GPUChainTracking* chain, const GPUSettingsQA* config) : mTracking(chain), mConfig(config ? *config : GPUQA_GetConfig(chain)), mGarbageCollector(std::make_unique<GPUQAGarbageCollection>())
+GPUQA::GPUQA(GPUChainTracking* chain, const GPUSettingsQA* config, const GPUParam* param) : mTracking(chain), mConfig(config ? *config : GPUQA_GetConfig(chain)), mParam(param ? *param : chain->GetParam()), mGarbageCollector(std::make_unique<GPUQAGarbageCollection>())
 {
   static int initColorsInitialized = initColors();
   (void)initColorsInitialized;
@@ -756,9 +756,9 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
     mcLabelBuffer[mNEvents - 1].resize(mTracking->mIOPtrs.nMergedTracks);
   }
 
-  bool mcAvail = mcPresent();
+  bool mcAvail = mcPresent() || tracksExtMC;
 
-  if (mcAvail && mTracking->GetParam().rec.NonConsecutiveIDs) {
+  if (mcAvail && !tracksExtMC && mTracking->GetParam().rec.NonConsecutiveIDs) {
     GPUError("QA incompatible to non-consecutive MC labels");
     return;
   }
@@ -1088,8 +1088,8 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
       GPUTPCGMPropagator prop;
       prop.SetMaxSinPhi(.999);
       prop.SetMaterialTPC();
-      prop.SetPolynomialField(&mTracking->GetParam().polynomialField);
-      prop.SetToyMCEventsFlag(mTracking->GetParam().par.ToyMCEventsFlag);
+      prop.SetPolynomialField(&mParam.polynomialField);
+      prop.SetToyMCEventsFlag(mParam.par.ToyMCEventsFlag);
 
       for (unsigned int i = 0; i < mTrackMCLabels.size(); i++) {
         if (mConfig.writeMCLabels) {
@@ -1188,11 +1188,11 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
         }
 
         auto getdz = [this, &param, &mc1, &side]() {
-          if (!mTracking->GetParam().par.continuousMaxTimeBin) {
+          if (!mParam.par.continuousMaxTimeBin) {
             return param.Z() - mc1.z;
           }
 #ifdef GPUCA_TPC_GEOMETRY_O2
-          if (!mTracking->GetParam().par.earlyTpcTransform) {
+          if (!mParam.par.earlyTpcTransform) {
             float shift = side == 2 ? 0 : mTracking->GetTPCTransform()->convDeltaTimeToDeltaZinTimeFrame(side * GPUChainTracking::NSLICES / 2, param.GetTZOffset() - mc1.t0);
             return param.GetZ() + shift - mc1.z;
           }
@@ -2263,8 +2263,9 @@ int GPUQA::DrawQAHistograms(TObjArray* qcout)
         }
         if (!mConfig.inputHistogramsOnly && mcAvail) {
           TH1D* e = hist;
-          e->GetEntries();
-          e->Fit("gaus", "sQ");
+          if (e && e->GetEntries()) {
+            e->Fit("gaus", "sQ");
+          }
         }
 
         float tmpMax = 0;

GPU/GPUTracking/Standalone/qa/GPUQA.h

@@ -83,14 +83,15 @@ struct AliHLTTPCClusterMCLabel;
 namespace GPUCA_NAMESPACE::gpu
 {
 class GPUChainTracking;
+class GPUParam;
 struct GPUTPCMCInfo;
 struct GPUQAGarbageCollection;
 
 class GPUQA
 {
  public:
   GPUQA();
-  GPUQA(GPUChainTracking* chain, const GPUSettingsQA* config = nullptr);
+  GPUQA(GPUChainTracking* chain, const GPUSettingsQA* config = nullptr, const GPUParam* param = nullptr);
   ~GPUQA();
 
   int InitQA(int tasks = -1);
@@ -206,6 +207,7 @@ class GPUQA
 
   GPUChainTracking* mTracking;
   const GPUSettingsQA& mConfig;
+  const GPUParam& mParam;
 
   const char* str_perf_figure_1 = "ALICE Performance 2018/03/20";
   // const char* str_perf_figure_2 = "2015, MC pp, #sqrt{s} = 5.02 TeV";