DigitizationAlgorithm.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2021 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/TrackParametrization.hpp"
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/GeometryHierarchyMap.hpp"
#include "Acts/Utilities/Logger.hpp"
#include "ActsExamples/Digitization/DigitizationConfig.hpp"
#include "ActsExamples/Digitization/MeasurementCreation.hpp"
#include "ActsExamples/Digitization/SmearingConfig.hpp"
#include "ActsExamples/EventData/Cluster.hpp"
#include "ActsExamples/EventData/Index.hpp"
#include "ActsExamples/EventData/IndexSourceLink.hpp"
#include "ActsExamples/EventData/Measurement.hpp"
#include "ActsExamples/EventData/SimHit.hpp"
#include "ActsExamples/Framework/DataHandle.hpp"
#include "ActsExamples/Framework/IAlgorithm.hpp"
#include "ActsExamples/Framework/ProcessCode.hpp"
#include "ActsExamples/Framework/RandomNumbers.hpp"
#include "ActsFatras/Digitization/Channelizer.hpp"
#include "ActsFatras/Digitization/PlanarSurfaceDrift.hpp"
#include "ActsFatras/Digitization/PlanarSurfaceMask.hpp"
#include "ActsFatras/Digitization/UncorrelatedHitSmearer.hpp"

#include <cstddef>
#include <memory>
#include <string>
#include <tuple>
#include <utility>
#include <variant>
#include <vector>

namespace ActsFatras {
class Barcode;
}  // namespace ActsFatras

namespace Acts {
class Surface;
class TrackingGeometry;
}  // namespace Acts

namespace ActsExamples {
struct AlgorithmContext;

class DigitizationAlgorithm final : public IAlgorithm {
 public:
  DigitizationAlgorithm(DigitizationConfig config, Acts::Logging::Level level);

  ProcessCode execute(const AlgorithmContext& ctx) const override;

  const DigitizationConfig& config() const { return m_cfg; }

 private:
  std::vector<ActsFatras::Channelizer::ChannelSegment> channelizing(
      const GeometricConfig& geoCfg, const SimHit& hit,
      const Acts::Surface& surface, const Acts::GeometryContext& gctx,
      RandomEngine& rng) const;

  DigitizedParameters localParameters(
      const GeometricConfig& geoCfg,
      const std::vector<ActsFatras::Channelizer::ChannelSegment>& channels,
      RandomEngine& rng) const;

  template <size_t kSmearDIM>
  struct CombinedDigitizer {
    GeometricConfig geometric;
    ActsFatras::BoundParametersSmearer<RandomEngine, kSmearDIM> smearing;
  };

  // Support max 4 digitization dimensions - either digital or smeared
  using Digitizer = std::variant<CombinedDigitizer<0>, CombinedDigitizer<1>,
                                 CombinedDigitizer<2>, CombinedDigitizer<3>,
                                 CombinedDigitizer<4>>;

  DigitizationConfig m_cfg;
  Acts::GeometryHierarchyMap<Digitizer> m_digitizers;
  ActsFatras::PlanarSurfaceDrift m_surfaceDrift;
  ActsFatras::PlanarSurfaceMask m_surfaceMask;
  ActsFatras::Channelizer m_channelizer;

  ReadDataHandle<SimHitContainer> m_simContainerReadHandle{this,
                                                           "SimHitContainer"};

  WriteDataHandle<IndexSourceLinkContainer> m_sourceLinkWriteHandle{
      this, "SourceLinks"};
  WriteDataHandle<MeasurementContainer> m_measurementWriteHandle{
      this, "Measurements"};
  WriteDataHandle<ClusterContainer> m_clusterWriteHandle{this, "Clusters"};
  WriteDataHandle<IndexMultimap<ActsFatras::Barcode>>
      m_measurementParticlesMapWriteHandle{this, "MeasurementParticlesMap"};
  WriteDataHandle<IndexMultimap<Index>> m_measurementSimHitsMapWriteHandle{
      this, "MeasurementSimHitsMap"};

  template <size_t kSmearDIM>
  static Digitizer makeDigitizer(const DigiComponentsConfig& cfg) {
    CombinedDigitizer<kSmearDIM> impl;
    // Copy the geometric configuration
    impl.geometric = cfg.geometricDigiConfig;
    // Prepare the smearing configuration
    for (int i = 0; i < static_cast<int>(kSmearDIM); ++i) {
      impl.smearing.indices[i] = cfg.smearingDigiConfig.at(i).index;
      impl.smearing.smearFunctions[i] =
          cfg.smearingDigiConfig.at(i).smearFunction;
    }
    return impl;
  }
};

}  // namespace ActsExamples