RectangleBounds.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2016-2020 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/Surfaces/BoundaryCheck.hpp"
#include "Acts/Surfaces/PlanarBounds.hpp"
#include "Acts/Surfaces/SurfaceBounds.hpp"

#include <array>
#include <cassert>
#include <iosfwd>
#include <limits>
#include <stdexcept>
#include <vector>

namespace Acts {

class RectangleBounds : public PlanarBounds {
 public:
  enum BoundValues : int {
    eMinX = 0,
    eMinY = 1,
    eMaxX = 2,
    eMaxY = 3,
    eSize = 4
  };

  RectangleBounds() = delete;

  RectangleBounds(double halfX, double halfY) noexcept(false)
      : m_min({-halfX, -halfY}), m_max({halfX, halfY}) {
    checkConsistency();
  }

  RectangleBounds(const std::array<double, eSize>& values) noexcept(false)
      : m_min({values[eMinX], values[eMinY]}),
        m_max({values[eMaxX], values[eMaxY]}) {
    checkConsistency();
  }

  RectangleBounds(const Vector2& min, const Vector2& max) noexcept(false)
      : m_min(min), m_max(max) {
    checkConsistency();
  }

  ~RectangleBounds() override = default;

  BoundsType type() const final;

  std::vector<double> values() const final;

  bool inside(const Vector2& lposition,
              const BoundaryCheck& bcheck) const final;

  std::vector<Vector2> vertices(unsigned int lseg = 1) const final;

  // Bounding box representation
  const RectangleBounds& boundingBox() const final;

  std::ostream& toStream(std::ostream& sl) const final;

  double get(BoundValues bValue) const;

  double halfLengthX() const;

  double halfLengthY() const;

  const Vector2& min() const;

  const Vector2& max() const;

 private:
  Vector2 m_min;
  Vector2 m_max;

  void checkConsistency() noexcept(false);
};

inline SurfaceBounds::BoundsType RectangleBounds::type() const {
  return SurfaceBounds::eRectangle;
}

inline const Vector2& RectangleBounds::min() const {
  return m_min;
}

inline const Vector2& RectangleBounds::max() const {
  return m_max;
}

inline double RectangleBounds::halfLengthX() const {
  return 0.5 * (m_max.x() - m_min.x());
}

inline double RectangleBounds::halfLengthY() const {
  return 0.5 * (m_max.y() - m_min.y());
}

inline std::vector<double> RectangleBounds::values() const {
  return {m_min.x(), m_min.y(), m_max.x(), m_max.y()};
}

inline double RectangleBounds::get(BoundValues bValue) const {
  switch (bValue) {
    case eMinX:
      return m_min.x();
    case eMinY:
      return m_min.y();
    case eMaxX:
      return m_max.x();
    case eMaxY:
      return m_max.y();
    default:
      assert(false and "Invalid BoundValue enum value");
      return std::numeric_limits<double>::quiet_NaN();
  }
}

inline void RectangleBounds::checkConsistency() noexcept(false) {
  if (get(eMinX) > get(eMaxX)) {
    throw std::invalid_argument("RectangleBounds: invalid local x setup");
  }
  if (get(eMinY) > get(eMaxY)) {
    throw std::invalid_argument("RectangleBounds: invalid local y setup");
  }
}

}  // namespace Acts