CuboidVolumeBounds.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file CuboidVolumeBounds.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/Geometry/Volume.hpp"
#include "Acts/Geometry/VolumeBounds.hpp"
#include "Acts/Utilities/BoundingBox.hpp"

#include <array>
#include <cmath>
#include <iomanip>
#include <iosfwd>
#include <memory>
#include <ostream>
#include <stdexcept>
#include <vector>

namespace Acts {

class RectangleBounds;

class CuboidVolumeBounds : public VolumeBounds {
 public:
  enum BoundValues : unsigned int {
    eHalfLengthX = 0,
    eHalfLengthY = 1,
    eHalfLengthZ = 2,
    eSize
  };

  CuboidVolumeBounds() = delete;

  CuboidVolumeBounds(double halex, double haley, double halez) noexcept(false);

  CuboidVolumeBounds(const std::array<double, eSize>& values) noexcept(false)
      : m_values(values) {
    checkConsistency();
    buildSurfaceBounds();
  }

  CuboidVolumeBounds(const CuboidVolumeBounds& bobo);

  CuboidVolumeBounds& operator=(const CuboidVolumeBounds& bobo);

  ~CuboidVolumeBounds() override = default;

  VolumeBounds::BoundsType type() const final { return VolumeBounds::eCuboid; }

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

  bool inside(const Vector3& pos, double tol = 0.) const override;

  OrientedSurfaces orientedSurfaces(
      const Transform3& transform = Transform3::Identity()) const override;

  Volume::BoundingBox boundingBox(const Transform3* trf = nullptr,
                                  const Vector3& envelope = {0, 0, 0},
                                  const Volume* entity = nullptr) const final;

  double binningBorder(BinningValue bValue) const final;

  double get(BoundValues bValue) const { return m_values[bValue]; }

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

 private:
  template <class stream_t>
  stream_t& dumpT(stream_t& dt) const;

  std::array<double, eSize> m_values;

  std::shared_ptr<const RectangleBounds> m_xyBounds{nullptr};
  std::shared_ptr<const RectangleBounds> m_yzBounds{nullptr};
  std::shared_ptr<const RectangleBounds> m_zxBounds{nullptr};

  void buildSurfaceBounds();

  void checkConsistency() noexcept(false);
};

inline bool CuboidVolumeBounds::inside(const Vector3& pos, double tol) const {
  return (std::abs(pos.x()) <= get(eHalfLengthX) + tol &&
          std::abs(pos.y()) <= get(eHalfLengthY) + tol &&
          std::abs(pos.z()) <= get(eHalfLengthZ) + tol);
}

inline std::vector<double> CuboidVolumeBounds::values() const {
  std::vector<double> valvector;
  valvector.insert(valvector.begin(), m_values.begin(), m_values.end());
  return valvector;
}

inline void CuboidVolumeBounds::checkConsistency() noexcept(false) {
  if (get(eHalfLengthX) <= 0 or get(eHalfLengthY) <= 0 or
      get(eHalfLengthZ) <= 0.) {
    throw std::invalid_argument(
        "CuboidVolumeBounds: invalid input, zero or negative.");
  }
}

template <class stream_t>
stream_t& CuboidVolumeBounds::dumpT(stream_t& dt) const {
  dt << std::setiosflags(std::ios::fixed);
  dt << std::setprecision(5);
  dt << "Acts::CuboidVolumeBounds: (halfLengthX, halfLengthY, halfLengthZ) = ";
  dt << "(" << get(eHalfLengthX) << ", " << get(eHalfLengthY) << ", "
     << get(eHalfLengthZ) << ")";
  return dt;
}
}  // namespace Acts