Extent.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2022 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 "Acts/Definitions/Algebra.hpp"
#include "Acts/Utilities/BinningType.hpp"
#include "Acts/Utilities/Enumerate.hpp"
#include "Acts/Utilities/Range1D.hpp"
#include "Acts/Utilities/RangeXD.hpp"

#include <array>
#include <bitset>
#include <ostream>
#include <string>
#include <vector>

namespace Acts {

using Envelope = std::array<ActsScalar, 2>;
using ExtentEnvelope = std::array<Envelope, binValues>;

constexpr Envelope zeroEnvelope = {0, 0};
constexpr ExtentEnvelope zeroEnvelopes = {
    zeroEnvelope, zeroEnvelope, zeroEnvelope, zeroEnvelope,
    zeroEnvelope, zeroEnvelope, zeroEnvelope, zeroEnvelope};

class Extent {
 public:
  Extent(const ExtentEnvelope& envelope = zeroEnvelopes);

  bool operator==(const Extent& e) const;

  bool operator!=(const Extent& e) const { return (not operator==(e)); }

  void extend(const Vector3& vtx,
              const std::vector<BinningValue>& bValues = s_binningValues,
              bool applyEnv = true, bool fillHistograms = false);

  template <typename vector_iterator_t>
  void extend(const vector_iterator_t& start, const vector_iterator_t& end,
              const std::vector<BinningValue>& bValues = s_binningValues,
              bool applyEnv = true, bool fillHistograms = false) {
    for (vector_iterator_t vIt = start; vIt < end; ++vIt) {
      extend(*vIt, bValues, applyEnv, fillHistograms);
    }
  }

  void extend(const Extent& rhs,
              const std::vector<BinningValue>& bValues = s_binningValues,
              bool applyEnv = true);

  void addConstrain(const Extent& rhs,
                    const ExtentEnvelope& envelope = zeroEnvelopes);

  void set(BinningValue bValue, ActsScalar min, ActsScalar max);

  void setEnvelope(const ExtentEnvelope& envelope = zeroEnvelopes);

  Range1D<ActsScalar>& range(BinningValue bValue);

  const Range1D<ActsScalar>& range(BinningValue bValue) const;

  const RangeXD<binValues, ActsScalar> range() const;

  template <unsigned int kSUBDIM>
  RangeXD<kSUBDIM, ActsScalar> range(
      const std::array<BinningValue, kSUBDIM>& binValues) const {
    RangeXD<kSUBDIM, ActsScalar> rRange;
    for (auto [i, v] : enumerate(binValues)) {
      rRange[i] = range(v);
    }
    return rRange;
  }

  ExtentEnvelope& envelope();

  const ExtentEnvelope& envelope() const;

  const std::array<std::vector<ActsScalar>, binValues>& valueHistograms() const;

  ActsScalar min(BinningValue bValue) const { return m_range[bValue].min(); }

  ActsScalar max(BinningValue bValue) const { return m_range[bValue].max(); }

  ActsScalar medium(BinningValue bValue) const {
    return 0.5 * (m_range[bValue].min() + m_range[bValue].max());
  }

  ActsScalar interval(BinningValue bValue) const {
    return m_range[bValue].size();
  }

  bool contains(const Extent& rhs, BinningValue bValue = binValues) const;

  bool intersects(const Extent& rhs, BinningValue bValue = binValues) const;

  bool constrains(BinningValue bValue = binValues) const;

  std::string toString(const std::string& indent = "") const;

 private:
  std::bitset<binValues> m_constrains{0};
  RangeXD<binValues, ActsScalar> m_range;
  ExtentEnvelope m_envelope = zeroEnvelopes;
  std::array<std::vector<ActsScalar>, binValues> m_valueHistograms;
};

inline Range1D<ActsScalar>& Acts::Extent::range(BinningValue bValue) {
  return m_range[bValue];
}

inline const Range1D<ActsScalar>& Acts::Extent::range(
    BinningValue bValue) const {
  return m_range[bValue];
}

inline const RangeXD<binValues, ActsScalar> Extent::range() const {
  return m_range;
}

inline ExtentEnvelope& Extent::envelope() {
  return m_envelope;
}

inline const ExtentEnvelope& Extent::envelope() const {
  return m_envelope;
}

inline const std::array<std::vector<ActsScalar>, binValues>&
Extent::valueHistograms() const {
  return m_valueHistograms;
}

std::ostream& operator<<(std::ostream& sl, const Extent& rhs);

}  // namespace Acts