TelescopeDetectorElement.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2020-2021 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/DetectorElementBase.hpp"
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/detail/DefaultDetectorElementBase.hpp"
#include "Acts/Surfaces/Surface.hpp"

#include <memory>
#include <utility>
#include <vector>

namespace Acts {
class Surface;
class PlanarBounds;
class DiscBounds;
class ISurfaceMaterial;
}  // namespace Acts

namespace ActsExamples {
namespace Telescope {

class TelescopeDetectorElement : public Acts::DetectorElementBase {
 public:
  struct ContextType {
    unsigned int iov = 0;
  };

  TelescopeDetectorElement(
      std::shared_ptr<const Acts::Transform3> transform,
      std::shared_ptr<const Acts::PlanarBounds> pBounds, double thickness,
      std::shared_ptr<const Acts::ISurfaceMaterial> material = nullptr);

  TelescopeDetectorElement(
      std::shared_ptr<const Acts::Transform3> transform,
      std::shared_ptr<const Acts::DiscBounds> dBounds, double thickness,
      std::shared_ptr<const Acts::ISurfaceMaterial> material = nullptr);

  ~TelescopeDetectorElement() override = default;

  const Acts::Surface& surface() const final;

  Acts::Surface& surface() final;

  double thickness() const final;

  const Acts::Transform3& transform(
      const Acts::GeometryContext& gctx) const final;

  const Acts::Transform3& nominalTransform(
      const Acts::GeometryContext& gctx) const;

  void addAlignedTransform(std::unique_ptr<Acts::Transform3> alignedTransform,
                           unsigned int iov);

  const std::vector<std::unique_ptr<Acts::Transform3>>& alignedTransforms()
      const;

 private:
  std::shared_ptr<const Acts::Transform3> m_elementTransform = nullptr;
  // the aligned transforms
  std::vector<std::unique_ptr<Acts::Transform3>> m_alignedTransforms = {};
  std::shared_ptr<Acts::Surface> m_elementSurface = nullptr;
  double m_elementThickness = 0.;
  std::shared_ptr<const Acts::PlanarBounds> m_elementPlanarBounds = nullptr;
  std::shared_ptr<const Acts::DiscBounds> m_elementDiscBounds = nullptr;
};

inline const Acts::Surface& TelescopeDetectorElement::surface() const {
  return *m_elementSurface;
}

inline Acts::Surface& TelescopeDetectorElement::surface() {
  return *m_elementSurface;
}

inline double TelescopeDetectorElement::thickness() const {
  return m_elementThickness;
}

inline const Acts::Transform3& TelescopeDetectorElement::transform(
    const Acts::GeometryContext& gctx) const {
  // Check if a different transform than the nominal exists
  if (!m_alignedTransforms.empty()) {
    // cast into the right context object
    auto alignContext = gctx.get<ContextType>();
    return (*m_alignedTransforms[alignContext.iov].get());
  }
  // Return the standard transform if not found
  return nominalTransform(gctx);
}

inline const Acts::Transform3& TelescopeDetectorElement::nominalTransform(
    const Acts::GeometryContext& /*gctx*/) const {
  return *m_elementTransform;
}

inline void TelescopeDetectorElement::addAlignedTransform(
    std::unique_ptr<Acts::Transform3> alignedTransform, unsigned int iov) {
  // most standard case, it's just a new one:
  auto cios = m_alignedTransforms.size();
  for (unsigned int ic = cios; ic <= iov; ++ic) {
    m_alignedTransforms.push_back(nullptr);
  }
  m_alignedTransforms[iov] = std::move(alignedTransform);
}

inline const std::vector<std::unique_ptr<Acts::Transform3>>&
TelescopeDetectorElement::alignedTransforms() const {
  return m_alignedTransforms;
}

}  // namespace Telescope
}  // namespace ActsExamples