AlignedDetectorElement.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2019 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/GeometryContext.hpp"
#include "Acts/Geometry/GeometryIdentifier.hpp"
#include "Acts/Plugins/Identification/IdentifiedDetectorElement.hpp"
#include "Acts/Plugins/Identification/Identifier.hpp"
#include "Acts/Surfaces/Surface.hpp"
#include "Acts/Utilities/Definitions.hpp"
#include "ActsExamples/GenericDetector/GenericDetectorElement.hpp"

#include <memory>

namespace ActsExamples {

namespace Contextual {

class AlignedDetectorElement : public Generic::GenericDetectorElement {
 public:
  struct ContextType {
    unsigned int iov = 0;
  };

  template <typename... Args>
  AlignedDetectorElement(Args&&... args)
      : Generic::GenericDetectorElement(std::forward<Args>(args)...) {}

  const Acts::Transform3D& transform(
      const Acts::GeometryContext& gctx) const final override;

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

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

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

 private:
  std::vector<std::unique_ptr<Acts::Transform3D>> m_alignedTransforms;
};

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

inline const Acts::Transform3D& AlignedDetectorElement::nominalTransform(
    const Acts::GeometryContext& gctx) const {
  return GenericDetectorElement::transform(gctx);
}

inline void AlignedDetectorElement::addAlignedTransform(
    std::unique_ptr<Acts::Transform3D> 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::Transform3D>>&
AlignedDetectorElement::alignedTransforms() const {
  return m_alignedTransforms;
}

}  // end of namespace Contextual
}  // end of namespace ActsExamples