BinnedArrayXD.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file BinnedArrayXD.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2016-2018 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

// BinnedArrayXD.h, Acts project

#pragma once
#include <array>
#include <iostream>
#include <vector>
#include "Acts/Utilities/BinUtility.hpp"
#include "Acts/Utilities/BinnedArray.hpp"

class MsgStream;

namespace Acts {

template <class T>
class BinnedArrayXD : public BinnedArray<T> {
  using TAP = std::pair<T, Vector3D>;

 public:
  BinnedArrayXD(T object)
      : BinnedArray<T>(),
        m_objectGrid(
            1, std::vector<std::vector<T>>(1, std::vector<T>(1, nullptr))),
        m_arrayObjects({object}),
        m_binUtility(nullptr) {
    m_objectGrid[0][0][0] = object;
  }

  BinnedArrayXD(const std::vector<TAP>& tapvector,
                std::unique_ptr<const BinUtility> bu)
      : BinnedArray<T>(),
        m_objectGrid(bu->bins(2),
                     std::vector<std::vector<T>>(
                         bu->bins(1), std::vector<T>(bu->bins(0), nullptr))),
        m_arrayObjects(),
        m_binUtility(std::move(bu)) {
    m_arrayObjects.reserve(tapvector.size());
    for (auto& tap : tapvector) {
      if (m_binUtility->inside(tap.second)) {
        // butil to the array store - if the bingen
        // dimension is smaller 1,2 it will provide 0
        auto bins = m_binUtility->binTriple(tap.second);
        m_objectGrid[bins[2]][bins[1]][bins[0]] = tap.first;
        if (std::find(m_arrayObjects.begin(), m_arrayObjects.end(),
                      tap.first) == m_arrayObjects.end()) {
          m_arrayObjects.push_back(tap.first);
        }
      }
    }
  }

  BinnedArrayXD(const std::vector<std::vector<std::vector<T>>>& grid,
                std::unique_ptr<const BinUtility> bu)
      : BinnedArray<T>(),
        m_objectGrid(grid),
        m_arrayObjects(),
        m_binUtility(std::move(bu)) {
    // get the total dimension
    size_t objects =
        m_binUtility->bins(0) * m_binUtility->bins(1) * m_binUtility->bins(2);
    m_arrayObjects.reserve(objects);
    for (auto& o2 : m_objectGrid) {
      for (auto& o1 : o2) {
        for (auto& o0 : o1) {
          if (o0) {
            if (std::find(m_arrayObjects.begin(), m_arrayObjects.end(), o0) ==
                m_arrayObjects.end()) {
              m_arrayObjects.push_back(o0);
            }
          }
        }
      }
    }
  }

  BinnedArrayXD(const BinnedArrayXD<T>& barr) = delete;

  BinnedArrayXD& operator=(const BinnedArrayXD<T>& barr) = delete;

  ~BinnedArrayXD() override = default;
  T object(const Vector2D& lposition, std::array<size_t, 3>& bins) const final {
    if (m_binUtility) {
      size_t bdim = m_binUtility->dimensions();
      bins[2] = bdim > 2 ? m_binUtility->bin(lposition, 2) : 0;
      bins[1] = bdim > 1 ? m_binUtility->bin(lposition, 1) : 0;
      bins[0] = m_binUtility->bin(lposition, 0);
      return m_objectGrid[bins[2]][bins[1]][bins[0]];
    }
    return m_objectGrid[0][0][0];
  }

  // satisfy overload / override
  T object(const Vector2D& lposition) const override {
    std::array<size_t, 3> bins;
    return object(lposition, bins);
  }

  T object(const Vector3D& position, std::array<size_t, 3>& bins) const final {
    if (m_binUtility) {
      size_t bdim = m_binUtility->dimensions();
      bins[2] = bdim > 2 ? m_binUtility->bin(position, 2) : 0;
      bins[1] = bdim > 1 ? m_binUtility->bin(position, 1) : 0;
      bins[0] = m_binUtility->bin(position, 0);
      return m_objectGrid[bins[2]][bins[1]][bins[0]];
    }
    return m_objectGrid[0][0][0];
  }

  // satisfy overload / override
  T object(const Vector3D& position) const override {
    std::array<size_t, 3> bins;
    return object(position, bins);
  }

  const std::vector<T>& arrayObjects() const final { return m_arrayObjects; }

  const std::vector<std::vector<std::vector<T>>>& objectGrid() const final {
    return m_objectGrid;
  }

  std::vector<T> objectCluster(
      const std::array<size_t, 3>& binTriple) const override {
    // prepare the return vector
    std::vector<T> rvector;
    // reference bin object to be excluded
    T bObject = m_objectGrid[binTriple[2]][binTriple[1]][binTriple[0]];
    // get the dimensions first
    size_t bdim = m_binUtility->dimensions();
    // avoiding code duplication
    std::vector<size_t> zerorange = {0};
    // 2D bin
    std::vector<size_t> bin2values =
        (bdim > 2) ? m_binUtility->binningData()[2].neighbourRange(binTriple[2])
                   : zerorange;
    // 1D bin
    std::vector<size_t> bin1values =
        (bdim > 1) ? m_binUtility->binningData()[1].neighbourRange(binTriple[1])
                   : zerorange;
    // 0D bin
    std::vector<size_t> bin0values =
        m_binUtility->binningData()[0].neighbourRange(binTriple[0]);

    // do the loop
    for (auto b2 : bin2values) {
      for (auto b1 : bin1values) {
        for (auto b0 : bin0values) {
          // get the object
          T object = m_objectGrid[b2][b1][b0];
          if (object && object != bObject &&
              std::find(rvector.begin(), rvector.end(), object) ==
                  rvector.end()) {
            rvector.push_back(object);
          }
        }
      }
    }
    // return the ones you found
    return rvector;
  }

  const BinUtility* binUtility() const final { return (m_binUtility.get()); }

 private:
  std::vector<std::vector<std::vector<T>>> m_objectGrid;
  std::vector<T> m_arrayObjects;
  std::unique_ptr<const BinUtility> m_binUtility;
};
}  // end of namespace Acts