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	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () 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 73 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 != "") {
         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 237 of file AnalyticalTrackSelector.cc.

237 {

238 }

Member Function Documentation

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

overrideprivatevirtual

process one event

Reimplemented from MultiTrackSelector.

Definition at line 241 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_));
   }
 }