TopologyClassifier.h

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.
 
 
#ifndef ALICEO2_IOTOF_TOPOLOGYCLASSIFIER_H
#define ALICEO2_IOTOF_TOPOLOGYCLASSIFIER_H
 
#include <array>
#include <cstdint>
#include <unordered_map>
 
#include <TFile.h>
 
#include "IOTOFBase/GeometryTGeo.h"
#include "IOTOFBase/IOTOFBaseParam.h"
#include "IOTOFBase/Segmentation.h"
#include "DataFormatsIOTOF/Cluster.h"
 
// TO BE REMOVED BEFORE PUSH
#include "Framework/Logger.h"
 
namespace o2
{
namespace iotof
{
 
enum Topologies : uint8_t {
  kSingleDigit,
  kLineOnRow,
  kLineOnCol,
  kSquare,
  kRectangle,
  kDiagonal,
  kLowerTriangleLeft,
  kLowerTriangleRight,
  kUpperTriangleLeft,
  kUpperTriangleRight,
  kSnake,
  kSnakeRefl,
  kSnakeRot90,
  kSnakeRot90Refl,
  kHuge,
  kOther,
  kNTopologies
};
 
struct TopologyInfo {
  int mSizeX = 0;
  int mSizeZ = 0;
  int mOffsetXToCOG = 0;
  int mOffsetZToCOG = 0;
  float mXMean = 0.f;
  float mZMean = 0.f;
  float mXSigma2 = 0.f;
  float mZSigma2 = 0.f;
  int mNPixels = 0;
  int mFrequency = 0;
  Topologies mTopology = Topologies::kNTopologies;
  uint16_t mPattern; 
 
  void print() const
  {
    LOG(info) << "---> TopologyInfo: Topology = " << static_cast<int>(mTopology)
              << ", SizeX = " << mSizeX << ", SizeZ = " << mSizeZ
              << ", OffsetXToCOG = " << mOffsetXToCOG << ", OffsetZToCOG = " << mOffsetZToCOG
              << ", XMean = " << mXMean << ", ZMean = " << mZMean
              << ", XSigma2 = " << mXSigma2 << ", ZSigma2 = " << mZSigma2
              << ", NPixels = " << mNPixels
              << ", Frequency = " << mFrequency
              << ", Pattern (bitmask) = 0x" << std::hex << mPattern;
  }
};
 
class TopologyClassifier
{
 public:
  // Define limits for domain validation
  static constexpr uint8_t MaxRowSpan = 255;
  static constexpr uint8_t MaxColSpan = 255;
  static constexpr uint16_t MaxBitmask = 65535;
 
  TopologyClassifier()
  {
    sSegmentation = o2::iotof::Segmentation::Instance();
  }
  TopologyClassifier(std::unordered_map<uint32_t, TopologyInfo> map) : mTopologyCache(std::move(map))
  {
    sSegmentation = o2::iotof::Segmentation::Instance();
  }
 
  const std::unordered_map<uint32_t, TopologyInfo>& getTopologyMap() const { return mTopologyCache; };
  void getTopology(uint16_t bitmask, uint16_t minRow, uint8_t spanRow, uint16_t minCol, uint8_t spanCol, uint32_t& topology);
  TopologyInfo getTopologyFeatures(uint32_t key);
  void accountTopology(uint16_t bitmask, uint16_t minRow, uint8_t spanRow, uint16_t minCol, uint8_t spanCol);
  void computeCOG(uint16_t bitmask, uint16_t minRow, uint8_t spanRow, uint16_t minCol, uint8_t spanCol, TopologyInfo& topoInfo);
 
  math_utils::Point3D<float> getClusterCoordinates(const Cluster& cluster);
 
  void saveCacheToFile(const char* filename);
  void print();
 
  float getErrX(uint32_t pattID) { return std::sqrt(getTopologyFeatures(pattID).mXSigma2); };
  float getErrZ(uint32_t pattID) { return std::sqrt(getTopologyFeatures(pattID).mZSigma2); };
  float getNPixels(uint32_t pattID) { return getTopologyFeatures(pattID).mNPixels; };
  float getMeanX(uint32_t pattID) { return getTopologyFeatures(pattID).mXMean; };
  float getMeanZ(uint32_t pattID) { return getTopologyFeatures(pattID).mZMean; };
 
  // Provide the common iotof::GeometryTGeo to access matrices and segmentation
  void setGeometry(const o2::iotof::GeometryTGeo* gm) { mGeometry = gm; }
 
  static uint32_t makeKey(uint8_t spanRow, uint8_t spanCol, uint16_t bitmask)
  {
    return (static_cast<uint32_t>(spanRow) << 24) |
           (static_cast<uint32_t>(spanCol) << 16) |
           static_cast<uint32_t>(bitmask);
  }
 
 private:
  [[nodiscard]] static constexpr uint32_t packKey(uint8_t spanRow, uint8_t spanCol, uint16_t bitmask) noexcept
  {
    return (static_cast<uint32_t>(spanRow) << 24) |
           (static_cast<uint32_t>(spanCol) << 16) |
           static_cast<uint32_t>(bitmask);
  }
 
  std::unordered_map<uint32_t, TopologyInfo> mTopologyCache;
  const o2::iotof::GeometryTGeo* mGeometry = nullptr; 
  static o2::iotof::Segmentation* sSegmentation;      
};
 
} // namespace iotof
} // namespace o2
 
#endif // ALICEO2_IOTOF_TOPOLOGYCLASSIFIER_H