tracking::reco::LinearTruthTracking Class Reference

Public Member Functions
	LinearTruthTracking (const std::string &name, framework::Process &process)
	Constructor.
virtual	~LinearTruthTracking ()=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 and create a collection of results which indicate if a charge particle can be found by the recoil tracker.
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.

Protected Member Functions
ldmx::StraightTrack	truthTracker (const std::vector< ldmx::SimTrackerHit > &points, std::vector< std::array< double, 3 > > &ecal_points)
double	calculateDistance (const std::array< double, 3 > &point1, const std::array< double, 3 > &point2)
std::tuple< double, double, double, double >	fit3DLine (const std::vector< ldmx::SimTrackerHit > &points)
double	globalChiSquare (const std::vector< ldmx::SimTrackerHit > &points, double a_x, double a_y, double b_x, double b_y)
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
double	processing_time_ {0.}
long	n_events_ {0}
unsigned int	n_truth_ {0}
long	n_missing_ {0}
long	n_empty_ {0}
double	ecal_first_layer_z_threshold_ {250.0}
std::string	out_trk_collection_ {"LinearRecoilTruthTracks"}
	The name of the output collection of seeds to be stored.
std::string	input_hits_collection_ {"RecoilSimHits"}
	The name of the input hits collection to use in finding seeds..
std::string	input_rec_hits_collection_ {"EcalRecHits"}
	The name of the tagger Tracks (only for Recoil Seeding)
std::string	input_pass_name_ {""}
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 26 of file LinearTruthTracking.h.

Constructor & Destructor Documentation

LinearTruthTracking()

tracking::reco::LinearTruthTracking::LinearTruthTracking	(	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 8 of file LinearTruthTracking.cxx.

    : TrackingGeometryUser(name, process) {}

Member Function Documentation

calculateDistance()

double tracking::reco::LinearTruthTracking::calculateDistance ( const std::array< double, 3 > & point1, const std::array< double, 3 > & point2 )

protected

Definition at line 161 of file LinearTruthTracking.cxx.

                                                                          {
  return sqrt(pow(point1[1] - point2[1], 2) + pow(point1[2] - point2[2], 2));
}  // calculateDistance

configure()

void tracking::reco::LinearTruthTracking::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 12 of file LinearTruthTracking.cxx.

                                                                         {
  // Output seed name
  out_trk_collection_ = parameters.get<std::string>("out_trk_collection",
                                                    "LinearRecoilTruthTracks");
 
  // Input strip hits_
  input_hits_collection_ =
      parameters.get<std::string>("input_hits_collection", "RecoilSimHits");
  input_rec_hits_collection_ =
      parameters.get<std::string>("input_recHits_collection", "EcalRecHits");
 
  input_pass_name_ = parameters.get<std::string>("input_pass_name");
 
  ecal_first_layer_z_threshold_ =
      parameters.get<double>("ecal_first_layer_z_threshold");
}  // configure

References framework::config::Parameters::get(), input_hits_collection_, input_rec_hits_collection_, and out_trk_collection_.

fit3DLine()

std::tuple< double, double, double, double > tracking::reco::LinearTruthTracking::fit3DLine ( const std::vector< ldmx::SimTrackerHit > & points )

protected

Definition at line 166 of file LinearTruthTracking.cxx.

                                                {
  std::vector<double> z_vals, x_vals, y_vals;
 
  for (const auto& point : points) {
    const auto& position = point.getPosition();
    x_vals.push_back(position[0]);
    y_vals.push_back(position[1]);
    z_vals.push_back(position[2]);
  }
 
  size_t num_points = points.size();
  Eigen::MatrixXd a_mat(num_points, 2);
  Eigen::VectorXd x_vec(num_points), y_vec(num_points);
 
  for (size_t i = 0; i < num_points; ++i) {
    a_mat(i, 0) = z_vals[i];
    a_mat(i, 1) = 1;
    x_vec(i) = x_vals[i];
    y_vec(i) = y_vals[i];
  }
 
  Eigen::Matrix2d at_a = a_mat.transpose() * a_mat;
  Eigen::Vector2d at_x = a_mat.transpose() * x_vec;
  Eigen::Vector2d at_y = a_mat.transpose() * y_vec;
 
  Eigen::Vector2d x_params = at_a.ldlt().solve(at_x);
  Eigen::Vector2d y_params = at_a.ldlt().solve(at_y);
 
  // Return (mx, bx, my, by)
  return {x_params(0), x_params(1), y_params(0), y_params(1)};
}

globalChiSquare()

double tracking::reco::LinearTruthTracking::globalChiSquare ( const std::vector< ldmx::SimTrackerHit > & points, double a_x, double a_y, double b_x, double b_y )

protected

Definition at line 199 of file LinearTruthTracking.cxx.

                            {
  double chi2_x = 0, chi2_y = 0;
 
  for (const auto& point : points) {
    const auto& position = point.getPosition();
    double x_pos = position[0];
    double y_pos = position[1];
    double z_pos = position[2];
 
    double x_fit = m_x * z_pos + b_x;
    double y_fit = m_y * z_pos + b_y;
 
    chi2_x += std::pow((x_pos - x_fit), 2);
    chi2_y += std::pow((y_pos - y_fit), 2);
  }
 
  return chi2_x + chi2_y;
}  // globalChiSquare

onProcessEnd()

void tracking::reco::LinearTruthTracking::onProcessEnd ( )

overridevirtual

Output event statistics.

Reimplemented from framework::EventProcessor.

Definition at line 150 of file LinearTruthTracking.cxx.

                                       {
  ldmx_log(info) << "AVG Time / Event: " << std::fixed << std::setprecision(1)
                 << processing_time_ / n_events_ << " ms";
  ldmx_log(info) << "Number of Events without enough seed points: "
                 << n_missing_;
  ldmx_log(info) << "Number of Events with only 1 trackID == 1 point: "
                 << n_empty_;
  ldmx_log(info) << "Total Truth Tracks / Event: " << n_truth_ << "/"
                 << n_events_;
}  // onProcessEnd

produce()

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

overridevirtual

Run the processor and create a collection of results which indicate if a charge particle can be found by the recoil tracker.

Parameters

event

The event to process.

Implements framework::Producer.

Definition at line 29 of file LinearTruthTracking.cxx.

                                                       {
  auto start = std::chrono::high_resolution_clock::now();
  std::vector<ldmx::StraightTrack> straight_truth_tracks;
  n_events_++;
 
  const std::vector<ldmx::SimTrackerHit> recoil_hits =
      event.getCollection<ldmx::SimTrackerHit>(input_hits_collection_,
                                               input_pass_name_);
  const std::vector<ldmx::EcalHit> ecal_rec_hit =
      event.getCollection<ldmx::EcalHit>(input_rec_hits_collection_,
                                         input_pass_name_);
 
  std::vector<std::array<double, 3>> first_layer_ecal_rec_hits;
 
  for (const auto& x_ecal : ecal_rec_hit) {
    if (x_ecal.getZPos() < ecal_first_layer_z_threshold_) {
      first_layer_ecal_rec_hits.push_back(
          {x_ecal.getZPos(), x_ecal.getXPos(), x_ecal.getYPos()});
    }  // if first layer_ of Ecal
  }  // for positions in ecalRecHit
 
  // Check if we would fit empty seeds.
  if (recoil_hits.size() < 2) {
    n_missing_++;
    n_truth_ += straight_truth_tracks.size();
    event.add(out_trk_collection_, straight_truth_tracks);
    return;
  }  // if not enough hits_
 
  std::vector<ldmx::SimTrackerHit> truth_points;
 
  // Find only recoil electron out of the hit collection
  for (const auto& point : recoil_hits) {
    if (point.getTrackID() == 1) {
      truth_points.push_back(point);
    }  // if trackID == 1
  }  // for point in hit collection
 
  // should only find 1 track (recoil e-) or 0 track (no recoil e-)
  if (truth_points.size() > 1) {
    straight_truth_tracks.push_back(
        truthTracker(truth_points, first_layer_ecal_rec_hits));
  }  // if we have truth points
  else {
    n_empty_++;
    n_truth_ += straight_truth_tracks.size();
    return;
  }  // else no truth points
 
  n_truth_ += straight_truth_tracks.size();
  event.add(out_trk_collection_, straight_truth_tracks);
 
  auto end = std::chrono::high_resolution_clock::now();
  auto diff = end - start;
  processing_time_ += std::chrono::duration<double, std::milli>(diff).count();
 
  first_layer_ecal_rec_hits.clear();
  straight_truth_tracks.clear();
 
}  // produce

References input_hits_collection_, input_rec_hits_collection_, and out_trk_collection_.

truthTracker()

ldmx::StraightTrack tracking::reco::LinearTruthTracking::truthTracker ( const std::vector< ldmx::SimTrackerHit > & points, std::vector< std::array< double, 3 > > & ecal_points )

protected

Definition at line 90 of file LinearTruthTracking.cxx.

                                                 {
  ldmx::StraightTrack trk = ldmx::StraightTrack();
 
  // We have pre-selected hits_ corresponding to the Recoil e-, so we only fit
  // these (no RecHit)
  auto [m_x, b_x, m_y, b_y] = fit3DLine(points);
 
  trk.setSlopeX(m_x);
  trk.setInterceptX(b_x);
  trk.setSlopeY(m_y);
  trk.setInterceptY(b_y);
  trk.setTheta(std::atan2(m_y, std::sqrt(1 + m_x * m_x)));
  trk.setPhi(std::atan2(m_x, 1.0));
  trk.setTargetLocation(0.0, b_x, b_y);
  trk.setNhits(points.size());
  trk.setNdf(points.size() - 2);
 
  trk.setTrackID(points[0].getTrackID());
  trk.setPdgID(points[0].getPdgID());
  trk.setTruthProb(1.0);
 
  trk.setAllTruthSensorPoints(points);
 
  trk.setChi2(globalChiSquare(points, m_x, m_y, b_x, b_y));
 
  // Z position from the first point in ecalPoints
  if (ecal_points.size() > 0) {
    double ecal_first_layer_z = ecal_points[0][0];
 
    // Extrapolate track to first layer_ of Ecal
    std::array<double, 3> extrapolated_point = {ecal_first_layer_z,
                                                m_x * ecal_first_layer_z + b_x,
                                                m_y * ecal_first_layer_z + b_y};
 
    const std::array<double, 3>* closest_rec_hit = nullptr;
    double min_distance = std::numeric_limits<double>::max();
 
    // Loop through ecalPoints to find the closest recHit to our track
    for (const auto& ecal_rec_hit : ecal_points) {
      double temp_distance =
          calculateDistance(extrapolated_point, ecal_rec_hit);
 
      if (temp_distance < min_distance) {
        min_distance = temp_distance;
        closest_rec_hit = &ecal_rec_hit;
      }  // if compare min distance
    }  // for recHits
 
    if (closest_rec_hit != nullptr) {
      trk.setFirstLayerEcalRecHit(*closest_rec_hit);
      trk.setDistancetoRecHit(min_distance);
      trk.setEcalLayer1Location(extrapolated_point);
    }  // if set trk info
  }  // make sure there are ecalPoints to work with
 
  return trk;
}  // truthTracker

Member Data Documentation

ecal_first_layer_z_threshold_

double tracking::reco::LinearTruthTracking::ecal_first_layer_z_threshold_ {250.0}

protected

Definition at line 83 of file LinearTruthTracking.h.

{250.0};

input_hits_collection_

std::string tracking::reco::LinearTruthTracking::input_hits_collection_ {"RecoilSimHits"}

protected

The name of the input hits collection to use in finding seeds..

Definition at line 88 of file LinearTruthTracking.h.

{"RecoilSimHits"};

Referenced by configure(), and produce().

input_pass_name_

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

protected

Definition at line 91 of file LinearTruthTracking.h.

{""};

input_rec_hits_collection_

std::string tracking::reco::LinearTruthTracking::input_rec_hits_collection_ {"EcalRecHits"}

protected

The name of the tagger Tracks (only for Recoil Seeding)

Definition at line 90 of file LinearTruthTracking.h.

{"EcalRecHits"};

Referenced by configure(), and produce().

n_empty_

long tracking::reco::LinearTruthTracking::n_empty_ {0}

protected

Definition at line 80 of file LinearTruthTracking.h.

{0};

n_events_

long tracking::reco::LinearTruthTracking::n_events_ {0}

protected

Definition at line 77 of file LinearTruthTracking.h.

{0};

n_missing_

long tracking::reco::LinearTruthTracking::n_missing_ {0}

protected

Definition at line 79 of file LinearTruthTracking.h.

{0};

n_truth_

unsigned int tracking::reco::LinearTruthTracking::n_truth_ {0}

protected

Definition at line 78 of file LinearTruthTracking.h.

{0};

out_trk_collection_

std::string tracking::reco::LinearTruthTracking::out_trk_collection_ {"LinearRecoilTruthTracks"}

protected

The name of the output collection of seeds to be stored.

Definition at line 86 of file LinearTruthTracking.h.

{"LinearRecoilTruthTracks"};

Referenced by configure(), and produce().

processing_time_

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

protected

Definition at line 76 of file LinearTruthTracking.h.

{0.};

---

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

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