CompactBinnedArray1D.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
// CompactBinnedArray1D.h, (c) ATLAS Detector software
 
#ifndef TRKDETDESCRUTILS_COMPACTBINNEDARRAY1D_H
#define TRKDETDESCRUTILS_COMPACTBINNEDARRAY1D_H
 
#include "TrkDetDescrUtils/BinUtility.h"
#include "TrkDetDescrUtils/CompactBinnedArray.h"
 
// STL
#include <vector>
 
class MsgStream;
 
namespace Trk {
 
template<class T>
class CompactBinnedArray1D final : public CompactBinnedArray<T>
{
public:
 
 //Rule of 0 for default ctors
 
 CompactBinnedArray1D(const std::vector<T*>& tclassvector,
                      const std::vector<size_t>& indexvector,
                      const BinUtility& bingen)
     : CompactBinnedArray<T>(),
       m_array(indexvector),
       m_arrayObjects(tclassvector),
       m_binUtility(bingen) {}
 
 CompactBinnedArray1D(const std::vector<T*>& tclassvector,
                      std::vector<size_t>&& indexvector,
                      BinUtility&& bingen)
     : CompactBinnedArray<T>(),
       m_array(std::move(indexvector)),
       m_arrayObjects(tclassvector),
       m_binUtility(std::move(bingen)) {}
 
 CompactBinnedArray1D* clone() const
 {
   return new CompactBinnedArray1D(m_arrayObjects, m_array, m_binUtility);
 }
 
 CompactBinnedArray1D* clone(const std::vector<T*>& ptrs) const
 {
   assert(ptrs.size() == m_arrayObjects.size());
   return new CompactBinnedArray1D(ptrs, m_array, m_binUtility);
 }
 
  T* object(const Amg::Vector2D& lp) const
  {
    if (m_binUtility.inside(lp)){
      return m_arrayObjects[m_array[m_binUtility.bin(lp, 0)]];
    }
    return nullptr;
  }
 
  T* object(const Amg::Vector3D& gp) const
  {
    return m_arrayObjects[m_array[m_binUtility.bin(gp, 0)]];
  }
 
  T* entryObject(const Amg::Vector3D& gp) const
  {
    return (m_arrayObjects[m_array[m_binUtility.entry(gp, 0)]]);
  }
 
  T* nextObject(const Amg::Vector3D& gp,
                const Amg::Vector3D& mom,
                bool associatedResult = true) const
  {
    // the bins
    size_t bin = associatedResult ? m_binUtility.bin(gp, 0)
                                  : m_binUtility.next(gp, mom, 0);
    return m_arrayObjects[m_array[bin]];
  }
 
  std::span<T* const> arrayObjects()
  {
    return std::span<T* const>(m_arrayObjects.begin(),m_arrayObjects.end());
  }
 
  std::span<T const * const> arrayObjects() const
  {
    return std::span<T const * const>(m_arrayObjects.begin(),m_arrayObjects.end());
  }
 
  unsigned int arrayObjectsNumber() const { return m_arrayObjects.size(); }
 
  const BinUtility* binUtility() const { return &m_binUtility; }
 
  const BinUtility* layerBinUtility(const Amg::Vector3D&) const
  {
    return &m_binUtility;
  }
 
  size_t layerBin(const Amg::Vector3D& pos) const
  {
    return m_binUtility.bin(pos);
  }
 
private:
  std::vector<size_t> m_array{};    
  std::vector<T*> m_arrayObjects{}; 
  BinUtility m_binUtility{};        
};
 
} // end of namespace Trk
 
#endif // TRKDETDESCRUTILS_COMPACTBINNEDARRAY1D_H