EcalHelper.h File Reference

Class that propagates tracks to the ECAL face. More...

#include "Tracking/Event/Track.h"
#include <cmath>
#include "Math/Vector3D.h"

Go to the source code of this file.

Functions
std::vector< float >	ecal::trackProp (const ldmx::Tracks &tracks, ldmx::TrackStateType ts_type, const std::string &ts_title)
	Return a vector of parameters for a propagated recoil track.
std::vector< std::vector< float > >	ecal::pTTrackProp (const ldmx::Tracks &tracks, int ele_count)
	Return a vector of ele_count valid track states with the greatest transverse momentum.
std::vector< std::vector< float > >	ecal::momTrackProp (const ldmx::Tracks &tracks, int ele_count)
	Return a vector of ele_count valid track states with the greatest total momentum.
float	ecal::distTwoLines (ROOT::Math::XYZVector v1, ROOT::Math::XYZVector v2, ROOT::Math::XYZVector w1, ROOT::Math::XYZVector w2)
	Returns the distance between the lines v and w, with v defined to pass through the points (v1,v2) (and similarly for w).
float	ecal::distPtToLine (ROOT::Math::XYZVector h1, ROOT::Math::XYZVector p1, ROOT::Math::XYZVector p2)
	Return the minimum distance between the point h1 and the line passing through points p1 and p2.

Detailed Description

Class that propagates tracks to the ECAL face.

Author

Tamas Vami, Jihoon Yoo (UCSB)

Definition in file EcalHelper.h.

Function Documentation

distPtToLine()

float ecal::distPtToLine	(	ROOT::Math::XYZVector	h1,
		ROOT::Math::XYZVector	p1,
		ROOT::Math::XYZVector	p2 )

Return the minimum distance between the point h1 and the line passing through points p1 and p2.

Parameters

[in]	h1	Point to find the distance to
[in]	p1	An arbitrary point on the line
[in]	p2	A second, distinct point on the line

Returns

Minimum distance between h1 and the line

Definition at line 183 of file EcalHelper.cxx.

                                         {
  return ((h1 - p1).Cross(h1 - p2)).R() / (p1 - p2).R();
}

References ecal::distPtToLine().

Referenced by ecal::distPtToLine(), and ecal::EcalMipTrackingProcessor::produce().

distTwoLines()

float ecal::distTwoLines	(	ROOT::Math::XYZVector	v1,
		ROOT::Math::XYZVector	v2,
		ROOT::Math::XYZVector	w1,
		ROOT::Math::XYZVector	w2 )

Returns the distance between the lines v and w, with v defined to pass through the points (v1,v2) (and similarly for w).

Parameters

[in]	v1	An arbitrary point on line v
[in]	v2	A second, distinct point on line v
[in]	w1	An arbitrary point on line w
[in]	w2	A second, distinct point on line w

Returns

Closest distance of approach of lines u and v

Definition at line 170 of file EcalHelper.cxx.

                                                               {
  ROOT::Math::XYZVector e1 = v1 - v2;
  ROOT::Math::XYZVector e2 = w1 - w2;
  ROOT::Math::XYZVector crs = e1.Cross(e2);
  if (crs.R() == 0) {
    return 100.0;  // arbitrary large number; edge case that shouldn't cause
                   // problems.
  } else {
    return std::abs(crs.Dot(v1 - w1) / crs.R());
  }
}

References ecal::distTwoLines().

Referenced by ecal::distTwoLines(), and ecal::EcalMipTrackingProcessor::produce().

momTrackProp()

std::vector< std::vector< float > > ecal::momTrackProp	(	const ldmx::Tracks &	tracks,
		int	ele_count )

Return a vector of ele_count valid track states with the greatest total momentum.

Parameters

[in]	tracks	The track collection
[in]	ele_count	The recorded number of electrons in the event

Returns

Vector of valid track states with the greatest total momentum

Definition at line 109 of file EcalHelper.cxx.

                                                            {
  // Vector variable to hold track state parameters, indexed by total momentum
  std::vector<std::pair<float, std::vector<float>>> new_track_states;
 
  // Return empty vector if no tracks
  if (tracks.empty()) return {};
 
  // Otherwise loop on the tracks
  for (auto& track : tracks) {
    // Vector to hold track state parameters for a single track
    std::vector<float> track_state_vars;
    track_state_vars.reserve(6);
    // Get track state for Ecal
    auto trk_ts = track.getTrackState(ldmx::TrackStateType::AtECAL);
    // Continue if there's no value
    if (!trk_ts.has_value()) continue;
    ldmx::Track::TrackState ecal_track_state = trk_ts.value();
 
    // Check that the track state is filled
    if (ecal_track_state.pos_.size() < 3 || ecal_track_state.mom_.size() < 3)
      continue;
 
    float total_momentum =
        std::sqrt(ecal_track_state.mom_[0] * ecal_track_state.mom_[0] +
                  ecal_track_state.mom_[1] * ecal_track_state.mom_[1] +
                  ecal_track_state.mom_[2] * ecal_track_state.mom_[2]);
 
    // store state variables
    track_state_vars.push_back(ecal_track_state.pos_[0]);
    track_state_vars.push_back(ecal_track_state.pos_[1]);
    track_state_vars.push_back(ecal_track_state.pos_[2]);
    track_state_vars.push_back(ecal_track_state.mom_[0]);
    track_state_vars.push_back(ecal_track_state.mom_[1]);
    track_state_vars.push_back(ecal_track_state.mom_[2]);
 
    // index track by total momentum into output
    new_track_states.emplace_back(total_momentum, std::move(track_state_vars));
  }
 
  // filters to get only the [ele_count] number of highest momentum tracks
  std::sort(new_track_states.begin(), new_track_states.end(),
            [](const auto& a, const auto& b) {
              return a.first > b.first;
            });  // sort descending
  if (new_track_states.size() > ele_count) new_track_states.resize(ele_count);
 
  // Outputs the [ele_count] track states themselves without the momentum
  // indexing
  std::vector<std::vector<float>> max_p_track_states;
  max_p_track_states.reserve(new_track_states.size());
  std::transform(std::make_move_iterator(new_track_states.begin()),
                 std::make_move_iterator(new_track_states.end()),
                 std::back_inserter(max_p_track_states),
                 [](auto&& ts) { return std::move(ts.second); });
 
  return max_p_track_states;
}

References ecal::momTrackProp().

Referenced by ecal::momTrackProp().

pTTrackProp()

std::vector< std::vector< float > > ecal::pTTrackProp	(	const ldmx::Tracks &	tracks,
		int	ele_count )

Return a vector of ele_count valid track states with the greatest transverse momentum.

Parameters

[in]	tracks	The track collection
[in]	ele_count	The recorded number of electrons in the event

Returns

Vector of valid track states with the greatest transverse momentum

Definition at line 47 of file EcalHelper.cxx.

                                                           {
  // Vector to hold the new track state variables, indexed by pT
  std::vector<std::pair<float, std::vector<float>>> new_track_states;
 
  // Return empty vector if no tracks
  if (tracks.empty()) return {};
 
  // Otherwise loop on the tracks
  for (auto& track : tracks) {
    // Vector to hold track state parameters for a single track
    std::vector<float> track_state_vars;
    track_state_vars.reserve(6);
    // Get track state for Ecal
    auto trk_ts = track.getTrackState(ldmx::TrackStateType::AtECAL);
    // Continue if there's no value
    if (!trk_ts.has_value()) continue;
    ldmx::Track::TrackState ecal_track_state = trk_ts.value();
 
    // Check that the track state is filled
    if (ecal_track_state.pos_.size() < 3 || ecal_track_state.mom_.size() < 3)
      continue;
 
    // Calculate transverse momentum
    float transverse_momentum =
        sqrt((ecal_track_state.mom_[0] * ecal_track_state.mom_[0]) +
             (ecal_track_state.mom_[1] * ecal_track_state.mom_[1]));
 
    // store state variables
    track_state_vars.push_back(ecal_track_state.pos_[0]);
    track_state_vars.push_back(ecal_track_state.pos_[1]);
    track_state_vars.push_back(ecal_track_state.pos_[2]);
    track_state_vars.push_back(ecal_track_state.mom_[0]);
    track_state_vars.push_back(ecal_track_state.mom_[1]);
    track_state_vars.push_back(ecal_track_state.mom_[2]);
 
    // index track by total momentum into output
    new_track_states.emplace_back(transverse_momentum,
                                  std::move(track_state_vars));
  }
 
  // filters to get only the [ele_count] number of highest pT tracks
  std::sort(new_track_states.begin(), new_track_states.end(),
            [](const auto& a, const auto& b) {
              return a.first > b.first;
            });  // sort descending
  if (new_track_states.size() > ele_count) new_track_states.resize(ele_count);
 
  // Outputs the 'ele_count' track states themselves without the momentum
  // indexing
  std::vector<std::vector<float>> max_p_t_track_states;
  max_p_t_track_states.reserve(new_track_states.size());
  std::transform(std::make_move_iterator(new_track_states.begin()),
                 std::make_move_iterator(new_track_states.end()),
                 std::back_inserter(max_p_t_track_states),
                 [](auto&& ts) { return std::move(ts.second); });
 
  return max_p_t_track_states;
}

References ecal::pTTrackProp().

Referenced by ecal::EcalRecoilRemovalProcessor::produce(), and ecal::pTTrackProp().

trackProp()

std::vector< float > ecal::trackProp	(	const ldmx::Tracks &	tracks,
		ldmx::TrackStateType	ts_type,
		const std::string &	ts_title )

Return a vector of parameters for a propagated recoil track.

Parameters

[in]	tracks	The track collection
[in]	ts_type	The track state type, i.e. tracks state at the ECAL face
[in]	ts_title	The track state title, most likely "ecal"

Returns

Vector of parameters for a propagated recoil track

Definition at line 7 of file EcalHelper.cxx.

                                                        {
  // Vector to hold the new track state variables
  std::vector<float> new_track_states;
 
  // Return if no tracks
  if (tracks.empty()) return new_track_states;
 
  // Otherwise loop on the tracks
  for (auto& track : tracks) {
    // Get track state for ts_type
    auto trk_ts = track.getTrackState(ts_type);
    // Continue if there's no value
    if (!trk_ts.has_value()) continue;
    ldmx::Track::TrackState ecal_track_state = trk_ts.value();
 
    // Check that the track state is filled
    if (ecal_track_state.pos_.size() < 3 || ecal_track_state.mom_.size() < 3)
      continue;
 
    // pos_ is (x, y, z) in mm (LDMX global); mom_ is (px, py, pz) in MeV
    new_track_states.push_back(static_cast<float>(ecal_track_state.pos_[0]));
    new_track_states.push_back(static_cast<float>(ecal_track_state.pos_[1]));
    new_track_states.push_back(static_cast<float>(ecal_track_state.pos_[2]));
    new_track_states.push_back(static_cast<float>(ecal_track_state.mom_[0]));
    new_track_states.push_back(static_cast<float>(ecal_track_state.mom_[1]));
    new_track_states.push_back(static_cast<float>(ecal_track_state.mom_[2]));
 
    // Break after getting the first valid track state
    // TODO: interface this with CLUE to make sure the propagated track
    //       has an associated cluster in the ECAL
    break;
  }
 
  return new_track_states;
}

References ecal::trackProp().

Referenced by ecal::EcalPnetVetoProcessor::produce(), ecal::EcalVetoProcessor::produce(), and ecal::trackProp().