FakeMods/src/FakeRate.cc

// $Id: FakeRate.cc,v 1.3 2009/08/10 16:07:26 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 {
          cerr << "Error: fElectronFakeRateHist_PtEta was not loaded properly.\n";
          assert(kFALSE);
        }
      }
    } else {
      if (fUseFitFunction) {
        if (fElectronFakeRateFit_Pt) {
          prob = fElectronFakeRateFit_Pt->Eval(pt);
        } else {
          cerr << "Error: fElectronFakeRateFit_Pt was not loaded properly.\n";
          assert(kFALSE);
        }
      } else {
        if (fElectronFakeRateHist_Pt) {
          Int_t ptbin = fElectronFakeRateHist_Pt->GetXaxis()->FindFixBin(pt);
          prob = fElectronFakeRateHist_Pt->GetBinContent(ptbin);
        } else {
          cerr << "Error: fElectronFakeRateHist_Pt was not loaded properly.\n";
          assert(kFALSE);
        }
      }
    }
  } else {
    cerr << "Error: FakeRate was not properly initialized. \n";
    assert(kFALSE);
  }
  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) {
          
          if(errorType == TH2DAsymErr::kStatErrLow) {
            return fElectronFakeRateHist_PtEta->GetStatErrorLow(pt, eta);
          } else if(errorType == TH2DAsymErr::kStatErrHigh) {
            return fElectronFakeRateHist_PtEta->GetStatErrorHigh(pt, eta);
          } else if(errorType == TH2DAsymErr::kSysErrLow) {
            return fElectronFakeRateHist_PtEta->GetSysErrorLow(pt, eta);
          } else if(errorType == TH2DAsymErr::kSysErrHigh) {
            return fElectronFakeRateHist_PtEta->GetSysErrorHigh(pt, eta);
          } else {
            cerr << "Error: Given ErrorType = " << errorType << " is not recognized.\n";
            return 0.0;
          }
        } else {
          cerr << "Error: fElectronFakeRateHist_PtEta_sysError was not loaded properly.\n";
          assert(kFALSE);
        }
      }
    } 
  } else {
    cerr << "Error: FakeRate was not properly initialized. \n";
    assert(kFALSE);
  }
  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 {
          cerr << "Error: fMuonFakeRateHist_PtEta was not loaded properly.\n";
          assert(kFALSE);
        }
      }
    } else {
      if (fUseFitFunction) {
        if (fMuonFakeRateFit_Pt) {
          prob = fMuonFakeRateFit_Pt->Eval(pt);
        } else {
          cerr << "Error: fMuonFakeRateFit_Pt was not loaded properly.\n";
          assert(kFALSE);
        }
      } else {
        if (fMuonFakeRateHist_Pt) {
          Int_t ptbin = fMuonFakeRateHist_Pt->GetXaxis()->FindFixBin(pt);
          prob = fMuonFakeRateHist_Pt->GetBinContent(ptbin);
        } else {
          cerr << "Error: fMuonFakeRateHist_Pt was not loaded properly.\n";
          assert(kFALSE);
        }
      }
    }
  } else {
    cerr << "Error: FakeRate was not properly initialized. \n";
    assert(kFALSE);
  }
  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) {

          if(errorType == TH2DAsymErr::kStatErrLow) {
            return fMuonFakeRateHist_PtEta->GetStatErrorLow(pt, eta);
          } else if(errorType == TH2DAsymErr::kStatErrHigh) {
            return fMuonFakeRateHist_PtEta->GetStatErrorHigh(pt, eta);
          } else if(errorType == TH2DAsymErr::kSysErrLow) {
            return fMuonFakeRateHist_PtEta->GetSysErrorLow(pt, eta);
          } else if(errorType == TH2DAsymErr::kSysErrHigh) {
            return fMuonFakeRateHist_PtEta->GetSysErrorHigh(pt, eta);
          } else {
            cerr << "Error: Given ErrorType = " << errorType << " is not recognized.\n";
            return 0.0;
          }
        } else {
          cerr << "Error: fMuonFakeRateHist_PtEta_sysError was not loaded properly.\n";
          assert(kFALSE);
        }
      }
    } 
  } else {
    cerr << "Error: FakeRate was not properly initialized. \n";
    assert(kFALSE);
  }
  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.4
Committed:	Tue Aug 11 09:16:01 2009 UTC (15 years, 8 months ago) by loizides
Content type:	text/plain
Branch:	MAIN
Changes since 1.3:	+70 -66 lines
Log Message:	Further cleanup
#	User	Rev	Content
1	loizides	1.4	// $Id: FakeRate.cc,v 1.3 2009/08/10 16:07:26 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			cerr << "Error: fElectronFakeRateHist_PtEta was not loaded properly.\n";
132	loizides	1.4	assert(kFALSE);
133	loizides	1.1	}
134			}
135			} else {
136			if (fUseFitFunction) {
137			if (fElectronFakeRateFit_Pt) {
138			prob = fElectronFakeRateFit_Pt->Eval(pt);
139			} else {
140			cerr << "Error: fElectronFakeRateFit_Pt was not loaded properly.\n";
141	loizides	1.4	assert(kFALSE);
142	loizides	1.1	}
143			} else {
144			if (fElectronFakeRateHist_Pt) {
145			Int_t ptbin = fElectronFakeRateHist_Pt->GetXaxis()->FindFixBin(pt);
146			prob = fElectronFakeRateHist_Pt->GetBinContent(ptbin);
147			} else {
148			cerr << "Error: fElectronFakeRateHist_Pt was not loaded properly.\n";
149	loizides	1.4	assert(kFALSE);
150	loizides	1.1	}
151			}
152			}
153			} else {
154			cerr << "Error: FakeRate was not properly initialized. \n";
155	loizides	1.4	assert(kFALSE);
156	loizides	1.1	}
157			return prob;
158			}
159
160			//--------------------------------------------------------------------------------------------------
161	phedex	1.3	Double_t FakeRate::ElectronFakeRateError(Double_t pt, Double_t eta, Double_t phi,
162	loizides	1.4	TH2DAsymErr::EErrType errorType)
163	loizides	1.1	{
164	phedex	1.3	// Calculate the electron fake rate error given pt, eta, and phi
165
166	loizides	1.1	Double_t error = 0.0;
167
168			if (fIsInit) {
169			if (fUse2DFakeRate) {
170			if (fUseFitFunction) {
171			cerr << "Error: Using 2D Fake Rates with Fit Function is not currently supported.\n";
172			} else {
173	phedex	1.3	if (fElectronFakeRateHist_PtEta) {
174	loizides	1.4
175			if(errorType == TH2DAsymErr::kStatErrLow) {
176	phedex	1.3	return fElectronFakeRateHist_PtEta->GetStatErrorLow(pt, eta);
177	loizides	1.4	} else if(errorType == TH2DAsymErr::kStatErrHigh) {
178	phedex	1.3	return fElectronFakeRateHist_PtEta->GetStatErrorHigh(pt, eta);
179	loizides	1.4	} else if(errorType == TH2DAsymErr::kSysErrLow) {
180	phedex	1.3	return fElectronFakeRateHist_PtEta->GetSysErrorLow(pt, eta);
181	loizides	1.4	} else if(errorType == TH2DAsymErr::kSysErrHigh) {
182	phedex	1.3	return fElectronFakeRateHist_PtEta->GetSysErrorHigh(pt, eta);
183			} else {
184			cerr << "Error: Given ErrorType = " << errorType << " is not recognized.\n";
185			return 0.0;
186	loizides	1.1	}
187			} else {
188			cerr << "Error: fElectronFakeRateHist_PtEta_sysError was not loaded properly.\n";
189	loizides	1.4	assert(kFALSE);
190	loizides	1.1	}
191			}
192			}
193			} else {
194			cerr << "Error: FakeRate was not properly initialized. \n";
195	loizides	1.4	assert(kFALSE);
196	loizides	1.1	}
197			return error;
198			}
199
200	phedex	1.3	//--------------------------------------------------------------------------------------------------
201			Double_t FakeRate::ElectronFakeRateStatErrorLow(Double_t pt, Double_t eta, Double_t phi)
202			{
203			// Calculate the electron fake rate lower statistical error given pt, eta, and phi
204	loizides	1.4	return ElectronFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kStatErrLow);
205	phedex	1.3	}
206
207			//--------------------------------------------------------------------------------------------------
208			Double_t FakeRate::ElectronFakeRateStatErrorHigh(Double_t pt, Double_t eta, Double_t phi)
209			{
210			// Calculate the electron fake rate upper statistical error given pt, eta, and phi
211	loizides	1.4	return ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh);
212	phedex	1.3	}
213
214			//--------------------------------------------------------------------------------------------------
215			Double_t FakeRate::ElectronFakeRateSysErrorLow(Double_t pt, Double_t eta, Double_t phi)
216			{
217			// Calculate the electron fake rate lower systematic error given pt, eta, and phi
218	loizides	1.4	return ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrLow);
219	phedex	1.3	}
220
221			//--------------------------------------------------------------------------------------------------
222			Double_t FakeRate::ElectronFakeRateSysErrorHigh(Double_t pt, Double_t eta, Double_t phi)
223			{
224			// Calculate the electron fake rate upper systematic error given pt, eta, and phi
225	loizides	1.4	return ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh);
226	phedex	1.3	}
227
228			//--------------------------------------------------------------------------------------------------
229			Double_t FakeRate::ElectronFakeRateErrorLow(Double_t pt, Double_t eta, Double_t phi)
230			{
231			// Calculate the electron fake rate total lower error given pt, eta, and phi
232	loizides	1.4	return TMath::Sqrt( ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrLow)*
233			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrLow) +
234			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrLow)*
235			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrLow)
236	phedex	1.3	);
237			}
238
239			//--------------------------------------------------------------------------------------------------
240			Double_t FakeRate::ElectronFakeRateErrorHigh(Double_t pt, Double_t eta, Double_t phi)
241			{
242			// Calculate the electron fake rate total upper error given pt, eta, and phi
243	loizides	1.4	return TMath::Sqrt( ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh)*
244			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh) +
245			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh)*
246			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh)
247	phedex	1.3	);
248			}
249
250	loizides	1.1	//--------------------------------------------------------------------------------------------------
251			Double_t FakeRate::MuonFakeRate(Double_t pt, Double_t eta, Double_t phi)
252			{
253			// Calculate the muon fake rate given pt, eta, and phi
254			Double_t prob = 0.0;
255
256			if (fIsInit) {
257			if (fUse2DFakeRate) {
258			if (fUseFitFunction) {
259			cerr << "Error: Using 2D Fake Rates with Fit Function is not currently supported.\n";
260			} else {
261			if (fMuonFakeRateHist_PtEta) {
262			Int_t ptbin = fMuonFakeRateHist_PtEta->GetXaxis()->FindFixBin(pt);
263			Int_t etabin = fMuonFakeRateHist_PtEta->GetYaxis()->FindFixBin(eta);
264			prob = fMuonFakeRateHist_PtEta->GetBinContent(ptbin,etabin);
265			} else {
266			cerr << "Error: fMuonFakeRateHist_PtEta was not loaded properly.\n";
267	loizides	1.4	assert(kFALSE);
268	loizides	1.1	}
269			}
270			} else {
271			if (fUseFitFunction) {
272			if (fMuonFakeRateFit_Pt) {
273			prob = fMuonFakeRateFit_Pt->Eval(pt);
274			} else {
275			cerr << "Error: fMuonFakeRateFit_Pt was not loaded properly.\n";
276	loizides	1.4	assert(kFALSE);
277	loizides	1.1	}
278			} else {
279			if (fMuonFakeRateHist_Pt) {
280			Int_t ptbin = fMuonFakeRateHist_Pt->GetXaxis()->FindFixBin(pt);
281			prob = fMuonFakeRateHist_Pt->GetBinContent(ptbin);
282			} else {
283			cerr << "Error: fMuonFakeRateHist_Pt was not loaded properly.\n";
284	loizides	1.4	assert(kFALSE);
285	loizides	1.1	}
286			}
287			}
288			} else {
289			cerr << "Error: FakeRate was not properly initialized. \n";
290	loizides	1.4	assert(kFALSE);
291	loizides	1.1	}
292			return prob;
293			}
294
295			//--------------------------------------------------------------------------------------------------
296	phedex	1.3	Double_t FakeRate::MuonFakeRateError(Double_t pt, Double_t eta, Double_t phi,
297	loizides	1.4	TH2DAsymErr::EErrType errorType)
298	loizides	1.1	{
299	loizides	1.4	// Calculate the muon fake rate error given pt, eta, and phi.
300
301	loizides	1.1	Double_t error = 0.0;
302
303			if (fIsInit) {
304			if (fUse2DFakeRate) {
305			if (fUseFitFunction) {
306			cerr << "Error: Using 2D Fake Rates with Fit Function is not currently supported.\n";
307			} else {
308	phedex	1.3	if (fMuonFakeRateHist_PtEta) {
309
310	loizides	1.4	if(errorType == TH2DAsymErr::kStatErrLow) {
311	phedex	1.3	return fMuonFakeRateHist_PtEta->GetStatErrorLow(pt, eta);
312	loizides	1.4	} else if(errorType == TH2DAsymErr::kStatErrHigh) {
313	phedex	1.3	return fMuonFakeRateHist_PtEta->GetStatErrorHigh(pt, eta);
314	loizides	1.4	} else if(errorType == TH2DAsymErr::kSysErrLow) {
315	phedex	1.3	return fMuonFakeRateHist_PtEta->GetSysErrorLow(pt, eta);
316	loizides	1.4	} else if(errorType == TH2DAsymErr::kSysErrHigh) {
317	phedex	1.3	return fMuonFakeRateHist_PtEta->GetSysErrorHigh(pt, eta);
318			} else {
319			cerr << "Error: Given ErrorType = " << errorType << " is not recognized.\n";
320			return 0.0;
321	loizides	1.1	}
322			} else {
323			cerr << "Error: fMuonFakeRateHist_PtEta_sysError was not loaded properly.\n";
324	loizides	1.4	assert(kFALSE);
325	loizides	1.1	}
326			}
327			}
328			} else {
329			cerr << "Error: FakeRate was not properly initialized. \n";
330	loizides	1.4	assert(kFALSE);
331	loizides	1.1	}
332			return error;
333			}
334	phedex	1.3
335			//--------------------------------------------------------------------------------------------------
336			Double_t FakeRate::MuonFakeRateStatErrorLow(Double_t pt, Double_t eta, Double_t phi)
337			{
338	loizides	1.4	// Calculate the muon fake rate lower statistical error given pt, eta, and phi.
339
340			return MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrLow);
341	phedex	1.3	}
342
343			//--------------------------------------------------------------------------------------------------
344			Double_t FakeRate::MuonFakeRateStatErrorHigh(Double_t pt, Double_t eta, Double_t phi)
345			{
346	loizides	1.4	// Calculate the muon fake rate upper statistical error given pt, eta, and phi.
347
348			return MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh);
349	phedex	1.3	}
350
351			//--------------------------------------------------------------------------------------------------
352			Double_t FakeRate::MuonFakeRateSysErrorLow(Double_t pt, Double_t eta, Double_t phi)
353			{
354	loizides	1.4	// Calculate the muon fake rate lower systematic error given pt, eta, and phi.
355
356			return MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrLow);
357	phedex	1.3	}
358
359			//--------------------------------------------------------------------------------------------------
360			Double_t FakeRate::MuonFakeRateSysErrorHigh(Double_t pt, Double_t eta, Double_t phi)
361			{
362	loizides	1.4	// Calculate the muon fake rate upper systematic error given pt, eta, and phi.
363
364			return MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh);
365	phedex	1.3	}
366
367			//--------------------------------------------------------------------------------------------------
368			Double_t FakeRate::MuonFakeRateErrorLow(Double_t pt, Double_t eta, Double_t phi)
369			{
370	loizides	1.4	// Calculate the muon fake rate total lower error given pt, eta, and phi.
371
372			return TMath::Sqrt( MuonFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kSysErrLow)*
373			MuonFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kSysErrLow) +
374			MuonFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kStatErrLow)*
375			MuonFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kStatErrLow)
376	phedex	1.3	);
377			}
378
379			//--------------------------------------------------------------------------------------------------
380			Double_t FakeRate::MuonFakeRateErrorHigh(Double_t pt, Double_t eta, Double_t phi)
381			{
382	loizides	1.4	// Calculate the muon fake rate total upper error given pt, eta, and phi.
383
384			return TMath::Sqrt( MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh)*
385			MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh) +
386			MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh)*
387			MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh)
388	phedex	1.3	);
389			}