Axis.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2017-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/.

#pragma once

#include <algorithm>
#include <cmath>
#include <vector>
#include "Acts/Utilities/IAxis.hpp"
#include "Acts/Utilities/detail/AxisFwd.hpp"

namespace Acts {

namespace detail {

// This object can be iterated to produce up to two sequences of integer
// indices, corresponding to the half-open integer ranges [begin1, end1[ and
// [begin2, end2[.
//
// The goal is to emulate the effect of enumerating a range of neighbor
// indices on an axis (which may go out of bounds and wrap around since we
// have AxisBoundaryType::Closed), inserting them into an std::vector, and
// discarding duplicates, without paying the price of duplicate removal
// and dynamic memory allocation in hot magnetic field interpolation code.
//
class NeighborHoodIndices {
 public:
  NeighborHoodIndices() = default;

  NeighborHoodIndices(size_t begin, size_t end)
      : m_begin1(begin), m_end1(end), m_begin2(end), m_end2(end) {}

  NeighborHoodIndices(size_t begin1, size_t end1, size_t begin2, size_t end2)
      : m_begin1(begin1), m_end1(end1), m_begin2(begin2), m_end2(end2) {}

  class iterator {
   public:
    iterator() = default;

    // Specialized constructor for end() iterator
    iterator(size_t current) : m_current(current), m_wrapped(true) {}

    iterator(size_t begin1, size_t end1, size_t begin2)
        : m_current(begin1),
          m_end1(end1),
          m_begin2(begin2),
          m_wrapped(begin1 == begin2) {}

    size_t operator*() const { return m_current; }

    iterator& operator++() {
      ++m_current;
      if (m_current == m_end1) {
        m_current = m_begin2;
        m_wrapped = true;
      }
      return *this;
    }

    bool operator==(const iterator& it) const {
      return (m_current == it.m_current) && (m_wrapped == it.m_wrapped);
    }

    bool operator!=(const iterator& it) const { return !(*this == it); }

   private:
    size_t m_current, m_end1, m_begin2;
    bool m_wrapped;
  };

  iterator begin() const { return iterator(m_begin1, m_end1, m_begin2); }

  iterator end() const { return iterator(m_end2); }

  // Number of indices that will be produced if this sequence is iterated
  size_t size() const { return (m_end1 - m_begin1) + (m_end2 - m_begin2); }

  // Collect the sequence of indices into an std::vector
  std::vector<size_t> collect() const {
    std::vector<size_t> result;
    result.reserve(this->size());
    for (size_t idx : *this) {
      result.push_back(idx);
    }
    return result;
  }

 private:
  size_t m_begin1 = 0, m_end1 = 0, m_begin2 = 0, m_end2 = 0;
};

template <AxisBoundaryType bdt>
class Axis<AxisType::Equidistant, bdt> final : public IAxis {
 public:
  Axis(double xmin, double xmax, size_t nBins)
      : m_min(xmin),
        m_max(xmax),
        m_width((xmax - xmin) / nBins),
        m_bins(nBins) {}

  bool isEquidistant() const override { return true; }

  bool isVariable() const override { return false; }

  AxisBoundaryType getBoundaryType() const override { return bdt; }

  NeighborHoodIndices neighborHoodIndices(size_t idx, size_t size = 1) const {
    return neighborHoodIndices(idx, std::make_pair(size, size));
  }

  template <AxisBoundaryType T = bdt,
            std::enable_if_t<T == AxisBoundaryType::Open, int> = 0>
  NeighborHoodIndices neighborHoodIndices(size_t idx,
                                          std::pair<size_t, size_t> sizes = {
                                              1, 1}) const {
    constexpr int min = 0;
    const int max = getNBins() + 1;
    const int itmin = std::max(min, int(idx - sizes.first));
    const int itmax = std::min(max, int(idx + sizes.second));
    return NeighborHoodIndices(itmin, itmax + 1);
  }

  template <AxisBoundaryType T = bdt,
            std::enable_if_t<T == AxisBoundaryType::Bound, int> = 0>
  NeighborHoodIndices neighborHoodIndices(size_t idx,
                                          std::pair<size_t, size_t> sizes = {
                                              1, 1}) const {
    if (idx <= 0 || idx >= (getNBins() + 1)) {
      return NeighborHoodIndices();
    }
    constexpr int min = 1;
    const int max = getNBins();
    const int itmin = std::max(min, int(idx - sizes.first));
    const int itmax = std::min(max, int(idx + sizes.second));
    return NeighborHoodIndices(itmin, itmax + 1);
  }

  template <AxisBoundaryType T = bdt,
            std::enable_if_t<T == AxisBoundaryType::Closed, int> = 0>
  NeighborHoodIndices neighborHoodIndices(size_t idx,
                                          std::pair<size_t, size_t> sizes = {
                                              1, 1}) const {
    // Handle invalid indices
    if (idx <= 0 || idx >= (getNBins() + 1)) {
      return NeighborHoodIndices();
    }

    // Handle corner case where user requests more neighbours than the number
    // of bins on the axis. We do not want to double-count bins in that case.
    sizes.first %= getNBins();
    sizes.second %= getNBins();
    if (sizes.first + sizes.second + 1 > getNBins()) {
      sizes.second -= (sizes.first + sizes.second + 1) - getNBins();
    }

    // If the entire index range is not covered, we must wrap the range of
    // targeted neighbor indices into the range of valid bin indices. This may
    // split the range of neighbor indices in two parts:
    //
    // Before wraparound - [        XXXXX]XXX
    // After wraparound  - [ XXXX   XXXX ]
    //
    const int itmin = idx - sizes.first;
    const int itmax = idx + sizes.second;
    const size_t itfirst = wrapBin(itmin);
    const size_t itlast = wrapBin(itmax);
    if (itfirst <= itlast) {
      return NeighborHoodIndices(itfirst, itlast + 1);
    } else {
      return NeighborHoodIndices(itfirst, getNBins() + 1, 1, itlast + 1);
    }
  }

  template <AxisBoundaryType T = bdt,
            std::enable_if_t<T == AxisBoundaryType::Open, int> = 0>
  size_t wrapBin(int bin) const {
    return std::max(std::min(bin, static_cast<int>(getNBins()) + 1), 0);
  }

  template <AxisBoundaryType T = bdt,
            std::enable_if_t<T == AxisBoundaryType::Bound, int> = 0>
  size_t wrapBin(int bin) const {
    return std::max(std::min(bin, static_cast<int>(getNBins())), 1);
  }

  template <AxisBoundaryType T = bdt,
            std::enable_if_t<T == AxisBoundaryType::Closed, int> = 0>
  size_t wrapBin(int bin) const {
    const int w = getNBins();
    return 1 + (w + ((bin - 1) % w)) % w;
    // return int(bin<1)*w - int(bin>w)*w + bin;
  }

  size_t getBin(double x) const {
    return wrapBin(std::floor((x - getMin()) / getBinWidth()) + 1);
  }

  double getBinWidth(size_t /*bin*/ = 0) const { return m_width; }

  double getBinLowerBound(size_t bin) const {
    return getMin() + (bin - 1) * getBinWidth();
  }

  double getBinUpperBound(size_t bin) const {
    return getMin() + bin * getBinWidth();
  }

  double getBinCenter(size_t bin) const {
    return getMin() + (bin - 0.5) * getBinWidth();
  }

  double getMax() const override { return m_max; }

  double getMin() const override { return m_min; }

  size_t getNBins() const override { return m_bins; }

  bool isInside(double x) const { return (m_min <= x) && (x < m_max); }

  std::vector<double> getBinEdges() const override {
    std::vector<double> binEdges;
    for (size_t i = 1; i <= m_bins; i++) {
      binEdges.push_back(getBinLowerBound(i));
    }
    binEdges.push_back(getBinUpperBound(m_bins));
    return binEdges;
  }

 private:
  double m_min;
  double m_max;
  double m_width;
  size_t m_bins;
};

template <AxisBoundaryType bdt>
class Axis<AxisType::Variable, bdt> final : public IAxis {
 public:
  Axis(std::vector<double> binEdges) : m_binEdges(std::move(binEdges)) {}

  bool isEquidistant() const override { return false; }

  bool isVariable() const override { return true; }

  AxisBoundaryType getBoundaryType() const override { return bdt; }

  NeighborHoodIndices neighborHoodIndices(size_t idx, size_t size = 1) const {
    return neighborHoodIndices(idx, std::make_pair(size, size));
  }

  template <AxisBoundaryType T = bdt,
            std::enable_if_t<T == AxisBoundaryType::Open, int> = 0>
  NeighborHoodIndices neighborHoodIndices(size_t idx,
                                          std::pair<size_t, size_t> sizes = {
                                              1, 1}) const {
    constexpr int min = 0;
    const int max = getNBins() + 1;
    const int itmin = std::max(min, int(idx - sizes.first));
    const int itmax = std::min(max, int(idx + sizes.second));
    return NeighborHoodIndices(itmin, itmax + 1);
  }

  template <AxisBoundaryType T = bdt,
            std::enable_if_t<T == AxisBoundaryType::Bound, int> = 0>
  NeighborHoodIndices neighborHoodIndices(size_t idx,
                                          std::pair<size_t, size_t> sizes = {
                                              1, 1}) const {
    if (idx <= 0 || idx >= (getNBins() + 1)) {
      return NeighborHoodIndices();
    }
    constexpr int min = 1;
    const int max = getNBins();
    const int itmin = std::max(min, int(idx - sizes.first));
    const int itmax = std::min(max, int(idx + sizes.second));
    return NeighborHoodIndices(itmin, itmax + 1);
  }

  template <AxisBoundaryType T = bdt,
            std::enable_if_t<T == AxisBoundaryType::Closed, int> = 0>
  NeighborHoodIndices neighborHoodIndices(size_t idx,
                                          std::pair<size_t, size_t> sizes = {
                                              1, 1}) const {
    // Handle invalid indices
    if (idx <= 0 || idx >= (getNBins() + 1)) {
      return NeighborHoodIndices();
    }

    // Handle corner case where user requests more neighbours than the number
    // of bins on the axis. We do not want to double-count bins in that case.
    sizes.first %= getNBins();
    sizes.second %= getNBins();
    if (sizes.first + sizes.second + 1 > getNBins()) {
      sizes.second -= (sizes.first + sizes.second + 1) - getNBins();
    }

    // If the entire index range is not covered, we must wrap the range of
    // targeted neighbor indices into the range of valid bin indices. This may
    // split the range of neighbor indices in two parts:
    //
    // Before wraparound - [        XXXXX]XXX
    // After wraparound  - [ XXXX   XXXX ]
    //
    const int itmin = idx - sizes.first;
    const int itmax = idx + sizes.second;
    const size_t itfirst = wrapBin(itmin);
    const size_t itlast = wrapBin(itmax);
    if (itfirst <= itlast) {
      return NeighborHoodIndices(itfirst, itlast + 1);
    } else {
      return NeighborHoodIndices(itfirst, getNBins() + 1, 1, itlast + 1);
    }
  }

  template <AxisBoundaryType T = bdt,
            std::enable_if_t<T == AxisBoundaryType::Open, int> = 0>
  size_t wrapBin(int bin) const {
    return std::max(std::min(bin, static_cast<int>(getNBins()) + 1), 0);
  }

  template <AxisBoundaryType T = bdt,
            std::enable_if_t<T == AxisBoundaryType::Bound, int> = 0>
  size_t wrapBin(int bin) const {
    return std::max(std::min(bin, static_cast<int>(getNBins())), 1);
  }

  template <AxisBoundaryType T = bdt,
            std::enable_if_t<T == AxisBoundaryType::Closed, int> = 0>
  size_t wrapBin(int bin) const {
    const int w = getNBins();
    return 1 + (w + ((bin - 1) % w)) % w;
    // return int(bin<1)*w - int(bin>w)*w + bin;
  }

  size_t getBin(double x) const {
    const auto it =
        std::upper_bound(std::begin(m_binEdges), std::end(m_binEdges), x);
    return wrapBin(std::distance(std::begin(m_binEdges), it));
  }

  double getBinWidth(size_t bin) const {
    return m_binEdges.at(bin) - m_binEdges.at(bin - 1);
  }

  double getBinLowerBound(size_t bin) const { return m_binEdges.at(bin - 1); }

  double getBinUpperBound(size_t bin) const { return m_binEdges.at(bin); }

  double getBinCenter(size_t bin) const {
    return 0.5 * (getBinLowerBound(bin) + getBinUpperBound(bin));
  }

  double getMax() const override { return m_binEdges.back(); }

  double getMin() const override { return m_binEdges.front(); }

  size_t getNBins() const override { return m_binEdges.size() - 1; }

  bool isInside(double x) const {
    return (m_binEdges.front() <= x) && (x < m_binEdges.back());
  }

  std::vector<double> getBinEdges() const override { return m_binEdges; }

 private:
  std::vector<double> m_binEdges;
};
}  // namespace detail

}  // namespace Acts