#include <HIMultiTrackSelector.h>

Inheritance diagram for HIMultiTrackSelector:

Public Member Functions
	HIMultiTrackSelector ()
	constructor More...

	HIMultiTrackSelector (const edm::ParameterSet &cfg)

virtual	~HIMultiTrackSelector ()
	destructor More...

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Protected Types
typedef math::XYZPoint	Point

Protected Member Functions
void	beginStream (edm::StreamID) overridefinal

void	ParseForestVars ()

void	processMVA (edm::Event &evt, const edm::EventSetup &es, std::vector< float > &mvaVals_, const reco::VertexCollection &hVtx) const

void	produce (edm::Event &evt, const edm::EventSetup &es) overridefinal
	process one event More...

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

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 Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Protected Attributes
std::vector< bool >	applyAbsCutsIfNoPV_

std::vector< bool >	applyAdaptedPVCuts_

bool	applyPixelMergingCuts_

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_

GBRForest *	forest_

std::string	forestLabel_

std::vector< std::string >	forestVars_

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::string	mvaType_

std::vector< int >	mvavars_indices

std::vector< std::string >	name_

std::vector< double >	nSigmaZ_

std::vector< std::vector < double > >	pixel_pTMaxCut_

std::vector< std::vector < double > >	pixel_pTMinCut_

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_

bool	useVertices_

bool	useVtxError_

std::vector < StringCutObjectSelector < reco::Vertex > >	vertexCut_

edm::EDGetTokenT < reco::VertexCollection >	vertices_

std::vector< int32_t >	vtxNumber_
	vertex cuts More...

Additional Inherited Members
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

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Detailed Description

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

Author: David Lange

Definition at line 52 of file HIMultiTrackSelector.h.

Member Typedef Documentation

typedef math::XYZPoint HIMultiTrackSelector::Point

protected

Definition at line 70 of file HIMultiTrackSelector.h.

Constructor & Destructor Documentation

HIMultiTrackSelector::HIMultiTrackSelector ( )

explicit

constructor

Definition at line 58 of file HIMultiTrackSelector.cc.

 {
   useForestFromDB_ = true;
   forest_ = nullptr;
 }

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

explicit

Definition at line 94 of file HIMultiTrackSelector.cc.

References applyAbsCutsIfNoPV_, applyAdaptedPVCuts_, applyPixelMergingCuts_, chi2n_no1Dmod_par_, chi2n_par_, d0_par1_, d0_par2_, dbFileName_, dz_par1_, dz_par2_, edm::hlt::Exception, edm::ParameterSet::exists(), forest_, forestLabel_, forestVars_, edm::ParameterSet::getParameter(), i, j, keepAllTracks_, max_d0_, max_d0NoPV_, max_eta_, max_lostHitFraction_, max_lostLayers_, max_minMissHitOutOrIn_, max_relpterr_, max_z0_, max_z0NoPV_, min_3Dlayers_, min_eta_, min_hits_bypass_, min_layers_, min_MVA_, min_nhits_, mvaType_, name_, nSigmaZ_, ParseForestVars(), pixel_pTMaxCut_, pixel_pTMinCut_, preFilter_, qualityToSet_, res_par_, setQualityBit_, AlCaHLTBitMon_QueryRunRegistry::string, useAnyMVA_, useForestFromDB_, useMVA_, useVertices_, vertexCut_, vertices_, and vtxNumber_.

                                                                         :
   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" ) )
   // now get the pset for each selector
 {
   if (useVertices_) vertices_ = consumes<reco::VertexCollection>(cfg.getParameter<edm::InputTag>( "vertices" ));
 
   applyPixelMergingCuts_ = false;
   if(cfg.exists("applyPixelMergingCuts")) 
     applyPixelMergingCuts_ = cfg.getParameter<bool>("applyPixelMergingCuts");
 
   useAnyMVA_ = false;
   forestLabel_ = "MVASelectorIter0";
   std::string type = "BDTG";
   useForestFromDB_ = true;
   dbFileName_ = "";
 
   forest_ = nullptr;
 
   if(cfg.exists("useAnyMVA")) useAnyMVA_ = cfg.getParameter<bool>("useAnyMVA");
   if(useAnyMVA_){
     if(cfg.exists("mvaType"))type = cfg.getParameter<std::string>("mvaType");
     if(cfg.exists("GBRForestLabel"))forestLabel_ = cfg.getParameter<std::string>("GBRForestLabel");
     if(cfg.exists("GBRForestVars")) {
       forestVars_ = cfg.getParameter<std::vector<std::string> >("GBRForestVars");
       ParseForestVars();
     }
     if(cfg.exists("GBRForestFileName")){
       dbFileName_ = cfg.getParameter<std::string>("GBRForestFileName");
       useForestFromDB_ = false;
     }
      mvaType_ = type;
   }
   std::vector<edm::ParameterSet> trkSelectors( cfg.getParameter<std::vector< edm::ParameterSet> >("trackSelectors") );
   qualityToSet_.reserve(trkSelectors.size());
   vtxNumber_.reserve(trkSelectors.size());
   vertexCut_.reserve(trkSelectors.size());
   res_par_.reserve(trkSelectors.size());
   chi2n_par_.reserve(trkSelectors.size());
   chi2n_no1Dmod_par_.reserve(trkSelectors.size());
   d0_par1_.reserve(trkSelectors.size());
   dz_par1_.reserve(trkSelectors.size());
   d0_par2_.reserve(trkSelectors.size());
   dz_par2_.reserve(trkSelectors.size());
   applyAdaptedPVCuts_.reserve(trkSelectors.size());
   max_d0_.reserve(trkSelectors.size());
   max_z0_.reserve(trkSelectors.size());
   nSigmaZ_.reserve(trkSelectors.size());
   pixel_pTMinCut_.reserve(trkSelectors.size());
   pixel_pTMaxCut_.reserve(trkSelectors.size());
   min_layers_.reserve(trkSelectors.size());
   min_3Dlayers_.reserve(trkSelectors.size());
   max_lostLayers_.reserve(trkSelectors.size());
   min_hits_bypass_.reserve(trkSelectors.size());
   applyAbsCutsIfNoPV_.reserve(trkSelectors.size());
   max_d0NoPV_.reserve(trkSelectors.size());
   max_z0NoPV_.reserve(trkSelectors.size());
   preFilter_.reserve(trkSelectors.size());
   max_relpterr_.reserve(trkSelectors.size());
   min_nhits_.reserve(trkSelectors.size());
   max_minMissHitOutOrIn_.reserve(trkSelectors.size());
   max_lostHitFraction_.reserve(trkSelectors.size());
   min_eta_.reserve(trkSelectors.size());
   max_eta_.reserve(trkSelectors.size());
   useMVA_.reserve(trkSelectors.size());
   //mvaReaders_.reserve(trkSelectors.size());
   min_MVA_.reserve(trkSelectors.size());
   //mvaType_.reserve(trkSelectors.size());
 
   produces<edm::ValueMap<float> >("MVAVals");
 
   for ( unsigned int i=0; i<trkSelectors.size(); i++) {
 
     qualityToSet_.push_back( TrackBase::undefQuality );
     // parameters for vertex selection
     vtxNumber_.push_back( useVertices_ ? trkSelectors[i].getParameter<int32_t>("vtxNumber") : 0 );
     vertexCut_.push_back( useVertices_ ? trkSelectors[i].getParameter<std::string>("vertexCut") : 0);
     //  parameters for adapted optimal cuts on chi2 and primary vertex compatibility
     res_par_.push_back(trkSelectors[i].getParameter< std::vector<double> >("res_par") );
     chi2n_par_.push_back( trkSelectors[i].getParameter<double>("chi2n_par") );
     chi2n_no1Dmod_par_.push_back( trkSelectors[i].getParameter<double>("chi2n_no1Dmod_par") );
     d0_par1_.push_back(trkSelectors[i].getParameter< std::vector<double> >("d0_par1"));
     dz_par1_.push_back(trkSelectors[i].getParameter< std::vector<double> >("dz_par1"));
     d0_par2_.push_back(trkSelectors[i].getParameter< std::vector<double> >("d0_par2"));
     dz_par2_.push_back(trkSelectors[i].getParameter< std::vector<double> >("dz_par2"));
     // Boolean indicating if adapted primary vertex compatibility cuts are to be applied.
     applyAdaptedPVCuts_.push_back(trkSelectors[i].getParameter<bool>("applyAdaptedPVCuts"));
     // Impact parameter absolute cuts.
     max_d0_.push_back(trkSelectors[i].getParameter<double>("max_d0"));
     max_z0_.push_back(trkSelectors[i].getParameter<double>("max_z0"));
     nSigmaZ_.push_back(trkSelectors[i].getParameter<double>("nSigmaZ"));
     // Cuts on numbers of layers with hits/3D hits/lost hits.
     min_layers_.push_back(trkSelectors[i].getParameter<uint32_t>("minNumberLayers") );
     min_3Dlayers_.push_back(trkSelectors[i].getParameter<uint32_t>("minNumber3DLayers") );
     max_lostLayers_.push_back(trkSelectors[i].getParameter<uint32_t>("maxNumberLostLayers"));
     min_hits_bypass_.push_back(trkSelectors[i].getParameter<uint32_t>("minHitsToBypassChecks"));
     // Flag to apply absolute cuts if no PV passes the selection
     applyAbsCutsIfNoPV_.push_back(trkSelectors[i].getParameter<bool>("applyAbsCutsIfNoPV"));
     keepAllTracks_.push_back( trkSelectors[i].getParameter<bool>("keepAllTracks")); 
     max_relpterr_.push_back(trkSelectors[i].getParameter<double>("max_relpterr"));
     min_nhits_.push_back(trkSelectors[i].getParameter<uint32_t>("min_nhits"));
     max_minMissHitOutOrIn_.push_back(
     trkSelectors[i].existsAs<int32_t>("max_minMissHitOutOrIn") ? 
     trkSelectors[i].getParameter<int32_t>("max_minMissHitOutOrIn") : 99);
     max_lostHitFraction_.push_back(
     trkSelectors[i].existsAs<double>("max_lostHitFraction") ?
     trkSelectors[i].getParameter<double>("max_lostHitFraction") : 1.0);
     min_eta_.push_back(trkSelectors[i].existsAs<double>("min_eta") ?
     trkSelectors[i].getParameter<double>("min_eta"):-9999);
     max_eta_.push_back(trkSelectors[i].existsAs<double>("max_eta") ?
     trkSelectors[i].getParameter<double>("max_eta"):9999);
   
     setQualityBit_.push_back( false );
     std::string qualityStr = trkSelectors[i].getParameter<std::string>("qualityBit");
     if (qualityStr != "") {
       setQualityBit_[i] = true;
       qualityToSet_[i]  = TrackBase::qualityByName(trkSelectors[i].getParameter<std::string>("qualityBit"));
     }
   
     if (setQualityBit_[i] && (qualityToSet_[i] == TrackBase::undefQuality)) throw cms::Exception("Configuration") <<
     "You can't set the quality bit " << trkSelectors[i].getParameter<std::string>("qualityBit") << " as it is 'undefQuality' or unknown.\n";
 
     if (applyAbsCutsIfNoPV_[i]) {
       max_d0NoPV_.push_back(trkSelectors[i].getParameter<double>("max_d0NoPV"));
       max_z0NoPV_.push_back(trkSelectors[i].getParameter<double>("max_z0NoPV"));
     }
     else{//dummy values
       max_d0NoPV_.push_back(0.);
       max_z0NoPV_.push_back(0.);
     }
   
     name_.push_back( trkSelectors[i].getParameter<std::string>("name") );
 
     preFilter_[i]=trkSelectors.size(); // no prefilter
 
     std::string pfName=trkSelectors[i].getParameter<std::string>("preFilterName");
     if (pfName!="") {
       bool foundPF=false;
       for ( unsigned int j=0; j<i; j++) 
     if (name_[j]==pfName ) {
       foundPF=true;
       preFilter_[i]=j;
     }
       if ( !foundPF)
     throw cms::Exception("Configuration") << "Invalid prefilter name in HIMultiTrackSelector " 
                           << trkSelectors[i].getParameter<std::string>("preFilterName");
       
     }
 
     if(applyPixelMergingCuts_)
     {
       pixel_pTMinCut_.push_back(trkSelectors[i].getParameter< std::vector<double> >("pixel_pTMinCut"));
       pixel_pTMaxCut_.push_back(trkSelectors[i].getParameter< std::vector<double> >("pixel_pTMaxCut"));
     }
 
     //    produces<std::vector<int> >(name_[i]).setBranchAlias( name_[i] + "TrackQuals");
     produces<edm::ValueMap<int> >(name_[i]).setBranchAlias( name_[i] + "TrackQuals");
     if(useAnyMVA_){
       bool thisMVA = false;
       if(trkSelectors[i].exists("useMVA"))thisMVA = trkSelectors[i].getParameter<bool>("useMVA");
       useMVA_.push_back(thisMVA);
       if(thisMVA){
     double minVal = -1;
     if(trkSelectors[i].exists("minMVA"))minVal = trkSelectors[i].getParameter<double>("minMVA");
     min_MVA_.push_back(minVal);
 
       }else{
     min_MVA_.push_back(-9999.0);
       }
     }else{
       min_MVA_.push_back(-9999.0);
     }
 
   }
 }

HIMultiTrackSelector::~HIMultiTrackSelector ( )

virtual

destructor

Definition at line 273 of file HIMultiTrackSelector.cc.

References forest_.

                                             {
   delete forest_;
 }

Member Function Documentation

void HIMultiTrackSelector::beginStream ( edm::StreamID )

finaloverrideprotectedvirtual

Reimplemented from edm::stream::EDProducerBase.

Definition at line 278 of file HIMultiTrackSelector.cc.

References dbFileName_, forest_, forestLabel_, and useForestFromDB_.

                                                   {
   if(!useForestFromDB_){
     TFile gbrfile(dbFileName_.c_str());
     forest_ = (GBRForest*)gbrfile.Get(forestLabel_.c_str());
   }
 
 }

void HIMultiTrackSelector::ParseForestVars ( )

protected

Definition at line 64 of file HIMultiTrackSelector.cc.

References chi2n, chi2n_no1dmod, chi2perdofperlayer, dxyperdxyerror, dzperdzerror, eta, etaerror, i, lostmidfrac, minlost, ndof, nhits, nlayers, nlayers3d, nlayerslost, relpterr, AlCaHLTBitMon_QueryRunRegistry::string, and findQualityFiles::v.

Referenced by HIMultiTrackSelector().

 {
   mvavars_indices.clear();
   for (unsigned i=0;i<forestVars_.size();i++)
     {
       std::string v = forestVars_[i];
       int ind = -1;
       if (v=="chi2perdofperlayer") ind=chi2perdofperlayer; 
       if (v=="dxyperdxyerror") ind=dxyperdxyerror;
       if (v=="dzperdzerror") ind=dzperdzerror;
       if (v=="relpterr") ind=relpterr;
       if (v=="lostmidfrac") ind=lostmidfrac;
       if (v=="minlost") ind=minlost;
       if (v=="nhits") ind=nhits;
       if (v=="eta") ind=eta;
       if (v=="chi2n_no1dmod") ind=chi2n_no1dmod;
       if (v=="chi2n") ind=chi2n ;
       if (v=="nlayerslost") ind=nlayerslost ;
       if (v=="nlayers3d") ind=nlayers3d ;
       if (v=="nlayers") ind=nlayers ;
       if (v=="ndof") ind=ndof ;
       if (v=="etaerror") ind=etaerror;
 
       if (ind==-1) edm::LogWarning("HIMultiTrackSelector") << "Unknown forest variable "<<v<<". Please make sure it's in the list of supported variables\n";
 
       mvavars_indices.push_back(ind);
     }
    
 }

void HIMultiTrackSelector::processMVA	(	edm::Event &	evt,
		const edm::EventSetup &	es,
		std::vector< float > &	mvaVals_,
		const reco::VertexCollection &	hVtx
	)		const

protected

Definition at line 593 of file HIMultiTrackSelector.cc.

Referenced by run().

 {
 
   using namespace std; 
   using namespace edm;
   using namespace reco;
 
   // Get tracks 
   Handle<TrackCollection> hSrcTrack;
   evt.getByToken( src_, hSrcTrack );
   const TrackCollection& srcTracks(*hSrcTrack);
   assert(mvaVals_.size()==srcTracks.size());
 
  // get hits in track..
   Handle<TrackingRecHitCollection> hSrcHits;
   evt.getByToken( hSrc_, hSrcHits );
   const TrackingRecHitCollection & srcHits(*hSrcHits);
 
 
   auto_ptr<edm::ValueMap<float> >mvaValValueMap = auto_ptr<edm::ValueMap<float> >(new edm::ValueMap<float>);
   edm::ValueMap<float>::Filler mvaFiller(*mvaValValueMap);
 
 
   if(!useAnyMVA_){
     // mvaVals_ already initalized...
     mvaFiller.insert(hSrcTrack,mvaVals_.begin(),mvaVals_.end());
     mvaFiller.fill();
     evt.put(mvaValValueMap,"MVAVals");
     return;
   }
 
   bool checkvertex = std::find(mvavars_indices.begin(), mvavars_indices.end(),dxyperdxyerror)!=mvavars_indices.end()
         || std::find(mvavars_indices.begin(), mvavars_indices.end(),dzperdzerror)!=mvavars_indices.end();
 
   size_t current = 0;
   for (TrackCollection::const_iterator it = srcTracks.begin(), ed = srcTracks.end(); it != ed; ++it, ++current) {
     const Track & trk = * it;
 
     float mvavalues[15];
     mvavalues[ndof] = trk.ndof();
     mvavalues[nlayers] = trk.hitPattern().trackerLayersWithMeasurement();
     mvavalues[nlayers3d] =  trk.hitPattern().pixelLayersWithMeasurement() + trk.hitPattern().numberOfValidStripLayersWithMonoAndStereo();
     mvavalues[nlayerslost] =  trk.hitPattern().trackerLayersWithoutMeasurement(reco::HitPattern::TRACK_HITS);
     mvavalues[chi2n_no1dmod] = trk.normalizedChi2();
     mvavalues[chi2perdofperlayer] = mvavalues[chi2n_no1dmod]/mvavalues[nlayers];
 
 
     float chi2n1d =  trk.normalizedChi2();
     int count1dhits = 0;
     auto ith = trk.extra()->firstRecHit();
     auto  edh = ith + trk.recHitsSize();
     for (; ith<edh; ++ith) {
       const TrackingRecHit & hit = srcHits[ith];
       if (hit.dimension()==1) ++count1dhits;
     }
     if (count1dhits > 0) {
       float chi2 = trk.chi2();
       float ndof = trk.ndof();
       chi2n1d = (chi2+count1dhits)/float(ndof+count1dhits);
     }
 
     mvavalues[chi2n] = chi2n1d;//chi2 and 1d modes
 
     mvavalues[eta] = trk.eta();
     mvavalues[relpterr] = float(trk.ptError())/std::max(float(trk.pt()),0.000001f);
     mvavalues[nhits] = trk.numberOfValidHits();
 
     int lostIn = trk.hitPattern().numberOfLostTrackerHits(reco::HitPattern::MISSING_INNER_HITS);
     int lostOut = trk.hitPattern().numberOfLostTrackerHits(reco::HitPattern::MISSING_OUTER_HITS);
     mvavalues[minlost] = std::min(lostIn,lostOut);
     mvavalues[lostmidfrac] = trk.numberOfLostHits() / (trk.numberOfValidHits() + trk.numberOfLostHits());
 
     mvavalues[etaerror] = trk.etaError();
 
     float reldz = 0;
     float reldxy = 0;
     if (checkvertex) {
       int vtxind = 0; // only first vertex is taken into account for the speed purposes
       float dxy = trk.dxy(vertices[vtxind].position()), dxyE =  sqrt(trk.dxyError()*trk.dxyError()+vertices[vtxind].xError()*vertices[vtxind].yError());
       float dz = trk.dz(vertices[vtxind].position()), dzE =  sqrt(trk.dzError()*trk.dzError()+vertices[vtxind].zError()*vertices[vtxind].zError());
       reldz = dz/dzE;
       reldxy = dxy/dxyE;
       
     }
     mvavalues[dxyperdxyerror] = reldxy;
     mvavalues[dzperdzerror] = reldz;
 
     std::vector<float> gbrValues;
 
     //fill in the gbrValues vector with the necessary variables
     for (unsigned i=0;i<mvavars_indices.size();i++) {
       gbrValues.push_back(mvavalues[mvavars_indices[i]]);
     }
 
 
     GBRForest const * forest = forest_;
     if(useForestFromDB_){
       edm::ESHandle<GBRForest> forestHandle;
       es.get<GBRWrapperRcd>().get(forestLabel_,forestHandle);
       forest = forestHandle.product();
     }
     
     auto gbrVal = forest->GetClassifier(&gbrValues[0]);
     mvaVals_[current] = gbrVal;
   }
   mvaFiller.insert(hSrcTrack,mvaVals_.begin(),mvaVals_.end());
   mvaFiller.fill();
   evt.put(mvaValValueMap,"MVAVals");
 
 }

void HIMultiTrackSelector::produce	(	edm::Event &	evt,
		const edm::EventSetup &	es
	)

inlinefinaloverrideprotectedvirtual

process one event

Implements edm::stream::EDProducerBase.

Definition at line 72 of file HIMultiTrackSelector.h.

References DTTTrigCorrFirst::run.

                                                                                  {
                run(evt,es);
             }

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

protectedvirtual

Definition at line 288 of file HIMultiTrackSelector.cc.

References beamspot_, cond::rpcobimon::current, edm::Event::getByToken(), hSrc_, i, j, keepAllTracks_, LogTrace, name_, convertSQLiteXML::ok, preFilter_, processMVA(), reco::TrackBase::pt(), edm::Event::put(), reco::TrackBase::qualityMask(), qualityToSet_, dt_dqm_sourceclient_common_cff::reco, select(), selectVertices(), setQualityBit_, src_, useAnyMVA_, useVertices_, and vertices_.

 {
   using namespace std; 
   using namespace edm;
   using namespace reco;
 
   // Get tracks 
   Handle<TrackCollection> hSrcTrack;
   evt.getByToken(src_, hSrcTrack );
   const TrackCollection& srcTracks(*hSrcTrack);
 
   // get hits in track..
   Handle<TrackingRecHitCollection> hSrcHits;
   evt.getByToken(hSrc_, hSrcHits );
   const TrackingRecHitCollection & srcHits(*hSrcHits);
 
 
   // looking for the beam spot
   edm::Handle<reco::BeamSpot> hBsp;
   evt.getByToken(beamspot_, hBsp);
   const reco::BeamSpot& vertexBeamSpot(*hBsp);
 
     
   // Select good primary vertices for use in subsequent track selection
   edm::Handle<reco::VertexCollection> hVtx;
   if (useVertices_) evt.getByToken(vertices_, hVtx);
 
   unsigned int trkSize=srcTracks.size();
   std::vector<int> selTracksSave( qualityToSet_.size()*trkSize,0);
 
   std::vector<float> mvaVals_(srcTracks.size(),-99.f);
   processMVA(evt,es, mvaVals_, *hVtx);
 
   for (unsigned int i=0; i<qualityToSet_.size(); i++) {  
     std::vector<int> selTracks(trkSize,0);
     auto_ptr<edm::ValueMap<int> > selTracksValueMap = auto_ptr<edm::ValueMap<int> >(new edm::ValueMap<int>);
     edm::ValueMap<int>::Filler filler(*selTracksValueMap);
 
     std::vector<Point> points;
     std::vector<float> vterr, vzerr;
     if (useVertices_) selectVertices(i,*hVtx, points, vterr, vzerr);
 
     // Loop over tracks
     size_t current = 0;
     for (TrackCollection::const_iterator it = srcTracks.begin(), ed = srcTracks.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() ;
 
       //already removed
       bool ok=true;
       float mvaVal = 0;
       if (preFilter_[i]<i && selTracksSave[preFilter_[i]*trkSize+current] < 0) {
     selTracks[current]=-1;
     ok=false;
     if ( !keepAllTracks_[i]) 
       continue;
       }
       else {
     if(useAnyMVA_) mvaVal = mvaVals_[current];
     ok = select(i,vertexBeamSpot, srcHits, trk, points, vterr, vzerr,mvaVal);
     if (!ok) { 
       LogTrace("TrackSelection") << "track with pt="<< trk.pt() << " NOT selected";
       if (!keepAllTracks_[i]) { 
         selTracks[current]=-1;
         continue;
       }
     }
     else
       LogTrace("TrackSelection") << "track with pt="<< trk.pt() << " selected";
       }
 
       if (preFilter_[i]<i ) {
     selTracks[current]=selTracksSave[preFilter_[i]*trkSize+current];
       }
       else {
     selTracks[current]=trk.qualityMask();
       }
       if ( ok && setQualityBit_[i]) {
     selTracks[current]= (selTracks[current] | (1<<qualityToSet_[i]));
     if (qualityToSet_[i]==TrackBase::tight) {
       selTracks[current]=(selTracks[current] | (1<<TrackBase::loose));
     } 
     else if (qualityToSet_[i]==TrackBase::highPurity) {
       selTracks[current]=(selTracks[current] | (1<<TrackBase::loose));
       selTracks[current]=(selTracks[current] | (1<<TrackBase::tight));
     }
 
     if (!points.empty()) {
       if (qualityToSet_[i]==TrackBase::loose) {
         selTracks[current]=(selTracks[current] | (1<<TrackBase::looseSetWithPV));
       }
       else if (qualityToSet_[i]==TrackBase::highPurity) {
         selTracks[current]=(selTracks[current] | (1<<TrackBase::looseSetWithPV));
         selTracks[current]=(selTracks[current] | (1<<TrackBase::highPuritySetWithPV));
       }
     }
       }
     }
     for ( unsigned int j=0; j< trkSize; j++ ) selTracksSave[j+i*trkSize]=selTracks[j];
     filler.insert(hSrcTrack, selTracks.begin(),selTracks.end());
     filler.fill();
 
     //    evt.put(selTracks,name_[i]);
     evt.put(selTracksValueMap,name_[i]);
   }
 }

bool HIMultiTrackSelector::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

protected

return class, or -1 if rejected

Definition at line 398 of file HIMultiTrackSelector.cc.

Referenced by run().

                                       {
   // Decide if the given track passes selection cuts.
 
   using namespace std; 
   
   //cuts on number of valid hits
   auto nhits = tk.numberOfValidHits();
   if(nhits>=min_hits_bypass_[tsNum]) return true;
   if(nhits < min_nhits_[tsNum]) return false;
 
   if ( tk.ndof() < 1E-5 ) return false;
 
 
   //Adding the MVA selection before any other cut//
   if(useAnyMVA_ && useMVA_[tsNum]){
     if(mvaVal < min_MVA_[tsNum])return false; else return true;
   }
   //End of MVA selection section//
 
 
   // Cuts on numbers of layers with hits/3D hits/lost hits.
   uint32_t nlayers     = tk.hitPattern().trackerLayersWithMeasurement();
   uint32_t nlayers3D   = tk.hitPattern().pixelLayersWithMeasurement() +
     tk.hitPattern().numberOfValidStripLayersWithMonoAndStereo();
   uint32_t nlayersLost = tk.hitPattern().trackerLayersWithoutMeasurement(reco::HitPattern::TRACK_HITS);
   LogDebug("TrackSelection") << "cuts on nlayers: " << nlayers << " " << nlayers3D << " " << nlayersLost << " vs " 
                  << min_layers_[tsNum] << " " << min_3Dlayers_[tsNum] << " " << max_lostLayers_[tsNum];
   if (nlayers < min_layers_[tsNum]) return false;
   if (nlayers3D < min_3Dlayers_[tsNum]) return false;
   if (nlayersLost > max_lostLayers_[tsNum]) return false;
   LogTrace("TrackSelection") << "cuts on nlayers passed";
 
   float chi2n =  tk.normalizedChi2();
   float chi2n_no1Dmod = chi2n;
 
   int count1dhits = 0;
   auto ith = tk.extra()->firstRecHit();
   auto  edh = ith + tk.recHitsSize();
   for (; ith<edh; ++ith) {
     const TrackingRecHit & hit = recHits[ith];
     if (hit.dimension()==1) ++count1dhits;
   }
   if (count1dhits > 0) {
     float chi2 = tk.chi2();
     float ndof = tk.ndof();
     chi2n = (chi2+count1dhits)/float(ndof+count1dhits);
   }
   // For each 1D rechit, the chi^2 and ndof is increased by one.  This is a way of retaining approximately
   // the same normalized chi^2 distribution as with 2D rechits.
   if (chi2n > chi2n_par_[tsNum]*nlayers) return false;
 
   if (chi2n_no1Dmod > chi2n_no1Dmod_par_[tsNum]*nlayers) return false;
 
   // Get track parameters
   float pt = std::max(float(tk.pt()),0.000001f);
   float eta = tk.eta();
   if (eta<min_eta_[tsNum] || eta>max_eta_[tsNum]) return false;
 
   //cuts on relative error on pt
   float relpterr = float(tk.ptError())/pt;
   if(relpterr > max_relpterr_[tsNum]) return false;
 
   int lostIn = tk.hitPattern().numberOfLostTrackerHits(reco::HitPattern::MISSING_INNER_HITS);
   int lostOut = tk.hitPattern().numberOfLostTrackerHits(reco::HitPattern::MISSING_OUTER_HITS);
   int minLost = std::min(lostIn,lostOut);
   if (minLost > max_minMissHitOutOrIn_[tsNum]) return false;
   float lostMidFrac = tk.numberOfLostHits() / (tk.numberOfValidHits() + tk.numberOfLostHits());
   if (lostMidFrac > max_lostHitFraction_[tsNum]) return false;
 
   // Pixel Track Merging pT dependent cuts
   if( applyPixelMergingCuts_ )
   {
     // hard cut at absolute min/max pt
     if( pt < pixel_pTMinCut_[tsNum][0] ) return false;
     if( pt > pixel_pTMaxCut_[tsNum][0] ) return false;
     // tapering cuts with chi2n_no1Dmod 
     double pTMaxCutPos = ( pixel_pTMaxCut_[tsNum][0] - pt ) / 
                          ( pixel_pTMaxCut_[tsNum][0] - pixel_pTMaxCut_[tsNum][1] );
     double pTMinCutPos = ( pt - pixel_pTMinCut_[tsNum][0] ) / 
                          ( pixel_pTMinCut_[tsNum][1] - pixel_pTMinCut_[tsNum][0] );
     if(  pt > pixel_pTMaxCut_[tsNum][1] && 
          chi2n_no1Dmod > pixel_pTMaxCut_[tsNum][2]*nlayers*pow(pTMaxCutPos,pixel_pTMaxCut_[tsNum][3]) ) 
       return false;
     if(  pt < pixel_pTMinCut_[tsNum][1] && 
          chi2n_no1Dmod > pixel_pTMinCut_[tsNum][2]*nlayers*pow(pTMinCutPos,pixel_pTMinCut_[tsNum][3]) ) 
       return false;
   }
 
   //other track parameters
   float d0 = -tk.dxy(vertexBeamSpot.position()), d0E =  tk.d0Error(),
     dz = tk.dz(vertexBeamSpot.position()), dzE =  tk.dzError();
 
   // parametrized d0 resolution for the track pt
   float nomd0E = sqrt(res_par_[tsNum][0]*res_par_[tsNum][0]+(res_par_[tsNum][1]/pt)*(res_par_[tsNum][1]/pt));
   // parametrized z0 resolution for the track pt and eta
   float nomdzE = nomd0E*(std::cosh(eta));
 
   float dzCut = std::min( powN(dz_par1_[tsNum][0]*nlayers,int(dz_par1_[tsNum][1]+0.5))*nomdzE, 
                   powN(dz_par2_[tsNum][0]*nlayers,int(dz_par2_[tsNum][1]+0.5))*dzE );
   float d0Cut = std::min( powN(d0_par1_[tsNum][0]*nlayers,int(d0_par1_[tsNum][1]+0.5))*nomd0E, 
                   powN(d0_par2_[tsNum][0]*nlayers,int(d0_par2_[tsNum][1]+0.5))*d0E );
 
 
   // ---- PrimaryVertex compatibility cut
   bool primaryVertexZCompatibility(false);   
   bool primaryVertexD0Compatibility(false);   
 
   if (points.empty()) { //If not primaryVertices are reconstructed, check just the compatibility with the BS
     //z0 within (n sigma + dzCut) of the beam spot z, if no good vertex is found
     if ( abs(dz) < hypot(vertexBeamSpot.sigmaZ()*nSigmaZ_[tsNum],dzCut) ) primaryVertexZCompatibility = true;  
     // d0 compatibility with beam line
     if (abs(d0) < d0Cut) primaryVertexD0Compatibility = true;     
   }
 
   int iv=0;
   for (std::vector<Point>::const_iterator point = points.begin(), end = points.end(); point != end; ++point) {
     LogTrace("TrackSelection") << "Test track w.r.t. vertex with z position " << point->z();
     if(primaryVertexZCompatibility && primaryVertexD0Compatibility) break;
     float dzPV = tk.dz(*point); //re-evaluate the dz with respect to the vertex position
     float d0PV = tk.dxy(*point); //re-evaluate the dxy with respect to the vertex position
     if(useVtxError_){
        float dzErrPV = std::sqrt(dzE*dzE+vzerr[iv]*vzerr[iv]); // include vertex error in z
        float d0ErrPV = std::sqrt(d0E*d0E+vterr[iv]*vterr[iv]); // include vertex error in xy
        iv++;
        if (abs(dzPV) < dz_par1_[tsNum][0]*pow(nlayers,dz_par1_[tsNum][1])*nomdzE &&
        abs(dzPV) < dz_par2_[tsNum][0]*pow(nlayers,dz_par2_[tsNum][1])*dzErrPV &&
        abs(dzPV) < max_z0_[tsNum])  primaryVertexZCompatibility = true;
        if (abs(d0PV) < d0_par1_[tsNum][0]*pow(nlayers,d0_par1_[tsNum][1])*nomd0E &&
        abs(d0PV) < d0_par2_[tsNum][0]*pow(nlayers,d0_par2_[tsNum][1])*d0ErrPV &&
        abs(d0PV) < max_d0_[tsNum]) primaryVertexD0Compatibility = true; 
     }else{
        if (abs(dzPV) < dzCut)  primaryVertexZCompatibility = true;
        if (abs(d0PV) < d0Cut) primaryVertexD0Compatibility = true;     
     }
     LogTrace("TrackSelection") << "distances " << dzPV << " " << d0PV << " vs " << dzCut << " " << d0Cut;
   }
 
   if (points.empty() && applyAbsCutsIfNoPV_[tsNum]) {
     if ( abs(dz) > max_z0NoPV_[tsNum] || abs(d0) > max_d0NoPV_[tsNum]) return false;
   }  else {
     // Absolute cuts on all tracks impact parameters with respect to beam-spot.
     // If BS is not compatible, verify if at least the reco-vertex is compatible (useful for incorrect BS settings)
     if (abs(d0) > max_d0_[tsNum] && !primaryVertexD0Compatibility) return false;
     LogTrace("TrackSelection") << "absolute cuts on d0 passed";
     if (abs(dz) > max_z0_[tsNum] && !primaryVertexZCompatibility) return false;
     LogTrace("TrackSelection") << "absolute cuts on dz passed";
   }
 
   LogTrace("TrackSelection") << "cuts on PV: apply adapted PV cuts? " << applyAdaptedPVCuts_[tsNum] 
                  << " d0 compatibility? " << primaryVertexD0Compatibility  
                  << " z compatibility? " << primaryVertexZCompatibility ;
 
   if (applyAdaptedPVCuts_[tsNum]) {
     return (primaryVertexD0Compatibility && primaryVertexZCompatibility);
   } else {
     return true;     
   }
 
 }

void HIMultiTrackSelector::selectVertices	(	unsigned int	tsNum,
		const reco::VertexCollection &	vtxs,
		std::vector< Point > &	points,
		std::vector< float > &	vterr,
		std::vector< float > &	vzerr
	)		const

protected

Definition at line 569 of file HIMultiTrackSelector.cc.

References LogDebug, LogTrace, dt_dqm_sourceclient_common_cff::reco, mathSSE::sqrt(), vertexCut_, and vtxNumber_.

Referenced by run().

                                                     {
   // Select good primary vertices
   using namespace reco;
   int32_t toTake = vtxNumber_[tsNum]; 
   for (VertexCollection::const_iterator it = vtxs.begin(), ed = vtxs.end(); it != ed; ++it) {
 
     LogDebug("SelectVertex") << " select vertex with z position " << it->z() << " " 
                  << it->chi2() << " " << it->ndof() << " " << TMath::Prob(it->chi2(), static_cast<int32_t>(it->ndof()));
     Vertex vtx = *it;
     bool pass = vertexCut_[tsNum]( vtx );
     if( pass ) { 
       points.push_back(it->position()); 
       vterr.push_back(sqrt(it->yError()*it->xError()));
       vzerr.push_back(it->zError());
       LogTrace("SelectVertex") << " SELECTED vertex with z position " << it->z();
       toTake--; if (toTake == 0) break;
     }
   }
 }

Member Data Documentation

std::vector<bool> HIMultiTrackSelector::applyAbsCutsIfNoPV_

protected

Definition at line 159 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<bool> HIMultiTrackSelector::applyAdaptedPVCuts_

protected

Definition at line 127 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

bool HIMultiTrackSelector::applyPixelMergingCuts_

protected

Definition at line 107 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

edm::EDGetTokenT<reco::BeamSpot> HIMultiTrackSelector::beamspot_

protected

Definition at line 99 of file HIMultiTrackSelector.h.

Referenced by run().

std::vector< double > HIMultiTrackSelector::chi2n_no1Dmod_par_

protected

Definition at line 121 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector< double > HIMultiTrackSelector::chi2n_par_

protected

Definition at line 120 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector< std::vector<double> > HIMultiTrackSelector::d0_par1_

protected

Definition at line 122 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector< std::vector<double> > HIMultiTrackSelector::d0_par2_

protected

Definition at line 124 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::string HIMultiTrackSelector::dbFileName_

protected

Definition at line 181 of file HIMultiTrackSelector.h.

Referenced by beginStream(), and HIMultiTrackSelector().

std::vector< std::vector<double> > HIMultiTrackSelector::dz_par1_

protected

Definition at line 123 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector< std::vector<double> > HIMultiTrackSelector::dz_par2_

protected

Definition at line 125 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

GBRForest* HIMultiTrackSelector::forest_

protected

Definition at line 179 of file HIMultiTrackSelector.h.

Referenced by beginStream(), HIMultiTrackSelector(), processMVA(), and ~HIMultiTrackSelector().

std::string HIMultiTrackSelector::forestLabel_

protected

Definition at line 177 of file HIMultiTrackSelector.h.

Referenced by beginStream(), HIMultiTrackSelector(), and processMVA().

std::vector<std::string> HIMultiTrackSelector::forestVars_

protected

Definition at line 178 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector().

edm::EDGetTokenT<TrackingRecHitCollection> HIMultiTrackSelector::hSrc_

protected

Definition at line 98 of file HIMultiTrackSelector.h.

Referenced by processMVA(), and run().

std::vector<bool> HIMultiTrackSelector::keepAllTracks_

protected

Definition at line 161 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and run().

std::vector<double> HIMultiTrackSelector::max_d0_

protected

Impact parameter absolute cuts.

Definition at line 130 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<double> HIMultiTrackSelector::max_d0NoPV_

protected

Definition at line 157 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<double> HIMultiTrackSelector::max_eta_

protected

Definition at line 154 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<int32_t> HIMultiTrackSelector::max_lostHitFraction_

protected

Definition at line 151 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<uint32_t> HIMultiTrackSelector::max_lostLayers_

protected

Definition at line 143 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<int32_t> HIMultiTrackSelector::max_minMissHitOutOrIn_

protected

Definition at line 150 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<double> HIMultiTrackSelector::max_relpterr_

protected

Definition at line 147 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<double> HIMultiTrackSelector::max_z0_

protected

Definition at line 131 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<double> HIMultiTrackSelector::max_z0NoPV_

protected

Definition at line 158 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<uint32_t> HIMultiTrackSelector::min_3Dlayers_

protected

Definition at line 142 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<double> HIMultiTrackSelector::min_eta_

protected

Definition at line 153 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<uint32_t> HIMultiTrackSelector::min_hits_bypass_

protected

Definition at line 144 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<uint32_t> HIMultiTrackSelector::min_layers_

protected

Cuts on numbers of layers with hits/3D hits/lost hits.

Definition at line 141 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<double> HIMultiTrackSelector::min_MVA_

protected

Definition at line 173 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<uint32_t> HIMultiTrackSelector::min_nhits_

protected

Definition at line 148 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::string HIMultiTrackSelector::mvaType_

protected

Definition at line 176 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector().

std::vector<int> HIMultiTrackSelector::mvavars_indices

protected

Definition at line 171 of file HIMultiTrackSelector.h.

Referenced by processMVA().

std::vector<std::string> HIMultiTrackSelector::name_

protected

Definition at line 165 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and run().

std::vector<double> HIMultiTrackSelector::nSigmaZ_

protected

Definition at line 132 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<std::vector<double> > HIMultiTrackSelector::pixel_pTMaxCut_

protected

Definition at line 137 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<std::vector<double> > HIMultiTrackSelector::pixel_pTMinCut_

protected

Definition at line 136 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<unsigned int> HIMultiTrackSelector::preFilter_

protected

Definition at line 164 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and run().

std::vector<reco::TrackBase::TrackQuality> HIMultiTrackSelector::qualityToSet_

protected

Definition at line 111 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and run().

std::vector< std::vector<double> > HIMultiTrackSelector::res_par_

protected

Definition at line 119 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<bool> HIMultiTrackSelector::setQualityBit_

protected

do I have to set a quality bit?

Definition at line 110 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and run().

edm::EDGetTokenT<reco::TrackCollection> HIMultiTrackSelector::src_

protected

source collection label

Definition at line 97 of file HIMultiTrackSelector.h.

Referenced by processMVA(), and run().

bool HIMultiTrackSelector::useAnyMVA_

protected

Definition at line 102 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), processMVA(), run(), and select().

bool HIMultiTrackSelector::useForestFromDB_

protected

Definition at line 180 of file HIMultiTrackSelector.h.

Referenced by beginStream(), HIMultiTrackSelector(), and processMVA().

std::vector<bool> HIMultiTrackSelector::useMVA_

protected

Definition at line 168 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

bool HIMultiTrackSelector::useVertices_

protected

Definition at line 100 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and run().

bool HIMultiTrackSelector::useVtxError_

protected

Definition at line 101 of file HIMultiTrackSelector.h.

Referenced by select().

std::vector<StringCutObjectSelector<reco::Vertex> > HIMultiTrackSelector::vertexCut_

protected

Definition at line 116 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and selectVertices().

edm::EDGetTokenT<reco::VertexCollection> HIMultiTrackSelector::vertices_

protected

Definition at line 103 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and run().

std::vector<int32_t> HIMultiTrackSelector::vtxNumber_

protected

vertex cuts

Definition at line 114 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and selectVertices().

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation