tracking::reco::SeedFinderProcessor Class Reference

Public Member Functions
	SeedFinderProcessor (const std::string &name, framework::Process &process)
	Constructor.
virtual	~SeedFinderProcessor ()=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	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 and create a collection of results which indicate if a charge particle can be found by the recoil tracker.
bool	groupStrips (const std::vector< ldmx::Measurement > &measurements, const std::vector< int > strategy)
void	findSeedsFromMap (std::vector< ldmx::Track > &seeds, const ldmx::Measurements &pmeas)
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	onNewRun (const ldmx::RunHeader &run_header)
	Callback for the EventProcessor to take any necessary action when the run being processed changes.
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 Member Functions
ldmx::Track	seedTracker (const ldmx::Measurements &vmeas, double xOrigin, const Acts::Vector3 &perigee_location, const ldmx::Measurements &pmeas_tgt)
void	lineParabolaToHelix (const Acts::Vector< 5 > parameters, Acts::Vector< 5 > &helix_parameters, Acts::Vector3 ref)

Private Attributes
Acts::Vector3	b_field_
std::shared_ptr< tracking::sim::SeedToTrackParamMaker >	seed_to_track_maker_
double	processing_time_ {0.}
long	nevents_ {0}
unsigned int	ntracks_ {0}
std::vector< double >	inflate_factors_ {1., 1., 1., 1., 1.}
std::string	out_seed_collection_ {"SeedTracks"}
	The name of the output collection of seeds to be stored.
std::string	input_hits_collection_ {"TaggerSimHits"}
	The name of the input hits collection to use in finding seeds..
std::string	tagger_trks_collection_ {"TaggerTracks"}
	The name of the tagger Tracks (only for Recoil Seeding)
std::string	input_pass_name_ {""}
std::string	sim_particles_coll_name_
std::string	sim_particles_passname_
std::string	tagger_trks_event_collection_passname_
std::string	sim_particles_event_passname_
std::vector< double >	perigee_location_ {-700., 0., 0}
	Location of the perigee for the helix track parameters.
double	pmin_ {0.05}
	Minimum cut on the momentum of the seeds.
double	pmax_ {8}
	Maximum cut on the momentum of the seeds.
double	d0max_ {20.}
	Max d0 allowed for the seeds.
double	d0min_ {20.}
	Min d0 allowed for the seeds.
double	z0max_ {60.}
	Max z0 allowed for the seeds.
double	piover2_ {1.5708}
double	phicut_ {0.1}
	PhiRange.
double	thetacut_ {0.2}
	ThetaRange.
double	loc0cut_ {0.1}
	loc0 / loc1 cuts
double	loc1cut_ {0.3}
std::vector< std::string >	strategies_ {}
	List of stragies for seed finding.
std::vector< std::vector< int > >	strategy_layers_ {}
	Layer lists parsed from strategies_, one per strategy.
double	bfield_ {1.5}
std::vector< float >	xhit_
std::vector< float >	yhit_
std::vector< float >	zhit_
std::vector< float >	b0_
std::vector< float >	b1_
std::vector< float >	b2_
std::vector< float >	b3_
std::vector< float >	b4_
long	ndoubles_ {0}
long	nmissing_ {0}
long	nfailpmin_ {0}
long	nfailpmax_ {0}
long	nfaild0min_ {0}
long	nfaild0max_ {0}
long	nfailz0max_ {0}
long	nfailphi_ {0}
long	nfailtheta_ {0}
std::map< int, std::vector< const ldmx::Measurement * > >	groups_map_
std::shared_ptr< tracking::sim::TruthMatchingTool >	truth_matching_tool_
double	u_error_
	u error
double	v_error_
	v error

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 38 of file SeedFinderProcessor.h.

Constructor & Destructor Documentation

SeedFinderProcessor()

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

    : TrackingGeometryUser(name, process) {
  // TODO REMOVE FROM DEFAULT
  /*
  output_file_ = new TFile("seeder.root", "RECREATE");
  output_tree_ = new TTree("seeder", "seeder");
 
  output_tree_->Branch("nevents", &nevents_);
  output_tree_->Branch("xhit", &xhit_);
  output_tree_->Branch("yhit", &yhit_);
  output_tree_->Branch("zhit", &zhit_);
 
  output_tree_->Branch("b0", &b0_);
  output_tree_->Branch("b1", &b1_);
  output_tree_->Branch("b2", &b2_);
  output_tree_->Branch("b3", &b3_);
  output_tree_->Branch("b4", &b4_);
  */
}

Member Function Documentation

configure()

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

                                                                         {
  // Output seed name
  out_seed_collection_ = parameters.get<std::string>("out_seed_collection",
                                                     getName() + "SeedTracks");
 
  // Input strip hits
  input_hits_collection_ =
      parameters.get<std::string>("input_hits_collection", "TaggerSimHits");
 
  // Tagger tracks - only for Recoil Seed finding
  tagger_trks_collection_ =
      parameters.get<std::string>("tagger_trks_collection", "TaggerTracks");
 
  perigee_location_ =
      parameters.get<std::vector<double>>("perigee_location", {-700, 0., 0.});
  pmin_ = parameters.get<double>("pmin", 0.05 * Acts::UnitConstants::GeV);
  pmax_ = parameters.get<double>("pmax", 8 * Acts::UnitConstants::GeV);
  d0max_ = parameters.get<double>("d0max", -15. * Acts::UnitConstants::mm);
  d0min_ = parameters.get<double>("d0min", -45. * Acts::UnitConstants::mm);
  z0max_ = parameters.get<double>("z0max", 60. * Acts::UnitConstants::mm);
  phicut_ = parameters.get<double>("phicut", 0.1);
  thetacut_ = parameters.get<double>("thetacut", 0.2);
  loc0cut_ = parameters.get<double>("loc0cut", 0.1);
  loc1cut_ = parameters.get<double>("loc1cut", 0.3);
  strategies_ =
      parameters.get<std::vector<std::string>>("strategies", {"0,1,2,3,4"});
 
  // parse each "l0,l1,..." string into a layer list
  strategy_layers_.clear();
  for (const auto& strategy : strategies_) {
    std::vector<int> layers;
    std::stringstream ss(strategy);
    std::string token;
    while (std::getline(ss, token, ',')) {
      if (!token.empty()) layers.push_back(std::stoi(token));
    }
    // the line+parabola fit needs at least 5 distinct layers
    std::set<int> distinct(layers.begin(), layers.end());
    if (distinct.size() < 5) {
      EXCEPTION_RAISE("BadConf", "Seeding strategy '" + strategy +
                                     "' has fewer than 5 distinct layers");
    }
    strategy_layers_.push_back(layers);
  }
  inflate_factors_ = parameters.get<std::vector<double>>(
      "inflate_factors", {10., 10., 10., 10., 10., 10.});
  bfield_ = parameters.get<double>("bfield", 1.5);
  input_pass_name_ = parameters.get<std::string>("input_pass_name");
  sim_particles_coll_name_ =
      parameters.get<std::string>("sim_particles_coll_name");
  sim_particles_passname_ =
      parameters.get<std::string>("sim_particles_passname");
  tagger_trks_event_collection_passname_ =
      parameters.get<std::string>("tagger_trks_event_collection_passname");
  sim_particles_event_passname_ =
      parameters.get<std::string>("sim_particles_event_passname");
  u_error_ = parameters.get<double>("u_error");
  v_error_ = parameters.get<double>("v_error");
}

References d0max_, d0min_, framework::config::Parameters::get(), framework::EventProcessor::getName(), input_hits_collection_, loc0cut_, out_seed_collection_, perigee_location_, phicut_, pmax_, pmin_, strategies_, strategy_layers_, tagger_trks_collection_, thetacut_, u_error_, v_error_, and z0max_.

findSeedsFromMap()

void tracking::reco::SeedFinderProcessor::findSeedsFromMap	(	std::vector< ldmx::Track > &	seeds,
		const ldmx::Measurements &	pmeas )

Definition at line 477 of file SeedFinderProcessor.cxx.

                                                                          {
  std::map<int, std::vector<const ldmx::Measurement*>>::iterator groups_iter =
      groups_map_.begin();
  // Vector of iterators, one per grouped layer
  const int k = groups_map_.size();
  if (k < 1) return;
  std::vector<std::vector<const ldmx::Measurement*>::iterator> it;
  it.resize(k);
 
  unsigned int ikey = 0;
  for (auto& key : groups_map_) {
    it[ikey] = key.second.begin();
    ikey++;
  }
 
  // K vectors in an array v[0],v[1].... v[K-1]
 
  // Loop over all combinations
  while (it[0] != groups_iter->second.end()) {
    // process the pointed-to elements
 
    /*
      for (int j=0; j<K; j++) {
      const ldmx::Measurement* meas = (*(it[j]));
      std::cout<<meas->getGlobalPosition()[0]<<","
      <<meas->getGlobalPosition()[1]<<","
      <<meas->getGlobalPosition()[2]<<","<<std::endl;
      }
    */
 
    std::vector<ldmx::Measurement> meas_for_seeds;
    meas_for_seeds.reserve(k);
 
    ldmx_log(debug) << " Grouping ";
 
    for (int j = 0; j < k; j++) {
      const ldmx::Measurement* meas = (*(it[j]));
      meas_for_seeds.push_back(*meas);
    }
 
    std::sort(meas_for_seeds.begin(), meas_for_seeds.end(),
              [](const ldmx::Measurement& m1, const ldmx::Measurement& m2) {
                return m1.getGlobalPosition()[0] < m2.getGlobalPosition()[0];
              });
 
    if (meas_for_seeds.size() < k) {
      nmissing_++;
      return;
    }
 
    ldmx_log(debug) << "making seedTrack";
 
    Acts::Vector3 perigee{perigee_location_[0], perigee_location_[1],
                          perigee_location_[2]};
 
    ldmx::Track seed_track = seedTracker(
        meas_for_seeds, meas_for_seeds.at(k / 2).getGlobalPosition()[0],
        perigee, pmeas);
 
    bool fail = false;
 
    // Remove failed fits
    if (1. / abs(seed_track.getQoP()) < pmin_) {
      nfailpmin_++;
      fail = true;
    } else if (1. / abs(seed_track.getQoP()) > pmax_) {
      nfailpmax_++;
      fail = true;
    }
 
    // Remove large part of fake tracks and duplicates with the following cuts
    // for various compatibility checks.
 
    else if (abs(seed_track.getZ0()) > z0max_) {
      nfailz0max_++;
      fail = true;
    } else if (seed_track.getD0() < d0min_) {
      nfaild0min_++;
      fail = true;
    } else if (seed_track.getD0() > d0max_) {
      nfaild0max_++;
      fail = true;
    } else if (abs(seed_track.getPhi()) > phicut_) {
      fail = true;
      nfailphi_++;
    } else if (abs(seed_track.getTheta() - piover2_) > thetacut_) {
      fail = true;
      nfailtheta_++;
    }
 
    // If I didn't use the target pseudo measurements in the track finding
    // I can use them for compatibility with the tagger track
 
    // TODO this should protect against running this check on tagger seeder.
    // This is true only if this seeder is not run twice on the tagger after
    // already having tagger tracks available.
    if (pmeas.size() > 0) {
      // I can have multiple target pseudo measurements
      // A seed is rejected if it is found incompatible with all the target
      // extrapolations
 
      // This is set but unused, eventually we will use tagger track position at
      // target to inform recoil tracking bool tgt_compatible = false;
      for (auto tgt_pseudomeas : pmeas) {
        // The d0/z0 are in a frame with the same orientation of the target
        // surface
        double delta_loc0 =
            seed_track.getD0() - tgt_pseudomeas.getLocalPosition()[0];
        double delta_loc1 =
            seed_track.getZ0() - tgt_pseudomeas.getLocalPosition()[1];
 
        if (abs(delta_loc0) < loc0cut_ && abs(delta_loc1) < loc1cut_) {
          // found at least 1 compatible target location
          // tgt_compatible = true;
          break;
        }
      }
    }  // pmeas > 0
 
    if (!fail) {
      if (truth_matching_tool_->configured()) {
        auto truth_info = truth_matching_tool_->truthMatch(meas_for_seeds);
        seed_track.setTrackID(truth_info.track_id_);
        seed_track.setPdgID(truth_info.pdg_id_);
        seed_track.setTruthProb(truth_info.truth_prob_);
      }
 
      seeds.push_back(seed_track);
    }
 
    else {
      b0_.pop_back();
      b1_.pop_back();
      b2_.pop_back();
      b3_.pop_back();
      b4_.pop_back();
    }
 
    // Go to next combination
    ldmx_log(debug) << "Go to the next combination";
 
    ++it[k - 1];
    for (int i = k - 1;
         (i > 0) && (it[i] == (std::next(groups_iter, i))->second.end()); --i) {
      it[i] = std::next(groups_iter, i)->second.begin();
      ++it[i - 1];
    }
  }
}  // find seeds

groupStrips()

bool tracking::reco::SeedFinderProcessor::groupStrips	(	const std::vector< ldmx::Measurement > &	measurements,
		const std::vector< int >	strategy )

Definition at line 447 of file SeedFinderProcessor.cxx.

                                   {
  //    std::cout<<"Using stratedy"<<std::endl;
  // for (auto& e : strategy) {
  //  std::cout<<e<<" ";
  //}
  // std::cout<<std::endl;
 
  for (auto& meas : measurements) {
    ldmx_log(trace) << meas;
 
    if (std::find(strategy.begin(), strategy.end(), meas.getLayer()) !=
        strategy.end()) {
      ldmx_log(debug) << "Adding measurement from layer_ = " << meas.getLayer();
      groups_map_[meas.getLayer()].push_back(&meas);
    }
 
  }  // loop meas
 
  if (groups_map_.size() < strategy.size())
    return false;
  else
    return true;
}

onProcessEnd()

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

                                       {
  // output_file_->cd();
  // output_tree_->Write();
  // output_file_->Close();
  ldmx_log(info) << "AVG Time/Event: " << std::fixed << std::setprecision(1)
                 << processing_time_ / nevents_ << " ms";
  ldmx_log(info) << "Total Seeds/Events: " << ntracks_ << "/" << nevents_;
  ldmx_log(info) << "Seeds discarded due to multiple hits on layers "
                 << ndoubles_;
  ldmx_log(info) << "not enough seed points " << nmissing_;
  ldmx_log(info) << " nfailpmin=" << nfailpmin_;
  ldmx_log(info) << "   nfailpmax=" << nfailpmax_;
  ldmx_log(info) << "   nfaild0max=" << nfaild0max_;
  ldmx_log(info) << "   nfaild0min=" << nfaild0min_;
  ldmx_log(info) << "   nfailphicut=" << nfailphi_;
  ldmx_log(info) << "   nfailthetacut=" << nfailtheta_;
  ldmx_log(info) << "   nfailz0max=" << nfailz0max_;
}

onProcessStart()

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

                                         {
  truth_matching_tool_ = std::make_shared<tracking::sim::TruthMatchingTool>();
}

produce()

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

overridevirtual

Run the processor and create a collection of results which indicate if a charge particle can be found by the recoil tracker.

Parameters

event

The event to process.

Implements framework::Producer.

Definition at line 108 of file SeedFinderProcessor.cxx.

                                                       {
  // tg is unused, should it be? FIXME
  // const auto& tg{geometry()};
  auto start = std::chrono::high_resolution_clock::now();
  std::vector<ldmx::Track> seed_tracks;
 
  nevents_++;
 
  // check if SimParticleMap is available for truth matching
  std::map<int, ldmx::SimParticle> particle_map;
 
  const auto& measurements = event.getCollection<ldmx::Measurement>(
      input_hits_collection_, input_pass_name_);
 
  std::vector<ldmx::Track> tagger_tracks;
  if (event.exists(tagger_trks_collection_,
                   tagger_trks_event_collection_passname_)) {
    tagger_tracks = event.getCollection<ldmx::Track>(tagger_trks_collection_,
                                                     input_pass_name_);
  }
 
  // Create an unbound surface at the target
  std::shared_ptr<Acts::Surface> tgt_surf =
      tracking::sim::utils::unboundSurface(0.);
 
  // Create the pseudomeasurements at the target
 
  ldmx::Measurements target_pseudo_meas;
 
  for (auto tagtrk : tagger_tracks) {
    // For Track, the perigee parameters are stored at the target surface.
    // Use d0/z0 as local position and the perigee covariance for the
    // pseudo measurement. Only create the pseudo measurement if cov is
    // available.
 
    // The covariance matrix passed to the pseudo measurement is considered as
    // uncorrelated. This is an approx that considers that loc-u and loc-v from
    // the track have small correlation.
 
    const auto& perigee_cov = tagtrk.getPerigeeCov();
    if (!perigee_cov.empty()) {
      Acts::BoundMatrix cov = tracking::sim::utils::unpackCov(perigee_cov);
      double locu = tagtrk.getD0();
      double locv = tagtrk.getZ0();
      double covuu =
          cov(Acts::BoundIndices::eBoundLoc0, Acts::BoundIndices::eBoundLoc0);
      double covvv =
          cov(Acts::BoundIndices::eBoundLoc1, Acts::BoundIndices::eBoundLoc1);
 
      ldmx::Measurement pseudo_meas;
      pseudo_meas.setLocalPosition(locu, locv);
      Acts::Vector3 dummy{0., 0., 0.};
      Acts::Vector2 local_pos{locu, locv};
      Acts::Vector3 global_pos =
          tgt_surf->localToGlobal(geometryContext(), local_pos, dummy);
 
      pseudo_meas.setGlobalPosition(global_pos(0), global_pos(1),
                                    global_pos(2));
      pseudo_meas.setTime(0.);
      pseudo_meas.setLocalCovariance(covuu, covvv);
 
      target_pseudo_meas.push_back(pseudo_meas);
    }
  }
 
  if (event.exists(sim_particles_coll_name_, sim_particles_event_passname_)) {
    particle_map = event.getMap<int, ldmx::SimParticle>(
        sim_particles_coll_name_, sim_particles_passname_);
    truth_matching_tool_->setup(particle_map, measurements);
  }
 
  ldmx_log(debug) << "Preparing the strategies";
 
  //  a strategy is a list of layers from which to make the seed
  //  layer_ numbering starts at 0
  for (const auto& strategy : strategy_layers_) {
    groups_map_.clear();
    if (groupStrips(measurements, strategy))
      findSeedsFromMap(seed_tracks, target_pseudo_meas);
  }
 
  groups_map_.clear();
  // output_tree_->Fill();
  ntracks_ += seed_tracks.size();
  event.add(out_seed_collection_, seed_tracks);
 
  auto end = std::chrono::high_resolution_clock::now();
 
  // long long microseconds =
  // std::chrono::duration_cast<std::chrono::microseconds>(end-start).count();
 
  auto diff = end - start;
  processing_time_ += std::chrono::duration<double, std::milli>(diff).count();
 
  // Seed finding using 2D Hits
  //  - The hits should keep track if they are already associated to a track or
  //  not. This can be used for subsequent passes of seed-finding
 
  // This should go into a digitization producer, which takes care of producing
  // measurements from:
  //  - raw hits in data
  //  - sim hits in MC
  // Step 0: Get the sim hits and project them on the surfaces to mimic 2d
  // hits Step 1: Smear the hits and associate an uncertainty to those
  // measurements.
 
  xhit_.clear();
  yhit_.clear();
  zhit_.clear();
 
  b0_.clear();
  b1_.clear();
  b2_.clear();
  b3_.clear();
  b4_.clear();
 
}  // produce

References framework::Event::exists(), input_hits_collection_, out_seed_collection_, ldmx::Measurement::setGlobalPosition(), ldmx::Measurement::setLocalCovariance(), ldmx::Measurement::setLocalPosition(), ldmx::Measurement::setTime(), strategy_layers_, and tagger_trks_collection_.

seedTracker()

ldmx::Track tracking::reco::SeedFinderProcessor::seedTracker ( const ldmx::Measurements & vmeas, double xOrigin, const Acts::Vector3 & perigee_location, const ldmx::Measurements & pmeas_tgt )

private

Definition at line 236 of file SeedFinderProcessor.cxx.

                                       {
  // Fit a straight line in the non-bending plane and a parabola in the bending
  // plane
 
  // Each measurement is treated as a 3D point, where the v direction is in the
  // center of the strip with sigma equal to the length of the strip / sqrt(12).
  // In this way it's easier to incorporate the tagger track extrapolation to
  // the fit
 
  Acts::Matrix<5, 5> a = Acts::Matrix<5, 5>::Zero();
  Acts::Vector<5> y = Acts::Vector<5>::Zero();
 
  for (auto meas : vmeas) {
    double xmeas = meas.getGlobalPosition()[0] - xOrigin;
 
    // Get the surface
    const Acts::Surface* hit_surface = geometry().getSurface(meas.getLayerID());
 
    // Get the global to local transformation
    auto rot =
        hit_surface->localToGlobalTransform(geometryContext()).rotation();
    auto tr =
        hit_surface->localToGlobalTransform(geometryContext()).translation();
 
    auto rotl2g = rot.transpose();
 
    // Only for saving purposes
    Acts::Vector2 loc{meas.getLocalPosition()[0], 0.};
 
    xhit_.push_back(xmeas);
    yhit_.push_back(meas.getGlobalPosition()[1]);
    zhit_.push_back(meas.getGlobalPosition()[2]);
 
    Acts::Matrix<2, 5> a_i;
 
    a_i(0, 0) = rotl2g(0, 1);
    a_i(0, 1) = rotl2g(0, 1) * xmeas;
    a_i(0, 2) = rotl2g(0, 1) * xmeas * xmeas;
    a_i(0, 3) = rotl2g(0, 2);
    a_i(0, 4) = rotl2g(0, 2) * xmeas;
 
    a_i(1, 0) = rotl2g(1, 1);
    a_i(1, 1) = rotl2g(1, 1) * xmeas;
    a_i(1, 2) = rotl2g(1, 1) * xmeas * xmeas;
    a_i(1, 3) = rotl2g(1, 2);
    a_i(1, 4) = rotl2g(1, 2) * xmeas;
 
    // Fill the yprime vector
    Acts::Vector2 offset = (rot.transpose() * tr).topRows<2>();
    Acts::Vector2 xoffset = {rotl2g(0, 0) * xmeas, rotl2g(1, 0) * xmeas};
 
    loc(0) = meas.getLocalPosition()[0];
    loc(1) = 0.;
    // weight matrix
    Acts::Matrix<2, 2> w_i = Acts::Matrix<2, 2>::Zero();
 
    w_i(0, 0) = 1. / (u_error_ * u_error_);
    w_i(1, 1) = 1. / (v_error_ * v_error_);
 
    Acts::Vector2 yprime_i = loc + offset - xoffset;
    y += (a_i.transpose()) * w_i * yprime_i;
 
    Acts::Matrix<2, 5> wa_i = (w_i * a_i);
    a += a_i.transpose() * wa_i;
  }
 
  Acts::Vector<5> b;
  b = a.inverse() * y;
 
  b0_.push_back(b(0));
  b1_.push_back(b(1));
  b2_.push_back(b(2));
  b3_.push_back(b(3));
  b4_.push_back(b(4));
 
  // Acts::Vector<5> hlx = Acts::Vector<5>::Zero();
  Acts::Vector<3> ref{0., 0., 0.};
 
  // relative_perigee_x is the perigee position in the fit frame (fit-x = ACTS x
  // - xOrigin). It is used only for evaluating the fitted curve (y, z, slopes).
  // The PerigeeSurface and seed_pos must use the absolute ACTS x coordinate,
  // which is perigee_location(0) directly.
  double relative_perigee_x = perigee_location(0) - xOrigin;
 
  std::shared_ptr<const Acts::PerigeeSurface> seed_perigee =
      Acts::Surface::makeShared<Acts::PerigeeSurface>(Acts::Vector3(
          perigee_location(0), perigee_location(1), perigee_location(2)));
 
  // in mm — x is absolute ACTS x; y and z evaluated at fit-x =
  // relative_perigee_x
  Acts::Vector3 seed_pos{perigee_location(0),
                         b(0) + b(1) * relative_perigee_x +
                             b(2) * relative_perigee_x * relative_perigee_x,
                         b(3) + b(4) * relative_perigee_x};
  Acts::Vector3 dir{1, b(1) + 2 * b(2) * relative_perigee_x, b(4)};
  dir /= dir.norm();
 
  // Momentum at xmeas
  // R in meters, p in GeV
  double p = 0.3 * bfield_ * (1. / (2. * abs(b(2)))) * 0.001;
  // std::cout<<"Momentum "<< p*dir << std::endl;
 
  // Convert it to MeV since that's what TrackUtils assumes
  Acts::Vector3 seed_mom = p * dir / Acts::UnitConstants::MeV;
  double q =
      b(2) < 0 ? -1 * Acts::UnitConstants::e : +1 * Acts::UnitConstants::e;
 
  // Linear intersection with the perigee line. TODO:: Use propagator instead
  // Project the position on the surface.
  // This is mainly necessary for the perigee surface, where
  // the mean might not fulfill the perigee condition.
 
  // mg  Aug 2024 .. interect has changed, but just remove boundary check
  //  and change intersection to intersections
  //   auto intersection =
  //     (*seed_perigee).intersect(geometry_context(), seed_pos, dir, false);
 
  // Acts::FreeVector seed_free = tracking::sim::utils::toFreeParameters(
  //     intersection.intersection.position, seed_mom, q);
 
  auto intersection =
      (*seed_perigee).intersect(geometryContext(), seed_pos, dir);
 
  Acts::FreeVector seed_free = tracking::sim::utils::toFreeParameters(
      intersection[0].position(), seed_mom, q);
 
  auto bound_params = Acts::transformFreeToBoundParameters(
                          seed_free, *seed_perigee, geometryContext())
                          .value();
 
  ldmx_log(trace) << "bound parameters at perigee location" << bound_params;
 
  Acts::BoundVector stddev;
  // sigma set to 75% of momentum
  double sigma_p = 0.75 * p * Acts::UnitConstants::GeV;
  stddev[Acts::eBoundLoc0] =
      inflate_factors_[Acts::eBoundLoc0] * 2 * Acts::UnitConstants::mm;
  stddev[Acts::eBoundLoc1] =
      inflate_factors_[Acts::eBoundLoc1] * 5 * Acts::UnitConstants::mm;
  stddev[Acts::eBoundPhi] =
      inflate_factors_[Acts::eBoundPhi] * 5 * Acts::UnitConstants::degree;
  stddev[Acts::eBoundTheta] =
      inflate_factors_[Acts::eBoundTheta] * 5 * Acts::UnitConstants::degree;
  stddev[Acts::eBoundQOverP] =
      inflate_factors_[Acts::eBoundQOverP] * (1. / p) * (1. / p) * sigma_p;
  stddev[Acts::eBoundTime] =
      inflate_factors_[Acts::eBoundTime] * 1000 * Acts::UnitConstants::ns;
 
  ldmx_log(debug)
      << "Making covariance matrix as diagonal matrix with inflated terms";
  Acts::BoundMatrix bound_cov = stddev.cwiseProduct(stddev).asDiagonal();
 
  ldmx_log(debug) << "...now putting together the seed track ...";
 
  ldmx::Track trk = ldmx::Track();
  // Store the perigee surface position (absolute ACTS coordinates) converted to
  // LDMX frame so CKFProcessor can reconstruct the same surface.
  Acts::Vector3 perigee_ldmx =
      tracking::sim::utils::acts2Ldmx(perigee_location);
  trk.setPerigeeLocation(perigee_ldmx(0), perigee_ldmx(1), perigee_ldmx(2));
  trk.setChi2(0.);
  trk.setNhits(5);
  trk.setNdf(0);
  trk.setNsharedHits(0);
  trk.setCharge(q < 0 ? -1 : 1);
  std::vector<double> v_seed_params(
      (bound_params).data(),
      bound_params.data() + bound_params.rows() * bound_params.cols());
  std::vector<double> v_seed_cov;
  tracking::sim::utils::flatCov(bound_cov, v_seed_cov);
  trk.setPerigeeParameters(v_seed_params);
  trk.setPerigeeCov(v_seed_cov);
 
  ldmx_log(debug)
      << "...making the ParticleHypothesis ...assume electron for now";
  auto part_hypo{Acts::ParticleHypothesis::electron()};
 
  ldmx_log(debug) << "Making BoundTrackParameters seedParameters";
  Acts::BoundTrackParameters seed_parameters(
      seed_perigee, std::move(bound_params), bound_cov, part_hypo);
 
  ldmx_log(debug) << "Returning seed track";
  return trk;
}

Member Data Documentation

b0_

std::vector<float> tracking::reco::SeedFinderProcessor::b0_

private

Definition at line 157 of file SeedFinderProcessor.h.

b1_

std::vector<float> tracking::reco::SeedFinderProcessor::b1_

private

Definition at line 158 of file SeedFinderProcessor.h.

b2_

std::vector<float> tracking::reco::SeedFinderProcessor::b2_

private

Definition at line 159 of file SeedFinderProcessor.h.

b3_

std::vector<float> tracking::reco::SeedFinderProcessor::b3_

private

Definition at line 160 of file SeedFinderProcessor.h.

b4_

std::vector<float> tracking::reco::SeedFinderProcessor::b4_

private

Definition at line 161 of file SeedFinderProcessor.h.

b_field_

Acts::Vector3 tracking::reco::SeedFinderProcessor::b_field_

private

Definition at line 91 of file SeedFinderProcessor.h.

bfield_

double tracking::reco::SeedFinderProcessor::bfield_ {1.5}

private

Definition at line 151 of file SeedFinderProcessor.h.

{1.5};

d0max_

double tracking::reco::SeedFinderProcessor::d0max_ {20.}

private

Max d0 allowed for the seeds.

Definition at line 127 of file SeedFinderProcessor.h.

{20.};

Referenced by configure().

d0min_

double tracking::reco::SeedFinderProcessor::d0min_ {20.}

private

Min d0 allowed for the seeds.

Definition at line 130 of file SeedFinderProcessor.h.

{20.};

Referenced by configure().

groups_map_

std::map<int, std::vector<const ldmx::Measurement*> > tracking::reco::SeedFinderProcessor::groups_map_

private

Definition at line 175 of file SeedFinderProcessor.h.

inflate_factors_

std::vector<double> tracking::reco::SeedFinderProcessor::inflate_factors_ {1., 1., 1., 1., 1.}

private

Definition at line 104 of file SeedFinderProcessor.h.

{1., 1., 1., 1., 1.};

input_hits_collection_

std::string tracking::reco::SeedFinderProcessor::input_hits_collection_ {"TaggerSimHits"}

private

The name of the input hits collection to use in finding seeds..

Definition at line 109 of file SeedFinderProcessor.h.

{"TaggerSimHits"};

Referenced by configure(), and produce().

input_pass_name_

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

private

Definition at line 112 of file SeedFinderProcessor.h.

{""};

loc0cut_

double tracking::reco::SeedFinderProcessor::loc0cut_ {0.1}

private

loc0 / loc1 cuts

Definition at line 144 of file SeedFinderProcessor.h.

{0.1};

Referenced by configure().

loc1cut_

double tracking::reco::SeedFinderProcessor::loc1cut_ {0.3}

private

Definition at line 145 of file SeedFinderProcessor.h.

{0.3};

ndoubles_

long tracking::reco::SeedFinderProcessor::ndoubles_ {0}

private

Definition at line 164 of file SeedFinderProcessor.h.

{0};

nevents_

long tracking::reco::SeedFinderProcessor::nevents_ {0}

private

Definition at line 101 of file SeedFinderProcessor.h.

{0};

nfaild0max_

long tracking::reco::SeedFinderProcessor::nfaild0max_ {0}

private

Definition at line 169 of file SeedFinderProcessor.h.

{0};

nfaild0min_

long tracking::reco::SeedFinderProcessor::nfaild0min_ {0}

private

Definition at line 168 of file SeedFinderProcessor.h.

{0};

nfailphi_

long tracking::reco::SeedFinderProcessor::nfailphi_ {0}

private

Definition at line 171 of file SeedFinderProcessor.h.

{0};

nfailpmax_

long tracking::reco::SeedFinderProcessor::nfailpmax_ {0}

private

Definition at line 167 of file SeedFinderProcessor.h.

{0};

nfailpmin_

long tracking::reco::SeedFinderProcessor::nfailpmin_ {0}

private

Definition at line 166 of file SeedFinderProcessor.h.

{0};

nfailtheta_

long tracking::reco::SeedFinderProcessor::nfailtheta_ {0}

private

Definition at line 172 of file SeedFinderProcessor.h.

{0};

nfailz0max_

long tracking::reco::SeedFinderProcessor::nfailz0max_ {0}

private

Definition at line 170 of file SeedFinderProcessor.h.

{0};

nmissing_

long tracking::reco::SeedFinderProcessor::nmissing_ {0}

private

Definition at line 165 of file SeedFinderProcessor.h.

{0};

ntracks_

unsigned int tracking::reco::SeedFinderProcessor::ntracks_ {0}

private

Definition at line 102 of file SeedFinderProcessor.h.

{0};

out_seed_collection_

std::string tracking::reco::SeedFinderProcessor::out_seed_collection_ {"SeedTracks"}

private

The name of the output collection of seeds to be stored.

Definition at line 107 of file SeedFinderProcessor.h.

{"SeedTracks"};

Referenced by configure(), and produce().

perigee_location_

std::vector<double> tracking::reco::SeedFinderProcessor::perigee_location_ {-700., 0., 0}

private

Location of the perigee for the helix track parameters.

Definition at line 119 of file SeedFinderProcessor.h.

{-700., 0., 0};

Referenced by configure().

phicut_

double tracking::reco::SeedFinderProcessor::phicut_ {0.1}

private

PhiRange.

Definition at line 138 of file SeedFinderProcessor.h.

{0.1};

Referenced by configure().

piover2_

double tracking::reco::SeedFinderProcessor::piover2_ {1.5708}

private

Definition at line 135 of file SeedFinderProcessor.h.

{1.5708};

pmax_

double tracking::reco::SeedFinderProcessor::pmax_ {8}

private

Maximum cut on the momentum of the seeds.

Definition at line 124 of file SeedFinderProcessor.h.

{8};

Referenced by configure().

pmin_

double tracking::reco::SeedFinderProcessor::pmin_ {0.05}

private

Minimum cut on the momentum of the seeds.

Definition at line 121 of file SeedFinderProcessor.h.

{0.05};

Referenced by configure().

processing_time_

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

private

Definition at line 100 of file SeedFinderProcessor.h.

{0.};

seed_to_track_maker_

std::shared_ptr<tracking::sim::SeedToTrackParamMaker> tracking::reco::SeedFinderProcessor::seed_to_track_maker_

private

Definition at line 98 of file SeedFinderProcessor.h.

sim_particles_coll_name_

std::string tracking::reco::SeedFinderProcessor::sim_particles_coll_name_

private

Definition at line 114 of file SeedFinderProcessor.h.

sim_particles_event_passname_

std::string tracking::reco::SeedFinderProcessor::sim_particles_event_passname_

private

Definition at line 117 of file SeedFinderProcessor.h.

sim_particles_passname_

std::string tracking::reco::SeedFinderProcessor::sim_particles_passname_

private

Definition at line 115 of file SeedFinderProcessor.h.

strategies_

std::vector<std::string> tracking::reco::SeedFinderProcessor::strategies_ {}

private

List of stragies for seed finding.

Definition at line 148 of file SeedFinderProcessor.h.

{};

Referenced by configure().

strategy_layers_

std::vector<std::vector<int> > tracking::reco::SeedFinderProcessor::strategy_layers_ {}

private

Layer lists parsed from strategies_, one per strategy.

Definition at line 150 of file SeedFinderProcessor.h.

{};

Referenced by configure(), and produce().

tagger_trks_collection_

std::string tracking::reco::SeedFinderProcessor::tagger_trks_collection_ {"TaggerTracks"}

private

The name of the tagger Tracks (only for Recoil Seeding)

Definition at line 111 of file SeedFinderProcessor.h.

{"TaggerTracks"};

Referenced by configure(), and produce().

tagger_trks_event_collection_passname_

std::string tracking::reco::SeedFinderProcessor::tagger_trks_event_collection_passname_

private

Definition at line 116 of file SeedFinderProcessor.h.

thetacut_

double tracking::reco::SeedFinderProcessor::thetacut_ {0.2}

private

ThetaRange.

Definition at line 141 of file SeedFinderProcessor.h.

{0.2};

Referenced by configure().

truth_matching_tool_

std::shared_ptr<tracking::sim::TruthMatchingTool> tracking::reco::SeedFinderProcessor::truth_matching_tool_

private

Initial value:

=
      nullptr

Definition at line 178 of file SeedFinderProcessor.h.

u_error_

double tracking::reco::SeedFinderProcessor::u_error_

private

u error

Definition at line 182 of file SeedFinderProcessor.h.

Referenced by configure().

v_error_

double tracking::reco::SeedFinderProcessor::v_error_

private

v error

Definition at line 184 of file SeedFinderProcessor.h.

Referenced by configure().

xhit_

std::vector<float> tracking::reco::SeedFinderProcessor::xhit_

private

Definition at line 153 of file SeedFinderProcessor.h.

yhit_

std::vector<float> tracking::reco::SeedFinderProcessor::yhit_

private

Definition at line 154 of file SeedFinderProcessor.h.

z0max_

double tracking::reco::SeedFinderProcessor::z0max_ {60.}

private

Max z0 allowed for the seeds.

Definition at line 133 of file SeedFinderProcessor.h.

{60.};

Referenced by configure().

zhit_

std::vector<float> tracking::reco::SeedFinderProcessor::zhit_

private

Definition at line 155 of file SeedFinderProcessor.h.

---

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

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