FakeMods/src/FakeRate.cc

// $Id: FakeRate.cc,v 1.4 2009/08/11 09:16:01 loizides 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.");
  }
  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) {
        cerr << "Error: Using 2D Fake Rates with Fit Function is not currently supported.\n";      
      } 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.");
  }
  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.5
Committed:	Tue Aug 11 11:19:40 2009 UTC (15 years, 8 months ago) by phedex
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_011a, Mit_011, Mit_010a
Changes since 1.4:	+16 -52 lines
Log Message:	style corrections
#	User	Rev	Content
1	phedex	1.5	// $Id: FakeRate.cc,v 1.4 2009/08/11 09:16:01 loizides 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			return prob;
154			}
155
156			//--------------------------------------------------------------------------------------------------
157	phedex	1.3	Double_t FakeRate::ElectronFakeRateError(Double_t pt, Double_t eta, Double_t phi,
158	loizides	1.4	TH2DAsymErr::EErrType errorType)
159	loizides	1.1	{
160	phedex	1.3	// Calculate the electron fake rate error given pt, eta, and phi
161
162	loizides	1.1	Double_t error = 0.0;
163
164			if (fIsInit) {
165			if (fUse2DFakeRate) {
166			if (fUseFitFunction) {
167			cerr << "Error: Using 2D Fake Rates with Fit Function is not currently supported.\n";
168			} else {
169	phedex	1.5	if (fElectronFakeRateHist_PtEta) {
170			return fElectronFakeRateHist_PtEta->GetError(pt, eta, errorType);
171	loizides	1.1	} else {
172	phedex	1.5	Fatal("ElectronFakeRate","Error: fElectronFakeRateHist_PtEta_sysError was not loaded properly.");
173	loizides	1.1	}
174			}
175			}
176			} else {
177	phedex	1.5	Fatal("ElectronFakeRate","Error: FakeRate was not properly initialized.");
178	loizides	1.1	}
179			return error;
180			}
181
182	phedex	1.3	//--------------------------------------------------------------------------------------------------
183			Double_t FakeRate::ElectronFakeRateStatErrorLow(Double_t pt, Double_t eta, Double_t phi)
184			{
185			// Calculate the electron fake rate lower statistical error given pt, eta, and phi
186	loizides	1.4	return ElectronFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kStatErrLow);
187	phedex	1.3	}
188
189			//--------------------------------------------------------------------------------------------------
190			Double_t FakeRate::ElectronFakeRateStatErrorHigh(Double_t pt, Double_t eta, Double_t phi)
191			{
192			// Calculate the electron fake rate upper statistical error given pt, eta, and phi
193	loizides	1.4	return ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh);
194	phedex	1.3	}
195
196			//--------------------------------------------------------------------------------------------------
197			Double_t FakeRate::ElectronFakeRateSysErrorLow(Double_t pt, Double_t eta, Double_t phi)
198			{
199			// Calculate the electron fake rate lower systematic error given pt, eta, and phi
200	loizides	1.4	return ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrLow);
201	phedex	1.3	}
202
203			//--------------------------------------------------------------------------------------------------
204			Double_t FakeRate::ElectronFakeRateSysErrorHigh(Double_t pt, Double_t eta, Double_t phi)
205			{
206			// Calculate the electron fake rate upper systematic error given pt, eta, and phi
207	loizides	1.4	return ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh);
208	phedex	1.3	}
209
210			//--------------------------------------------------------------------------------------------------
211			Double_t FakeRate::ElectronFakeRateErrorLow(Double_t pt, Double_t eta, Double_t phi)
212			{
213			// Calculate the electron fake rate total lower error given pt, eta, and phi
214	loizides	1.4	return TMath::Sqrt( ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrLow)*
215			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrLow) +
216			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrLow)*
217			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrLow)
218	phedex	1.3	);
219			}
220
221			//--------------------------------------------------------------------------------------------------
222			Double_t FakeRate::ElectronFakeRateErrorHigh(Double_t pt, Double_t eta, Double_t phi)
223			{
224			// Calculate the electron fake rate total upper error given pt, eta, and phi
225	loizides	1.4	return TMath::Sqrt( ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh)*
226			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh) +
227			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh)*
228			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh)
229	phedex	1.3	);
230			}
231
232	loizides	1.1	//--------------------------------------------------------------------------------------------------
233			Double_t FakeRate::MuonFakeRate(Double_t pt, Double_t eta, Double_t phi)
234			{
235			// Calculate the muon fake rate given pt, eta, and phi
236			Double_t prob = 0.0;
237
238			if (fIsInit) {
239			if (fUse2DFakeRate) {
240			if (fUseFitFunction) {
241			cerr << "Error: Using 2D Fake Rates with Fit Function is not currently supported.\n";
242			} else {
243			if (fMuonFakeRateHist_PtEta) {
244			Int_t ptbin = fMuonFakeRateHist_PtEta->GetXaxis()->FindFixBin(pt);
245			Int_t etabin = fMuonFakeRateHist_PtEta->GetYaxis()->FindFixBin(eta);
246			prob = fMuonFakeRateHist_PtEta->GetBinContent(ptbin,etabin);
247			} else {
248	phedex	1.5	Fatal("ElectronFakeRate","Error: fMuonFakeRateHist_PtEta was not loaded properly.");
249	loizides	1.1	}
250			}
251			} else {
252			if (fUseFitFunction) {
253			if (fMuonFakeRateFit_Pt) {
254			prob = fMuonFakeRateFit_Pt->Eval(pt);
255			} else {
256	phedex	1.5	Fatal("ElectronFakeRate","Error: fMuonFakeRateFit_Pt was not loaded properly.");
257	loizides	1.1	}
258			} else {
259			if (fMuonFakeRateHist_Pt) {
260			Int_t ptbin = fMuonFakeRateHist_Pt->GetXaxis()->FindFixBin(pt);
261			prob = fMuonFakeRateHist_Pt->GetBinContent(ptbin);
262			} else {
263	phedex	1.5	Fatal("ElectronFakeRate","Error: fMuonFakeRateHist_Pt was not loaded properly.");
264	loizides	1.1	}
265			}
266			}
267			} else {
268	phedex	1.5	Fatal("ElectronFakeRate","Error: FakeRate was not properly initialized.");
269	loizides	1.1	}
270			return prob;
271			}
272
273			//--------------------------------------------------------------------------------------------------
274	phedex	1.3	Double_t FakeRate::MuonFakeRateError(Double_t pt, Double_t eta, Double_t phi,
275	loizides	1.4	TH2DAsymErr::EErrType errorType)
276	loizides	1.1	{
277	loizides	1.4	// Calculate the muon fake rate error given pt, eta, and phi.
278
279	loizides	1.1	Double_t error = 0.0;
280
281			if (fIsInit) {
282			if (fUse2DFakeRate) {
283			if (fUseFitFunction) {
284			cerr << "Error: Using 2D Fake Rates with Fit Function is not currently supported.\n";
285			} else {
286	phedex	1.3	if (fMuonFakeRateHist_PtEta) {
287	phedex	1.5	return fMuonFakeRateHist_PtEta->GetError(pt, eta, errorType);
288	loizides	1.1	} else {
289	phedex	1.5	Fatal("ElectronFakeRate","Error: fMuonFakeRateHist_PtEta_sysError was not loaded properly.");
290	loizides	1.1	}
291			}
292			}
293			} else {
294	phedex	1.5	Fatal("ElectronFakeRate","Error: FakeRate was not properly initialized.");
295	loizides	1.1	}
296			return error;
297			}
298	phedex	1.3
299			//--------------------------------------------------------------------------------------------------
300			Double_t FakeRate::MuonFakeRateStatErrorLow(Double_t pt, Double_t eta, Double_t phi)
301			{
302	loizides	1.4	// Calculate the muon fake rate lower statistical error given pt, eta, and phi.
303
304			return MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrLow);
305	phedex	1.3	}
306
307			//--------------------------------------------------------------------------------------------------
308			Double_t FakeRate::MuonFakeRateStatErrorHigh(Double_t pt, Double_t eta, Double_t phi)
309			{
310	loizides	1.4	// Calculate the muon fake rate upper statistical error given pt, eta, and phi.
311
312			return MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh);
313	phedex	1.3	}
314
315			//--------------------------------------------------------------------------------------------------
316			Double_t FakeRate::MuonFakeRateSysErrorLow(Double_t pt, Double_t eta, Double_t phi)
317			{
318	loizides	1.4	// Calculate the muon fake rate lower systematic error given pt, eta, and phi.
319
320			return MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrLow);
321	phedex	1.3	}
322
323			//--------------------------------------------------------------------------------------------------
324			Double_t FakeRate::MuonFakeRateSysErrorHigh(Double_t pt, Double_t eta, Double_t phi)
325			{
326	loizides	1.4	// Calculate the muon fake rate upper systematic error given pt, eta, and phi.
327
328			return MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh);
329	phedex	1.3	}
330
331			//--------------------------------------------------------------------------------------------------
332			Double_t FakeRate::MuonFakeRateErrorLow(Double_t pt, Double_t eta, Double_t phi)
333			{
334	loizides	1.4	// Calculate the muon fake rate total lower error given pt, eta, and phi.
335
336			return TMath::Sqrt( MuonFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kSysErrLow)*
337			MuonFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kSysErrLow) +
338			MuonFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kStatErrLow)*
339			MuonFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kStatErrLow)
340	phedex	1.3	);
341			}
342
343			//--------------------------------------------------------------------------------------------------
344			Double_t FakeRate::MuonFakeRateErrorHigh(Double_t pt, Double_t eta, Double_t phi)
345			{
346	loizides	1.4	// Calculate the muon fake rate total upper error given pt, eta, and phi.
347
348			return TMath::Sqrt( MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh)*
349			MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh) +
350			MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh)*
351			MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh)
352	phedex	1.3	);
353			}