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/Definitions/Algebra.hpp"
#include "Acts/Definitions/Direction.hpp"
#include "Acts/Geometry/Volume.hpp"
#include "Acts/Utilities/BinningType.hpp"

#include <cmath>
#include <iostream>
#include <memory>
#include <utility>
#include <vector>

namespace Acts {

class Surface;
class VolumeBounds;
class Direction;

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

using OrientedSurface = std::pair<std::shared_ptr<Surface>, Direction>;
using OrientedSurfaces = std::vector<OrientedSurface>;

// Planar definitions to help construct the boundary surfaces
static const Transform3 s_planeXY = Transform3::Identity();
static const Transform3 s_planeYZ = AngleAxis3(0.5 * M_PI, Vector3::UnitY()) *
                                    AngleAxis3(0.5 * M_PI, Vector3::UnitZ()) *
                                    Transform3::Identity();
static const Transform3 s_planeZX = AngleAxis3(-0.5 * M_PI, Vector3::UnitX()) *
                                    AngleAxis3(-0.5 * M_PI, Vector3::UnitZ()) *
                                    Transform3::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 Vector3& gpos, double tol = 0.) const = 0;

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

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

  virtual Vector3 binningOffset(BinningValue bValue) const;

  virtual double binningBorder(BinningValue bValue) const;

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

inline Vector3 VolumeBounds::binningOffset(
    BinningValue /*bValue*/) const {  // standard offset is 0.,0.,0.
  return Vector3(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