TopologyDictionary.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 "ITS3Reconstruction/TopologyDictionary.h"
#include "ITS3Base/SegmentationMosaix.h"
#include "ITS3Base/SpecsV2.h"
#include "ITSMFTBase/SegmentationAlpide.h"
#include "CommonUtils/StringUtils.h"
#include <TFile.h>
#include <iostream>
 
ClassImp(o2::its3::TopologyDictionary);
 
namespace o2::its3
{
 
void TopologyDictionaryData::print() const noexcept
{
  LOG(info) << "Number of keys: " << mVectorOfIDs.size();
  LOG(info) << "Number of common topologies: " << mCommonMap.size();
  LOG(info) << "Number of groups of rare topologies: " << mGroupMap.size();
}
 
TopologyDictionary::TopologyDictionary()
{
  reset();
}
 
TopologyDictionary::TopologyDictionary(const std::string& fileName)
{
  readFromFile(fileName);
}
 
void TopologyDictionary::print() const noexcept
{
  LOG(info) << "ITS3 TopologyDictionary";
  LOG(info) << "InnerBarrel";
  mDataIB.print();
  LOG(info) << "OuterBarrel";
  mDataOB.print();
}
 
void TopologyDictionary::reset() noexcept
{
  mDataIB.mSmallTopologiesLUT.fill(-1);
  mDataOB.mSmallTopologiesLUT.fill(-1);
  mDataIB.mVectorOfIDs.clear();
  mDataOB.mVectorOfIDs.clear();
}
 
void TopologyDictionary::resetMaps(bool IB) noexcept
{
  auto& data = (IB) ? mDataIB : mDataOB;
  data.mCommonMap.clear();
  data.mGroupMap.clear();
}
 
std::ostream& operator<<(std::ostream& os, const its3::TopologyDictionary& dict)
{
  int ID = 0;
  os << "--- InnerBarrel:\n";
  for (auto& p : dict.mDataIB.mVectorOfIDs) {
    os << "ID: " << ID++ << " Hash: " << p.mHash << " ErrX: " << p.mErrX << " ErrZ : " << p.mErrZ << " xCOG: " << p.mXCOG << " zCOG: " << p.mZCOG << " Npixles: " << p.mNpixels << " Frequency: " << p.mFrequency << " isGroup : " << std::boolalpha << p.mIsGroup << '\n'
       << p.mPattern << '\n'
       << "*********************************************************" << '\n'
       << '\n';
  }
  ID = 0;
  os << "--- OuterBarrel:\n";
  for (auto& p : dict.mDataOB.mVectorOfIDs) {
    os << "ID: " << ID++ << " Hash: " << p.mHash << " ErrX: " << p.mErrX << " ErrZ : " << p.mErrZ << " xCOG: " << p.mXCOG << " zCOG: " << p.mZCOG << " Npixles: " << p.mNpixels << " Frequency: " << p.mFrequency << " isGroup : " << std::boolalpha << p.mIsGroup << '\n'
       << p.mPattern << '\n'
       << "*********************************************************" << '\n'
       << '\n';
  }
  return os;
}
 
void TopologyDictionary::writeBinaryFile(const std::string& outputfile)
{
  std::ofstream file_output(outputfile, std::ios::out | std::ios::binary);
  if (!file_output) {
    throw std::runtime_error(fmt::format("Cannot open output file %s!", outputfile));
  }
 
  auto writeData = [](auto& file_output, auto& data) {
    auto size = data.mVectorOfIDs.size();
    file_output.write(reinterpret_cast<char*>(&size), sizeof(size));
    for (auto& p : data.mVectorOfIDs) {
      file_output.write(reinterpret_cast<char*>(&p.mHash), sizeof(unsigned long));
      file_output.write(reinterpret_cast<char*>(&p.mErrX), sizeof(float));
      file_output.write(reinterpret_cast<char*>(&p.mErrZ), sizeof(float));
      file_output.write(reinterpret_cast<char*>(&p.mErr2X), sizeof(float));
      file_output.write(reinterpret_cast<char*>(&p.mErr2Z), sizeof(float));
      file_output.write(reinterpret_cast<char*>(&p.mXCOG), sizeof(float));
      file_output.write(reinterpret_cast<char*>(&p.mZCOG), sizeof(float));
      file_output.write(reinterpret_cast<char*>(&p.mNpixels), sizeof(int));
      file_output.write(reinterpret_cast<char*>(&p.mFrequency), sizeof(double));
      file_output.write(reinterpret_cast<char*>(&p.mIsGroup), sizeof(bool));
      file_output.write(const_cast<char*>(reinterpret_cast<const char*>(&p.mPattern.getPattern())),
                        sizeof(unsigned char) * (itsmft::ClusterPattern::kExtendedPatternBytes));
    }
  };
 
  writeData(file_output, mDataIB);
  writeData(file_output, mDataOB);
 
  file_output.close();
}
 
void TopologyDictionary::readFromFile(const std::string& fname)
{
  LOGP(info, "Reading TopologyDictionary from File '{}'", fname);
  if (o2::utils::Str::endsWith(fname, ".root")) {
    std::unique_ptr<TopologyDictionary> d{loadFrom(fname)};
    *this = *d;
  } else if (o2::utils::Str::endsWith(fname, ".bin")) {
    readBinaryFile(fname);
  } else {
    throw std::runtime_error(fmt::format("Unrecognized format {}", fname));
  }
}
 
void TopologyDictionary::readBinaryFile(const std::string& fname)
{
  reset();
 
  std::ifstream in(fname.data(), std::ios::in | std::ios::binary);
  if (!in.is_open()) {
    LOG(error) << "The file " << fname << " coud not be opened";
    throw std::runtime_error("The file coud not be opened");
  } else {
 
    auto readData = [](auto& in, auto& data) {
      int groupID = 0;
      std::size_t size{}, cur{};
      itsmft::GroupStruct gr;
      in.read(reinterpret_cast<char*>(&size), sizeof(std::size_t));
      while (cur++ != size) {
        in.read(reinterpret_cast<char*>(&gr.mHash), sizeof(unsigned long));
        in.read(reinterpret_cast<char*>(&gr.mErrX), sizeof(float));
        in.read(reinterpret_cast<char*>(&gr.mErrZ), sizeof(float));
        in.read(reinterpret_cast<char*>(&gr.mErr2X), sizeof(float));
        in.read(reinterpret_cast<char*>(&gr.mErr2Z), sizeof(float));
        in.read(reinterpret_cast<char*>(&gr.mXCOG), sizeof(float));
        in.read(reinterpret_cast<char*>(&gr.mZCOG), sizeof(float));
        in.read(reinterpret_cast<char*>(&gr.mNpixels), sizeof(int));
        in.read(reinterpret_cast<char*>(&gr.mFrequency), sizeof(double));
        in.read(reinterpret_cast<char*>(&gr.mIsGroup), sizeof(bool));
        in.read(const_cast<char*>(reinterpret_cast<const char*>(&gr.mPattern.getPattern())), sizeof(unsigned char) * (itsmft::ClusterPattern::kExtendedPatternBytes));
        data.mVectorOfIDs.push_back(gr);
        if (!gr.mIsGroup) {
          data.mCommonMap.insert(std::make_pair(gr.mHash, groupID));
          if (gr.mPattern.getUsedBytes() == 1) {
            data.mSmallTopologiesLUT[(gr.mPattern.getColumnSpan() - 1) * 255 + (int)gr.mPattern.getByte(2)] = groupID;
          }
        } else {
          data.mGroupMap.insert(std::make_pair((int)(gr.mHash >> 32) & 0x00000000ffffffff, groupID));
        }
        groupID++;
      }
    };
 
    readData(in, mDataIB);
    readData(in, mDataOB);
  }
  in.close();
}
 
TH1F* TopologyDictionary::getTopologyDistribution(const std::string_view hname, bool IB) const
{
  int dictSize = getSize(IB);
  auto* histo = new TH1F(hname.data(), Form("%s;Topology ID;Frequency", (IB) ? "InnerBarrel" : "OuterBarrel"), dictSize, -0.5, dictSize - 0.5);
  histo->SetFillColor(kRed);
  histo->SetFillStyle(3005);
  histo->SetDrawOption("histo");
  for (int i = 0; i < dictSize; i++) {
    histo->Fill(i, getFrequency(i, IB));
  }
  return histo;
}
 
template <typename T>
math_utils::Point3D<T> TopologyDictionary::getClusterCoordinates(const itsmft::CompClusterExt& cl) const
{
  static std::array<o2::its3::SegmentationMosaix, 3> mIBSegmentations{0, 1, 2};
  math_utils::Point3D<T> locCl;
  if (!its3::constants::detID::isDetITS3(cl.getSensorID())) {
    o2::itsmft::SegmentationAlpide::detectorToLocalUnchecked(cl.getRow(), cl.getCol(), locCl);
    locCl.SetX(locCl.X() + this->getXCOG(cl.getPatternID(), false) * itsmft::SegmentationAlpide::PitchRow);
    locCl.SetZ(locCl.Z() + this->getZCOG(cl.getPatternID(), false) * itsmft::SegmentationAlpide::PitchCol);
  } else {
    auto layer = its3::constants::detID::getDetID2Layer(cl.getSensorID());
    mIBSegmentations[layer].detectorToLocalUnchecked(cl.getRow(), cl.getCol(), locCl);
    locCl.SetX(locCl.X() + this->getXCOG(cl.getPatternID(), true) * its3::SegmentationMosaix::PitchRow);
    locCl.SetY(its3::constants::pixelarray::pixels::apts::responseYShift);
    locCl.SetZ(locCl.Z() + this->getZCOG(cl.getPatternID(), true) * its3::SegmentationMosaix::PitchCol);
    float xCurved{0.f}, yCurved{0.f};
    mIBSegmentations[layer].flatToCurved(locCl.X(), locCl.Y(), xCurved, yCurved);
    locCl.SetXYZ(xCurved, yCurved, locCl.Z());
  }
  return locCl;
}
 
template <typename T>
math_utils::Point3D<T> TopologyDictionary::getClusterCoordinates(const itsmft::CompClusterExt& cl, const itsmft::ClusterPattern& patt, bool isGroup)
{
  static std::array<o2::its3::SegmentationMosaix, 3> mIBSegmentations{0, 1, 2};
  auto refRow = cl.getRow();
  auto refCol = cl.getCol();
  float xCOG = 0, zCOG = 0;
  patt.getCOG(xCOG, zCOG);
  if (isGroup) {
    refRow -= round(xCOG);
    refCol -= round(zCOG);
  }
  math_utils::Point3D<T> locCl;
  if (!its3::constants::detID::isDetITS3(cl.getSensorID())) {
    o2::itsmft::SegmentationAlpide::detectorToLocalUnchecked(refRow + xCOG, refCol + zCOG, locCl);
  } else {
    auto layer = its3::constants::detID::getDetID2Layer(cl.getSensorID());
    mIBSegmentations[layer].detectorToLocalUnchecked(refRow + xCOG, refCol + zCOG, locCl);
    float xCurved{0.f}, yCurved{0.f};
    mIBSegmentations[layer].flatToCurved(locCl.X(), locCl.Y(), xCurved, yCurved);
    locCl.SetXYZ(xCurved, yCurved, locCl.Z());
  }
  return locCl;
}
 
TopologyDictionary* TopologyDictionary::loadFrom(const std::string& fname, const std::string& objName)
{
  LOGP(info, "Loading TopologyDictionary from {} with name {}", fname, objName);
  // load object from file
  TFile fl(fname.c_str(), "READ");
  if (fl.IsZombie() || !fl.IsOpen()) {
    throw std::runtime_error(fmt::format("Failed to open {} file", fname));
  }
  auto dict = fl.Get<its3::TopologyDictionary>(objName.c_str());
  if (dict == nullptr) {
    throw std::runtime_error(fmt::format("Failed to load {} from {}", objName, fname));
  }
  return dict;
}
 
// Explicitly instaniate templates
template math_utils::Point3D<float> TopologyDictionary::getClusterCoordinates<float>(const itsmft::CompClusterExt& cl) const;
template math_utils::Point3D<float> TopologyDictionary::getClusterCoordinates<float>(const itsmft::CompClusterExt& cl, const itsmft::ClusterPattern& patt, bool isGroup);
template math_utils::Point3D<double> TopologyDictionary::getClusterCoordinates<double>(const itsmft::CompClusterExt& cl) const;
template math_utils::Point3D<double> TopologyDictionary::getClusterCoordinates<double>(const itsmft::CompClusterExt& cl, const itsmft::ClusterPattern& patt, bool isGroup);
 
} // namespace o2::its3