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, const ldmx::Measurements &fit_constraints)
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::Measurement *constraint)
	Fit the strips plus an optional target constraint (nullptr = none)
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.
bool	prefilter_unconstrained_ {false}
	Constrained fits only after the plain fit passes the cuts.
long	nfailprefilter_ {0}
std::vector< long >	seeds_per_strategy_ {}
	Seeds found per strategy, for the end of job summary.
bool	use_target_constraint_ {false}
	Put tagger track positions at the target into the seed fit.
std::shared_ptr< Acts::Surface >	target_surface_
	Target surface the constraints live on.
bool	warned_ambiguous_tagger_ {false}
	Warn only once about several tagger track collections.
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 27 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 25 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 51 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"});
  use_target_constraint_ = parameters.get<bool>("use_target_constraint", false);
  prefilter_unconstrained_ =
      parameters.get<bool>("prefilter_unconstrained", false);
 
  if (use_target_constraint_ && tagger_trks_collection_.empty()) {
    EXCEPTION_RAISE("BadConf",
                    "use_target_constraint needs a tagger_trks_collection");
  }
 
  // 5 fit parameters: one equation per strip, two per target constraint
  const size_t min_layers = use_target_constraint_ ? 4 : 5;
 
  // 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));
    }
    std::set<int> distinct(layers.begin(), layers.end());
    if (distinct.size() < min_layers) {
      EXCEPTION_RAISE("BadConf",
                      "Seeding strategy '" + strategy + "' has fewer than " +
                          std::to_string(min_layers) + " 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_, prefilter_unconstrained_, strategies_, strategy_layers_, tagger_trks_collection_, thetacut_, u_error_, use_target_constraint_, v_error_, and z0max_.

findSeedsFromMap()

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

Definition at line 530 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]};
 
    // one seed per constraint; nullptr is the unconstrained fit
    std::vector<const ldmx::Measurement*> constraints;
    for (const auto& c : fit_constraints) constraints.push_back(&c);
    if (constraints.empty()) constraints.push_back(nullptr);
 
    // constrained fits only for combinations whose plain fit passes the
    // cuts; otherwise the constraint lets many fake combinations through
    if (prefilter_unconstrained_ && constraints.front() != nullptr &&
        meas_for_seeds.size() >= 5) {
      ldmx::Track plain = seedTracker(
          meas_for_seeds, meas_for_seeds.at(k / 2).getGlobalPosition()[0],
          perigee, nullptr);
      b0_.pop_back();
      b1_.pop_back();
      b2_.pop_back();
      b3_.pop_back();
      b4_.pop_back();
      const double p = 1. / std::abs(plain.getQoP());
      if (p < pmin_ || p > pmax_ || std::abs(plain.getZ0()) > z0max_ ||
          plain.getD0() < d0min_ || plain.getD0() > d0max_ ||
          std::abs(plain.getPhi()) > phicut_ ||
          std::abs(plain.getTheta() - piover2_) > thetacut_) {
        nfailprefilter_++;
        constraints.clear();
      }
    }
 
    for (const auto* constraint : constraints) {
      // 5 parameters need 5 equations: one per strip, two per constraint
      if (meas_for_seeds.size() + (constraint ? 2 : 0) < 5) {
        nmissing_++;
        continue;
      }
 
      ldmx::Track seed_track = seedTracker(
          meas_for_seeds, meas_for_seeds.at(k / 2).getGlobalPosition()[0],
          perigee, constraint);
 
      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
 
      // the tagger seeder has no tagger_trks_collection, so pmeas is empty
      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();
      }
    }  // constraints
 
    // 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 500 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 470 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_;
  for (size_t is = 0; is < seeds_per_strategy_.size(); ++is) {
    ldmx_log(info) << "  strategy '" << strategies_[is]
                   << "' seeds: " << seeds_per_strategy_[is];
  }
  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_;
  if (prefilter_unconstrained_) {
    ldmx_log(info) << "   nfailprefilter=" << nfailprefilter_;
  }
}

References prefilter_unconstrained_, seeds_per_strategy_, and strategies_.

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 46 of file SeedFinderProcessor.cxx.

                                         {
  truth_matching_tool_ = std::make_shared<tracking::sim::TruthMatchingTool>();
  target_surface_ = tracking::sim::utils::unboundSurface(0.);
}

References target_surface_.

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 122 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_);
 
  // tagger tracks give the target position; an empty name disables it
  std::vector<ldmx::Track> tagger_tracks;
  if (!tagger_trks_collection_.empty()) {
    // prefer this pass so a re-reco does not see two copies
    std::string pass = tagger_trks_event_collection_passname_;
    if (pass.empty() &&
        event.exists(tagger_trks_collection_, event.getPassName())) {
      pass = event.getPassName();
    }
    if (event.exists(tagger_trks_collection_, pass)) {
      tagger_tracks =
          event.getCollection<ldmx::Track>(tagger_trks_collection_, pass);
    } else if (use_target_constraint_) {
      // the target constraint needs the tagger tracker
      if (event.exists(tagger_trks_collection_, pass, false)) {
        EXCEPTION_RAISE("BadConf",
                        "Several '" + tagger_trks_collection_ +
                            "' collections found, set "
                            "tagger_trks_event_collection_passname to pick "
                            "one");
      }
      EXCEPTION_RAISE("NoTaggerTracks", "No '" + tagger_trks_collection_ +
                                            "' collection for the target "
                                            "constraint, run tagger tracking");
    } else if (!warned_ambiguous_tagger_ &&
               event.exists(tagger_trks_collection_, pass, false)) {
      ldmx_log(warn) << "Several '" << tagger_trks_collection_
                     << "' collections found, set "
                        "tagger_trks_event_collection_passname to pick one";
      warned_ambiguous_tagger_ = true;
    }
  }
 
  const auto& tgt_surf = target_surface_;
 
  // 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);
    }
  }
 
  // Constraints that enter the fit: tagger tracks only
  ldmx::Measurements fit_constraints;
  if (use_target_constraint_) fit_constraints = target_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
  seeds_per_strategy_.resize(strategy_layers_.size(), 0);
  for (size_t is = 0; is < strategy_layers_.size(); ++is) {
    groups_map_.clear();
    const size_t n_before = seed_tracks.size();
    if (groupStrips(measurements, strategy_layers_[is]))
      findSeedsFromMap(seed_tracks, target_pseudo_meas, fit_constraints);
    seeds_per_strategy_[is] += seed_tracks.size() - n_before;
  }
 
  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(), framework::Event::getPassName(), input_hits_collection_, out_seed_collection_, seeds_per_strategy_, ldmx::Measurement::setGlobalPosition(), ldmx::Measurement::setLocalCovariance(), ldmx::Measurement::setLocalPosition(), ldmx::Measurement::setTime(), strategy_layers_, tagger_trks_collection_, target_surface_, use_target_constraint_, and warned_ambiguous_tagger_.

seedTracker()

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

private

Fit the strips plus an optional target constraint (nullptr = none)

Definition at line 280 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();
 
  // accumulate one 2D point on a surface into the normal equations
  auto add_point = [&](const Acts::Surface& surface, const Acts::Vector2& loc,
                       double xmeas, double var_u, double var_v) {
    auto rot = surface.localToGlobalTransform(geometryContext()).rotation();
    auto tr = surface.localToGlobalTransform(geometryContext()).translation();
    auto rotl2g = rot.transpose();
 
    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;
 
    Acts::Vector2 offset = (rot.transpose() * tr).topRows<2>();
    Acts::Vector2 xoffset = {rotl2g(0, 0) * xmeas, rotl2g(1, 0) * xmeas};
 
    Acts::Matrix<2, 2> w_i = Acts::Matrix<2, 2>::Zero();
    w_i(0, 0) = 1. / var_u;
    w_i(1, 1) = 1. / var_v;
 
    Acts::Vector2 yprime_i = loc + offset - xoffset;
    y += (a_i.transpose()) * w_i * yprime_i;
    a += a_i.transpose() * (w_i * a_i);
  };
 
  for (auto meas : vmeas) {
    double xmeas = meas.getGlobalPosition()[0] - xOrigin;
    const Acts::Surface* hit_surface = geometry().getSurface(meas.getLayerID());
 
    xhit_.push_back(xmeas);
    yhit_.push_back(meas.getGlobalPosition()[1]);
    zhit_.push_back(meas.getGlobalPosition()[2]);
 
    // strips measure u only; v sits at the strip center
    Acts::Vector2 loc{meas.getLocalPosition()[0], 0.};
    add_point(*hit_surface, loc, xmeas, u_error_ * u_error_,
              v_error_ * v_error_);
  }
 
  if (constraint) {
    double xmeas = constraint->getGlobalPosition()[0] - xOrigin;
    Acts::Vector2 loc{constraint->getLocalPosition()[0],
                      constraint->getLocalPosition()[1]};
    auto cov = constraint->getLocalCovariance();
    // floor at (1 um)^2 so a missing covariance cannot blow up the weight
    add_point(*target_surface_, loc, xmeas, std::max<double>(cov[0], 1e-6),
              std::max<double>(cov[1], 1e-6));
  }
 
  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(vmeas.size());
  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;
}

References ldmx::Measurement::getGlobalPosition(), ldmx::Measurement::getLocalCovariance(), ldmx::Measurement::getLocalPosition(), target_surface_, u_error_, and v_error_.

Member Data Documentation

b0_

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

private

Definition at line 159 of file SeedFinderProcessor.h.

b1_

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

private

Definition at line 160 of file SeedFinderProcessor.h.

b2_

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

private

Definition at line 161 of file SeedFinderProcessor.h.

b3_

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

private

Definition at line 162 of file SeedFinderProcessor.h.

b4_

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

private

Definition at line 163 of file SeedFinderProcessor.h.

b_field_

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

private

Definition at line 82 of file SeedFinderProcessor.h.

bfield_

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

private

Definition at line 153 of file SeedFinderProcessor.h.

{1.5};

d0max_

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

private

Max d0 allowed for the seeds.

Definition at line 118 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 121 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 177 of file SeedFinderProcessor.h.

inflate_factors_

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

private

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

{""};

loc0cut_

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

private

loc0 / loc1 cuts

Definition at line 135 of file SeedFinderProcessor.h.

{0.1};

Referenced by configure().

loc1cut_

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

private

Definition at line 136 of file SeedFinderProcessor.h.

{0.3};

ndoubles_

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

private

Definition at line 166 of file SeedFinderProcessor.h.

{0};

nevents_

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

private

Definition at line 92 of file SeedFinderProcessor.h.

{0};

nfaild0max_

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

private

Definition at line 171 of file SeedFinderProcessor.h.

{0};

nfaild0min_

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

private

Definition at line 170 of file SeedFinderProcessor.h.

{0};

nfailphi_

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

private

Definition at line 173 of file SeedFinderProcessor.h.

{0};

nfailpmax_

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

private

Definition at line 169 of file SeedFinderProcessor.h.

{0};

nfailpmin_

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

private

Definition at line 168 of file SeedFinderProcessor.h.

{0};

nfailprefilter_

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

private

Definition at line 144 of file SeedFinderProcessor.h.

{0};

nfailtheta_

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

private

Definition at line 174 of file SeedFinderProcessor.h.

{0};

nfailz0max_

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

private

Definition at line 172 of file SeedFinderProcessor.h.

{0};

nmissing_

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

private

Definition at line 167 of file SeedFinderProcessor.h.

{0};

ntracks_

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

private

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

{-700., 0., 0};

Referenced by configure().

phicut_

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

private

PhiRange.

Definition at line 129 of file SeedFinderProcessor.h.

{0.1};

Referenced by configure().

piover2_

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

private

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

{0.05};

Referenced by configure().

prefilter_unconstrained_

bool tracking::reco::SeedFinderProcessor::prefilter_unconstrained_ {false}

private

Constrained fits only after the plain fit passes the cuts.

Definition at line 143 of file SeedFinderProcessor.h.

{false};

Referenced by configure(), and onProcessEnd().

processing_time_

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

private

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

seeds_per_strategy_

std::vector<long> tracking::reco::SeedFinderProcessor::seeds_per_strategy_ {}

private

Seeds found per strategy, for the end of job summary.

Definition at line 146 of file SeedFinderProcessor.h.

{};

Referenced by onProcessEnd(), and produce().

sim_particles_coll_name_

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

private

Definition at line 105 of file SeedFinderProcessor.h.

sim_particles_event_passname_

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

private

Definition at line 108 of file SeedFinderProcessor.h.

sim_particles_passname_

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

private

Definition at line 106 of file SeedFinderProcessor.h.

strategies_

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

private

List of stragies for seed finding.

Definition at line 139 of file SeedFinderProcessor.h.

{};

Referenced by configure(), and onProcessEnd().

strategy_layers_

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

private

Layer lists parsed from strategies_, one per strategy.

Definition at line 141 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 102 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 107 of file SeedFinderProcessor.h.

target_surface_

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

private

Target surface the constraints live on.

Definition at line 150 of file SeedFinderProcessor.h.

Referenced by onProcessStart(), produce(), and seedTracker().

thetacut_

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

private

ThetaRange.

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

u_error_

double tracking::reco::SeedFinderProcessor::u_error_

private

u error

Definition at line 184 of file SeedFinderProcessor.h.

Referenced by configure(), and seedTracker().

use_target_constraint_

bool tracking::reco::SeedFinderProcessor::use_target_constraint_ {false}

private

Put tagger track positions at the target into the seed fit.

Definition at line 148 of file SeedFinderProcessor.h.

{false};

Referenced by configure(), and produce().

v_error_

double tracking::reco::SeedFinderProcessor::v_error_

private

v error

Definition at line 186 of file SeedFinderProcessor.h.

Referenced by configure(), and seedTracker().

warned_ambiguous_tagger_

bool tracking::reco::SeedFinderProcessor::warned_ambiguous_tagger_ {false}

private

Warn only once about several tagger track collections.

Definition at line 152 of file SeedFinderProcessor.h.

{false};

Referenced by produce().

xhit_

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

private

Definition at line 155 of file SeedFinderProcessor.h.

yhit_

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

private

Definition at line 156 of file SeedFinderProcessor.h.

z0max_

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

private

Max z0 allowed for the seeds.

Definition at line 124 of file SeedFinderProcessor.h.

{60.};

Referenced by configure().

zhit_

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

private

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