GreedyAmbiguitySolver.h

#pragma once
 
//--- Framework ---//
#include "Framework/Configure/Parameters.h"
#include "Framework/EventProcessor.h"
#include "Framework/RandomNumberSeedService.h"
 
//--- C++ ---//
#include <memory>
#include <random>
 
//--- LDMX ---//
#include "Tracking/Reco/TrackingGeometryUser.h"
 
//--- ACTS ---//
 
// Utils and Definitions
#include "Acts/Definitions/Common.hpp"
#include "Acts/Utilities/Logger.hpp"
 
// geometry
#include "Acts/Geometry/GeometryContext.hpp"
 
// geometry
#include <Acts/Geometry/TrackingGeometry.hpp>
 
#include "Acts/Geometry/GeometryIdentifier.hpp"
 
//--- Tracking ---//
#include "Tracking/Event/Measurement.h"
#include "Tracking/Event/Track.h"
#include "Tracking/Reco/TrackExtrapolatorTool.h"
#include "Tracking/Sim/IndexSourceLink.h"
#include "Tracking/Sim/MeasurementCalibrator.h"
#include "Tracking/Sim/TrackingUtils.h"
 
//--- Interpolated magnetic field ---//
#include "Tracking/Sim/BFieldXYZUtils.h"
 
namespace tracking {
namespace reco {
 
class GreedyAmbiguitySolver final : public TrackingGeometryUser {
 public:
  GreedyAmbiguitySolver(const std::string& name, framework::Process& process);
 
  virtual ~GreedyAmbiguitySolver() = default;
 
  void onNewRun(const ldmx::RunHeader& rh) override;
 
  void configure(framework::config::Parameters& parameters) override;
 
  void produce(framework::Event& event) override;
 
  void onProcessEnd() override;
 
 private:
  int nevents_{0};
  int n_input_tracks_{0};
  int n_output_tracks_{0};
  double processing_time_{0.};
 
  std::uint32_t maximum_shared_hits_{1};
  std::uint32_t maximum_iterations_{1000};
 
  std::size_t n_meas_min_{7};
 
  std::string out_trk_collection_{"TaggerTracksClean"};
 
  std::string track_collection_{"TaggerTracks"};
 
  std::string meas_collection_{"DigiTaggerSimHits"};
 
  std::string input_pass_name_{""};
 
  struct State {
    std::size_t number_of_tracks_{};
 
    std::vector<int> track_tips_;
    std::vector<float> track_chi2_;
    std::vector<std::vector<std::size_t>> measurements_per_track_;
 
    // TODO consider boost 1.81 unordered_flat_map
    boost::container::flat_map<std::size_t,
                               boost::container::flat_set<std::size_t>>
        tracks_per_measurement_;
    std::vector<std::size_t> shared_measurements_per_track_;
 
    // TODO consider boost 1.81 unordered_flat_map
    boost::container::flat_set<std::size_t> selected_tracks_;
  };
 
  template <typename geometry_t, typename source_link_hash_t,
            typename source_link_equality_t>
  void computeInitialState(std::vector<ldmx::Track> tracks,
                           std::vector<ldmx::Measurement> measurements,
                           State& state, geometry_t& tg,
                           source_link_hash_t&& sourceLinkHash,
                           source_link_equality_t&& sourceLinkEquality) const;
 
  void resolve(State& state);
 
  void removeTrack(State& state, std::size_t iTrack) const;
 
  /*
  std::size_t sourceLinkHash(const Acts::SourceLink& a);
 
  bool sourceLinkEquality(const Acts::SourceLink& a, const Acts::SourceLink& b);
  */
 
};  // MyProcessor
 
}  // namespace reco
}  // namespace tracking