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
std::map< std::string, double >	profiling_map_
	Time profiling data for performance analysis.
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, BetheHeitlerApprox, 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::shared_ptr< tracking::reco::TrackExtrapolatorTool< Propagator > >	trk_extrap_
std::shared_ptr< Acts::Surface >	beam_origin_surface_
	Beam origin surface at z=-700 mm (tagger track initialization)
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 ()
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 11 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");
  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 14 of file GSFProcessor.cxx.

                                                   {
  beam_origin_surface_ = tracking::sim::utils::unboundSurface(-700);
  target_surface_ = tracking::sim::utils::unboundSurface(0.);
  ecal_surface_ = tracking::sim::utils::unboundSurface(240.5);
 
  // Custom transformation of the interpolated bfield map
  bool debug_transform = false;
  auto transform_pos = [debug_transform](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;
 
    // Apply A rotation around the center of the magnet. (I guess offset first
    // and then rotation)
 
    if (debug_transform) {
      std::cout << "PF::DEFAULT3 TRANSFORM\n";
      std::cout << "PF::Check:: transforming Pos\n";
      std::cout << pos_;
      std::cout << "\nTO\n";
      std::cout << rot_pos << "\n";
    }
 
    return rot_pos;
  };
 
  // Reminder about coordinate system:
  // acts x = global z
  // acts y = global x
  // acts z = global y
  Acts::RotationMatrix3 rotation = Acts::RotationMatrix3::Identity();
  double scale = 1.;
 
  auto transform_b_field = [rotation, scale, debug_transform](
                               const Acts::Vector3& field,
                               const Acts::Vector3& /*pos_*/) {
    // Rotate the field in tracking coordinates
    Acts::Vector3 rot_field;
    rot_field(0) = field(2);
    rot_field(1) = field(0);
    rot_field(2) = field(1);
 
    // Scale the field
    rot_field = scale * rot_field;
 
    // Rotate the field
    rot_field = rotation * rot_field;
 
    // A distortion scaled by position.
 
    if (debug_transform) {
      std::cout << "PF::DEFAULT3 TRANSFORM\n";
      std::cout << "PF::Check:: transforming\n";
      std::cout << field;
      std::cout << "\nTO\n";
      std::cout << rot_field << "\n";
    }
 
    return rot_field;
  };
 
  // Setup a interpolated bfield map
  const auto map = std::make_shared<InterpolatedMagneticField3>(
      loadDefaultBField(field_map_,
                        // default_transformPos,
                        // default_transformBField));
                        transform_pos, transform_b_field));
 
  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));
 
  BetheHeitlerApprox bethe_heitler = 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));
 
  trk_extrap_ = std::make_shared<std::decay_t<decltype(*trk_extrap_)>>(
      *propagator_, geometryContext(), magneticFieldContext());
}

References beam_origin_surface_, debug_, ecal_surface_, field_map_, gsf_, propagator_, 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 469 of file GSFProcessor.cxx.

{};

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 468 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 164 of file GSFProcessor.cxx.

                                                {
  // General Setup
 
  auto tg{geometry()};
 
  // Retrieve the tracks
  if (!event.exists(track_collection_, track_collection_event_passname_))
    return;
  auto tracks{
      event.getCollection<ldmx::Track>(track_collection_, track_passname_)};
 
  // Retrieve the measurements
  if (!event.exists(meas_collection_, meas_collection_event_passname_)) return;
  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, AbortList>
      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.actionList.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.actionList.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 = 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
  unsigned int itrk = 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);
 
    // GSF starting parameters: for tagger, extrapolate back to beam origin;
    // for recoil, use target parameters directly.
    Acts::BoundTrackParameters trk_btp_fit_start = trk_btp;
 
    if (tagger_tracking_) {
      auto opt_beam_origin =
          trk_extrap_->extrapolate(trk_btp, beam_origin_surface_);
      if (!opt_beam_origin) {
        ldmx_log(warn) << "Failed extrapolating to beam origin for GSF start. "
                          "Skipping..";
        continue;
      }
      trk_btp_fit_start = *opt_beam_origin;
    }
 
    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";
 
    // Update GSF reference surface for this track
    if (tagger_tracking_) {
      gsf_ref_surface = beam_origin_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(warn) << "GSF re-fit failed: "
                     << gsf_refit_result.error().message();
      continue;
    }
 
    ldmx_log(debug) << "  GSF fit succeeded, tc.size() = " << tc.size();
 
    if (tc.size() < 1) continue;
 
    auto gsftrk = tc.getTrack(0);
    // 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.transform(geometryContext()).translation()(0) << ", "
        << perigee_surface.transform(geometryContext()).translation()(1) << ", "
        << perigee_surface.transform(geometryContext()).translation()(2) << ")";
 
    ldmx_log(debug) << "    Found track has " << gsftrk.nTrackStates()
                    << " track states";
 
    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_);
 
    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_->transform(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 {
      ldmx_log(debug) << "    GSF target extrapolation failed, 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));
    }
 
    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
 
  event.add(out_trk_collection_, out_tracks);
}  // 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_, 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 247 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 track initialization)

Definition at line 281 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 175 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 250 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 287 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 198 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 262 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 178 of file GSFProcessor.h.

gsf_

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

private

Gaussian Sum Fitter instance for track refitting.

Definition at line 223 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 274 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 244 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 229 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 241 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 235 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 202 of file GSFProcessor.h.

{"TaggerMeasurements"};

normal_

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

private

Normal distribution for smearing measurements.

Definition at line 181 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 207 of file GSFProcessor.h.

{"GSFTracks"};

Referenced by configure(), and produce().

profiling_map_

std::map<std::string, double> tracking::reco::GSFProcessor::profiling_map_

private

Time profiling data for performance analysis.

Definition at line 168 of file GSFProcessor.h.

propagator_

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

private

Propagator for track extrapolation using eigen stepper.

Definition at line 271 of file GSFProcessor.h.

Referenced by onNewRun().

propagator_max_steps_

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

private

Maximum number of propagation steps before aborting.

Definition at line 259 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 256 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 218 of file GSFProcessor.h.

{"seedTracks"};

tagger_tracking_

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

private

Definition at line 268 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 284 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 226 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 238 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 232 of file GSFProcessor.h.

Referenced by configure(), and produce().

trk_extrap_

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

private

Definition at line 278 of file GSFProcessor.h.

use_perigee_

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

private

Use perigee parameterization for tracks.

Definition at line 265 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 253 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