CylindricalDetectorHelper.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 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/Definitions/Algebra.hpp"
#include "Acts/Definitions/Common.hpp"
#include "Acts/Detector/DetectorComponents.hpp"
#include "Acts/Detector/Portal.hpp"
#include "Acts/Geometry/CylinderVolumeBounds.hpp"
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/VolumeBounds.hpp"
#include "Acts/Utilities/Logger.hpp"

#include <array>
#include <limits>
#include <map>
#include <memory>
#include <vector>

namespace Acts {

namespace Experimental {

class DetectorVolume;
class Portal;

namespace detail {
namespace CylindricalDetectorHelper {

DetectorComponent::PortalContainer connectInR(
    const GeometryContext& gctx,
    std::vector<std::shared_ptr<DetectorVolume>>& volumes,
    const std::vector<unsigned int>& selectedOnly = {},
    Acts::Logging::Level logLevel = Acts::Logging::INFO);

DetectorComponent::PortalContainer connectInZ(
    const GeometryContext& gctx,
    std::vector<std::shared_ptr<DetectorVolume>>& volumes,
    const std::vector<unsigned int>& selectedOnly = {},
    Acts::Logging::Level logLevel = Acts::Logging::INFO);

DetectorComponent::PortalContainer connectInPhi(
    const GeometryContext& gctx,
    std::vector<std::shared_ptr<DetectorVolume>>& volumes,
    const std::vector<unsigned int>& selectedOnly = {},
    Acts::Logging::Level logLevel = Acts::Logging::INFO);

DetectorComponent::PortalContainer wrapInZR(
    const GeometryContext& gctx,
    std::vector<std::shared_ptr<DetectorVolume>>& volumes,
    Acts::Logging::Level logLevel = Acts::Logging::INFO);

DetectorComponent::PortalContainer connectInR(
    const GeometryContext& gctx,
    const std::vector<DetectorComponent::PortalContainer>& containers,
    const std::vector<unsigned int>& selectedOnly = {},
    Acts::Logging::Level logLevel = Acts::Logging::INFO);

DetectorComponent::PortalContainer connectInZ(
    const GeometryContext& gctx,
    const std::vector<DetectorComponent::PortalContainer>& containers,
    const std::vector<unsigned int>& selectedOnly = {},
    Acts::Logging::Level logLevel = Acts::Logging::INFO);

DetectorComponent::PortalContainer connectInPhi(
    const GeometryContext& gctx,
    const std::vector<DetectorComponent::PortalContainer>& containers,
    const std::vector<unsigned int>& selectedOnly = {},
    Acts::Logging::Level logLevel = Acts::Logging::INFO);

DetectorComponent::PortalContainer wrapInZR(
    const GeometryContext& gctx,
    const std::vector<DetectorComponent::PortalContainer>& containers,
    Acts::Logging::Level logLevel = Acts::Logging::INFO);

template <typename volume_container_t>
std::array<std::vector<ActsScalar>, 3u> rzphiBoundaries(
    const GeometryContext& gctx, const volume_container_t& volumes,
    Acts::Logging::Level logLevel = Acts::Logging::INFO) {
  // The local logger
  ACTS_LOCAL_LOGGER(getDefaultLogger("CylindricalDetectorHelper", logLevel));

  ACTS_DEBUG("Estimate R/z/phi boundaries of  " << volumes.size()
                                                << " volumes.");

  // The return boundaries
  std::array<std::set<ActsScalar>, 3u> uniqueBoundaries;

  // Loop over the volumes and collect boundaries
  for (const auto& v : volumes) {
    if (v->volumeBounds().type() == VolumeBounds::BoundsType::eCylinder) {
      const auto& bValues = v->volumeBounds().values();
      // The min/max values
      ActsScalar rMin = bValues[CylinderVolumeBounds::BoundValues::eMinR];
      ActsScalar rMax = bValues[CylinderVolumeBounds::BoundValues::eMaxR];
      ActsScalar zCenter = v->transform(gctx).translation().z();
      ActsScalar zHalfLength =
          bValues[CylinderVolumeBounds::BoundValues::eHalfLengthZ];
      ActsScalar zMin = zCenter - zHalfLength;
      ActsScalar zMax = zCenter + zHalfLength;
      ActsScalar phiCenter =
          bValues[CylinderVolumeBounds::BoundValues::eAveragePhi];
      ActsScalar phiSector =
          bValues[CylinderVolumeBounds::BoundValues::eHalfPhiSector];
      ActsScalar phiMin = phiCenter - phiSector;
      ActsScalar phiMax = phiCenter + phiSector;
      // Fill the sets
      uniqueBoundaries[0].insert(rMin);
      uniqueBoundaries[0].insert(rMax);
      uniqueBoundaries[1].insert(zMin);
      uniqueBoundaries[1].insert(zMax);
      uniqueBoundaries[2].insert(phiMin);
      uniqueBoundaries[2].insert(phiMax);
    }
  }

  ACTS_VERBOSE("- did yield " << uniqueBoundaries[0u].size()
                              << " boundaries in R.");
  ACTS_VERBOSE("- did yield " << uniqueBoundaries[1u].size()
                              << " boundaries in z.");
  ACTS_VERBOSE("- did yield " << uniqueBoundaries[2u].size()
                              << " boundaries in phi.");

  return {{std::vector<ActsScalar>(uniqueBoundaries[0].begin(),
                                   uniqueBoundaries[0].end()),
           std::vector<ActsScalar>(uniqueBoundaries[1].begin(),
                                   uniqueBoundaries[1].end()),
           std::vector<ActsScalar>(uniqueBoundaries[2].begin(),
                                   uniqueBoundaries[2].end())}};
}

}  // namespace CylindricalDetectorHelper
}  // namespace detail
}  // namespace Experimental
}  // namespace Acts