CMS 3D CMS Logo
Classes | Public Types | Public Member Functions | Private Member Functions | Private Attributes

AlignmentTrackSelector Class Reference

#include <AlignmentTrackSelector.h>

List of all members.

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
Tracks select (const Tracks &tracks, const edm::Event &evt) const
 select tracks
bool useThisFilter ()
 returns if any of the Filters is used.
 ~AlignmentTrackSelector ()
 destructor

Private Member Functions

Tracks basicCuts (const Tracks &tracks, const edm::Event &evt) const
 apply basic cuts on pt,eta,phi,nhit
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
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
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

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

{}

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_, eta(), reco::TrackBase::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(), TECDetId::isZMinusSide(), TIDDetId::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, align::Tracker, 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 align::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 align::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 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::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::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 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().

Generated for CMSSW Reference Manual by doxygen 1.7.3