RangeXD.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2021 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/Utilities/Range1D.hpp"

#include <algorithm>
#include <array>
#include <limits>
#include <sstream>
#include <string>

namespace Acts {
template <std::size_t Dims, typename Type,
          template <typename, std::size_t> typename Vector = std::array>
class RangeXD {
 public:
  using coordinate_t = Vector<Type, Dims>;

  bool degenerate(void) const {
    for (std::size_t i = 0; i < Dims; ++i) {
      if (m_dims[i].degenerate()) {
        return true;
      }
    }
    return false;
  }

  bool contains(const coordinate_t& v) const {
    for (std::size_t i = 0; i < Dims; ++i) {
      if (!m_dims[i].contains(v[i])) {
        return false;
      }
    }

    return true;
  }

  Range1D<Type>& operator[](const std::size_t& i) { return m_dims[i]; }

  const Range1D<Type>& operator[](const std::size_t& i) const {
    return m_dims[i];
  }

  bool operator==(const RangeXD<Dims, Type, Vector>& o) const {
    for (std::size_t i = 0; i < Dims; ++i) {
      if (!(this->m_dims[i] == o[i])) {
        return false;
      }
    }

    return true;
  }

  bool operator<=(const RangeXD<Dims, Type, Vector>& o) const {
    for (std::size_t i = 0; i < Dims; ++i) {
      if (!(this->m_dims[i] <= o[i])) {
        return false;
      }
    }

    return true;
  }

  bool operator>=(const RangeXD<Dims, Type, Vector>& o) const {
    for (std::size_t i = 0; i < Dims; ++i) {
      if (!(this->m_dims[i] >= o[i])) {
        return false;
      }
    }

    return true;
  }

  RangeXD<Dims, Type, Vector> operator&(
      const RangeXD<Dims, Type, Vector>& o) const {
    RangeXD<Dims, Type> res;

    for (std::size_t i = 0; i < Dims; ++i) {
      res[i] = m_dims[i] & o[i];
    }

    return res;
  }

  RangeXD<Dims, Type, Vector>& operator&=(
      const RangeXD<Dims, Type, Vector>& o) {
    for (std::size_t i = 0; i < Dims; ++i) {
      m_dims[i] &= o[i];
    }

    return *this;
  }

  bool operator&&(const RangeXD<Dims, Type, Vector>& r) const {
    for (std::size_t i = 0; i < Dims; ++i) {
      if (!(m_dims[i] && r[i])) {
        return false;
      }
    }

    return true;
  }

  std::string toString(void) const {
    std::stringstream s;

    for (std::size_t i = 0; i < Dims; ++i) {
      s << m_dims[i].min() << " <= v[" << i << "] <= " << m_dims[i].max();
      if (i != Dims - 1) {
        s << ", ";
      }
    }

    return s.str();
  }

 private:
  std::array<Range1D<Type>, Dims> m_dims;
};
}  // namespace Acts