NavBinnedArray1D.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
// NavBinnedArray1D.h, (c) ATLAS Detector software
 
#ifndef TRKDETDESCRUTILS_NAVBINNEDARRAY1D_H
#define TRKDETDESCRUTILS_NAVBINNEDARRAY1D_H
 
#include "TrkDetDescrUtils/BinUtility.h"
#include "TrkDetDescrUtils/SharedObject.h"
 
// STL
#include <vector>
 
class MsgStream;
 
namespace Trk {
 
template<class T>
class NavBinnedArray1D final : public BinnedArray<T>
{
 
public:
  NavBinnedArray1D()
    : BinnedArray<T>()
    , m_array{}
    , m_arrayObjects(nullptr)
    , m_binUtility()
    , m_transf(nullptr)
  {}
 
  NavBinnedArray1D(const std::vector<SharedObject<T>>& tclassvector,
                   BinUtility* bingen,
                   Amg::Transform3D* transform)
    : BinnedArray<T>()
    , m_array{}
    , m_arrayObjects(nullptr)
    , m_binUtility(SharedObject<BinUtility>(bingen))
    , m_transf(transform)
  {
    // prepare the binned Array // simplify as the array is ordered when defined
    if (bingen) {
      m_array = std::vector<SharedObject<T>>(tclassvector);
    }
  }
 
  NavBinnedArray1D(const NavBinnedArray1D& barr,
                   std::vector<SharedObject<T>>&& vec,
                   Amg::Transform3D& shift)
    : BinnedArray<T>()
    , m_array(std::move(vec))
    , m_arrayObjects{}
    , m_binUtility(barr.m_binUtility)
    , m_transf(new Amg::Transform3D(shift * (*barr.m_transf)))
  {}
 
  NavBinnedArray1D(const NavBinnedArray1D& barr)
    : BinnedArray<T>()
    , m_array{}
    , m_arrayObjects(nullptr)
    , m_binUtility(barr.m_binUtility)
    , m_transf(nullptr)
  {
    if (m_binUtility.get()) {
      m_array = std::vector<SharedObject<T>>(m_binUtility.get()->bins(0));
      for (size_t ient = 0; ient < m_binUtility.get()->bins(0); ++ient) {
        m_array[ient] = (barr.m_array)[ient];
      }
    }
    m_transf =
      (barr.m_transf) ? new Amg::Transform3D(*(barr.m_transf)) : nullptr;
  }
 
  NavBinnedArray1D& operator=(const NavBinnedArray1D& barr)
  {
    if (this != &barr) {
      m_arrayObjects.release();
      delete m_transf;
      // now refill
      m_binUtility = barr.m_binUtility;
      // --------------------------------------------------------------------------
      if (m_binUtility.get()) {
        m_array = std::vector<SharedObject<T>>(m_binUtility.get()->bins(0));
        for (size_t ient = 0; ient < m_binUtility.get()->bins(0); ++ient) {
          m_array[ient] = (barr.m_array)[ient];
        }
      }
      m_transf =
        (barr.m_transf) ? new Amg::Transform3D(*barr.m_transf) : nullptr;
    }
    return *this;
  }
 
  NavBinnedArray1D* clone() const { return new NavBinnedArray1D(*this); }
 
  ~NavBinnedArray1D() { delete m_transf; }
 
  T* object(const Amg::Vector2D& lp) const
  {
    if (m_binUtility.get()->inside(lp)) {
      return (m_array[m_binUtility.get()->bin(lp)]).get();
    }
    return nullptr;
  }
 
  T* object(const Amg::Vector3D& gp) const
  {
    // transform into navig.coordinates
    const Amg::Vector3D navGP((m_transf->inverse()) * gp);
    if (m_binUtility.get()->inside(navGP)) {
      return (m_array[m_binUtility.get()->bin(navGP)]).get();
    }
    return nullptr;
  }
 
  T* entryObject(const Amg::Vector3D&) const { return (m_array[0]).get(); }
 
  T* nextObject(const Amg::Vector3D& gp,
                const Amg::Vector3D& mom,
                bool associatedResult = true) const
  {
    // transform into navig.coordinates
    const Amg::Vector3D navGP((m_transf->inverse()) * gp);
    const Amg::Vector3D navMom((m_transf->inverse()).linear() * mom);
    // the bins
    size_t firstBin = m_binUtility.get()->next(navGP, navMom, 0);
    // use the information of the associated result
    if (associatedResult) {
      if (firstBin <= m_binUtility.get()->max(0)) {
        return (m_array[firstBin]).get();
      } else {
        return nullptr;
      }
    }
    // the associated result was 0 -> set to boundary
    firstBin = (firstBin < m_binUtility.get()->bins(0))
                 ? firstBin
                 : m_binUtility.get()->max(0);
    return (m_array[m_binUtility.get()->bin(navGP)]).get();
  }
 
  BinnedArraySpan<T* const> arrayObjects()
  {
    createArrayCache();
    return BinnedArraySpan<T* const>(&*(m_arrayObjects->begin()), &*(m_arrayObjects->end()));
  }
 
  BinnedArraySpan<T const * const> arrayObjects() const
  {
    createArrayCache();
    return BinnedArraySpan<T const * const>(&*(m_arrayObjects->begin()), &*(m_arrayObjects->end()));
  }
 
  unsigned int arrayObjectsNumber() const { return arrayObjects().size(); }
 
  const BinUtility* binUtility() const { return (m_binUtility.get()); }
 
  Amg::Transform3D* transform() const { return (m_transf); }
 
  void updateTransform(Amg::Transform3D& transform)
  {
    Amg::Transform3D* tr = m_transf;
    m_transf = new Amg::Transform3D(transform * (*m_transf));
    delete tr;
  }
 
private:
  void createArrayCache() const
  {
    if (!m_arrayObjects) {
      std::unique_ptr<std::vector<T*>> arrayObjects =
        std::make_unique<std::vector<T*>>();
      for (unsigned int ill = 0; ill < m_array.size(); ++ill) {
        arrayObjects->push_back((m_array[ill]).get());
      }
      m_arrayObjects.set(std::move(arrayObjects));
    }
  }
 
  std::vector<SharedObject<T>> m_array;
  CxxUtils::CachedUniquePtr<std::vector<T*>> m_arrayObjects;
  SharedObject<BinUtility> m_binUtility;
  // !< transform into local navigation coordinates
  Amg::Transform3D* m_transf;
};
 
} // end of namespace Trk
 
#endif // TRKDETDESCRUTILS_NAVBINNEDARRAY1D_H