DetectorVolumeUpdators.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2022-2023 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/Navigation/NavigationDelegates.hpp"
#include "Acts/Navigation/NavigationState.hpp"
#include "Acts/Navigation/NavigationStateFillers.hpp"
#include "Acts/Navigation/NavigationStateUpdators.hpp"
#include "Acts/Utilities/detail/Axis.hpp"
#include "Acts/Utilities/detail/Grid.hpp"

#include <stdexcept>

namespace Acts {
namespace Experimental {

class DetectorVolume;

struct EndOfWorldImpl : public INavigationDelegate {
  inline void update(const GeometryContext& /*ignored*/,
                     NavigationState& nState) const {
    nState.currentVolume = nullptr;
  }
};

struct SingleDetectorVolumeImpl : public INavigationDelegate {
  const DetectorVolume* dVolume = nullptr;

  SingleDetectorVolumeImpl(const DetectorVolume* sVolume) noexcept(false)
      : dVolume(sVolume) {
    if (sVolume == nullptr) {
      throw std::invalid_argument(
          "DetectorVolumeUpdators: nullptr provided, use EndOfWorld instead.");
    }
  }

  SingleDetectorVolumeImpl() = delete;

  inline void update(const GeometryContext& /*ignored*/,
                     NavigationState& nState) const {
    nState.currentVolume = dVolume;
  }
};

using SingleIndex = std::size_t;

using VariableBoundAxis =
    Acts::detail::Axis<Acts::detail::AxisType::Variable,
                       Acts::detail::AxisBoundaryType::Bound>;
using VariableBoundIndexGrid1 =
    Acts::detail::Grid<SingleIndex, VariableBoundAxis>;

struct DetectorVolumesCollection {
  std::vector<const DetectorVolume*> dVolumes = {};

  inline const DetectorVolume* extract(const GeometryContext& /*gctx*/,
                                       const NavigationState& /*nState*/,
                                       const SingleIndex& index) const {
    return dVolumes[index];
  }
};

struct BoundVolumesGrid1Impl : public INavigationDelegate {
  using IndexedUpdator =
      IndexedUpdatorImpl<VariableBoundIndexGrid1, DetectorVolumesCollection,
                         DetectorVolumeFiller>;
  // The indexed updator
  IndexedUpdator indexedUpdator;

  BoundVolumesGrid1Impl(
      const std::vector<ActsScalar>& gBoundaries, BinningValue bValue,
      const std::vector<const DetectorVolume*>& cVolumes,
      const Transform3& bTransform = Transform3::Identity()) noexcept(false)
      : indexedUpdator(IndexedUpdator(VariableBoundIndexGrid1(std::make_tuple(
                                          VariableBoundAxis(gBoundaries))),
                                      {bValue}, bTransform)) {
    indexedUpdator.extractor.dVolumes = cVolumes;

    if (gBoundaries.size() != cVolumes.size() + 1u) {
      throw std::invalid_argument(
          "DetectorVolumeUpdators: mismatching boundaries and volume numbers");
    }
    // Initialize the grid entries
    for (std::size_t ib = 1u; ib < gBoundaries.size(); ++ib) {
      indexedUpdator.grid.at(ib) = ib - 1;
    }
  }
  // Deleted default constructor
  BoundVolumesGrid1Impl() = delete;

  inline void update(const GeometryContext& gctx,
                     NavigationState& nState) const {
    indexedUpdator.update(gctx, nState);
  }
};

}  // namespace Experimental
}  // namespace Acts