DigitizationConfig.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file DigitizationConfig.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/Definitions/Units.hpp"
#include "Acts/Geometry/GeometryHierarchyMap.hpp"
#include "Acts/Geometry/TrackingGeometry.hpp"
#include "Acts/Utilities/BinUtility.hpp"
#include "Acts/Utilities/BinningType.hpp"
#include "Acts/Utilities/Logger.hpp"
#include "Acts/Utilities/Result.hpp"
#include "ActsExamples/Digitization/DigitizationConfig.hpp"
#include "ActsExamples/Digitization/Smearers.hpp"
#include "ActsExamples/Digitization/SmearingConfig.hpp"
#include "ActsExamples/Framework/RandomNumbers.hpp"
#include "ActsFatras/Digitization/UncorrelatedHitSmearer.hpp"

#include <algorithm>
#include <cstddef>
#include <functional>
#include <memory>
#include <stdexcept>
#include <string>
#include <system_error>
#include <utility>
#include <vector>

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

namespace ActsExamples {

struct GeometricConfig {
  // The dimensions of the measurement
  std::vector<Acts::BoundIndices> indices = {};

  // The (multidimensional) binning definition for the segmentation of the
  // sensor
  Acts::BinUtility segmentation;

  // The thickness of the sensor
  double thickness = 0.;

  ActsFatras::SingleParameterSmearFunction<ActsExamples::RandomEngine>
      chargeSmearer = Digitization::Exact{};

  // The threshold below a cell activation is ignored
  double threshold = 0.;

  // Whether to assume digital readout (activation is either 0 or 1)
  bool digital = false;

  Acts::ActsScalar charge(Acts::ActsScalar path, RandomEngine &rng) const {
    if (not chargeSmearer) {
      return path;
    }
    auto res = chargeSmearer(path, rng);
    if (res.ok()) {
      return std::max(0.0, res->first);
    } else {
      throw std::runtime_error(res.error().message());
    }
  }

  std::vector<Acts::ActsScalar> variances(size_t /*size0*/, size_t /*size1*/,
                                          RandomEngine & /*rng*/) const {
    return {};
  };

  Acts::Vector3 drift(const Acts::Vector3 & /*position*/,
                      RandomEngine & /*rng*/) const {
    return Acts::Vector3(0., 0., 0.);
  };
};

struct DigiComponentsConfig {
  GeometricConfig geometricDigiConfig;
  SmearingConfig smearingDigiConfig = {};
};

class DigitizationConfig {
 public:
  DigitizationConfig(bool merge, double sigma, bool commonCorner)
      : DigitizationConfig(merge, sigma, commonCorner,
                           Acts::GeometryHierarchyMap<DigiComponentsConfig>()) {
  }

  DigitizationConfig(
      bool doMerge, double mergeNsigma, bool mergeCommonCorner,
      Acts::GeometryHierarchyMap<DigiComponentsConfig> &&digiCfgs);

  DigitizationConfig(
      Acts::GeometryHierarchyMap<DigiComponentsConfig> &&digiCfgs);

  std::string inputSimHits = "simhits";
  std::string outputSourceLinks = "sourcelinks";
  std::string outputMeasurements = "measurements";
  std::string outputClusters = "clusters";
  std::string outputMeasurementParticlesMap = "measurement_particles_map";
  std::string outputMeasurementSimHitsMap = "measurement_simhits_map";
  std::shared_ptr<const Acts::TrackingGeometry> trackingGeometry = nullptr;
  std::shared_ptr<const RandomNumbers> randomNumbers = nullptr;
  bool doMerge;
  const double mergeNsigma;
  const bool mergeCommonCorner;
  double minEnergyDeposit = 0.0;  // 1000 * 3.65 * Acts::UnitConstants::eV;
  Acts::GeometryHierarchyMap<DigiComponentsConfig> digitizationConfigs;

  std::vector<
      std::pair<Acts::GeometryIdentifier, std::vector<Acts::BoundIndices>>>
  getBoundIndices() const;
};
}  // namespace ActsExamples