#include <HICaloCompatibleTrackSelector.h>

Inheritance diagram for reco::modules::HICaloCompatibleTrackSelector:

Public Member Functions
	HICaloCompatibleTrackSelector (const edm::ParameterSet &cfg)
	constructor More...

	~HICaloCompatibleTrackSelector () override
	destructor More...

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

	~EDProducer () override

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

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () noexcept(false) override

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

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

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

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

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

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

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

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Types
typedef reco::PFCandidateCollection::const_iterator	CI

typedef math::XYZPoint	Point

typedef reco::TrackCollection::const_iterator	TI

Private Member Functions
void	matchByDrAllowReuse (const reco::Track &trk, const edm::Handle< CaloTowerCollection > &towers, double &bestdr, double &bestpt)

double	matchPFCandToTrack (const edm::Handle< PFCandidateCollection > &pfCandidates, unsigned it, double trkPt)

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

bool	selectByPFCands (TI ti, const edm::Handle< TrackCollection > hSrcTrack, const edm::Handle< PFCandidateCollection > pfCandidates, bool isPFThere)

bool	selectByTowers (TI ti, const edm::Handle< TrackCollection > hSrcTrack, const edm::Handle< CaloTowerCollection > towers, bool isTowerThere)

Private Attributes
bool	applyPtDepCut_

bool	copyExtras_
	copy only the tracks, not extras and rechits (for AOD) More...

bool	copyTrajectories_
	copy also trajectories and trajectory->track associations More...

TF1 *	fCaloComp

TF1 *	fDeltaRTowerMatch

std::string	funcCaloComp_

std::string	funcDeltaRTowerMatch_

bool	keepAllTracks_

double	matchConeRadius_

std::string	minimumQuality_

bool	passElectrons_

bool	passMuons_

std::string	qualityToMatch_

std::string	qualityToSet_

std::string	qualityToSkip_

bool	resetQuality_

TrackingRecHitRefProd	rHits_

reco::TrackExtraRefProd	rTrackExtras_

reco::TrackRefProd	rTracks_

edm::RefProd< std::vector< Trajectory > >	rTrajectories_

std::unique_ptr< TrackingRecHitCollection >	selHits_

std::unique_ptr< reco::TrackExtraCollection >	selTrackExtras_

std::unique_ptr< reco::TrackCollection >	selTracks_
	storage More...

std::unique_ptr< std::vector< const Trajectory * > >	selTrajPtrs_

std::unique_ptr< std::vector< Trajectory > >	selTrajs_

std::unique_ptr< TrajTrackAssociationCollection >	selTTAss_

edm::EDGetTokenT< reco::PFCandidateCollection >	srcPFCands_

edm::EDGetTokenT< CaloTowerCollection >	srcTower_

edm::EDGetTokenT< reco::TrackCollection >	srcTracks_
	source collection label More...

edm::EDGetTokenT< TrajTrackAssociationCollection >	srcTrackTrajAssoc_

edm::EDGetTokenT< std::vector< Trajectory > >	srcTrackTrajs_

double	towerPtMin_

std::vector< reco::TrackRef >	trackRefs_

double	trkCompPtMin_

double	trkEtaMax_

double	trkMatchPtMin_

bool	usePFCandMatching_

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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)

Detailed Description

Definition at line 48 of file HICaloCompatibleTrackSelector.h.

Member Typedef Documentation

typedef reco::PFCandidateCollection::const_iterator reco::modules::HICaloCompatibleTrackSelector::CI

private

Definition at line 58 of file HICaloCompatibleTrackSelector.h.

typedef math::XYZPoint reco::modules::HICaloCompatibleTrackSelector::Point

private

Definition at line 57 of file HICaloCompatibleTrackSelector.h.

typedef reco::TrackCollection::const_iterator reco::modules::HICaloCompatibleTrackSelector::TI

private

Definition at line 59 of file HICaloCompatibleTrackSelector.h.

Constructor & Destructor Documentation

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

explicit

constructor

Definition at line 31 of file HICaloCompatibleTrackSelector.cc.

References egammaCTFFinalFitWithMaterial_cff::alias, copyExtras_, copyTrajectories_, fCaloComp, fDeltaRTowerMatch, funcCaloComp_, funcDeltaRTowerMatch_, edm::ParameterSet::getParameter(), srcTrackTrajAssoc_, srcTrackTrajs_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                           :
   srcTracks_(consumes<TrackCollection>(cfg.getParameter<edm::InputTag>("srcTracks"))),
   srcPFCands_(consumes<PFCandidateCollection>(cfg.getParameter<edm::InputTag>("srcPFCands"))),
   srcTower_(consumes<CaloTowerCollection>(cfg.getParameter<edm::InputTag>("srcTower"))),
   usePFCandMatching_(cfg.getUntrackedParameter<bool>("usePFCandMatching", true)),
   trkMatchPtMin_(cfg.getUntrackedParameter<double>("trkMatchPtMin",10.0)),
   trkCompPtMin_(cfg.getUntrackedParameter<double>("trkCompPtMin",35.0)),
   trkEtaMax_(cfg.getUntrackedParameter<double>("trkEtaMax",2.4)),
   towerPtMin_(cfg.getUntrackedParameter<double>("towerPtMin",5.0)),
   matchConeRadius_(cfg.getUntrackedParameter<double>("matchConeRadius",0.087)),
   keepAllTracks_(cfg.getUntrackedParameter<bool>("keepAllTracks", true)),
   copyExtras_(cfg.getUntrackedParameter<bool>("copyExtras", true)),
   copyTrajectories_(cfg.getUntrackedParameter<bool>("copyTrajectories", true)),
   qualityToSet_(cfg.getParameter<std::string>("qualityToSet")),
   qualityToSkip_(cfg.getParameter<std::string>("qualityToSkip")),
   qualityToMatch_(cfg.getParameter<std::string>("qualityToMatch")),
   minimumQuality_(cfg.getParameter<std::string>("minimumQuality")),
   resetQuality_(cfg.getUntrackedParameter<bool>("resetQuality", true)),
   passMuons_(cfg.getUntrackedParameter<bool>("passMuons", true)),
   passElectrons_(cfg.getUntrackedParameter<bool>("passElectrons", false)),
   funcDeltaRTowerMatch_(cfg.getParameter<std::string>("funcDeltaRTowerMatch")),
   funcCaloComp_(cfg.getParameter<std::string>("funcCaloComp"))
 {
   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");
     srcTrackTrajs_ = (consumes<std::vector<Trajectory> >(cfg.getParameter<edm::InputTag>("srcTracks")));
     srcTrackTrajAssoc_ = (consumes<TrajTrackAssociationCollection>(cfg.getParameter<edm::InputTag>("srcTracks")));
   }
 
   // pt dependence of delta R matching requirement
   fDeltaRTowerMatch = new TF1("fDeltaRTowerMatch",funcDeltaRTowerMatch_.c_str(),0,200); 
   // pt dependance of calo compatibility, i.e., minimum sum Calo Et vs. track pT
   fCaloComp = new TF1("fCaloComp",funcCaloComp_.c_str(),0,200); // a parameterization of pt dependent cut
 
 
 }

HICaloCompatibleTrackSelector::~HICaloCompatibleTrackSelector ( )

override

destructor

Definition at line 75 of file HICaloCompatibleTrackSelector.cc.

75 {

76 }

Member Function Documentation

void HICaloCompatibleTrackSelector::matchByDrAllowReuse	(	const reco::Track &	trk,
		const edm::Handle< CaloTowerCollection > &	towers,
		double &	bestdr,
		double &	bestpt
	)

private

Definition at line 359 of file HICaloCompatibleTrackSelector.cc.

References reco::deltaR(), runTauDisplay::dr, reco::LeafCandidate::eta(), mps_fire::i, EnergyCorrector::pt, reco::LeafCandidate::pt(), edm::SortedCollection< T, SORT >::size(), towerPtMin_, and trkEtaMax_.

Referenced by selectByTowers().

 {
   // loop over towers
   bestdr=1e10;
   bestpt=0.;
   for(unsigned int i = 0; i < towers->size(); ++i){
     const CaloTower & tower= (*towers)[i];
     double pt = tower.pt();
     if (pt<towerPtMin_) continue;
     if (fabs(tower.eta())>trkEtaMax_) continue;
     double dr = reco::deltaR(tower,trk);
     if (dr<bestdr) {
       bestdr = dr;
       bestpt = pt;
     }
   }
 }

double HICaloCompatibleTrackSelector::matchPFCandToTrack	(	const edm::Handle< PFCandidateCollection > &	pfCandidates,
		unsigned	it,
		double	trkPt
	)

private

Definition at line 272 of file HICaloCompatibleTrackSelector.cc.

References reco::PFCandidate::e, reco::PFBlockElement::ECAL, allElectronIsolations_cfi::elements, reco::PFCandidate::elementsInBlocks(), reco::PFCandidate::h, reco::PFBlockElement::HCAL, cuy::ib, edm::Ref< C, T, F >::key(), reco::PFCandidate::mu, reco::PFCandidate::particleId(), passElectrons_, passMuons_, reco::PFBlockElement::TRACK, reco::PFCandidate::trackRef(), and trkMatchPtMin_.

Referenced by selectByPFCands().

 {
 
   // This function returns the sum of the calo energy in the block containing the track
   // There is another piece of information which could be useful which is the pT assigned to the charged hadron by PF
   
 
   double sum_ecal=0.0, sum_hcal=0.0;
     
   int candType = 0;
   reco::PFCandidate matchedCand; 
 
   // loop over the PFCandidates until you find the one whose trackRef points to the track
 
   for( CI ci  = pfCandidates->begin(); ci!=pfCandidates->end(); ++ci)  {
 
     const reco::PFCandidate& cand = *ci;
 
     int type = cand.particleId();
     
     // only charged hadrons and leptons can be asscociated with a track
     if(!(type == PFCandidate::h ||     //type1
      type == PFCandidate::e ||     //type2
      type == PFCandidate::mu      //type3
      )
        ) continue;
     
     
     unsigned candTrackRefKey = cand.trackRef().key();      
     
     if(it==candTrackRefKey) {
       matchedCand = cand;
       candType = type;
       break;      
     }
   }
   // take all muons as compatible, extend to electrons when validataed
   if(passMuons_ && candType==3) return 9999.;
   if(passElectrons_ && candType==2) return 9999.;
 
   if(trkPt < trkMatchPtMin_ ) return 0.;
 
   if(candType>0){
     
     // Now that we found the matched PF candidate, loop over the elements in the block summing the calo Et
     for(unsigned ib=0; ib<matchedCand.elementsInBlocks().size(); ib++) {
       
       PFBlockRef blockRef = matchedCand.elementsInBlocks()[ib].first;
             
       unsigned indexInBlock = matchedCand.elementsInBlocks()[ib].second;
       const edm::OwnVector<  reco::PFBlockElement>&  elements = (*blockRef).elements();
       
       //This tells you what type of element it is:
       //cout<<" block type"<<elements[indexInBlock].type()<<endl;
       
       switch (elements[indexInBlock].type()) {
     
       case PFBlockElement::ECAL: {
     reco::PFClusterRef clusterRef = elements[indexInBlock].clusterRef();
     sum_ecal += clusterRef->energy()/cosh(clusterRef->eta());
     break;
       }
     
       case PFBlockElement::HCAL: {
     reco::PFClusterRef clusterRef = elements[indexInBlock].clusterRef();
     sum_hcal += clusterRef->energy()/cosh(clusterRef->eta());
     break; 
       }       
       case PFBlockElement::TRACK: {
     //Do nothing since track are not normally linked to other tracks
     break; 
       }       
       default:
     break;
       }
       
       // We could also add in the PS, HO, ..
 
     } // end of elementsInBlocks()
   }  // end of isCandFound  
   
   
 
   return sum_ecal+sum_hcal;
   
 }

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

overrideprivate

process one event

Definition at line 79 of file HICaloCompatibleTrackSelector.cc.

References edm::AssociationMap< edm::OneToOne< std::vector< Trajectory >, reco::TrackCollection, unsigned short > >::const_iterator, copyExtras_, copyTrajectories_, edm::friendlyname::emptyString(), edm::AssociationMap< Tag >::end(), edm::AssociationMap< Tag >::find(), edm::Event::getByToken(), edm::Event::getRefBeforePut(), mps_fire::i, reco::Track::innerDetId(), reco::Track::innerMomentum(), reco::Track::innerOk(), reco::Track::innerPosition(), reco::Track::innerStateCovariance(), keepAllTracks_, edm::Ref< C, T, F >::key(), LogDebug, match(), eostools::move(), gen::n, reco::Track::outerDetId(), reco::Track::outerMomentum(), reco::Track::outerOk(), reco::Track::outerPosition(), reco::Track::outerStateCovariance(), patMuonMerger_cfi::pfCandidates, edm::Event::put(), reco::TrackBase::qualityByName(), qualityToSet_, reco::Track::recHitsBegin(), reco::Track::recHitsEnd(), reco::Track::residuals(), rHits_, rTrackExtras_, rTracks_, rTrajectories_, reco::Track::seedDirection(), reco::Track::seedRef(), selectByPFCands(), selectByTowers(), selHits_, selTrackExtras_, selTracks_, selTrajs_, selTTAss_, reco::TrackExtraBase::setHits(), reco::TrackExtra::setResiduals(), srcPFCands_, srcTower_, srcTracks_, srcTrackTrajAssoc_, srcTrackTrajs_, trackRefs_, trkMatchPtMin_, and usePFCandMatching_.

 {
   using namespace std; 
   using namespace edm;
   using namespace reco;
   
   LogDebug("HICaloCompatibleTrackSelector")<<"min pt for selection = "<< trkMatchPtMin_<<endl;
   
   
   Handle<TrackCollection> hSrcTrack;
   Handle< vector<Trajectory> > hTraj;
   Handle< vector<Trajectory> > hTrajP;
   Handle< TrajTrackAssociationCollection > hTTAss;
 
   evt.getByToken(srcTracks_,hSrcTrack);
   
   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());
 
 
   Handle<PFCandidateCollection> pfCandidates;
   Handle<CaloTowerCollection> towers;
 
   bool isPFThere = false;
   bool isTowerThere = false;
   
   if(usePFCandMatching_) isPFThere = evt.getByToken(srcPFCands_, pfCandidates);  
   else isTowerThere = evt.getByToken(srcTower_, towers);
   
   size_t current = 0;
   for (TI ti = hSrcTrack->begin(), ed = hSrcTrack->end(); ti != ed; ++ti, ++current) {
     
 
     const reco::Track& trk = *ti;
     
     bool isSelected;
     if(usePFCandMatching_) isSelected = selectByPFCands(ti, hSrcTrack, pfCandidates, isPFThere);
     else isSelected = selectByTowers(ti, hSrcTrack, towers, isTowerThere);
     
     if(!keepAllTracks_ && !isSelected) continue; 
 
     // Add all tracks to output collection, the rest of the code only sets the quality bit
     selTracks_->push_back( reco::Track( trk ) ); // clone and store
     
     
     if(isSelected) selTracks_->back().setQuality(reco::TrackBase::qualityByName(qualityToSet_));
     
         
     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 );
     }
     if (copyTrajectories_) {
       trackRefs_[current] = TrackRef(rTracks_, selTracks_->size() - 1);
     }
 
     
   }  // close track loop
   
   if ( copyTrajectories_ ) {
     Handle< vector<Trajectory> > hTraj;
     Handle< TrajTrackAssociationCollection > hTTAss;
     evt.getByToken(srcTrackTrajs_, hTTAss);
     evt.getByToken(srcTrackTrajAssoc_, hTraj);
     selTrajs_ = std::make_unique<std::vector<Trajectory>>(); 
     rTrajectories_ = evt.getRefBeforePut< vector<Trajectory> >();
     selTTAss_ = std::make_unique<TrajTrackAssociationCollection>();
     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] );
     }
       }
     }
   }
   
   static const string emptyString;
   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_));
   }
 }

bool HICaloCompatibleTrackSelector::selectByPFCands	(	TI	ti,
		const edm::Handle< TrackCollection >	hSrcTrack,
		const edm::Handle< PFCandidateCollection >	pfCandidates,
		bool	isPFThere
	)

private

Definition at line 197 of file HICaloCompatibleTrackSelector.cc.

References Exception, fCaloComp, matchPFCandToTrack(), minimumQuality_, reco::TrackBase::pt(), reco::TrackBase::quality(), reco::TrackBase::qualityByName(), qualityToMatch_, qualityToSkip_, trkCompPtMin_, and usePFCandMatching_.

Referenced by produce().

 {
 
   const reco::Track& trk = *ti;
 
   // If it passes this quality threshold or is under the minimum match pT, automatically save it
   if(trk.quality(reco::TrackBase::qualityByName(qualityToSkip_))){
     return true;
   }
   else if(!trk.quality(reco::TrackBase::qualityByName(minimumQuality_))){
     return false;
   }
   else
     {      
       
       double trkPt = trk.pt();
       //if(trkPt < trkMatchPtMin_ ) return false;
       
       double caloEt = 0.0;
       if(usePFCandMatching_){
     if(isPFThere){
       unsigned int trackKey = ti - hSrcTrack->begin();
       caloEt = matchPFCandToTrack(pfCandidates, trackKey, trkPt);      
     }
       }
       
       // Set quality bit based on calo matching
       if(!(caloEt>0.)) return false;
       
       
       if(trkPt<=trkCompPtMin_){
     if(trk.quality(reco::TrackBase::qualityByName(qualityToMatch_))) return true;
     else return false;
       }
       else{
     // loose cuts are implied in selectors, make configurable?
     float compPt = (fCaloComp->Eval(trkPt)!=fCaloComp->Eval(trkPt)) ? 0 : fCaloComp->Eval(trkPt); // protect agains NaN
     if(caloEt>compPt) return true;
     else return false;
       }            
     } // else above trkMatchPtMin_
 
   throw cms::Exception("Undefined case in HICaloCompatibleTrackSelector") << "Undefined case in HICaloCompatibleTrackSelector";
 }

bool HICaloCompatibleTrackSelector::selectByTowers	(	TI	ti,
		const edm::Handle< TrackCollection >	hSrcTrack,
		const edm::Handle< CaloTowerCollection >	towers,
		bool	isTowerThere
	)

private

Definition at line 244 of file HICaloCompatibleTrackSelector.cc.

References fDeltaRTowerMatch, matchByDrAllowReuse(), reco::TrackBase::pt(), reco::TrackBase::quality(), reco::TrackBase::qualityByName(), qualityToMatch_, qualityToSkip_, trkCompPtMin_, and trkMatchPtMin_.

Referenced by produce().

 {
 
   // Not up to date! use PF towers instead
 
   const reco::Track& trk = *ti;
 
   // If it passes the high purity cuts, then consider it confirmed
   if(trk.quality(reco::TrackBase::qualityByName(qualityToSkip_))){
     return true;
   }
   else{
     if(trk.pt() <  trkMatchPtMin_ || !trk.quality(reco::TrackBase::qualityByName(qualityToMatch_))) return false;
     
     double caloEt = 0.0;
     if(isTowerThere){      
       double matchDr;
       matchByDrAllowReuse(trk,towers,matchDr,caloEt);
       float matchConeRadius_pt = (fDeltaRTowerMatch->Eval(trk.pt())!=fDeltaRTowerMatch->Eval(trk.pt())) ? 0 : fDeltaRTowerMatch->Eval(trk.pt()); // protect agains NaN
       if (caloEt>0 && matchDr>matchConeRadius_pt) caloEt=0.;      
     }
     
     if(trk.pt()<trkCompPtMin_||caloEt>0.75*(trk.pt()-trkCompPtMin_)) return true;
     else return false;
   }
 }