tracking::reco::GSFProcessor Class Reference

Public Member Functions
	GSFProcessor (const std::string &name, framework::Process &process)
	Constructor.
virtual	~GSFProcessor ()=default
	Destructor.
void	onProcessStart () override
	Callback for the EventProcessor to take any necessary action when the processing of events starts, such as creating histograms.
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	onProcessEnd () override
	Callback for the EventProcessor to take any necessary action when the processing of events finishes, such as calculating job-summary quantities.
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	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.
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 Attributes
int	nevents_ {0}
int	n_input_tracks_ {0}
int	n_gsf_failed_ {0}
int	n_output_tracks_ {0}
int	n_target_extrap_failed_ {0}
int	n_ecal_extrap_failed_ {0}
double	processing_time_ {0.}
bool	debug_ {false}
	Enable verbose debug output logging.
std::default_random_engine	generator_
	Random number generator for smearing operations.
std::shared_ptr< std::normal_distribution< float > >	normal_
	Normal distribution for smearing measurements.
std::vector< double >	extrapolate_location_ {0., 0., 0.}
	Location to extrapolate tracks to (x, y, z in mm)
std::string	measurement_collection_ {"TaggerMeasurements"}
	Collection name for input measurements.
std::string	out_trk_collection_ {"GSFTracks"}
	Collection name for output GSF-refitted tracks.
std::string	seed_coll_name_ {"seedTracks"}
	Collection name for seed tracks (currently unused)
std::unique_ptr< const Acts::GaussianSumFitter< GsfPropagator, Acts::VectorMultiTrajectory > >	gsf_
	Gaussian Sum Fitter instance for track refitting.
std::string	track_collection_ {"TaggerTracks"}
	Collection name for input tracks to be refit.
std::string	meas_collection_ {"DigiTaggerSimHits"}
	Collection name for measurements associated with tracks.
std::string	track_passname_
	Pass name for track collection in event.
std::string	meas_passname_
	Pass name for measurement collection in event.
std::string	track_collection_event_passname_
	Pass name qualifier for track collection event key.
std::string	meas_collection_event_passname_
	Pass name qualifier for measurement collection event key.
size_t	max_components_ {4}
	Maximum number of mixture components in GSF fit.
bool	abort_on_error_ {false}
	Abort fit if any error occurs (strict error handling)
bool	disable_all_material_handling_ {false}
	Disable all material interactions during propagation.
double	weight_cutoff_ {1.0e-4}
	Weight threshold below which mixture components are dropped.
double	propagator_step_size_ {200.}
	Step size for track propagation in mm.
int	propagator_max_steps_ {1000}
	Maximum number of propagation steps before aborting.
std::string	field_map_ {""}
	Path to magnetic field map file.
bool	use_perigee_ {false}
	Use perigee parameterization for tracks.
bool	tagger_tracking_ {true}
std::unique_ptr< const Propagator >	propagator_
	Propagator for track extrapolation using eigen stepper.
std::unordered_map< unsigned int, const Acts::Surface * >	layer_surface_map_
	Layer ID to ACTS Surface mapping for hit surface lookup.
std::unique_ptr< const GsfExtrapPropagator >	propagator_extrap_
std::shared_ptr< tracking::reco::TrackExtrapolatorTool< GsfExtrapPropagator > >	trk_extrap_
std::shared_ptr< Acts::Surface >	beam_origin_surface_
	Beam origin surface at z=-700 mm (tagger post-fit extrapolation via VoidNavigator)
std::shared_ptr< Acts::Surface >	tagger_start_surface_
	Tagger GSF start surface at x≈-617mm in ACTS (1mm inside tagger volume outer boundary ~-618mm, 1.5mm upstream of L1 sensors at x=-615.5mm)
std::shared_ptr< Acts::Surface >	target_surface_
	Target surface at z=0 mm (recoil track initialization, perigee output)
std::shared_ptr< Acts::Surface >	ecal_surface_
	ECAL surface at z=240.5 mm (ECAL scoring plane for recoil tracking)

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

Definition at line 102 of file GSFProcessor.h.

Constructor & Destructor Documentation

GSFProcessor()

tracking::reco::GSFProcessor::GSFProcessor	(	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 GSFProcessor.cxx.

    : TrackingGeometryUser(name, process) {}

Member Function Documentation

configure()

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

                                                                  {
  out_trk_collection_ =
      parameters.get<std::string>("out_trk_collection", "GSFTracks");
 
  track_collection_ =
      parameters.get<std::string>("track_collection", "TaggerTracks");
  meas_collection_ =
      parameters.get<std::string>("meas_collection", "DigiTaggerSimHits");
 
  track_passname_ = parameters.get<std::string>("track_passname");
  meas_passname_ = parameters.get<std::string>("meas_passname");
  track_collection_event_passname_ =
      parameters.get<std::string>("track_collection_event_passname");
  meas_collection_event_passname_ =
      parameters.get<std::string>("meas_collection_event_passname");
 
  max_components_ = parameters.get<int>("max_components", 4);
  abort_on_error_ = parameters.get<bool>("abort_on_error", false);
  disable_all_material_handling_ =
      parameters.get<bool>("disable_all_material_handling", false);
  weight_cutoff_ = parameters.get<double>("weight_cutoff_", 1.0e-4);
 
  propagator_max_steps_ = parameters.get<int>("propagator_max_steps", 10000);
  propagator_step_size_ = parameters.get<double>("propagator_step_size", 200.);
  field_map_ = parameters.get<std::string>("field_map");
  use_perigee_ = parameters.get<bool>("usePerigee", false);
 
  debug_ = parameters.get<bool>("debug", false);
  tagger_tracking_ = parameters.get<bool>("tagger_tracking", true);
 
  // final_reduction_method_ =
  // parameters.get<double>("finalReductionMethod",);
}  // end of configure()

References abort_on_error_, debug_, disable_all_material_handling_, field_map_, framework::config::Parameters::get(), max_components_, meas_collection_, meas_collection_event_passname_, meas_passname_, out_trk_collection_, propagator_max_steps_, propagator_step_size_, track_collection_, track_collection_event_passname_, track_passname_, use_perigee_, and weight_cutoff_.

onNewRun()

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

                                                   {
  beam_origin_surface_ = tracking::sim::utils::unboundSurface(-700);
  // 1mm inside tagger ACTS volume outer boundary (~-618mm), 1.5mm upstream of
  // L1 at x=-615.5mm
  tagger_start_surface_ = tracking::sim::utils::unboundSurface(-617.);
  target_surface_ = tracking::sim::utils::unboundSurface(0.);
  ecal_surface_ = tracking::sim::utils::unboundSurface(240.5);
 
  // Setup a interpolated bfield map
  if (field_map_.empty())
    loadBField();
  else
    loadBField(field_map_);
  const auto map =
      std::static_pointer_cast<InterpolatedMagneticField3>(bField());
 
  auto acts_logging_level = Acts::Logging::FATAL;
 
  if (debug_) acts_logging_level = Acts::Logging::VERBOSE;
 
  // Setup the GSF Fitter
 
  // Stepper
  // Acts::MixtureReductionMethod finalReductionMethod;
  // const auto multi_stepper = Acts::MultiEigenStepperLoop{map};
 
  // Acts::ComponentMergeMethod reductionMethod =
  //    Acts::ComponentMergeMethod::eMaxWeight;
  //  Acts::MultiEigenStepperLoop multi_stepper(
  //      map, reductionMethod,
  //      Acts::getDefaultLogger("GSF_STEP", acts_loggingLevel));
 
  Acts::MultiEigenStepperLoop multi_stepper(map);
  // Detailed Stepper
 
  // Acts::MultiEigenStepperLoop multi_stepper(map, finalReductionMethod);
 
  // Navigator
  Acts::Navigator::Config nav_cfg{geometry().getTG()};
  nav_cfg.resolveMaterial = true;
  nav_cfg.resolvePassive = false;
  nav_cfg.resolveSensitive = true;
  const Acts::Navigator navigator(nav_cfg);
 
  auto gsf_propagator =
      GsfPropagator(std::move(multi_stepper), std::move(navigator),
                    Acts::getDefaultLogger("GSF_PROP", acts_logging_level));
 
  auto bethe_heitler = std::make_shared<Acts::PolynomialBetheHeitlerApprox>(
      Acts::makeDefaultBetheHeitlerApprox());
 
  gsf_ = std::make_unique<std::decay_t<decltype(*gsf_)>>(
      std::move(gsf_propagator), std::move(bethe_heitler),
      Acts::getDefaultLogger("GSF", acts_logging_level));
 
  const auto stepper = Acts::EigenStepper<>{map};
  propagator_ = std::make_unique<Propagator>(
      stepper, navigator,
      Acts::getDefaultLogger("GSF_EXTRAP", acts_logging_level));
 
  propagator_extrap_ = std::make_unique<GsfExtrapPropagator>(
      Acts::EigenStepper<>{map}, Acts::VoidNavigator{});
  trk_extrap_ = std::make_shared<std::decay_t<decltype(*trk_extrap_)>>(
      *propagator_extrap_, geometryContext(), magneticFieldContext());
}

References beam_origin_surface_, tracking::reco::TrackingGeometryUser::bField(), debug_, ecal_surface_, field_map_, gsf_, tracking::reco::TrackingGeometryUser::loadBField(), propagator_, tagger_start_surface_, and target_surface_.

onProcessEnd()

void tracking::reco::GSFProcessor::onProcessEnd ( )

overridevirtual

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

Reimplemented from framework::EventProcessor.

Definition at line 465 of file GSFProcessor.cxx.

                                {
  ldmx_log(info) << "--------------------------------- ";
  ldmx_log(info) << "GSF: " << n_output_tracks_ << " output tracks / "
                 << n_input_tracks_ << " input tracks";
  ldmx_log(info) << "AVG Time/Event: " << std::fixed << std::setprecision(1)
                 << processing_time_ / nevents_ << " ms";
  ldmx_log(info) << "GSF Fit Failures: " << n_gsf_failed_;
  ldmx_log(info) << "Extrapolation Failures::";
  ldmx_log(info) << "  Target: " << n_target_extrap_failed_ << " times";
  if (!tagger_tracking_)
    ldmx_log(info) << "  ECAL:   " << n_ecal_extrap_failed_ << " times";
}

onProcessStart()

void tracking::reco::GSFProcessor::onProcessStart ( )

overridevirtual

Callback for the EventProcessor to take any necessary action when the processing of events starts, such as creating histograms.

Reimplemented from framework::EventProcessor.

Definition at line 463 of file GSFProcessor.cxx.

{}

produce()

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

overridevirtual

Run the processor.

Parameters

event

The event to process.

Implements framework::Producer.

Definition at line 116 of file GSFProcessor.cxx.

                                                {
  auto t_start = std::chrono::high_resolution_clock::now();
 
  // General Setup
 
  auto tg{geometry()};
 
  // Retrieve the tracks
  if (!event.exists(track_collection_, track_collection_event_passname_))
    return;
  const auto& tracks =
      event.getCollection<ldmx::Track>(track_collection_, track_passname_);
 
  // Retrieve the measurements
  if (!event.exists(meas_collection_, meas_collection_event_passname_)) return;
  const auto& measurements =
      event.getCollection<ldmx::Measurement>(meas_collection_, meas_passname_);
 
  tracking::sim::LdmxMeasurementCalibrator calibrator{measurements};
 
  // GSF Setup
  Acts::GainMatrixUpdater updater;
  Acts::GsfExtensions<Acts::VectorMultiTrajectory> gsf_extensions;
  gsf_extensions.updater.connect<
      &Acts::GainMatrixUpdater::operator()<Acts::VectorMultiTrajectory>>(
      &updater);
  gsf_extensions.calibrator
      .connect<&tracking::sim::LdmxMeasurementCalibrator::calibrate1d<
          Acts::VectorMultiTrajectory>>(&calibrator);
 
  // Surface Accessor
  struct SurfaceAccessor {
    const Acts::TrackingGeometry* tracking_geometry_;
 
    const Acts::Surface* operator()(const Acts::SourceLink& sourceLink) const {
      const auto& index_source_link =
          sourceLink.get<acts_examples::IndexSourceLink>();
      return tracking_geometry_->findSurface(index_source_link.geometryId());
    }
  };
 
  SurfaceAccessor m_sl_surface_accessor{tg.getTG().get()};
  // m_slSurfaceAccessor.trackingGeometry = tg.getTG();
  gsf_extensions.surfaceAccessor.connect<&SurfaceAccessor::operator()>(
      &m_sl_surface_accessor);
  gsf_extensions.mixtureReducer.connect<&Acts::reduceMixtureLargestWeights>();
 
  // Propagator Options
 
  // Move this at the start of the producer
  Acts::PropagatorOptions<Acts::StepperPlainOptions,
                          Acts::NavigatorPlainOptions, ActionList>
      propagator_options(geometryContext(), magneticFieldContext());
 
  propagator_options.pathLimit = std::numeric_limits<double>::max();
 
  // Activate loop protection at some pt value
  propagator_options.loopProtection = false;
  //(startParameters.transverseMomentum() < cfg.ptLoopers);
 
  // Switch the material interaction on/off & eventually into logging mode
  auto& m_interactor =
      propagator_options.actorList.get<Acts::MaterialInteractor>();
  m_interactor.multipleScattering = true;
  m_interactor.energyLoss = true;
  m_interactor.recordInteractions = false;
 
  // The logger can be switched to sterile, e.g. for timing logging
  auto& s_logger =
      propagator_options.actorList.get<Acts::detail::SteppingLogger>();
  s_logger.sterile = true;
  // Set a maximum step size
  propagator_options.stepping.maxStepSize =
      propagator_step_size_ * Acts::UnitConstants::mm;
  propagator_options.maxSteps = propagator_max_steps_;
 
  // Electron hypothesis
  //  propagator_options.mass = 0.511 * Acts::UnitConstants::MeV;
 
  // GSF options will be configured per-track
  std::shared_ptr<const Acts::Surface> gsf_ref_surface;
  Acts::GsfOptions<Acts::VectorMultiTrajectory> gsf_options{
      geometryContext(), magneticFieldContext(), calibrationContext()};
  gsf_options.extensions = gsf_extensions;
  gsf_options.propagatorPlainOptions =
      static_cast<Acts::PropagatorPlainOptions>(propagator_options);
  gsf_options.maxComponents = max_components_;
  gsf_options.weightCutoff = weight_cutoff_;
  gsf_options.abortOnError = abort_on_error_;
  gsf_options.disableAllMaterialHandling = disable_all_material_handling_;
 
  // Output track container
  std::vector<ldmx::Track> out_tracks;
 
  Acts::VectorTrackContainer vtc;
  Acts::VectorMultiTrajectory mtj;
  Acts::TrackContainer tc{vtc, mtj};
 
  // Loop on tracks
  n_input_tracks_ += static_cast<int>(tracks.size());
 
  unsigned int itrk = 0;
  int n_gsf_ok_evt = 0;
  int n_tgt_fail_evt = 0;
  ldmx_log(debug) << "Starting GSF processing of " << tracks.size()
                  << " tracks";
 
  for (auto& track : tracks) {
    ldmx_log(debug) << "Processing track " << itrk << " with "
                    << track.getMeasurementsIdxs().size() << " measurements";
    // Retrieve measurements on track
    std::vector<ldmx::Measurement> meas_on_track;
 
    // std::vector<ActsExamples::IndexSourceLink> fit_trackSourceLinks;
    std::vector<Acts::SourceLink> fit_track_source_links;
 
    for (auto imeas : track.getMeasurementsIdxs()) {
      auto meas = measurements.at(imeas);
      meas_on_track.push_back(meas);
 
      // Retrieve the surface
 
      const Acts::Surface* hit_surface =
          tg.geo::TrackingGeometry::getSurface(meas.getLayerID());
 
      // Store the index source link
      acts_examples::IndexSourceLink idx_sl(hit_surface->geometryId(), imeas);
      fit_track_source_links.push_back(Acts::SourceLink(idx_sl));
    }
 
    // Reverse the order of the vectors
    std::reverse(meas_on_track.begin(), meas_on_track.end());
    std::reverse(fit_track_source_links.begin(), fit_track_source_links.end());
 
    for (auto m : meas_on_track) {
      ldmx_log(trace) << "    Measurement:\n" << m << "\n";
    }
 
    ldmx_log(debug) << "  Track bound track parameters preparation:";
 
    // Reconstruct BoundTrackParameters at perigee (target) from stored params.
    // perigee_ is stored in LDMX frame; rotate to ACTS frame for surface
    // creation.
    Acts::Vector3 perigee_acts = tracking::sim::utils::ldmx2Acts(Acts::Vector3(
        track.getPerigeeX(), track.getPerigeeY(), track.getPerigeeZ()));
    std::shared_ptr<Acts::PerigeeSurface> perigee =
        Acts::Surface::makeShared<Acts::PerigeeSurface>(perigee_acts);
 
    Acts::BoundTrackParameters trk_btp =
        tracking::sim::utils::boundTrackParameters(track, perigee);
 
    Acts::BoundTrackParameters trk_btp_fit_start = trk_btp;
 
    // For tagger: backward-extrapolate (via VoidNavigator) from the target
    // perigee (x=0mm) to just inside the tagger outer boundary (x≈-650mm), then
    // run the GSF forward (+x) through L1→L7.  The CKF stores tagger track
    // perigees at the target, so we must back-propagate before handing off to
    // the GSF.
    if (tagger_tracking_) {
      auto opt_tagger_start =
          trk_extrap_->extrapolate(trk_btp, tagger_start_surface_);
      if (!opt_tagger_start) {
        ldmx_log(debug)
            << "  Failed pre-fit extrapolation to tagger start surface (itrk="
            << itrk << ")";
        ++n_gsf_failed_;
        continue;
      }
      trk_btp_fit_start = *opt_tagger_start;
    }
 
    ldmx_log(debug) << "    Perigee surface (acts): (" << track.getPerigeeX()
                    << ", " << track.getPerigeeY() << ", "
                    << track.getPerigeeZ() << ")";
 
    const Acts::BoundVector& trkpars = trk_btp.parameters();
    ldmx_log(debug) << "    Perigee parameters (d0, z0, phi, theta, q/p)= ("
                    << trkpars[Acts::eBoundLoc0] << ", "
                    << trkpars[Acts::eBoundLoc1] << ", "
                    << trkpars[Acts::eBoundPhi] << ", "
                    << trkpars[Acts::eBoundTheta] << ", "
                    << trkpars[Acts::eBoundQOverP] << ")";
 
    const Acts::BoundVector& fit_start_pars = trk_btp_fit_start.parameters();
    ldmx_log(debug) << "    GSF start parameters (d0, z0, phi, theta, q/p)= ("
                    << fit_start_pars[Acts::eBoundLoc0] << ", "
                    << fit_start_pars[Acts::eBoundLoc1] << ", "
                    << fit_start_pars[Acts::eBoundPhi] << ", "
                    << fit_start_pars[Acts::eBoundTheta] << ", "
                    << fit_start_pars[Acts::eBoundQOverP] << ")";
 
    ldmx_log(debug) << "  About to run GSF fit with "
                    << fit_track_source_links.size() << " source links";
 
    // GSF reference surface: for tagger use the start surface (x=-648mm, inside
    // geometry), for recoil use the target (x=0mm).
    if (tagger_tracking_) {
      gsf_ref_surface = tagger_start_surface_;
    } else {
      gsf_ref_surface = target_surface_;
    }
    gsf_options.referenceSurface = &(*gsf_ref_surface);
 
    auto gsf_refit_result =
        gsf_->fit(fit_track_source_links.begin(), fit_track_source_links.end(),
                  trk_btp_fit_start, gsf_options, tc);
 
    if (!gsf_refit_result.ok()) {
      ldmx_log(debug) << "  GSF re-fit failed (itrk=" << itrk
                      << "): " << gsf_refit_result.error().message();
      if (n_gsf_failed_ < 5)
        ldmx_log(info) << "  [GSF dbg] fit failed (first few): "
                       << gsf_refit_result.error().message();
      ++n_gsf_failed_;
      continue;
    }
 
    ++n_gsf_ok_evt;
    ldmx_log(debug) << "  GSF fit succeeded (itrk=" << itrk
                    << "), tc.size()=" << tc.size();
 
    auto gsftrk = gsf_refit_result.value();
    // calculateTrackQuantities(gsftrk);
 
    const Acts::BoundVector& perigee_pars = gsftrk.parameters();
    const Acts::BoundMatrix& trk_cov = gsftrk.covariance();
    const Acts::Surface& perigee_surface = gsftrk.referenceSurface();
 
    ldmx_log(debug) << "    Reference Surface (acts-x, acts-y, acts-z) = ("
                    << perigee_surface.localToGlobalTransform(geometryContext())
                           .translation()(0)
                    << ", "
                    << perigee_surface.localToGlobalTransform(geometryContext())
                           .translation()(1)
                    << ", "
                    << perigee_surface.localToGlobalTransform(geometryContext())
                           .translation()(2)
                    << ")";
 
    ldmx_log(debug) << "    nTrackStates=" << gsftrk.nTrackStates()
                    << " nMeasurements=" << gsftrk.nMeasurements()
                    << " chi2=" << gsftrk.chi2();
    if (gsftrk.nTrackStates() == 0)
      ldmx_log(info) << "  [GSF dbg] track has 0 states after fit (itrk="
                     << itrk << ");";
 
    ldmx_log(debug) << "    Track parameters (d0, z0, phi, theta, q/p)= ("
                    << perigee_pars[Acts::eBoundLoc0] << ", "
                    << perigee_pars[Acts::eBoundLoc1] << ", "
                    << perigee_pars[Acts::eBoundPhi] << ", "
                    << perigee_pars[Acts::eBoundTheta] << ", "
                    << perigee_pars[Acts::eBoundQOverP] << ") ";
 
    ldmx::Track trk;
 
    // Extrapolate GSF track to target surface to get perigee parameters
    auto opt_target = trk_extrap_->extrapolate(gsftrk, target_surface_);
 
    ldmx_log(debug) << "    Extrapolating to target (itrk=" << itrk << ")";
    if (opt_target) {
      ldmx_log(debug) << "    GSF target extrapolation succeeded";
      auto ts_at_target = tracking::sim::utils::makeTrackState(
          geometryContext(), *opt_target, ldmx::AtTarget);
      trk.addTrackState(ts_at_target);
 
      trk.setPerigeeParameters(tracking::sim::utils::convertActsToLdmxPars(
          opt_target->parameters()));
      if (opt_target->covariance()) {
        std::vector<double> cov_vec;
        tracking::sim::utils::flatCov(*(opt_target->covariance()), cov_vec);
        trk.setPerigeeCov(cov_vec);
      }
      Acts::Vector3 target_loc_ldmx = tracking::sim::utils::acts2Ldmx(
          target_surface_->localToGlobalTransform(geometryContext())
              .translation());
      trk.setPerigeeLocation(target_loc_ldmx[0], target_loc_ldmx[1],
                             target_loc_ldmx[2]);
 
      ldmx_log(debug)
          << "    GSF target parameters (d0, z0, phi, theta, q/p)= ("
          << opt_target->parameters()[Acts::eBoundLoc0] << ", "
          << opt_target->parameters()[Acts::eBoundLoc1] << ", "
          << opt_target->parameters()[Acts::eBoundPhi] << ", "
          << opt_target->parameters()[Acts::eBoundTheta] << ", "
          << opt_target->parameters()[Acts::eBoundQOverP] << ")";
    } else {
      ++n_target_extrap_failed_;
      ++n_tgt_fail_evt;
      ldmx_log(debug) << "    GSF target extrapolation failed (itrk=" << itrk
                      << "), using GSF fit parameters at reference surface";
      trk.setPerigeeParameters(
          tracking::sim::utils::convertActsToLdmxPars(perigee_pars));
      std::vector<double> v_trk_cov;
      tracking::sim::utils::flatCov(trk_cov, v_trk_cov);
      trk.setPerigeeCov(v_trk_cov);
    }
 
    // Tagger: also add beam-origin state; Recoil: add ECAL state
    if (tagger_tracking_) {
      auto opt_beam_origin =
          trk_extrap_->extrapolate(gsftrk, beam_origin_surface_);
      if (opt_beam_origin)
        trk.addTrackState(tracking::sim::utils::makeTrackState(
            geometryContext(), *opt_beam_origin, ldmx::AtBeamOrigin));
    } else {
      ldmx_log(debug) << "  ECAL extrapolation";
      auto opt_ecal = trk_extrap_->extrapolate(gsftrk, ecal_surface_);
      if (opt_ecal)
        trk.addTrackState(tracking::sim::utils::makeTrackState(
            geometryContext(), *opt_ecal, ldmx::AtECAL));
      else
        ++n_ecal_extrap_failed_;
    }
 
    trk.setChi2(gsftrk.chi2());
    trk.setNhits(gsftrk.nMeasurements());
    trk.setNdf(gsftrk.nMeasurements() - 5);
    trk.setCharge(perigee_pars[Acts::eBoundQOverP] > 0 ? 1 : -1);
 
    // Truth information carried over from input track
    trk.setTrackID(track.getTrackID());
    trk.setPdgID(track.getPdgID());
    trk.setTruthProb(track.getTruthProb());
 
    itrk++;
 
    ldmx_log(debug) << "  Added track to output, total tracks = "
                    << (out_tracks.size() + 1);
 
    out_tracks.push_back(trk);
 
  }  // loop on tracks
 
  ldmx_log(debug) << "[GSF evt " << nevents_ << "] in=" << tracks.size()
                  << " gsf_ok=" << n_gsf_ok_evt
                  << " tgt_fail=" << n_tgt_fail_evt
                  << " out=" << out_tracks.size();
 
  n_output_tracks_ += static_cast<int>(out_tracks.size());
  event.add(out_trk_collection_, out_tracks);
 
  auto t_end = std::chrono::high_resolution_clock::now();
  processing_time_ +=
      std::chrono::duration<double, std::milli>(t_end - t_start).count();
  ++nevents_;
}  // end of produce()

References abort_on_error_, beam_origin_surface_, tracking::sim::LdmxMeasurementCalibrator::calibrate1d(), disable_all_material_handling_, ecal_surface_, framework::Event::exists(), gsf_, max_components_, meas_collection_, meas_collection_event_passname_, meas_passname_, out_trk_collection_, propagator_max_steps_, propagator_step_size_, tagger_start_surface_, target_surface_, track_collection_, track_collection_event_passname_, track_passname_, and weight_cutoff_.

Member Data Documentation

abort_on_error_

bool tracking::reco::GSFProcessor::abort_on_error_ {false}

private

Abort fit if any error occurs (strict error handling)

Definition at line 252 of file GSFProcessor.h.

{false};

Referenced by configure(), and produce().

beam_origin_surface_

std::shared_ptr<Acts::Surface> tracking::reco::GSFProcessor::beam_origin_surface_

private

Beam origin surface at z=-700 mm (tagger post-fit extrapolation via VoidNavigator)

Definition at line 288 of file GSFProcessor.h.

Referenced by onNewRun(), and produce().

debug_

bool tracking::reco::GSFProcessor::debug_ {false}

private

Enable verbose debug output logging.

Definition at line 180 of file GSFProcessor.h.

{false};

Referenced by configure(), and onNewRun().

disable_all_material_handling_

bool tracking::reco::GSFProcessor::disable_all_material_handling_ {false}

private

Disable all material interactions during propagation.

Definition at line 255 of file GSFProcessor.h.

{false};

Referenced by configure(), and produce().

ecal_surface_

std::shared_ptr<Acts::Surface> tracking::reco::GSFProcessor::ecal_surface_

private

ECAL surface at z=240.5 mm (ECAL scoring plane for recoil tracking)

Definition at line 298 of file GSFProcessor.h.

Referenced by onNewRun(), and produce().

extrapolate_location_

std::vector<double> tracking::reco::GSFProcessor::extrapolate_location_ {0., 0., 0.}

private

Location to extrapolate tracks to (x, y, z in mm)

Definition at line 203 of file GSFProcessor.h.

{0., 0., 0.};

field_map_

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

private

Path to magnetic field map file.

Definition at line 267 of file GSFProcessor.h.

{""};

Referenced by configure(), and onNewRun().

generator_

std::default_random_engine tracking::reco::GSFProcessor::generator_

private

Random number generator for smearing operations.

Definition at line 183 of file GSFProcessor.h.

gsf_

std::unique_ptr< const Acts::GaussianSumFitter<GsfPropagator, Acts::VectorMultiTrajectory> > tracking::reco::GSFProcessor::gsf_

private

Gaussian Sum Fitter instance for track refitting.

Definition at line 228 of file GSFProcessor.h.

Referenced by onNewRun(), and produce().

layer_surface_map_

std::unordered_map<unsigned int, const Acts::Surface*> tracking::reco::GSFProcessor::layer_surface_map_

private

Layer ID to ACTS Surface mapping for hit surface lookup.

Definition at line 279 of file GSFProcessor.h.

max_components_

size_t tracking::reco::GSFProcessor::max_components_ {4}

private

Maximum number of mixture components in GSF fit.

Definition at line 249 of file GSFProcessor.h.

{4};

Referenced by configure(), and produce().

meas_collection_

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

private

Collection name for measurements associated with tracks.

Definition at line 234 of file GSFProcessor.h.

{"DigiTaggerSimHits"};

Referenced by configure(), and produce().

meas_collection_event_passname_

std::string tracking::reco::GSFProcessor::meas_collection_event_passname_

private

Pass name qualifier for measurement collection event key.

Definition at line 246 of file GSFProcessor.h.

Referenced by configure(), and produce().

meas_passname_

std::string tracking::reco::GSFProcessor::meas_passname_

private

Pass name for measurement collection in event.

Definition at line 240 of file GSFProcessor.h.

Referenced by configure(), and produce().

measurement_collection_

std::string tracking::reco::GSFProcessor::measurement_collection_ {"TaggerMeasurements"}

private

Collection name for input measurements.

Definition at line 207 of file GSFProcessor.h.

{"TaggerMeasurements"};

n_ecal_extrap_failed_

int tracking::reco::GSFProcessor::n_ecal_extrap_failed_ {0}

private

Definition at line 172 of file GSFProcessor.h.

{0};

n_gsf_failed_

int tracking::reco::GSFProcessor::n_gsf_failed_ {0}

private

Definition at line 169 of file GSFProcessor.h.

{0};

n_input_tracks_

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

private

Definition at line 168 of file GSFProcessor.h.

{0};

n_output_tracks_

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

private

Definition at line 170 of file GSFProcessor.h.

{0};

n_target_extrap_failed_

int tracking::reco::GSFProcessor::n_target_extrap_failed_ {0}

private

Definition at line 171 of file GSFProcessor.h.

{0};

nevents_

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

private

Definition at line 167 of file GSFProcessor.h.

{0};

normal_

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

private

Normal distribution for smearing measurements.

Definition at line 186 of file GSFProcessor.h.

out_trk_collection_

std::string tracking::reco::GSFProcessor::out_trk_collection_ {"GSFTracks"}

private

Collection name for output GSF-refitted tracks.

Definition at line 212 of file GSFProcessor.h.

{"GSFTracks"};

Referenced by configure(), and produce().

processing_time_

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

private

Definition at line 173 of file GSFProcessor.h.

{0.};

propagator_

std::unique_ptr<const Propagator> tracking::reco::GSFProcessor::propagator_

private

Propagator for track extrapolation using eigen stepper.

Definition at line 276 of file GSFProcessor.h.

Referenced by onNewRun().

propagator_extrap_

std::unique_ptr<const GsfExtrapPropagator> tracking::reco::GSFProcessor::propagator_extrap_

private

Definition at line 282 of file GSFProcessor.h.

propagator_max_steps_

int tracking::reco::GSFProcessor::propagator_max_steps_ {1000}

private

Maximum number of propagation steps before aborting.

Definition at line 264 of file GSFProcessor.h.

{1000};

Referenced by configure(), and produce().

propagator_step_size_

double tracking::reco::GSFProcessor::propagator_step_size_ {200.}

private

Step size for track propagation in mm.

Definition at line 261 of file GSFProcessor.h.

{200.};

Referenced by configure(), and produce().

seed_coll_name_

std::string tracking::reco::GSFProcessor::seed_coll_name_ {"seedTracks"}

private

Collection name for seed tracks (currently unused)

Definition at line 223 of file GSFProcessor.h.

{"seedTracks"};

tagger_start_surface_

std::shared_ptr<Acts::Surface> tracking::reco::GSFProcessor::tagger_start_surface_

private

Tagger GSF start surface at x≈-617mm in ACTS (1mm inside tagger volume outer boundary ~-618mm, 1.5mm upstream of L1 sensors at x=-615.5mm)

Definition at line 292 of file GSFProcessor.h.

Referenced by onNewRun(), and produce().

tagger_tracking_

bool tracking::reco::GSFProcessor::tagger_tracking_ {true}

private

Definition at line 273 of file GSFProcessor.h.

{true};

target_surface_

std::shared_ptr<Acts::Surface> tracking::reco::GSFProcessor::target_surface_

private

Target surface at z=0 mm (recoil track initialization, perigee output)

Definition at line 295 of file GSFProcessor.h.

Referenced by onNewRun(), and produce().

track_collection_

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

private

Collection name for input tracks to be refit.

Definition at line 231 of file GSFProcessor.h.

{"TaggerTracks"};

Referenced by configure(), and produce().

track_collection_event_passname_

std::string tracking::reco::GSFProcessor::track_collection_event_passname_

private

Pass name qualifier for track collection event key.

Definition at line 243 of file GSFProcessor.h.

Referenced by configure(), and produce().

track_passname_

std::string tracking::reco::GSFProcessor::track_passname_

private

Pass name for track collection in event.

Definition at line 237 of file GSFProcessor.h.

Referenced by configure(), and produce().

trk_extrap_

std::shared_ptr<tracking::reco::TrackExtrapolatorTool<GsfExtrapPropagator> > tracking::reco::GSFProcessor::trk_extrap_

private

Definition at line 284 of file GSFProcessor.h.

use_perigee_

bool tracking::reco::GSFProcessor::use_perigee_ {false}

private

Use perigee parameterization for tracks.

Definition at line 270 of file GSFProcessor.h.

{false};

Referenced by configure().

weight_cutoff_

double tracking::reco::GSFProcessor::weight_cutoff_ {1.0e-4}

private

Weight threshold below which mixture components are dropped.

Definition at line 258 of file GSFProcessor.h.

{1.0e-4};

Referenced by configure(), and produce().

---

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

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