tpc-residual-aggregator.cxx

Go to the documentation of this file.

// 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.
 
#include "Framework/DataProcessorSpec.h"
#include "SpacePoints/ResidualAggregator.h"
#include "TPCInterpolationWorkflow/TPCResidualAggregatorSpec.h"
#include "TPCInterpolationWorkflow/TPCUnbinnedResidualReaderSpec.h"
#include "GlobalTrackingWorkflowHelpers/InputHelper.h"
#include "DetectorsRaw/HBFUtilsInitializer.h"
#include "Framework/CallbacksPolicy.h"
 
using namespace o2::framework;
using GID = o2::dataformats::GlobalTrackID;
 
void customize(std::vector<o2::framework::CallbacksPolicy>& policies)
{
  o2::raw::HBFUtilsInitializer::addNewTimeSliceCallback(policies);
}
 
// we need to add workflow options before including Framework/runDataProcessing
void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
{
  std::vector<o2::framework::ConfigParamSpec> options{
    {"output-type", VariantType::String, "unbinnedResid,trackParams", {"Comma separated list of outputs (without spaces). Valid strings: unbinnedResid, binnedResid, trackParams"}},
    {"enable-track-input", VariantType::Bool, false, {"Whether to expect track data from interpolation workflow"}},
    {"enable-ctp", VariantType::Bool, false, {"Subscribe to lumi info from CTP"}},
    {"enable-mc", VariantType::Bool, false, {"Whether to expect the MC truth of the track data from interpolation workflow (requires enable-track-input)"}},
    {"disable-root-input", VariantType::Bool, false, {"disable root-files input readers"}},
    {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
  o2::raw::HBFUtilsInitializer::addConfigOption(options);
  std::swap(workflowOptions, options);
}
 
// ------------------------------------------------------------------
 
#include "Framework/runDataProcessing.h"
 
WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
{
  o2::conf::ConfigurableParam::updateFromString(configcontext.options().get<std::string>("configKeyValues"));
  auto trkInput = configcontext.options().get<bool>("enable-track-input");
  auto ctpInput = configcontext.options().get<bool>("enable-ctp");
  auto mcInput = configcontext.options().get<bool>("enable-mc");
  if (mcInput && !trkInput) {
    LOG(error) << "MC truth input requires the track input (enable-track-input), will be ignored";
    mcInput = false;
  }
 
  bool writeUnbinnedResiduals = false;
  bool writeBinnedResiduals = false;
  bool writeTrackData = false;
  auto outputType = configcontext.options().get<std::string>("output-type");
  std::vector<std::string> outputTypes;
  size_t pos = 0;
  while ((pos = outputType.find(",")) != std::string::npos) {
    outputTypes.push_back(outputType.substr(0, pos));
    outputType.erase(0, pos + 1);
  }
  outputTypes.push_back(outputType);
  for (const auto& out : outputTypes) {
    if (out == "unbinnedResid") {
      writeUnbinnedResiduals = true;
    } else if (out == "binnedResid") {
      writeBinnedResiduals = true;
    } else if (out == "trackParams") {
      if (!trkInput) {
        LOG(error) << "Track output will be empty, because it is not configured as input";
      }
      writeTrackData = true;
    } else {
      LOG(error) << "Invalid output requested: " << out;
    }
  }
 
  WorkflowSpec specs;
  if (!configcontext.options().get<bool>("disable-root-input")) {
    specs.emplace_back(o2::tpc::getUnbinnedTPCResidualsReaderSpec(trkInput, mcInput));
  }
  specs.emplace_back(getTPCResidualAggregatorSpec(trkInput, ctpInput, writeUnbinnedResiduals, writeBinnedResiduals, writeTrackData, mcInput));
 
  // CTP input
  if (ctpInput) {
    auto maskClusters = GID::getSourcesMask("CTP");
    auto maskNone = GID::getSourcesMask(GID::NONE);
    o2::globaltracking::InputHelper::addInputSpecs(configcontext, specs, maskClusters, maskNone, maskNone, false);
  }
 
  // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
  o2::raw::HBFUtilsInitializer hbfIni(configcontext, specs);
 
  return specs;
}