PreClusterFinderSpec.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 "MCHPreClustering/PreClusterFinderSpec.h"
 
#include <iostream>
#include <fstream>
#include <chrono>
#include <vector>
#include <stdexcept>
 
#include <gsl/span>
 
#include "Framework/CallbackService.h"
#include "Framework/ConfigParamRegistry.h"
#include "Framework/ControlService.h"
#include "Framework/DataProcessorSpec.h"
#include "Framework/Lifetime.h"
#include "Framework/Output.h"
#include "Framework/Task.h"
#include "Framework/Logger.h"
#include "Framework/WorkflowSpec.h"
 
#include "DataFormatsMCH/ROFRecord.h"
#include "MCHBase/Error.h"
#include "MCHBase/ErrorMap.h"
#include "MCHBase/PreCluster.h"
#include "MCHBase/SanityCheck.h"
#include "MCHPreClustering/PreClusterFinder.h"
 
#include <iostream>
#include <chrono>
#include <vector>
 
namespace o2
{
namespace mch
{
 
using namespace std;
using namespace o2::framework;
 
enum tCheckNoLeftoverDigits {
  CHECK_NO_LEFTOVER_DIGITS_QUIET,
  CHECK_NO_LEFTOVER_DIGITS_ERROR,
  CHECK_NO_LEFTOVER_DIGITS_FATAL
};
 
class PreClusterFinderTask
{
 public:
  //_________________________________________________________________________________________________
  void init(framework::InitContext& ic)
  {
    LOG(info) << "initializing preclusterizer";
 
    mPreClusterFinder.init();
 
    auto stop = [this]() {
      LOG(info) << "reset precluster finder duration = " << mTimeResetPreClusterFinder.count() << " ms";
      LOG(info) << "load digits duration = " << mTimeLoadDigits.count() << " ms";
      LOG(info) << "discard high occupancy duration = " << mTimeDiscardHighOccupancy.count() << " ms";
      LOG(info) << "precluster finder duration = " << mTimePreClusterFinder.count() << " ms";
      LOG(info) << "store precluster duration = " << mTimeStorePreClusters.count() << " ms";
      auto tStart = std::chrono::high_resolution_clock::now();
      this->mPreClusterFinder.deinit();
      auto tEnd = std::chrono::high_resolution_clock::now();
      LOG(info) << "deinitializing preclusterizer in: "
                << std::chrono::duration<double, std::milli>(tEnd - tStart).count() << " ms";
      mErrorMap.forEach([](Error error) {
        LOGP(warning, "{}", error.asString());
      });
    };
    ic.services().get<CallbackService>().set<CallbackService::Id::Stop>(stop);
 
    auto checkNoLeftoverDigits = ic.options().get<std::string>("check-no-leftover-digits");
    if (checkNoLeftoverDigits == "quiet") {
      mCheckNoLeftoverDigits = CHECK_NO_LEFTOVER_DIGITS_QUIET;
    } else if (checkNoLeftoverDigits == "error") {
      mCheckNoLeftoverDigits = CHECK_NO_LEFTOVER_DIGITS_ERROR;
    } else if (checkNoLeftoverDigits == "fatal") {
      mCheckNoLeftoverDigits = CHECK_NO_LEFTOVER_DIGITS_FATAL;
    }
    mDiscardHighOccDEs = ic.options().get<bool>("discard-high-occupancy-des");
    mDiscardHighOccEvents = ic.options().get<bool>("discard-high-occupancy-events");
    mSanityCheck = ic.options().get<bool>("sanity-check");
  }
 
  //_________________________________________________________________________________________________
  void run(framework::ProcessingContext& pc)
  {
 
    // get the input messages with digits
    auto digitROFs = pc.inputs().get<gsl::span<ROFRecord>>("digitrofs");
    auto digits = pc.inputs().get<gsl::span<Digit>>("digits");
 
    bool abort{false};
    if (mSanityCheck) {
      auto error = sanityCheck(digitROFs, digits);
 
      if (!isOK(error)) {
        if (error.nofOutOfBounds > 0) {
          // FIXME: replace this error log with a counters' message ?
          LOGP(error, "{}", asString(error));
          LOGP(error, "in a TF with {} rofs and {} digits", digitROFs.size(), digits.size());
          abort = true;
        }
      }
    }
 
    // create the output message for precluster ROFs
    auto& preClusterROFs = pc.outputs().make<std::vector<ROFRecord>>(OutputRef{"preclusterrofs"});
 
    // count the number of digits associated with the input ROFs. This can be smaller than the
    // total number of digits if we are processing filtered ROFs.
    int nDigitsInRofs = 0;
    for (const auto& digitROF : digitROFs) {
      nDigitsInRofs += digitROF.getNEntries();
    }
 
    // prepare to receive new data
    mPreClusters.clear();
    mUsedDigits.clear();
    auto& errorMap = mPreClusterFinder.getErrorMap();
    errorMap.clear();
 
    if (!abort) {
 
      preClusterROFs.reserve(digitROFs.size());
      mUsedDigits.reserve(digits.size());
      int nRemovedDigits(0);
 
      for (const auto& digitROF : digitROFs) {
 
        // prepare to receive new data
        auto tStart = std::chrono::high_resolution_clock::now();
        mPreClusterFinder.reset();
        auto tEnd = std::chrono::high_resolution_clock::now();
        mTimeResetPreClusterFinder += tEnd - tStart;
 
        // load the digits to get the fired pads
        tStart = std::chrono::high_resolution_clock::now();
        mPreClusterFinder.loadDigits(digits.subspan(digitROF.getFirstIdx(), digitROF.getNEntries()));
        tEnd = std::chrono::high_resolution_clock::now();
        mTimeLoadDigits += tEnd - tStart;
 
        // discard high-occupancy (noisy) DEs and/or events
        tStart = std::chrono::high_resolution_clock::now();
        nRemovedDigits += mPreClusterFinder.discardHighOccupancy(mDiscardHighOccDEs, mDiscardHighOccEvents);
        tEnd = std::chrono::high_resolution_clock::now();
        mTimeDiscardHighOccupancy += tEnd - tStart;
 
        // preclusterize
        tStart = std::chrono::high_resolution_clock::now();
        int nPreClusters = mPreClusterFinder.run();
        tEnd = std::chrono::high_resolution_clock::now();
        mTimePreClusterFinder += tEnd - tStart;
 
        // get the preclusters and associated digits
        tStart = std::chrono::high_resolution_clock::now();
        preClusterROFs.emplace_back(digitROF.getBCData(), mPreClusters.size(), nPreClusters, digitROF.getBCWidth());
        mPreClusterFinder.getPreClusters(mPreClusters, mUsedDigits);
        tEnd = std::chrono::high_resolution_clock::now();
        mTimeStorePreClusters += tEnd - tStart;
      }
 
      // check sizes of input and output digits vectors
      if (nRemovedDigits + mUsedDigits.size() != nDigitsInRofs) {
        errorMap.add(ErrorType::PreClustering_LostDigit, 0, 0, nDigitsInRofs - nRemovedDigits - mUsedDigits.size());
        switch (mCheckNoLeftoverDigits) {
          case CHECK_NO_LEFTOVER_DIGITS_QUIET:
            break;
          case CHECK_NO_LEFTOVER_DIGITS_ERROR:
            static int nAlarms = 0;
            if (nAlarms++ < 5) {
              LOG(warning) << "some digits have been lost during the preclustering";
            }
            break;
          case CHECK_NO_LEFTOVER_DIGITS_FATAL:
            throw runtime_error("some digits have been lost during the preclustering");
            break;
        };
      }
    }
 
    // create the output messages for preclusters and associated digits
    pc.outputs().snapshot(OutputRef{"preclusters"}, mPreClusters);
    pc.outputs().snapshot(OutputRef{"preclusterdigits"}, mUsedDigits);
 
    // create the output message for preclustering errors
    auto& preClusterErrors = pc.outputs().make<std::vector<Error>>(OutputRef{"preclustererrors"});
    errorMap.forEach([&preClusterErrors](Error error) {
      preClusterErrors.emplace_back(error);
    });
    mErrorMap.add(errorMap);
 
    LOGP(info, "Processed {} digit rofs with {} digits and output {} precluster rofs with {} preclusters and {} digits",
         digitROFs.size(),
         nDigitsInRofs,
         preClusterROFs.size(),
         mPreClusters.size(), mUsedDigits.size());
  }
 
 private:
  PreClusterFinder mPreClusterFinder{};   
  std::vector<PreCluster> mPreClusters{}; 
  std::vector<Digit> mUsedDigits{};       
  ErrorMap mErrorMap{};                   
 
  int mCheckNoLeftoverDigits{CHECK_NO_LEFTOVER_DIGITS_ERROR};             
  bool mDiscardHighOccDEs = false;                                        
  bool mDiscardHighOccEvents = false;                                     
  bool mSanityCheck = false;                                              
  std::chrono::duration<double, std::milli> mTimeResetPreClusterFinder{}; 
  std::chrono::duration<double, std::milli> mTimeLoadDigits{};            
  std::chrono::duration<double, std::milli> mTimeDiscardHighOccupancy{};  
  std::chrono::duration<double, std::milli> mTimePreClusterFinder{};      
  std::chrono::duration<double, std::milli> mTimeStorePreClusters{};      
};
 
//_________________________________________________________________________________________________
o2::framework::DataProcessorSpec getPreClusterFinderSpec(const char* specName,
                                                         std::string_view inputDigitDataDescription,
                                                         std::string_view inputDigitRofDataDescription)
{
  std::string input =
    fmt::format("digits:MCH/{}/0;digitrofs:MCH/{}/0",
                inputDigitDataDescription,
                inputDigitRofDataDescription);
  std::string helpstr = "[quiet/error/fatal] check that all digits are included in pre-clusters";
 
  return DataProcessorSpec{
    specName,
    o2::framework::select(input.c_str()),
    Outputs{OutputSpec{{"preclusterrofs"}, "MCH", "PRECLUSTERROFS", 0, Lifetime::Timeframe},
            OutputSpec{{"preclusters"}, "MCH", "PRECLUSTERS", 0, Lifetime::Timeframe},
            OutputSpec{{"preclusterdigits"}, "MCH", "PRECLUSTERDIGITS", 0, Lifetime::Timeframe},
            OutputSpec{{"preclustererrors"}, "MCH", "PRECLUSTERERRORS", 0, Lifetime::Timeframe}},
    AlgorithmSpec{adaptFromTask<PreClusterFinderTask>()},
    Options{{"check-no-leftover-digits", VariantType::String, "error", {helpstr}},
            {{"sanity-check"}, VariantType::Bool, false, {"perform some input digit sanity checks"}},
            {"discard-high-occupancy-des", VariantType::Bool, false, {"discard DEs with occupancy > 20%"}},
            {"discard-high-occupancy-events", VariantType::Bool, false, {"discard events with >= 5 DEs above 20% occupancy"}}}};
}
 
} // end namespace mch
} // end namespace o2