tof-compressor.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 "TOFCompression/CompressorTask.h"
#include "Framework/WorkflowSpec.h"
#include "Framework/ConfigParamSpec.h"
#include "Framework/ConcreteDataMatcher.h"
#include "Framework/Logger.h"
#include "DetectorsRaw/RDHUtils.h"
#include "CommonUtils/ConfigurableParam.h"
#include "CommonUtils/NameConf.h"
 
using namespace o2::framework;
 
// add workflow options, note that customization needs to be declared before
// including Framework/runDataProcessing
void customize(std::vector<ConfigParamSpec>& workflowOptions)
{
  auto config = ConfigParamSpec{"tof-compressor-config", VariantType::String, "x:TOF/RAWDATA", {"TOF compressor workflow configuration"}};
  auto outputDesc = ConfigParamSpec{"tof-compressor-output-desc", VariantType::String, "CRAWDATA", {"Output specs description string"}};
  auto rdhVersion = ConfigParamSpec{"tof-compressor-rdh-version", VariantType::Int, o2::raw::RDHUtils::getVersion<o2::header::RAWDataHeader>(), {"Raw Data Header version"}};
  auto verbose = ConfigParamSpec{"tof-compressor-verbose", VariantType::Bool, false, {"Enable verbose compressor"}};
  auto paranoid = ConfigParamSpec{"tof-compressor-paranoid", VariantType::Bool, false, {"Enable paranoid compressor"}};
  auto ignoreStf = ConfigParamSpec{"ignore-dist-stf", VariantType::Bool, false, {"do not subscribe to FLP/DISTSUBTIMEFRAME/0 message (no lost TF recovery)"}};
  auto payloadlim = ConfigParamSpec{"payload-limit", VariantType::Int64, -1ll, {"Payload limit in Byte (-1 -> no limits)"}};
 
  workflowOptions.push_back(config);
  workflowOptions.push_back(outputDesc);
  workflowOptions.push_back(rdhVersion);
  workflowOptions.push_back(verbose);
  workflowOptions.push_back(paranoid);
  workflowOptions.push_back(ignoreStf);
  workflowOptions.push_back(payloadlim);
  workflowOptions.push_back(ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}});
}
 
#include "Framework/runDataProcessing.h" // the main driver
 
WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
{
  o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
  auto config = cfgc.options().get<std::string>("tof-compressor-config");
  //  auto outputDesc = cfgc.options().get<std::string>("output-desc");
  auto rdhVersion = cfgc.options().get<int>("tof-compressor-rdh-version");
  auto verbose = cfgc.options().get<bool>("tof-compressor-verbose");
  auto paranoid = cfgc.options().get<bool>("tof-compressor-paranoid");
  auto ignoreStf = cfgc.options().get<bool>("ignore-dist-stf");
  auto payloadLim = cfgc.options().get<long>("payload-limit");
 
  std::vector<OutputSpec> outputs;
  outputs.emplace_back(OutputSpec(ConcreteDataTypeMatcher{"TOF", "CRAWDATA"}));
 
  AlgorithmSpec algoSpec;
  if (rdhVersion == o2::raw::RDHUtils::getVersion<o2::header::RAWDataHeader>()) {
    if (!verbose && !paranoid) {
      algoSpec = AlgorithmSpec{adaptFromTask<o2::tof::CompressorTask<o2::header::RAWDataHeader, false, false>>(payloadLim)};
    }
    if (!verbose && paranoid) {
      algoSpec = AlgorithmSpec{adaptFromTask<o2::tof::CompressorTask<o2::header::RAWDataHeader, false, true>>(payloadLim)};
    }
    if (verbose && !paranoid) {
      algoSpec = AlgorithmSpec{adaptFromTask<o2::tof::CompressorTask<o2::header::RAWDataHeader, true, false>>(payloadLim)};
    }
    if (verbose && paranoid) {
      algoSpec = AlgorithmSpec{adaptFromTask<o2::tof::CompressorTask<o2::header::RAWDataHeader, true, true>>(payloadLim)};
    }
  }
 
  WorkflowSpec workflow;
 
  std::stringstream ssconfig(config);
  std::string iconfig;
  int idevice = 0;
 
  while (getline(ssconfig, iconfig, ',')) {
    std::vector<InputSpec> inputs = select(iconfig.c_str());
    if (!ignoreStf) {
      inputs.emplace_back("stdDist", "FLP", "DISTSUBTIMEFRAME", 0, Lifetime::Timeframe);
    }
    workflow.emplace_back(DataProcessorSpec{
      std::string("tof-compressor-") + std::to_string(idevice),
      //      select(iconfig.c_str()),
      inputs,
      outputs,
      algoSpec,
      Options{
        {"tof-compressor-output-buffer-size", VariantType::Int, 1048576, {"Encoder output buffer size (in bytes). Zero = automatic (careful)."}},
        {"tof-compressor-conet-mode", VariantType::Bool, false, {"Decoder CONET flag"}},
        {"tof-compressor-decoder-verbose", VariantType::Bool, false, {"Decoder verbose flag"}},
        {"tof-compressor-encoder-verbose", VariantType::Bool, false, {"Encoder verbose flag"}},
        {"tof-compressor-checker-verbose", VariantType::Bool, false, {"Checker verbose flag"}}}});
    idevice++;
  }
 
  return workflow;
}