DetectorElement.h

#pragma once
 
#include <iostream>
 
#include "Acts/Definitions/Algebra.hpp"
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/GeometryIdentifier.hpp"
#include "Acts/Material/HomogeneousSurfaceMaterial.hpp"
#include "Acts/Surfaces/Surface.hpp"
#include "Acts/Surfaces/SurfacePlacementBase.hpp"
#include "Framework/Exception/Exception.h"
#include "Tracking/geo/GeoUtils.h"
 
// This class is necessary in order to apply any transformation change passed
// via the geometry context to the final sensitive element.
 
namespace tracking::geo {
 
class DetectorElement : public Acts::SurfacePlacementBase {
 public:
  // The detector element is initialized with the surface initial transformation
  // created from the TrackingGeometry constructor/parser
  // The DetectorElement ACTS mechanism is such that subsequent calls to the
  // transform(GeometryContext) method will return the full transformation valid
  // for a certain IoV via the ConditionsProvider mechanism
 
  DetectorElement(const std::shared_ptr<Acts::Surface>& surface,
                  const Acts::Transform3& default_transform, double thickness) {
    m_surface_ = surface;
    m_thickness_ = thickness;
 
    // This is the local to global transformation
    m_transform_ = default_transform;
  }
 
  ~DetectorElement() override;
 
  // This method will always return a copy to the uncorrected transformation
 
  Acts::Transform3 uncorrectedTransform() const { return m_transform_; }
 
  // This method will load the transformation from the geometry context if found
  // otherwise will return the default transform
  // This is very *hot* code, do not place computations in this function in
  // order to keep performance under control.
 
  // CAUTION:: The tracking geometry + geometry context machinery
  // assumes large enough envelopes / gaps between sensors
  // to allow for not breaking the layers overlaps.
  // In case the corrections to the stored transformations will be too large
  // this assumption will be broken.
 
  // TODO Current implementation implies always checking the stored map of
  // corrections Could be interesting to cache the transformations and re-update
  // all of them when IoV changes
 
  const Acts::Transform3& localToGlobalTransform(
      const Acts::GeometryContext& gctx) const override;
 
  const Acts::Surface& surface() const override;
 
  Acts::Surface& surface() override;
 
  bool isSensitive() const override { return true; }
 
  // The thickness of the detector element is taken from the center of the
  // associated surface
  double thickness() const;
 
  Acts::GeometryIdentifier geometryId() const {
    if (!m_surface_)
      EXCEPTION_RAISE("BadGeometry", "DetectorElement:: surface not assigned");
 
    return (m_surface_->geometryId());
  }
 
 private:
  // cache
  Acts::Transform3 m_transform_ = Acts::Transform3::Identity();
 
  std::shared_ptr<Acts::Surface> m_surface_;
  double m_thickness_;
};
 
}  // namespace tracking::geo