VolumeBounds.hpp

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

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

#include <iomanip>
#include <iostream>
#include <memory>

namespace Acts {

class Surface;
class Volume;

class VolumeBounds;
using VolumeBoundsPtr = std::shared_ptr<const VolumeBounds>;

using SurfacePtr = std::shared_ptr<const Surface>;
using OrientedSurface = std::pair<SurfacePtr, NavigationDirection>;
using OrientedSurfaces = std::vector<OrientedSurface>;

// Planar definitions to help construct the boundary surfaces
static const Transform3D s_planeXY = Transform3D::Identity();
static const Transform3D s_planeYZ =
    AngleAxis3D(0.5 * M_PI, Vector3D::UnitY()) *
    AngleAxis3D(0.5 * M_PI, Vector3D::UnitZ()) * Transform3D::Identity();
static const Transform3D s_planeZX =
    AngleAxis3D(-0.5 * M_PI, Vector3D::UnitX()) *
    AngleAxis3D(-0.5 * M_PI, Vector3D::UnitZ()) * Transform3D::Identity();


class VolumeBounds {
 public:
  // @enum BoundsType
  enum BoundsType : int {
    eCone = 0,
    eCuboid = 1,
    eCutoutCylinder = 2,
    eCylinder = 3,
    eGenericCuboid = 4,
    eTrapezoid = 5,
    eOther = 6
  };

  VolumeBounds() = default;

  virtual ~VolumeBounds() = default;

  virtual BoundsType type() const = 0;

  virtual std::vector<double> values() const = 0;

  virtual bool inside(const Vector3D& gpos, double tol = 0.) const = 0;

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

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

  virtual Vector3D binningOffset(BinningValue bValue) const;

  virtual double binningBorder(BinningValue bValue) const;

  virtual std::ostream& toStream(std::ostream& sl) const = 0;
};

inline Vector3D VolumeBounds::binningOffset(
    BinningValue /*bValue*/) const {  // standard offset is 0.,0.,0.
  return Vector3D(0., 0., 0.);
}

inline double VolumeBounds::binningBorder(BinningValue /*bValue*/) const {
  return 0.;
}

std::ostream& operator<<(std::ostream& sl, const VolumeBounds& vb);

inline bool operator==(const VolumeBounds& lhs, const VolumeBounds& rhs) {
  if (&lhs == &rhs) {
    return true;
  }
  return (lhs.type() == rhs.type()) && (lhs.values() == rhs.values());
}

}  // namespace Acts