ConeVolumeBounds.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 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/Geometry/Volume.hpp"
#include "Acts/Geometry/VolumeBounds.hpp"
#include "Acts/Utilities/BoundingBox.hpp"
#include "Acts/Utilities/Definitions.hpp"

#include <cmath>

namespace Acts {

class Surface;
class CylinderBounds;
class ConeBounds;
class RadialBounds;
class PlanarBounds;
class Volume;

class ConeVolumeBounds : public VolumeBounds {
 public:
  enum BoundValues : unsigned int {
    eInnerAlpha = 0,
    eInnerOffsetZ = 1,
    eOuterAlpha = 2,
    eOuterOffsetZ = 3,
    eHalfLengthZ = 4,
    eAveragePhi = 5,
    eHalfPhiSector = 6,
    eSize
  };

  ConeVolumeBounds() = delete;

  ConeVolumeBounds(double innerAlpha, double innerTipZ, double outerAlpha,
                   double outerOffsetZ, double halflengthZ, double averagePhi,
                   double halfPhiSector) noexcept(false);

  ConeVolumeBounds(double cylinderR, double alpha, double offsetZ,
                   double halflengthZ, double averagePhi,
                   double halfPhiSector) noexcept(false);

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

  ConeVolumeBounds(const ConeVolumeBounds& cobo) = default;
  ~ConeVolumeBounds() override = default;
  ConeVolumeBounds& operator=(const ConeVolumeBounds& cobo) = default;

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

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

  bool inside(const Vector3D& pos, double tol = 0.) const final;

  OrientedSurfaces orientedSurfaces(
      const Transform3D& transform = Transform3D::Identity()) const final;

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

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

  // Return the derived innerRmin
  double innerRmin() const;

  // Return the derived innerRmin
  double innerRmax() const;

  // Return the derived inner tan(alpha)
  double innerTanAlpha() const;

  // Return the derived outerRmin
  double outerRmin() const;

  // Return the derived outerRmax
  double outerRmax() const;

  // Return the derived outer tan(alpha)
  double outerTanAlpha() const;

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

 private:
  void checkConsistency() noexcept(false);

  void buildSurfaceBounds();

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

  std::array<double, eSize> m_values;
  std::shared_ptr<CylinderBounds> m_innerCylinderBounds{nullptr};
  std::shared_ptr<ConeBounds> m_innerConeBounds{nullptr};
  std::shared_ptr<ConeBounds> m_outerConeBounds{nullptr};
  std::shared_ptr<CylinderBounds> m_outerCylinderBounds{nullptr};
  std::shared_ptr<RadialBounds> m_negativeDiscBounds{nullptr};
  std::shared_ptr<RadialBounds> m_positiveDiscBounds{nullptr};
  std::shared_ptr<PlanarBounds> m_sectorBounds{nullptr};

  double m_innerRmin = 0.;
  double m_innerRmax = 0.;
  double m_innerTanAlpha = 0.;
  double m_outerRmin = 0.;
  double m_outerRmax = 0.;
  double m_outerTanAlpha = 0.;
};

inline double ConeVolumeBounds::innerRmin() const {
  return m_innerRmin;
}

inline double ConeVolumeBounds::innerRmax() const {
  return m_innerRmax;
}

inline double ConeVolumeBounds::innerTanAlpha() const {
  return m_innerTanAlpha;
}

inline double ConeVolumeBounds::outerRmin() const {
  return m_outerRmin;
}

inline double ConeVolumeBounds::outerRmax() const {
  return m_outerRmax;
}

inline double ConeVolumeBounds::outerTanAlpha() const {
  return m_outerTanAlpha;
}

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

template <class stream_t>
stream_t& ConeVolumeBounds::dumpT(stream_t& dt) const {
  dt << std::setiosflags(std::ios::fixed);
  dt << std::setprecision(5);
  dt << "Acts::ConeVolumeBounds : (innerAlpha, innerOffsetZ, outerAlpha,";
  dt << "  outerOffsetZ, halflenghZ, averagePhi, halfPhiSector) = ";
  dt << get(eInnerAlpha) << ", " << get(eInnerOffsetZ) << ", ";
  dt << get(eOuterAlpha) << ", " << get(eOuterOffsetZ) << ", ";
  dt << get(eHalfLengthZ) << ", " << get(eAveragePhi) << std::endl;
  return dt;
}

}  // namespace Acts