FakeMods/src/FakeRate.cc

// $Id: FakeRate.cc,v 1.5 2009/08/11 11:19:40 phedex Exp $

#include "MitPhysics/FakeMods/interface/FakeRate.h"
#include "MitCommon/DataFormats/interface/TH2DAsymErr.h"
#include <TMath.h>
#include <TFile.h>
#include <TMath.h>
#include <TH1.h>
#include <TH2.h>
#include <TH3.h>
#include <TF1.h>
#include <TF2.h>

using namespace mithep;
using namespace std;

ClassImp(mithep::FakeRate)

//--------------------------------------------------------------------------------------------------
Bool_t FakeRate::Init()
{
  // Load all fake rate histogram files.

  // get the root file which is storing the fake rates
  TFile *ElectronFRFile = new TFile(fElectronFRFilename);  
  if (!ElectronFRFile) {
    cerr << "The Electron FakeRate file : " << fElectronFRFilename << " could not be opened!\n";
    return kFALSE;
  }
  TFile *MuonFRFile = new TFile(fMuonFRFilename);  
  if (!MuonFRFile) {
    cerr << "The Muon FakeRate file : " << fMuonFRFilename << " could not be opened!\n";
    return kFALSE;
  }
  
  // load histogram/fit functions from the file
  if (fUse2DFakeRate) {

    fElectronFakeRateHist_PtEta = (TH2DAsymErr*)(ElectronFRFile->Get(fElectronFRHistName));
    fMuonFakeRateHist_PtEta = (TH2DAsymErr*)(MuonFRFile->Get(fMuonFRHistName));

    if (!fElectronFakeRateHist_PtEta) {
      cout << "Error: Histogram " << fElectronFRHistName << " cannot be loaded from file "
           << fElectronFRFilename << endl;
    }
    if (!fMuonFakeRateHist_PtEta) {
      cout << "Error: Histogram " << fMuonFRHistName << " cannot be loaded. from file"
           << fMuonFRFilename << endl;
    }

    fElectronFakeRateHist_PtEta->SetDirectory(0);
    fMuonFakeRateHist_PtEta->SetDirectory(0);

    if (fUseFitFunction) {
      //Currently unsupported
      cerr << "Error: Using 2D Fake Rates with Fit Function is not currently supported.\n";
      return kFALSE;

      //Once supported, below code will load the functions.
      TF2 *ElectronFakeRateFit_PtEta_temp = (TF2*)(ElectronFRFile->Get(fElectronFRFunctionName));
      TF2 *MuonFakeRateFit_PtEta_temp = (TF2*)(MuonFRFile->Get(fMuonFRFunctionName));
      if (!ElectronFakeRateFit_PtEta_temp) {
        cout << "Error: Function " << fElectronFRFunctionName << " cannot be loaded from file "
             << fElectronFRFilename << endl;
      }
      if (!MuonFakeRateFit_PtEta_temp) {
      cout << "Error: Function " << fMuonFRFunctionName << " cannot be loaded. from file"
           << fMuonFRFilename << endl;
      }
      fElectronFakeRateFit_PtEta = (TF2*)(ElectronFakeRateFit_PtEta_temp->Clone());
      fMuonFakeRateFit_PtEta = (TF2*)(MuonFakeRateFit_PtEta_temp->Clone());
    }

  } else {

    fElectronFakeRateHist_Pt = (TH1F*)(ElectronFRFile->Get(fElectronFRHistName)); 
    fMuonFakeRateHist_Pt = (TH1F*)(MuonFRFile->Get(fMuonFRHistName)); 
    if (!fElectronFakeRateHist_Pt) {
      cout << "Error: Histogram " << fElectronFRHistName << " cannot be loaded from file "
           << fElectronFRFilename << endl;
    }
    if (!fMuonFakeRateHist_Pt) {
      cout << "Error: Histogram " << fMuonFRHistName << " cannot be loaded. from file"
           << fMuonFRFilename << endl;
    }
    fElectronFakeRateHist_Pt->SetDirectory(0);
    fMuonFakeRateHist_Pt->SetDirectory(0);

    if (fUseFitFunction) {
      TF1 *ElectronFakeRateFit_Pt_temp = (TF1*)(ElectronFRFile->Get(fElectronFRFunctionName));
      TF1 *MuonFakeRateFit_Pt_temp = (TF1*)(MuonFRFile->Get(fMuonFRFunctionName));
      if (!ElectronFakeRateFit_Pt_temp) {
        cout << "Error: Function " << fElectronFRFunctionName << " cannot be loaded from file "
             << fElectronFRFilename << endl;
      }
      if (!MuonFakeRateFit_Pt_temp) {
      cout << "Error: Function " << fMuonFRFunctionName << " cannot be loaded. from file"
           << fMuonFRFilename << endl;
      }
      fElectronFakeRateFit_Pt = (TF1*)(ElectronFakeRateFit_Pt_temp->Clone());
      fMuonFakeRateFit_Pt = (TF1*)(MuonFakeRateFit_Pt_temp->Clone());
    }
  }

  ElectronFRFile->Close();
  MuonFRFile->Close();
  delete ElectronFRFile;
  delete MuonFRFile;

  return true;
}


//--------------------------------------------------------------------------------------------------
Double_t FakeRate::ElectronFakeRate(Double_t pt, Double_t eta, Double_t phi)
{
  // Calculate the electron fake rate given pt, eta, and phi.

  Double_t prob = 0.0;

  if (fIsInit) {
    if (fUse2DFakeRate) {
      if (fUseFitFunction) {
        cerr << "Error: Using 2D Fake Rates with Fit Function is not currently supported.\n";      
      } else {
        if (fElectronFakeRateHist_PtEta) {
          Int_t ptbin = fElectronFakeRateHist_PtEta->GetXaxis()->FindFixBin(pt);
          Int_t etabin = fElectronFakeRateHist_PtEta->GetYaxis()->FindFixBin(eta);    
          prob = fElectronFakeRateHist_PtEta->GetBinContent(ptbin,etabin);
        } else {
          Fatal("ElectronFakeRate","Error: fElectronFakeRateHist_PtEta was not loaded properly.");
        }
      }
    } else {
      if (fUseFitFunction) {
        if (fElectronFakeRateFit_Pt) {
          prob = fElectronFakeRateFit_Pt->Eval(pt);
        } else {
          Fatal("ElectronFakeRate","Error: fElectronFakeRateFit_Pt was not loaded properly.");
        }
      } else {
        if (fElectronFakeRateHist_Pt) {
          Int_t ptbin = fElectronFakeRateHist_Pt->GetXaxis()->FindFixBin(pt);
          prob = fElectronFakeRateHist_Pt->GetBinContent(ptbin);
        } else {
          Fatal("ElectronFakeRate","Error: fElectronFakeRateHist_Pt was not loaded properly.");
        }
      }
    }
  } else {
    Fatal("ElectronFakeRate","Error: FakeRate was not properly initialized.");
  }
  if (prob > 1) {
    cerr << "Fake Rate = " << prob << " is larger than 1.0" << endl;
  }
  return prob;
}

//--------------------------------------------------------------------------------------------------
Double_t FakeRate::ElectronFakeRateError(Double_t pt, Double_t eta, Double_t phi, 
                                         TH2DAsymErr::EErrType errorType)
{
  // Calculate the electron fake rate error given pt, eta, and phi

  Double_t error = 0.0;

  if (fIsInit) {
    if (fUse2DFakeRate) {
      if (fUseFitFunction) {
      } else {
        if (fElectronFakeRateHist_PtEta) { 
          return fElectronFakeRateHist_PtEta->GetError(pt, eta, errorType);        
        } else {
          Fatal("ElectronFakeRate","Error: fElectronFakeRateHist_PtEta_sysError was not loaded properly.");
        }
      }
    } 
  } else {
    Fatal("ElectronFakeRate","Error: FakeRate was not properly initialized.");
  }
  return error;
}

//--------------------------------------------------------------------------------------------------
Double_t FakeRate::ElectronFakeRateStatErrorLow(Double_t pt, Double_t eta, Double_t phi)
{
  // Calculate the electron fake rate lower statistical error given pt, eta, and phi
  return ElectronFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kStatErrLow);
}

//--------------------------------------------------------------------------------------------------
Double_t FakeRate::ElectronFakeRateStatErrorHigh(Double_t pt, Double_t eta, Double_t phi)
{
  // Calculate the electron fake rate upper statistical error given pt, eta, and phi
  return ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh);
}

//--------------------------------------------------------------------------------------------------
Double_t FakeRate::ElectronFakeRateSysErrorLow(Double_t pt, Double_t eta, Double_t phi)
{
  // Calculate the electron fake rate  lower systematic error given pt, eta, and phi
  return ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrLow);
}

//--------------------------------------------------------------------------------------------------
Double_t FakeRate::ElectronFakeRateSysErrorHigh(Double_t pt, Double_t eta, Double_t phi)
{
  // Calculate the electron fake rate upper systematic error given pt, eta, and phi
  return ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh);
}

//--------------------------------------------------------------------------------------------------
Double_t FakeRate::ElectronFakeRateErrorLow(Double_t pt, Double_t eta, Double_t phi)
{
  // Calculate the electron fake rate total lower error given pt, eta, and phi
  return TMath::Sqrt( ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrLow)*
                      ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrLow) +
                      ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrLow)*
                      ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrLow)
    );
}

//--------------------------------------------------------------------------------------------------
Double_t FakeRate::ElectronFakeRateErrorHigh(Double_t pt, Double_t eta, Double_t phi)
{
  // Calculate the electron fake rate total upper error given pt, eta, and phi
  return TMath::Sqrt( ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh)*
                      ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh) +
                      ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh)*
                      ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh)
    );
}

//--------------------------------------------------------------------------------------------------
Double_t FakeRate::MuonFakeRate(Double_t pt, Double_t eta, Double_t phi)
{
  // Calculate the muon fake rate given pt, eta, and phi
  Double_t prob = 0.0;

  if (fIsInit) {
    if (fUse2DFakeRate) {
      if (fUseFitFunction) {
        cerr << "Error: Using 2D Fake Rates with Fit Function is not currently supported.\n";      
      } else {
        if (fMuonFakeRateHist_PtEta) {
          Int_t ptbin = fMuonFakeRateHist_PtEta->GetXaxis()->FindFixBin(pt);
          Int_t etabin = fMuonFakeRateHist_PtEta->GetYaxis()->FindFixBin(eta);    
          prob = fMuonFakeRateHist_PtEta->GetBinContent(ptbin,etabin);
        } else {
          Fatal("ElectronFakeRate","Error: fMuonFakeRateHist_PtEta was not loaded properly.");
        }
      }
    } else {
      if (fUseFitFunction) {
        if (fMuonFakeRateFit_Pt) {
          prob = fMuonFakeRateFit_Pt->Eval(pt);
        } else {
          Fatal("ElectronFakeRate","Error: fMuonFakeRateFit_Pt was not loaded properly.");
        }
      } else {
        if (fMuonFakeRateHist_Pt) {
          Int_t ptbin = fMuonFakeRateHist_Pt->GetXaxis()->FindFixBin(pt);
          prob = fMuonFakeRateHist_Pt->GetBinContent(ptbin);
        } else {
          Fatal("ElectronFakeRate","Error: fMuonFakeRateHist_Pt was not loaded properly.");
        }
      }
    }
  } else {
    Fatal("ElectronFakeRate","Error: FakeRate was not properly initialized.");
  }
  if (prob > 1) {
    cerr << "Fake Rate is larger than 1.0" << endl;
  }
  return prob;
}

//--------------------------------------------------------------------------------------------------
Double_t FakeRate::MuonFakeRateError(Double_t pt, Double_t eta, Double_t phi, 
                                     TH2DAsymErr::EErrType errorType)
{
  // Calculate the muon fake rate error given pt, eta, and phi.

  Double_t error = 0.0;

  if (fIsInit) {
    if (fUse2DFakeRate) {
      if (fUseFitFunction) {
        cerr << "Error: Using 2D Fake Rates with Fit Function is not currently supported.\n";      
      } else {
        if (fMuonFakeRateHist_PtEta) {
          return fMuonFakeRateHist_PtEta->GetError(pt, eta, errorType);                 
        } else {
          Fatal("ElectronFakeRate","Error: fMuonFakeRateHist_PtEta_sysError was not loaded properly.");
        }
      }
    } 
  } else {
    Fatal("ElectronFakeRate","Error: FakeRate was not properly initialized.");
  }
  return error;
}

//--------------------------------------------------------------------------------------------------
Double_t FakeRate::MuonFakeRateStatErrorLow(Double_t pt, Double_t eta, Double_t phi)
{
  // Calculate the muon fake rate lower statistical error given pt, eta, and phi.

  return MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrLow);
}

//--------------------------------------------------------------------------------------------------
Double_t FakeRate::MuonFakeRateStatErrorHigh(Double_t pt, Double_t eta, Double_t phi)
{
  // Calculate the muon fake rate upper statistical error given pt, eta, and phi.

  return MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh);
}

//--------------------------------------------------------------------------------------------------
Double_t FakeRate::MuonFakeRateSysErrorLow(Double_t pt, Double_t eta, Double_t phi)
{
  // Calculate the muon fake rate lower systematic error given pt, eta, and phi.

  return MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrLow);
}

//--------------------------------------------------------------------------------------------------
Double_t FakeRate::MuonFakeRateSysErrorHigh(Double_t pt, Double_t eta, Double_t phi)
{
  // Calculate the muon fake rate upper systematic error given pt, eta, and phi.

  return MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh);
}

//--------------------------------------------------------------------------------------------------
Double_t FakeRate::MuonFakeRateErrorLow(Double_t pt, Double_t eta, Double_t phi)
{
  // Calculate the muon fake rate total lower error given pt, eta, and phi.

  return TMath::Sqrt( MuonFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kSysErrLow)*
                      MuonFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kSysErrLow) +
                      MuonFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kStatErrLow)*
                      MuonFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kStatErrLow)
    );
}

//--------------------------------------------------------------------------------------------------
Double_t FakeRate::MuonFakeRateErrorHigh(Double_t pt, Double_t eta, Double_t phi)
{
  // Calculate the muon fake rate total upper error given pt, eta, and phi.

  return TMath::Sqrt( MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh)*
                      MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh) +
                      MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh)*
                      MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh)
    );
}
Revision:	1.6
Committed:	Tue Nov 3 08:40:37 2009 UTC (15 years, 6 months ago) by ceballos
Content type:	text/plain
Branch:	MAIN
Changes since 1.5:	+8 -3 lines
Log Message:	a few fixes
#	User	Rev	Content
1	ceballos	1.6	// $Id: FakeRate.cc,v 1.5 2009/08/11 11:19:40 phedex Exp $
2	loizides	1.1
3			#include "MitPhysics/FakeMods/interface/FakeRate.h"
4	phedex	1.3	#include "MitCommon/DataFormats/interface/TH2DAsymErr.h"
5	loizides	1.2	#include <TMath.h>
6	loizides	1.1	#include <TFile.h>
7	phedex	1.3	#include <TMath.h>
8	loizides	1.1	#include <TH1.h>
9			#include <TH2.h>
10			#include <TH3.h>
11			#include <TF1.h>
12			#include <TF2.h>
13
14			using namespace mithep;
15			using namespace std;
16
17			ClassImp(mithep::FakeRate)
18
19			//--------------------------------------------------------------------------------------------------
20			Bool_t FakeRate::Init()
21			{
22	loizides	1.4	// Load all fake rate histogram files.
23	loizides	1.1
24	loizides	1.4	// get the root file which is storing the fake rates
25	loizides	1.1	TFile *ElectronFRFile = new TFile(fElectronFRFilename);
26			if (!ElectronFRFile) {
27			cerr << "The Electron FakeRate file : " << fElectronFRFilename << " could not be opened!\n";
28	loizides	1.4	return kFALSE;
29	loizides	1.1	}
30			TFile *MuonFRFile = new TFile(fMuonFRFilename);
31			if (!MuonFRFile) {
32			cerr << "The Muon FakeRate file : " << fMuonFRFilename << " could not be opened!\n";
33	loizides	1.4	return kFALSE;
34	loizides	1.1	}
35
36	loizides	1.4	// load histogram/fit functions from the file
37	loizides	1.1	if (fUse2DFakeRate) {
38
39	phedex	1.3	fElectronFakeRateHist_PtEta = (TH2DAsymErr*)(ElectronFRFile->Get(fElectronFRHistName));
40			fMuonFakeRateHist_PtEta = (TH2DAsymErr*)(MuonFRFile->Get(fMuonFRHistName));
41
42	loizides	1.1	if (!fElectronFakeRateHist_PtEta) {
43			cout << "Error: Histogram " << fElectronFRHistName << " cannot be loaded from file "
44			<< fElectronFRFilename << endl;
45			}
46			if (!fMuonFakeRateHist_PtEta) {
47			cout << "Error: Histogram " << fMuonFRHistName << " cannot be loaded. from file"
48			<< fMuonFRFilename << endl;
49			}
50
51			fElectronFakeRateHist_PtEta->SetDirectory(0);
52			fMuonFakeRateHist_PtEta->SetDirectory(0);
53
54			if (fUseFitFunction) {
55			//Currently unsupported
56			cerr << "Error: Using 2D Fake Rates with Fit Function is not currently supported.\n";
57	loizides	1.4	return kFALSE;
58	loizides	1.1
59			//Once supported, below code will load the functions.
60			TF2 ElectronFakeRateFit_PtEta_temp = (TF2)(ElectronFRFile->Get(fElectronFRFunctionName));
61			TF2 MuonFakeRateFit_PtEta_temp = (TF2)(MuonFRFile->Get(fMuonFRFunctionName));
62			if (!ElectronFakeRateFit_PtEta_temp) {
63			cout << "Error: Function " << fElectronFRFunctionName << " cannot be loaded from file "
64			<< fElectronFRFilename << endl;
65			}
66			if (!MuonFakeRateFit_PtEta_temp) {
67			cout << "Error: Function " << fMuonFRFunctionName << " cannot be loaded. from file"
68			<< fMuonFRFilename << endl;
69			}
70			fElectronFakeRateFit_PtEta = (TF2*)(ElectronFakeRateFit_PtEta_temp->Clone());
71			fMuonFakeRateFit_PtEta = (TF2*)(MuonFakeRateFit_PtEta_temp->Clone());
72			}
73	loizides	1.4
74	loizides	1.1	} else {
75
76			fElectronFakeRateHist_Pt = (TH1F*)(ElectronFRFile->Get(fElectronFRHistName));
77			fMuonFakeRateHist_Pt = (TH1F*)(MuonFRFile->Get(fMuonFRHistName));
78			if (!fElectronFakeRateHist_Pt) {
79			cout << "Error: Histogram " << fElectronFRHistName << " cannot be loaded from file "
80			<< fElectronFRFilename << endl;
81			}
82			if (!fMuonFakeRateHist_Pt) {
83			cout << "Error: Histogram " << fMuonFRHistName << " cannot be loaded. from file"
84			<< fMuonFRFilename << endl;
85			}
86			fElectronFakeRateHist_Pt->SetDirectory(0);
87			fMuonFakeRateHist_Pt->SetDirectory(0);
88
89			if (fUseFitFunction) {
90			TF1 ElectronFakeRateFit_Pt_temp = (TF1)(ElectronFRFile->Get(fElectronFRFunctionName));
91			TF1 MuonFakeRateFit_Pt_temp = (TF1)(MuonFRFile->Get(fMuonFRFunctionName));
92			if (!ElectronFakeRateFit_Pt_temp) {
93			cout << "Error: Function " << fElectronFRFunctionName << " cannot be loaded from file "
94			<< fElectronFRFilename << endl;
95			}
96			if (!MuonFakeRateFit_Pt_temp) {
97			cout << "Error: Function " << fMuonFRFunctionName << " cannot be loaded. from file"
98			<< fMuonFRFilename << endl;
99			}
100			fElectronFakeRateFit_Pt = (TF1*)(ElectronFakeRateFit_Pt_temp->Clone());
101			fMuonFakeRateFit_Pt = (TF1*)(MuonFakeRateFit_Pt_temp->Clone());
102			}
103			}
104
105			ElectronFRFile->Close();
106			MuonFRFile->Close();
107			delete ElectronFRFile;
108			delete MuonFRFile;
109
110			return true;
111			}
112
113
114			//--------------------------------------------------------------------------------------------------
115			Double_t FakeRate::ElectronFakeRate(Double_t pt, Double_t eta, Double_t phi)
116			{
117	loizides	1.4	// Calculate the electron fake rate given pt, eta, and phi.
118	phedex	1.3
119	loizides	1.1	Double_t prob = 0.0;
120
121			if (fIsInit) {
122			if (fUse2DFakeRate) {
123			if (fUseFitFunction) {
124			cerr << "Error: Using 2D Fake Rates with Fit Function is not currently supported.\n";
125			} else {
126			if (fElectronFakeRateHist_PtEta) {
127			Int_t ptbin = fElectronFakeRateHist_PtEta->GetXaxis()->FindFixBin(pt);
128			Int_t etabin = fElectronFakeRateHist_PtEta->GetYaxis()->FindFixBin(eta);
129			prob = fElectronFakeRateHist_PtEta->GetBinContent(ptbin,etabin);
130			} else {
131	phedex	1.5	Fatal("ElectronFakeRate","Error: fElectronFakeRateHist_PtEta was not loaded properly.");
132	loizides	1.1	}
133			}
134			} else {
135			if (fUseFitFunction) {
136			if (fElectronFakeRateFit_Pt) {
137			prob = fElectronFakeRateFit_Pt->Eval(pt);
138			} else {
139	phedex	1.5	Fatal("ElectronFakeRate","Error: fElectronFakeRateFit_Pt was not loaded properly.");
140	loizides	1.1	}
141			} else {
142			if (fElectronFakeRateHist_Pt) {
143			Int_t ptbin = fElectronFakeRateHist_Pt->GetXaxis()->FindFixBin(pt);
144			prob = fElectronFakeRateHist_Pt->GetBinContent(ptbin);
145			} else {
146	phedex	1.5	Fatal("ElectronFakeRate","Error: fElectronFakeRateHist_Pt was not loaded properly.");
147	loizides	1.1	}
148			}
149			}
150			} else {
151	phedex	1.5	Fatal("ElectronFakeRate","Error: FakeRate was not properly initialized.");
152	loizides	1.1	}
153	ceballos	1.6	if (prob > 1) {
154			cerr << "Fake Rate = " << prob << " is larger than 1.0" << endl;
155			}
156	loizides	1.1	return prob;
157			}
158
159			//--------------------------------------------------------------------------------------------------
160	phedex	1.3	Double_t FakeRate::ElectronFakeRateError(Double_t pt, Double_t eta, Double_t phi,
161	loizides	1.4	TH2DAsymErr::EErrType errorType)
162	loizides	1.1	{
163	phedex	1.3	// Calculate the electron fake rate error given pt, eta, and phi
164
165	loizides	1.1	Double_t error = 0.0;
166
167			if (fIsInit) {
168			if (fUse2DFakeRate) {
169			if (fUseFitFunction) {
170			} else {
171	ceballos	1.6	if (fElectronFakeRateHist_PtEta) {
172	phedex	1.5	return fElectronFakeRateHist_PtEta->GetError(pt, eta, errorType);
173	loizides	1.1	} else {
174	phedex	1.5	Fatal("ElectronFakeRate","Error: fElectronFakeRateHist_PtEta_sysError was not loaded properly.");
175	loizides	1.1	}
176			}
177			}
178			} else {
179	phedex	1.5	Fatal("ElectronFakeRate","Error: FakeRate was not properly initialized.");
180	loizides	1.1	}
181			return error;
182			}
183
184	phedex	1.3	//--------------------------------------------------------------------------------------------------
185			Double_t FakeRate::ElectronFakeRateStatErrorLow(Double_t pt, Double_t eta, Double_t phi)
186			{
187			// Calculate the electron fake rate lower statistical error given pt, eta, and phi
188	loizides	1.4	return ElectronFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kStatErrLow);
189	phedex	1.3	}
190
191			//--------------------------------------------------------------------------------------------------
192			Double_t FakeRate::ElectronFakeRateStatErrorHigh(Double_t pt, Double_t eta, Double_t phi)
193			{
194			// Calculate the electron fake rate upper statistical error given pt, eta, and phi
195	loizides	1.4	return ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh);
196	phedex	1.3	}
197
198			//--------------------------------------------------------------------------------------------------
199			Double_t FakeRate::ElectronFakeRateSysErrorLow(Double_t pt, Double_t eta, Double_t phi)
200			{
201			// Calculate the electron fake rate lower systematic error given pt, eta, and phi
202	loizides	1.4	return ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrLow);
203	phedex	1.3	}
204
205			//--------------------------------------------------------------------------------------------------
206			Double_t FakeRate::ElectronFakeRateSysErrorHigh(Double_t pt, Double_t eta, Double_t phi)
207			{
208			// Calculate the electron fake rate upper systematic error given pt, eta, and phi
209	loizides	1.4	return ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh);
210	phedex	1.3	}
211
212			//--------------------------------------------------------------------------------------------------
213			Double_t FakeRate::ElectronFakeRateErrorLow(Double_t pt, Double_t eta, Double_t phi)
214			{
215			// Calculate the electron fake rate total lower error given pt, eta, and phi
216	loizides	1.4	return TMath::Sqrt( ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrLow)*
217			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrLow) +
218			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrLow)*
219			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrLow)
220	phedex	1.3	);
221			}
222
223			//--------------------------------------------------------------------------------------------------
224			Double_t FakeRate::ElectronFakeRateErrorHigh(Double_t pt, Double_t eta, Double_t phi)
225			{
226			// Calculate the electron fake rate total upper error given pt, eta, and phi
227	loizides	1.4	return TMath::Sqrt( ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh)*
228			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh) +
229			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh)*
230			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh)
231	phedex	1.3	);
232			}
233
234	loizides	1.1	//--------------------------------------------------------------------------------------------------
235			Double_t FakeRate::MuonFakeRate(Double_t pt, Double_t eta, Double_t phi)
236			{
237			// Calculate the muon fake rate given pt, eta, and phi
238			Double_t prob = 0.0;
239
240			if (fIsInit) {
241			if (fUse2DFakeRate) {
242			if (fUseFitFunction) {
243			cerr << "Error: Using 2D Fake Rates with Fit Function is not currently supported.\n";
244			} else {
245			if (fMuonFakeRateHist_PtEta) {
246			Int_t ptbin = fMuonFakeRateHist_PtEta->GetXaxis()->FindFixBin(pt);
247			Int_t etabin = fMuonFakeRateHist_PtEta->GetYaxis()->FindFixBin(eta);
248			prob = fMuonFakeRateHist_PtEta->GetBinContent(ptbin,etabin);
249			} else {
250	phedex	1.5	Fatal("ElectronFakeRate","Error: fMuonFakeRateHist_PtEta was not loaded properly.");
251	loizides	1.1	}
252			}
253			} else {
254			if (fUseFitFunction) {
255			if (fMuonFakeRateFit_Pt) {
256			prob = fMuonFakeRateFit_Pt->Eval(pt);
257			} else {
258	phedex	1.5	Fatal("ElectronFakeRate","Error: fMuonFakeRateFit_Pt was not loaded properly.");
259	loizides	1.1	}
260			} else {
261			if (fMuonFakeRateHist_Pt) {
262			Int_t ptbin = fMuonFakeRateHist_Pt->GetXaxis()->FindFixBin(pt);
263			prob = fMuonFakeRateHist_Pt->GetBinContent(ptbin);
264			} else {
265	phedex	1.5	Fatal("ElectronFakeRate","Error: fMuonFakeRateHist_Pt was not loaded properly.");
266	loizides	1.1	}
267			}
268			}
269			} else {
270	phedex	1.5	Fatal("ElectronFakeRate","Error: FakeRate was not properly initialized.");
271	loizides	1.1	}
272	ceballos	1.6	if (prob > 1) {
273			cerr << "Fake Rate is larger than 1.0" << endl;
274			}
275	loizides	1.1	return prob;
276			}
277
278			//--------------------------------------------------------------------------------------------------
279	phedex	1.3	Double_t FakeRate::MuonFakeRateError(Double_t pt, Double_t eta, Double_t phi,
280	loizides	1.4	TH2DAsymErr::EErrType errorType)
281	loizides	1.1	{
282	loizides	1.4	// Calculate the muon fake rate error given pt, eta, and phi.
283
284	loizides	1.1	Double_t error = 0.0;
285
286			if (fIsInit) {
287			if (fUse2DFakeRate) {
288			if (fUseFitFunction) {
289			cerr << "Error: Using 2D Fake Rates with Fit Function is not currently supported.\n";
290			} else {
291	phedex	1.3	if (fMuonFakeRateHist_PtEta) {
292	phedex	1.5	return fMuonFakeRateHist_PtEta->GetError(pt, eta, errorType);
293	loizides	1.1	} else {
294	phedex	1.5	Fatal("ElectronFakeRate","Error: fMuonFakeRateHist_PtEta_sysError was not loaded properly.");
295	loizides	1.1	}
296			}
297			}
298			} else {
299	phedex	1.5	Fatal("ElectronFakeRate","Error: FakeRate was not properly initialized.");
300	loizides	1.1	}
301			return error;
302			}
303	phedex	1.3
304			//--------------------------------------------------------------------------------------------------
305			Double_t FakeRate::MuonFakeRateStatErrorLow(Double_t pt, Double_t eta, Double_t phi)
306			{
307	loizides	1.4	// Calculate the muon fake rate lower statistical error given pt, eta, and phi.
308
309			return MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrLow);
310	phedex	1.3	}
311
312			//--------------------------------------------------------------------------------------------------
313			Double_t FakeRate::MuonFakeRateStatErrorHigh(Double_t pt, Double_t eta, Double_t phi)
314			{
315	loizides	1.4	// Calculate the muon fake rate upper statistical error given pt, eta, and phi.
316
317			return MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh);
318	phedex	1.3	}
319
320			//--------------------------------------------------------------------------------------------------
321			Double_t FakeRate::MuonFakeRateSysErrorLow(Double_t pt, Double_t eta, Double_t phi)
322			{
323	loizides	1.4	// Calculate the muon fake rate lower systematic error given pt, eta, and phi.
324
325			return MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrLow);
326	phedex	1.3	}
327
328			//--------------------------------------------------------------------------------------------------
329			Double_t FakeRate::MuonFakeRateSysErrorHigh(Double_t pt, Double_t eta, Double_t phi)
330			{
331	loizides	1.4	// Calculate the muon fake rate upper systematic error given pt, eta, and phi.
332
333			return MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh);
334	phedex	1.3	}
335
336			//--------------------------------------------------------------------------------------------------
337			Double_t FakeRate::MuonFakeRateErrorLow(Double_t pt, Double_t eta, Double_t phi)
338			{
339	loizides	1.4	// Calculate the muon fake rate total lower error given pt, eta, and phi.
340
341			return TMath::Sqrt( MuonFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kSysErrLow)*
342			MuonFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kSysErrLow) +
343			MuonFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kStatErrLow)*
344			MuonFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kStatErrLow)
345	phedex	1.3	);
346			}
347
348			//--------------------------------------------------------------------------------------------------
349			Double_t FakeRate::MuonFakeRateErrorHigh(Double_t pt, Double_t eta, Double_t phi)
350			{
351	loizides	1.4	// Calculate the muon fake rate total upper error given pt, eta, and phi.
352
353			return TMath::Sqrt( MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh)*
354			MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh) +
355			MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh)*
356			MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh)
357	phedex	1.3	);
358			}