TopologyDictionary.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_ITS3_TOPOLOGYDICTIONARY_H
#define ALICEO2_ITS3_TOPOLOGYDICTIONARY_H
 
#include "DataFormatsITSMFT/TopologyDictionary.h"
#include "DataFormatsITSMFT/ClusterPattern.h"
 
namespace o2::its3
{
 
class BuildTopologyDictionary;
class LookUp;
 
struct TopologyDictionaryData {
  static constexpr int STopoSize{(8 * 255) + 1};
  std::array<int, STopoSize> mSmallTopologiesLUT{};  
  std::vector<itsmft::GroupStruct> mVectorOfIDs;     
  std::unordered_map<unsigned long, int> mCommonMap; 
  std::unordered_map<int, int> mGroupMap;            
 
  void print() const noexcept;
 
  ClassDefNV(TopologyDictionaryData, 1);
};
 
class TopologyDictionary
{
 public:
  TopologyDictionary();
  TopologyDictionary(const std::string& fileName);
 
  static constexpr int RowClassSpan = 4;                                                                      
  static constexpr int ColClassSpan = 4;                                                                      
  static constexpr int MaxNumberOfRowClasses = 1 + ((itsmft::ClusterPattern::MaxRowSpan - 1) / RowClassSpan); 
  static constexpr int MaxNumberOfColClasses = 1 + ((itsmft::ClusterPattern::MaxColSpan - 1) / ColClassSpan); 
  static constexpr int NumberOfRareGroups = MaxNumberOfRowClasses * MaxNumberOfColClasses;                    
  void reset() noexcept;
  void resetMaps(bool IB = true) noexcept;
  friend std::ostream& operator<<(std::ostream& os, const its3::TopologyDictionary& dictionary);
  void writeBinaryFile(const std::string& outputFile);
  void readBinaryFile(const std::string& fileName);
  void readFromFile(const std::string& fileName);
  void print() const noexcept;
 
  [[nodiscard]] float getXCOG(int n, bool IB = true) const
  {
    const auto& data = (IB) ? mDataIB : mDataOB;
    assert(n >= 0 || n < (int)data.mVectorOfIDs.size());
    return data.mVectorOfIDs[n].mXCOG;
  }
  [[nodiscard]] float getErrX(int n, bool IB = true) const
  {
    const auto& data = (IB) ? mDataIB : mDataOB;
    assert(n >= 0 || n < (int)data.mVectorOfIDs.size());
    return data.mVectorOfIDs[n].mErrX;
  }
  [[nodiscard]] float getZCOG(int n, bool IB = true) const
  {
    const auto& data = (IB) ? mDataIB : mDataOB;
    assert(n >= 0 || n < (int)data.mVectorOfIDs.size());
    return data.mVectorOfIDs[n].mZCOG;
  }
  [[nodiscard]] float getErrZ(int n, bool IB = true) const
  {
    const auto& data = (IB) ? mDataIB : mDataOB;
    assert(n >= 0 || n < (int)data.mVectorOfIDs.size());
    return data.mVectorOfIDs[n].mErrZ;
  }
  [[nodiscard]] float getErr2X(int n, bool IB = true) const
  {
    const auto& data = (IB) ? mDataIB : mDataOB;
    assert(n >= 0 || n < (int)data.mVectorOfIDs.size());
    return data.mVectorOfIDs[n].mErr2X;
  }
  [[nodiscard]] float getErr2Z(int n, bool IB = true) const
  {
    const auto& data = (IB) ? mDataIB : mDataOB;
    assert(n >= 0 || n < (int)data.mVectorOfIDs.size());
    return data.mVectorOfIDs[n].mErr2Z;
  }
  [[nodiscard]] unsigned long getHash(int n, bool IB = true) const
  {
    const auto& data = (IB) ? mDataIB : mDataOB;
    assert(n >= 0 || n < (int)data.mVectorOfIDs.size());
    return data.mVectorOfIDs[n].mHash;
  }
  [[nodiscard]] int getNpixels(int n, bool IB = true) const
  {
    const auto& data = (IB) ? mDataIB : mDataOB;
    assert(n >= 0 || n < (int)data.mVectorOfIDs.size());
    return data.mVectorOfIDs[n].mNpixels;
  }
  [[nodiscard]] double getFrequency(int n, bool IB = true) const
  {
    const auto& data = (IB) ? mDataIB : mDataOB;
    assert(n >= 0 || n < (int)data.mVectorOfIDs.size());
    return data.mVectorOfIDs[n].mFrequency;
  }
  [[nodiscard]] bool isGroup(int n, bool IB = true) const
  {
    const auto& data = (IB) ? mDataIB : mDataOB;
    assert(n >= 0 || n < (int)data.mVectorOfIDs.size());
    return data.mVectorOfIDs[n].mIsGroup;
  }
  [[nodiscard]] const itsmft::ClusterPattern& getPattern(int n, bool IB = true) const
  {
    const auto& data = (IB) ? mDataIB : mDataOB;
    assert(n >= 0 || n < (int)data.mVectorOfIDs.size());
    return data.mVectorOfIDs[n].mPattern;
  }
 
  [[nodiscard]] TH1F* getTopologyDistribution(const std::string_view hname, bool IB = true) const;
  [[nodiscard]] int getSize(bool IB) const
  {
    return static_cast<int>((IB) ? mDataIB.mVectorOfIDs.size() : mDataOB.mVectorOfIDs.size());
  }
 
  template <typename T = float>
  math_utils::Point3D<T> getClusterCoordinates(const itsmft::CompClusterExt& cl) const;
 
  template <typename T = float>
  static math_utils::Point3D<T> getClusterCoordinates(const itsmft::CompClusterExt& cl, const itsmft::ClusterPattern& patt, bool isGroup = true);
 
  static TopologyDictionary* loadFrom(const std::string& fileName = "", const std::string& objName = "ccdb_object");
 
  friend its3::BuildTopologyDictionary;
  friend its3::LookUp;
 
 private:
  TopologyDictionaryData mDataIB;
  TopologyDictionaryData mDataOB;
 
  ClassDefNV(TopologyDictionary, 4);
};
} // namespace o2::its3
 
#endif