tracking::reco::GreedyAmbiguitySolver Class Reference

Minimal example of a processor. More...

#include <GreedyAmbiguitySolver.h>

Classes
struct	State

Public Member Functions
	GreedyAmbiguitySolver (const std::string &name, framework::Process &process)
	Constructor.
virtual	~GreedyAmbiguitySolver ()=default
	Destructor.
void	onNewRun (const ldmx::RunHeader &rh) override
	onNewRun is the first function called for each processor after the conditions are fully configured and accessible.
void	configure (framework::config::Parameters &parameters) override
	Configure the processor using the given user specified parameters.
void	produce (framework::Event &event) override
	Process the event and put new data products into it.
Public Member Functions inherited from tracking::reco::TrackingGeometryUser
	TrackingGeometryUser (const std::string &name, framework::Process &p)
Public Member Functions inherited from framework::Producer
	Producer (const std::string &name, Process &process)
	Class constructor.
virtual void	process (Event &event) final
	Processing an event for a Producer is calling produce.
Public Member Functions inherited from framework::EventProcessor
	DECLARE_FACTORY (EventProcessor, EventProcessor *, const std::string &, Process &)
	declare that we have a factory for this class
	EventProcessor (const std::string &name, Process &process)
	Class constructor.
virtual	~EventProcessor ()=default
	Class destructor.
virtual void	beforeNewRun (ldmx::RunHeader &run_header)
	Callback for Producers to add parameters to the run header before conditions are initialized.
virtual void	onFileOpen (EventFile &event_file)
	Callback for the EventProcessor to take any necessary action when a new event input ROOT file is opened.
virtual void	onFileClose (EventFile &event_file)
	Callback for the EventProcessor to take any necessary action when a event input ROOT file is closed.
virtual void	onProcessStart ()
	Callback for the EventProcessor to take any necessary action when the processing of events starts, such as creating histograms.
virtual void	onProcessEnd ()
	Callback for the EventProcessor to take any necessary action when the processing of events finishes, such as calculating job-summary quantities.
template<class T >
const T &	getCondition (const std::string &condition_name)
	Access a conditions object for the current event.
TDirectory *	getHistoDirectory ()
	Access/create a directory in the histogram file for this event processor to create histograms and analysis tuples.
void	setStorageHint (framework::StorageControl::Hint hint)
	Mark the current event as having the given storage control hint from this module_.
void	setStorageHint (framework::StorageControl::Hint hint, const std::string &purposeString)
	Mark the current event as having the given storage control hint from this module and the given purpose string.
int	getLogFrequency () const
	Get the current logging frequency from the process.
int	getRunNumber () const
	Get the run number from the process.
std::string	getName () const
	Get the processor name.
void	createHistograms (const std::vector< framework::config::Parameters > &histos)
	Internal function which is used to create histograms passed from the python configuration @parma histos vector of Parameters that configure histograms to create.

Private Member Functions
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)
	Updates the state iteratively by evicting one track after the other until the final state conditions are met.
void	removeTrack (State &state, std::size_t iTrack) const

Private Attributes
std::uint32_t	maximum_shared_hits_ {1}
	Maximum amount of shared hits per track.
std::uint32_t	maximum_iterations_ {1000}
	Maximum number of iterations.
std::size_t	n_meas_min_ {7}
	Minimum number of measurement to form a track.
std::string	out_trk_collection_ {"TaggerTracksClean"}
std::string	track_collection_ {"TaggerTracks"}
std::string	meas_collection_ {"DigiTaggerSimHits"}
std::string	input_pass_name_ {""}

Additional Inherited Members
Protected Member Functions inherited from tracking::reco::TrackingGeometryUser
const Acts::GeometryContext &	geometryContext ()
const Acts::MagneticFieldContext &	magneticFieldContext ()
const Acts::CalibrationContext &	calibrationContext ()
const geo::TrackersTrackingGeometry &	geometry ()
Protected Member Functions inherited from framework::EventProcessor
void	abortEvent ()
	Abort the event immediately.
Protected Attributes inherited from framework::EventProcessor
HistogramPool	histograms_
	helper object for making and filling histograms
NtupleManager &	ntuple_ {NtupleManager::getInstance()}
	Manager for any ntuples.
logging::logger	the_log_
	The logger for this EventProcessor.

Detailed Description

Minimal example of a processor.

This processor will loop over all of the ECal hits in an event and print out their details.

Definition at line 49 of file GreedyAmbiguitySolver.h.

Constructor & Destructor Documentation

GreedyAmbiguitySolver()

tracking::reco::GreedyAmbiguitySolver::GreedyAmbiguitySolver	(	const std::string &	name,
		framework::Process &	process )

Constructor.

Parameters

name	Name for this instance of the class.
process	The Process class associated with EventProcessor, provided by the framework.

Definition at line 11 of file GreedyAmbiguitySolver.cxx.

    : TrackingGeometryUser(name, process) {}

Member Function Documentation

computeInitialState()

template<typename geometry_t , typename source_link_hash_t , typename source_link_equality_t >

void tracking::reco::GreedyAmbiguitySolver::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

private

Parameters

tracks	The input track container.
state	An empty state object which is expected to be default constructed.
sourceLinkHash	A functor to acquire a hash from a given source link.
sourceLinkEquality	A functor to check equality of two source links.

Definition at line 43 of file GreedyAmbiguitySolver.cxx.

                                                       {
  auto measurement_index_map =
      std::unordered_map<Acts::SourceLink, std::size_t, source_link_hash_t,
                         source_link_equality_t>(0, sourceLinkHash,
                                                 sourceLinkEquality);
 
  // auto tg{geometry()};
  // Iterate through all input tracks, collect their properties like measurement
  // count and chi2 and fill the measurement map in order to relate tracks to
  // each other if they have shared hits_.
  state.number_of_tracks_ = 0;
  for (const auto& track : tracks) {
    // Kick out tracks that do not fulfill our initial requirements
    if (track.getNhits() < n_meas_min_) {
      continue;
    }
 
    std::vector<std::size_t> measurements;
    for (auto imeas : track.getMeasurementsIdxs()) {
      auto meas = meas_coll.at(imeas);
      const Acts::Surface* hit_surface = tg.getSurface(meas.getLayerID());
      // Store the index_ source link
      acts_examples::IndexSourceLink idx_sl(hit_surface->geometryId(), imeas);
      Acts::SourceLink source_link = Acts::SourceLink(idx_sl);
 
      auto emplace = measurement_index_map.try_emplace(
          source_link, measurement_index_map.size());
      measurements.push_back(emplace.first->second);
    }
 
    state.track_tips_.push_back(state.number_of_tracks_);
    state.track_chi2_.push_back(track.getChi2() / track.getNdf());
    state.measurements_per_track_.push_back(std::move(measurements));
    state.selected_tracks_.insert(state.number_of_tracks_);
 
    ++state.number_of_tracks_;
  }
 
  // Now we relate measurements to tracks
  for (std::size_t i_track = 0; i_track < state.number_of_tracks_; ++i_track) {
    for (auto i_measurement : state.measurements_per_track_[i_track]) {
      state.tracks_per_measurement_[i_measurement].insert(i_track);
    }
  }
 
  // Finally, we can accumulate the number of shared measurements per track
  state.shared_measurements_per_track_ =
      std::vector<std::size_t>(state.track_tips_.size(), 0);
  for (std::size_t i_track = 0; i_track < state.number_of_tracks_; ++i_track) {
    for (auto i_measurement : state.measurements_per_track_[i_track]) {
      if (state.tracks_per_measurement_[i_measurement].size() > 1) {
        ++state.shared_measurements_per_track_[i_track];
      }
    }
  }
}

References n_meas_min_.

Referenced by produce().

configure()

void tracking::reco::GreedyAmbiguitySolver::configure ( framework::config::Parameters & parameters )

overridevirtual

Configure the processor using the given user specified parameters.

The user specified parameters that are availabed are defined in the python configuration class. Look at the my_processor.py module of the EventProc python for the python structure.

Parameters

parameters

Set of parameters used to configure this processor.

Reimplemented from framework::EventProcessor.

Definition at line 164 of file GreedyAmbiguitySolver.cxx.

                                           {
  out_trk_collection_ =
      parameters.get<std::string>("out_trk_collection", "TaggerTracksClean");
 
  track_collection_ =
      parameters.get<std::string>("trackCollection", "TaggerTracks");
 
  meas_collection_ =
      parameters.get<std::string>("measCollection", "DigiTaggerSimHits");
  input_pass_name_ = parameters.get<std::string>("input_pass_name");
  n_meas_min_ = parameters.get<int>("nMeasurementsMin", 5);
  maximum_shared_hits_ = parameters.get<int>("maximumSharedHits", 1);
}

References framework::config::Parameters::get(), maximum_shared_hits_, and n_meas_min_.

onNewRun()

void tracking::reco::GreedyAmbiguitySolver::onNewRun ( const ldmx::RunHeader & rh )

overridevirtual

onNewRun is the first function called for each processor after the conditions are fully configured and accessible.

This is where you could create single-processors, multi-event calculation objects.

Reimplemented from framework::EventProcessor.

Definition at line 162 of file GreedyAmbiguitySolver.cxx.

{}

produce()

void tracking::reco::GreedyAmbiguitySolver::produce ( framework::Event & event )

overridevirtual

Process the event and put new data products into it.

Parameters

event

The event to process.

Implements framework::Producer.

Definition at line 179 of file GreedyAmbiguitySolver.cxx.

                                                         {
  GreedyAmbiguitySolver::State state;
  std::vector<ldmx::Track> out_tracks;
 
  auto tg{geometry()};
 
  if (!event.exists(track_collection_, input_pass_name_)) {
    ldmx_log(debug) << "Track collection not found, exiting";
    return;
  }
  auto tracks{
      event.getCollection<ldmx::Track>(track_collection_, input_pass_name_)};
 
  if (!event.exists(meas_collection_, input_pass_name_)) {
    ldmx_log(debug) << "Measurement collection not found, exiting";
    return;
  }
  auto measurements{event.getCollection<ldmx::Measurement>(meas_collection_,
                                                           input_pass_name_)};
 
  computeInitialState(tracks, measurements, state, tg,
                      tracking::sim::utils::sourceLinkHash,
                      tracking::sim::utils::sourceLinkEquality);
  resolve(state);
 
  for (auto i_track : state.selected_tracks_) {
    auto clean_trk = tracks[state.track_tips_.at(i_track)];
    if ((clean_trk.getNhits() > n_meas_min_) &&
        (std::abs(1. / clean_trk.getQoP()) > 0.05)) {
      out_tracks.push_back(clean_trk);
    }
  }
 
  event.add(out_trk_collection_, out_tracks);
 
  // for (auto iTrack : initial_state.selectedTracks) {
  //     std::cout << event.getEventNumber() << " " << iTrack << " " <<
  //     initial_state.trackChi2[iTrack] << " " <<
  //     initial_state.measurementsPerTrack[iTrack].size() << std::endl;
  // }
 
  ldmx_log(info) << " Resolved to " << state.selected_tracks_.size()
                 << " tracks from " << " " << tracks.size();
}

References computeInitialState(), framework::Event::exists(), n_meas_min_, and resolve().

removeTrack()

void tracking::reco::GreedyAmbiguitySolver::removeTrack ( State & state, std::size_t iTrack ) const

private

Parameters

state	A state object that was previously filled by the initialization.
iTrack

Definition at line 29 of file GreedyAmbiguitySolver.cxx.

                                                                {
  for (auto i_measurement : state.measurements_per_track_[iTrack]) {
    state.tracks_per_measurement_[i_measurement].erase(iTrack);
    if (state.tracks_per_measurement_[i_measurement].size() == 1) {
      auto j_track = *state.tracks_per_measurement_[i_measurement].begin();
      --state.shared_measurements_per_track_[j_track];
    }
  }
  state.selected_tracks_.erase(iTrack);
}

Referenced by resolve().

resolve()

void tracking::reco::GreedyAmbiguitySolver::resolve ( State & state )

private

Updates the state iteratively by evicting one track after the other until the final state conditions are met.

Parameters

state

A state object that was previously filled by the initialization.

Compares two tracks based on the number of shared measurements in order to decide if we already met the final state.

Compares two tracks in order to find the one which should be evicted. First we compare the relative amount of shared measurements. If that is indecisive we use the chi2.

Helper to calculate the relative amount of shared measurements.

Definition at line 103 of file GreedyAmbiguitySolver.cxx.

                                                {
  auto shared_measurements_comperator = [&state](std::size_t a, std::size_t b) {
    return state.shared_measurements_per_track_[a] <
           state.shared_measurements_per_track_[b];
  };
 
  auto track_comperator = [&state](std::size_t a, std::size_t b) {
    auto relative_shared_measurements = [&state](std::size_t i) {
      return 1.0 * state.shared_measurements_per_track_[i] /
             state.measurements_per_track_[i].size();
    };
 
    if (relative_shared_measurements(a) != relative_shared_measurements(b)) {
      return relative_shared_measurements(a) < relative_shared_measurements(b);
    }
    return state.track_chi2_[a] < state.track_chi2_[b];
  };
 
  for (std::size_t i = 0; i < maximum_iterations_; ++i) {
    // Lazy out if there is nothing to filter on.
    if (state.selected_tracks_.empty()) {
      ldmx_log(trace) << "No tracks left - exit loop";
      break;
    }
 
    // Find the maximum amount of shared measurements per track to decide if we
    // are done or not.
    auto maximum_shared_measurements = *std::max_element(
        state.selected_tracks_.begin(), state.selected_tracks_.end(),
        shared_measurements_comperator);
    // ldmx_log(debug)  <<
    //     "maximum shared measurements "
    //     << state.sharedMeasurementsPerTrack[maximumSharedMeasurements];
    if (state.shared_measurements_per_track_[maximum_shared_measurements] <
        maximum_shared_hits_) {
      break;
    }
 
    // Find the "worst" track by comparing them to each other
    auto bad_track =
        *std::max_element(state.selected_tracks_.begin(),
                          state.selected_tracks_.end(), track_comperator);
    ldmx_log(trace) << "Remove track " << bad_track << ", nMeas = "
                    << state.measurements_per_track_[bad_track].size()
                    << ", nShared = "
                    << state.shared_measurements_per_track_[bad_track]
                    << ", chi2 =" << state.track_chi2_[bad_track];
    removeTrack(state, bad_track);
  }
}

References maximum_iterations_, maximum_shared_hits_, and removeTrack().

Referenced by produce().

Member Data Documentation

input_pass_name_

std::string tracking::reco::GreedyAmbiguitySolver::input_pass_name_ {""}

private

Definition at line 104 of file GreedyAmbiguitySolver.h.

{""};

maximum_iterations_

std::uint32_t tracking::reco::GreedyAmbiguitySolver::maximum_iterations_ {1000}

private

Maximum number of iterations.

Definition at line 93 of file GreedyAmbiguitySolver.h.

{1000};

Referenced by resolve().

maximum_shared_hits_

std::uint32_t tracking::reco::GreedyAmbiguitySolver::maximum_shared_hits_ {1}

private

Maximum amount of shared hits per track.

Definition at line 91 of file GreedyAmbiguitySolver.h.

{1};

Referenced by configure(), and resolve().

meas_collection_

std::string tracking::reco::GreedyAmbiguitySolver::meas_collection_ {"DigiTaggerSimHits"}

private

Definition at line 102 of file GreedyAmbiguitySolver.h.

{"DigiTaggerSimHits"};

n_meas_min_

std::size_t tracking::reco::GreedyAmbiguitySolver::n_meas_min_ {7}

private

Minimum number of measurement to form a track.

Definition at line 96 of file GreedyAmbiguitySolver.h.

{7};

Referenced by computeInitialState(), configure(), and produce().

out_trk_collection_

std::string tracking::reco::GreedyAmbiguitySolver::out_trk_collection_ {"TaggerTracksClean"}

private

Definition at line 98 of file GreedyAmbiguitySolver.h.

{"TaggerTracksClean"};

track_collection_

std::string tracking::reco::GreedyAmbiguitySolver::track_collection_ {"TaggerTracks"}

private

Definition at line 100 of file GreedyAmbiguitySolver.h.

{"TaggerTracks"};

---

The documentation for this class was generated from the following files:

• Tracking/include/Tracking/Reco/GreedyAmbiguitySolver.h
• Tracking/src/Tracking/Reco/GreedyAmbiguitySolver.cxx