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