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	beforeNewRun (ldmx::RunHeader &header)
	Handle allowing producers to modify run headers before the run begins.
Public Member Functions inherited from framework::EventProcessor
	EventProcessor (const std::string &name, Process &process)
	Class constructor.
virtual	~EventProcessor ()
	Class destructor.
virtual void	onFileOpen (EventFile &eventFile)
	Callback for the EventProcessor to take any necessary action when a new event input ROOT file is opened.
virtual void	onFileClose (EventFile &eventFile)
	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
Static Public Member Functions inherited from framework::EventProcessor
static void	declare (const std::string &classname, int classtype, EventProcessorMaker *)
	Internal function which is part of the PluginFactory machinery.
Static Public Attributes inherited from framework::Producer
static const int	CLASSTYPE {1}
	Constant used to track EventProcessor types by the PluginFactory.
Protected Member Functions inherited from tracking::reco::TrackingGeometryUser
const Acts::GeometryContext &	geometry_context ()
const Acts::MagneticFieldContext &	magnetic_field_context ()
const Acts::CalibrationContext &	calibration_context ()
const geo::TrackersTrackingGeometry &	geometry ()
Protected Member Functions inherited from framework::EventProcessor
void	abortEvent ()
	Abort the event immediately.
Protected Attributes inherited from framework::EventProcessor
HistogramHelper	histograms_
	Interface class for making and filling histograms.
NtupleManager &	ntuple_ {NtupleManager::getInstance()}
	Manager for any ntuples.
logging::logger	theLog_
	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 measurementIndexMap =
      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
      ActsExamples::IndexSourceLink idx_sl(hit_surface->geometryId(), imeas);
      Acts::SourceLink sourceLink = Acts::SourceLink(idx_sl);
 
      auto emplace = measurementIndexMap.try_emplace(
          sourceLink, measurementIndexMap.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 iTrack = 0; iTrack < state.number_of_tracks; ++iTrack) {
    for (auto iMeasurement : state.measurements_per_track[iTrack]) {
      state.tracks_per_measurement[iMeasurement].insert(iTrack);
    }
  }
 
  // 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 iTrack = 0; iTrack < state.number_of_tracks; ++iTrack) {
    for (auto iMeasurement : state.measurements_per_track[iTrack]) {
      if (state.tracks_per_measurement[iMeasurement].size() > 1) {
        ++state.shared_measurements_per_track[iTrack];
      }
    }
  }
}

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.getParameter<std::string>(
      "out_trk_collection", "TaggerTracksClean");
 
  track_collection_ =
      parameters.getParameter<std::string>("trackCollection", "TaggerTracks");
 
  meas_collection_ = parameters.getParameter<std::string>("measCollection",
                                                          "DigiTaggerSimHits");
  input_pass_name_ =
      parameters.getParameter<std::string>("input_pass_name", "");
  n_meas_min_ = parameters.getParameter<int>("nMeasurementsMin", 5);
  maximum_shared_hits_ = parameters.getParameter<int>("maximumSharedHits", 1);
}

References 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 180 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 iTrack : state.selected_tracks) {
    auto clean_trk = tracks[state.track_tips.at(iTrack)];
    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 iMeasurement : state.measurements_per_track[iTrack]) {
    state.tracks_per_measurement[iMeasurement].erase(iTrack);
    if (state.tracks_per_measurement[iMeasurement].size() == 1) {
      auto jTrack = *state.tracks_per_measurement[iMeasurement].begin();
      --state.shared_measurements_per_track[jTrack];
    }
  }
  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 sharedMeasurementsComperator = [&state](std::size_t a, std::size_t b) {
    return state.shared_measurements_per_track[a] <
           state.shared_measurements_per_track[b];
  };
 
  auto trackComperator = [&state](std::size_t a, std::size_t b) {
    auto relativeSharedMeasurements = [&state](std::size_t i) {
      return 1.0 * state.shared_measurements_per_track[i] /
             state.measurements_per_track[i].size();
    };
 
    if (relativeSharedMeasurements(a) != relativeSharedMeasurements(b)) {
      return relativeSharedMeasurements(a) < relativeSharedMeasurements(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 maximumSharedMeasurements = *std::max_element(
        state.selected_tracks.begin(), state.selected_tracks.end(),
        sharedMeasurementsComperator);
    // ldmx_log(debug)  <<
    //     "maximum shared measurements "
    //     << state.sharedMeasurementsPerTrack[maximumSharedMeasurements];
    if (state.shared_measurements_per_track[maximumSharedMeasurements] <
        maximum_shared_hits_) {
      break;
    }
 
    // Find the "worst" track by comparing them to each other
    auto badTrack =
        *std::max_element(state.selected_tracks.begin(),
                          state.selected_tracks.end(), trackComperator);
    ldmx_log(trace) << "Remove track " << badTrack << ", nMeas = "
                    << state.measurements_per_track[badTrack].size()
                    << ", nShared = "
                    << state.shared_measurements_per_track[badTrack]
                    << ", chi2 =" << state.track_chi2[badTrack];
    removeTrack(state, badTrack);
  }
}

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