tracking::reco::TruthSeedProcessor Class Reference

Create a track seed using truth information extracted from the corresponding SimParticle or SimTrackerHit. More...

#include <TruthSeedProcessor.h>

Public Member Functions
	TruthSeedProcessor (const std::string &name, framework::Process &process)
	Constructor.
virtual	~TruthSeedProcessor ()=default
	Destructor.
void	configure (framework::config::Parameters &parameters) override
	Callback for the EventProcessor to configure itself from the given set of parameters.
void	onProcessStart () override
	Callback for the EventProcessor to take any necessary action when the processing of events starts.
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	produce (framework::Event &event) override
	Main loop that creates the seed tracks for both the tagger and 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	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	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
void	makeHitCountMap (const std::vector< ldmx::SimTrackerHit > &sim_hits, std::map< int, std::vector< int > > &hit_count_map)
	Create a mapping from the selected scoring plane hit objects to the number of hits they associated particle creates in the tracker.
void	createTruthTrack (const ldmx::SimParticle &particle, ldmx::Track &trk, const std::shared_ptr< Acts::Surface > &target_surface)
	Use the vertex position of the SimParticle to extract (x_, y_, z_, px, py, pz, q) and create a track seed.
void	createTruthTrack (const ldmx::SimParticle &particle, const ldmx::SimTrackerHit &hit, ldmx::Track &trk, const std::shared_ptr< Acts::Surface > &target_surface)
	Use the scoring plane hit at the target to extract (x_, y_, z_, px, py, pz) and create a track seed.
void	createTruthTrack (const std::vector< double > &pos_vec, const std::vector< double > &p_vec, int charge, ldmx::Track &trk, const std::shared_ptr< Acts::Surface > &target_surface)
	Create a seed track from the given position, momentum and charge.
bool	scoringPlaneHitFilter (const ldmx::SimTrackerHit &hit, const std::vector< ldmx::SimTrackerHit > &ecal_sp_hits)
	Filter that checks if a scoring plane passes specified momentum cuts as well as if the associated SimParticle hits the ECal.
ldmx::Track	seedFromTruth (const ldmx::Track &tt, bool seed_smearing)
	Create a track seed from a truth track applying a smearing to the truth parameters as well as an inflation to the covariance matrix.
ldmx::Track	recoilFullSeed (const ldmx::SimParticle &particle, const int trackID, const ldmx::SimTrackerHit &hit, const ldmx::SimTrackerHit &ecal_hit, const std::map< int, std::vector< int > > &hit_count_map, const std::shared_ptr< Acts::Surface > &origin_surface, const std::shared_ptr< Acts::Surface > &target_surface, const std::shared_ptr< Acts::Surface > &ecal_surface)
ldmx::Track	taggerFullSeed (const ldmx::SimParticle &beam_electron, const int trackID, const ldmx::SimTrackerHit &hit, const std::map< int, std::vector< int > > &hit_count_map, const std::shared_ptr< Acts::Surface > &origin_surface, const std::shared_ptr< Acts::Surface > &target_surface)
	This method retrieves the beam electron and forms a full seed The seed parameters are the truth parameters from the beam electron stored at the beam origin Additionally, the foolowing track states are stored ts_smeared : the truth smeared perigee state at the beam origin ts_truth_target : the truth on-surface state at the target Linear extrapolations are done from the origin of the particle to the reference surfaces This track also contains the list of hits belonging to the beam electron on the sensitive surfaces on the tagger tracker, for acceptance studies.

Private Attributes
std::vector< int >	pdg_ids_ {11}
	pdg_ids of the particles we want to select for the seeds
std::string	scoring_hits_coll_name_ {"TargetScoringPlaneHits"}
	Which scoring plane hits to use for the truth seeds generation.
std::string	ecal_sp_coll_name_ {"EcalScoringPlaneHits"}
std::string	sp_pass_name_ {""}
std::string	tagger_sim_hits_coll_name_ {"TaggerSimHits"}
	Sim hits to check if the truth seed is findable.
std::string	recoil_sim_hits_coll_name_ {"RecoilSimHits"}
	Sim hits to check if the truth seed is findable.
std::string	input_pass_name_ {""}
	Pass name for the sim hit collections.
std::string	sim_particles_coll_name_
std::string	sim_particles_passname_
int	n_min_hits_tagger_ {7}
	Minimum number of hits left in the recoil tracker to consider the seed as findable.
int	n_min_hits_recoil_ {7}
	Minimum number of hits left in the recoil tracker to consider the seed as findable.
float	z_min_ {-999}
	Min cut on the z_ of the scoring hit.
int	track_id_ {-999}
	Only select a particular trackID.
double	pz_cut_ {-9999}
	Ask for a minimum pz for the seeds.
double	p_cut_ {0.}
	Ask for a minimum p for the seeds.
double	p_cut_max_ {100000.}
	Ask for a maximum p for the seeds.
double	p_cut_ecal_ {-1.}
bool	recoil_sp_ {true}
bool	target_sp_ {true}
bool	skip_tagger_ {false}
bool	skip_recoil_ {false}
int	max_track_id_ {5}
std::unique_ptr< const TruthPropagator >	propagator_
std::shared_ptr< tracking::reco::TrackExtrapolatorTool< TruthPropagator > >	trk_extrap_
std::string	field_map_ {""}
	Path to the magnetic field map.
std::default_random_engine	generator_
std::shared_ptr< std::normal_distribution< float > >	normal_
bool	seed_smearing_ {false}
std::vector< double >	d0smear_
std::vector< double >	z0smear_
double	phismear_
double	thetasmear_
double	relpsmear_
std::vector< double >	rel_smearfactors_
std::vector< double >	inflate_factors_
std::vector< double >	beam_origin_ {-880.1, -44., 0.}
int	particle_hypothesis_
std::string	beam_electrons_collection_
std::string	tagger_truth_collection_
std::string	recoil_truth_collection_
std::string	tagger_seeds_collection_
std::string	recoil_seeds_collection_

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 std::vector< double > &map_offset={0., 0., 0.})
	Load the interpolated B-field map from path and cache it.
void	loadBField (const std::vector< double > &map_offset={0., 0., 0.})
	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.
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

Create a track seed using truth information extracted from the corresponding SimParticle or SimTrackerHit.

When creating seeds in the Tagger tracker, the SimParticle associated with the incident electron (trackID == 1) is used to create the seed from the parameters (x_, y_, z_, px, py, pz, q) at the vertex. For the Recoil tracker, since the electron is produced upstream, the SimParticle can't be used to get any parameters at the target. In this case, the target scoring plane hits are used to extract the parameters above.

Definition at line 43 of file TruthSeedProcessor.h.

Constructor & Destructor Documentation

TruthSeedProcessor()

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

    : TrackingGeometryUser(name, process) {}

Member Function Documentation

configure()

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

overridevirtual

Callback for the EventProcessor to configure itself from the given set of parameters.

The parameters a processor has access to are the member variables of the python class in the sequence that has class_name equal to the EventProcessor class name.

Parameters

parameters

Parameters for configuration.

Reimplemented from framework::EventProcessor.

Definition at line 53 of file TruthSeedProcessor.cxx.

                                                                        {
  scoring_hits_coll_name_ =
      parameters.get<std::string>("scoring_hits_coll_name");
  ecal_sp_coll_name_ = parameters.get<std::string>("ecal_sp_coll_name");
  sp_pass_name_ = parameters.get<std::string>("sp_pass_name");
  recoil_sim_hits_coll_name_ =
      parameters.get<std::string>("recoil_sim_hits_coll_name");
  tagger_sim_hits_coll_name_ =
      parameters.get<std::string>("tagger_sim_hits_coll_name");
  input_pass_name_ = parameters.get<std::string>("input_pass_name");
  sim_particles_coll_name_ =
      parameters.get<std::string>("sim_particles_coll_name");
  sim_particles_passname_ =
      parameters.get<std::string>("sim_particles_passname");
 
  n_min_hits_tagger_ = parameters.get<int>("n_min_hits_tagger", 11);
  n_min_hits_recoil_ = parameters.get<int>("n_min_hits_recoil", 7);
  pdg_ids_ = parameters.get<std::vector<int>>("pdg_ids", {11});
  z_min_ = parameters.get<double>("z_min", -9999);  // mm
  track_id_ = parameters.get<int>("track_id", -9999);
  pz_cut_ = parameters.get<double>("pz_cut", -9999);  // MeV
  p_cut_ = parameters.get<double>("p_cut", 0.);
  p_cut_max_ = parameters.get<double>("p_cut_max", 100000.);  // MeV
  p_cut_ecal_ = parameters.get<double>("p_cut_ecal", -1.);    // MeV
  recoil_sp_ = parameters.get<double>("recoil_sp", true);
  target_sp_ = parameters.get<double>("tagger_sp", true);
  seed_smearing_ = parameters.get<bool>("seedSmearing", false);
  max_track_id_ = parameters.get<int>("max_track_id", 5);
 
  ldmx_log(info) << "Seed Smearing is set to " << seed_smearing_;
 
  d0smear_ = parameters.get<std::vector<double>>("d0smear", {0.01, 0.01, 0.01});
  z0smear_ = parameters.get<std::vector<double>>("z0smear", {0.1, 0.1, 0.1});
  phismear_ = parameters.get<double>("phismear", 0.001);
  thetasmear_ = parameters.get<double>("thetasmear", 0.001);
  relpsmear_ = parameters.get<double>("relpsmear", 0.1);
 
  // Relative smear factor terms, only used if seed_smearing_ is true.
  rel_smearfactors_ = parameters.get<std::vector<double>>(
      "rel_smearfactors", {0.1, 0.1, 0.1, 0.1, 0.1, 0.1});
  inflate_factors_ = parameters.get<std::vector<double>>(
      "inflate_factors", {10., 10., 10., 10., 10., 10.});
 
  // In tracking frame: where do these numbers come from?
  // These numbers come from approximating the path of the beam up
  // until it is about to enter the first detector volume (TriggerPad1).
  // In detector coordinates, (x_,y_,z_) = (-21.7, -883) is
  // where the beam arrives (if no smearing is applied) and we simply
  // reorder these values so that they are in tracking coordinates.
  beam_origin_ = parameters.get<std::vector<double>>("beamOrigin",
                                                     {-883.0, -21.745876, 0.0});
 
  // Skip the tagger or recoil trackers if wanted
  skip_tagger_ = parameters.get<bool>("skip_tagger", false);
  skip_recoil_ = parameters.get<bool>("skip_recoil", false);
  particle_hypothesis_ = parameters.get<int>("particle_hypothesis");
 
  beam_electrons_collection_ =
      parameters.get<std::string>("beam_electrons_collection");
  tagger_truth_collection_ =
      parameters.get<std::string>("tagger_truth_collection");
  recoil_truth_collection_ =
      parameters.get<std::string>("recoil_truth_collection");
  tagger_seeds_collection_ =
      parameters.get<std::string>("tagger_seeds_collection");
  recoil_seeds_collection_ =
      parameters.get<std::string>("recoil_seeds_collection");
  // Get the field map for the propagator
  field_map_ = parameters.get<std::string>("field_map");
}

References field_map_, framework::config::Parameters::get(), input_pass_name_, n_min_hits_recoil_, n_min_hits_tagger_, p_cut_, p_cut_max_, pdg_ids_, pz_cut_, recoil_sim_hits_coll_name_, scoring_hits_coll_name_, tagger_sim_hits_coll_name_, track_id_, and z_min_.

createTruthTrack() [1/3]

void tracking::reco::TruthSeedProcessor::createTruthTrack ( const ldmx::SimParticle & particle, const ldmx::SimTrackerHit & hit, ldmx::Track & trk, const std::shared_ptr< Acts::Surface > & target_surface )

private

Use the scoring plane hit at the target to extract (x_, y_, z_, px, py, pz) and create a track seed.

In this case, the SimParticle is used to extract the charge of the particle.

Parameters

particle	The SimParticle to extract the charge from.
hit	The SimTrackerHit used to create the seed.

Definition at line 124 of file TruthSeedProcessor.cxx.

                                                                      {
  std::vector<double> pos{static_cast<double>(hit.getPosition()[0]),
                          static_cast<double>(hit.getPosition()[1]),
                          static_cast<double>(hit.getPosition()[2])};
  createTruthTrack(pos, hit.getMomentum(), particle.getCharge(), trk,
                   target_surface);
 
  trk.setTrackID(hit.getTrackID());
  trk.setPdgID(hit.getPdgID());
}

References createTruthTrack(), ldmx::SimParticle::getCharge(), ldmx::SimTrackerHit::getMomentum(), ldmx::SimTrackerHit::getPdgID(), ldmx::SimTrackerHit::getPosition(), and ldmx::SimTrackerHit::getTrackID().

createTruthTrack() [2/3]

void tracking::reco::TruthSeedProcessor::createTruthTrack ( const ldmx::SimParticle & particle, ldmx::Track & trk, const std::shared_ptr< Acts::Surface > & target_surface )

private

Use the vertex position of the SimParticle to extract (x_, y_, z_, px, py, pz, q) and create a track seed.

Parameters

particle

The SimParticle to make a seed from.

Definition at line 137 of file TruthSeedProcessor.cxx.

                                                      {
  createTruthTrack(particle.getVertex(), particle.getMomentum(),
                   particle.getCharge(), trk, target_surface);
 
  trk.setPdgID(particle.getPdgID());
}

References createTruthTrack(), ldmx::SimParticle::getCharge(), ldmx::SimParticle::getMomentum(), ldmx::SimParticle::getPdgID(), and ldmx::SimParticle::getVertex().

Referenced by createTruthTrack(), createTruthTrack(), and taggerFullSeed().

createTruthTrack() [3/3]

void tracking::reco::TruthSeedProcessor::createTruthTrack ( const std::vector< double > & pos_vec, const std::vector< double > & p_vec, int charge, ldmx::Track & trk, const std::shared_ptr< Acts::Surface > & target_surface )

private

Create a seed track from the given position, momentum and charge.

Parameters

pos_	The position at which the particle was created.
p	The momentum of the particle at the point of creation.
charge	The charge of the particle.
target_surface	the surface to where to express the truth track

Definition at line 146 of file TruthSeedProcessor.cxx.

                                                      {
  // Get the position and momentum of the particle at the point of creation.
  // This only works for the incident electron when creating a tagger tracker
  // seed. For the recoil tracker, the scoring plane position will need to
  // be used.  For other particles created in the target or tracker planes,
  // this version of the method can also be used.
  // These are just Eigen vectors defined as
  // Eigen::Matrix<double, kSize, 1>;
  Acts::Vector3 pos{pos_vec[0], pos_vec[1], pos_vec[2]};
  Acts::Vector3 mom{p_vec[0], p_vec[1], p_vec[2]};
 
  // Rotate the position and momentum into the ACTS frame.
  pos = tracking::sim::utils::ldmx2Acts(pos);
  mom = tracking::sim::utils::ldmx2Acts(mom);
 
  // Get the charge of the particle.
  // TODO: Add function that uses the PDG ID to calculate this.
  double q{charge * Acts::UnitConstants::e};
 
  // The idea here is:
  // 1 - Define a bound track state parameters at point P on track. Basically a
  // curvilinear representation.
  // 2 - Propagate to target surface to obtain the
  // BoundTrackState there.
 
  // Transform the position, momentum and charge to free parameters.
  auto free_params{tracking::sim::utils::toFreeParameters(pos, mom, q)};
 
  // Create a line surface at the perigee.  The perigee position is extracted
  // from a particle's vertex or the particle's position at a specific
  // scoring plane.
  auto gen_surface{Acts::Surface::makeShared<Acts::PerigeeSurface>(
      Acts::Vector3(free_params[Acts::eFreePos0], free_params[Acts::eFreePos1],
                    free_params[Acts::eFreePos2]))};
 
  // ldmx_log(trace)<<"PF:: gen_surface"<<free_params[Acts::eFreePos0]<<"
  // " <<free_params[Acts::eFreePos1]<<" " <<free_params[Acts::eFreePos2];
 
  // Transform the parameters to local positions on the perigee surface.
  auto bound_params{Acts::transformFreeToBoundParameters(
                        free_params, *gen_surface, geometryContext())
                        .value()};
  // Create a particle hypothesis
  auto part{Acts::ParticleHypothesis(Acts::PdgParticle(particle_hypothesis_))};
  Acts::BoundTrackParameters bound_trk_pars(gen_surface, bound_params,
                                            std::nullopt, part);
 
  auto prop_bound_state =
      trk_extrap_->extrapolate(bound_trk_pars, target_surface);
 
  if (!prop_bound_state) {
    ldmx_log(warn) << "Propagation to target surface failed — "
                   << "track may have exited the B-field map.";
    return;
  }
 
  // Create the seed track object.
  Acts::Vector3 ref = target_surface->center(geometryContext());
  Acts::Vector3 ref_ldmx = tracking::sim::utils::acts2Ldmx(ref);
  trk.setPerigeeLocation(ref_ldmx(0), ref_ldmx(1), ref_ldmx(2));
 
  auto prop_bound_vec = prop_bound_state->parameters();
 
  trk.setPerigeeParameters(
      tracking::sim::utils::convertActsToLdmxPars(prop_bound_vec));
}

makeHitCountMap()

void tracking::reco::TruthSeedProcessor::makeHitCountMap ( const std::vector< ldmx::SimTrackerHit > & sim_hits, std::map< int, std::vector< int > > & hit_count_map )

private

Create a mapping from the selected scoring plane hit objects to the number of hits they associated particle creates in the tracker.

Parameters

sim_hits	vector
hit_count_map	filled with the hits lefts by each track

Definition at line 467 of file TruthSeedProcessor.cxx.

                                                {
  for (int i_sim_hit = 0; i_sim_hit < sim_hits.size(); i_sim_hit++) {
    auto& sim_hit = sim_hits.at(i_sim_hit);
    // This track never left a hit before
    if (!hit_count_map.count(sim_hit.getTrackID())) {
      hit_count_map[sim_hit.getTrackID()].push_back(i_sim_hit);
    }
 
    // This track left a hit before.
    // Check if it's on a different sensor than the others
 
    else {
      int sensor_id = tracking::sim::utils::getSensorID(sim_hit);
      bool found_hit = false;
 
      for (auto& i_rhit : hit_count_map[sim_hit.getTrackID()]) {
        int tmp_sensor_id =
            tracking::sim::utils::getSensorID(sim_hits.at(i_rhit));
 
        if (sensor_id == tmp_sensor_id) {
          found_hit = true;
          break;
        }
      }  // loop on the already recorded hits
 
      if (!found_hit) {
        hit_count_map[sim_hit.getTrackID()].push_back(i_sim_hit);
      }
    }
  }  // loop on sim hits
}

Referenced by produce().

onNewRun()

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

                                                         {
  normal_ = std::make_shared<std::normal_distribution<float>>(0., 1.);
 
  // Custom transformation of the interpolated bfield map
  auto transform_pos = [](const Acts::Vector3& pos_) {
    Acts::Vector3 rot_pos;
    rot_pos(0) = pos_(1);
    rot_pos(1) = pos_(2);
    rot_pos(2) = pos_(0) + DIPOLE_OFFSET;
    return rot_pos;
  };
 
  auto transform_b_field = [](const Acts::Vector3& field,
                              const Acts::Vector3& /*pos_*/) {
    Acts::Vector3 rot_field;
    rot_field(0) = field(2);
    rot_field(1) = field(0);
    rot_field(2) = field(1);
    return rot_field;
  };
 
  // Setup the interpolated bfield map
  const auto map = std::make_shared<InterpolatedMagneticField3>(
      loadDefaultBField(field_map_, transform_pos, transform_b_field));
 
  // Setup the stepper and navigator
  const auto stepper = Acts::EigenStepper<>{map};
  Acts::Navigator::Config nav_cfg{geometry().getTG()};
  nav_cfg.resolveMaterial = true;
  nav_cfg.resolvePassive = true;
  nav_cfg.resolveSensitive = true;
  const Acts::Navigator navigator(nav_cfg);
 
  propagator_ = std::make_unique<TruthPropagator>(
      stepper, navigator,
      Acts::getDefaultLogger("TruthPropagator", Acts::Logging::FATAL));
  trk_extrap_ = std::make_shared<std::decay_t<decltype(*trk_extrap_)>>(
      *propagator_, geometryContext(), magneticFieldContext());
  trk_extrap_->setMaxStepSize(200);  // mm
  trk_extrap_->setPathLimit(3000);   // mm
}

References field_map_.

onProcessStart()

void tracking::reco::TruthSeedProcessor::onProcessStart ( )

inlineoverridevirtual

Callback for the EventProcessor to take any necessary action when the processing of events starts.

For this class, the callback is used to retrieve the GeometryContext from ACTS.

Reimplemented from framework::EventProcessor.

Definition at line 74 of file TruthSeedProcessor.h.

{};

produce()

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

overridevirtual

Main loop that creates the seed tracks for both the tagger and recoil tracker.

Parameters

event

The event containing the collections to process.

Implements framework::Producer.

Definition at line 555 of file TruthSeedProcessor.cxx.

                                                      {
  // Retrieve the particleMap
  auto particle_map{event.getMap<int, ldmx::SimParticle>(
      sim_particles_coll_name_, sim_particles_passname_)};
 
  // Retrieve the target scoring hits
  // Information is extracted using the
  // scoring plane hit left by the particle at the target.
 
  const auto& scoring_hits = event.getCollection<ldmx::SimTrackerHit>(
      scoring_hits_coll_name_, sp_pass_name_);
 
  // Retrieve the sim hits in the tagger tracker
  const auto& tagger_sim_hits = event.getCollection<ldmx::SimTrackerHit>(
      tagger_sim_hits_coll_name_, input_pass_name_);
 
  // Retrieve the sim hits in the recoil tracker
  const auto& recoil_sim_hits = event.getCollection<ldmx::SimTrackerHit>(
      recoil_sim_hits_coll_name_, input_pass_name_);
 
  // If sim hit collections are empty throw a warning
  if (tagger_sim_hits.size() == 0 && !skip_tagger_) {
    ldmx_log(error) << "Tagger sim hits collection empty for event ";
  }
  if (recoil_sim_hits.size() == 0 && !skip_recoil_) {
    ldmx_log(error) << "Recoil sim hits collection empty for event ";
  }
 
  // The map stores which track leaves which sim hits
  std::map<int, std::vector<int>> hit_count_map_recoil;
  makeHitCountMap(recoil_sim_hits, hit_count_map_recoil);
 
  std::map<int, std::vector<int>> hit_count_map_tagger;
  makeHitCountMap(tagger_sim_hits, hit_count_map_tagger);
 
  // to keep track of how many sim particles leave hits on the scoring plane
  std::vector<int> recoil_sh_idxs;
  std::unordered_map<int, std::vector<int>> recoil_sh_count_map;
 
  std::vector<int> tagger_sh_idxs;
  std::unordered_map<int, std::vector<int>> tagger_sh_count_map;
 
  // Target scoring hits for Tagger will have Z<0, Recoil scoring hits will
  // have Z>0
  for (unsigned int i_sh = 0; i_sh < scoring_hits.size(); i_sh++) {
    const ldmx::SimTrackerHit& hit = scoring_hits.at(i_sh);
    double zhit = hit.getPosition()[2];
 
    Acts::Vector3 p_vec{hit.getMomentum()[0], hit.getMomentum()[1],
                        hit.getMomentum()[2]};
    double tagger_p_max = 0.;
 
    // Check if it is a tagger track going fwd that passes basic cuts
    if (zhit < 0.) {
      // Tagger selection cuts
      // Negative scoring plane hit, with momentum > p_cut
      if (p_vec(2) < 0. || p_vec.norm() < p_cut_) continue;
 
      // Check that the hit was left by a charged particle
      if (abs(particle_map[hit.getTrackID()].getCharge()) < 1e-8) continue;
 
      if (p_vec.norm() > tagger_p_max) {
        tagger_sh_count_map[hit.getTrackID()].push_back(i_sh);
      }
    }  // Tagger loop
 
    // Check the recoil hits
    else {
      // Recoil selection cuts
      // Positive scoring plane hit, forward direction with momentum > p_cut
      if (p_vec(2) < 0. || p_vec.norm() < p_cut_) continue;
 
      // Check that the hit was left by a charged particle
      if (abs(particle_map[hit.getTrackID()].getCharge()) < 1e-8) continue;
 
      recoil_sh_count_map[hit.getTrackID()].push_back(i_sh);
 
    }  // Recoil
  }  // loop on Target scoring plane hits
 
  for (std::pair<int, std::vector<int>> element : recoil_sh_count_map) {
    std::sort(
        element.second.begin(), element.second.end(),
        [&](const int idx1, int idx2) -> bool {
          const ldmx::SimTrackerHit& hit1 = scoring_hits.at(idx1);
          const ldmx::SimTrackerHit& hit2 = scoring_hits.at(idx2);
 
          Acts::Vector3 phit1{hit1.getMomentum()[0], hit1.getMomentum()[1],
                              hit1.getMomentum()[2]};
          Acts::Vector3 phit2{hit2.getMomentum()[0], hit2.getMomentum()[1],
                              hit2.getMomentum()[2]};
 
          return phit1.norm() > phit2.norm();
        });
  }
 
  // Sort tagger hits.
  for (auto& [_track_id, hit_indices] : tagger_sh_count_map) {
    std::sort(
        hit_indices.begin(), hit_indices.end(),
        [&](const int idx1, int idx2) -> bool {
          const ldmx::SimTrackerHit& hit1 = scoring_hits.at(idx1);
          const ldmx::SimTrackerHit& hit2 = scoring_hits.at(idx2);
 
          Acts::Vector3 phit1{hit1.getMomentum()[0], hit1.getMomentum()[1],
                              hit1.getMomentum()[2]};
          Acts::Vector3 phit2{hit2.getMomentum()[0], hit2.getMomentum()[1],
                              hit2.getMomentum()[2]};
 
          return phit1.norm() > phit2.norm();
        });
  }
 
  // Building of the event truth information and the truth seeds
  // TODO remove the truthtracks in the future as the truth seeds are enough
 
  std::vector<ldmx::Track> tagger_truth_tracks;
  std::vector<ldmx::Track> tagger_truth_seeds;
  std::vector<ldmx::Track> recoil_truth_tracks;
  std::vector<ldmx::Track> recoil_truth_seeds;
  std::vector<ldmx::Track> beam_electrons;
 
  // TODO:: The target should be taken from some conditions DB in the future.
  // Define the perigee_surface at 0.0.0
  auto target_surface{Acts::Surface::makeShared<Acts::PerigeeSurface>(
      Acts::Vector3(0., 0., 0.))};
 
  // Define the target_surface
  auto target_unbound_surface = tracking::sim::utils::unboundSurface(0.);
 
  // ecal
  auto ecal_surface = tracking::sim::utils::unboundSurface(240.5);
 
  auto beam_origin_surface{Acts::Surface::makeShared<Acts::PerigeeSurface>(
      Acts::Vector3(beam_origin_[0], beam_origin_[1], beam_origin_[2]))};
 
  if (!skip_tagger_) {
    for (const auto& [track_id, hit_indices] : tagger_sh_count_map) {
      const ldmx::SimTrackerHit& hit = scoring_hits.at(hit_indices.at(0));
      const ldmx::SimParticle& phit = particle_map[hit.getTrackID()];
 
      if (hit_count_map_tagger[hit.getTrackID()].size() > n_min_hits_tagger_) {
        ldmx::Track truth_tagger_track;
        createTruthTrack(phit, hit, truth_tagger_track, target_surface);
        truth_tagger_track.setNhits(
            hit_count_map_tagger[hit.getTrackID()].size());
        // Add AtTarget state from the scoring plane hit (pos in mm, mom in MeV,
        // both already in LDMX global frame)
        ldmx::Track::TrackState ts_target;
        ts_target.pos_ = {hit.getPosition()[0], hit.getPosition()[1],
                          hit.getPosition()[2]};
        ts_target.mom_ = {hit.getMomentum()[0], hit.getMomentum()[1],
                          hit.getMomentum()[2]};
        ts_target.ts_type_ = ldmx::AtTarget;
        truth_tagger_track.addTrackState(ts_target);
        tagger_truth_tracks.push_back(truth_tagger_track);
 
        if (hit.getPdgID() == 11 && hit.getTrackID() < max_track_id_) {
          ldmx::Track beam_e_truth_seed =
              taggerFullSeed(particle_map[hit.getTrackID()], hit.getTrackID(),
                             hit, hit_count_map_tagger, beam_origin_surface,
                             target_unbound_surface);
          beam_electrons.push_back(beam_e_truth_seed);
        }
      }
    }
  }
 
  // Recover the EcalScoring hits
  const auto& ecal_sp_hits = event.getCollection<ldmx::SimTrackerHit>(
      ecal_sp_coll_name_, sp_pass_name_);
  // Select ECAL hits
  std::vector<ldmx::SimTrackerHit> sel_ecal_sp_hits;
 
  for (auto sp_hit : ecal_sp_hits) {
    if (sp_hit.getMomentum()[2] > 0 && ((sp_hit.getID() & 0xfff) == 31)) {
      sel_ecal_sp_hits.push_back(sp_hit);
    }
  }
 
  // Recoil target surface for truth and seed tracks is the target
 
  for (std::pair<int, std::vector<int>> element : recoil_sh_count_map) {
    // Only take the first entry of the vector: it should be the scoring plane
    // hit with the highest momentum.
    const ldmx::SimTrackerHit& hit = scoring_hits.at(element.second.at(0));
    const ldmx::SimParticle& phit = particle_map[hit.getTrackID()];
    ldmx::SimTrackerHit ecal_hit;
 
    bool found_ecal_hit = false;
    for (auto ecal_sp_hit : sel_ecal_sp_hits) {
      if (ecal_sp_hit.getTrackID() == hit.getTrackID()) {
        ecal_hit = ecal_sp_hit;
        found_ecal_hit = true;
        break;
      }
    }
 
    // Findable particle selection
    // ldmx_log(trace) << "!!! n_recoil_sim_hits found: " <<
    // hit_count_map_recoil[hit.getTrackID()].size();
    if (hit_count_map_recoil[hit.getTrackID()].size() > n_min_hits_recoil_ &&
        found_ecal_hit && !skip_recoil_) {
      ldmx::Track truth_recoil_track;
      createTruthTrack(phit, hit, truth_recoil_track, target_surface);
      truth_recoil_track.setTrackID(hit.getTrackID());
 
      // AtTarget state from target scoring plane hit (pos mm, mom MeV, LDMX
      // frame)
      ldmx::Track::TrackState ts_target;
      ts_target.pos_ = {hit.getPosition()[0], hit.getPosition()[1],
                        hit.getPosition()[2]};
      ts_target.mom_ = {hit.getMomentum()[0], hit.getMomentum()[1],
                        hit.getMomentum()[2]};
      ts_target.ts_type_ = ldmx::AtTarget;
      truth_recoil_track.addTrackState(ts_target);
 
      // Express truth ECAL state in the bound parametrization of ecal_surface
      // (same surface definition used by CKFProcessor).
      {
        Acts::Vector3 ep{ecal_hit.getPosition()[0], ecal_hit.getPosition()[1],
                         ecal_hit.getPosition()[2]};
        Acts::Vector3 em{ecal_hit.getMomentum()[0], ecal_hit.getMomentum()[1],
                         ecal_hit.getMomentum()[2]};
        ep = tracking::sim::utils::ldmx2Acts(ep);
        em = tracking::sim::utils::ldmx2Acts(em);
        // Linearly extrapolate transverse coordinates to ACTS x = 240.5 mm
        // (= LDMX z = 240.5 mm), correcting for the track slope over the small
        // z-offset between the scoring plane and the ECAL surface.
        if (std::abs(em[0]) > 0) {
          double delta = 240.5 - ep[0];
          ep[1] += delta * em[1] / em[0];
          ep[2] += delta * em[2] / em[0];
          ep[0] = 240.5;
        }
        double q_ecal = phit.getCharge() * Acts::UnitConstants::e;
        auto ecal_free = tracking::sim::utils::toFreeParameters(ep, em, q_ecal);
        auto ecal_bound = Acts::transformFreeToBoundParameters(
            ecal_free, *ecal_surface, geometryContext());
        if (ecal_bound.ok()) {
          auto part{Acts::ParticleHypothesis(
              Acts::PdgParticle(particle_hypothesis_))};
          Acts::BoundTrackParameters ecal_pars(ecal_surface, ecal_bound.value(),
                                               Acts::BoundMatrix::Identity(),
                                               part);
          truth_recoil_track.addTrackState(tracking::sim::utils::makeTrackState(
              geometryContext(), ecal_pars, ldmx::AtECAL));
        }
      }
 
      // Attach sim hit indices
      int nhits = 0;
      for (auto sim_hit_idx : hit_count_map_recoil.at(hit.getTrackID())) {
        truth_recoil_track.addMeasurementIndex(sim_hit_idx);
        nhits++;
      }
      truth_recoil_track.setNhits(nhits);
 
      recoil_truth_tracks.push_back(truth_recoil_track);
    }
  }
 
  /*
    for (std::pair<int,std::vector<int>> element : recoil_sh_count_map) {
 
    const ldmx::SimTrackerHit& hit  = scoring_hits.at(element.second.at(0));
    const ldmx::SimParticle&   phit = particleMap[hit.getTrackID()];
 
    if (hit_count_map_recoil[hit.getTrackID()].size() > n_min_hits_recoil_) {
    ldmx::Track truth_recoil_track;
    createTruthTrack(phit,hit,truth_recoil_track,targetSurface);
    truth_recoil_track.setNhits(hit_count_map_recoil[hit.getTrackID()].size());
    recoil_truth_tracks.push_back(truth_recoil_track);
    }
    }
  */
 
  // Form a truth seed from a truth track
 
  for (auto& tt : tagger_truth_tracks) {
    ldmx::Track seed = seedFromTruth(tt, seed_smearing_);
 
    tagger_truth_seeds.push_back(seed);
  }
 
  ldmx_log(debug) << "Forming seeds from truth";
  for (auto& tt : recoil_truth_tracks) {
    ldmx_log(debug) << "Smearing truth track";
 
    ldmx::Track seed = seedFromTruth(tt, seed_smearing_);
 
    recoil_truth_seeds.push_back(seed);
  }
 
  // even if skip_tagger/recoil_ is true, still make the collections in the
  // event
  event.add(beam_electrons_collection_, beam_electrons);
  event.add(tagger_truth_collection_, tagger_truth_tracks);
  event.add(recoil_truth_collection_, recoil_truth_tracks);
  event.add(tagger_seeds_collection_, tagger_truth_seeds);
  event.add(recoil_seeds_collection_, recoil_truth_seeds);
}

References ldmx::SimTrackerHit::getMomentum(), ldmx::SimTrackerHit::getPosition(), ldmx::SimTrackerHit::getTrackID(), input_pass_name_, makeHitCountMap(), p_cut_, recoil_sim_hits_coll_name_, scoring_hits_coll_name_, and tagger_sim_hits_coll_name_.

recoilFullSeed()

ldmx::Track tracking::reco::TruthSeedProcessor::recoilFullSeed ( const ldmx::SimParticle & particle, const int trackID, const ldmx::SimTrackerHit & hit, const ldmx::SimTrackerHit & ecal_hit, const std::map< int, std::vector< int > > & hit_count_map, const std::shared_ptr< Acts::Surface > & origin_surface, const std::shared_ptr< Acts::Surface > & target_surface, const std::shared_ptr< Acts::Surface > & ecal_surface )

private

Definition at line 218 of file TruthSeedProcessor.cxx.

                                                    {
  ldmx::Track truth_recoil_track;
  createTruthTrack(particle, hit, truth_recoil_track, origin_surface);
  truth_recoil_track.setTrackID(trackID);
 
  // Seed at the target location
  ldmx::Track smeared_truth_track = seedFromTruth(truth_recoil_track, false);
 
  // Add truth track state at the target: use scoring plane hit (already LDMX
  // frame)
  ldmx::Track::TrackState ts_truth_target;
  ts_truth_target.pos_ = {hit.getPosition()[0], hit.getPosition()[1],
                          hit.getPosition()[2]};
  ts_truth_target.mom_ = {hit.getMomentum()[0], hit.getMomentum()[1],
                          hit.getMomentum()[2]};
  ts_truth_target.ts_type_ = ldmx::AtTarget;
  smeared_truth_track.addTrackState(ts_truth_target);
 
  // Express truth ECAL state in the bound parametrization of ecal_surface
  // (same surface definition used by CKFProcessor) rather than storing raw
  // scoring plane hit coordinates.
  {
    Acts::Vector3 ep{ecal_hit.getPosition()[0], ecal_hit.getPosition()[1],
                     ecal_hit.getPosition()[2]};
    Acts::Vector3 em{ecal_hit.getMomentum()[0], ecal_hit.getMomentum()[1],
                     ecal_hit.getMomentum()[2]};
    ep = tracking::sim::utils::ldmx2Acts(ep);
    em = tracking::sim::utils::ldmx2Acts(em);
    // Linearly extrapolate transverse coordinates to ACTS x = 240.5 mm
    // (= LDMX z = 240.5 mm), correcting for the track slope over the small
    // z-offset between the scoring plane and the ECAL surface.
    if (std::abs(em[0]) > 0) {
      double delta = 240.5 - ep[0];
      ep[1] += delta * em[1] / em[0];
      ep[2] += delta * em[2] / em[0];
      ep[0] = 240.5;
    }
    double q_ecal = particle.getCharge() * Acts::UnitConstants::e;
    auto ecal_free = tracking::sim::utils::toFreeParameters(ep, em, q_ecal);
    auto ecal_bound = Acts::transformFreeToBoundParameters(
        ecal_free, *ecal_surface, geometryContext());
    if (ecal_bound.ok()) {
      auto part{
          Acts::ParticleHypothesis(Acts::PdgParticle(particle_hypothesis_))};
      Acts::BoundTrackParameters ecal_pars(ecal_surface, ecal_bound.value(),
                                           Acts::BoundMatrix::Identity(), part);
      smeared_truth_track.addTrackState(tracking::sim::utils::makeTrackState(
          geometryContext(), ecal_pars, ldmx::AtECAL));
    }
  }
 
  // Add the hits
  int nhits = 0;
 
  for (auto sim_hit_idx : hit_count_map.at(smeared_truth_track.getTrackID())) {
    smeared_truth_track.addMeasurementIndex(sim_hit_idx);
    nhits += 1;
  }
 
  smeared_truth_track.setNhits(nhits);
 
  return smeared_truth_track;
}

scoringPlaneHitFilter()

bool tracking::reco::TruthSeedProcessor::scoringPlaneHitFilter ( const ldmx::SimTrackerHit & hit, const std::vector< ldmx::SimTrackerHit > & ecal_sp_hits )

private

Filter that checks if a scoring plane passes specified momentum cuts as well as if the associated SimParticle hits the ECal.

Parameters

hit	The target scoring plane hit to check.
ecal_sp_hits	The ECal scoring plane hit used to check if the associated particle hits the ECal.

Definition at line 501 of file TruthSeedProcessor.cxx.

                                                      {
  // Clean some of the hits we don't want
  if (hit.getPosition()[2] < z_min_) return false;
 
  // Check if the track_id was requested
  if (track_id_ > 0 && hit.getTrackID() != track_id_) return false;
 
  // Check if we are requesting particular particles
  if (std::find(pdg_ids_.begin(), pdg_ids_.end(), hit.getPdgID()) ==
      pdg_ids_.end())
    return false;
 
  Acts::Vector3 p_vec{hit.getMomentum()[0], hit.getMomentum()[1],
                      hit.getMomentum()[2]};
 
  // p cut
  if (p_cut_ >= 0. && p_vec.norm() < p_cut_) return false;
 
  // p cut Max
  if (p_cut_ < 100000. && p_vec.norm() > p_cut_max_) return false;
 
  // pz cut
  if (pz_cut_ > -9999 && p_vec(2) < pz_cut_) return false;
 
  // Check the ecal scoring plane
  bool pass_ecal_scoring_plane = true;
 
  if (p_cut_ecal_ > 0) {  // only check if we care about it.
 
    for (auto& e_sp_hit : ecal_sp_hits) {
      if (e_sp_hit.getTrackID() == hit.getTrackID() &&
          e_sp_hit.getPdgID() == hit.getPdgID()) {
        Acts::Vector3 e_sp_p{e_sp_hit.getMomentum()[0],
                             e_sp_hit.getMomentum()[1],
                             e_sp_hit.getMomentum()[2]};
 
        if (e_sp_p.norm() < p_cut_ecal_) pass_ecal_scoring_plane = false;
 
        // Skip the rest of the scoring plane hits since we already found the
        // track we care about
        break;
 
      }  // check that the hit belongs to the inital particle from the target
         // scoring plane hit
    }  // loop on Ecal scoring plane hits
  }  // pcutEcal
 
  if (!pass_ecal_scoring_plane) return false;
 
  return true;
}

References ldmx::SimTrackerHit::getMomentum(), ldmx::SimTrackerHit::getPdgID(), ldmx::SimTrackerHit::getPosition(), ldmx::SimTrackerHit::getTrackID(), p_cut_, p_cut_max_, pdg_ids_, pz_cut_, track_id_, and z_min_.

seedFromTruth()

ldmx::Track tracking::reco::TruthSeedProcessor::seedFromTruth ( const ldmx::Track & tt, bool seed_smearing )

private

Create a track seed from a truth track applying a smearing to the truth parameters as well as an inflation to the covariance matrix.

Parameters

tt	TruthTrack to be used to form a seed

Returns

seed The seed track

Definition at line 353 of file TruthSeedProcessor.cxx.

                                                                  {
  ldmx::Track seed = ldmx::Track();
  seed.setPerigeeLocation(tt.getPerigeeLocation()[0],
                          tt.getPerigeeLocation()[1],
                          tt.getPerigeeLocation()[2]);
  seed.setChi2(0.);
  seed.setNhits(tt.getNhits());
  seed.setNdf(0);
  seed.setNsharedHits(0);
  seed.setTrackID(tt.getTrackID());
  seed.setPdgID(tt.getPdgID());
  seed.setTruthProb(1.);
 
  Acts::BoundVector bound_params;
  Acts::BoundVector stddev;
 
  if (seed_smearing) {
    ldmx_log(debug) << "Smear track and inflate covariance";
 
    /*
      double sigma_d0     = rel_smearfactors_[Acts::eBoundLoc0]   * tt.getD0();
      double sigma_z0     = rel_smearfactors_[Acts::eBoundLoc1]   * tt.getZ0();
      double sigma_phi    = rel_smearfactors_[Acts::eBoundPhi]    * tt.getPhi();
      double sigma_theta  = rel_smearfactors_[Acts::eBoundTheta]  *
      tt.getTheta(); double sigma_p      = rel_smearfactors_[Acts::eBoundQOverP]
      * abs(1/tt.getQoP()); double sigma_t      =
      rel_smearfactors_[Acts::eBoundTime]   * tt.getT();
    */
 
    double sigma_d0 = d0smear_[0];
    double sigma_z0 = z0smear_[0];
    double sigma_phi = phismear_;
    double sigma_theta = thetasmear_;
    double sigma_p = relpsmear_ * abs(1 / tt.getQoP());
    double sigma_t = 1. * Acts::UnitConstants::ns;
 
    double smear = (*normal_)(generator_);
    double d0smear = tt.getD0() + smear * sigma_d0;
 
    smear = (*normal_)(generator_);
    double z0smear = tt.getZ0() + smear * sigma_z0;
 
    smear = (*normal_)(generator_);
    double phismear = tt.getPhi() + smear * sigma_phi;
 
    smear = (*normal_)(generator_);
    double thetasmear = tt.getTheta() + smear * sigma_theta;
 
    double p = std::abs(1. / tt.getQoP());
    smear = (*normal_)(generator_);
    double psmear = p + smear * sigma_p;
 
    double q = tt.getQoP() < 0 ? -1. : 1.;
    double qo_psmear = q / psmear;
 
    smear = (*normal_)(generator_);
    double tsmear = tt.getT() + smear * sigma_t;
 
    bound_params << d0smear, z0smear, phismear, thetasmear, qo_psmear, tsmear;
 
    stddev[Acts::eBoundLoc0] =
        inflate_factors_[Acts::eBoundLoc0] * sigma_d0 * Acts::UnitConstants::mm;
    stddev[Acts::eBoundLoc1] =
        inflate_factors_[Acts::eBoundLoc1] * sigma_z0 * Acts::UnitConstants::mm;
    stddev[Acts::eBoundPhi] = inflate_factors_[Acts::eBoundPhi] * sigma_phi;
    stddev[Acts::eBoundTheta] =
        inflate_factors_[Acts::eBoundTheta] * sigma_theta;
    stddev[Acts::eBoundQOverP] =
        inflate_factors_[Acts::eBoundQOverP] * (1. / p) * (1. / p) * sigma_p;
    stddev[Acts::eBoundTime] =
        inflate_factors_[Acts::eBoundTime] * sigma_t * Acts::UnitConstants::ns;
 
    ldmx_log(debug) << stddev;
 
    std::vector<double> v_seed_params(
        (bound_params).data(),
        bound_params.data() + bound_params.rows() * bound_params.cols());
 
    Acts::BoundMatrix bound_cov = stddev.cwiseProduct(stddev).asDiagonal();
    std::vector<double> v_seed_cov;
    tracking::sim::utils::flatCov(bound_cov, v_seed_cov);
    seed.setPerigeeParameters(v_seed_params);
    seed.setPerigeeCov(v_seed_cov);
 
  } else {
    // Do not smear the seed
 
    bound_params << tt.getD0(), tt.getZ0(), tt.getPhi(), tt.getTheta(),
        tt.getQoP(), tt.getT();
 
    std::vector<double> v_seed_params(
        (bound_params).data(),
        bound_params.data() + bound_params.rows() * bound_params.cols());
 
    double p = std::abs(1. / tt.getQoP());
    double sigma_p = 0.75 * p * Acts::UnitConstants::GeV;
    stddev[Acts::eBoundLoc0] = 2 * Acts::UnitConstants::mm;
    stddev[Acts::eBoundLoc1] = 5 * Acts::UnitConstants::mm;
    stddev[Acts::eBoundTime] = 1000 * Acts::UnitConstants::ns;
    stddev[Acts::eBoundPhi] = 5 * Acts::UnitConstants::degree;
    stddev[Acts::eBoundTheta] = 5 * Acts::UnitConstants::degree;
    stddev[Acts::eBoundQOverP] = (1. / p) * (1. / p) * sigma_p;
 
    Acts::BoundMatrix bound_cov = stddev.cwiseProduct(stddev).asDiagonal();
    std::vector<double> v_seed_cov;
    tracking::sim::utils::flatCov(bound_cov, v_seed_cov);
    seed.setPerigeeParameters(v_seed_params);
    seed.setPerigeeCov(v_seed_cov);
  }
 
  return seed;
}

Referenced by taggerFullSeed().

taggerFullSeed()

ldmx::Track tracking::reco::TruthSeedProcessor::taggerFullSeed ( const ldmx::SimParticle & beam_electron, const int trackID, const ldmx::SimTrackerHit & hit, const std::map< int, std::vector< int > > & hit_count_map, const std::shared_ptr< Acts::Surface > & origin_surface, const std::shared_ptr< Acts::Surface > & target_surface )

private

This method retrieves the beam electron and forms a full seed The seed parameters are the truth parameters from the beam electron stored at the beam origin Additionally, the foolowing track states are stored ts_smeared : the truth smeared perigee state at the beam origin ts_truth_target : the truth on-surface state at the target Linear extrapolations are done from the origin of the particle to the reference surfaces This track also contains the list of hits belonging to the beam electron on the sensitive surfaces on the tagger tracker, for acceptance studies.

Parameters

beam_electron	: the beam electron particle
hit	: the scoring hit at the target from the beam electron particle survived
hit_count_map	: the sim hit on track map
origin_surface	: where to express the track origin parameters. Can be perigee, plane...
target_surface	: the target surface for the truth target state

Definition at line 288 of file TruthSeedProcessor.cxx.

                                                      {
  ldmx::Track truth_track;
 
  createTruthTrack(beam_electron, truth_track, origin_surface);
  truth_track.setTrackID(trackID);
 
  // Smeared track at the beam origin
  ldmx::Track smeared_truth_track = seedFromTruth(truth_track, true);
 
  ldmx_log(debug) << "Truth parameters at beam origin";
  for (auto par : truth_track.getPerigeeParameters())
    ldmx_log(debug) << par << " ";
  ldmx_log(debug);
 
  // Add the truth track state at the target using the scoring plane hit
  // (position and momentum are already in LDMX global frame)
  ldmx::Track::TrackState ts_truth_target;
  ts_truth_target.pos_ = {hit.getPosition()[0], hit.getPosition()[1],
                          hit.getPosition()[2]};
  ts_truth_target.mom_ = {hit.getMomentum()[0], hit.getMomentum()[1],
                          hit.getMomentum()[2]};
  ts_truth_target.ts_type_ = ldmx::AtTarget;
  smeared_truth_track.addTrackState(ts_truth_target);
 
  ldmx_log(debug) << "Truth position at target: " << hit.getPosition()[0] << " "
                  << hit.getPosition()[1] << " " << hit.getPosition()[2];
 
  // Add the truth track state at the beam origin using particle vertex/momentum
  // (SimParticle vertex and momentum are in LDMX global frame)
  ldmx::Track::TrackState ts_truth_beam_origin;
  ts_truth_beam_origin.pos_ = {beam_electron.getVertex()[0],
                               beam_electron.getVertex()[1],
                               beam_electron.getVertex()[2]};
  ts_truth_beam_origin.mom_ = {beam_electron.getMomentum()[0],
                               beam_electron.getMomentum()[1],
                               beam_electron.getMomentum()[2]};
  ts_truth_beam_origin.ts_type_ = ldmx::AtBeamOrigin;
  smeared_truth_track.addTrackState(ts_truth_beam_origin);
 
  ldmx_log(debug) << "Smeared parameters at origin";
  for (auto par : smeared_truth_track.getPerigeeParameters())
    ldmx_log(debug) << par << " ";
 
  // assign the sim hit indices
  // TODO this is not fully correct as the sim hits
  // might be duplicated on sensors
  // and should be merged if that is the case
 
  int nhits = 0;
 
  for (auto sim_hit_idx : hit_count_map.at(smeared_truth_track.getTrackID())) {
    smeared_truth_track.addMeasurementIndex(sim_hit_idx);
    nhits += 1;
  }
 
  smeared_truth_track.setNhits(nhits);
 
  return smeared_truth_track;
}

References createTruthTrack(), ldmx::SimParticle::getMomentum(), ldmx::SimTrackerHit::getMomentum(), ldmx::SimTrackerHit::getPosition(), ldmx::SimParticle::getVertex(), and seedFromTruth().

Member Data Documentation

beam_electrons_collection_

std::string tracking::reco::TruthSeedProcessor::beam_electrons_collection_

private

Definition at line 286 of file TruthSeedProcessor.h.

beam_origin_

std::vector<double> tracking::reco::TruthSeedProcessor::beam_origin_ {-880.1, -44., 0.}

private

Definition at line 283 of file TruthSeedProcessor.h.

{-880.1, -44., 0.};

d0smear_

std::vector<double> tracking::reco::TruthSeedProcessor::d0smear_

private

Definition at line 276 of file TruthSeedProcessor.h.

ecal_sp_coll_name_

std::string tracking::reco::TruthSeedProcessor::ecal_sp_coll_name_ {"EcalScoringPlaneHits"}

private

Definition at line 197 of file TruthSeedProcessor.h.

{"EcalScoringPlaneHits"};

field_map_

std::string tracking::reco::TruthSeedProcessor::field_map_ {""}

private

Path to the magnetic field map.

Definition at line 267 of file TruthSeedProcessor.h.

{""};

Referenced by configure(), and onNewRun().

generator_

std::default_random_engine tracking::reco::TruthSeedProcessor::generator_

private

Definition at line 271 of file TruthSeedProcessor.h.

inflate_factors_

std::vector<double> tracking::reco::TruthSeedProcessor::inflate_factors_

private

Definition at line 282 of file TruthSeedProcessor.h.

input_pass_name_

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

private

Pass name for the sim hit collections.

Definition at line 207 of file TruthSeedProcessor.h.

{""};

Referenced by configure(), and produce().

max_track_id_

int tracking::reco::TruthSeedProcessor::max_track_id_ {5}

private

Definition at line 258 of file TruthSeedProcessor.h.

{5};

n_min_hits_recoil_

int tracking::reco::TruthSeedProcessor::n_min_hits_recoil_ {7}

private

Minimum number of hits left in the recoil tracker to consider the seed as findable.

Definition at line 222 of file TruthSeedProcessor.h.

{7};

Referenced by configure().

n_min_hits_tagger_

int tracking::reco::TruthSeedProcessor::n_min_hits_tagger_ {7}

private

Minimum number of hits left in the recoil tracker to consider the seed as findable.

Definition at line 216 of file TruthSeedProcessor.h.

{7};

Referenced by configure().

normal_

std::shared_ptr<std::normal_distribution<float> > tracking::reco::TruthSeedProcessor::normal_

private

Definition at line 272 of file TruthSeedProcessor.h.

p_cut_

double tracking::reco::TruthSeedProcessor::p_cut_ {0.}

private

Ask for a minimum p for the seeds.

Definition at line 237 of file TruthSeedProcessor.h.

{0.};

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

p_cut_ecal_

double tracking::reco::TruthSeedProcessor::p_cut_ecal_ {-1.}

private

Definition at line 243 of file TruthSeedProcessor.h.

{-1.};

p_cut_max_

double tracking::reco::TruthSeedProcessor::p_cut_max_ {100000.}

private

Ask for a maximum p for the seeds.

Definition at line 240 of file TruthSeedProcessor.h.

{100000.};

Referenced by configure(), and scoringPlaneHitFilter().

particle_hypothesis_

int tracking::reco::TruthSeedProcessor::particle_hypothesis_

private

Definition at line 284 of file TruthSeedProcessor.h.

pdg_ids_

std::vector<int> tracking::reco::TruthSeedProcessor::pdg_ids_ {11}

private

pdg_ids of the particles we want to select for the seeds

Definition at line 193 of file TruthSeedProcessor.h.

{11};

Referenced by configure(), and scoringPlaneHitFilter().

phismear_

double tracking::reco::TruthSeedProcessor::phismear_

private

Definition at line 278 of file TruthSeedProcessor.h.

propagator_

std::unique_ptr<const TruthPropagator> tracking::reco::TruthSeedProcessor::propagator_

private

Definition at line 260 of file TruthSeedProcessor.h.

pz_cut_

double tracking::reco::TruthSeedProcessor::pz_cut_ {-9999}

private

Ask for a minimum pz for the seeds.

Definition at line 234 of file TruthSeedProcessor.h.

{-9999};

Referenced by configure(), and scoringPlaneHitFilter().

recoil_seeds_collection_

std::string tracking::reco::TruthSeedProcessor::recoil_seeds_collection_

private

Definition at line 290 of file TruthSeedProcessor.h.

recoil_sim_hits_coll_name_

std::string tracking::reco::TruthSeedProcessor::recoil_sim_hits_coll_name_ {"RecoilSimHits"}

private

Sim hits to check if the truth seed is findable.

Definition at line 204 of file TruthSeedProcessor.h.

{"RecoilSimHits"};

Referenced by configure(), and produce().

recoil_sp_

bool tracking::reco::TruthSeedProcessor::recoil_sp_ {true}

private

Definition at line 246 of file TruthSeedProcessor.h.

{true};

recoil_truth_collection_

std::string tracking::reco::TruthSeedProcessor::recoil_truth_collection_

private

Definition at line 288 of file TruthSeedProcessor.h.

rel_smearfactors_

std::vector<double> tracking::reco::TruthSeedProcessor::rel_smearfactors_

private

Definition at line 281 of file TruthSeedProcessor.h.

relpsmear_

double tracking::reco::TruthSeedProcessor::relpsmear_

private

Definition at line 280 of file TruthSeedProcessor.h.

scoring_hits_coll_name_

std::string tracking::reco::TruthSeedProcessor::scoring_hits_coll_name_ {"TargetScoringPlaneHits"}

private

Which scoring plane hits to use for the truth seeds generation.

Definition at line 196 of file TruthSeedProcessor.h.

{"TargetScoringPlaneHits"};

Referenced by configure(), and produce().

seed_smearing_

bool tracking::reco::TruthSeedProcessor::seed_smearing_ {false}

private

Definition at line 274 of file TruthSeedProcessor.h.

{false};

sim_particles_coll_name_

std::string tracking::reco::TruthSeedProcessor::sim_particles_coll_name_

private

Definition at line 209 of file TruthSeedProcessor.h.

sim_particles_passname_

std::string tracking::reco::TruthSeedProcessor::sim_particles_passname_

private

Definition at line 210 of file TruthSeedProcessor.h.

skip_recoil_

bool tracking::reco::TruthSeedProcessor::skip_recoil_ {false}

private

Definition at line 255 of file TruthSeedProcessor.h.

{false};

skip_tagger_

bool tracking::reco::TruthSeedProcessor::skip_tagger_ {false}

private

Definition at line 252 of file TruthSeedProcessor.h.

{false};

sp_pass_name_

std::string tracking::reco::TruthSeedProcessor::sp_pass_name_ {""}

private

Definition at line 198 of file TruthSeedProcessor.h.

{""};

tagger_seeds_collection_

std::string tracking::reco::TruthSeedProcessor::tagger_seeds_collection_

private

Definition at line 289 of file TruthSeedProcessor.h.

tagger_sim_hits_coll_name_

std::string tracking::reco::TruthSeedProcessor::tagger_sim_hits_coll_name_ {"TaggerSimHits"}

private

Sim hits to check if the truth seed is findable.

Definition at line 201 of file TruthSeedProcessor.h.

{"TaggerSimHits"};

Referenced by configure(), and produce().

tagger_truth_collection_

std::string tracking::reco::TruthSeedProcessor::tagger_truth_collection_

private

Definition at line 287 of file TruthSeedProcessor.h.

target_sp_

bool tracking::reco::TruthSeedProcessor::target_sp_ {true}

private

Definition at line 249 of file TruthSeedProcessor.h.

{true};

thetasmear_

double tracking::reco::TruthSeedProcessor::thetasmear_

private

Definition at line 279 of file TruthSeedProcessor.h.

track_id_

int tracking::reco::TruthSeedProcessor::track_id_ {-999}

private

Only select a particular trackID.

Definition at line 231 of file TruthSeedProcessor.h.

{-999};

Referenced by configure(), and scoringPlaneHitFilter().

trk_extrap_

std::shared_ptr<tracking::reco::TrackExtrapolatorTool<TruthPropagator> > tracking::reco::TruthSeedProcessor::trk_extrap_

private

Definition at line 264 of file TruthSeedProcessor.h.

z0smear_

std::vector<double> tracking::reco::TruthSeedProcessor::z0smear_

private

Definition at line 277 of file TruthSeedProcessor.h.

z_min_

float tracking::reco::TruthSeedProcessor::z_min_ {-999}

private

Min cut on the z_ of the scoring hit.

It could be used to clean the scoring hits if desired.

Definition at line 228 of file TruthSeedProcessor.h.

{-999};

Referenced by configure(), and scoringPlaneHitFilter().

---

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

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