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 (ldmx::Tracks &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	beforeNewRun (ldmx::RunHeader &header)
	Handle allowing producers to modify run headers before the run begins.
Public Member Functions inherited from framework::EventProcessor
	EventProcessor (const std::string &name, Process &process)
	Class constructor.
virtual	~EventProcessor ()
	Class destructor.
virtual void	onNewRun (const ldmx::RunHeader &runHeader)
	Callback for the EventProcessor to take any necessary action when the run being processed changes.
virtual void	onFileOpen (EventFile &eventFile)
	Callback for the EventProcessor to take any necessary action when a new event input ROOT file is opened.
virtual void	onFileClose (EventFile &eventFile)
	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::ActsVector< 5 > parameters, Acts::ActsVector< 5 > &helix_parameters, Acts::Vector3 ref)

Private Attributes
Acts::Vector3	bField_
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::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.
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 >	truthMatchingTool_

Additional Inherited Members
Static Public Member Functions inherited from framework::EventProcessor
static void	declare (const std::string &classname, int classtype, EventProcessorMaker *)
	Internal function which is part of the PluginFactory machinery.
Static Public Attributes inherited from framework::Producer
static const int	CLASSTYPE {1}
	Constant used to track EventProcessor types by the PluginFactory.
Protected Member Functions inherited from tracking::reco::TrackingGeometryUser
const Acts::GeometryContext &	geometry_context ()
const Acts::MagneticFieldContext &	magnetic_field_context ()
const Acts::CalibrationContext &	calibration_context ()
const geo::TrackersTrackingGeometry &	geometry ()
Protected Member Functions inherited from framework::EventProcessor
void	abortEvent ()
	Abort the event immediately.
Protected Attributes inherited from framework::EventProcessor
HistogramHelper	histograms_
	Interface class for making and filling histograms.
NtupleManager &	ntuple_ {NtupleManager::getInstance()}
	Manager for any ntuples.
logging::logger	theLog_
	The logger for this EventProcessor.

Detailed Description

Definition at line 40 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 20 of file SeedFinderProcessor.cxx.

    : TrackingGeometryUser(name, process) {
  // TODO REMOVE FROM DEFAULT
  /*
  outputFile_ = new TFile("seeder.root", "RECREATE");
  outputTree_ = new TTree("seeder", "seeder");
 
  outputTree_->Branch("nevents", &nevents_);
  outputTree_->Branch("xhit", &xhit_);
  outputTree_->Branch("yhit", &yhit_);
  outputTree_->Branch("zhit", &zhit_);
 
  outputTree_->Branch("b0", &b0_);
  outputTree_->Branch("b1", &b1_);
  outputTree_->Branch("b2", &b2_);
  outputTree_->Branch("b3", &b3_);
  outputTree_->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 45 of file SeedFinderProcessor.cxx.

                                                                         {
  // Output seed name
  out_seed_collection_ = parameters.getParameter<std::string>(
      "out_seed_collection", getName() + "SeedTracks");
 
  // Input strip hits
  input_hits_collection_ = parameters.getParameter<std::string>(
      "input_hits_collection", "TaggerSimHits");
 
  // Tagger tracks - only for Recoil Seed finding
  tagger_trks_collection_ = parameters.getParameter<std::string>(
      "tagger_trks_collection", "TaggerTracks");
 
  perigee_location_ = parameters.getParameter<std::vector<double>>(
      "perigee_location", {-700, 0., 0.});
  pmin_ =
      parameters.getParameter<double>("pmin", 0.05 * Acts::UnitConstants::GeV);
  pmax_ = parameters.getParameter<double>("pmax", 8 * Acts::UnitConstants::GeV);
  d0max_ =
      parameters.getParameter<double>("d0max", -15. * Acts::UnitConstants::mm);
  d0min_ =
      parameters.getParameter<double>("d0min", -45. * Acts::UnitConstants::mm);
  z0max_ =
      parameters.getParameter<double>("z0max", 60. * Acts::UnitConstants::mm);
 
  phicut_ = parameters.getParameter<double>("phicut", 0.1);
  thetacut_ = parameters.getParameter<double>("thetacut", 0.2);
 
  loc0cut_ = parameters.getParameter<double>("loc0cut", 0.1);
  loc1cut_ = parameters.getParameter<double>("loc1cut", 0.3);
 
  strategies_ = parameters.getParameter<std::vector<std::string>>(
      "strategies", {"0,1,2,3,4"});
 
  inflate_factors_ = parameters.getParameter<std::vector<double>>(
      "inflate_factors", {10., 10., 10., 10., 10., 10.});
 
  bfield_ = parameters.getParameter<double>("bfield", 1.5);
 
  input_pass_name_ =
      parameters.getParameter<std::string>("input_pass_name", "");
}

References d0max_, d0min_, framework::EventProcessor::getName(), input_hits_collection_, loc0cut_, out_seed_collection_, perigee_location_, phicut_, pmax_, pmin_, strategies_, tagger_trks_collection_, thetacut_, and z0max_.

FindSeedsFromMap()

void tracking::reco::SeedFinderProcessor::FindSeedsFromMap	(	ldmx::Tracks &	seeds,
		const ldmx::Measurements &	pmeas )

Definition at line 467 of file SeedFinderProcessor.cxx.

                                                                          {
  std::map<int, std::vector<const ldmx::Measurement*>>::iterator groups_iter =
      groups_map.begin();
  // Vector of iterators
  constexpr size_t K = 5;
  std::vector<std::vector<const ldmx::Measurement*>::iterator> it;
  it.reserve(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]
 
  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(5);
 
    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() < 5) {
      nmissing_++;
      return;
    }
 
    ldmx_log(debug) << "making seedTrack";
 
    Acts::Vector3 perigee{perigee_location_[0], perigee_location_[1],
                          perigee_location_[2]};
 
    ldmx::Track seedTrack =
        SeedTracker(meas_for_seeds, meas_for_seeds.at(2).getGlobalPosition()[0],
                    perigee, pmeas);
 
    bool fail = false;
 
    // Remove failed fits
    if (1. / abs(seedTrack.getQoP()) < pmin_) {
      nfailpmin_++;
      fail = true;
    } else if (1. / abs(seedTrack.getQoP()) > pmax_) {
      nfailpmax_++;
      fail = true;
    }
 
    // Remove large part of fake tracks and duplicates with the following cuts
    // for various compatibility checks.
 
    else if (abs(seedTrack.getZ0()) > z0max_) {
      nfailz0max_++;
      fail = true;
    } else if (seedTrack.getD0() < d0min_) {
      nfaild0min_++;
      fail = true;
    } else if (seedTrack.getD0() > d0max_) {
      nfaild0max_++;
      fail = true;
    } else if (abs(seedTrack.getPhi()) > phicut_) {
      fail = true;
      nfailphi_++;
    } else if (abs(seedTrack.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 =
            seedTrack.getD0() - tgt_pseudomeas.getLocalPosition()[0];
        double delta_loc1 =
            seedTrack.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 (truthMatchingTool_->configured()) {
        auto truthInfo = truthMatchingTool_->TruthMatch(meas_for_seeds);
        seedTrack.setTrackID(truthInfo.trackID);
        seedTrack.setPdgID(truthInfo.pdgID);
        seedTrack.setTruthProb(truthInfo.truthProb);
      }
 
      seeds.push_back(seedTrack);
    }
 
    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 437 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() < 5)
    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 414 of file SeedFinderProcessor.cxx.

                                       {
  // outputFile_->cd();
  // outputTree_->Write();
  // outputFile_->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 41 of file SeedFinderProcessor.cxx.

                                         {
  truthMatchingTool_ = 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 88 of file SeedFinderProcessor.cxx.

                                                       {
  // tg is unused, should it be? FIXME
  // const auto& tg{geometry()};
  auto start = std::chrono::high_resolution_clock::now();
  ldmx::Tracks seed_tracks;
 
  nevents_++;
 
  // check if SimParticleMap is available for truth matching
  std::map<int, ldmx::SimParticle> particleMap;
 
  const std::vector<ldmx::Measurement> measurements =
      event.getCollection<ldmx::Measurement>(input_hits_collection_,
                                             input_pass_name_);
 
  std::vector<ldmx::Track> tagger_tracks;
  if (event.exists(tagger_trks_collection_)) {
    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) {
    auto ts = tagtrk.getTrackState(ldmx::TrackStateType::AtTarget);
 
    // 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.
 
    if (ts.has_value()) {
      auto trackState = ts.value();
 
      Acts::BoundSquareMatrix cov =
          tracking::sim::utils::unpackCov(trackState.cov);
      double locu = trackState.params[0];
      double locv = trackState.params[1];
      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(geometry_context(), 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("SimParticles")) {
    particleMap = event.getMap<int, ldmx::SimParticle>("SimParticles");
    truthMatchingTool_->setup(particleMap, measurements);
  }
 
  ldmx_log(debug) << "Preparing the strategies";
 
  groups_map.clear();
  //  set the seeding strategy
  //  strategy is a list of layers from which to  make the seed
  //  this must include 5 layers; layer numbering starts at 0.
  //  std::vector<int> strategy = {9,10,11,12,13};
  std::vector<int> strategy = {0, 1, 2, 3, 4};
  bool success = GroupStrips(measurements, strategy);
  if (success) FindSeedsFromMap(seed_tracks, target_pseudo_meas);
 
  //  currently, we only use a single strategy but eventually
  //  we will use more.  Below is an example of how to add them
  /*
  groups_map.clear();
  strategy = {9,10,11,12,13};
  success = GroupStrips(measurements,strategy);
  if (success)
    FindSeedsFromMap(seed_tracks, target_pseudo_meas);
  */
 
  groups_map.clear();
  // outputTree_->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(), 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 224 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::ActsMatrix<5, 5> A = Acts::ActsMatrix<5, 5>::Zero();
  Acts::ActsVector<5> Y = Acts::ActsVector<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->transform(geometry_context()).rotation();
    auto tr = hit_surface->transform(geometry_context()).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::ActsMatrix<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.;
    double uError = sqrt(vmeas[0].getLocalCovariance()[0]);
 
    // TODO Fix vError for measurements
    double vError = 40. / sqrt(12);
 
    Acts::ActsMatrix<2, 2> W_i =
        Acts::ActsMatrix<2, 2>::Zero();  // weight matrix
 
    W_i(0, 0) = 1. / (uError * uError);
    W_i(1, 1) = 1. / (vError * vError);
 
    Acts::Vector2 Yprime_i = loc + offset - xoffset;
    Y += (A_i.transpose()) * W_i * Yprime_i;
 
    Acts::ActsMatrix<2, 5> WA_i = (W_i * A_i);
    A += A_i.transpose() * WA_i;
  }
 
  Acts::ActsVector<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::ActsVector<5> hlx = Acts::ActsVector<5>::Zero();
  Acts::ActsVector<3> ref{0., 0., 0.};
 
  double relativePerigeeX = perigee_location(0) - xOrigin;
 
  std::shared_ptr<const Acts::PerigeeSurface> seed_perigee =
      Acts::Surface::makeShared<Acts::PerigeeSurface>(Acts::Vector3(
          relativePerigeeX, perigee_location(1), perigee_location(2)));
 
  // in mm
  Acts::Vector3 seed_pos{relativePerigeeX,
                         B(0) + B(1) * relativePerigeeX +
                             B(2) * relativePerigeeX * relativePerigeeX,
                         B(3) + B(4) * relativePerigeeX};
  Acts::Vector3 dir{1, B(1) + 2 * B(2) * relativePerigeeX, B(4)};
  dir /= dir.norm();
 
  // Momentum at xmeas
  double p =
      0.3 * bfield_ * (1. / (2. * abs(B(2)))) * 0.001;  // R in meters, p in GeV
  // 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;
  Acts::ActsScalar 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(geometry_context(), seed_pos, dir);
 
  Acts::FreeVector seed_free = tracking::sim::utils::toFreeParameters(
      intersection.intersections()[0].position(), seed_mom, q);
 
  auto bound_params = Acts::transformFreeToBoundParameters(
                          seed_free, *seed_perigee, geometry_context())
                          .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::BoundSquareMatrix bound_cov = stddev.cwiseProduct(stddev).asDiagonal();
 
  ldmx_log(debug) << "...now putting together the seed track ...";
 
  ldmx::Track trk = ldmx::Track();
  trk.setPerigeeLocation(perigee_location(0), perigee_location(1),
                         perigee_location(2));
  trk.setChi2(0.);
  trk.setNhits(5);
  trk.setNdf(0);
  trk.setNsharedHits(0);
  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);
 
  // Store the global position and momentum at the perigee
  // TODO:: The eFreePos0 is wrong due to the linear intersection.
  // YZ are ~ correct
  trk.setPosition(seed_free[Acts::eFreePos0], seed_free[Acts::eFreePos1],
                  seed_free[Acts::eFreePos2]);
  trk.setMomentum(seed_free[Acts::eFreeDir0], seed_free[Acts::eFreeDir1],
                  seed_free[Acts::eFreeDir2]);
 
  ldmx_log(debug)
      << "...making the ParticleHypothesis ...assume electron for now";
  auto partHypo{Acts::SinglyChargedParticleHypothesis::electron()};
 
  ldmx_log(debug) << "Making BoundTrackParameters seedParameters";
  Acts::BoundTrackParameters seedParameters(
      seed_perigee, std::move(bound_params), bound_cov, partHypo);
 
  ldmx_log(debug) << "Returning seed track";
  return trk;
}

Member Data Documentation

b0_

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

private

Definition at line 151 of file SeedFinderProcessor.h.

b1_

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

private

Definition at line 152 of file SeedFinderProcessor.h.

b2_

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

private

Definition at line 153 of file SeedFinderProcessor.h.

b3_

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

private

Definition at line 154 of file SeedFinderProcessor.h.

b4_

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

private

Definition at line 155 of file SeedFinderProcessor.h.

bField_

Acts::Vector3 tracking::reco::SeedFinderProcessor::bField_

private

Definition at line 92 of file SeedFinderProcessor.h.

bfield_

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

private

Definition at line 145 of file SeedFinderProcessor.h.

{1.5};

d0max_

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

private

Max d0 allowed for the seeds.

Definition at line 123 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 126 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 169 of file SeedFinderProcessor.h.

inflate_factors_

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

private

Definition at line 105 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 110 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 113 of file SeedFinderProcessor.h.

{""};

loc0cut_

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

private

loc0 / loc1 cuts

Definition at line 140 of file SeedFinderProcessor.h.

{0.1};

Referenced by configure().

loc1cut_

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

private

Definition at line 141 of file SeedFinderProcessor.h.

{0.3};

ndoubles_

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

private

Definition at line 158 of file SeedFinderProcessor.h.

{0};

nevents_

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

private

Definition at line 102 of file SeedFinderProcessor.h.

{0};

nfaild0max_

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

private

Definition at line 163 of file SeedFinderProcessor.h.

{0};

nfaild0min_

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

private

Definition at line 162 of file SeedFinderProcessor.h.

{0};

nfailphi_

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

private

Definition at line 165 of file SeedFinderProcessor.h.

{0};

nfailpmax_

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

private

Definition at line 161 of file SeedFinderProcessor.h.

{0};

nfailpmin_

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

private

Definition at line 160 of file SeedFinderProcessor.h.

{0};

nfailtheta_

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

private

Definition at line 166 of file SeedFinderProcessor.h.

{0};

nfailz0max_

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

private

Definition at line 164 of file SeedFinderProcessor.h.

{0};

nmissing_

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

private

Definition at line 159 of file SeedFinderProcessor.h.

{0};

ntracks_

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

private

Definition at line 103 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 108 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 115 of file SeedFinderProcessor.h.

{-700., 0., 0};

Referenced by configure().

phicut_

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

private

PhiRange.

Definition at line 134 of file SeedFinderProcessor.h.

{0.1};

Referenced by configure().

piover2_

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

private

Definition at line 131 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 120 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 117 of file SeedFinderProcessor.h.

{0.05};

Referenced by configure().

processing_time_

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

private

Definition at line 101 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 99 of file SeedFinderProcessor.h.

strategies_

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

private

List of stragies for seed finding.

Definition at line 144 of file SeedFinderProcessor.h.

{};

Referenced by configure().

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

{"TaggerTracks"};

Referenced by configure(), and produce().

thetacut_

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

private

ThetaRange.

Definition at line 137 of file SeedFinderProcessor.h.

{0.2};

Referenced by configure().

truthMatchingTool_

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

private

Initial value:

=
      nullptr

Definition at line 172 of file SeedFinderProcessor.h.

xhit_

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

private

Definition at line 147 of file SeedFinderProcessor.h.

yhit_

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

private

Definition at line 148 of file SeedFinderProcessor.h.

z0max_

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

private

Max z0 allowed for the seeds.

Definition at line 129 of file SeedFinderProcessor.h.

{60.};

Referenced by configure().

zhit_

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

private

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