TrapezoidVolumeBounds.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file TrapezoidVolumeBounds.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 <array>
#include <iomanip>
#include <iosfwd>
#include <memory>
#include <ostream>
#include <stdexcept>
#include <vector>

namespace Acts {

class RectangleBounds;
class TrapezoidBounds;

class TrapezoidVolumeBounds : public VolumeBounds {
 public:
  enum BoundValues : unsigned int {
    eHalfLengthXnegY = 0,  
    eHalfLengthXposY = 1,  
    eHalfLengthY = 2,      
    eHalfLengthZ = 3,      
    eAlpha = 4,            
    eBeta = 5,             
    eSize                  
  };

  TrapezoidVolumeBounds() = delete;

  TrapezoidVolumeBounds(double minhalex, double maxhalex, double haley,
                        double halez) noexcept(false);

  TrapezoidVolumeBounds(double minhalex, double haley, double halez,
                        double alpha, double beta) noexcept(false);

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

  TrapezoidVolumeBounds(const TrapezoidVolumeBounds& trabo) = default;
  ~TrapezoidVolumeBounds() override = default;
  TrapezoidVolumeBounds& operator=(const TrapezoidVolumeBounds& trabo) =
      default;

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

  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;

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

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

 private:
  std::array<double, eSize> m_values{};
  std::shared_ptr<const TrapezoidBounds> m_faceXYTrapezoidBounds{nullptr};
  std::shared_ptr<const RectangleBounds> m_faceAlphaRectangleBounds{nullptr};
  std::shared_ptr<const RectangleBounds> m_faceBetaRectangleBounds{nullptr};
  std::shared_ptr<const RectangleBounds> m_faceZXRectangleBoundsBottom{nullptr};
  std::shared_ptr<const RectangleBounds> m_faceZXRectangleBoundsTop{nullptr};

  void checkConsistency() noexcept(false);

  void buildSurfaceBounds();

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

template <class stream_t>
stream_t& TrapezoidVolumeBounds::dumpT(stream_t& dt) const {
  dt << std::setiosflags(std::ios::fixed);
  dt << std::setprecision(5);
  dt << "Acts::TrapezoidVolumeBounds: (minhalfX, halfY, halfZ, alpha, beta) "
        "= ";
  dt << "(" << get(eHalfLengthXnegY) << ", " << get(eHalfLengthXposY) << ", "
     << get(eHalfLengthY) << ", " << get(eHalfLengthZ);
  dt << ", " << get(eAlpha) << ", " << get(eBeta) << ")";
  return dt;
}

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

inline void TrapezoidVolumeBounds::checkConsistency() noexcept(false) {
  if (get(eHalfLengthXnegY) < 0. or get(eHalfLengthXposY) < 0.) {
    throw std::invalid_argument(
        "TrapezoidVolumeBounds: invalid trapezoid parameters in x.");
  }
  if (get(eHalfLengthY) <= 0.) {
    throw std::invalid_argument("TrapezoidVolumeBounds: invalid y extrusion.");
  }
  if (get(eHalfLengthZ) <= 0.) {
    throw std::invalid_argument("TrapezoidVolumeBounds: invalid z extrusion.");
  }
}

}  // namespace Acts