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.

void	onProcessEnd () override
	Callback for the EventProcessor to take any necessary action when the processing of events finishes, such as calculating job-summary quantities.

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.

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
int	nevents_ {0}

int	n_input_tracks_ {0}

int	n_output_tracks_ {0}

double	processing_time_ {0.}

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 ()

void	loadBField (const std::string &path, const BFieldDistortion &distortion={})
	Load the interpolated B-field map from `path` and cache it.

void	loadBField (const BFieldDistortion &distortion={})
	Load B-field from the path recorded in the detector GDML.

std::shared_ptr< Acts::MagneticFieldProvider >	bField () const
	Return the loaded B-field provider.

Protected Member Functions inherited from framework::EventProcessor
void	abortEvent ()
	Abort the event immediately.

Static Protected Member Functions inherited from tracking::reco::TrackingGeometryUser
static BFieldDistortion	bFieldDistortion (const framework::config::Parameters &parameters)
	Build a BFieldDistortion from processor configuration.

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 38 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 16 of file GreedyAmbiguitySolver.cxx.

18 : TrackingGeometryUser(name, process) {}

framework::Producer::process

virtual void process(Event &event) final

Processing an event for a Producer is calling produce.

Definition EventProcessor.h:276

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 48 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 169 of file GreedyAmbiguitySolver.cxx.

                                           {
  out_trk_collection_ =
      parameters.get<std::string>("out_trk_collection", "TaggerTracksClean");
 
  track_collection_ =
      parameters.get<std::string>("track_collection", "TaggerTracks");
 
  meas_collection_ =
      parameters.get<std::string>("meas_collection", "DigiTaggerSimHits");
  input_pass_name_ = parameters.get<std::string>("input_pass_name");
  n_meas_min_ = parameters.get<int>("n_measurements_min", 5);
  maximum_shared_hits_ = parameters.get<int>("maximum_shared_hits", 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 167 of file GreedyAmbiguitySolver.cxx.

167{}

◆ onProcessEnd()

void tracking::reco::GreedyAmbiguitySolver::onProcessEnd ( )

overridevirtual

Callback for the EventProcessor to take any necessary action when the processing of events finishes, such as calculating job-summary quantities.

Reimplemented from framework::EventProcessor.

Definition at line 233 of file GreedyAmbiguitySolver.cxx.

                                         {
  double avg_in =
      nevents_ > 0 ? static_cast<double>(n_input_tracks_) / nevents_ : 0.;
  double avg_out =
      nevents_ > 0 ? static_cast<double>(n_output_tracks_) / nevents_ : 0.;
  double retention =
      n_input_tracks_ > 0 ? 100.0 * n_output_tracks_ / n_input_tracks_ : 0.;
  ldmx_log(info) << "--------------------------------- ";
  ldmx_log(info) << "GAS: " << n_output_tracks_ << " output tracks / "
                 << n_input_tracks_ << " input tracks";
  ldmx_log(info) << "AVG Time/Event: " << std::fixed << std::setprecision(1)
                 << processing_time_ / nevents_ << " ms";
  ldmx_log(info) << "AVG tracks in/event:  " << std::fixed
                 << std::setprecision(1) << avg_in;
  ldmx_log(info) << "AVG tracks out/event: " << std::fixed
                 << std::setprecision(1) << avg_out << " (" << std::fixed
                 << std::setprecision(1) << retention << "% retained)";
}

◆ 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 184 of file GreedyAmbiguitySolver.cxx.

                                                         {
  auto t_start = std::chrono::high_resolution_clock::now();
 
  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";
    ++nevents_;
    return;
  }
  const 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";
    ++nevents_;
    return;
  }
  const auto& measurements = event.getCollection<ldmx::Measurement>(
      meas_collection_, input_pass_name_);
 
  n_input_tracks_ += static_cast<int>(tracks.size());
 
  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);
    }
  }
 
  n_output_tracks_ += static_cast<int>(out_tracks.size());
 
  event.add(out_trk_collection_, out_tracks);
 
  auto t_end = std::chrono::high_resolution_clock::now();
  processing_time_ +=
      std::chrono::duration<double, std::milli>(t_end - t_start).count();
  ++nevents_;
}

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 34 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 108 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 100 of file GreedyAmbiguitySolver.h.

100{""};

◆ maximum_iterations_

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

private

Maximum number of iterations.

Definition at line 89 of file GreedyAmbiguitySolver.h.

89{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 87 of file GreedyAmbiguitySolver.h.

87{1};

Referenced by configure(), and resolve().

◆ meas_collection_

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

private

Definition at line 98 of file GreedyAmbiguitySolver.h.

98{"DigiTaggerSimHits"};

◆ n_input_tracks_

int tracking::reco::GreedyAmbiguitySolver::n_input_tracks_ {0}

private

Definition at line 82 of file GreedyAmbiguitySolver.h.

82{0};

◆ 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 92 of file GreedyAmbiguitySolver.h.

92{7};

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

◆ n_output_tracks_

int tracking::reco::GreedyAmbiguitySolver::n_output_tracks_ {0}

private

Definition at line 83 of file GreedyAmbiguitySolver.h.

83{0};

◆ nevents_

int tracking::reco::GreedyAmbiguitySolver::nevents_ {0}

private

Definition at line 81 of file GreedyAmbiguitySolver.h.

81{0};

◆ out_trk_collection_

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

private

Definition at line 94 of file GreedyAmbiguitySolver.h.

94{"TaggerTracksClean"};

◆ processing_time_

double tracking::reco::GreedyAmbiguitySolver::processing_time_ {0.}

private

Definition at line 84 of file GreedyAmbiguitySolver.h.

84{0.};

◆ track_collection_

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

private

Definition at line 96 of file GreedyAmbiguitySolver.h.

96{"TaggerTracks"};

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

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

Classes

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ GreedyAmbiguitySolver()

Member Function Documentation

◆ computeInitialState()

◆ configure()

◆ onNewRun()

◆ onProcessEnd()

◆ produce()

◆ removeTrack()

◆ resolve()

Member Data Documentation

◆ input_pass_name_

◆ maximum_iterations_

◆ maximum_shared_hits_

◆ meas_collection_

◆ n_input_tracks_

◆ n_meas_min_

◆ n_output_tracks_

◆ nevents_

◆ out_trk_collection_

◆ processing_time_

◆ track_collection_