LeptonSelection/src/MuonSelection.cc

#include <math.h>
#include <iostream>

#include "MuonSelection.h"
#include "ParseArgs.h"
#include "SelectionStatus.h"

#include "Track.h"
#include "MuonTools.h"
#include "MuonQuality.h"
#include "MuonIDMVA.h"

mithep::MuonIDMVA * muIDMVA;
mithep::MuonTools muTools;

extern vector<bool> PFnoPUflag;
extern Float_t computePFMuonIso(const mithep::Muon *mu, 
                        const mithep::Vertex * vtx,
                        const mithep::Array<mithep::PFCandidate> * pfCandidates,
                        const Double_t dRMax);

bool muon2012CutBasedIDTight(const mithep::Muon *mu, const mithep::Vertex * vtx, const mithep::Array<mithep::PFCandidate> * pfCandidates, const mithep::Array<mithep::PileupEnergyDensity> * puEnergyDensity)
{

  mithep::MuonTools   muT;

  Float_t charged_iso = 0;
  Float_t neutral_iso = 0;
  Float_t gamma_iso = 0;
  
  for(int k=0; k<pfCandidates->GetEntries(); ++k) {
    
    if( !(PFnoPUflag[k]) ) continue; 
    const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*pfCandidates)[k]);
    
    Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
    if (dr > 0.4) continue;
    
    if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
      
      if (abs(pf->PFType()) == mithep::PFCandidate::eElectron || abs(pf->PFType()) == mithep::PFCandidate::eMuon) continue;
      
      charged_iso += pf->Pt();
    }
    
    else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
      
      gamma_iso += pf->Pt();
    }
    
    else {
      neutral_iso += pf->Pt();
    }
  }
  
  mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion  = mithep::MuonTools::kMuEAData2012;
  float rho = puEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral();
  
  double iso_sum = charged_iso + fmax(0.0,(gamma_iso + neutral_iso 
                                        -rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
                                                                   mu->Eta(),EffectiveAreaVersion)));

  bool pass = kTRUE;
  if(!mu->IsGlobalMuon()) pass = kFALSE;

  //there is not necessarily a global track or a tracker track if is global muon is false
  if(!pass) return pass;

  if(!mu->IsPFMuon()) pass = kFALSE;
  if(mu->GlobalTrk()->RChi2() > 10) pass= kFALSE;
  if(mu->NValidHits() == 0 ) pass= kFALSE;
  if(mu->NMatches() <= 1) pass = kFALSE;
  if(fabs(mu->TrackerTrk()->D0Corrected(*vtx)) > 0.2) pass = kFALSE;
  if(fabs(mu->TrackerTrk()->DzCorrected(*vtx)) > 0.5) pass = kFALSE;
  if(mu->BestTrk()->NPixelHits() == 0) pass = kFALSE;
  if(mu->NTrkLayersHit() <= 5) pass = kFALSE; 
  if(iso_sum/mu->Pt() > 0.12 ) pass = kFALSE;

  return pass;


 }

bool trackToPFMuonSelection( const mithep::Track *track, const mithep::MuonCol * muoncol )
{
        bool pass = false;
  for(UInt_t i=0; i<muoncol->GetEntries(); ++i) {
    const mithep::Muon *mu = muoncol->At(i);
                if(mu->TrackerTrk() == track && (mu->IsGlobalMuon() || mu->IsTrackerMuon()) && mu->IsPFMuon())
                        pass = true;
        }               
                
        return pass;            
                
}

//--------------------------------------------------------------------------------------------------
SelectionStatus muonDummyVeto(ControlFlags &ctrl, 
                              const mithep::Muon *muon, 
                              const mithep::Vertex * vtx) 
//--------------------------------------------------------------------------------------------------
{ 
  SelectionStatus status;
  status.setStatus(SelectionStatus::PRESELECTION);
  return status;  
}

//--------------------------------------------------------------------------------------------------
SelectionStatus muonCutBasedVeto(ControlFlags &ctrl, 
                                 const mithep::Muon *muon, 
                                 const mithep::Vertex *vtx) 
//--------------------------------------------------------------------------------------------------
{ 
  //
  // Loose cut-based ID for isolation veto
  //
  bool ret = true;
  
  if(!(muon->IsGlobalMuon() || muon->IsTrackerMuon())) ret = false;
  if( muon->NValidHits() < 11 )                        ret = false;
  if( fabs(muon->Ip3dPVSignificance()) >= 4 )          ret = false;

  SelectionStatus status;
  if( ret ) status.setStatus(SelectionStatus::PRESELECTION);
  return status;
}


//--------------------------------------------------------------------------------------------------
SelectionStatus noPreSelection( ControlFlags &ctrl,  const mithep::Muon * mu ) 

//--------------------------------------------------------------------------------------------------
{
        SelectionStatus status;
        status.setStatus(SelectionStatus::PRESELECTION); 
        if(ctrl.debug) cout << "muon presel returning status : " << status.getStatus() << endl;
        return status;
}

//--------------------------------------------------------------------------------------------------
SelectionStatus muonPreSelection( ControlFlags &ctrl,  
                                  const mithep::Muon * mu, 
                                  const mithep::Vertex * vtx, 
                                  const mithep::Array<mithep::PFCandidate> * pfCandidates ) 
//--------------------------------------------------------------------------------------------------
{ 
  bool ret = true; 

  ret &= ( fabs(mu->Ip3dPVSignificance()) < 100 ); 
  ret &= ( mu->Pt() >= 5 ); 
  ret &= ( fabs(mu->Eta()) <= 2.4 ); 
  ret &= ( mu->IsTrackerMuon() || mu->IsGlobalMuon() ); 
//   if( mu->IsTrackerMuon() && mu->HasTrackerTrk() && !mu->IsGlobalMuon() )  
//     ret &=  ( mu->Quality().QualityMask().Mask() & mithep::MuonQuality::AllArbitrated);
  ret &= (  mu->IsoR03SumPt()/mu->Pt() < 0.7 );

  SelectionStatus status;
  if( ret ) status.setStatus(SelectionStatus::PRESELECTION);
  if(ctrl.debug) cout << "muon presel returning status : " << status.getStatus() << endl;  
  return status;
} 


//--------------------------------------------------------------------------------------------------
SelectionStatus muonReferencePreSelection( ControlFlags &ctrl,  
                                           const mithep::Muon * mu, 
                                           const mithep::Vertex * vtx, 
                                           const mithep::Array<mithep::PFCandidate> * pfCandidates ) 
//--------------------------------------------------------------------------------------------------
{ 
  bool ret = true; 

  if(ctrl.debug) cout << "inside muonpresel ... " << endl;
  ret &= ( fabs(mu->Ip3dPVSignificance()) < 100 ); 
  if(ctrl.debug) cout << "and pass IP (" << mu->Ip3dPVSignificance() << ") ? ... " << ret << endl;  
  ret &= ( mu->Pt() >= 5 ); 
  if(ctrl.debug) cout << "and >5 GeV (" << mu->Pt() << ") ? ... " << ret << endl;  
  ret &= ( fabs(mu->Eta()) <= 2.4 ); 
  if(ctrl.debug) cout << "and < 2.4 eta (" << mu->Eta() << ")? ... " << ret << endl;  
  ret &= ( mu->IsTrackerMuon() || mu->IsGlobalMuon() ); 
  if(ctrl.debug) cout << "is Tracker or Global? ... " << ret << endl;
  ret &= (mu->HasTrackerTrk() && 
          fabs(mu->TrackerTrk()->D0Corrected(*vtx)) < 0.5 &&
          fabs(mu->TrackerTrk()->DzCorrected(*vtx)) < 1.0); 
  if(ctrl.debug) cout << "d0 and dz? ... " << ret << endl;  
          
  //  if( mu->IsTrackerMuon() && mu->HasTrackerTrk() && !mu->IsGlobalMuon() )  
  //    ret &=  ( mu->Quality().QualityMask().Mask() & mithep::MuonQuality::AllArbitrated);
  //  if(ctrl.debug) cout << "if isTrackerMuon, arbitrated ? ... " << ret << endl;  
  //  ret &= ( mu->BestTrk()->DzCorrected(vtx) < 0.1);   
  //  if( ctrl.debug ) cout << "elepresel : ret after dZcorr : " << ret <<  endl;


  SelectionStatus status;
  if( ret ) status.setStatus(SelectionStatus::PRESELECTION);
  if(ctrl.debug) cout << "muon presel returning status : " << status.getStatus() << endl;  
  return status;
} 

//--------------------------------------------------------------------------------------------------
SelectionStatus muonPreSelectionNoD0DzIP( ControlFlags &ctrl,  
                                          const mithep::Muon * mu, 
                                          const mithep::Vertex * vtx, 
                                          const mithep::Array<mithep::PFCandidate> * pfCandidates ) 
//--------------------------------------------------------------------------------------------------
{ 
  bool ret = true; 

  if(ctrl.debug) cout << "inside muonpresel ... " << endl;
  ret &= ( mu->Pt() >= 5 ); 
  if(ctrl.debug) cout << "and >5 GeV (" << mu->Pt() << ") ? ... " << ret << endl;  
  ret &= ( fabs(mu->Eta()) <= 2.4 ); 
  if(ctrl.debug) cout << "and < 2.4 eta (" << mu->Eta() << ")? ... " << ret << endl;  
  ret &= ( mu->IsTrackerMuon() || mu->IsGlobalMuon() ); 
  if(ctrl.debug) cout << "is Tracker or Global? ... " << ret << endl;
          
  //  if( mu->IsTrackerMuon() && mu->HasTrackerTrk() && !mu->IsGlobalMuon() )  
  //    ret &=  ( mu->Quality().QualityMask().Mask() & mithep::MuonQuality::AllArbitrated);
  //  if(ctrl.debug) cout << "if isTrackerMuon, arbitrated ? ... " << ret << endl;  
  //  ret &= ( mu->BestTrk()->DzCorrected(vtx) < 0.1);   
  //  if( ctrl.debug ) cout << "elepresel : ret after dZcorr : " << ret <<  endl;


  SelectionStatus status;
  if( ret ) status.setStatus(SelectionStatus::PRESELECTION);
  if(ctrl.debug) cout << "muon presel returning status : " << status.getStatus() << endl;  
  return status;
} 


//--------------------------------------------------------------------------------------------------
SelectionStatus muonIDMVASelection(ControlFlags &ctrl, 
                                 const mithep::Muon *mu,
                                 const mithep::Vertex * vtx   )
//--------------------------------------------------------------------------------------------------
{
  double global_rchi2 = (mu->IsGlobalMuon()) ? mu->GlobalTrk()->RChi2() : 0.;

  // 
  // WARNING !!! KH hacked out to sync
  //
  /*
  double mvaval = muIDMVA->MVAValue_ID(mu->Pt(),
                                    mu->Eta(),
                                    mu->IsGlobalMuon(),
                                    mu->IsTrackerMuon(),
                                    mu->TrackerTrk()->RChi2(),
                                    global_rchi2,
                                    (Double_t)(mu->NValidHits()),
                                    (Double_t)(mu->TrackerTrk()->NHits()),
                                    (Double_t)(mu->TrackerTrk()->NPixelHits()),
                                    (Double_t)(mu->NMatches()),
                                    mu->TrkKink(),
                                    muTools.GetSegmentCompatability(mu),
                                    muTools.GetCaloCompatability(mu,true,true),
                                    mu->HadEnergy(),
                                    mu->EmEnergy(),
                                    mu->HadS9Energy(),
                                    mu->EmS9Energy(),
                                    (Bool_t)(ctrl.debug) );
  */
  double mvaval = 0.0;

  SelectionStatus status;
  bool pass = false;
  
  if( mu->IsGlobalMuon() && mu->IsTrackerMuon() 
      && fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_IDMVA_CUT_BIN0)  pass = true;
  else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
           && fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_IDMVA_CUT_BIN1)  pass = true;
  else if( mu->IsGlobalMuon() && mu->IsTrackerMuon() 
           && fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_IDMVA_CUT_BIN2)  pass = true;
  else if( mu->IsGlobalMuon() && mu->IsTrackerMuon() 
           && fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_IDMVA_CUT_BIN3)  pass = true;
  else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_IDMVA_CUT_BIN4 )  pass = true;
  else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_IDMVA_CUT_BIN5 )  pass = true;
   

  if( pass ) {
    status.orStatus(SelectionStatus::LOOSEID);
    status.orStatus(SelectionStatus::TIGHTID);
  }

  return status;
}

//--------------------------------------------------------------------------------------------------
void initMuonIDMVA() 
//--------------------------------------------------------------------------------------------------
{ 
  muIDMVA = new mithep::MuonIDMVA();
  vector<string> weightFiles;
  weightFiles.push_back("./data/MuonIDMVAWeights/MuonIDMVA_BDTG_barrel_lowpt_V2.weights.xml");
  weightFiles.push_back("./data/MuonIDMVAWeights/MuonIDMVA_BDTG_barrel_highpt_V2.weights.xml");
  weightFiles.push_back("./data/MuonIDMVAWeights/MuonIDMVA_BDTG_endcap_lowpt_V2.weights.xml");
  weightFiles.push_back("./data/MuonIDMVAWeights/MuonIDMVA_BDTG_endcap_highpt_V2.weights.xml");
  weightFiles.push_back("./data/MuonIDMVAWeights/MuonIDMVA_BDTG_tracker_V2.weights.xml");
  weightFiles.push_back("./data/MuonIDMVAWeights/MuonIDMVA_BDTG_global_V2.weights.xml");
  muIDMVA->Initialize( "MuonIDMVA",
                       mithep::MuonIDMVA::kIDV0,
                       kTRUE, weightFiles);
}

//--------------------------------------------------------------------------------------------------
SelectionStatus muonIDPFSelection(ControlFlags &ctrl, 
                                  const mithep::Muon *mu,
                                  const mithep::Vertex * vtx,
                                  const mithep::Array<mithep::PFCandidate> * pfCandidates )
//--------------------------------------------------------------------------------------------------
{
  bool pass = false;
  SelectionStatus status; // init'ed to FAIL

  // check that it matches to a PF muon
  for( int i=0; i<pfCandidates->GetEntries(); i++ ) {
    // tmp 
    if( !(PFnoPUflag[i]) ) continue; // my PF no PU hack

    const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*pfCandidates)[i]);
    if( (pf->TrackerTrk() == mu->TrackerTrk()) && abs(pf->PFType()) == mithep::PFCandidate::eMuon ) {
      pass = true;
      break;
    }
  }
//      
//      if(mu->IsPFMuon()) pass = true;
//      else pass = false;

  //
  // NB : ipsig here for reference synch ...
  //
#ifdef SYNC
  if( pass && fabs(mu->Ip3dPVSignificance()) < 4 ) {
    status.orStatus(SelectionStatus::LOOSEID);
    status.orStatus(SelectionStatus::TIGHTID);
  }
#else
  if( pass ) {
    status.orStatus(SelectionStatus::LOOSEID);
    status.orStatus(SelectionStatus::TIGHTID);
  }
#endif

  return status;
}
//----------------------------------------------------------------------------------------
SelectionStatus PassWwMuonSel(const mithep::Muon *mu, const mithep::Vertex *vtx,
                              const mithep::Array<mithep::PFCandidate> *pfArr
)
{
  bool passID=true;
  bool passIso=true;
  
  if (mu->Pt() < 5)
    passID = false;
  if (fabs(mu->Eta()) > 2.4)
    passID = false;
  if (mu->BestTrk()->PtErr()/mu->Pt() > 0.1)
    passID = false;
  if (fabs(mu->BestTrk()->DzCorrected(*vtx)) > 0.1)
    passID = false;
  Bool_t isGlobal  = (mu->IsGlobalMuon()) && (mu->BestTrk()->RChi2() < 10) &&
                      (mu->NMatches() > 1) && (mu->NValidHits() > 0);
  Bool_t isTracker = (mu->IsTrackerMuon()) &&
                      (mu->Quality().Quality(mithep::MuonQuality::TMLastStationTight));
  if (!isGlobal && !isTracker)
    passID = false;
  int ntrkhits = (mu->HasTrackerTrk()) ? mu->TrackerTrk()->NHits() : 0;
  if (ntrkhits < 10)
    passID = false;
  if (mu->BestTrk()->NPixelHits() < 1)
    passID = false;
  if (fabs(mu->BestTrk()->D0Corrected(*vtx)) > 0.02)
    passID = false;
  
  // note: this isn't really ww muon isolation
  float pfiso = computePFMuonIso(mu,vtx,pfArr,0.3);

  if (pfiso > 0.2)
    passIso = false;

  SelectionStatus status;
  if(passID)  status |= SelectionStatus::TIGHTIDANDPRE;
  if(passIso) status |= SelectionStatus::TIGHTISOANDPRE;
  
  return status;

}
Revision:	1.28
Committed:	Wed Jun 13 14:11:22 2012 UTC (12 years, 11 months ago) by dkralph
Content type:	text/plain
Branch:	MAIN
Changes since 1.27:	+43 -0 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	khahn	1.1	#include <math.h>
2			#include <iostream>
3
4			#include "MuonSelection.h"
5			#include "ParseArgs.h"
6			#include "SelectionStatus.h"
7
8	khahn	1.4	#include "Track.h"
9			#include "MuonTools.h"
10			#include "MuonQuality.h"
11			#include "MuonIDMVA.h"
12
13			mithep::MuonIDMVA * muIDMVA;
14			mithep::MuonTools muTools;
15
16	khahn	1.19	extern vector<bool> PFnoPUflag;
17	khahn	1.4	extern Float_t computePFMuonIso(const mithep::Muon *mu,
18	anlevin	1.21	const mithep::Vertex * vtx,
19	khahn	1.4	const mithep::Array<mithep::PFCandidate> * pfCandidates,
20			const Double_t dRMax);
21
22	anlevin	1.27	bool muon2012CutBasedIDTight(const mithep::Muon mu, const mithep::Vertex vtx, const mithep::Array<mithep::PFCandidate> * pfCandidates, const mithep::Array<mithep::PileupEnergyDensity> * puEnergyDensity)
23			{
24
25			mithep::MuonTools muT;
26
27			Float_t charged_iso = 0;
28			Float_t neutral_iso = 0;
29			Float_t gamma_iso = 0;
30
31			for(int k=0; k<pfCandidates->GetEntries(); ++k) {
32
33			if( !(PFnoPUflag[k]) ) continue;
34			const mithep::PFCandidate pf = (mithep::PFCandidate)((*pfCandidates)[k]);
35
36			Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
37			if (dr > 0.4) continue;
38
39			if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
40
41			if (abs(pf->PFType()) == mithep::PFCandidate::eElectron \|\| abs(pf->PFType()) == mithep::PFCandidate::eMuon) continue;
42
43			charged_iso += pf->Pt();
44			}
45
46			else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
47
48			gamma_iso += pf->Pt();
49			}
50
51			else {
52			neutral_iso += pf->Pt();
53			}
54			}
55
56			mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion = mithep::MuonTools::kMuEAData2012;
57			float rho = puEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral();
58
59			double iso_sum = charged_iso + fmax(0.0,(gamma_iso + neutral_iso
60			-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
61			mu->Eta(),EffectiveAreaVersion)));
62
63			bool pass = kTRUE;
64			if(!mu->IsGlobalMuon()) pass = kFALSE;
65
66			//there is not necessarily a global track or a tracker track if is global muon is false
67			if(!pass) return pass;
68
69			if(!mu->IsPFMuon()) pass = kFALSE;
70			if(mu->GlobalTrk()->RChi2() > 10) pass= kFALSE;
71			if(mu->NValidHits() == 0 ) pass= kFALSE;
72			if(mu->NMatches() <= 1) pass = kFALSE;
73			if(fabs(mu->TrackerTrk()->D0Corrected(*vtx)) > 0.2) pass = kFALSE;
74			if(fabs(mu->TrackerTrk()->DzCorrected(*vtx)) > 0.5) pass = kFALSE;
75			if(mu->BestTrk()->NPixelHits() == 0) pass = kFALSE;
76			if(mu->NTrkLayersHit() <= 5) pass = kFALSE;
77			if(iso_sum/mu->Pt() > 0.12 ) pass = kFALSE;
78
79			return pass;
80
81
82			}
83
84	anlevin	1.24	bool trackToPFMuonSelection( const mithep::Track track, const mithep::MuonCol muoncol )
85			{
86			bool pass = false;
87			for(UInt_t i=0; i<muoncol->GetEntries(); ++i) {
88			const mithep::Muon *mu = muoncol->At(i);
89			if(mu->TrackerTrk() == track && (mu->IsGlobalMuon() \|\| mu->IsTrackerMuon()) && mu->IsPFMuon())
90			pass = true;
91			}
92
93			return pass;
94
95			}
96
97	khahn	1.4	//--------------------------------------------------------------------------------------------------
98	khahn	1.8	SelectionStatus muonDummyVeto(ControlFlags &ctrl,
99			const mithep::Muon *muon,
100	anlevin	1.21	const mithep::Vertex * vtx)
101	khahn	1.8	//--------------------------------------------------------------------------------------------------
102			{
103			SelectionStatus status;
104			status.setStatus(SelectionStatus::PRESELECTION);
105			return status;
106			}
107
108			//--------------------------------------------------------------------------------------------------
109			SelectionStatus muonCutBasedVeto(ControlFlags &ctrl,
110			const mithep::Muon *muon,
111	anlevin	1.21	const mithep::Vertex *vtx)
112	khahn	1.8	//--------------------------------------------------------------------------------------------------
113			{
114			//
115			// Loose cut-based ID for isolation veto
116			//
117			bool ret = true;
118
119			if(!(muon->IsGlobalMuon() \|\| muon->IsTrackerMuon())) ret = false;
120			if( muon->NValidHits() < 11 ) ret = false;
121			if( fabs(muon->Ip3dPVSignificance()) >= 4 ) ret = false;
122
123			SelectionStatus status;
124			if( ret ) status.setStatus(SelectionStatus::PRESELECTION);
125			return status;
126			}
127
128
129			//--------------------------------------------------------------------------------------------------
130	khahn	1.4	SelectionStatus noPreSelection( ControlFlags &ctrl, const mithep::Muon * mu )
131
132			//--------------------------------------------------------------------------------------------------
133			{
134	anlevin	1.3	SelectionStatus status;
135			status.setStatus(SelectionStatus::PRESELECTION);
136			if(ctrl.debug) cout << "muon presel returning status : " << status.getStatus() << endl;
137			return status;
138			}
139	khahn	1.1
140	khahn	1.4	//--------------------------------------------------------------------------------------------------
141			SelectionStatus muonPreSelection( ControlFlags &ctrl,
142			const mithep::Muon * mu,
143	anlevin	1.21	const mithep::Vertex * vtx,
144	khahn	1.4	const mithep::Array<mithep::PFCandidate> * pfCandidates )
145			//--------------------------------------------------------------------------------------------------
146			{
147			bool ret = true;
148	khahn	1.20
149			ret &= ( fabs(mu->Ip3dPVSignificance()) < 100 );
150	khahn	1.14	ret &= ( mu->Pt() >= 5 );
151	khahn	1.7	ret &= ( fabs(mu->Eta()) <= 2.4 );
152	khahn	1.11	ret &= ( mu->IsTrackerMuon() \|\| mu->IsGlobalMuon() );
153	khahn	1.20	// if( mu->IsTrackerMuon() && mu->HasTrackerTrk() && !mu->IsGlobalMuon() )
154			// ret &= ( mu->Quality().QualityMask().Mask() & mithep::MuonQuality::AllArbitrated);
155			ret &= ( mu->IsoR03SumPt()/mu->Pt() < 0.7 );
156	khahn	1.1
157			SelectionStatus status;
158			if( ret ) status.setStatus(SelectionStatus::PRESELECTION);
159			if(ctrl.debug) cout << "muon presel returning status : " << status.getStatus() << endl;
160			return status;
161			}
162
163	khahn	1.4
164	khahn	1.1
165	khahn	1.13	//--------------------------------------------------------------------------------------------------
166			SelectionStatus muonReferencePreSelection( ControlFlags &ctrl,
167			const mithep::Muon * mu,
168	anlevin	1.21	const mithep::Vertex * vtx,
169	khahn	1.13	const mithep::Array<mithep::PFCandidate> * pfCandidates )
170			//--------------------------------------------------------------------------------------------------
171			{
172			bool ret = true;
173	khahn	1.20
174	khahn	1.13	if(ctrl.debug) cout << "inside muonpresel ... " << endl;
175	khahn	1.16	ret &= ( fabs(mu->Ip3dPVSignificance()) < 100 );
176	khahn	1.13	if(ctrl.debug) cout << "and pass IP (" << mu->Ip3dPVSignificance() << ") ? ... " << ret << endl;
177	khahn	1.14	ret &= ( mu->Pt() >= 5 );
178	khahn	1.13	if(ctrl.debug) cout << "and >5 GeV (" << mu->Pt() << ") ? ... " << ret << endl;
179			ret &= ( fabs(mu->Eta()) <= 2.4 );
180			if(ctrl.debug) cout << "and < 2.4 eta (" << mu->Eta() << ")? ... " << ret << endl;
181			ret &= ( mu->IsTrackerMuon() \|\| mu->IsGlobalMuon() );
182	anlevin	1.21	if(ctrl.debug) cout << "is Tracker or Global? ... " << ret << endl;
183	khahn	1.26	ret &= (mu->HasTrackerTrk() &&
184			fabs(mu->TrackerTrk()->D0Corrected(*vtx)) < 0.5 &&
185			fabs(mu->TrackerTrk()->DzCorrected(*vtx)) < 1.0);
186	anlevin	1.21	if(ctrl.debug) cout << "d0 and dz? ... " << ret << endl;
187
188	khahn	1.13	// if( mu->IsTrackerMuon() && mu->HasTrackerTrk() && !mu->IsGlobalMuon() )
189			// ret &= ( mu->Quality().QualityMask().Mask() & mithep::MuonQuality::AllArbitrated);
190			// if(ctrl.debug) cout << "if isTrackerMuon, arbitrated ? ... " << ret << endl;
191			// ret &= ( mu->BestTrk()->DzCorrected(vtx) < 0.1);
192			// if( ctrl.debug ) cout << "elepresel : ret after dZcorr : " << ret << endl;
193
194
195			SelectionStatus status;
196			if( ret ) status.setStatus(SelectionStatus::PRESELECTION);
197			if(ctrl.debug) cout << "muon presel returning status : " << status.getStatus() << endl;
198			return status;
199			}
200
201	khahn	1.25	//--------------------------------------------------------------------------------------------------
202			SelectionStatus muonPreSelectionNoD0DzIP( ControlFlags &ctrl,
203			const mithep::Muon * mu,
204			const mithep::Vertex * vtx,
205			const mithep::Array<mithep::PFCandidate> * pfCandidates )
206			//--------------------------------------------------------------------------------------------------
207			{
208			bool ret = true;
209
210			if(ctrl.debug) cout << "inside muonpresel ... " << endl;
211			ret &= ( mu->Pt() >= 5 );
212			if(ctrl.debug) cout << "and >5 GeV (" << mu->Pt() << ") ? ... " << ret << endl;
213			ret &= ( fabs(mu->Eta()) <= 2.4 );
214			if(ctrl.debug) cout << "and < 2.4 eta (" << mu->Eta() << ")? ... " << ret << endl;
215			ret &= ( mu->IsTrackerMuon() \|\| mu->IsGlobalMuon() );
216			if(ctrl.debug) cout << "is Tracker or Global? ... " << ret << endl;
217
218			// if( mu->IsTrackerMuon() && mu->HasTrackerTrk() && !mu->IsGlobalMuon() )
219			// ret &= ( mu->Quality().QualityMask().Mask() & mithep::MuonQuality::AllArbitrated);
220			// if(ctrl.debug) cout << "if isTrackerMuon, arbitrated ? ... " << ret << endl;
221			// ret &= ( mu->BestTrk()->DzCorrected(vtx) < 0.1);
222			// if( ctrl.debug ) cout << "elepresel : ret after dZcorr : " << ret << endl;
223
224
225			SelectionStatus status;
226			if( ret ) status.setStatus(SelectionStatus::PRESELECTION);
227			if(ctrl.debug) cout << "muon presel returning status : " << status.getStatus() << endl;
228			return status;
229			}
230
231	khahn	1.13
232
233	anlevin	1.3
234	khahn	1.4	//--------------------------------------------------------------------------------------------------
235			SelectionStatus muonIDMVASelection(ControlFlags &ctrl,
236			const mithep::Muon *mu,
237	anlevin	1.21	const mithep::Vertex * vtx )
238	khahn	1.4	//--------------------------------------------------------------------------------------------------
239			{
240			double global_rchi2 = (mu->IsGlobalMuon()) ? mu->GlobalTrk()->RChi2() : 0.;
241	anlevin	1.3
242	khahn	1.13	//
243			// WARNING !!! KH hacked out to sync
244			//
245			/*
246	khahn	1.4	double mvaval = muIDMVA->MVAValue_ID(mu->Pt(),
247			mu->Eta(),
248			mu->IsGlobalMuon(),
249			mu->IsTrackerMuon(),
250			mu->TrackerTrk()->RChi2(),
251			global_rchi2,
252			(Double_t)(mu->NValidHits()),
253	khahn	1.11	(Double_t)(mu->TrackerTrk()->NHits()),
254	khahn	1.4	(Double_t)(mu->TrackerTrk()->NPixelHits()),
255			(Double_t)(mu->NMatches()),
256			mu->TrkKink(),
257			muTools.GetSegmentCompatability(mu),
258			muTools.GetCaloCompatability(mu,true,true),
259			mu->HadEnergy(),
260			mu->EmEnergy(),
261			mu->HadS9Energy(),
262			mu->EmS9Energy(),
263			(Bool_t)(ctrl.debug) );
264	khahn	1.13	*/
265			double mvaval = 0.0;
266	anlevin	1.3
267	khahn	1.4	SelectionStatus status;
268			bool pass = false;
269
270			if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
271	khahn	1.7	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_IDMVA_CUT_BIN0) pass = true;
272	khahn	1.4	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
273	khahn	1.7	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_IDMVA_CUT_BIN1) pass = true;
274	khahn	1.4	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
275	khahn	1.7	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_IDMVA_CUT_BIN2) pass = true;
276	khahn	1.4	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
277			&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_IDMVA_CUT_BIN3) pass = true;
278	khahn	1.11	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_IDMVA_CUT_BIN4 ) pass = true;
279			else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_IDMVA_CUT_BIN5 ) pass = true;
280
281	khahn	1.4
282
283			if( pass ) {
284			status.orStatus(SelectionStatus::LOOSEID);
285			status.orStatus(SelectionStatus::TIGHTID);
286	anlevin	1.3	}
287
288	khahn	1.4	return status;
289			}
290	anlevin	1.3
291	khahn	1.4	//--------------------------------------------------------------------------------------------------
292			void initMuonIDMVA()
293			//--------------------------------------------------------------------------------------------------
294			{
295			muIDMVA = new mithep::MuonIDMVA();
296			vector<string> weightFiles;
297	khahn	1.6	weightFiles.push_back("./data/MuonIDMVAWeights/MuonIDMVA_BDTG_barrel_lowpt_V2.weights.xml");
298			weightFiles.push_back("./data/MuonIDMVAWeights/MuonIDMVA_BDTG_barrel_highpt_V2.weights.xml");
299			weightFiles.push_back("./data/MuonIDMVAWeights/MuonIDMVA_BDTG_endcap_lowpt_V2.weights.xml");
300			weightFiles.push_back("./data/MuonIDMVAWeights/MuonIDMVA_BDTG_endcap_highpt_V2.weights.xml");
301			weightFiles.push_back("./data/MuonIDMVAWeights/MuonIDMVA_BDTG_tracker_V2.weights.xml");
302			weightFiles.push_back("./data/MuonIDMVAWeights/MuonIDMVA_BDTG_global_V2.weights.xml");
303	khahn	1.4	muIDMVA->Initialize( "MuonIDMVA",
304			mithep::MuonIDMVA::kIDV0,
305			kTRUE, weightFiles);
306			}
307	khahn	1.9
308			//--------------------------------------------------------------------------------------------------
309			SelectionStatus muonIDPFSelection(ControlFlags &ctrl,
310			const mithep::Muon *mu,
311	anlevin	1.21	const mithep::Vertex * vtx,
312	khahn	1.9	const mithep::Array<mithep::PFCandidate> * pfCandidates )
313			//--------------------------------------------------------------------------------------------------
314			{
315			bool pass = false;
316			SelectionStatus status; // init'ed to FAIL
317
318			// check that it matches to a PF muon
319			for( int i=0; i<pfCandidates->GetEntries(); i++ ) {
320	khahn	1.19	// tmp
321			if( !(PFnoPUflag[i]) ) continue; // my PF no PU hack
322
323	khahn	1.9	const mithep::PFCandidate pf = (mithep::PFCandidate)((*pfCandidates)[i]);
324	khahn	1.19	if( (pf->TrackerTrk() == mu->TrackerTrk()) && abs(pf->PFType()) == mithep::PFCandidate::eMuon ) {
325	khahn	1.17	pass = true;
326			break;
327	khahn	1.9	}
328			}
329	anlevin	1.22	//
330			// if(mu->IsPFMuon()) pass = true;
331			// else pass = false;
332	khahn	1.9
333	khahn	1.13	//
334			// NB : ipsig here for reference synch ...
335			//
336	khahn	1.19	#ifdef SYNC
337	khahn	1.16	if( pass && fabs(mu->Ip3dPVSignificance()) < 4 ) {
338	khahn	1.9	status.orStatus(SelectionStatus::LOOSEID);
339			status.orStatus(SelectionStatus::TIGHTID);
340			}
341	khahn	1.19	#else
342			if( pass ) {
343			status.orStatus(SelectionStatus::LOOSEID);
344			status.orStatus(SelectionStatus::TIGHTID);
345			}
346			#endif
347	khahn	1.9
348			return status;
349			}
350	dkralph	1.28	//----------------------------------------------------------------------------------------
351			SelectionStatus PassWwMuonSel(const mithep::Muon mu, const mithep::Vertex vtx,
352			const mithep::Array<mithep::PFCandidate> *pfArr
353			)
354			{
355			bool passID=true;
356			bool passIso=true;
357
358			if (mu->Pt() < 5)
359			passID = false;
360			if (fabs(mu->Eta()) > 2.4)
361			passID = false;
362			if (mu->BestTrk()->PtErr()/mu->Pt() > 0.1)
363			passID = false;
364			if (fabs(mu->BestTrk()->DzCorrected(*vtx)) > 0.1)
365			passID = false;
366			Bool_t isGlobal = (mu->IsGlobalMuon()) && (mu->BestTrk()->RChi2() < 10) &&
367			(mu->NMatches() > 1) && (mu->NValidHits() > 0);
368			Bool_t isTracker = (mu->IsTrackerMuon()) &&
369			(mu->Quality().Quality(mithep::MuonQuality::TMLastStationTight));
370			if (!isGlobal && !isTracker)
371			passID = false;
372			int ntrkhits = (mu->HasTrackerTrk()) ? mu->TrackerTrk()->NHits() : 0;
373			if (ntrkhits < 10)
374			passID = false;
375			if (mu->BestTrk()->NPixelHits() < 1)
376			passID = false;
377			if (fabs(mu->BestTrk()->D0Corrected(*vtx)) > 0.02)
378			passID = false;
379
380			// note: this isn't really ww muon isolation
381			float pfiso = computePFMuonIso(mu,vtx,pfArr,0.3);
382
383			if (pfiso > 0.2)
384			passIso = false;
385
386			SelectionStatus status;
387			if(passID) status \|= SelectionStatus::TIGHTIDANDPRE;
388			if(passIso) status \|= SelectionStatus::TIGHTISOANDPRE;
389
390			return status;
391
392			}