#include <AlignmentTrackSelector.h>

Classes
struct	ComparePt
	compare two tracks in pt (used by theNHighestPtTracks) More...

Public Types
typedef std::vector< const reco::Track * >	Tracks

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

Tracks	select (const Tracks &tracks, const edm::Event &evt) const
	select tracks More...

bool	useThisFilter ()
	returns if any of the Filters is used. More...

	~AlignmentTrackSelector ()
	destructor More...

Private Member Functions
Tracks	basicCuts (const Tracks &tracks, const edm::Event &evt) const
	apply basic cuts on pt,eta,phi,nhit More...

Tracks	checkPrescaledHits (const Tracks &tracks, const edm::Event &evt) const

bool	detailedHitsCheck (const reco::Track *track, const edm::Event &evt) const
	checking hit requirements beyond simple number of valid hits More...

bool	isHit2D (const TrackingRecHit &hit) const

bool	isIsolated (const TrackingRecHit *therechit, const edm::Event &evt) const

bool	isOkCharge (const TrackingRecHit *therechit) const
	if valid, check for minimum charge (currently only in strip), if invalid give true More...

bool	isOkChargeStripHit (const SiStripRecHit1D &siStripRecHit1D) const

bool	isOkChargeStripHit (const SiStripRecHit2D &siStripRecHit2D) const

bool	isOkTrkQuality (const reco::Track *track) const

Tracks	theNHighestPtTracks (const Tracks &tracks) const
	filter the n highest pt tracks More...

Private Attributes
const bool	applyBasicCuts_

const bool	applyIsolation_

bool	applyIterStepCheck_

const bool	applyMultiplicityFilter_

const bool	applyNHighestPt_

const bool	applyPrescaledHitsFilter_

bool	applyTrkQualityCheck_

const bool	chargeCheck_

const double	chi2nMax_

const edm::InputTag	clusterValueMapTag_

const bool	countStereoHitAs2D_

const double	d0Max_

const double	d0Min_

const double	dzMax_

const double	dzMin_

const double	etaMax_

const double	etaMin_

const edm::InputTag	matchedrecHitsTag_

const double	maxHitDiffEndcaps_

const int	maxMultiplicity_

const double	minHitChargeStrip_

const double	minHitIsolation_

const int	minHitsinBPIX_

const int	minHitsinENDCAP_

const int	minHitsinENDCAPminus_

const int	minHitsinENDCAPplus_

const int	minHitsinFPIX_

const int	minHitsinFPIXminus_

const int	minHitsinFPIXplus_

const int	minHitsinPIX_

const int	minHitsinTEC_

const int	minHitsinTECminus_

const int	minHitsinTECplus_

const int	minHitsinTIB_

const int	minHitsinTID_

const int	minHitsinTIDminus_

const int	minHitsinTIDplus_

const int	minHitsinTOB_

const int	minMultiplicity_

const int	minPrescaledHits_

const bool	multiplicityOnInput_

const int	nHighestPt_

const double	nHitMax_

const unsigned int	nHitMin2D_

const double	nHitMin_

const double	nLostHitMax_

const double	phiMax_

const double	phiMin_

const double	pMax_

const double	pMin_

ComparePt	ptComparator

const double	ptMax_

const double	ptMin_
	if true, cut min/maxMultiplicity on input instead of on final result More...

const edm::InputTag	rphirecHitsTag_

const bool	seedOnlyFromAbove_

const int	theCharge_

std::vector < reco::TrackBase::TrackQuality >	trkQualities_

std::vector < reco::TrackBase::TrackAlgorithm >	trkSteps_

Detailed Description

Definition at line 17 of file AlignmentTrackSelector.h.

Member Typedef Documentation

typedef std::vector<const reco::Track*> AlignmentTrackSelector::Tracks

Definition at line 22 of file AlignmentTrackSelector.h.

Constructor & Destructor Documentation

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

constructor

Definition at line 32 of file AlignmentTrackSelector.cc.

References reco::TrackBase::algoByName(), applyBasicCuts_, applyIsolation_, applyIterStepCheck_, applyMultiplicityFilter_, applyNHighestPt_, applyPrescaledHitsFilter_, applyTrkQualityCheck_, chargeCheck_, chi2nMax_, clusterValueMapTag_, countStereoHitAs2D_, etaMax_, etaMin_, edm::ParameterSet::getParameter(), i, maxHitDiffEndcaps_, maxMultiplicity_, minHitChargeStrip_, minHitIsolation_, minHitsinBPIX_, minHitsinENDCAP_, minHitsinENDCAPminus_, minHitsinENDCAPplus_, minHitsinFPIX_, minHitsinFPIXminus_, minHitsinFPIXplus_, minHitsinPIX_, minHitsinTEC_, minHitsinTECminus_, minHitsinTECplus_, minHitsinTIB_, minHitsinTID_, minHitsinTIDminus_, minHitsinTIDplus_, minHitsinTOB_, minMultiplicity_, minPrescaledHits_, multiplicityOnInput_, nHighestPt_, nHitMax_, nHitMin2D_, nHitMin_, nLostHitMax_, phiMax_, phiMin_, pMax_, pMin_, ptMax_, ptMin_, reco::TrackBase::qualityByName(), trkQualities_, and trkSteps_.

                                                                           :
   applyBasicCuts_( cfg.getParameter<bool>( "applyBasicCuts" ) ),
   applyNHighestPt_( cfg.getParameter<bool>( "applyNHighestPt" ) ),
   applyMultiplicityFilter_( cfg.getParameter<bool>( "applyMultiplicityFilter" ) ),
   seedOnlyFromAbove_( cfg.getParameter<int>( "seedOnlyFrom" ) ),
   applyIsolation_( cfg.getParameter<bool>( "applyIsolationCut" ) ),
   chargeCheck_( cfg.getParameter<bool>( "applyChargeCheck" ) ),
   nHighestPt_( cfg.getParameter<int>( "nHighestPt" ) ),
   minMultiplicity_ ( cfg.getParameter<int>( "minMultiplicity" ) ),
   maxMultiplicity_ ( cfg.getParameter<int>( "maxMultiplicity" ) ),
   multiplicityOnInput_ ( cfg.getParameter<bool>( "multiplicityOnInput" ) ),
   ptMin_( cfg.getParameter<double>( "ptMin" ) ),
   ptMax_( cfg.getParameter<double>( "ptMax" ) ),
   pMin_( cfg.getParameter<double>( "pMin" ) ),
   pMax_( cfg.getParameter<double>( "pMax" ) ),
   etaMin_( cfg.getParameter<double>( "etaMin" ) ),
   etaMax_( cfg.getParameter<double>( "etaMax" ) ),
   phiMin_( cfg.getParameter<double>( "phiMin" ) ),
   phiMax_( cfg.getParameter<double>( "phiMax" ) ),
   nHitMin_( cfg.getParameter<double>( "nHitMin" ) ),
   nHitMax_( cfg.getParameter<double>( "nHitMax" ) ),
   chi2nMax_( cfg.getParameter<double>( "chi2nMax" ) ),
   d0Min_(  cfg.getParameter<double>( "d0Min" ) ),
   d0Max_(  cfg.getParameter<double>( "d0Max" ) ),
   dzMin_(  cfg.getParameter<double>( "dzMin" ) ),
   dzMax_(  cfg.getParameter<double>( "dzMax" ) ),
   theCharge_( cfg.getParameter<int>( "theCharge" ) ),
   minHitChargeStrip_( cfg.getParameter<double>( "minHitChargeStrip" ) ),
   minHitIsolation_( cfg.getParameter<double>( "minHitIsolation" ) ),
   rphirecHitsTag_( cfg.getParameter<edm::InputTag>("rphirecHits") ),
   matchedrecHitsTag_( cfg.getParameter<edm::InputTag>("matchedrecHits") ),
   countStereoHitAs2D_( cfg.getParameter<bool>( "countStereoHitAs2D" ) ),
   nHitMin2D_( cfg.getParameter<unsigned int>( "nHitMin2D" ) ),
   // Ugly to use the same getParameter n times, but this allows const cut variables...
   minHitsinTIB_(cfg.getParameter<edm::ParameterSet>( "minHitsPerSubDet" ).getParameter<int>( "inTIB" ) ),
   minHitsinTOB_ (cfg.getParameter<edm::ParameterSet>( "minHitsPerSubDet" ).getParameter<int>( "inTOB" ) ),
   minHitsinTID_ (cfg.getParameter<edm::ParameterSet>( "minHitsPerSubDet" ).getParameter<int>( "inTID" ) ),
   minHitsinTEC_ (cfg.getParameter<edm::ParameterSet>( "minHitsPerSubDet" ).getParameter<int>( "inTEC" ) ),
   minHitsinBPIX_ (cfg.getParameter<edm::ParameterSet>( "minHitsPerSubDet" ).getParameter<int>( "inBPIX" ) ),
   minHitsinFPIX_ (cfg.getParameter<edm::ParameterSet>( "minHitsPerSubDet" ).getParameter<int>( "inFPIX" ) ),
   minHitsinPIX_ (cfg.getParameter<edm::ParameterSet>( "minHitsPerSubDet" ).getParameter<int>( "inPIXEL" ) ),
   minHitsinTIDplus_ (cfg.getParameter<edm::ParameterSet>( "minHitsPerSubDet" ).getParameter<int>( "inTIDplus" ) ),
   minHitsinTIDminus_ (cfg.getParameter<edm::ParameterSet>( "minHitsPerSubDet" ).getParameter<int>( "inTIDminus" ) ),
   minHitsinTECplus_ (cfg.getParameter<edm::ParameterSet>( "minHitsPerSubDet" ).getParameter<int>( "inTECplus" ) ),
   minHitsinTECminus_ (cfg.getParameter<edm::ParameterSet>( "minHitsPerSubDet" ).getParameter<int>( "inTECminus" ) ),
   minHitsinFPIXplus_ (cfg.getParameter<edm::ParameterSet>( "minHitsPerSubDet" ).getParameter<int>( "inFPIXplus" ) ),
   minHitsinFPIXminus_ (cfg.getParameter<edm::ParameterSet>( "minHitsPerSubDet" ).getParameter<int>( "inFPIXminus" ) ),
   minHitsinENDCAP_ (cfg.getParameter<edm::ParameterSet>( "minHitsPerSubDet" ).getParameter<int>( "inENDCAP" ) ),
   minHitsinENDCAPplus_ (cfg.getParameter<edm::ParameterSet>( "minHitsPerSubDet" ).getParameter<int>( "inENDCAPplus" ) ),
   minHitsinENDCAPminus_ (cfg.getParameter<edm::ParameterSet>( "minHitsPerSubDet" ).getParameter<int>( "inENDCAPminus" ) ),
   maxHitDiffEndcaps_( cfg.getParameter<double>( "maxHitDiffEndcaps" ) ),
   nLostHitMax_( cfg.getParameter<double>( "nLostHitMax" ) ),
   clusterValueMapTag_(cfg.getParameter<edm::InputTag>("hitPrescaleMapTag")),
   minPrescaledHits_( cfg.getParameter<int>("minPrescaledHits")),
   applyPrescaledHitsFilter_(clusterValueMapTag_.encode().size() && minPrescaledHits_ > 0)
 {
 
   //convert track quality from string to enum
   std::vector<std::string> trkQualityStrings(cfg.getParameter<std::vector<std::string> >("trackQualities"));
   std::string qualities;
   if(trkQualityStrings.size()>0){
     applyTrkQualityCheck_=true;
     for (unsigned int i = 0; i < trkQualityStrings.size(); ++i) {
       (qualities += trkQualityStrings[i]) += ", ";
       trkQualities_.push_back(reco::TrackBase::qualityByName(trkQualityStrings[i]));
     }
   }
   else applyTrkQualityCheck_=false;
 
   std::vector<std::string> trkIterStrings(cfg.getParameter<std::vector<std::string> >("iterativeTrackingSteps"));
   if(trkIterStrings.size()>0){
     applyIterStepCheck_=true;
     std::string tracksteps;
     for (unsigned int i = 0; i < trkIterStrings.size(); ++i) {
       (tracksteps += trkIterStrings[i]) += ", ";
       trkSteps_.push_back(reco::TrackBase::algoByName(trkIterStrings[i]));
     }
   }
   else   applyIterStepCheck_=false;
 
   if (applyBasicCuts_){
       edm::LogInfo("AlignmentTrackSelector") 
     << "applying basic track cuts ..."
     << "\nptmin,ptmax:     " << ptMin_   << "," << ptMax_ 
     << "\npmin,pmax:       " << pMin_    << "," << pMax_ 
     << "\netamin,etamax:   " << etaMin_  << "," << etaMax_
     << "\nphimin,phimax:   " << phiMin_  << "," << phiMax_
     << "\nnhitmin,nhitmax: " << nHitMin_ << "," << nHitMax_
     << "\nnlosthitmax:     " << nLostHitMax_
     << "\nnhitmin2D:       " << nHitMin2D_
         << (countStereoHitAs2D_ ? "," : ", not") << " counting hits on SiStrip stereo modules as 2D" 
     << "\nchi2nmax:        " << chi2nMax_;
 
       if (applyIsolation_)
     edm::LogInfo("AlignmentTrackSelector") 
       << "only retain tracks isolated at least by " << minHitIsolation_ << 
       " cm from other rechits"; 
       
       if (chargeCheck_)
     edm::LogInfo("AlignmentTrackSelector") 
       << "only retain hits with at least " << minHitChargeStrip_ <<  
       " ADC counts of total cluster charge"; 
    
       edm::LogInfo("AlignmentTrackSelector") 
     << "Minimum number of hits in TIB/TID/TOB/TEC/BPIX/FPIX/PIXEL = " 
     << minHitsinTIB_ << "/" << minHitsinTID_ << "/" << minHitsinTOB_
         << "/" << minHitsinTEC_ << "/" << minHitsinBPIX_ << "/" << minHitsinFPIX_ << "/" << minHitsinPIX_;
 
       edm::LogInfo("AlignmentTrackSelector")
         << "Minimum number of hits in TID+/TID-/TEC+/TEC-/FPIX+/FPIX- = "
         << minHitsinTIDplus_ << "/" << minHitsinTIDminus_
         << "/" << minHitsinTECplus_ << "/" << minHitsinTECminus_
         << "/" << minHitsinFPIXplus_ << "/" << minHitsinFPIXminus_;
 
       edm::LogInfo("AlignmentTrackSelector")
         << "Minimum number of hits in EndCap (TID+TEC)/EndCap+/EndCap- = "
         << minHitsinENDCAP_ << "/" << minHitsinENDCAPplus_ << "/" << minHitsinENDCAPminus_;
 
       edm::LogInfo("AlignmentTrackSelector")
     << "Max value of |nHitsinENDCAPplus - nHitsinENDCAPminus| = "
     << maxHitDiffEndcaps_;
 
       if (trkQualityStrings.size()) {
     edm::LogInfo("AlignmentTrackSelector")
       << "Select tracks with these qualities: " << qualities;
       }    
   }
   
   if (applyNHighestPt_)
     edm::LogInfo("AlignmentTrackSelector") 
       << "filter N tracks with highest Pt N=" << nHighestPt_;
 
   if (applyMultiplicityFilter_)
     edm::LogInfo("AlignmentTrackSelector") 
       << "apply multiplicity filter N>= " << minMultiplicity_ << "and N<= " << maxMultiplicity_
           << " on " << (multiplicityOnInput_ ? "input" : "output");
 
   if (applyPrescaledHitsFilter_) {
     edm::LogInfo("AlignmentTrackSelector") 
       << "apply cut on number of prescaled hits N>= " << minPrescaledHits_
       << " (prescale info from " << clusterValueMapTag_ << ")";
     
   }
 
 }

AlignmentTrackSelector::~AlignmentTrackSelector ( )

destructor

Definition at line 180 of file AlignmentTrackSelector.cc.

181 {}

Member Function Documentation

AlignmentTrackSelector::Tracks AlignmentTrackSelector::basicCuts	(	const Tracks &	tracks,
		const edm::Event &	evt
	)		const

private

apply basic cuts on pt,eta,phi,nhit

Definition at line 230 of file AlignmentTrackSelector.cc.

References applyIterStepCheck_, applyTrkQualityCheck_, reco::TrackBase::charge(), chi2nMax_, reco::TrackBase::d0(), d0Max_, d0Min_, detailedHitsCheck(), reco::TrackBase::dz(), dzMax_, dzMin_, reco::TrackBase::eta(), eta(), etaMax_, etaMin_, funct::false, isOkTrkQuality(), nHitMax_, nHitMin_, nLostHitMax_, reco::TrackBase::normalizedChi2(), reco::TrackBase::numberOfLostHits(), reco::TrackBase::numberOfValidHits(), reco::TrackBase::p(), AlCaHLTBitMon_ParallelJobs::p, phi, reco::TrackBase::phi(), phiMax_, phiMin_, pMax_, pMin_, reco::TrackBase::pt(), ptMax_, ptMin_, lumiQueryAPI::q, query::result, theCharge_, and funct::true.

Referenced by select().

 {
   Tracks result;
 
   for (Tracks::const_iterator it=tracks.begin(); it != tracks.end(); ++it) {
     const reco::Track* trackp=*it;
     float pt=trackp->pt();
     float p=trackp->p();
     float eta=trackp->eta();
     float phi=trackp->phi();
     int nhit = trackp->numberOfValidHits(); 
     int nlosthit = trackp->numberOfLostHits(); 
     float chi2n = trackp->normalizedChi2();
 
     int q = trackp->charge();
     bool isChargeOk = false;
     if(theCharge_==-1 && q<0)         isChargeOk = true; 
     else if (theCharge_==1 && q>0)    isChargeOk = true; 
     else if (theCharge_==0)           isChargeOk = true; 
 
     float d0    = trackp->d0();
     float dz    = trackp->dz();
 
     // edm::LogDebug("AlignmentTrackSelector") << " pt,eta,phi,nhit: "
     //  <<pt<<","<<eta<<","<<phi<<","<<nhit;
 
     if (pt>ptMin_ && pt<ptMax_ 
        && p>pMin_ && p<pMax_ 
        && eta>etaMin_ && eta<etaMax_ 
        && phi>phiMin_ && phi<phiMax_ 
        && nhit>=nHitMin_ && nhit<=nHitMax_
        && nlosthit<=nLostHitMax_
        && chi2n<chi2nMax_
        && isChargeOk
        && d0>=d0Min_ && d0<=d0Max_
        && dz>=dzMin_ && dz<=dzMax_) {
       bool trkQualityOk=false ;
       if (!applyTrkQualityCheck_ &&!applyIterStepCheck_)trkQualityOk=true ; // nothing required
       else trkQualityOk = this->isOkTrkQuality(trackp);
 
       bool hitsCheckOk=this->detailedHitsCheck(trackp, evt);
  
       if (trkQualityOk && hitsCheckOk )  result.push_back(trackp);
     }
   }
 
   return result;
 }

AlignmentTrackSelector::Tracks AlignmentTrackSelector::checkPrescaledHits	(	const Tracks &	tracks,
		const edm::Event &	evt
	)		const

private

Definition at line 593 of file AlignmentTrackSelector.cc.

References clusterValueMapTag_, cond::rpcobgas::detid, TrackingRecHit::geographicalId(), edm::Event::getByLabel(), AlignmentClusterFlag::isTaken(), TrackingRecHit::isValid(), kBPIX, kFPIX, minPrescaledHits_, reco::Track::recHitsBegin(), reco::Track::recHitsEnd(), query::result, and DetId::subdetId().

Referenced by select().

 {
   Tracks result;
 
   //take Cluster-Flag Assomap
   edm::Handle<AliClusterValueMap> fMap;
   evt.getByLabel( clusterValueMapTag_, fMap);
   const AliClusterValueMap &flagMap=*fMap;
 
   //for each track loop on hits and count the number of taken hits
   for (Tracks::const_iterator ittrk=tracks.begin(); ittrk != tracks.end(); ++ittrk) {
     const reco::Track* trackp=*ittrk;
     int ntakenhits=0;
     //    float pt=trackp->pt();
 
     for (trackingRecHit_iterator ith = trackp->recHitsBegin(), edh = trackp->recHitsEnd(); ith != edh; ++ith) {
       const TrackingRecHit *hit = ith->get(); // ith is an iterator on edm::Ref to rechit
       if(! hit->isValid())continue;
       DetId detid = hit->geographicalId();
       int subDet = detid.subdetId();
       AlignmentClusterFlag flag;
 
       bool isPixelHit=(subDet == kFPIX || subDet == kBPIX);
 
       if (!isPixelHit){
     const std::type_info &type = typeid(*hit);
 
     if (type == typeid(SiStripRecHit2D)) {  
       const SiStripRecHit2D* striphit=dynamic_cast<const  SiStripRecHit2D*>(hit); 
       if(striphit!=0){
         SiStripRecHit2D::ClusterRef stripclust(striphit->cluster());
         flag = flagMap[stripclust];
       }
     }
     else if(type == typeid(SiStripRecHit1D)){
       const SiStripRecHit1D* striphit = dynamic_cast<const SiStripRecHit1D*>(hit);
       if(striphit!=0){
         SiStripRecHit1D::ClusterRef stripclust(striphit->cluster());
         flag = flagMap[stripclust];
       }
     } 
     else{
        edm::LogError("AlignmentTrackSelector")<<"ERROR in <AlignmentTrackSelector::checkPrescaledHits>: Dynamic cast of Strip RecHit failed!"
                           <<" Skipping this hit.";
        continue;
     }
 
       
 
       }//end if hit in Strips
       else{ // test explicitely BPIX/FPIX
     const SiPixelRecHit* pixelhit= dynamic_cast<const SiPixelRecHit*>(hit);
     if(pixelhit!=0){
       SiPixelRecHit::ClusterRef pixclust(pixelhit->cluster());
       flag = flagMap[pixclust];
     }
     else{
         edm::LogError("AlignmentTrackSelector")<<"ERROR in <AlignmentTrackSelector::checkPrescaledHits>: Dynamic cast of Pixel RecHit failed!  ";
     }
       }//end else hit is in Pixel
       
       if(flag.isTaken())ntakenhits++;
 
     }//end loop on hits
     if(ntakenhits >= minPrescaledHits_)result.push_back(trackp);
   }//end loop on tracks
 
   return result;
 }//end checkPrescaledHits

bool AlignmentTrackSelector::detailedHitsCheck	(	const reco::Track *	track,
		const edm::Event &	evt
	)		const

private

checking hit requirements beyond simple number of valid hits

Definition at line 281 of file AlignmentTrackSelector.cc.

References abs, applyIsolation_, chargeCheck_, isHit2D(), isIsolated(), isOkCharge(), TIDDetId::isZMinusSide(), TECDetId::isZMinusSide(), TIDDetId::isZPlusSide(), TECDetId::isZPlusSide(), kBPIX, kFPIX, maxHitDiffEndcaps_, minHitsinBPIX_, minHitsinENDCAP_, minHitsinENDCAPminus_, minHitsinENDCAPplus_, minHitsinFPIX_, minHitsinFPIXminus_, minHitsinFPIXplus_, minHitsinPIX_, minHitsinTEC_, minHitsinTECminus_, minHitsinTECplus_, minHitsinTIB_, minHitsinTID_, minHitsinTIDminus_, minHitsinTIDplus_, minHitsinTOB_, nHitMin2D_, reco::Track::recHitsBegin(), reco::Track::recHitsEnd(), seedOnlyFromAbove_, PXFDetId::side(), DetId::subdetId(), SiStripDetId::TEC, SiStripDetId::TIB, SiStripDetId::TID, SiStripDetId::TOB, and DetId::Tracker.

Referenced by basicCuts().

 {
   // checking hit requirements beyond simple number of valid hits
 
   if (minHitsinTIB_ || minHitsinTOB_ || minHitsinTID_ || minHitsinTEC_
       || minHitsinENDCAP_ || minHitsinENDCAPplus_ || minHitsinENDCAPminus_ || (maxHitDiffEndcaps_ < 999)
       || minHitsinTIDplus_ || minHitsinTIDminus_
       || minHitsinFPIXplus_ || minHitsinFPIXminus_
       || minHitsinTECplus_ || minHitsinTECminus_
       || minHitsinFPIX_ || minHitsinBPIX_ || minHitsinPIX_ ||nHitMin2D_ || chargeCheck_
       || applyIsolation_ || (seedOnlyFromAbove_ == 1 || seedOnlyFromAbove_ == 2)) {
     // any detailed hit cut is active, so have to check
     
     int nhitinTIB = 0, nhitinTOB = 0, nhitinTID = 0;
     int nhitinTEC = 0, nhitinBPIX = 0, nhitinFPIX = 0, nhitinPIXEL=0;
     int nhitinENDCAP = 0, nhitinENDCAPplus = 0, nhitinENDCAPminus = 0;
     int nhitinTIDplus = 0, nhitinTIDminus = 0;
     int nhitinFPIXplus = 0, nhitinFPIXminus = 0;
     int nhitinTECplus = 0, nhitinTECminus = 0;
     unsigned int nHit2D = 0;
     unsigned int thishit = 0;
 
     for (trackingRecHit_iterator iHit = trackp->recHitsBegin(); iHit != trackp->recHitsEnd(); ++iHit) {
       thishit++;
       const DetId detId((*iHit)->geographicalId());
       const int subdetId = detId.subdetId(); 
 
       // *** thishit == 1 means last hit in CTF *** 
       // (FIXME: assumption might change or not be valid for all tracking algorthms)
       // ==> for cosmics
       // seedOnlyFrom = 1 is TIB-TOB-TEC tracks only
       // seedOnlyFrom = 2 is TOB-TEC tracks only 
       if (seedOnlyFromAbove_ == 1 && thishit == 1 
           && (subdetId == int(SiStripDetId::TOB) || subdetId == int(SiStripDetId::TEC))){
         return false; 
       }
       if (seedOnlyFromAbove_ == 2 && thishit == 1 && subdetId == int(SiStripDetId::TIB)) {
         return false;
       }
 
       if (!(*iHit)->isValid()) continue; // only real hits count as in trackp->numberOfValidHits()
       if (detId.det() != DetId::Tracker) {
         edm::LogError("DetectorMismatch") << "@SUB=AlignmentTrackSelector::detailedHitsCheck"
                                           << "DetId.det() != DetId::Tracker (=" << DetId::Tracker
                                           << "), but " << detId.det() << ".";
       }
       const TrackingRecHit* therechit = (*iHit).get();
       if (chargeCheck_ && !(this->isOkCharge(therechit))) return false;
       if (applyIsolation_ && (!this->isIsolated(therechit, evt))) return false;
       if      (SiStripDetId::TIB == subdetId) ++nhitinTIB;
       else if (SiStripDetId::TOB == subdetId) ++nhitinTOB;
       else if (SiStripDetId::TID == subdetId) {
         ++nhitinTID;
         ++nhitinENDCAP;
         TIDDetId tidId(detId);
         if (tidId.isZMinusSide()) {
           ++nhitinTIDminus;
           ++nhitinENDCAPminus;
     }
         else if (tidId.isZPlusSide()) {
           ++nhitinTIDplus;
           ++nhitinENDCAPplus;
     }
       }
       else if (SiStripDetId::TEC == subdetId) {
         ++nhitinTEC;
         ++nhitinENDCAP;
         TECDetId tecId(detId);
         if (tecId.isZMinusSide()) {
           ++nhitinTECminus;
           ++nhitinENDCAPminus;
     }
         else if (tecId.isZPlusSide()) {
           ++nhitinTECplus;
           ++nhitinENDCAPplus;
     }
       }
       else if (            kBPIX == subdetId) {++nhitinBPIX;++nhitinPIXEL;}
       else if (            kFPIX == subdetId) {
         ++nhitinFPIX;
         ++nhitinPIXEL;
     PXFDetId fpixId(detId);
         if (fpixId.side()==1) ++nhitinFPIXminus;
         else if (fpixId.side()==2) ++nhitinFPIXplus;
       }
       // Do not call isHit2D(..) if already enough 2D hits for performance reason:
       if (nHit2D < nHitMin2D_ && this->isHit2D(**iHit)) ++nHit2D;
     } // end loop on hits
   
     return (nhitinTIB >= minHitsinTIB_ && nhitinTOB >= minHitsinTOB_ 
             && nhitinTID >= minHitsinTID_ && nhitinTEC >= minHitsinTEC_ 
             && nhitinENDCAP >= minHitsinENDCAP_ && nhitinENDCAPplus >= minHitsinENDCAPplus_ && nhitinENDCAPminus >= minHitsinENDCAPminus_
         && std::abs(nhitinENDCAPplus-nhitinENDCAPminus) <= maxHitDiffEndcaps_
             && nhitinTIDplus >= minHitsinTIDplus_ && nhitinTIDminus >= minHitsinTIDminus_
             && nhitinFPIXplus >= minHitsinFPIXplus_ && nhitinFPIXminus >= minHitsinFPIXminus_
             && nhitinTECplus >= minHitsinTECplus_ && nhitinTECminus >= minHitsinTECminus_
             && nhitinBPIX >= minHitsinBPIX_ 
         && nhitinFPIX >= minHitsinFPIX_ && nhitinPIXEL>=minHitsinPIX_ 
             && nHit2D >= nHitMin2D_);
   } else { // no cuts set, so we are just fine and can avoid loop on hits
     return true;
   }
   
 }

bool AlignmentTrackSelector::isHit2D ( const TrackingRecHit & hit ) const

private

Definition at line 388 of file AlignmentTrackSelector.cc.

References countStereoHitAs2D_, TrackingRecHit::dimension(), TrackingRecHit::geographicalId(), TrackingRecHit::isValid(), kBPIX, kFPIX, ProjectedSiStripRecHit2D::originalHit(), SiStripDetId::stereo(), and DetId::Tracker.

Referenced by detailedHitsCheck().

 {
   // we count SiStrip stereo modules as 2D if selected via countStereoHitAs2D_
   // (since they provide theta information)
   if (!hit.isValid() ||
       (hit.dimension() < 2 && !countStereoHitAs2D_ && !dynamic_cast<const SiStripRecHit1D*>(&hit))){
     return false; // real RecHit1D - but SiStripRecHit1D depends on countStereoHitAs2D_
   } else {
     const DetId detId(hit.geographicalId());
     if (detId.det() == DetId::Tracker) {
       if (detId.subdetId() == kBPIX || detId.subdetId() == kFPIX) {
         return true; // pixel is always 2D
       } else { // should be SiStrip now
     const SiStripDetId stripId(detId);
     if (stripId.stereo()) return countStereoHitAs2D_; // stereo modules
         else if (dynamic_cast<const SiStripRecHit1D*>(&hit)
          || dynamic_cast<const SiStripRecHit2D*>(&hit)) return false; // rphi modules hit
     //the following two are not used any more since ages... 
         else if (dynamic_cast<const SiStripMatchedRecHit2D*>(&hit)) return true; // matched is 2D
         else if (dynamic_cast<const ProjectedSiStripRecHit2D*>(&hit)) {
       const ProjectedSiStripRecHit2D* pH = static_cast<const ProjectedSiStripRecHit2D*>(&hit);
       return (countStereoHitAs2D_ && this->isHit2D(pH->originalHit())); // depends on original...
     } else {
           edm::LogError("UnkownType") << "@SUB=AlignmentTrackSelector::isHit2D"
                                       << "Tracker hit not in pixel, neither SiStripRecHit[12]D nor "
                                       << "SiStripMatchedRecHit2D nor ProjectedSiStripRecHit2D.";
           return false;
         }
       }
     } else { // not tracker??
       edm::LogWarning("DetectorMismatch") << "@SUB=AlignmentTrackSelector::isHit2D"
                                           << "Hit not in tracker with 'official' dimension >=2.";
       return true; // dimension() >= 2 so accept that...
     }
   }
   // never reached...
 }

bool AlignmentTrackSelector::isIsolated	(	const TrackingRecHit *	therechit,
		const edm::Event &	evt
	)		const

private

Definition at line 526 of file AlignmentTrackSelector.cc.

References TrackingRecHit::geographicalId(), edm::Event::getByLabel(), TrackingRecHit::localPosition(), mag(), matchedrecHitsTag_, minHitIsolation_, DetId::rawId(), and rphirecHitsTag_.

Referenced by detailedHitsCheck().

 {
   // FIXME:
   // adapt to changes after introduction of SiStripRecHit1D...
   //
   // edm::ESHandle<TrackerGeometry> tracker;
   edm::Handle<SiStripRecHit2DCollection> rphirecHits;
   edm::Handle<SiStripMatchedRecHit2DCollection> matchedrecHits;
   // es.get<TrackerDigiGeometryRecord>().get(tracker);
   evt.getByLabel( rphirecHitsTag_, rphirecHits );
   evt.getByLabel( matchedrecHitsTag_, matchedrecHits ); 
 
   SiStripRecHit2DCollection::DataContainer::const_iterator istripSt; 
   SiStripMatchedRecHit2DCollection::DataContainer::const_iterator istripStm; 
   const SiStripRecHit2DCollection::DataContainer& stripcollSt = rphirecHits->data();
   const SiStripMatchedRecHit2DCollection::DataContainer& stripcollStm = matchedrecHits->data();
   
   DetId idet = therechit->geographicalId(); 
   
   // FIXME: instead of looping the full hit collection, we should explore the features of 
   // SiStripRecHit2DCollection::rangeRphi = rphirecHits.get(idet) and loop
   // only from rangeRphi.first until rangeRphi.second
   for( istripSt=stripcollSt.begin(); istripSt!=stripcollSt.end(); ++istripSt ) {
     const SiStripRecHit2D *aHit = &*(istripSt);
     DetId mydet1 = aHit->geographicalId(); 
     if (idet.rawId() != mydet1.rawId()) continue; 
     float theDistance = ( therechit->localPosition() - aHit->localPosition() ).mag();
     // std::cout << "theDistance1 = " << theDistance << "\n";
     if (theDistance > 0.001 && theDistance < minHitIsolation_) return false;
   }
   
   // FIXME: see above
   for( istripStm=stripcollStm.begin(); istripStm!=stripcollStm.end(); ++istripStm ) {
     const SiStripMatchedRecHit2D *aHit = &*(istripStm);
     DetId mydet2 = aHit->geographicalId(); 
     if (idet.rawId() != mydet2.rawId()) continue;
     float theDistance = (therechit->localPosition() - aHit->localPosition()).mag();
     // std::cout << "theDistance1 = " << theDistance << "\n";
     if (theDistance > 0.001 && theDistance < minHitIsolation_) return false;
   }
   return true;
 }

bool AlignmentTrackSelector::isOkCharge ( const TrackingRecHit * therechit ) const

private

if valid, check for minimum charge (currently only in strip), if invalid give true

Definition at line 428 of file AlignmentTrackSelector.cc.

References TrackingRecHit::geographicalId(), errorMatrix2Lands_multiChannel::id, isOkChargeStripHit(), TrackingRecHit::isValid(), kBPIX, kFPIX, ProjectedSiStripRecHit2D::originalHit(), and DetId::Tracker.

Referenced by detailedHitsCheck().

 {
   if (!hit || !hit->isValid()) return true; 
 
   // check det and subdet
   const DetId id(hit->geographicalId());
   if (id.det() != DetId::Tracker) {
     edm::LogWarning("DetectorMismatch") << "@SUB=isOkCharge" << "Hit not in tracker!";
     return true;
   }
   if (id.subdetId() == kFPIX || id.subdetId() == kBPIX) {
     return true; // might add some requirement...
   }
 
   // We are in SiStrip now, so test normal hit:
   const std::type_info &type = typeid(*hit);
   
 
   if (type == typeid(SiStripRecHit2D)) {
     const SiStripRecHit2D *stripHit2D = dynamic_cast<const SiStripRecHit2D*>(hit);
     if (stripHit2D) {
       return this->isOkChargeStripHit(*stripHit2D);
     }
   }
   else if(type == typeid(SiStripRecHit1D)){
     const SiStripRecHit1D *stripHit1D = dynamic_cast<const SiStripRecHit1D*>(hit);
     if (stripHit1D) {
       return this->isOkChargeStripHit(*stripHit1D);
     } 
   }
 
   else if(type == typeid(SiStripMatchedRecHit2D)){  // or matched (should not occur anymore due to hit splitting since 20X)
     const SiStripMatchedRecHit2D *matchedHit = dynamic_cast<const SiStripMatchedRecHit2D*>(hit);
     if (matchedHit) {  
       return (this->isOkChargeStripHit(matchedHit->monoHit())
           && this->isOkChargeStripHit(matchedHit->stereoHit()));
     }
   }
   else if(type == typeid(ProjectedSiStripRecHit2D)){ 
     // or projected (should not occur anymore due to hit splitting since 20X):
     const ProjectedSiStripRecHit2D *projHit = dynamic_cast<const ProjectedSiStripRecHit2D*>(hit);
     if (projHit) {
       return this->isOkChargeStripHit(projHit->originalHit());
     }
   }
   else{
     edm::LogError("AlignmentTrackSelector")<< "@SUB=isOkCharge" <<"Unknown type of a valid tracker hit in Strips "
                                            << " SubDet = "<<id.subdetId();
     return false;
   }
   
 
 
   // and now? SiTrackerMultiRecHit? Not here I guess!
   // Should we throw instead?
   edm::LogError("AlignmentTrackSelector") 
     << "@SUB=isOkCharge" << "Unknown valid tracker hit not in pixel, subdet " << id.subdetId()
     << ", SiTrackerMultiRecHit " << dynamic_cast<const SiTrackerMultiRecHit*>(hit)
     << ", BaseTrackerRecHit " << dynamic_cast<const BaseTrackerRecHit*>(hit); 
   
   return true;
 } 

bool AlignmentTrackSelector::isOkChargeStripHit ( const SiStripRecHit1D & siStripRecHit1D ) const

private

Definition at line 510 of file AlignmentTrackSelector.cc.

References DeDxDiscriminatorTools::charge(), and minHitChargeStrip_.

Referenced by isOkCharge().

 {
   double charge = 0.;
 
   SiStripRecHit1D::ClusterRef cluster(siStripRecHit1D.cluster());
   const std::vector<uint8_t> &amplitudes = cluster->amplitudes();
 
   for (size_t ia = 0; ia < amplitudes.size(); ++ia) {
     charge += amplitudes[ia];
   }
 
   return (charge >= minHitChargeStrip_);
 }

bool AlignmentTrackSelector::isOkChargeStripHit ( const SiStripRecHit2D & siStripRecHit2D ) const

private

Definition at line 494 of file AlignmentTrackSelector.cc.

References DeDxDiscriminatorTools::charge(), and minHitChargeStrip_.

 {
   double charge = 0.;
 
   SiStripRecHit2D::ClusterRef cluster(siStripRecHit2D.cluster());
   const std::vector<uint8_t> &amplitudes = cluster->amplitudes();
 
   for (size_t ia = 0; ia < amplitudes.size(); ++ia) {
     charge += amplitudes[ia];
   }
 
   return (charge >= minHitChargeStrip_);
 }

bool AlignmentTrackSelector::isOkTrkQuality ( const reco::Track * track ) const

private

Definition at line 665 of file AlignmentTrackSelector.cc.

References reco::TrackBase::algo(), applyIterStepCheck_, applyTrkQualityCheck_, i, reco::TrackBase::quality(), trkQualities_, and trkSteps_.

Referenced by basicCuts().

 {
   bool qualityOk=false;
   bool iterStepOk=false;
 
   //check iterative step
   if(applyIterStepCheck_){
     for (unsigned int i = 0; i < trkSteps_.size(); ++i) {
       if (track->algo()==(trkSteps_[i])) {
     iterStepOk=true;
       }
     }
   }
   else iterStepOk=true;
 
   //check track quality
   if(applyTrkQualityCheck_){
     for (unsigned int i = 0; i < trkQualities_.size(); ++i) {
       if (track->quality(trkQualities_[i])) {
     qualityOk=true;
       }
     }
   }
   else  qualityOk=true;
 
   return qualityOk&&iterStepOk;
 }//end check on track quality

AlignmentTrackSelector::Tracks AlignmentTrackSelector::select	(	const Tracks &	tracks,
		const edm::Event &	evt
	)		const

select tracks

Definition at line 187 of file AlignmentTrackSelector.cc.

References applyBasicCuts_, applyMultiplicityFilter_, applyNHighestPt_, applyPrescaledHitsFilter_, basicCuts(), checkPrescaledHits(), maxMultiplicity_, minMultiplicity_, multiplicityOnInput_, query::result, theNHighestPtTracks(), and testEve_cfg::tracks.

Referenced by Vispa.Views.LineDecayView.LineDecayContainer::createObject(), Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::find(), Vispa.Views.LineDecayView.LineDecayContainer::mousePressEvent(), Vispa.Gui.PortConnection.PointToPointConnection::mousePressEvent(), Vispa.Gui.VispaWidget.VispaWidget::mousePressEvent(), Vispa.Views.AbstractView.AbstractView::restoreSelection(), and TrackConfigSelector::select().

 {
   
   if (applyMultiplicityFilter_ && multiplicityOnInput_ && 
       (tracks.size() < static_cast<unsigned int>(minMultiplicity_) 
        || tracks.size() > static_cast<unsigned int>(maxMultiplicity_))) {
     return Tracks(); // empty collection
   }
 
   Tracks result = tracks;
   // apply basic track cuts (if selected)
   if (applyBasicCuts_) result= this->basicCuts(result, evt);
   
   // filter N tracks with highest Pt (if selected)
   if (applyNHighestPt_) result = this->theNHighestPtTracks(result);
   
   // apply minimum multiplicity requirement (if selected)
   if (applyMultiplicityFilter_ && !multiplicityOnInput_) {
     if (result.size() < static_cast<unsigned int>(minMultiplicity_) 
         || result.size() > static_cast<unsigned int>(maxMultiplicity_) ) {
 
       result.clear();
     }
   }
 
   if(applyPrescaledHitsFilter_){
     result = this->checkPrescaledHits(result, evt);
   }
 
   return result;
 }

AlignmentTrackSelector::Tracks AlignmentTrackSelector::theNHighestPtTracks ( const Tracks & tracks ) const

private

filter the n highest pt tracks

Definition at line 572 of file AlignmentTrackSelector.cc.

References n, nHighestPt_, ptComparator, query::result, python.multivaluedict::sort(), and testEve_cfg::tracks.

Referenced by select().

 {
   Tracks sortedTracks=tracks;
   Tracks result;
 
   // sort in pt
   std::sort(sortedTracks.begin(),sortedTracks.end(),ptComparator);
 
   // copy theTrackMult highest pt tracks to result vector
   int n=0;
   for (Tracks::const_iterator it=sortedTracks.begin();
        it!=sortedTracks.end(); ++it) {
     if (n<nHighestPt_) { result.push_back(*it); n++; }
   }
 
   return result;
 }

bool AlignmentTrackSelector::useThisFilter ( )

returns if any of the Filters is used.

Definition at line 220 of file AlignmentTrackSelector.cc.

References applyBasicCuts_, applyMultiplicityFilter_, applyNHighestPt_, and applyPrescaledHitsFilter_.

Referenced by TrackConfigSelector::TrackConfigSelector().

 {
   return applyMultiplicityFilter_ || applyBasicCuts_ || applyNHighestPt_ || applyPrescaledHitsFilter_;
 
 }

Member Data Documentation

const bool AlignmentTrackSelector::applyBasicCuts_

private

Definition at line 64 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), select(), and useThisFilter().

const bool AlignmentTrackSelector::applyIsolation_

private

Definition at line 65 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

bool AlignmentTrackSelector::applyIterStepCheck_

private

Definition at line 92 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), basicCuts(), and isOkTrkQuality().

const bool AlignmentTrackSelector::applyMultiplicityFilter_

private

Definition at line 64 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), select(), and useThisFilter().

const bool AlignmentTrackSelector::applyNHighestPt_

private

Definition at line 64 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), select(), and useThisFilter().

const bool AlignmentTrackSelector::applyPrescaledHitsFilter_

private

Definition at line 86 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), select(), and useThisFilter().

bool AlignmentTrackSelector::applyTrkQualityCheck_

private

Definition at line 91 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), basicCuts(), and isOkTrkQuality().

const bool AlignmentTrackSelector::chargeCheck_

private

Definition at line 65 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

const double AlignmentTrackSelector::chi2nMax_

private

Definition at line 69 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and basicCuts().

const edm::InputTag AlignmentTrackSelector::clusterValueMapTag_

private

Definition at line 84 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and checkPrescaledHits().

const bool AlignmentTrackSelector::countStereoHitAs2D_

private

Definition at line 74 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and isHit2D().

const double AlignmentTrackSelector::d0Max_

private

Definition at line 69 of file AlignmentTrackSelector.h.

Referenced by basicCuts().

const double AlignmentTrackSelector::d0Min_

private

Definition at line 69 of file AlignmentTrackSelector.h.

Referenced by basicCuts().

const double AlignmentTrackSelector::dzMax_

private

Definition at line 69 of file AlignmentTrackSelector.h.

Referenced by basicCuts().

const double AlignmentTrackSelector::dzMin_

private

Definition at line 69 of file AlignmentTrackSelector.h.

Referenced by basicCuts().

const double AlignmentTrackSelector::etaMax_

private

Definition at line 68 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and basicCuts().

const double AlignmentTrackSelector::etaMin_

private

Definition at line 68 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and basicCuts().

const edm::InputTag AlignmentTrackSelector::matchedrecHitsTag_

private

Definition at line 73 of file AlignmentTrackSelector.h.

Referenced by isIsolated().

const double AlignmentTrackSelector::maxHitDiffEndcaps_

private

Definition at line 81 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

const int AlignmentTrackSelector::maxMultiplicity_

private

Definition at line 66 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and select().

const double AlignmentTrackSelector::minHitChargeStrip_

private

Definition at line 71 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and isOkChargeStripHit().

const double AlignmentTrackSelector::minHitIsolation_

private

Definition at line 71 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and isIsolated().

const int AlignmentTrackSelector::minHitsinBPIX_

private

Definition at line 77 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

const int AlignmentTrackSelector::minHitsinENDCAP_

private

Definition at line 80 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

const int AlignmentTrackSelector::minHitsinENDCAPminus_

private

Definition at line 80 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

const int AlignmentTrackSelector::minHitsinENDCAPplus_

private

Definition at line 80 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

const int AlignmentTrackSelector::minHitsinFPIX_

private

Definition at line 77 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

const int AlignmentTrackSelector::minHitsinFPIXminus_

private

Definition at line 79 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

const int AlignmentTrackSelector::minHitsinFPIXplus_

private

Definition at line 79 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

const int AlignmentTrackSelector::minHitsinPIX_

private

Definition at line 77 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

const int AlignmentTrackSelector::minHitsinTEC_

private

Definition at line 76 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

const int AlignmentTrackSelector::minHitsinTECminus_

private

Definition at line 78 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

const int AlignmentTrackSelector::minHitsinTECplus_

private

Definition at line 78 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

const int AlignmentTrackSelector::minHitsinTIB_

private

Definition at line 76 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

const int AlignmentTrackSelector::minHitsinTID_

private

Definition at line 76 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

const int AlignmentTrackSelector::minHitsinTIDminus_

private

Definition at line 78 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

const int AlignmentTrackSelector::minHitsinTIDplus_

private

Definition at line 78 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

const int AlignmentTrackSelector::minHitsinTOB_

private

Definition at line 76 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

const int AlignmentTrackSelector::minMultiplicity_

private

Definition at line 66 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and select().

const int AlignmentTrackSelector::minPrescaledHits_

private

Definition at line 85 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and checkPrescaledHits().

const bool AlignmentTrackSelector::multiplicityOnInput_

private

Definition at line 67 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and select().

const int AlignmentTrackSelector::nHighestPt_

private

Definition at line 66 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and theNHighestPtTracks().

const double AlignmentTrackSelector::nHitMax_

private

Definition at line 69 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and basicCuts().

const unsigned int AlignmentTrackSelector::nHitMin2D_

private

Definition at line 75 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

const double AlignmentTrackSelector::nHitMin_

private

Definition at line 69 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and basicCuts().

const double AlignmentTrackSelector::nLostHitMax_

private

Definition at line 82 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and basicCuts().

const double AlignmentTrackSelector::phiMax_

private

Definition at line 68 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and basicCuts().

const double AlignmentTrackSelector::phiMin_

private

Definition at line 68 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and basicCuts().

const double AlignmentTrackSelector::pMax_

private

Definition at line 68 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and basicCuts().

const double AlignmentTrackSelector::pMin_

private

Definition at line 68 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and basicCuts().

ComparePt AlignmentTrackSelector::ptComparator

private

Definition at line 62 of file AlignmentTrackSelector.h.

Referenced by theNHighestPtTracks().

const double AlignmentTrackSelector::ptMax_

private

Definition at line 68 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and basicCuts().

const double AlignmentTrackSelector::ptMin_

private

if true, cut min/maxMultiplicity on input instead of on final result

Definition at line 68 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and basicCuts().

const edm::InputTag AlignmentTrackSelector::rphirecHitsTag_

private

Definition at line 72 of file AlignmentTrackSelector.h.

Referenced by isIsolated().

const bool AlignmentTrackSelector::seedOnlyFromAbove_

private

Definition at line 65 of file AlignmentTrackSelector.h.

Referenced by detailedHitsCheck().

const int AlignmentTrackSelector::theCharge_

private

Definition at line 70 of file AlignmentTrackSelector.h.

Referenced by basicCuts().

std::vector<reco::TrackBase::TrackQuality> AlignmentTrackSelector::trkQualities_

private

Definition at line 88 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and isOkTrkQuality().

std::vector<reco::TrackBase::TrackAlgorithm> AlignmentTrackSelector::trkSteps_

private

Definition at line 90 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and isOkTrkQuality().

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation