AnalyticalTrackSelector Class Reference

Inheritance diagram for AnalyticalTrackSelector:

Public Member Functions
	AnalyticalTrackSelector (const edm::ParameterSet &cfg)
	constructor More...
	~AnalyticalTrackSelector () override
	destructor More...
Public Member Functions inherited from MultiTrackSelector
	MultiTrackSelector ()
	constructor More...
	MultiTrackSelector (const edm::ParameterSet &cfg)
	~MultiTrackSelector () override
	destructor More...
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndRuns () const final

Private Types
typedef math::XYZPoint	Point

Private Member Functions
void	run (edm::Event &evt, const edm::EventSetup &es) const override
	process one event More...

Private Attributes
bool	copyExtras_
	copy only the tracks, not extras and rechits (for AOD) More...
bool	copyTrajectories_
	copy also trajectories and trajectory->track associations More...
double	maxEta_
double	minEta_
	eta restrictions More...
edm::EDGetTokenT< TrajTrackAssociationCollection >	srcTass_
edm::EDGetTokenT< std::vector< Trajectory > >	srcTraj_

Additional Inherited Members
Public Types inherited from MultiTrackSelector
using	MVACollection = std::vector< float >
using	QualityMaskCollection = std::vector< unsigned char >
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T... >	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache
Protected Types inherited from MultiTrackSelector
typedef math::XYZPoint	Point
Protected Member Functions inherited from MultiTrackSelector
void	beginStream (edm::StreamID) final
Point	getBestVertex (const reco::TrackBaseRef, const reco::VertexCollection) const
void	processMVA (edm::Event &evt, const edm::EventSetup &es, const reco::BeamSpot &beamspot, const reco::VertexCollection &vertices, int selIndex, std::vector< float > &mvaVals_, bool writeIt=false) const
void	produce (edm::Event &evt, const edm::EventSetup &es) final
	process one event More...
bool	select (unsigned tsNum, const reco::BeamSpot &vertexBeamSpot, const TrackingRecHitCollection &recHits, const reco::Track &tk, const std::vector< Point > &points, std::vector< float > &vterr, std::vector< float > &vzerr, double mvaVal) const
	return class, or -1 if rejected More...
void	selectVertices (unsigned int tsNum, const reco::VertexCollection &vtxs, std::vector< Point > &points, std::vector< float > &vterr, std::vector< float > &vzerr) const
Protected Attributes inherited from MultiTrackSelector
std::vector< bool >	applyAbsCutsIfNoPV_
std::vector< bool >	applyAdaptedPVCuts_
edm::EDGetTokenT< reco::BeamSpot >	beamspot_
std::vector< double >	chi2n_no1Dmod_par_
std::vector< double >	chi2n_par_
std::vector< std::vector< double > >	d0_par1_
std::vector< std::vector< double > >	d0_par2_
std::string	dbFileName_
std::vector< std::vector< double > >	dz_par1_
std::vector< std::vector< double > >	dz_par2_
std::vector< GBRForest * >	forest_
std::vector< std::string >	forestLabel_
edm::EDGetTokenT< TrackingRecHitCollection >	hSrc_
std::vector< bool >	keepAllTracks_
std::vector< double >	max_d0_
	Impact parameter absolute cuts. More...
std::vector< double >	max_d0NoPV_
std::vector< double >	max_eta_
std::vector< int32_t >	max_lostHitFraction_
std::vector< uint32_t >	max_lostLayers_
std::vector< int32_t >	max_minMissHitOutOrIn_
std::vector< double >	max_relpterr_
std::vector< double >	max_z0_
std::vector< double >	max_z0NoPV_
std::vector< uint32_t >	min_3Dlayers_
std::vector< double >	min_eta_
std::vector< uint32_t >	min_hits_bypass_
std::vector< uint32_t >	min_layers_
	Cuts on numbers of layers with hits/3D hits/lost hits. More...
std::vector< double >	min_MVA_
std::vector< uint32_t >	min_nhits_
std::vector< std::string >	mvaType_
std::vector< std::string >	name_
std::vector< double >	nSigmaZ_
std::vector< unsigned int >	preFilter_
std::vector< reco::TrackBase::TrackQuality >	qualityToSet_
std::vector< std::vector< double > >	res_par_
std::vector< bool >	setQualityBit_
	do I have to set a quality bit? More...
edm::EDGetTokenT< reco::TrackCollection >	src_
	source collection label More...
bool	useAnyMVA_
bool	useForestFromDB_
std::vector< bool >	useMVA_
std::vector< bool >	useMVAonly_
bool	useVertices_
bool	useVtxError_
std::vector< StringCutObjectSelector< reco::Vertex > >	vertexCut_
edm::EDGetTokenT< reco::VertexCollection >	vertices_
std::vector< int32_t >	vtxNumber_
	vertex cuts More...

Detailed Description

selects a subset of a track collection, copying extra information on demand

Author

Paolo Azzurri, Giovanni Petrucciani

Definition at line 36 of file AnalyticalTrackSelector.cc.

Member Typedef Documentation

Point

typedef math::XYZPoint AnalyticalTrackSelector::Point

private

Definition at line 45 of file AnalyticalTrackSelector.cc.

Constructor & Destructor Documentation

AnalyticalTrackSelector()

AnalyticalTrackSelector::AnalyticalTrackSelector ( const edm::ParameterSet &  cfg )

explicit

constructor

Definition at line 67 of file AnalyticalTrackSelector.cc.

                                                                           : MultiTrackSelector() {
  //Spoof the pset for each track selector!
  //Size is always 1!!!
  qualityToSet_.reserve(1);
  vtxNumber_.reserve(1);
  vertexCut_.reserve(1);
  res_par_.reserve(1);
  chi2n_par_.reserve(1);
  chi2n_no1Dmod_par_.reserve(1);
  d0_par1_.reserve(1);
  dz_par1_.reserve(1);
  d0_par2_.reserve(1);
  dz_par2_.reserve(1);
  applyAdaptedPVCuts_.reserve(1);
  max_d0_.reserve(1);
  max_z0_.reserve(1);
  nSigmaZ_.reserve(1);
  min_layers_.reserve(1);
  min_3Dlayers_.reserve(1);
  max_lostLayers_.reserve(1);
  min_hits_bypass_.reserve(1);
  applyAbsCutsIfNoPV_.reserve(1);
  max_d0NoPV_.reserve(1);
  max_z0NoPV_.reserve(1);
  preFilter_.reserve(1);
  max_relpterr_.reserve(1);
  min_nhits_.reserve(1);
  max_minMissHitOutOrIn_.reserve(1);
  max_lostHitFraction_.reserve(1);
  min_eta_.reserve(1);
  max_eta_.reserve(1);
  forest_.reserve(1);
  mvaType_.reserve(1);
  useMVA_.reserve(1);
 
  produces<edm::ValueMap<float>>("MVAVals");
  //foward compatibility
  produces<MVACollection>("MVAValues");
  useAnyMVA_ = false;
  forest_[0] = nullptr;
  if (cfg.exists("useAnyMVA"))
    useAnyMVA_ = cfg.getParameter<bool>("useAnyMVA");
 
  src_ = consumes<reco::TrackCollection>(cfg.getParameter<edm::InputTag>("src"));
  hSrc_ = consumes<TrackingRecHitCollection>(cfg.getParameter<edm::InputTag>("src"));
  beamspot_ = consumes<reco::BeamSpot>(cfg.getParameter<edm::InputTag>("beamspot"));
  useVertices_ = cfg.getParameter<bool>("useVertices");
  useVtxError_ = cfg.getParameter<bool>("useVtxError");
  if (useVertices_)
    vertices_ = consumes<reco::VertexCollection>(cfg.getParameter<edm::InputTag>("vertices"));
  copyExtras_ = cfg.getUntrackedParameter<bool>("copyExtras", false);
  copyTrajectories_ = cfg.getUntrackedParameter<bool>("copyTrajectories", false);
  if (copyTrajectories_) {
    srcTraj_ = consumes<std::vector<Trajectory>>(cfg.getParameter<edm::InputTag>("src"));
    srcTass_ = consumes<TrajTrackAssociationCollection>(cfg.getParameter<edm::InputTag>("src"));
  }
 
  qualityToSet_.push_back(TrackBase::undefQuality);
  // parameters for vertex selection
  vtxNumber_.push_back(useVertices_ ? cfg.getParameter<int32_t>("vtxNumber") : 0);
  vertexCut_.push_back(useVertices_ ? cfg.getParameter<std::string>("vertexCut") : "");
  //  parameters for adapted optimal cuts on chi2 and primary vertex compatibility
  res_par_.push_back(cfg.getParameter<std::vector<double>>("res_par"));
  chi2n_par_.push_back(cfg.getParameter<double>("chi2n_par"));
  chi2n_no1Dmod_par_.push_back(cfg.getParameter<double>("chi2n_no1Dmod_par"));
  d0_par1_.push_back(cfg.getParameter<std::vector<double>>("d0_par1"));
  dz_par1_.push_back(cfg.getParameter<std::vector<double>>("dz_par1"));
  d0_par2_.push_back(cfg.getParameter<std::vector<double>>("d0_par2"));
  dz_par2_.push_back(cfg.getParameter<std::vector<double>>("dz_par2"));
 
  // Boolean indicating if adapted primary vertex compatibility cuts are to be applied.
  applyAdaptedPVCuts_.push_back(cfg.getParameter<bool>("applyAdaptedPVCuts"));
  // Impact parameter absolute cuts.
  max_d0_.push_back(cfg.getParameter<double>("max_d0"));
  max_z0_.push_back(cfg.getParameter<double>("max_z0"));
  nSigmaZ_.push_back(cfg.getParameter<double>("nSigmaZ"));
  // Cuts on numbers of layers with hits/3D hits/lost hits.
  min_layers_.push_back(cfg.getParameter<uint32_t>("minNumberLayers"));
  min_3Dlayers_.push_back(cfg.getParameter<uint32_t>("minNumber3DLayers"));
  max_lostLayers_.push_back(cfg.getParameter<uint32_t>("maxNumberLostLayers"));
  min_hits_bypass_.push_back(cfg.getParameter<uint32_t>("minHitsToBypassChecks"));
  max_relpterr_.push_back(cfg.getParameter<double>("max_relpterr"));
  min_nhits_.push_back(cfg.getParameter<uint32_t>("min_nhits"));
  max_minMissHitOutOrIn_.push_back(
      cfg.existsAs<int32_t>("max_minMissHitOutOrIn") ? cfg.getParameter<int32_t>("max_minMissHitOutOrIn") : 99);
  max_lostHitFraction_.push_back(
      cfg.existsAs<double>("max_lostHitFraction") ? cfg.getParameter<double>("max_lostHitFraction") : 1.0);
  min_eta_.push_back(cfg.getParameter<double>("min_eta"));
  max_eta_.push_back(cfg.getParameter<double>("max_eta"));
 
  // Flag to apply absolute cuts if no PV passes the selection
  applyAbsCutsIfNoPV_.push_back(cfg.getParameter<bool>("applyAbsCutsIfNoPV"));
  keepAllTracks_.push_back(cfg.exists("keepAllTracks") ? cfg.getParameter<bool>("keepAllTracks") : false);
 
  setQualityBit_.push_back(false);
  std::string qualityStr = cfg.getParameter<std::string>("qualityBit");
 
  if (d0_par1_[0].size() != 2 || dz_par1_[0].size() != 2 || d0_par2_[0].size() != 2 || dz_par2_[0].size() != 2) {
    edm::LogError("MisConfiguration") << "vector of size less then 2";
    throw;
  }
 
  if (cfg.exists("qualityBit")) {
    std::string qualityStr = cfg.getParameter<std::string>("qualityBit");
    if (!qualityStr.empty()) {
      setQualityBit_[0] = true;
      qualityToSet_[0] = TrackBase::qualityByName(cfg.getParameter<std::string>("qualityBit"));
    }
  }
 
  if (keepAllTracks_[0] && !setQualityBit_[0])
    throw cms::Exception("Configuration")
        << "If you set 'keepAllTracks' to true, you must specify which qualityBit to set.\n";
  if (setQualityBit_[0] && (qualityToSet_[0] == TrackBase::undefQuality))
    throw cms::Exception("Configuration")
        << "You can't set the quality bit " << cfg.getParameter<std::string>("qualityBit")
        << " as it is 'undefQuality' or unknown.\n";
  if (applyAbsCutsIfNoPV_[0]) {
    max_d0NoPV_.push_back(cfg.getParameter<double>("max_d0NoPV"));
    max_z0NoPV_.push_back(cfg.getParameter<double>("max_z0NoPV"));
  } else {  //dummy values
    max_d0NoPV_.push_back(0.);
    max_z0NoPV_.push_back(0.);
  }
 
  if (useAnyMVA_) {
    bool thisMVA = false;
    if (cfg.exists("useMVA"))
      thisMVA = cfg.getParameter<bool>("useMVA");
    useMVA_.push_back(thisMVA);
    if (thisMVA) {
      double minVal = -1;
      if (cfg.exists("minMVA"))
        minVal = cfg.getParameter<double>("minMVA");
      min_MVA_.push_back(minVal);
      mvaType_.push_back(cfg.exists("mvaType") ? cfg.getParameter<std::string>("mvaType") : "Detached");
      forestLabel_.push_back(cfg.exists("GBRForestLabel") ? cfg.getParameter<std::string>("GBRForestLabel")
                                                          : "MVASelectorIter0");
      useMVAonly_.push_back(cfg.exists("useMVAonly") ? cfg.getParameter<bool>("useMVAonly") : false);
    } else {
      min_MVA_.push_back(-9999.0);
      useMVAonly_.push_back(false);
      mvaType_.push_back("Detached");
      forestLabel_.push_back("MVASelectorIter0");
    }
  } else {
    useMVA_.push_back(false);
    useMVAonly_.push_back(false);
    min_MVA_.push_back(-9999.0);
    mvaType_.push_back("Detached");
    forestLabel_.push_back("MVASelectorIter0");
  }
 
  std::string alias(cfg.getParameter<std::string>("@module_label"));
  produces<reco::TrackCollection>().setBranchAlias(alias + "Tracks");
  if (copyExtras_) {
    produces<reco::TrackExtraCollection>().setBranchAlias(alias + "TrackExtras");
    produces<TrackingRecHitCollection>().setBranchAlias(alias + "RecHits");
  }
  if (copyTrajectories_) {
    produces<std::vector<Trajectory>>().setBranchAlias(alias + "Trajectories");
    produces<TrajTrackAssociationCollection>().setBranchAlias(alias + "TrajectoryTrackAssociations");
  }
}

References SiStripOfflineCRack_cfg::alias, MultiTrackSelector::applyAbsCutsIfNoPV_, MultiTrackSelector::applyAdaptedPVCuts_, MultiTrackSelector::beamspot_, looper::cfg, MultiTrackSelector::chi2n_no1Dmod_par_, MultiTrackSelector::chi2n_par_, copyExtras_, copyTrajectories_, MultiTrackSelector::d0_par1_, MultiTrackSelector::d0_par2_, MultiTrackSelector::dz_par1_, MultiTrackSelector::dz_par2_, Exception, MultiTrackSelector::forest_, MultiTrackSelector::forestLabel_, MultiTrackSelector::hSrc_, MultiTrackSelector::keepAllTracks_, MultiTrackSelector::max_d0_, MultiTrackSelector::max_d0NoPV_, MultiTrackSelector::max_eta_, MultiTrackSelector::max_lostHitFraction_, MultiTrackSelector::max_lostLayers_, MultiTrackSelector::max_minMissHitOutOrIn_, MultiTrackSelector::max_relpterr_, MultiTrackSelector::max_z0_, MultiTrackSelector::max_z0NoPV_, MultiTrackSelector::min_3Dlayers_, MultiTrackSelector::min_eta_, MultiTrackSelector::min_hits_bypass_, MultiTrackSelector::min_layers_, MultiTrackSelector::min_MVA_, MultiTrackSelector::min_nhits_, MultiTrackSelector::mvaType_, MultiTrackSelector::nSigmaZ_, MultiTrackSelector::preFilter_, MultiTrackSelector::qualityToSet_, MultiTrackSelector::res_par_, MultiTrackSelector::setQualityBit_, findQualityFiles::size, MultiTrackSelector::src_, srcTass_, srcTraj_, AlCaHLTBitMon_QueryRunRegistry::string, MultiTrackSelector::useAnyMVA_, MultiTrackSelector::useMVA_, MultiTrackSelector::useMVAonly_, MultiTrackSelector::useVertices_, MultiTrackSelector::useVtxError_, MultiTrackSelector::vertexCut_, MultiTrackSelector::vertices_, and MultiTrackSelector::vtxNumber_.

~AnalyticalTrackSelector()

AnalyticalTrackSelector::~AnalyticalTrackSelector ( )

override

destructor

Definition at line 232 of file AnalyticalTrackSelector.cc.

{}

Member Function Documentation

run()

void AnalyticalTrackSelector::run ( edm::Event &  evt, const edm::EventSetup &  es  ) const

overrideprivatevirtual

process one event

Reimplemented from MultiTrackSelector.

Definition at line 234 of file AnalyticalTrackSelector.cc.

                                                                              {
  // storage....
  std::unique_ptr<reco::TrackCollection> selTracks_;
  std::unique_ptr<reco::TrackExtraCollection> selTrackExtras_;
  std::unique_ptr<TrackingRecHitCollection> selHits_;
  std::unique_ptr<std::vector<Trajectory>> selTrajs_;
  std::unique_ptr<std::vector<const Trajectory*>> selTrajPtrs_;
  std::unique_ptr<TrajTrackAssociationCollection> selTTAss_;
  reco::TrackRefProd rTracks_;
  reco::TrackExtraRefProd rTrackExtras_;
  TrackingRecHitRefProd rHits_;
  edm::RefProd<std::vector<Trajectory>> rTrajectories_;
  std::vector<reco::TrackRef> trackRefs_;
 
  using namespace std;
  using namespace edm;
  using namespace reco;
 
  Handle<TrackCollection> hSrcTrack;
  Handle<vector<Trajectory>> hTraj;
  Handle<vector<Trajectory>> hTrajP;
  Handle<TrajTrackAssociationCollection> hTTAss;
 
  // looking for the beam spot
  edm::Handle<reco::BeamSpot> hBsp;
  evt.getByToken(beamspot_, hBsp);
  reco::BeamSpot vertexBeamSpot;
  vertexBeamSpot = *hBsp;
 
  // Select good primary vertices for use in subsequent track selection
  edm::Handle<reco::VertexCollection> hVtx;
  std::vector<Point> points;
  std::vector<float> vterr, vzerr;
  if (useVertices_) {
    evt.getByToken(vertices_, hVtx);
    selectVertices(0, *hVtx, points, vterr, vzerr);
    // Debug
    LogDebug("SelectVertex") << points.size() << " good pixel vertices";
  }
 
  // Get tracks
  evt.getByToken(src_, hSrcTrack);
  // get hits in track..
  Handle<TrackingRecHitCollection> hSrcHits;
  evt.getByToken(hSrc_, hSrcHits);
  const TrackingRecHitCollection& srcHits(*hSrcHits);
 
  selTracks_ = std::make_unique<TrackCollection>();
  rTracks_ = evt.getRefBeforePut<TrackCollection>();
  if (copyExtras_) {
    selTrackExtras_ = std::make_unique<TrackExtraCollection>();
    selHits_ = std::make_unique<TrackingRecHitCollection>();
    rHits_ = evt.getRefBeforePut<TrackingRecHitCollection>();
    rTrackExtras_ = evt.getRefBeforePut<TrackExtraCollection>();
  }
 
  if (copyTrajectories_)
    trackRefs_.resize(hSrcTrack->size());
 
  std::vector<float> mvaVals_(hSrcTrack->size(), -99.f);
  processMVA(evt, es, vertexBeamSpot, *(hVtx.product()), 0, mvaVals_, true);
 
  // Loop over tracks
  size_t current = 0;
  for (TrackCollection::const_iterator it = hSrcTrack->begin(), ed = hSrcTrack->end(); it != ed; ++it, ++current) {
    const Track& trk = *it;
    // Check if this track passes cuts
 
    LogTrace("TrackSelection") << "ready to check track with pt=" << trk.pt();
 
    float mvaVal = 0;
    if (useAnyMVA_)
      mvaVal = mvaVals_[current];
    bool ok = select(0, vertexBeamSpot, srcHits, trk, points, vterr, vzerr, mvaVal);
    if (!ok) {
      LogTrace("TrackSelection") << "track with pt=" << trk.pt() << " NOT selected";
 
      if (copyTrajectories_)
        trackRefs_[current] = reco::TrackRef();
      if (!keepAllTracks_[0])
        continue;
    }
    LogTrace("TrackSelection") << "track with pt=" << trk.pt() << " selected";
    selTracks_->push_back(Track(trk));  // clone and store
    if (ok && setQualityBit_[0]) {
      selTracks_->back().setQuality(qualityToSet_[0]);
      if (qualityToSet_[0] == TrackBase::tight) {
        selTracks_->back().setQuality(TrackBase::loose);
      } else if (qualityToSet_[0] == TrackBase::highPurity) {
        selTracks_->back().setQuality(TrackBase::loose);
        selTracks_->back().setQuality(TrackBase::tight);
      }
      if (!points.empty()) {
        if (qualityToSet_[0] == TrackBase::loose) {
          selTracks_->back().setQuality(TrackBase::looseSetWithPV);
        } else if (qualityToSet_[0] == TrackBase::highPurity) {
          selTracks_->back().setQuality(TrackBase::looseSetWithPV);
          selTracks_->back().setQuality(TrackBase::highPuritySetWithPV);
        }
      }
    }
    if (copyExtras_) {
      // TrackExtras
      selTrackExtras_->push_back(TrackExtra(trk.outerPosition(),
                                            trk.outerMomentum(),
                                            trk.outerOk(),
                                            trk.innerPosition(),
                                            trk.innerMomentum(),
                                            trk.innerOk(),
                                            trk.outerStateCovariance(),
                                            trk.outerDetId(),
                                            trk.innerStateCovariance(),
                                            trk.innerDetId(),
                                            trk.seedDirection(),
                                            trk.seedRef()));
      selTracks_->back().setExtra(TrackExtraRef(rTrackExtras_, selTrackExtras_->size() - 1));
      TrackExtra& tx = selTrackExtras_->back();
      tx.setResiduals(trk.residuals());
      // TrackingRecHits
      auto const firstHitIndex = selHits_->size();
      for (trackingRecHit_iterator hit = trk.recHitsBegin(); hit != trk.recHitsEnd(); ++hit) {
        selHits_->push_back((*hit)->clone());
      }
      tx.setHits(rHits_, firstHitIndex, selHits_->size() - firstHitIndex);
      tx.setTrajParams(trk.extra()->trajParams(), trk.extra()->chi2sX5());
    }
    if (copyTrajectories_) {
      trackRefs_[current] = TrackRef(rTracks_, selTracks_->size() - 1);
    }
  }
  if (copyTrajectories_) {
    Handle<vector<Trajectory>> hTraj;
    Handle<TrajTrackAssociationCollection> hTTAss;
    evt.getByToken(srcTass_, hTTAss);
    evt.getByToken(srcTraj_, hTraj);
    selTrajs_ = std::make_unique<std::vector<Trajectory>>();
    rTrajectories_ = evt.getRefBeforePut<vector<Trajectory>>();
    selTTAss_ = std::make_unique<TrajTrackAssociationCollection>(rTrajectories_, rTracks_);
    for (size_t i = 0, n = hTraj->size(); i < n; ++i) {
      Ref<vector<Trajectory>> trajRef(hTraj, i);
      TrajTrackAssociationCollection::const_iterator match = hTTAss->find(trajRef);
      if (match != hTTAss->end()) {
        const Ref<TrackCollection>& trkRef = match->val;
        short oldKey = static_cast<short>(trkRef.key());
        if (trackRefs_[oldKey].isNonnull()) {
          selTrajs_->push_back(Trajectory(*trajRef));
          selTTAss_->insert(Ref<vector<Trajectory>>(rTrajectories_, selTrajs_->size() - 1), trackRefs_[oldKey]);
        }
      }
    }
  }
 
  evt.put(std::move(selTracks_));
  if (copyExtras_) {
    evt.put(std::move(selTrackExtras_));
    evt.put(std::move(selHits_));
  }
  if (copyTrajectories_) {
    evt.put(std::move(selTrajs_));
    evt.put(std::move(selTTAss_));
  }
}

References MultiTrackSelector::beamspot_, edm::AssociationMap< edm::OneToOne< std::vector< Trajectory >, reco::TrackCollection, unsigned short > >::const_iterator, copyExtras_, copyTrajectories_, edm::AssociationMap< Tag >::end(), reco::Track::extra(), edm::AssociationMap< Tag >::find(), edm::Event::getByToken(), edm::Event::getRefBeforePut(), muons_cff::highPurity, MultiTrackSelector::hSrc_, mps_fire::i, reco::Track::innerDetId(), reco::Track::innerMomentum(), reco::Track::innerOk(), reco::Track::innerPosition(), reco::Track::innerStateCovariance(), MultiTrackSelector::keepAllTracks_, edm::Ref< C, T, F >::key(), LogDebug, LogTrace, match(), eostools::move(), dqmiodumpmetadata::n, convertSQLiteXML::ok, reco::Track::outerDetId(), reco::Track::outerMomentum(), reco::Track::outerOk(), reco::Track::outerPosition(), reco::Track::outerStateCovariance(), HLT_2018_cff::points, MultiTrackSelector::processMVA(), edm::Handle< T >::product(), reco::TrackBase::pt(), edm::Event::put(), MultiTrackSelector::qualityToSet_, reco::Track::recHitsBegin(), reco::Track::recHitsEnd(), reco::Track::residuals(), reco::Track::seedDirection(), reco::Track::seedRef(), MultiTrackSelector::select(), MultiTrackSelector::selectVertices(), reco::TrackExtraBase::setHits(), MultiTrackSelector::setQualityBit_, reco::TrackExtra::setResiduals(), reco::TrackExtraBase::setTrajParams(), edm::OwnVector< T, P >::size(), MultiTrackSelector::src_, srcTass_, srcTraj_, MultiTrackSelector::useAnyMVA_, MultiTrackSelector::useVertices_, and MultiTrackSelector::vertices_.

Member Data Documentation

copyExtras_

bool AnalyticalTrackSelector::copyExtras_

private

copy only the tracks, not extras and rechits (for AOD)

Definition at line 50 of file AnalyticalTrackSelector.cc.

Referenced by AnalyticalTrackSelector(), and run().

copyTrajectories_

bool AnalyticalTrackSelector::copyTrajectories_

private

copy also trajectories and trajectory->track associations

Definition at line 52 of file AnalyticalTrackSelector.cc.

Referenced by AnalyticalTrackSelector(), and run().

maxEta_

double AnalyticalTrackSelector::maxEta_

private

Definition at line 55 of file AnalyticalTrackSelector.cc.

minEta_

double AnalyticalTrackSelector::minEta_

private

eta restrictions

Definition at line 54 of file AnalyticalTrackSelector.cc.

srcTass_

edm::EDGetTokenT<TrajTrackAssociationCollection> AnalyticalTrackSelector::srcTass_

private

Definition at line 58 of file AnalyticalTrackSelector.cc.

Referenced by AnalyticalTrackSelector(), and run().

srcTraj_

edm::EDGetTokenT<std::vector<Trajectory> > AnalyticalTrackSelector::srcTraj_

private

Definition at line 57 of file AnalyticalTrackSelector.cc.

Referenced by AnalyticalTrackSelector(), and run().