SurfaceArrayCreator.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file SurfaceArrayCreator.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/.

// SurfaceArrayCreator.h, Acts project

#pragma once

#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/ProtoLayer.hpp"
#include "Acts/Surfaces/PlanarBounds.hpp"
#include "Acts/Surfaces/Surface.hpp"
#include "Acts/Surfaces/SurfaceArray.hpp"
#include "Acts/Utilities/Definitions.hpp"
#include "Acts/Utilities/Logger.hpp"
#include "Acts/Utilities/Units.hpp"

#include <optional>

namespace Acts {
namespace Test {
struct SurfaceArrayCreatorFixture;
}

using SurfaceMatcher = std::function<bool(
    const GeometryContext& gctx, BinningValue, const Surface*, const Surface*)>;

using SurfaceVector = std::vector<const Surface*>;
using SurfaceMatrix = std::vector<SurfaceVector>;

using V3Vector = std::vector<Vector3D>;
using V3Matrix = std::vector<V3Vector>;

class SurfaceArrayCreator {
 public:
  friend Acts::Test::SurfaceArrayCreatorFixture;
  friend Acts::SurfaceArray;

  struct ProtoAxis {
    BinningType bType;
    BinningValue bValue;
    size_t nBins;
    double min;
    double max;
    std::vector<double> binEdges;

    size_t getBin(double x) const {
      if (binEdges.empty()) {
        // equidistant
        double w = (max - min) / nBins;
        return std::floor((x - min) / w);
      } else {
        // variable
        const auto it =
            std::upper_bound(std::begin(binEdges), std::end(binEdges), x);
        return std::distance(std::begin(binEdges), it) - 1;
      }
    }
  };

  // Configuration struct
  struct Config {
    SurfaceMatcher surfaceMatcher = SurfaceArrayCreator::isSurfaceEquivalent;

    bool doPhiBinningOptimization = true;
  };

  SurfaceArrayCreator(std::unique_ptr<const Logger> logger = getDefaultLogger(
                          "SurfaceArrayCreator", Logging::INFO))
      : m_cfg(Config()), m_logger(std::move(logger)) {}
  SurfaceArrayCreator(const Config& cfg,
                      std::unique_ptr<const Logger> logger = getDefaultLogger(
                          "SurfaceArrayCreator", Logging::INFO))
      : m_cfg(cfg), m_logger(std::move(logger)) {}

  virtual ~SurfaceArrayCreator() = default;

  std::unique_ptr<SurfaceArray> surfaceArrayOnCylinder(
      const GeometryContext& gctx,
      std::vector<std::shared_ptr<const Surface>> surfaces, size_t binsPhi,
      size_t binsZ, std::optional<ProtoLayer> protoLayerOpt = std::nullopt,
      const std::shared_ptr<const Transform3D>& transformOpt = nullptr) const;

  std::unique_ptr<Acts::SurfaceArray> surfaceArrayOnCylinder(
      const GeometryContext& gctx,
      std::vector<std::shared_ptr<const Surface>> surfaces,
      BinningType bTypePhi = equidistant, BinningType bTypeZ = equidistant,
      std::optional<ProtoLayer> protoLayerOpt = std::nullopt,
      const std::shared_ptr<const Transform3D>& transformOpt = nullptr) const;

  std::unique_ptr<SurfaceArray> surfaceArrayOnDisc(
      const GeometryContext& gctx,
      std::vector<std::shared_ptr<const Surface>> surfaces, size_t binsR,
      size_t binsPhi, std::optional<ProtoLayer> protoLayerOpt = std::nullopt,
      const std::shared_ptr<const Transform3D>& transformOpt = nullptr) const;

  std::unique_ptr<Acts::SurfaceArray> surfaceArrayOnDisc(
      const GeometryContext& gctx,
      std::vector<std::shared_ptr<const Surface>> surfaces, BinningType bTypeR,
      BinningType bTypePhi,
      std::optional<ProtoLayer> protoLayerOpt = std::nullopt,
      const std::shared_ptr<const Transform3D>& transformOpt = nullptr) const;

  std::unique_ptr<SurfaceArray> surfaceArrayOnPlane(
      const GeometryContext& gctx,
      std::vector<std::shared_ptr<const Surface>> surfaces, size_t bins1,
      size_t bins2, BinningValue bValue,
      std::optional<ProtoLayer> protoLayerOpt = std::nullopt,
      const std::shared_ptr<const Transform3D>& transformOpt = nullptr) const;

  static bool isSurfaceEquivalent(const GeometryContext& gctx,
                                  BinningValue bValue, const Surface* a,
                                  const Surface* b) {
    using namespace UnitLiterals;
    using VectorHelpers::perp;

    if (bValue == Acts::binPhi) {
      // Take the two binning positions
      auto pos1 = a->binningPosition(gctx, binR),
           pos2 = b->binningPosition(gctx, binR);

      // Project them on the (x, y) plane, where Phi angles are calculated
      auto proj1 = pos1.head<2>(), proj2 = pos2.head<2>();

      // Basic dot and cross products identities give us the cosine and sine
      // of these angles, time the squared vector norm
      auto cos_dPhi_n2 = proj1.dot(proj2);
      auto sin_dPhi_n2 = proj1.x() * proj2.y() - proj2.x() * proj1.y();

      // ...so by injecting them into atan2, we get the angle between them
      auto dPhi = std::atan2(sin_dPhi_n2, cos_dPhi_n2);
      return std::abs(dPhi) < M_PI / 180.;
    }

    if (bValue == Acts::binZ) {
      return (std::abs(a->binningPosition(gctx, binR).z() -
                       b->binningPosition(gctx, binR).z()) < 1_um);
    }

    if (bValue == Acts::binR) {
      return (std::abs(perp(a->binningPosition(gctx, binR)) -
                       perp(b->binningPosition(gctx, binR))) < 1_um);
    }

    return false;
  }

  void setLogger(std::unique_ptr<const Logger> logger) {
    m_logger = std::move(logger);
  }

 private:
  Config m_cfg;

  const Logger& logger() const { return *m_logger; }

  std::vector<const Surface*> findKeySurfaces(
      const std::vector<const Surface*>& surfaces,
      const std::function<bool(const Surface*, const Surface*)>& equal) const;

  size_t determineBinCount(const GeometryContext& gctx,
                           const std::vector<const Surface*>& surfaces,
                           BinningValue bValue) const;

  ProtoAxis createVariableAxis(const GeometryContext& gctx,
                               const std::vector<const Surface*>& surfaces,
                               BinningValue bValue, ProtoLayer protoLayer,
                               Transform3D& transform) const;

  ProtoAxis createEquidistantAxis(const GeometryContext& gctx,
                                  const std::vector<const Surface*>& surfaces,
                                  BinningValue bValue, ProtoLayer protoLayer,
                                  Transform3D& transform,
                                  size_t nBins = 0) const;

  template <detail::AxisBoundaryType bdtA, detail::AxisBoundaryType bdtB,
            typename F1, typename F2>
  static std::unique_ptr<SurfaceArray::ISurfaceGridLookup>
  makeSurfaceGridLookup2D(F1 globalToLocal, F2 localToGlobal, ProtoAxis pAxisA,
                          ProtoAxis pAxisB) {
    using ISGL = SurfaceArray::ISurfaceGridLookup;
    std::unique_ptr<ISGL> ptr;

    // this becomes completely unreadable otherwise
    // clang-format off
    if (pAxisA.bType == equidistant && pAxisB.bType == equidistant) {

      detail::Axis<detail::AxisType::Equidistant, bdtA> axisA(pAxisA.min, pAxisA.max, pAxisA.nBins);
      detail::Axis<detail::AxisType::Equidistant, bdtB> axisB(pAxisB.min, pAxisB.max, pAxisB.nBins);

      using SGL = SurfaceArray::SurfaceGridLookup<decltype(axisA), decltype(axisB)>;
      ptr = std::unique_ptr<ISGL>(static_cast<ISGL*>(
            new SGL(globalToLocal, localToGlobal, std::make_tuple(axisA, axisB))));

    } else if (pAxisA.bType == equidistant && pAxisB.bType == arbitrary) {

      detail::Axis<detail::AxisType::Equidistant, bdtA> axisA(pAxisA.min, pAxisA.max, pAxisA.nBins);
      detail::Axis<detail::AxisType::Variable, bdtB> axisB(pAxisB.binEdges);

      using SGL = SurfaceArray::SurfaceGridLookup<decltype(axisA), decltype(axisB)>;
      ptr = std::unique_ptr<ISGL>(static_cast<ISGL*>(
            new SGL(globalToLocal, localToGlobal, std::make_tuple(axisA, axisB))));

    } else if (pAxisA.bType == arbitrary && pAxisB.bType == equidistant) {

      detail::Axis<detail::AxisType::Variable, bdtA> axisA(pAxisA.binEdges);
      detail::Axis<detail::AxisType::Equidistant, bdtB> axisB(pAxisB.min, pAxisB.max, pAxisB.nBins);

      using SGL = SurfaceArray::SurfaceGridLookup<decltype(axisA), decltype(axisB)>;
      ptr = std::unique_ptr<ISGL>(static_cast<ISGL*>(
            new SGL(globalToLocal, localToGlobal, std::make_tuple(axisA, axisB))));

    } else /*if (pAxisA.bType == arbitrary && pAxisB.bType == arbitrary)*/ {

      detail::Axis<detail::AxisType::Variable, bdtA> axisA(pAxisA.binEdges);
      detail::Axis<detail::AxisType::Variable, bdtB> axisB(pAxisB.binEdges);

      using SGL = SurfaceArray::SurfaceGridLookup<decltype(axisA), decltype(axisB)>;
      ptr = std::unique_ptr<ISGL>(static_cast<ISGL*>(
            new SGL(globalToLocal, localToGlobal, std::make_tuple(axisA, axisB))));
    }
    // clang-format on

    return ptr;
  }

  std::unique_ptr<const Logger> m_logger;

  void completeBinning(const GeometryContext& gctx,
                       SurfaceArray::ISurfaceGridLookup& sl,
                       const std::vector<const Surface*>& surfaces) const {
    ACTS_VERBOSE(
        "Complete binning by filling closest neighbour surfaces into "
        "empty bins.");

    size_t binCompleted = sl.completeBinning(gctx, surfaces);

    ACTS_VERBOSE("       filled  : " << binCompleted
                                     << " (includes under/overflow)");
  }

  std::vector<Acts::Vector3D> makeGlobalVertices(
      const GeometryContext& gctx, const Acts::Surface& surface,
      const std::vector<Acts::Vector2D>& locVertices) const;
};

}  // namespace Acts