NavigationLayer.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file NavigationLayer.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/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/Layer.hpp"
#include "Acts/Surfaces/BoundaryCheck.hpp"
#include "Acts/Surfaces/Surface.hpp"
#include "Acts/Utilities/BinningType.hpp"

#include <algorithm>
#include <memory>
#include <utility>

namespace Acts {


class NavigationLayer : public Layer {
 public:
  static LayerPtr create(std::shared_ptr<const Surface> sRepresentation,
                         double thickness = 0.) {
    return LayerPtr(new NavigationLayer(std::move(sRepresentation), thickness));
  }

  ~NavigationLayer() override;

  Vector3 binningPosition(const GeometryContext& gctx,
                          BinningValue bValue) const final;

  NavigationLayer() = delete;

  NavigationLayer(const NavigationLayer&) = delete;

  NavigationLayer& operator=(const NavigationLayer&) = delete;

  const Surface& surfaceRepresentation() const final;

  // Non-const version
  Surface& surfaceRepresentation() final;

  bool isOnLayer(const GeometryContext& gctx, const Vector3& gp,
                 const BoundaryCheck& bcheck = true) const final;

  bool resolve(bool resolveSensitive, bool resolveMaterial,
               bool resolvePassive) const final;

 protected:
  NavigationLayer(std::shared_ptr<const Surface> surfaceRepresentation,
                  double thickness);

  std::shared_ptr<const Surface> m_surfaceRepresentation;
};

inline const Surface& NavigationLayer::surfaceRepresentation() const {
  return (*m_surfaceRepresentation);
}

inline Surface& NavigationLayer::surfaceRepresentation() {
  return *(const_cast<Surface*>(m_surfaceRepresentation.get()));
}

inline Vector3 NavigationLayer::binningPosition(const GeometryContext& gctx,
                                                BinningValue bValue) const {
  return m_surfaceRepresentation->binningPosition(gctx, bValue);
}

inline bool NavigationLayer::isOnLayer(const GeometryContext& gctx,
                                       const Vector3& gp,
                                       const BoundaryCheck& bcheck) const {
  return m_surfaceRepresentation->isOnSurface(gctx, gp, Vector3::Zero(),
                                              bcheck);
}

inline bool NavigationLayer::resolve(bool /*resolveSensitive*/,
                                     bool /*resolveMaterial*/,
                                     bool /*reolvePassive*/) const {
  return false;
}

}  // namespace Acts