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 Float_t computePFMuonIso(const mithep::Muon *mu, 
                        const mithep::Vertex & vtx,
                        const mithep::Array<mithep::PFCandidate> * pfCandidates,
                        const Double_t dRMax);

//--------------------------------------------------------------------------------------------------
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; 
  if(ctrl.debug) cout << "inside muonpresel ... " << endl;
  //  bool ret = isMuFO(mu,vtx,pfCandidates);
  if(ctrl.debug) cout << "iS fo? ... " << ret << endl;  
  ret &= ( fabs(mu->Ip3dPVSignificance()) < 4 ); 
  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->HasTrackerTrk() && 
           (mu->Quality().QualityMask().Mask() & mithep::MuonQuality::AllArbitrated));
  if(ctrl.debug) cout << "and isTrackerMuon ? ... " << ret << endl;  
  //  ret &=  (mu->IsoR03SumPt()/mu->Pt() < 0.7 ); 
  ret &=  (mu->IsoR03SumPt()/mu->Pt() < 0.7 ); 
  if(ctrl.debug) cout << "and loose trk iso ? ... " << ret << endl;  

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


//--------------------------------------------------------------------------------------------------
bool isMuFO( const mithep::Muon * mu, 
             const mithep::Vertex & vtx, 
             const mithep::Array<mithep::PFCandidate> * pfCandidates ) 
//--------------------------------------------------------------------------------------------------
{ 
  bool isgood=true;
  float reliso = computePFMuonIso(mu,vtx,pfCandidates,0.3)/mu->Pt();

  if( mu->Pt() < 5  )         isgood=false;                           
  if ( fabs(mu->BestTrk()->DzCorrected(vtx)) > 0.2 ) isgood=false;   // needed to remove cosmics in HF sample

  // 

  // HF seems to not want tkquality, SS does
  if( mu->Pt()>20 ) { 
    if ( !((mu->IsGlobalMuon()) && mu->NSegments()>0  ) ) isgood=false; //&& mu->nValidHits>0
  } else {
    if ( !((mu->IsGlobalMuon()) && mu->NSegments()>0 ) //&& //&& mu->nValidHits>0 
         && !( (mu->IsTrackerMuon()) &&  (mu->Quality().QualityMask().Mask() & muTools.kTMOneStationLoose)
               )
         )   isgood=false;
  }


  //
  // for HF MC to agree w/ data, cannot put any Tk quality bits
  // but to get to 5% closure in the SS test, we need at least Tk oneStationLoose

  /*
&& ( (mu->qualityBits & kTMOneStationLoose) ||
                                               (mu->qualityBits & kTMLastStationOptimizedBarrelLowPtLoose) ||
                                               (mu->qualityBits & kTMLastStationOptimizedLowPtLoose) 
                                               )
  */


  // comment for more stats for mu fake shape
  if( mu->Pt() < 20 ) { 
    if( reliso > 3 ) isgood=false;    
  } else { 
    if( reliso > 5 ) isgood=false;    
  }

  return isgood;
};

//--------------------------------------------------------------------------------------------------
SelectionStatus passSoftMuonSelection( ControlFlags &ctrl, 
                                       const mithep::Muon * mu , 
                                       const mithep::Vertex & vtx) 
//--------------------------------------------------------------------------------------------------
{ 

  int level=0;
  unsigned failmask=0x0;
  
  // Use tracker track when available
  const mithep::Track *muTrk=0;
  if(mu->HasStandaloneTrk()) { muTrk = mu->StandaloneTrk(); }
  else if(mu->HasTrackerTrk())         { muTrk = mu->TrackerTrk(); }
  else if(mu->HasGlobalTrk())     { muTrk = mu->GlobalTrk(); }
  assert(muTrk);                  

  if(mu->TrackerTrk()->NHits() < 11 )  
    failmask |= (1<<level);
  level++;

  if(fabs(muTrk->D0Corrected(vtx)) > 0.2) 
    failmask |= (1<<level);
  level++;

  if(fabs(muTrk->DzCorrected(vtx)) > 0.1) 
    failmask |= (1<<level);
  level++;

  if(!(mu->IsTrackerMuon())) 
    failmask |= (1<<level);
  level++;

  //  if(!(mu->Quality().QualityMask().Mask() & muTools.kTMLastStationAngTight)) 
  if(!(mu->Quality().QualityMask().Mask() & muTools.kTMLastStationTight)) 
    failmask |= (1<<level);       
  level++;

  Double_t iso = (mu->IsoR03SumPt() + mu->IsoR03EmEt() + mu->IsoR03HadEt())/mu->Pt();
  if(mu->Pt()>20 && iso<0.1) 
    failmask |= (1<<level);

  bool passtight  = !(failmask);
  bool passloose  = !(failmask);
  return SelectionStatus( passtight | passloose );
  
}

//-------------------------------------------------------------------------------------------------- 
//unsigned passMuonSelectionZZ( const mithep::TMuon * mu ) { 
SelectionStatus passMuonSelectionZZ( ControlFlags &ctrl, const mithep::Muon * mu ) 
//--------------------------------------------------------------------------------------------------
{ 
  int level=0;
  unsigned failmask=0x0;

  if(mu->Pt() < 5) {
    failmask |= (1<<level);
  }

  level++;
  if(fabs(mu->Eta()) > 2.4) {
    failmask |= (1<<level);
  }

  level++;
  if(!(mu->IsGlobalMuon())) {
    failmask |= (1<<level);
  }

  level++;
  if(mu->TrackerTrk()->NHits()  < 10) {
    failmask |= (1<<level);
  }


  level++;  
  if( (mu->IsoR03SumPt()/mu->Pt()) > 0.7 ) {
    failmask |= (1<<level);
  }

  //  if(muon->nPixHits   < 1)     return false;
  //  if(muon->muNchi2    > 10)    return false;
  //  if(muon->nMatch     < 2)     return false;
  //  if(muon->nValidHits         < 1)     return false;
  //  if(muon->pterr/muon->pt > 0.1)   return false;
  //  if(fabs(muon->dz)       > 0.1)   return false;  
  
  SelectionStatus status;
  if( !failmask ) status.orStatus(SelectionStatus::LOOSEID);
  if( !failmask ) status.orStatus(SelectionStatus::TIGHTID);
  return status;


};


//
// Kevin's WW selection
//
//--------------------------------------------------------------------------------------------------
SelectionStatus passMuonSelection( ControlFlags &ctrl, 
                                   const mithep::Muon * mu, 
                                   const mithep::Vertex & vtx   ) 
//--------------------------------------------------------------------------------------------------
{ 
  SelectionStatus status;
  int level=0;
  unsigned failmask=0x0;

  // Use tracker track when available
  const mithep::Track *muTrk=0;
  if(mu->HasTrackerTrk())         { muTrk = mu->TrackerTrk(); }
  else if(mu->HasGlobalTrk())     { muTrk = mu->GlobalTrk(); }
  else if(mu->HasStandaloneTrk()) { muTrk = mu->StandaloneTrk(); }
  assert(muTrk);                  
  

  // 0x1
  if(muTrk->Pt() < 5) {
    failmask |= (1<<level);
  }

  // 0x2
  level++;
  if(fabs(muTrk->Eta()) > 2.4) {
    failmask |= (1<<level);
  }

  // 0x4
  level++;
  if(muTrk->PtErr()/muTrk->Pt() > 0.1)   {
    failmask |= (1<<level);
  }

  // 0x8
  level++;
  if( fabs(muTrk->DzCorrected(vtx)) > 0.1 )   {
    failmask |= (1<<level);
  }

  double muNchi2;
  if(mu->HasStandaloneTrk())      { muNchi2 = mu->StandaloneTrk()->RChi2(); }
  else if(mu->HasGlobalTrk())     { muNchi2 = mu->GlobalTrk()->RChi2();     }
  else if(mu->HasTrackerTrk())    { muNchi2 = mu->TrackerTrk()->RChi2();    }

  unsigned qualityBits = mu->Quality().QualityMask().Mask();
  
  Bool_t isGlobal  = (mu->IsGlobalMuon()) && (muNchi2 < 10) && (mu->NMatches() > 1) && (mu->NValidHits() > 0);
  Bool_t isTracker = (mu->IsTrackerMuon() ) && (qualityBits & muTools.kTMLastStationTight);

  // 0x10
  level++;
  if((!isGlobal && !isTracker) || !(mu->HasTrackerTrk())) {
    failmask |= (1<<level);
    status.setStatus(SelectionStatus::FAIL);
    return status;    
  }

  // 0x20
  level++;
  assert(mu->HasTrackerTrk());
  assert(mu->TrackerTrk());
  if( mu->TrackerTrk()->NHits() < 10 ) {
    failmask |= (1<<level);
  }

  level++;
  if(muTrk->NPixelHits()          < 1) {
    failmask |= (1<<level);
  }


  level++;
  if(fabs(muTrk->D0Corrected(vtx))>0.02)   { 
    failmask |= (1<<level);
  }

  /*
  if(mu->pt>20) {
    if(fabs(mu->d0)>0.02)   { 
      failmask |= (1<<level);
    }
  } else {
    if(fabs(mu->d0)>0.01)  {
    failmask |= (1<<level);
    }
  }
  */

  if( !failmask ) status.orStatus(SelectionStatus::LOOSEID);
  if( !failmask ) status.orStatus(SelectionStatus::TIGHTID);
  return status;


};


//--------------------------------------------------------------------------------------------------
SelectionStatus muonIDMVASelection(ControlFlags &ctrl, 
                                 const mithep::Muon *mu,
                                 const mithep::Vertex & vtx   )
//--------------------------------------------------------------------------------------------------
{
  assert(mu->IsTrackerMuon()); // must be
  assert(mu->HasTrackerTrk());
  assert(mu->TrackerTrk());

  /*
  cerr << "TrackerTrk: " << mu->TrackerTrk() << endl;
  flush(cerr);
  cerr << "Rchi2: " << mu->TrackerTrk()->RChi2() << endl;
  flush(cerr);

  cerr << "calling MVa ... "<< endl;
  flush(cerr);
  */

  double global_rchi2 = (mu->IsGlobalMuon()) ? mu->GlobalTrk()->RChi2() : 0.;

  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) );


  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() 
           && (mu->Quality().QualityMask().Mask() & mithep::MuonQuality::AllArbitrated) && mvaval >= MUON_IDMVA_CUT_BIN4)
    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 muon is tracker 
  if( !(mu->IsTrackerMuon()) )   return status; 

  // check that it matches to a PF muon
  for( int i=0; i<pfCandidates->GetEntries(); i++ ) {
    const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*pfCandidates)[i]);
    if( pf->HasTrackerTrk() ) {
      if( pf->TrackerTrk() == mu->TrackerTrk() && abs(pf->PFType()) == mithep::PFCandidate::eMuon ) {
        pass = true;
        break;
      }
    }
  }

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

  return status;
}
Revision:	1.9
Committed:	Tue May 1 16:38:35 2012 UTC (13 years ago) by khahn
Content type:	text/plain
Branch:	MAIN
Changes since 1.8:	+32 -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			extern Float_t computePFMuonIso(const mithep::Muon *mu,
17			const mithep::Vertex & vtx,
18			const mithep::Array<mithep::PFCandidate> * pfCandidates,
19			const Double_t dRMax);
20
21			//--------------------------------------------------------------------------------------------------
22	khahn	1.8	SelectionStatus muonDummyVeto(ControlFlags &ctrl,
23			const mithep::Muon *muon,
24			const mithep::Vertex &vtx)
25			//--------------------------------------------------------------------------------------------------
26			{
27			SelectionStatus status;
28			status.setStatus(SelectionStatus::PRESELECTION);
29			return status;
30			}
31
32			//--------------------------------------------------------------------------------------------------
33			SelectionStatus muonCutBasedVeto(ControlFlags &ctrl,
34			const mithep::Muon *muon,
35			const mithep::Vertex &vtx)
36			//--------------------------------------------------------------------------------------------------
37			{
38			//
39			// Loose cut-based ID for isolation veto
40			//
41			bool ret = true;
42
43			if(!(muon->IsGlobalMuon() \|\| muon->IsTrackerMuon())) ret = false;
44			if( muon->NValidHits() < 11 ) ret = false;
45			if( fabs(muon->Ip3dPVSignificance()) >= 4 ) ret = false;
46
47			SelectionStatus status;
48			if( ret ) status.setStatus(SelectionStatus::PRESELECTION);
49			return status;
50			}
51
52
53			//--------------------------------------------------------------------------------------------------
54	khahn	1.4	SelectionStatus noPreSelection( ControlFlags &ctrl, const mithep::Muon * mu )
55
56			//--------------------------------------------------------------------------------------------------
57			{
58	anlevin	1.3	SelectionStatus status;
59			status.setStatus(SelectionStatus::PRESELECTION);
60			if(ctrl.debug) cout << "muon presel returning status : " << status.getStatus() << endl;
61			return status;
62			}
63	khahn	1.1
64	khahn	1.4	//--------------------------------------------------------------------------------------------------
65			SelectionStatus muonPreSelection( ControlFlags &ctrl,
66			const mithep::Muon * mu,
67			const mithep::Vertex & vtx,
68			const mithep::Array<mithep::PFCandidate> * pfCandidates )
69			//--------------------------------------------------------------------------------------------------
70			{
71			bool ret = true;
72	khahn	1.1	if(ctrl.debug) cout << "inside muonpresel ... " << endl;
73	khahn	1.4	// bool ret = isMuFO(mu,vtx,pfCandidates);
74	khahn	1.1	if(ctrl.debug) cout << "iS fo? ... " << ret << endl;
75	khahn	1.4	ret &= ( fabs(mu->Ip3dPVSignificance()) < 4 );
76			if(ctrl.debug) cout << "and pass IP (" << mu->Ip3dPVSignificance() << ") ? ... " << ret << endl;
77			ret &= ( mu->Pt() > 5 );
78	khahn	1.7	if(ctrl.debug) cout << "and >5 GeV (" << mu->Pt() << ") ? ... " << ret << endl;
79			ret &= ( fabs(mu->Eta()) <= 2.4 );
80			if(ctrl.debug) cout << "and < 2.4 eta (" << mu->Eta() << ")? ... " << ret << endl;
81			ret &= (mu->IsTrackerMuon() && mu->HasTrackerTrk() &&
82			(mu->Quality().QualityMask().Mask() & mithep::MuonQuality::AllArbitrated));
83	khahn	1.4	if(ctrl.debug) cout << "and isTrackerMuon ? ... " << ret << endl;
84	khahn	1.7	// ret &= (mu->IsoR03SumPt()/mu->Pt() < 0.7 );
85	khahn	1.4	ret &= (mu->IsoR03SumPt()/mu->Pt() < 0.7 );
86			if(ctrl.debug) cout << "and loose trk iso ? ... " << ret << endl;
87	khahn	1.1
88			SelectionStatus status;
89			if( ret ) status.setStatus(SelectionStatus::PRESELECTION);
90			if(ctrl.debug) cout << "muon presel returning status : " << status.getStatus() << endl;
91			return status;
92			}
93
94	khahn	1.4
95			//--------------------------------------------------------------------------------------------------
96			bool isMuFO( const mithep::Muon * mu,
97			const mithep::Vertex & vtx,
98			const mithep::Array<mithep::PFCandidate> * pfCandidates )
99			//--------------------------------------------------------------------------------------------------
100			{
101	khahn	1.1	bool isgood=true;
102	khahn	1.4	float reliso = computePFMuonIso(mu,vtx,pfCandidates,0.3)/mu->Pt();
103	khahn	1.1
104	khahn	1.4	if( mu->Pt() < 5 ) isgood=false;
105			if ( fabs(mu->BestTrk()->DzCorrected(vtx)) > 0.2 ) isgood=false; // needed to remove cosmics in HF sample
106	khahn	1.1
107			//
108
109			// HF seems to not want tkquality, SS does
110	khahn	1.4	if( mu->Pt()>20 ) {
111			if ( !((mu->IsGlobalMuon()) && mu->NSegments()>0 ) ) isgood=false; //&& mu->nValidHits>0
112	khahn	1.1	} else {
113	khahn	1.4	if ( !((mu->IsGlobalMuon()) && mu->NSegments()>0 ) //&& //&& mu->nValidHits>0
114			&& !( (mu->IsTrackerMuon()) && (mu->Quality().QualityMask().Mask() & muTools.kTMOneStationLoose)
115	khahn	1.1	)
116			) isgood=false;
117			}
118
119
120			//
121			// for HF MC to agree w/ data, cannot put any Tk quality bits
122			// but to get to 5% closure in the SS test, we need at least Tk oneStationLoose
123
124			/*
125			&& ( (mu->qualityBits & kTMOneStationLoose) \|\|
126			(mu->qualityBits & kTMLastStationOptimizedBarrelLowPtLoose) \|\|
127			(mu->qualityBits & kTMLastStationOptimizedLowPtLoose)
128			)
129			*/
130
131
132			// comment for more stats for mu fake shape
133	khahn	1.4	if( mu->Pt() < 20 ) {
134	khahn	1.1	if( reliso > 3 ) isgood=false;
135			} else {
136			if( reliso > 5 ) isgood=false;
137			}
138
139			return isgood;
140			};
141
142	khahn	1.4	//--------------------------------------------------------------------------------------------------
143			SelectionStatus passSoftMuonSelection( ControlFlags &ctrl,
144			const mithep::Muon * mu ,
145			const mithep::Vertex & vtx)
146			//--------------------------------------------------------------------------------------------------
147			{
148	khahn	1.1
149			int level=0;
150			unsigned failmask=0x0;
151
152	khahn	1.4	// Use tracker track when available
153			const mithep::Track *muTrk=0;
154			if(mu->HasStandaloneTrk()) { muTrk = mu->StandaloneTrk(); }
155			else if(mu->HasTrackerTrk()) { muTrk = mu->TrackerTrk(); }
156			else if(mu->HasGlobalTrk()) { muTrk = mu->GlobalTrk(); }
157			assert(muTrk);
158
159			if(mu->TrackerTrk()->NHits() < 11 )
160	khahn	1.1	failmask \|= (1<<level);
161			level++;
162
163	khahn	1.4	if(fabs(muTrk->D0Corrected(vtx)) > 0.2)
164	khahn	1.1	failmask \|= (1<<level);
165			level++;
166
167	khahn	1.4	if(fabs(muTrk->DzCorrected(vtx)) > 0.1)
168	khahn	1.1	failmask \|= (1<<level);
169			level++;
170
171	khahn	1.4	if(!(mu->IsTrackerMuon()))
172	khahn	1.1	failmask \|= (1<<level);
173			level++;
174
175	khahn	1.4	// if(!(mu->Quality().QualityMask().Mask() & muTools.kTMLastStationAngTight))
176			if(!(mu->Quality().QualityMask().Mask() & muTools.kTMLastStationTight))
177	khahn	1.1	failmask \|= (1<<level);
178			level++;
179
180	khahn	1.4	Double_t iso = (mu->IsoR03SumPt() + mu->IsoR03EmEt() + mu->IsoR03HadEt())/mu->Pt();
181			if(mu->Pt()>20 && iso<0.1)
182	khahn	1.1	failmask \|= (1<<level);
183
184			bool passtight = !(failmask);
185			bool passloose = !(failmask);
186			return SelectionStatus( passtight \| passloose );
187
188			}
189
190	khahn	1.4	//--------------------------------------------------------------------------------------------------
191	khahn	1.1	//unsigned passMuonSelectionZZ( const mithep::TMuon * mu ) {
192	khahn	1.4	SelectionStatus passMuonSelectionZZ( ControlFlags &ctrl, const mithep::Muon * mu )
193			//--------------------------------------------------------------------------------------------------
194			{
195	khahn	1.1	int level=0;
196			unsigned failmask=0x0;
197
198	khahn	1.4	if(mu->Pt() < 5) {
199	khahn	1.1	failmask \|= (1<<level);
200			}
201
202			level++;
203	khahn	1.4	if(fabs(mu->Eta()) > 2.4) {
204	khahn	1.1	failmask \|= (1<<level);
205			}
206
207			level++;
208	khahn	1.4	if(!(mu->IsGlobalMuon())) {
209	khahn	1.1	failmask \|= (1<<level);
210			}
211
212			level++;
213	khahn	1.4	if(mu->TrackerTrk()->NHits() < 10) {
214	khahn	1.1	failmask \|= (1<<level);
215			}
216
217
218			level++;
219	khahn	1.4	if( (mu->IsoR03SumPt()/mu->Pt()) > 0.7 ) {
220	khahn	1.1	failmask \|= (1<<level);
221			}
222
223			// if(muon->nPixHits < 1) return false;
224			// if(muon->muNchi2 > 10) return false;
225			// if(muon->nMatch < 2) return false;
226			// if(muon->nValidHits < 1) return false;
227			// if(muon->pterr/muon->pt > 0.1) return false;
228			// if(fabs(muon->dz) > 0.1) return false;
229
230			SelectionStatus status;
231	khahn	1.4	if( !failmask ) status.orStatus(SelectionStatus::LOOSEID);
232			if( !failmask ) status.orStatus(SelectionStatus::TIGHTID);
233	khahn	1.1	return status;
234
235
236
237			};
238
239
240
241
242			//
243			// Kevin's WW selection
244			//
245	khahn	1.4	//--------------------------------------------------------------------------------------------------
246			SelectionStatus passMuonSelection( ControlFlags &ctrl,
247			const mithep::Muon * mu,
248			const mithep::Vertex & vtx )
249			//--------------------------------------------------------------------------------------------------
250			{
251			SelectionStatus status;
252	khahn	1.1	int level=0;
253			unsigned failmask=0x0;
254
255	khahn	1.4	// Use tracker track when available
256			const mithep::Track *muTrk=0;
257			if(mu->HasTrackerTrk()) { muTrk = mu->TrackerTrk(); }
258			else if(mu->HasGlobalTrk()) { muTrk = mu->GlobalTrk(); }
259			else if(mu->HasStandaloneTrk()) { muTrk = mu->StandaloneTrk(); }
260			assert(muTrk);
261
262
263	anlevin	1.3
264	khahn	1.1	// 0x1
265	khahn	1.4	if(muTrk->Pt() < 5) {
266	khahn	1.1	failmask \|= (1<<level);
267			}
268
269			// 0x2
270			level++;
271	khahn	1.4	if(fabs(muTrk->Eta()) > 2.4) {
272	khahn	1.1	failmask \|= (1<<level);
273			}
274
275			// 0x4
276			level++;
277	khahn	1.4	if(muTrk->PtErr()/muTrk->Pt() > 0.1) {
278	khahn	1.1	failmask \|= (1<<level);
279			}
280
281			// 0x8
282			level++;
283	khahn	1.4	if( fabs(muTrk->DzCorrected(vtx)) > 0.1 ) {
284	khahn	1.1	failmask \|= (1<<level);
285			}
286
287	khahn	1.4	double muNchi2;
288			if(mu->HasStandaloneTrk()) { muNchi2 = mu->StandaloneTrk()->RChi2(); }
289			else if(mu->HasGlobalTrk()) { muNchi2 = mu->GlobalTrk()->RChi2(); }
290			else if(mu->HasTrackerTrk()) { muNchi2 = mu->TrackerTrk()->RChi2(); }
291	khahn	1.1
292	khahn	1.4	unsigned qualityBits = mu->Quality().QualityMask().Mask();
293
294			Bool_t isGlobal = (mu->IsGlobalMuon()) && (muNchi2 < 10) && (mu->NMatches() > 1) && (mu->NValidHits() > 0);
295			Bool_t isTracker = (mu->IsTrackerMuon() ) && (qualityBits & muTools.kTMLastStationTight);
296	khahn	1.1
297			// 0x10
298			level++;
299	khahn	1.4	if((!isGlobal && !isTracker) \|\| !(mu->HasTrackerTrk())) {
300	khahn	1.1	failmask \|= (1<<level);
301	khahn	1.4	status.setStatus(SelectionStatus::FAIL);
302			return status;
303	khahn	1.1	}
304
305			// 0x20
306			level++;
307	khahn	1.4	assert(mu->HasTrackerTrk());
308			assert(mu->TrackerTrk());
309			if( mu->TrackerTrk()->NHits() < 10 ) {
310	khahn	1.1	failmask \|= (1<<level);
311			}
312
313			level++;
314	khahn	1.4	if(muTrk->NPixelHits() < 1) {
315	khahn	1.1	failmask \|= (1<<level);
316			}
317
318
319			level++;
320	khahn	1.4	if(fabs(muTrk->D0Corrected(vtx))>0.02) {
321	khahn	1.1	failmask \|= (1<<level);
322			}
323
324			/*
325			if(mu->pt>20) {
326			if(fabs(mu->d0)>0.02) {
327			failmask \|= (1<<level);
328			}
329			} else {
330			if(fabs(mu->d0)>0.01) {
331			failmask \|= (1<<level);
332			}
333			}
334			*/
335
336	khahn	1.4	if( !failmask ) status.orStatus(SelectionStatus::LOOSEID);
337			if( !failmask ) status.orStatus(SelectionStatus::TIGHTID);
338	khahn	1.1	return status;
339
340
341			};
342
343	anlevin	1.3
344	khahn	1.4	//--------------------------------------------------------------------------------------------------
345			SelectionStatus muonIDMVASelection(ControlFlags &ctrl,
346			const mithep::Muon *mu,
347			const mithep::Vertex & vtx )
348			//--------------------------------------------------------------------------------------------------
349			{
350			assert(mu->IsTrackerMuon()); // must be
351			assert(mu->HasTrackerTrk());
352			assert(mu->TrackerTrk());
353
354			/*
355			cerr << "TrackerTrk: " << mu->TrackerTrk() << endl;
356			flush(cerr);
357			cerr << "Rchi2: " << mu->TrackerTrk()->RChi2() << endl;
358			flush(cerr);
359
360			cerr << "calling MVa ... "<< endl;
361			flush(cerr);
362			*/
363
364			double global_rchi2 = (mu->IsGlobalMuon()) ? mu->GlobalTrk()->RChi2() : 0.;
365	anlevin	1.3
366	khahn	1.4	double mvaval = muIDMVA->MVAValue_ID(mu->Pt(),
367			mu->Eta(),
368			mu->IsGlobalMuon(),
369			mu->IsTrackerMuon(),
370			mu->TrackerTrk()->RChi2(),
371			global_rchi2,
372			(Double_t)(mu->NValidHits()),
373			(Double_t)(mu->TrackerTrk()->NHits()),
374			(Double_t)(mu->TrackerTrk()->NPixelHits()),
375			(Double_t)(mu->NMatches()),
376			mu->TrkKink(),
377			muTools.GetSegmentCompatability(mu),
378			muTools.GetCaloCompatability(mu,true,true),
379			mu->HadEnergy(),
380			mu->EmEnergy(),
381			mu->HadS9Energy(),
382			mu->EmS9Energy(),
383			(Bool_t)(ctrl.debug) );
384	anlevin	1.3
385
386	khahn	1.4	SelectionStatus status;
387			bool pass = false;
388
389			if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
390	khahn	1.7	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_IDMVA_CUT_BIN0) pass = true;
391	khahn	1.4	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
392	khahn	1.7	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_IDMVA_CUT_BIN1) pass = true;
393	khahn	1.4	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
394	khahn	1.7	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_IDMVA_CUT_BIN2) pass = true;
395	khahn	1.4	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
396			&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_IDMVA_CUT_BIN3) pass = true;
397			else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon()
398			&& (mu->Quality().QualityMask().Mask() & mithep::MuonQuality::AllArbitrated) && mvaval >= MUON_IDMVA_CUT_BIN4)
399			pass = true;
400
401
402			if( pass ) {
403			status.orStatus(SelectionStatus::LOOSEID);
404			status.orStatus(SelectionStatus::TIGHTID);
405	anlevin	1.3	}
406
407	khahn	1.4	return status;
408			}
409	anlevin	1.3
410	khahn	1.4	//--------------------------------------------------------------------------------------------------
411			void initMuonIDMVA()
412			//--------------------------------------------------------------------------------------------------
413			{
414			muIDMVA = new mithep::MuonIDMVA();
415			vector<string> weightFiles;
416	khahn	1.6	weightFiles.push_back("./data/MuonIDMVAWeights/MuonIDMVA_BDTG_barrel_lowpt_V2.weights.xml");
417			weightFiles.push_back("./data/MuonIDMVAWeights/MuonIDMVA_BDTG_barrel_highpt_V2.weights.xml");
418			weightFiles.push_back("./data/MuonIDMVAWeights/MuonIDMVA_BDTG_endcap_lowpt_V2.weights.xml");
419			weightFiles.push_back("./data/MuonIDMVAWeights/MuonIDMVA_BDTG_endcap_highpt_V2.weights.xml");
420			weightFiles.push_back("./data/MuonIDMVAWeights/MuonIDMVA_BDTG_tracker_V2.weights.xml");
421			weightFiles.push_back("./data/MuonIDMVAWeights/MuonIDMVA_BDTG_global_V2.weights.xml");
422	khahn	1.4	muIDMVA->Initialize( "MuonIDMVA",
423			mithep::MuonIDMVA::kIDV0,
424			kTRUE, weightFiles);
425			}
426	khahn	1.9
427			//--------------------------------------------------------------------------------------------------
428			SelectionStatus muonIDPFSelection(ControlFlags &ctrl,
429			const mithep::Muon *mu,
430			const mithep::Vertex & vtx,
431			const mithep::Array<mithep::PFCandidate> * pfCandidates )
432			//--------------------------------------------------------------------------------------------------
433			{
434			bool pass = false;
435			SelectionStatus status; // init'ed to FAIL
436
437			// check that muon is tracker
438			if( !(mu->IsTrackerMuon()) ) return status;
439
440			// check that it matches to a PF muon
441			for( int i=0; i<pfCandidates->GetEntries(); i++ ) {
442			const mithep::PFCandidate pf = (mithep::PFCandidate)((*pfCandidates)[i]);
443			if( pf->HasTrackerTrk() ) {
444			if( pf->TrackerTrk() == mu->TrackerTrk() && abs(pf->PFType()) == mithep::PFCandidate::eMuon ) {
445			pass = true;
446			break;
447			}
448			}
449			}
450
451			if( pass ) {
452			status.orStatus(SelectionStatus::LOOSEID);
453			status.orStatus(SelectionStatus::TIGHTID);
454			}
455
456			return status;
457			}