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

typedef math::XYZPoint AnalyticalTrackSelector::Point

private

Definition at line 45 of file AnalyticalTrackSelector.cc.

Constructor & Destructor Documentation

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");
   }
 }

AnalyticalTrackSelector::~AnalyticalTrackSelector ( )

override

destructor

Definition at line 232 of file AnalyticalTrackSelector.cc.

232 {}

Member Function Documentation

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_));
   }
 }