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.}
int	n_fieldmap_gsf_failed_ {0}
int	n_fallback_gsf_recovered_ {0}
int	n_fieldmap_start_extrap_failed_ {0}
int	n_fallback_start_extrap_recovered_ {0}
int	n_fieldmap_target_extrap_failed_ {0}
int	n_fallback_target_extrap_recovered_ {0}
int	n_fieldmap_ecal_extrap_failed_ {0}
int	n_fallback_ecal_extrap_recovered_ {0}
int	n_start_extrap_failed_ {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 GsfFitter >	gsf_
	Gaussian Sum Fitter instance for track refitting.
std::unique_ptr< const GsfFitter >	gsf_zero_b_
	Zero-field GSF, fallback for the recoil.
std::unique_ptr< const GsfFitter >	gsf_const_b_
	Constant-field (bfield_) GSF, fallback for the tagger.
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.
double	bfield_ {-1.5}
	Bz of the tagger fallback field, in Tesla.
BFieldDistortion	bfield_distortion_ {}
	Mis-placement of the reconstruction field; must match the CKF's.
bool	use_perigee_ {false}
	Use perigee parameterization for tracks.
bool	tagger_tracking_ {true}
double	tagger_start_x_ {-617.}
	ACTS x of the tagger GSF start surface [mm].
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::unique_ptr< const GsfExtrapPropagator >	propagator_extrap_zero_b_
std::shared_ptr< tracking::reco::TrackExtrapolatorTool< GsfExtrapPropagator > >	trk_extrap_zero_b_
std::unique_ptr< const GsfExtrapPropagator >	propagator_extrap_const_b_
std::shared_ptr< tracking::reco::TrackExtrapolatorTool< GsfExtrapPropagator > >	trk_extrap_const_b_
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=tagger_start_x_ in ACTS.
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 BFieldDistortion &distortion={})
	Load the interpolated B-field map from path and cache it.
void	loadBField (const BFieldDistortion &distortion={})
	Load B-field from the path recorded in the detector GDML.
std::shared_ptr< Acts::MagneticFieldProvider >	bField () const
	Return the loaded B-field provider.
Protected Member Functions inherited from framework::EventProcessor
void	abortEvent ()
	Abort the event immediately.
Static Protected Member Functions inherited from tracking::reco::TrackingGeometryUser
static BFieldDistortion	bFieldDistortion (const framework::config::Parameters &parameters)
	Build a BFieldDistortion from processor configuration.
Protected Attributes inherited from framework::EventProcessor
HistogramPool	histograms_
	helper object for making and filling histograms
NtupleManager &	ntuple_ {NtupleManager::getInstance()}
	Manager for any ntuples.
logging::logger	the_log_
	The logger for this EventProcessor.

Detailed Description

Definition at line 78 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 28 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 130 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");
  bfield_ = parameters.get<double>("bfield", -1.5);
  bfield_distortion_ = bFieldDistortion(parameters);
  use_perigee_ = parameters.get<bool>("usePerigee", false);
 
  debug_ = parameters.get<bool>("debug", false);
  tagger_tracking_ = parameters.get<bool>("tagger_tracking", true);
  tagger_start_x_ = parameters.get<double>("tagger_start_x", -617.);
 
  // final_reduction_method_ =
  // parameters.get<double>("finalReductionMethod",);
}  // end of configure()

References abort_on_error_, bfield_, bfield_distortion_, tracking::reco::TrackingGeometryUser::bFieldDistortion(), 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_, tagger_start_x_, 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 31 of file GSFProcessor.cxx.

                                                   {
  beam_origin_surface_ = tracking::sim::utils::unboundSurface(-700);
  // 1mm inside tagger ACTS volume outer boundary, upstream of L1
  tagger_start_surface_ = tracking::sim::utils::unboundSurface(tagger_start_x_);
  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(bfield_distortion_);
  else
    loadBField(field_map_, bfield_distortion_);
  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<GsfFitter>(
      std::move(gsf_propagator), 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());
 
  // Constant-field fallbacks for tracks that leave the field map, as in the CKF
  const auto zero_b_field =
      std::make_shared<Acts::ConstantBField>(Acts::Vector3(0., 0., 0.));
  const auto const_b_field = std::make_shared<Acts::ConstantBField>(
      Acts::Vector3(0., 0., bfield_ * Acts::UnitConstants::T));
 
  MultiStepper zero_b_multi_stepper(zero_b_field);
  gsf_zero_b_ = std::make_unique<GsfFitter>(
      GsfPropagator(
          std::move(zero_b_multi_stepper), navigator,
          Acts::getDefaultLogger("GSF_PROP_ZERO_B", acts_logging_level)),
      bethe_heitler, Acts::getDefaultLogger("GSF_ZERO_B", acts_logging_level));
 
  MultiStepper const_b_multi_stepper(const_b_field);
  gsf_const_b_ = std::make_unique<GsfFitter>(
      GsfPropagator(
          std::move(const_b_multi_stepper), navigator,
          Acts::getDefaultLogger("GSF_PROP_CONST_B", acts_logging_level)),
      bethe_heitler, Acts::getDefaultLogger("GSF_CONST_B", acts_logging_level));
 
  propagator_extrap_zero_b_ = std::make_unique<GsfExtrapPropagator>(
      Acts::EigenStepper<>{zero_b_field}, Acts::VoidNavigator{});
  trk_extrap_zero_b_ =
      std::make_shared<std::decay_t<decltype(*trk_extrap_zero_b_)>>(
          *propagator_extrap_zero_b_, geometryContext(),
          magneticFieldContext());
 
  propagator_extrap_const_b_ = std::make_unique<GsfExtrapPropagator>(
      Acts::EigenStepper<>{const_b_field}, Acts::VoidNavigator{});
  trk_extrap_const_b_ =
      std::make_shared<std::decay_t<decltype(*trk_extrap_const_b_)>>(
          *propagator_extrap_const_b_, geometryContext(),
          magneticFieldContext());
}

References beam_origin_surface_, tracking::reco::TrackingGeometryUser::bField(), bfield_, bfield_distortion_, debug_, ecal_surface_, field_map_, gsf_, gsf_const_b_, gsf_zero_b_, tracking::reco::TrackingGeometryUser::loadBField(), propagator_, tagger_start_surface_, tagger_start_x_, 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 579 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::";
  if (tagger_tracking_)
    ldmx_log(info) << "  Tagger start: " << n_start_extrap_failed_ << " times";
  ldmx_log(info) << "  Target: " << n_target_extrap_failed_ << " times";
  if (!tagger_tracking_)
    ldmx_log(info) << "  ECAL:   " << n_ecal_extrap_failed_ << " times";
 
  const std::string fallback_name = tagger_tracking_ ? "const-B" : "zero-B";
  auto recovery_fraction = [](int recovered, int failed) {
    return failed > 0 ? 100.0 * recovered / failed : 0.0;
  };
 
  ldmx_log(info) << "GSF Fallback Statistics (" << fallback_name << ")::";
  ldmx_log(info) << "  Fit: field-map failed " << n_fieldmap_gsf_failed_
                 << " times, fallback recovered " << n_fallback_gsf_recovered_
                 << " ("
                 << recovery_fraction(n_fallback_gsf_recovered_,
                                      n_fieldmap_gsf_failed_)
                 << "%)";
  if (tagger_tracking_)
    ldmx_log(info) << "  Tagger start extrap: field-map failed "
                   << n_fieldmap_start_extrap_failed_
                   << " times, fallback recovered "
                   << n_fallback_start_extrap_recovered_ << " ("
                   << recovery_fraction(n_fallback_start_extrap_recovered_,
                                        n_fieldmap_start_extrap_failed_)
                   << "%)";
  ldmx_log(info) << "  Target extrap: field-map failed "
                 << n_fieldmap_target_extrap_failed_
                 << " times, fallback recovered "
                 << n_fallback_target_extrap_recovered_ << " ("
                 << recovery_fraction(n_fallback_target_extrap_recovered_,
                                      n_fieldmap_target_extrap_failed_)
                 << "%)";
  if (!tagger_tracking_)
    ldmx_log(info) << "  ECAL extrap: field-map failed "
                   << n_fieldmap_ecal_extrap_failed_
                   << " times, fallback recovered "
                   << n_fallback_ecal_extrap_recovered_ << " ("
                   << recovery_fraction(n_fallback_ecal_extrap_recovered_,
                                        n_fieldmap_ecal_extrap_failed_)
                   << "%)";
}

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 577 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 167 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";
 
  // Fallback for this system
  const GsfFitter& fallback_gsf =
      tagger_tracking_ ? *gsf_const_b_ : *gsf_zero_b_;
  auto& fallback_extrap =
      tagger_tracking_ ? trk_extrap_const_b_ : trk_extrap_zero_b_;
  const std::string fallback_name = tagger_tracking_ ? "const-B" : "zero-B";
 
  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) {
        ++n_fieldmap_start_extrap_failed_;
        ldmx_log(debug) << "  Field-map pre-fit extrapolation to tagger start "
                           "surface failed, trying "
                        << fallback_name << " fallback (itrk=" << itrk << ")";
        opt_tagger_start =
            fallback_extrap->extrapolate(trk_btp, tagger_start_surface_);
        if (opt_tagger_start) ++n_fallback_start_extrap_recovered_;
      }
      if (!opt_tagger_start) {
        ldmx_log(debug)
            << "  Failed pre-fit extrapolation to tagger start surface (itrk="
            << itrk << ")";
        ++n_start_extrap_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);
 
    // Index in tc of the successful fit
    std::optional<Acts::TrackIndexType> fitted_index;
 
    {
      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()) {
        fitted_index = gsf_refit_result.value().index();
      } else {
        ++n_fieldmap_gsf_failed_;
        ldmx_log(debug) << "  Field-map GSF re-fit failed (itrk=" << itrk
                        << "): " << gsf_refit_result.error().message()
                        << ", trying " << fallback_name << " fallback";
        if (n_fieldmap_gsf_failed_ <= 5)
          ldmx_log(info) << "  [GSF dbg] fit failed (first few): "
                         << gsf_refit_result.error().message();
 
        auto fallback_result = fallback_gsf.fit(
            fit_track_source_links.begin(), fit_track_source_links.end(),
            trk_btp_fit_start, gsf_options, tc);
 
        if (fallback_result.ok()) {
          ++n_fallback_gsf_recovered_;
          fitted_index = fallback_result.value().index();
          ldmx_log(debug) << "  Yay! " << fallback_name
                          << " GSF succeeded as fallback!";
        } else {
          ldmx_log(debug) << "  " << fallback_name
                          << " GSF also failed (itrk=" << itrk
                          << "): " << fallback_result.error().message();
        }
      }
    }
 
    if (!fitted_index) {
      ++n_gsf_failed_;
      continue;
    }
 
    ++n_gsf_ok_evt;
    ldmx_log(debug) << "  GSF fit succeeded (itrk=" << itrk
                    << "), tc.size()=" << tc.size();
 
    auto gsftrk = tc.getTrack(*fitted_index);
    // 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
    ldmx_log(debug) << "    Extrapolating to target (itrk=" << itrk << ")";
    auto opt_target = trk_extrap_->extrapolate(gsftrk, target_surface_);
 
    if (!opt_target) {
      ++n_fieldmap_target_extrap_failed_;
      ldmx_log(debug) << "    Field-map target extrapolation failed, trying "
                      << fallback_name << " fallback";
      opt_target = fallback_extrap->extrapolate(gsftrk, target_surface_);
      if (opt_target) ++n_fallback_target_extrap_recovered_;
    }
 
    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)
        opt_beam_origin =
            fallback_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) {
        ++n_fieldmap_ecal_extrap_failed_;
        ldmx_log(debug) << "    Field-map ECAL extrapolation failed, trying "
                        << fallback_name << " fallback";
        opt_ecal = fallback_extrap->extrapolate(gsftrk, ecal_surface_);
        if (opt_ecal) ++n_fallback_ecal_extrap_recovered_;
      }
 
      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_, gsf_const_b_, gsf_zero_b_, 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 243 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 298 of file GSFProcessor.h.

Referenced by onNewRun(), and produce().

bfield_

double tracking::reco::GSFProcessor::bfield_ {-1.5}

private

Bz of the tagger fallback field, in Tesla.

Definition at line 261 of file GSFProcessor.h.

{-1.5};

Referenced by configure(), and onNewRun().

bfield_distortion_

BFieldDistortion tracking::reco::GSFProcessor::bfield_distortion_ {}

private

Mis-placement of the reconstruction field; must match the CKF's.

Definition at line 264 of file GSFProcessor.h.

{};

Referenced by configure(), and onNewRun().

debug_

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

private

Enable verbose debug output logging.

Definition at line 167 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 246 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 307 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 190 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 258 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 170 of file GSFProcessor.h.

gsf_

std::unique_ptr<const GsfFitter> tracking::reco::GSFProcessor::gsf_

private

Gaussian Sum Fitter instance for track refitting.

Definition at line 213 of file GSFProcessor.h.

Referenced by onNewRun(), and produce().

gsf_const_b_

std::unique_ptr<const GsfFitter> tracking::reco::GSFProcessor::gsf_const_b_

private

Constant-field (bfield_) GSF, fallback for the tagger.

Definition at line 219 of file GSFProcessor.h.

Referenced by onNewRun(), and produce().

gsf_zero_b_

std::unique_ptr<const GsfFitter> tracking::reco::GSFProcessor::gsf_zero_b_

private

Zero-field GSF, fallback for the recoil.

Definition at line 216 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 240 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 225 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 237 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 231 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 194 of file GSFProcessor.h.

{"TaggerMeasurements"};

n_ecal_extrap_failed_

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

private

Definition at line 148 of file GSFProcessor.h.

{0};

n_fallback_ecal_extrap_recovered_

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

private

Definition at line 159 of file GSFProcessor.h.

{0};

n_fallback_gsf_recovered_

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

private

Definition at line 153 of file GSFProcessor.h.

{0};

n_fallback_start_extrap_recovered_

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

private

Definition at line 155 of file GSFProcessor.h.

{0};

n_fallback_target_extrap_recovered_

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

private

Definition at line 157 of file GSFProcessor.h.

{0};

n_fieldmap_ecal_extrap_failed_

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

private

Definition at line 158 of file GSFProcessor.h.

{0};

n_fieldmap_gsf_failed_

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

private

Definition at line 152 of file GSFProcessor.h.

{0};

n_fieldmap_start_extrap_failed_

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

private

Definition at line 154 of file GSFProcessor.h.

{0};

n_fieldmap_target_extrap_failed_

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

private

Definition at line 156 of file GSFProcessor.h.

{0};

n_gsf_failed_

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

private

Definition at line 145 of file GSFProcessor.h.

{0};

n_input_tracks_

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

private

Definition at line 144 of file GSFProcessor.h.

{0};

n_output_tracks_

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

private

Definition at line 146 of file GSFProcessor.h.

{0};

n_start_extrap_failed_

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

private

Definition at line 160 of file GSFProcessor.h.

{0};

n_target_extrap_failed_

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

private

Definition at line 147 of file GSFProcessor.h.

{0};

nevents_

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

private

Definition at line 143 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 173 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 199 of file GSFProcessor.h.

{"GSFTracks"};

Referenced by configure(), and produce().

processing_time_

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

private

Definition at line 149 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_extrap_const_b_

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

private

Definition at line 292 of file GSFProcessor.h.

propagator_extrap_zero_b_

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

private

Definition at line 287 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 255 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 252 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 210 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=tagger_start_x_ in ACTS.

Definition at line 301 of file GSFProcessor.h.

Referenced by onNewRun(), and produce().

tagger_start_x_

double tracking::reco::GSFProcessor::tagger_start_x_ {-617.}

private

ACTS x of the tagger GSF start surface [mm].

Definition at line 273 of file GSFProcessor.h.

{-617.};

Referenced by configure(), and onNewRun().

tagger_tracking_

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

private

Definition at line 270 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 304 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 222 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 234 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 228 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.

trk_extrap_const_b_

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

private

Definition at line 294 of file GSFProcessor.h.

trk_extrap_zero_b_

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

private

Definition at line 289 of file GSFProcessor.h.

use_perigee_

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

private

Use perigee parameterization for tracks.

Definition at line 267 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 249 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