MuonBadTrackFilter Class Reference

Inheritance diagram for MuonBadTrackFilter:

Public Member Functions
	MuonBadTrackFilter (const edm::ParameterSet &)
	~MuonBadTrackFilter ()
Public Member Functions inherited from edm::global::EDFilter<>
	EDFilter ()=default
Public Member Functions inherited from edm::global::EDFilterBase
	EDFilterBase ()
ModuleDescription const &	moduleDescription () const
virtual	~EDFilterBase ()
Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	ProducerBase ()
void	registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...
virtual	~ProducerBase ()
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
	EDConsumerBase ()
ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
virtual	~EDConsumerBase ()

Private Member Functions
virtual bool	filter (edm::StreamID iID, edm::Event &, const edm::EventSetup &) const override
virtual void	printMuonProperties (const reco::MuonRef &muonRef) const
virtual std::string	trackInfo (const reco::TrackRef &trackRef) const

Private Attributes
const double	chi2Min_
const bool	debug_
const double	p1_
const double	p2_
const double	p3_
const double	ptMin_
const bool	taggingMode_
edm::EDGetTokenT < reco::PFCandidateCollection >	tokenPFCandidates_

Additional Inherited Members
Public Types inherited from edm::global::EDFilterBase
typedef EDFilterBase	ModuleType
Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Static Public Member Functions inherited from edm::global::EDFilterBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 28 of file MuonBadTrackFilter.cc.

Constructor & Destructor Documentation

MuonBadTrackFilter::MuonBadTrackFilter ( const edm::ParameterSet &  iConfig )

explicit

Definition at line 62 of file MuonBadTrackFilter.cc.

  : tokenPFCandidates_ ( consumes<reco::PFCandidateCollection>(iConfig.getParameter<edm::InputTag> ("PFCandidates")  ))
  , taggingMode_          ( iConfig.getParameter<bool>    ("taggingMode")         )
  , ptMin_                ( iConfig.getParameter<double>        ("ptMin")         )
  , chi2Min_              ( iConfig.getParameter<double>      ("chi2Min")         )
  , p1_                   ( iConfig.getParameter<double>        ("p1")            )
  , p2_                   ( iConfig.getParameter<double>        ("p2")            )
  , p3_                   ( iConfig.getParameter<double>        ("p3")            )
  , debug_                ( iConfig.getParameter<bool>          ("debug")         )
{
  produces<bool>();
}

MuonBadTrackFilter::~MuonBadTrackFilter

(

)

Definition at line 75 of file MuonBadTrackFilter.cc.

{ }

Member Function Documentation

bool MuonBadTrackFilter::filter ( edm::StreamID  iID, edm::Event &  iEvent, const edm::EventSetup &  iSetup  ) const

overrideprivatevirtual

Implements edm::global::EDFilterBase.

Definition at line 84 of file MuonBadTrackFilter.cc.

References funct::abs(), chi2Min_, gather_cfg::cout, debug_, edm::Event::getByToken(), i, edm::Ref< C, T, F >::isAvailable(), edm::Ref< C, T, F >::isNull(), metsig::muon, reco::PFCandidate::muonRef(), P, p1_, p2_, p3_, reco::LeafCandidate::pdgId(), reco::tau::pfCandidates(), printMuonProperties(), reco::tau::disc::Pt(), reco::LeafCandidate::pt(), ptMin_, edm::Event::put(), mathSSE::sqrt(), taggingMode_, tokenPFCandidates_, and reco::PFCandidate::trackRef().

{
  using namespace std;
  using namespace edm;

  Handle<reco::PFCandidateCollection>     pfCandidates;
  iEvent.getByToken(tokenPFCandidates_,pfCandidates);

  bool foundBadTrack = false;

  for ( unsigned i=0; i<pfCandidates->size(); ++i ) {

    const reco::PFCandidate & cand = (*pfCandidates)[i];
  
    if ( std::abs(cand.pdgId()) != 13 ) continue;

    if (cand.pt() < ptMin_) continue;

    if (cand.muonRef().isNull()) continue;
    
    const reco::MuonRef       muon  = cand.muonRef();
    if ( debug_ ) printMuonProperties(muon);
    
    if (muon->muonBestTrack().isAvailable()) {
      if (muon->muonBestTrack()->hitPattern().numberOfValidMuonHits() == 0) {
        
        if (muon->globalTrack().isAvailable()) {
          if (muon->globalTrack()->normalizedChi2() > chi2Min_) {
            foundBadTrack = true;
            if ( debug_ ) cout << "globalTrack numberOfValidMuonHits: " << muon->globalTrack()->hitPattern().numberOfValidMuonHits() <<
              " numberOfValidMuonCSCHits: " << muon->globalTrack()->hitPattern().numberOfValidMuonCSCHits() <<
              " numberOfValidMuonDTHits: " << muon->globalTrack()->hitPattern().numberOfValidMuonDTHits() <<
              " normalizedChi2: " << muon->globalTrack()->normalizedChi2() << endl;
            if ( debug_ ) cout << "muonBestTrack numberOfValidMuonHits: " << muon->muonBestTrack()->hitPattern().numberOfValidMuonHits() <<
              " numberOfValidMuonCSCHits: " << muon->muonBestTrack()->hitPattern().numberOfValidMuonCSCHits() <<
              " numberOfValidMuonDTHits: " << muon->muonBestTrack()->hitPattern().numberOfValidMuonDTHits() <<
              " normalizedChi2: " << muon->muonBestTrack()->normalizedChi2() << endl;
          }
        }

      }
    }
    
    // perform same check as for charged hadrons
    if (!cand.trackRef().isNull()) {
    
      const reco::TrackRef trackref = cand.trackRef();
      const double Pt = trackref->pt();
      const double DPt = trackref->ptError();
      const double P = trackref->p();
      const unsigned int LostHits = trackref->numberOfLostHits();

      if ((DPt/Pt) > (p1_ * sqrt(p2_*p2_/P+p3_*p3_) / (1.+LostHits))) {

        foundBadTrack = true;

        if ( debug_ ) {
          cout << cand << endl;
          cout << "muon \t" << "track pT = " << Pt << " +/- " << DPt;
          cout << endl;
        }
      }
    }

    // check if at least one track has good quality
    if (muon->innerTrack().isAvailable()) {
      const double P = muon->innerTrack()->p();
      const double DPt = muon->innerTrack()->ptError();
      if (P != 0) {
        if ( debug_ ) cout << "innerTrack DPt/P: " << DPt/P << endl;
        if (DPt/P < 1) {
          if ( debug_ ) cout << "innerTrack good" << endl;
          continue;
        }
      }
    }
    if (muon->pickyTrack().isAvailable()) {
      const double P = muon->pickyTrack()->p();
      const double DPt = muon->pickyTrack()->ptError();
      if (P != 0) {
        if ( debug_ ) cout << "pickyTrack DPt/P: " << DPt/P << endl;
        if (DPt/P < 1) {
          if ( debug_ ) cout << "pickyTrack good" << endl;
          continue;
        }
      }
    }
    if (muon->globalTrack().isAvailable()) {
      const double P = muon->globalTrack()->p();
      const double DPt = muon->globalTrack()->ptError();
      if (P != 0) {
        if ( debug_ ) cout << "globalTrack DPt/P: " << DPt/P << endl;
        if (DPt/P < 1) {
          if ( debug_ ) cout << "globalTrack good" << endl;
          continue;
        }
      }
    }
    if (muon->tpfmsTrack().isAvailable()) {
      const double P = muon->tpfmsTrack()->p();
      const double DPt = muon->tpfmsTrack()->ptError();
      if (P != 0) {
        if ( debug_ ) cout << "tpfmsTrack DPt/P: " << DPt/P << endl;
        if (DPt/P < 1) {
          if ( debug_ ) cout << "tpfmsTrack good" << endl;
          continue;
        }
      }
    }
    if (muon->dytTrack().isAvailable()) {
      const double P = muon->dytTrack()->p();
      const double DPt = muon->dytTrack()->ptError();
      if (P != 0) {
        if ( debug_ ) cout << "dytTrack DPt/P: " << DPt/P << endl;
        if (DPt/P < 1) {
          if ( debug_ ) cout << "dytTrack good" << endl;
          continue;
        }
      }
    }
    if ( debug_ ) cout << "No tracks are good" << endl;
    foundBadTrack = true;
    
    
  } // end loop over PF candidates


  bool pass = !foundBadTrack;

  iEvent.put( std::auto_ptr<bool>(new bool(pass)) );

  return taggingMode_ || pass;
}

void MuonBadTrackFilter::printMuonProperties ( const reco::MuonRef &  muonRef ) const

privatevirtual

Definition at line 249 of file MuonBadTrackFilter.cc.

References runregparse::combined, reco::Muon::CombinedTrack, gather_cfg::cout, delta, reco::Muon::DYT, reco::Muon::InnerTrack, muon::isGoodMuon(), edm::Ref< C, T, F >::isNonnull(), bookConverter::max, min(), reco::Muon::OuterTrack, reco::Muon::Picky, mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, muon::TM2DCompatibilityLoose, muon::TM2DCompatibilityTight, muon::TMLastStationAngLoose, muon::TMLastStationAngTight, muon::TMLastStationLoose, muon::TMLastStationOptimizedBarrelLowPtLoose, muon::TMLastStationOptimizedBarrelLowPtTight, muon::TMLastStationOptimizedLowPtLoose, muon::TMLastStationOptimizedLowPtTight, muon::TMLastStationTight, muon::TMOneStationLoose, muon::TMOneStationTight, reco::Muon::TPFMS, patCandidatesForDimuonsSequences_cff::tracker, and trackInfo().

Referenced by filter().

                                                                             {
  
  if ( !muonRef.isNonnull() ) return;
  
  bool isGL = muonRef->isGlobalMuon();
  bool isTR = muonRef->isTrackerMuon();
  bool isST = muonRef->isStandAloneMuon();
  bool isTPFMS = muonRef->tpfmsTrack().isNonnull() && muonRef->tpfmsTrack()->pt()>0;
  bool isPicky = muonRef->pickyTrack().isNonnull() && muonRef->pickyTrack()->pt()>0;
  bool isDyt = muonRef->dytTrack().isNonnull() && muonRef->dytTrack()->pt()>0;
 
  reco::Muon::MuonTrackType tunePType = muonRef->tunePMuonBestTrackType();
  std::string tunePTypeStr; 
  switch( tunePType ){
  case reco::Muon::InnerTrack: tunePTypeStr = "Inner"; break;
  case reco::Muon::OuterTrack: tunePTypeStr = "Outer"; break;
  case reco::Muon::CombinedTrack: tunePTypeStr = "Combined"; break;
  case reco::Muon::TPFMS: tunePTypeStr = "TPFMS"; break;
  case reco::Muon::Picky: tunePTypeStr = "Picky"; break;
  case reco::Muon::DYT: tunePTypeStr = "DYT"; break;
  default:tunePTypeStr = "unknow"; break;
  } 

  std::cout<<"pt " << muonRef->pt()
     <<" eta " << muonRef->eta()  
           <<" GL: "<<isGL
     <<" TR: "<<isTR
     <<" ST: "<<isST
     <<" TPFMS: "<<isTPFMS
     <<" Picky: "<<isPicky
     <<" DYT: "<<isDyt
     <<" TuneP: "<<tunePTypeStr
     <<" nMatches "<<muonRef->numberOfMatches()<<std::endl;

  if ( isGL ) {
    std::cout<<"\tCombined "<<trackInfo(muonRef->combinedMuon())<<std::endl;
    std::cout<<"\tInner "<<trackInfo(muonRef->innerTrack())<<std::endl;
  }

  if ( isST ) {  
    std::cout<<"\tOuter "<<trackInfo(muonRef->standAloneMuon())<<std::endl;
  }

  if ( isTR ){
    reco::TrackRef trackerMu = muonRef->innerTrack();
    // const reco::Track& track = *trackerMu;
    std::cout<<"\tInner "<<trackInfo(trackerMu)<<std::endl;
    std::cout<< "\t\tTMLastStationAngLoose               "
  << muon::isGoodMuon(*muonRef,muon::TMLastStationAngLoose) << std::endl       
  << "\t\tTMLastStationAngTight               "
  << muon::isGoodMuon(*muonRef,muon::TMLastStationAngTight) << std::endl          
  << "\t\tTMLastStationLoose               "
  << muon::isGoodMuon(*muonRef,muon::TMLastStationLoose) << std::endl       
  << "\t\tTMLastStationTight               "
  << muon::isGoodMuon(*muonRef,muon::TMLastStationTight) << std::endl          
  << "\t\tTMOneStationLoose                "
  << muon::isGoodMuon(*muonRef,muon::TMOneStationLoose) << std::endl       
  << "\t\tTMOneStationTight                "
  << muon::isGoodMuon(*muonRef,muon::TMOneStationTight) << std::endl       
  << "\t\tTMLastStationOptimizedLowPtLoose " 
  << muon::isGoodMuon(*muonRef,muon::TMLastStationOptimizedLowPtLoose) << std::endl
  << "\t\tTMLastStationOptimizedLowPtTight " 
  << muon::isGoodMuon(*muonRef,muon::TMLastStationOptimizedLowPtTight) << std::endl 
  << "\t\tTMLastStationOptimizedBarrelLowPtLoose " 
  << muon::isGoodMuon(*muonRef,muon::TMLastStationOptimizedBarrelLowPtLoose) << std::endl
  << "\t\tTMLastStationOptimizedBarrelLowPtTight " 
  << muon::isGoodMuon(*muonRef,muon::TMLastStationOptimizedBarrelLowPtTight) << std::endl 
  << std::endl;
  }

  if( isPicky ) {
    std::cout<<"\tPicky "<<trackInfo(muonRef->pickyTrack())<<std::endl;
  }

  if( isDyt ) {
    std::cout<<"\tDyt "<<trackInfo(muonRef->dytTrack())<<std::endl;
  }

  if( isTPFMS ) {
    std::cout<<"\tTPFMS "<<trackInfo(muonRef->tpfmsTrack())<<std::endl;
  }

  std::cout<< "TM2DCompatibilityLoose           "
     << muon::isGoodMuon(*muonRef,muon::TM2DCompatibilityLoose) << std::endl 
     << "TM2DCompatibilityTight           "
     << muon::isGoodMuon(*muonRef,muon::TM2DCompatibilityTight) << std::endl;

  if ( muonRef->isGlobalMuon() 
       &&  muonRef->isTrackerMuon() 
       &&  muonRef->isStandAloneMuon() ) {
    reco::TrackRef combinedMu = muonRef->combinedMuon();
    reco::TrackRef trackerMu = muonRef->track();
    reco::TrackRef standAloneMu = muonRef->standAloneMuon();
  
    double sigmaCombined = combinedMu->ptError()/(combinedMu->pt()*combinedMu->pt());    
    double sigmaTracker = trackerMu->ptError()/(trackerMu->pt()*trackerMu->pt());    
    double sigmaStandAlone = standAloneMu->ptError()/(standAloneMu->pt()*standAloneMu->pt());    
  
    bool combined = combinedMu->ptError()/combinedMu->pt() < 0.20;   
    bool tracker = trackerMu->ptError()/trackerMu->pt() < 0.20;    
    bool standAlone = standAloneMu->ptError()/standAloneMu->pt() < 0.20;   

    double delta1 =  combined && tracker ?   
      fabs(1./combinedMu->pt() -1./trackerMu->pt())    
      /sqrt(sigmaCombined*sigmaCombined + sigmaTracker*sigmaTracker) : 100.;   
    double delta2 = combined && standAlone ?   
      fabs(1./combinedMu->pt() -1./standAloneMu->pt())   
      /sqrt(sigmaCombined*sigmaCombined + sigmaStandAlone*sigmaStandAlone) : 100.;

    double delta3 = standAlone && tracker ?    
      fabs(1./standAloneMu->pt() -1./trackerMu->pt())    
      /sqrt(sigmaStandAlone*sigmaStandAlone + sigmaTracker*sigmaTracker) : 100.;  

    double delta =   
      standAloneMu->hitPattern().numberOfValidMuonDTHits()+    
      standAloneMu->hitPattern().numberOfValidMuonCSCHits() > 0 ?    
      std::min(delta3,std::min(delta1,delta2)) : std::max(delta3,std::max(delta1,delta2));   

    std::cout << "delta = " << delta << " delta1 "<<delta1<<" delta2 "<<delta2<<" delta3 "<<delta3<<std::endl;   
  
    double ratio =   
      combinedMu->ptError()/combinedMu->pt()   
      / (trackerMu->ptError()/trackerMu->pt());    
    //if ( ratio > 2. && delta < 3. ) std::cout << "ALARM ! " << ratio << ", " << delta << std::endl;
    std::cout<<" ratio "<<ratio<<" combined mu pt "<<combinedMu->pt()<<std::endl;
    //bool quality3 =  ( combinedMu->pt() < 50. || ratio < 2. ) && delta <  3.;
  }

  double sumPtR03 = muonRef->isolationR03().sumPt;
  double emEtR03 = muonRef->isolationR03().emEt;
  double hadEtR03 = muonRef->isolationR03().hadEt;    
  double relIsoR03 = (sumPtR03 + emEtR03 + hadEtR03)/muonRef->pt();
  double sumPtR05 = muonRef->isolationR05().sumPt;
  double emEtR05 = muonRef->isolationR05().emEt;
  double hadEtR05 = muonRef->isolationR05().hadEt;    
  double relIsoR05 = (sumPtR05 + emEtR05 + hadEtR05)/muonRef->pt();
  std::cout<<" 0.3 Rel Iso: "<<relIsoR03<<" sumPt "<<sumPtR03<<" emEt "<<emEtR03<<" hadEt "<<hadEtR03<<std::endl;
  std::cout<<" 0.5 Rel Iso: "<<relIsoR05<<" sumPt "<<sumPtR05<<" emEt "<<emEtR05<<" hadEt "<<hadEtR05<<std::endl;
  return;
}

std::string MuonBadTrackFilter::trackInfo ( const reco::TrackRef &  trackRef ) const

privatevirtual

Definition at line 219 of file MuonBadTrackFilter.cc.

References reco::TrackBase::hitPattern(), edm::Ref< C, T, F >::isAvailable(), edm::Ref< C, T, F >::isNull(), reco::TrackBase::normalizedChi2(), reco::HitPattern::numberOfLostMuonCSCHits(), reco::HitPattern::numberOfLostMuonDTHits(), reco::HitPattern::numberOfLostMuonHits(), reco::HitPattern::numberOfLostMuonRPCHits(), reco::HitPattern::numberOfValidMuonCSCHits(), reco::HitPattern::numberOfValidMuonDTHits(), reco::HitPattern::numberOfValidMuonHits(), reco::HitPattern::numberOfValidMuonRPCHits(), reco::HitPattern::numberOfValidPixelHits(), reco::HitPattern::numberOfValidTrackerHits(), dbtoconf::out, reco::TrackBase::pt(), and reco::TrackBase::ptError().

Referenced by printMuonProperties().

                                                                          {
  
  std::ostringstream out;
  
  if(trackRef.isNull()) {
    out << "track ref not set"; 
  }
  else if (! trackRef.isAvailable()) {
    out << "track ref not available"; 
  }
  else {
    const reco::Track& track = *trackRef; 
    out << "pt = " << track.pt() << " +- " << track.ptError()/track.pt()
  << " chi2 = " << track.normalizedChi2()
  << "; Muon Hits: " << track.hitPattern().numberOfValidMuonHits()
  << "/" << track.hitPattern().numberOfLostMuonHits()
  << " (DT: " << track.hitPattern().numberOfValidMuonDTHits()
  << "/" << track.hitPattern().numberOfLostMuonDTHits()
  << " CSC: " << track.hitPattern().numberOfValidMuonCSCHits()
  << "/" << track.hitPattern().numberOfLostMuonCSCHits()
  << " RPC: " << track.hitPattern().numberOfValidMuonRPCHits()
  << "/" << track.hitPattern().numberOfLostMuonRPCHits() << ")"
        << "; Valid inner hits:"
  << " TRK: " << track.hitPattern().numberOfValidTrackerHits()
  << " PIX: " << track.hitPattern().numberOfValidPixelHits();  
  }   
  return out.str();
}

Member Data Documentation

const double MuonBadTrackFilter::chi2Min_

private

Definition at line 43 of file MuonBadTrackFilter.cc.

Referenced by filter().

const bool MuonBadTrackFilter::debug_

private

Definition at line 47 of file MuonBadTrackFilter.cc.

Referenced by filter().

const double MuonBadTrackFilter::p1_

private

Definition at line 44 of file MuonBadTrackFilter.cc.

Referenced by filter().

const double MuonBadTrackFilter::p2_

private

Definition at line 45 of file MuonBadTrackFilter.cc.

Referenced by filter().

const double MuonBadTrackFilter::p3_

private

Definition at line 46 of file MuonBadTrackFilter.cc.

Referenced by filter().

const double MuonBadTrackFilter::ptMin_

private

Definition at line 42 of file MuonBadTrackFilter.cc.

Referenced by filter().

const bool MuonBadTrackFilter::taggingMode_

private

Definition at line 41 of file MuonBadTrackFilter.cc.

Referenced by filter().

edm::EDGetTokenT<reco::PFCandidateCollection> MuonBadTrackFilter::tokenPFCandidates_

private

Definition at line 40 of file MuonBadTrackFilter.cc.

Referenced by filter().