#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, edm::ConsumesCollector &iC)
	constructor More...

Tracks	select (const Tracks &tracks, const edm::Event &evt, const edm::EventSetup &eSetup) 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 edm::EventSetup &eSetup) 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 edm::EventSetup &eSetup) 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_

edm::EDGetTokenT< AliClusterValueMap >	clusterValueMapToken_

const bool	countStereoHitAs2D_

const double	d0Max_

const double	d0Min_

const double	dzMax_

const double	dzMin_

const double	etaMax_

const double	etaMin_

edm::EDGetTokenT< SiStripMatchedRecHit2DCollection >	matchedrecHitsToken_

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...

std::vector< double >	RorZofFirstHitMax_

std::vector< double >	RorZofFirstHitMin_

std::vector< double >	RorZofLastHitMax_

std::vector< double >	RorZofLastHitMin_

edm::EDGetTokenT< SiStripRecHit2DCollection >	rphirecHitsToken_

const int	seedOnlyFromAbove_

const int	theCharge_

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

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

Detailed Description

Definition at line 23 of file AlignmentTrackSelector.h.

Member Typedef Documentation

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

Definition at line 25 of file AlignmentTrackSelector.h.

Constructor & Destructor Documentation

AlignmentTrackSelector::AlignmentTrackSelector	(	const edm::ParameterSet &	cfg,
		edm::ConsumesCollector &	iC
	)

constructor

Definition at line 33 of file AlignmentTrackSelector.cc.

References reco::TrackBase::algoByName(), applyBasicCuts_, applyIsolation_, applyIterStepCheck_, applyMultiplicityFilter_, applyNHighestPt_, applyPrescaledHitsFilter_, applyTrkQualityCheck_, chargeCheck_, chi2nMax_, clusterValueMapTag_, clusterValueMapToken_, edm::ConsumesCollector::consumes(), countStereoHitAs2D_, etaMax_, etaMin_, Exception, edm::ParameterSet::getParameter(), mps_fire::i, matchedrecHitsToken_, 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(), RorZofFirstHitMax_, RorZofFirstHitMin_, RorZofLastHitMax_, RorZofLastHitMin_, rphirecHitsToken_, AlCaHLTBitMon_QueryRunRegistry::string, 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")),
       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")),
       RorZofFirstHitMin_(cfg.getParameter<std::vector<double> >("RorZofFirstHitMin")),
       RorZofFirstHitMax_(cfg.getParameter<std::vector<double> >("RorZofFirstHitMax")),
       RorZofLastHitMin_(cfg.getParameter<std::vector<double> >("RorZofLastHitMin")),
       RorZofLastHitMax_(cfg.getParameter<std::vector<double> >("RorZofLastHitMax")),
       clusterValueMapTag_(cfg.getParameter<edm::InputTag>("hitPrescaleMapTag")),
       minPrescaledHits_(cfg.getParameter<int>("minPrescaledHits")),
       applyPrescaledHitsFilter_(!clusterValueMapTag_.encode().empty() && minPrescaledHits_ > 0) {
   if (applyIsolation_) {
     rphirecHitsToken_ = iC.consumes<SiStripRecHit2DCollection>(cfg.getParameter<edm::InputTag>("rphirecHits"));
     matchedrecHitsToken_ =
         iC.consumes<SiStripMatchedRecHit2DCollection>(cfg.getParameter<edm::InputTag>("matchedrecHits"));
   }
 
   if (applyPrescaledHitsFilter_) {
     clusterValueMapToken_ = iC.consumes<AliClusterValueMap>(clusterValueMapTag_);
   }
 
   //convert track quality from string to enum
   std::vector<std::string> trkQualityStrings(cfg.getParameter<std::vector<std::string> >("trackQualities"));
   std::string qualities;
   if (!trkQualityStrings.empty()) {
     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.empty()) {
     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.empty()) {
       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_ << ")";
   }
 
   // Checking whether cuts on positions of first and last track hits are defined properly
   if (RorZofFirstHitMin_.size() != 2) {
     throw cms::Exception("BadConfig") << "@SUB=AlignmentTrackSelector::AlignmentTrackSelector"
                                       << "Wrong configuration of 'RorZofFirstHitMin'."
                                       << " Must have exactly 2 values instead of configured "
                                       << RorZofFirstHitMin_.size() << ")";
   } else {
     RorZofFirstHitMin_.at(0) = std::fabs(RorZofFirstHitMin_.at(0));
     RorZofFirstHitMin_.at(1) = std::fabs(RorZofFirstHitMin_.at(1));
   }
   if (RorZofFirstHitMax_.size() != 2) {
     throw cms::Exception("BadConfig") << "@SUB=AlignmentTrackSelector::AlignmentTrackSelector"
                                       << "Wrong configuration of 'RorZofFirstHitMax'."
                                       << " Must have exactly 2 values instead of configured "
                                       << RorZofFirstHitMax_.size() << ")";
   } else {
     RorZofFirstHitMax_.at(0) = std::fabs(RorZofFirstHitMax_.at(0));
     RorZofFirstHitMax_.at(1) = std::fabs(RorZofFirstHitMax_.at(1));
   }
   if (RorZofLastHitMin_.size() != 2) {
     throw cms::Exception("BadConfig") << "@SUB=AlignmentTrackSelector::AlignmentTrackSelector"
                                       << "Wrong configuration of 'RorZofLastHitMin'."
                                       << " Must have exactly 2 values instead of configured "
                                       << RorZofLastHitMin_.size() << ")";
   } else {
     RorZofLastHitMin_.at(0) = std::fabs(RorZofLastHitMin_.at(0));
     RorZofLastHitMin_.at(1) = std::fabs(RorZofLastHitMin_.at(1));
   }
   if (RorZofLastHitMax_.size() != 2) {
     throw cms::Exception("BadConfig") << "@SUB=AlignmentTrackSelector::AlignmentTrackSelector"
                                       << "Wrong configuration of 'RorZofLastHitMax'."
                                       << " Must have exactly 2 values instead of configured "
                                       << RorZofLastHitMax_.size() << ")";
   } else {
     RorZofLastHitMax_.at(0) = std::fabs(RorZofLastHitMax_.at(0));
     RorZofLastHitMax_.at(1) = std::fabs(RorZofLastHitMax_.at(1));
   }
   // If first hit set to be at larger distance then the last hit
   if (RorZofFirstHitMin_.at(0) > RorZofLastHitMax_.at(0) && RorZofFirstHitMin_.at(1) > RorZofLastHitMax_.at(1)) {
     throw cms::Exception("BadConfig") << "@SUB=AlignmentTrackSelector::AlignmentTrackSelector"
                                       << "Position of the first hit is set to larger distance than the last hit:."
                                       << " First hit(min): [" << RorZofFirstHitMin_.at(0) << ", "
                                       << RorZofFirstHitMin_.at(1) << "]; Last hit(max): [" << RorZofLastHitMax_.at(0)
                                       << ", " << RorZofLastHitMax_.at(1) << "];";
   }
 }

AlignmentTrackSelector::~AlignmentTrackSelector ( )

destructor

Definition at line 225 of file AlignmentTrackSelector.cc.

225 {}

Member Function Documentation

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

private

apply basic cuts on pt,eta,phi,nhit

Definition at line 269 of file AlignmentTrackSelector.cc.

References applyIterStepCheck_, applyTrkQualityCheck_, reco::TrackBase::charge(), chi2n, chi2nMax_, allConversions_cfi::d0, reco::TrackBase::d0(), d0Min_, detailedHitsCheck(), PVValHelper::dz, reco::TrackBase::dz(), dzMax_, dzMin_, PVValHelper::eta, reco::TrackBase::eta(), etaMin_, isOkTrkQuality(), nHitMax_, nHitMin_, nLostHitMax_, reco::TrackBase::normalizedChi2(), reco::TrackBase::numberOfLostHits(), reco::TrackBase::numberOfValidHits(), AlCaHLTBitMon_ParallelJobs::p, reco::TrackBase::p(), phi, reco::TrackBase::phi(), phiMin_, pMin_, EnergyCorrector::pt, reco::TrackBase::pt(), ptMin_, lumiQueryAPI::q, mps_fire::result, and theCharge_.

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, eSetup);
 
       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 672 of file AlignmentTrackSelector.cc.

References SiStripRecHit1D::cluster(), SiStripRecHit2D::cluster(), SiPixelRecHit::cluster(), clusterValueMapToken_, RemoveAddSevLevel::flag, edm::Event::getByToken(), AlignmentClusterFlag::isTaken(), kBPIX, kFPIX, minPrescaledHits_, mps_fire::result, and DetId::subdetId().

Referenced by select().

                                                                                                      {
   Tracks result;
 
   //take Cluster-Flag Assomap
   edm::Handle<AliClusterValueMap> fMap;
   evt.getByToken(clusterValueMapToken_, fMap);
   const AliClusterValueMap& flagMap = *fMap;
 
   //for each track loop on hits and count the number of taken hits
   for (auto const& trackp : tracks) {
     int ntakenhits = 0;
     //    float pt=trackp->pt();
 
     for (auto const& hit : trackp->recHits()) {
       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 != nullptr) {
             SiStripRecHit2D::ClusterRef stripclust(striphit->cluster());
             flag = flagMap[stripclust];
           }
         } else if (type == typeid(SiStripRecHit1D)) {
           const SiStripRecHit1D* striphit = dynamic_cast<const SiStripRecHit1D*>(hit);
           if (striphit != nullptr) {
             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 != nullptr) {
           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 edm::EventSetup &	eSetup
	)		const

private

checking hit requirements beyond simple number of valid hits

Definition at line 320 of file AlignmentTrackSelector.cc.

References funct::abs(), applyIsolation_, chargeCheck_, edm::EventSetup::get(), reco::Track::innerPosition(), isHit2D(), isIsolated(), isOkCharge(), kBPIX, kFPIX, maxHitDiffEndcaps_, minHitsinBPIX_, minHitsinENDCAP_, minHitsinENDCAPminus_, minHitsinENDCAPplus_, minHitsinFPIX_, minHitsinFPIXminus_, minHitsinFPIXplus_, minHitsinPIX_, minHitsinTEC_, minHitsinTECminus_, minHitsinTECplus_, minHitsinTIB_, minHitsinTID_, minHitsinTIDminus_, minHitsinTIDplus_, minHitsinTOB_, nHitMin2D_, reco::Track::outerPosition(), edm::ESHandle< T >::product(), TrackerTopology::pxfSide(), reco::Track::recHits(), RorZofFirstHitMax_, RorZofFirstHitMin_, RorZofLastHitMax_, RorZofLastHitMin_, seedOnlyFromAbove_, DetId::subdetId(), SiStripDetId::TEC, TrackerTopology::tecIsZMinusSide(), TrackerTopology::tecIsZPlusSide(), SiStripDetId::TIB, SiStripDetId::TID, TrackerTopology::tidIsZMinusSide(), TrackerTopology::tidIsZPlusSide(), SiStripDetId::TOB, and DetId::Tracker.

Referenced by basicCuts().

                                                                                   {
   //Retrieve tracker topology from geometry
   edm::ESHandle<TrackerTopology> tTopoHandle;
   eSetup.get<TrackerTopologyRcd>().get(tTopoHandle);
   const TrackerTopology* const tTopo = tTopoHandle.product();
 
   // 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) || !RorZofFirstHitMin_.empty() ||
       !RorZofFirstHitMax_.empty() || !RorZofLastHitMin_.empty() || !RorZofLastHitMax_.empty()) {
     // 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 (auto const& hit : trackp->recHits()) {
       thishit++;
       const DetId detId(hit->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 (!hit->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() << ".";
       }
       if (chargeCheck_ && !(this->isOkCharge(hit)))
         return false;
       if (applyIsolation_ && (!this->isIsolated(hit, evt)))
         return false;
       if (SiStripDetId::TIB == subdetId)
         ++nhitinTIB;
       else if (SiStripDetId::TOB == subdetId)
         ++nhitinTOB;
       else if (SiStripDetId::TID == subdetId) {
         ++nhitinTID;
         ++nhitinENDCAP;
 
         if (tTopo->tidIsZMinusSide(detId)) {
           ++nhitinTIDminus;
           ++nhitinENDCAPminus;
         } else if (tTopo->tidIsZPlusSide(detId)) {
           ++nhitinTIDplus;
           ++nhitinENDCAPplus;
         }
       } else if (SiStripDetId::TEC == subdetId) {
         ++nhitinTEC;
         ++nhitinENDCAP;
 
         if (tTopo->tecIsZMinusSide(detId)) {
           ++nhitinTECminus;
           ++nhitinENDCAPminus;
         } else if (tTopo->tecIsZPlusSide(detId)) {
           ++nhitinTECplus;
           ++nhitinENDCAPplus;
         }
       } else if (kBPIX == subdetId) {
         ++nhitinBPIX;
         ++nhitinPIXEL;
       } else if (kFPIX == subdetId) {
         ++nhitinFPIX;
         ++nhitinPIXEL;
 
         if (tTopo->pxfSide(detId) == 1)
           ++nhitinFPIXminus;
         else if (tTopo->pxfSide(detId) == 2)
           ++nhitinFPIXplus;
       }
       // Do not call isHit2D(..) if already enough 2D hits for performance reason:
       if (nHit2D < nHitMin2D_ && this->isHit2D(*hit))
         ++nHit2D;
     }  // end loop on hits
 
     // Checking whether the track satisfies requirement of the first and last hit positions
     bool passedLastHitPositionR = true;
     bool passedLastHitPositionZ = true;
     bool passedFirstHitPositionR = true;
     bool passedFirstHitPositionZ = true;
 
     if (RorZofFirstHitMin_.at(0) != 0.0 || RorZofFirstHitMin_.at(1) != 0.0 || RorZofFirstHitMax_.at(0) != 999.0 ||
         RorZofFirstHitMax_.at(1) != 999.0) {
       const reco::TrackBase::Point& firstPoint(trackp->innerPosition());
 
       if ((std::fabs(firstPoint.R()) < RorZofFirstHitMin_.at(0)))
         passedFirstHitPositionR = false;
       if ((std::fabs(firstPoint.R()) > RorZofFirstHitMax_.at(0)))
         passedFirstHitPositionR = false;
       if ((std::fabs(firstPoint.Z()) < RorZofFirstHitMin_.at(1)))
         passedFirstHitPositionZ = false;
       if ((std::fabs(firstPoint.Z()) > RorZofFirstHitMax_.at(1)))
         passedFirstHitPositionZ = false;
     }
 
     if (RorZofLastHitMin_.at(0) != 0.0 || RorZofLastHitMin_.at(1) != 0.0 || RorZofLastHitMax_.at(0) != 999.0 ||
         RorZofLastHitMax_.at(1) != 999.0) {
       const reco::TrackBase::Point& lastPoint(trackp->outerPosition());
 
       if ((std::fabs(lastPoint.R()) < RorZofLastHitMin_.at(0)))
         passedLastHitPositionR = false;
       if ((std::fabs(lastPoint.R()) > RorZofLastHitMax_.at(0)))
         passedLastHitPositionR = false;
       if ((std::fabs(lastPoint.Z()) < RorZofLastHitMin_.at(1)))
         passedLastHitPositionZ = false;
       if ((std::fabs(lastPoint.Z()) > RorZofLastHitMax_.at(1)))
         passedLastHitPositionZ = false;
     }
 
     bool passedFirstHitPosition = passedFirstHitPositionR || passedFirstHitPositionZ;
     bool passedLastHitPosition = passedLastHitPositionR || passedLastHitPositionZ;
 
     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_ && passedFirstHitPosition && passedLastHitPosition);
   } 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 472 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 603 of file AlignmentTrackSelector.cc.

References edmNew::DetSetVector< T >::data(), TrackingRecHit::geographicalId(), edm::Event::getByToken(), BaseTrackerRecHit::localPosition(), TrackingRecHit::localPosition(), mag(), AlignmentTrackSelector_cfi::matchedrecHits, matchedrecHitsToken_, minHitIsolation_, DetId::rawId(), AlignmentTrackSelector_cfi::rphirecHits, and rphirecHitsToken_.

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.getByToken(rphirecHitsToken_, rphirecHits);
   evt.getByToken(matchedrecHitsToken_, 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 = hit->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 = (hit->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 = (hit->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 512 of file AlignmentTrackSelector.cc.

References TrackingRecHit::geographicalId(), triggerObjects_cff::id, isOkChargeStripHit(), TrackingRecHit::isValid(), kBPIX, kFPIX, SiStripMatchedRecHit2D::monoHit(), ProjectedSiStripRecHit2D::originalHit(), SiStripMatchedRecHit2D::stereoHit(), 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 588 of file AlignmentTrackSelector.cc.

References ALCARECOTkAlJpsiMuMu_cff::charge, SiStripRecHit1D::cluster(), and minHitChargeStrip_.

Referenced by isOkCharge().

                                                                                             {
   double charge = 0.;
 
   SiStripRecHit1D::ClusterRef cluster(siStripRecHit1D.cluster());
   const auto& 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 573 of file AlignmentTrackSelector.cc.

References ALCARECOTkAlJpsiMuMu_cff::charge, SiStripRecHit2D::cluster(), and minHitChargeStrip_.

                                                                                             {
   double charge = 0.;
 
   SiStripRecHit2D::ClusterRef cluster(siStripRecHit2D.cluster());
   const auto& 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 742 of file AlignmentTrackSelector.cc.

References reco::TrackBase::algo(), applyIterStepCheck_, applyTrkQualityCheck_, mps_fire::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 edm::EventSetup &	eSetup
	)		const

select tracks

Definition at line 229 of file AlignmentTrackSelector.cc.

References applyBasicCuts_, applyMultiplicityFilter_, applyNHighestPt_, applyPrescaledHitsFilter_, basicCuts(), checkPrescaledHits(), maxMultiplicity_, minMultiplicity_, multiplicityOnInput_, mps_fire::result, theNHighestPtTracks(), and l1t::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, eSetup);
 
   // 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 651 of file AlignmentTrackSelector.cc.

References gen::n, nHighestPt_, ptComparator, mps_fire::result, jetUpdater_cfi::sort, and l1t::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 263 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 63 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 97 of file AlignmentTrackSelector.h.

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

const bool AlignmentTrackSelector::applyMultiplicityFilter_

private

Definition at line 63 of file AlignmentTrackSelector.h.

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

const bool AlignmentTrackSelector::applyNHighestPt_

private

Definition at line 63 of file AlignmentTrackSelector.h.

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

const bool AlignmentTrackSelector::applyPrescaledHitsFilter_

private

Definition at line 91 of file AlignmentTrackSelector.h.

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

bool AlignmentTrackSelector::applyTrkQualityCheck_

private

Definition at line 96 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 88 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector().

edm::EDGetTokenT<AliClusterValueMap> AlignmentTrackSelector::clusterValueMapToken_

private

Definition at line 89 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.

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().

const double AlignmentTrackSelector::etaMin_

private

Definition at line 68 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and basicCuts().

edm::EDGetTokenT<SiStripMatchedRecHit2DCollection> AlignmentTrackSelector::matchedrecHitsToken_

private

Definition at line 73 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and 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 90 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().

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().

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 61 of file AlignmentTrackSelector.h.

Referenced by theNHighestPtTracks().

const double AlignmentTrackSelector::ptMax_

private

Definition at line 68 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector().

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().

std::vector<double> AlignmentTrackSelector::RorZofFirstHitMax_

private

Definition at line 84 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

std::vector<double> AlignmentTrackSelector::RorZofFirstHitMin_

private

Definition at line 83 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

std::vector<double> AlignmentTrackSelector::RorZofLastHitMax_

private

Definition at line 86 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

std::vector<double> AlignmentTrackSelector::RorZofLastHitMin_

private

Definition at line 85 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and detailedHitsCheck().

edm::EDGetTokenT<SiStripRecHit2DCollection> AlignmentTrackSelector::rphirecHitsToken_

private

Definition at line 72 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and isIsolated().

const int AlignmentTrackSelector::seedOnlyFromAbove_

private

Definition at line 64 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 93 of file AlignmentTrackSelector.h.

Referenced by AlignmentTrackSelector(), and isOkTrkQuality().

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

private

Definition at line 95 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