Public Member Functions
	LinearTrackFinder (const std::string &name, framework::Process &process)
	Constructor.

virtual	~LinearTrackFinder ()=default
	Destructor.

void	onProcessEnd () override
	Output event statistics.

void	configure (framework::config::Parameters &parameters) override
	Configure the processor using the given user specified parameters.

void	produce (framework::Event &event) override
	Run the processor.

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	onNewRun (const ldmx::RunHeader &run_header)
	Callback for the EventProcessor to take any necessary action when the run being processed changes.

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
std::vector< ldmx::StraightTrack >	findTracks (const std::vector< ldmx::StraightTrack > &track_seeds)

bool	isPositionUsed (const ldmx::Measurement &measurement, const std::set< std::tuple< float, float, float > > &used_sensor_positions)

Private Attributes
int	n_events_ {0}

double	processing_time_ {0.}

std::string	out_trk_collection_ {"LinearRecoilTracks"}

std::string	seed_collection_ {"LinearRecoilSeedTracks"}

std::string	input_pass_name_ {""}

int	n_seeds_ {0}

int	n_tracks_ {0}

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

Definition at line 19 of file LinearTrackFinder.h.

Constructor & Destructor Documentation

◆ LinearTrackFinder()

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

Constructor.

Parameters

name	The name of the instance of this object.
process	The process running this producer.

Definition at line 13 of file LinearTrackFinder.cxx.

15 : 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

◆ configure()

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

overridevirtual

Configure the processor using the given user specified parameters.

Parameters

parameters Set of parameters used to configure this processor.

Reimplemented from framework::EventProcessor.

Definition at line 17 of file LinearTrackFinder.cxx.

                                                                       {
  // seeds from the event
  seed_collection_ =
      parameters.get<std::string>("seed_collection", "LinearRecoilSeedTracks");
  // output track collection
  out_trk_collection_ =
      parameters.get<std::string>("out_trk_collection", "LinearRecoilTracks");
 
  input_pass_name_ = parameters.get<std::string>("input_pass_name");
 
}  // configure

References framework::config::Parameters::get().

◆ findTracks()

std::vector< ldmx::StraightTrack > tracking::reco::LinearTrackFinder::findTracks ( const std::vector< ldmx::StraightTrack > & track_seeds )

private

Definition at line 68 of file LinearTrackFinder.cxx.

                                                     {
  std::vector<ldmx::StraightTrack> best_tracks;
  std::map<std::array<double, 3>, std::vector<ldmx::StraightTrack>>
      seeds_by_rec_hit;
 
  // Group seeds by their EcalRecHit point
  for (const auto& seed : track_seeds) {
    auto rec_hit_point = seed.getFirstLayerEcalRecHit();
    seeds_by_rec_hit[rec_hit_point].push_back(seed);
  }
 
  // Track used sensor positions
  std::set<std::tuple<float, float, float>> used_sensor_positions;
 
  // Find the best seed for each RecHit
  // numTracks <= number of RecHits
  for (auto& entry : seeds_by_rec_hit) {
    const auto& rec_hit_point = entry.first;
    auto& seeds_with_same_rec_hit = entry.second;
 
    ldmx_log(debug) << "Processing RecHit at: (" << rec_hit_point[0] << ", "
                    << rec_hit_point[1] << ", " << rec_hit_point[2] << ")\n";
 
    // Main function to remove seeds with overlapping sensor positions
    seeds_with_same_rec_hit.erase(
        std::remove_if(
            seeds_with_same_rec_hit.begin(), seeds_with_same_rec_hit.end(),
            [&](const ldmx::StraightTrack& seed) {
              for (const auto& measurement : seed.getAllSensorPoints()) {
                // Check if this sensor's position is already used
                if (isPositionUsed(measurement, used_sensor_positions)) {
                  // Mark this seed for removal
                  return true;
                }  // ifPositionUsed
              }  // for measurement
              // Keep the seed if no position overlap
              return false;
            }),
        seeds_with_same_rec_hit.end());
 
    // If no valid seeds remain after filtering, skip to next RecHit
    if (seeds_with_same_rec_hit.empty()) continue;
 
    // Find the seed with the lowest chi2 for this RecHit, this is "best" seed
    auto best_seed_it = std::min_element(
        seeds_with_same_rec_hit.begin(), seeds_with_same_rec_hit.end(),
        [](const ldmx::StraightTrack& trk_a, const ldmx::StraightTrack& trk_b) {
          return trk_a.getChi2() < trk_b.getChi2();
        });
 
    // Store the best seed for this RecHit
    ldmx::StraightTrack best_seed = *best_seed_it;
    best_tracks.push_back(best_seed);
 
    ldmx_log(debug) << "For RecHit at: (" << rec_hit_point[0] << ", "
                    << rec_hit_point[1] << ", " << rec_hit_point[2] << ")\n";
 
    // Add best seed's sensor position to the global used positions set
    auto best_seed_measurement = best_seed.getAllSensorPoints();
 
    for (auto& position_object : best_seed_measurement) {
      used_sensor_positions.insert(
          std::make_tuple(position_object.getGlobalPosition()[0],
                          position_object.getGlobalPosition()[1],
                          position_object.getGlobalPosition()[2]));
      ldmx_log(debug) << "We used the following point: ("
                      << position_object.getGlobalPosition()[0] << ", "
                      << position_object.getGlobalPosition()[1] << ", "
                      << position_object.getGlobalPosition()[2] << ")\n";
      ldmx_log(debug) << "Which gave a track a distance: "
                      << best_seed.getDistanceToRecHit()
                      << " to the closest ECalRecHit\n";
    }  // for sensor points in "best" seed
 
  }  // for entry loop, everytime we loop onto a new RecHit, we will have fewer
     // points to check
 
  return best_tracks;
 
}  // findTracks

◆ isPositionUsed()

bool tracking::reco::LinearTrackFinder::isPositionUsed	(	const ldmx::Measurement &	measurement,
		const std::set< std::tuple< float, float, float > > &	used_sensor_positions )

private

Definition at line 150 of file LinearTrackFinder.cxx.

                                                                        {
  const auto& position = std::make_tuple(measurement.getGlobalPosition()[0],
                                         measurement.getGlobalPosition()[1],
                                         measurement.getGlobalPosition()[2]);
 
  return used_sensor_positions.find(position) != used_sensor_positions.end();
 
}  // isPositionUsed

◆ onProcessEnd()

void tracking::reco::LinearTrackFinder::onProcessEnd ( )

overridevirtual

Output event statistics.

Reimplemented from framework::EventProcessor.

Definition at line 61 of file LinearTrackFinder.cxx.

                                     {
  ldmx_log(info) << "found " << n_tracks_ << " tracks / " << n_events_
                 << " events.";
  ldmx_log(info) << "AVG Time/Event: " << std::fixed << std::setprecision(1)
                 << processing_time_ / n_events_ << " ms";
}  // onProcessEnd

◆ produce()

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

overridevirtual

Run the processor.

Parameters

event The event to process.

Implements framework::Producer.

Definition at line 29 of file LinearTrackFinder.cxx.

                                                     {
  std::vector<ldmx::StraightTrack> straight_tracks;
 
  auto start = std::chrono::high_resolution_clock::now();
 
  n_events_++;
  if (n_events_ % 1000 == 0) ldmx_log(info) << "events processed:" << n_events_;
 
  ldmx_log(debug) << "Retrieve the seeds::" << seed_collection_;
 
  const auto& seed_tracks = event.getCollection<ldmx::StraightTrack>(
      seed_collection_, input_pass_name_);
 
  n_seeds_ = seed_tracks.size();
  ldmx_log(debug) << "Number of seeds::" << n_seeds_;
 
  if (n_seeds_ > 0) {
    straight_tracks = findTracks(seed_tracks);
  }
 
  n_tracks_ += straight_tracks.size();
 
  // Add the tracks to the event
  event.add(out_trk_collection_, straight_tracks);
 
  auto end = std::chrono::high_resolution_clock::now();
  auto diff = end - start;
  processing_time_ += std::chrono::duration<double, std::milli>(diff).count();
 
  straight_tracks.clear();
}  // produce

Member Data Documentation

◆ input_pass_name_

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

private

Definition at line 59 of file LinearTrackFinder.h.

59{""};

◆ n_events_

int tracking::reco::LinearTrackFinder::n_events_ {0}

private

Definition at line 51 of file LinearTrackFinder.h.

51{0};

◆ n_seeds_

int tracking::reco::LinearTrackFinder::n_seeds_ {0}

private

Definition at line 61 of file LinearTrackFinder.h.

61{0};

◆ n_tracks_

int tracking::reco::LinearTrackFinder::n_tracks_ {0}

private

Definition at line 62 of file LinearTrackFinder.h.

62{0};

◆ out_trk_collection_

std::string tracking::reco::LinearTrackFinder::out_trk_collection_ {"LinearRecoilTracks"}

private

Definition at line 55 of file LinearTrackFinder.h.

55{"LinearRecoilTracks"};

◆ processing_time_

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

private

Definition at line 52 of file LinearTrackFinder.h.

52{0.};

◆ seed_collection_

std::string tracking::reco::LinearTrackFinder::seed_collection_ {"LinearRecoilSeedTracks"}

private

Definition at line 58 of file LinearTrackFinder.h.

58{"LinearRecoilSeedTracks"};

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

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

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ LinearTrackFinder()

Member Function Documentation

◆ configure()

◆ findTracks()

◆ isPositionUsed()

◆ onProcessEnd()

◆ produce()

Member Data Documentation

◆ input_pass_name_

◆ n_events_

◆ n_seeds_

◆ n_tracks_

◆ out_trk_collection_

◆ processing_time_

◆ seed_collection_