FakeMods/src/FakeRate.cc

// $Id: FakeRate.cc,v 1.2 2009/07/13 11:27:13 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 false;
  }
  TFile *MuonFRFile = new TFile(fMuonFRFilename);  
  if (!MuonFRFile) {
    cerr << "The Muon FakeRate file : " << fMuonFRFilename << " could not be opened!\n";
    return false;
  }
  
  // *****************************************************************************************
  // 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 false;

      //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(false);
        }
      }
    } else {
      if (fUseFitFunction) {
        if (fElectronFakeRateFit_Pt) {
          prob = fElectronFakeRateFit_Pt->Eval(pt);
        } else {
          cerr << "Error: fElectronFakeRateFit_Pt was not loaded properly.\n";
          assert(false);
        }
      } 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(false);
        }
      }
    }
  } else {
    cerr << "Error: FakeRate was not properly initialized. \n";
    assert(false);
  }
  return prob;
}

//--------------------------------------------------------------------------------------------------
Double_t FakeRate::ElectronFakeRateError(Double_t pt, Double_t eta, Double_t phi, 
                                         mithep::TH2DAsymErr::ErrorType 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 == mithep::TH2DAsymErr::kStatErrorLow) {
            return fElectronFakeRateHist_PtEta->GetStatErrorLow(pt, eta);
          } else if(errorType == mithep::TH2DAsymErr::kStatErrorHigh) {
            return fElectronFakeRateHist_PtEta->GetStatErrorHigh(pt, eta);
          } else if(errorType == mithep::TH2DAsymErr::kSysErrorLow) {
            return fElectronFakeRateHist_PtEta->GetSysErrorLow(pt, eta);
          } else if(errorType == mithep::TH2DAsymErr::kSysErrorHigh) {
            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(false);
        }
      }
    } 
  } else {
    cerr << "Error: FakeRate was not properly initialized. \n";
    assert(false);
  }
  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::kStatErrorLow);
}

//--------------------------------------------------------------------------------------------------
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, mithep::TH2DAsymErr::kStatErrorHigh);
}

//--------------------------------------------------------------------------------------------------
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, mithep::TH2DAsymErr::kSysErrorLow);
}

//--------------------------------------------------------------------------------------------------
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, mithep::TH2DAsymErr::kSysErrorHigh);
}

//--------------------------------------------------------------------------------------------------
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, mithep::TH2DAsymErr::kSysErrorLow)*
                      ElectronFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kSysErrorLow) +
                      ElectronFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kStatErrorLow)*
                      ElectronFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kStatErrorLow)
    );
}

//--------------------------------------------------------------------------------------------------
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, mithep::TH2DAsymErr::kSysErrorHigh)*
                      ElectronFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kSysErrorHigh) +
                      ElectronFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kStatErrorHigh)*
                      ElectronFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kStatErrorHigh)
    );
}

//--------------------------------------------------------------------------------------------------
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(false);
        }
      }
    } else {
      if (fUseFitFunction) {
        if (fMuonFakeRateFit_Pt) {
          prob = fMuonFakeRateFit_Pt->Eval(pt);
        } else {
          cerr << "Error: fMuonFakeRateFit_Pt was not loaded properly.\n";
          assert(false);
        }
      } 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(false);
        }
      }
    }
  } else {
    cerr << "Error: FakeRate was not properly initialized. \n";
    assert(false);
  }
  return prob;
}

//--------------------------------------------------------------------------------------------------
Double_t FakeRate::MuonFakeRateError(Double_t pt, Double_t eta, Double_t phi, 
                                     mithep::TH2DAsymErr::ErrorType 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 ==mithep::TH2DAsymErr::kStatErrorLow) {
            return fMuonFakeRateHist_PtEta->GetStatErrorLow(pt, eta);
          } else if(errorType == mithep::TH2DAsymErr::kStatErrorHigh) {
            return fMuonFakeRateHist_PtEta->GetStatErrorHigh(pt, eta);
          } else if(errorType == mithep::TH2DAsymErr::kSysErrorLow) {
            return fMuonFakeRateHist_PtEta->GetSysErrorLow(pt, eta);
          } else if(errorType == mithep::TH2DAsymErr::kSysErrorHigh) {
            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(false);
        }
      }
    } 
  } else {
    cerr << "Error: FakeRate was not properly initialized. \n";
    assert(false);
  }
  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, mithep::TH2DAsymErr::kStatErrorLow);
}

//--------------------------------------------------------------------------------------------------
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, mithep::TH2DAsymErr::kStatErrorHigh);
}

//--------------------------------------------------------------------------------------------------
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, mithep::TH2DAsymErr::kSysErrorLow);
}

//--------------------------------------------------------------------------------------------------
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, mithep::TH2DAsymErr::kSysErrorHigh);
}

//--------------------------------------------------------------------------------------------------
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::kSysErrorLow)*
                      MuonFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kSysErrorLow) +
                      MuonFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kStatErrorLow)*
                      MuonFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kStatErrorLow)
    );
}

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