CTFCoder.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 "ITSMFTReconstruction/CTFCoder.h"
#include <TTree.h>
 
namespace o2::itsmft
{
 
// Register encoded data in the tree (Fill is not called, will be done by caller)
template <int N>
void CTFCoder<N>::appendToTree(TTree& tree, CTF& ec, int id)
{
  ec.appendToTree(tree, id >= 0 ? fmt::format("{}_{}", mDet.getName(), id) : mDet.getName());
}
 
// extract and decode data from the tree
template <int N>
void CTFCoder<N>::readFromTree(TTree& tree, int entry, int id, std::vector<ROFRecord>& rofRecVec,
                               std::vector<CompClusterExt>& cclusVec, std::vector<unsigned char>& pattVec, const NoiseMap* noiseMap, const LookUp& clPattLookup)
{
  assert(entry >= 0 && entry < tree.GetEntries());
  CTF ec;
  ec.readFromTree(tree, id >= 0 ? fmt::format("{}_{}", mDet.getName(), id) : mDet.getName(), entry);
  decode(ec, rofRecVec, cclusVec, pattVec, noiseMap, clPattLookup);
}
 
template <int N>
void CTFCoder<N>::compress(CompressedClusters& cc,
                           const gsl::span<const ROFRecord>& rofRecVec,
                           const gsl::span<const CompClusterExt>& cclusVec,
                           const gsl::span<const unsigned char>& pattVec,
                           const LookUp& clPattLookup, int strobeLength)
{
  // store in the header the orbit of 1st ROF
  cc.clear();
  cc.header.det = mDet;
  if (!rofRecVec.size()) {
    return;
  }
  uint32_t firstROF = rofRecVec.size(), nrofSel = rofRecVec.size(), nClusSel = cclusVec.size();
  std::vector<bool> reject(rofRecVec.size());
  if (mIRFrameSelector.isSet()) {
    for (size_t ir = 0; ir < rofRecVec.size(); ir++) {
      auto irStart = rofRecVec[ir].getBCData();
      if (mIRFrameSelector.check({irStart, irStart + strobeLength - 1}) < 0) {
        reject[ir] = true;
        nrofSel--;
        nClusSel -= rofRecVec[ir].getNEntries();
      } else if (firstROF == rofRecVec.size()) {
        firstROF = ir;
      }
    }
  } else {
    firstROF = 0;
  }
  if (nrofSel == 0) { // nothing is selected
    return;
  }
  assert(nClusSel <= cclusVec.size());
 
  const auto& rofRec0 = rofRecVec[firstROF];
  cc.header.firstOrbit = rofRec0.getBCData().orbit;
  cc.header.firstBC = rofRec0.getBCData().bc;
  cc.header.nROFs = nrofSel;
  cc.header.nClusters = nClusSel;
 
  cc.firstChipROF.resize(nrofSel);
  cc.bcIncROF.resize(nrofSel);
  cc.orbitIncROF.resize(nrofSel);
  cc.nclusROF.resize(nrofSel);
  //
  cc.row.resize(nClusSel);
  cc.colInc.resize(nClusSel);
  //  cc.chipInc.resize(cc.header.nClusters); // this is the version with chipInc stored for every pixel
  cc.chipInc.reserve(1000); // this is the version with chipInc stored once per new chip
  cc.chipMul.reserve(1000); // this is the version with chipInc stored once per new chip
  cc.pattID.resize(nClusSel);
 
  bool selectPatterns = nrofSel < rofRecVec.size();
  if (!selectPatterns) { // nothing is rejected, simply copy the patterns
    cc.header.nPatternBytes = pattVec.size();
    cc.pattMap.resize(pattVec.size()); // to be resized in case of selection
    memcpy(cc.pattMap.data(), pattVec.data(), pattVec.size());
  } else {
    cc.pattMap.reserve(pattVec.size());
  }
 
  uint16_t prevBC = cc.header.firstBC;
  uint32_t prevOrbit = cc.header.firstOrbit;
  int irofOut = 0, iclOut = 0;
  auto pattIt = pattVec.begin(), pattIt0 = pattVec.begin();
  for (uint32_t irof = 0; irof < rofRecVec.size(); irof++) {
    const auto& rofRec = rofRecVec[irof];
    const auto& intRec = rofRec.getBCData();
 
    if (reject[irof]) {                          // need to skip some patterns
      if (selectPatterns && pattIt != pattIt0) { // copy what was already selected
        cc.pattMap.insert(cc.pattMap.end(), pattIt0, pattIt);
        pattIt0 = pattIt;
      }
      for (int icl = rofRec.getFirstEntry(); icl < rofRec.getFirstEntry() + rofRec.getNEntries(); icl++) {
        const auto& clus = cclusVec[icl];
        if (clus.getPatternID() == o2::itsmft::CompCluster::InvalidPatternID || clPattLookup.isGroup(clus.getPatternID())) {
          o2::itsmft::ClusterPattern::skipPattern(pattIt0);
        }
      }
      pattIt = pattIt0;
      continue;
    }
    if (intRec.orbit == prevOrbit) {
      cc.orbitIncROF[irofOut] = 0;
#ifdef _CHECK_INCREMENTES_
      if (intRec.bc < prevBC) {
        LOG(warning) << "Negative BC increment " << intRec.bc << " -> " << prevBC;
      }
#endif
      cc.bcIncROF[irofOut] = int16_t(intRec.bc - prevBC); // store increment of BC if in the same orbit
    } else {
      cc.orbitIncROF[irofOut] = int32_t(intRec.orbit - prevOrbit);
#ifdef _CHECK_INCREMENTES_
      if (intRec.orbit < prevOrbit) {
        LOG(warning) << "Negative Orbit increment " << intRec.orbit << " -> " << prevOrbit;
      }
#endif
      cc.bcIncROF[irofOut] = intRec.bc; // otherwise, store absolute bc
      prevOrbit = intRec.orbit;
    }
    prevBC = intRec.bc;
    auto ncl = rofRec.getNEntries();
    cc.nclusROF[irofOut] = ncl;
    if (!ncl) { // no hits data for this ROF
      cc.firstChipROF[irofOut] = 0;
      irofOut++;
      continue;
    }
    cc.firstChipROF[irofOut] = cclusVec[rofRec.getFirstEntry()].getChipID();
    int icl = rofRec.getFirstEntry(), iclMax = icl + ncl;
 
    uint16_t prevChip = cc.firstChipROF[irofOut], prevCol = 0;
    if (icl != iclMax) { // there are still clusters to store
      cc.chipMul.push_back(0);
      cc.chipInc.push_back(0);
    }
    for (; icl < iclMax; icl++) { // clusters within a chip are stored in increasing column number
      const auto& cl = cclusVec[icl];
      cc.row[iclOut] = cl.getRow(); // row is practically random, store it as it is
      cc.pattID[iclOut] = cl.getPatternID();
      if (selectPatterns && (cc.pattID[iclOut] == o2::itsmft::CompCluster::InvalidPatternID || clPattLookup.isGroup(cl.getPatternID()))) {
        o2::itsmft::ClusterPattern::skipPattern(pattIt);
      }
      if (cl.getChipID() == prevChip) { // for the same chip store column increment
        // cc.chipInc[iclOut] = 0;  // this is the version with chipInc stored for every pixel
        cc.chipMul.back()++; // this is the version with chipInc stored once per new chip
        cc.colInc[iclOut] = int16_t(cl.getCol()) - prevCol;
        prevCol = cl.getCol();
      } else { // for new chips store chipID increment and abs. column
        // cc.chipInc[iclOut] = cl.getChipID() - prevChip;  // this is the version with chipInc stored for every pixel
        cc.chipInc.push_back(int16_t(cl.getChipID() - prevChip)); // this is the version with chipInc stored once per new chip
#ifdef _CHECK_INCREMENTES_
        if (cl.getChipID() < prevChip) {
          LOG(warning) << "Negative Chip increment " << cl.getChipID() << " -> " << prevChip;
        }
#endif
        cc.chipMul.push_back(1); // this is the version with chipInc stored once per new chip
        prevCol = cc.colInc[iclOut] = cl.getCol();
        prevChip = cl.getChipID();
      }
      iclOut++;
    }
    irofOut++;
  }
  if (selectPatterns && pattIt != pattIt0) { // copy leftover patterns
    cc.pattMap.insert(cc.pattMap.end(), pattIt0, pattIt);
    pattIt0 = pattIt;
  }
  cc.header.nPatternBytes = cc.pattMap.size();
  cc.header.nChips = cc.chipMul.size();
}
 
template <int N>
void CTFCoder<N>::createCoders(const std::vector<char>& bufVec, o2::ctf::CTFCoderBase::OpType op)
{
  const auto ctf = CTF::getImage(bufVec.data());
  CompressedClusters cc; // just to get member types
#define MAKECODER(part, slot) createCoder(op, std::get<rans::RenormedDenseHistogram<typename decltype(part)::value_type>>(ctf.getDictionary<typename decltype(part)::value_type>(slot, mANSVersion)), int(slot))
  // clang-format off
  MAKECODER(cc.firstChipROF, CTF::BLCfirstChipROF);
  MAKECODER(cc.bcIncROF,     CTF::BLCbcIncROF    );
  MAKECODER(cc.orbitIncROF,  CTF::BLCorbitIncROF );
  MAKECODER(cc.nclusROF,     CTF::BLCnclusROF    );
  //
  MAKECODER(cc.chipInc,      CTF::BLCchipInc     );
  MAKECODER(cc.chipMul,      CTF::BLCchipMul     );
  MAKECODER(cc.row,          CTF::BLCrow         );
  MAKECODER(cc.colInc,       CTF::BLCcolInc      );
  MAKECODER(cc.pattID,       CTF::BLCpattID      );
  MAKECODER(cc.pattMap,      CTF::BLCpattMap     );
  // clang-format on
}
 
template <int N>
size_t CTFCoder<N>::estimateCompressedSize(const CompressedClusters& cc)
{
  size_t sz = 0;
  // RS FIXME this is very crude estimate, instead, an empirical values should be used
 
  sz += estimateBufferSize(static_cast<int>(CTF::BLCfirstChipROF), cc.firstChipROF);
  sz += estimateBufferSize(static_cast<int>(CTF::BLCbcIncROF), cc.bcIncROF);
  sz += estimateBufferSize(static_cast<int>(CTF::BLCorbitIncROF), cc.orbitIncROF);
  sz += estimateBufferSize(static_cast<int>(CTF::BLCnclusROF), cc.nclusROF);
  //
  sz += estimateBufferSize(static_cast<int>(CTF::BLCchipInc), cc.chipInc);
  sz += estimateBufferSize(static_cast<int>(CTF::BLCchipMul), cc.chipMul);
  sz += estimateBufferSize(static_cast<int>(CTF::BLCrow), cc.row);
  sz += estimateBufferSize(static_cast<int>(CTF::BLCcolInc), cc.colInc);
  sz += estimateBufferSize(static_cast<int>(CTF::BLCpattID), cc.pattID);
  sz += estimateBufferSize(static_cast<int>(CTF::BLCpattMap), cc.pattMap);
  sz *= 2. / 3; // if needed, will be autoexpanded
  LOG(debug) << "Estimated output size is " << sz << " bytes";
  return sz;
}
 
template <int N>
CompressedClusters CTFCoder<N>::decodeCompressedClusters(const CTF::base& ec, o2::ctf::CTFIOSize& iosize)
{
  CompressedClusters cc;
  cc.header = ec.getHeader();
  checkDictVersion(static_cast<const o2::ctf::CTFDictHeader&>(cc.header));
  ec.print(getPrefix(), mVerbosity);
#define DECODEITSMFT(part, slot) ec.decode(part, int(slot), mCoders[int(slot)])
  // clang-format off
  iosize += DECODEITSMFT(cc.firstChipROF, CTF::BLCfirstChipROF);
  iosize += DECODEITSMFT(cc.bcIncROF,     CTF::BLCbcIncROF);
  iosize += DECODEITSMFT(cc.orbitIncROF,  CTF::BLCorbitIncROF);
  iosize += DECODEITSMFT(cc.nclusROF,     CTF::BLCnclusROF);
  //
  iosize += DECODEITSMFT(cc.chipInc,      CTF::BLCchipInc);
  iosize += DECODEITSMFT(cc.chipMul,      CTF::BLCchipMul);
  iosize += DECODEITSMFT(cc.row,          CTF::BLCrow);
  iosize += DECODEITSMFT(cc.colInc,       CTF::BLCcolInc);
  iosize += DECODEITSMFT(cc.pattID,       CTF::BLCpattID);
  iosize += DECODEITSMFT(cc.pattMap,      CTF::BLCpattMap);
  // clang-format on
  return cc;
}
 
template class CTFCoder<o2::detectors::DetID::ITS>;
template class CTFCoder<o2::detectors::DetID::MFT>;
} // namespace o2::itsmft