TPC Workflow: simplify stupid complicated way to pass parameters

Author: davidrohr

Detectors/TPC/workflow/include/TPCWorkflow/CATrackerSpec.h

@@ -29,92 +29,7 @@ namespace tpc
 
 namespace ca
 {
-// The CA tracker is now a wrapper to not only the actual tracking on GPU but
-// also the decoding of the zero-suppressed raw format and the clusterer.
-enum struct Operation {
-  DecompressTPC,          // run cluster decompressor
-  DecompressTPCFromROOT,  // the cluster decompressor input is a root object not flat
-  CAClusterer,            // run the CA clusterer
-  ZSDecoder,              // run the ZS raw data decoder
-  ZSOnTheFly,             // use zs on the fly
-  OutputTracks,           // publish tracks
-  OutputCAClusters,       // publish the clusters produced by CA clusterer
-  OutputCompClusters,     // publish CompClusters container
-  OutputCompClustersFlat, // publish CompClusters container
-  OutputQA,               // Ship QA histograms to QC
-  OutputSharedClusterMap, // Ship optional shared cluster map
-  ProcessMC,              // process MC labels
-  SendClustersPerSector,  // Send clusters and clusters mc labels per sector
-  Noop,                   // skip argument on the constructor
-};
-
-/// Helper struct to pass the individual ca::Operation flags to
-/// the processor spec. The struct is initialized by a variable list of
-/// constructor arguments.
 struct Config {
-  Config(const Config&) = default;
-  template <typename... Args>
-  Config(Args&&... args)
-  {
-    init(std::forward<Args>(args)...);
-  }
-
-  template <typename... Args>
-  void init(Operation const& op, Args&&... args)
-  {
-    switch (op) {
-      case Operation::DecompressTPC:
-        decompressTPC = true;
-        break;
-      case Operation::DecompressTPCFromROOT:
-        decompressTPCFromROOT = true;
-        break;
-      case Operation::CAClusterer:
-        caClusterer = true;
-        break;
-      case Operation::ZSDecoder:
-        zsDecoder = true;
-        break;
-      case Operation::ZSOnTheFly:
-        zsOnTheFly = true;
-        break;
-      case Operation::OutputTracks:
-        outputTracks = true;
-        break;
-      case Operation::OutputCompClusters:
-        outputCompClusters = true;
-        break;
-      case Operation::OutputCompClustersFlat:
-        outputCompClustersFlat = true;
-        break;
-      case Operation::OutputCAClusters:
-        outputCAClusters = true;
-        break;
-      case Operation::OutputQA:
-        outputQA = true;
-        break;
-      case Operation::OutputSharedClusterMap:
-        outputSharedClusterMap = true;
-        break;
-      case Operation::ProcessMC:
-        processMC = true;
-        break;
-      case Operation::SendClustersPerSector:
-        sendClustersPerSector = true;
-        break;
-      case Operation::Noop:
-        break;
-      default:
-        throw std::runtime_error("invalid CATracker operation");
-    }
-    if constexpr (sizeof...(args) > 0) {
-      init(std::forward<Args>(args)...);
-    }
-  }
-
-  // Cannot specialize constructor to create proper copy constructor directly --> must overload init
-  void init(const Config& x) { *this = x; }
-
   bool decompressTPC = false;
   bool decompressTPCFromROOT = false;
   bool caClusterer = false;
@@ -129,7 +44,6 @@ struct Config {
   bool processMC = false;
   bool sendClustersPerSector = false;
 };
-
 } // namespace ca
 
 /// create a processor spec for the CATracker

Detectors/TPC/workflow/src/RecoWorkflow.cxx

@@ -421,22 +421,21 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
   //
   // selected by output type 'tracks'
   if (runTracker) {
-    specs.emplace_back(o2::tpc::getCATrackerSpec(policyData, ca::Config{
-                                                               propagateMC ? ca::Operation::ProcessMC : ca::Operation::Noop,
-                                                               decompressTPC ? ca::Operation::DecompressTPC : ca::Operation::Noop,
-                                                               decompressTPC && inputType == InputType::CompClusters ? ca::Operation::DecompressTPCFromROOT : ca::Operation::Noop,
-                                                               caClusterer ? ca::Operation::CAClusterer : ca::Operation::Noop,
-                                                               zsDecoder ? ca::Operation::ZSDecoder : ca::Operation::Noop,
-                                                               zsOnTheFly ? ca::Operation::ZSOnTheFly : ca::Operation::Noop,
-                                                               produceTracks ? ca::Operation::OutputTracks : ca::Operation::Noop,
-                                                               produceCompClusters ? ca::Operation::OutputCompClusters : ca::Operation::Noop,
-                                                               runClusterEncoder ? ca::Operation::OutputCompClustersFlat : ca::Operation::Noop,
-                                                               isEnabled(OutputType::SendClustersPerSector) ? ca::Operation::SendClustersPerSector : ca::Operation::Noop,
-                                                               isEnabled(OutputType::QA) ? ca::Operation::OutputQA : ca::Operation::Noop,
-                                                               isEnabled(OutputType::Clusters) && (caClusterer || decompressTPC) ? ca::Operation::OutputCAClusters : ca::Operation::Noop,
-                                                               isEnabled(OutputType::Clusters) && isEnabled(OutputType::Tracks) && !isEnabled(OutputType::NoSharedClusterMap) ? ca::Operation::OutputSharedClusterMap : ca::Operation::Noop,
-                                                             },
-                                                 tpcSectors));
+    ca::Config cfg;
+    cfg.decompressTPC = decompressTPC;
+    cfg.decompressTPCFromROOT = decompressTPC && inputType == InputType::CompClusters;
+    cfg.caClusterer = caClusterer;
+    cfg.zsDecoder = zsDecoder;
+    cfg.zsOnTheFly = zsOnTheFly;
+    cfg.outputTracks = produceTracks;
+    cfg.outputCompClusters = produceCompClusters;
+    cfg.outputCompClustersFlat = runClusterEncoder;
+    cfg.outputCAClusters = isEnabled(OutputType::Clusters) && (caClusterer || decompressTPC);
+    cfg.outputQA = isEnabled(OutputType::QA);
+    cfg.outputSharedClusterMap = isEnabled(OutputType::Clusters) && isEnabled(OutputType::Tracks) && !isEnabled(OutputType::NoSharedClusterMap);
+    cfg.processMC = propagateMC;
+    cfg.sendClustersPerSector = isEnabled(OutputType::SendClustersPerSector);
+    specs.emplace_back(o2::tpc::getCATrackerSpec(policyData, cfg, tpcSectors));
   }
 
   //////////////////////////////////////////////////////////////////////////////////////////////