RootSimHitReader.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file RootSimHitReader.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/Propagator/MaterialInteractor.hpp"
#include "Acts/Utilities/Logger.hpp"
#include "ActsExamples/EventData/SimHit.hpp"
#include "ActsExamples/Framework/DataHandle.hpp"
#include "ActsExamples/Framework/IReader.hpp"
#include "ActsExamples/Framework/ProcessCode.hpp"

#include <cstddef>
#include <cstdint>
#include <map>
#include <memory>
#include <mutex>
#include <string>
#include <utility>
#include <vector>

class TChain;

namespace ActsExamples {
struct AlgorithmContext;

class RootSimHitReader : public IReader {
 public:
  struct Config {
    std::string simHitCollection = "simhits";
    std::string treeName = "hits";
    std::string filePath;
    bool orderedEvents = true;
  };

  RootSimHitReader(const RootSimHitReader &) = delete;
  RootSimHitReader(const RootSimHitReader &&) = delete;

  RootSimHitReader(const Config &config, Acts::Logging::Level level);

  std::string name() const override { return "RootSimHitReader"; }

  std::pair<size_t, size_t> availableEvents() const override;

  ProcessCode read(const ActsExamples::AlgorithmContext &context) override;

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

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

  Config m_cfg;

  WriteDataHandle<SimHitContainer> m_outputSimHits{this, "OutputSimHits"};
  std::unique_ptr<const Acts::Logger> m_logger;

  std::mutex m_read_mutex;

  std::vector<std::tuple<uint32_t, std::size_t, std::size_t>> m_eventMap;

  TChain *m_inputChain = nullptr;

  constexpr static std::array<const char *, 12> m_floatKeys = {
      "tx",  "ty", "tz",      "tt",      "tpx",     "tpy",
      "tpz", "te", "deltapx", "deltapy", "deltapz", "deltae"};
  constexpr static std::array<const char *, 2> m_uint64Keys = {"geometry_id",
                                                               "particle_id"};
  constexpr static std::array<const char *, 6> m_uint32Keys = {
      "event_id", "volume_id",   "boundary_id",
      "layer_id", "approach_id", "sensitive_id"};
  constexpr static std::array<const char *, 1> m_int32Keys = {"index"};

  std::unordered_map<std::string_view, float> m_floatColumns;
  std::unordered_map<std::string_view, std::uint32_t> m_uint32Columns;
  std::unordered_map<std::string_view, std::int32_t> m_int32Columns;

  // For some reason I need to use here `unsigned long long` instead of
  // `uint64_t` to prevent an internal ROOT type mismatch...
  std::unordered_map<std::string_view, unsigned long long> m_uint64Columns;
};

}  // namespace ActsExamples