FakeMods/src/FakeRate.cc

// $Id: FakeRate.cc,v 1.6 2009/11/03 08:40:37 ceballos 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);

    cout << " check fake rate histogram : " << fElectronFRHistName << " from " << fElectronFRFilename << endl;
    for (int b=0;b<=fElectronFakeRateHist_PtEta->GetXaxis()->GetNbins();b++) {
      for (int c=0;c<=fElectronFakeRateHist_PtEta->GetYaxis()->GetNbins();c++) {
        Double_t x = fElectronFakeRateHist_PtEta->GetXaxis()->GetBinCenter(b);
        Double_t y = fElectronFakeRateHist_PtEta->GetYaxis()->GetBinCenter(c);
        cout << "bin : " << x << " " << y << " " << fElectronFakeRateHist_PtEta->GetBinContent(b,c) << "  |  " <<  fElectronFakeRateHist_PtEta->GetStatErrorLow(x,y) << " " << fElectronFakeRateHist_PtEta->GetStatErrorHigh(x,y) << " " << fElectronFakeRateHist_PtEta->GetSysErrorLow(x,y) << " " << fElectronFakeRateHist_PtEta->GetSysErrorHigh(x,y) << endl;
      }
    }


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

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

  } else {

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

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

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

  return true;
}


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

  Double_t prob = 0.0;

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

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

  Double_t error = 0.0;

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

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

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

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

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

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

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

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

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

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

  Double_t error = 0.0;

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

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

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

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

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

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

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

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

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

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

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

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

  return TMath::Sqrt( MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh)*
                      MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh) +
                      MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh)*
                      MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh)
    );
}
Revision:	1.7
Committed:	Tue Nov 3 15:58:25 2009 UTC (15 years, 6 months ago) by sixie
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_029c, Mit_029b, Mit_029a, Mit_028a, Mit_028, Mit_027, Mit_027a, Mit_025e, Mit_025d, Mit_025c, Mit_025b, Mit_025a, Mit_025, Mit_025pre2, Mit_024b, Mit_025pre1, Mit_024a, Mit_024, Mit_023, Mit_022a, Mit_022, Mit_020d, TMit_020d, Mit_020c, Mit_021, Mit_021pre2, Mit_021pre1, Mit_020b, Mit_020a, Mit_020, Mit_020pre1, Mit_018, Mit_017, Mit_017pre3, Mit_017pre2, Mit_017pre1, Mit_016, Mit_015b, Mit_015a, Mit_015, Mit_014e, Mit_014d, Mit_014c, Mit_014b, Mit_014a, Mit_014, Mit_014pre3, Mit_014pre2, Mit_014pre1, Mit_013d, Mit_013c, Mit_013b, Mit_013a, Mit_013, Mit_013pre1, Mit_012i, Mit_012g, Mit_012f, Mit_012e, Mit_012d, Mit_012c, Mit_012b, Mit_012a, Mit_012, HEAD
Changes since 1.6:	+11 -1 lines
Log Message:	Add some initialization text output. shows contents of fake rate histogram.
#	User	Rev	Content
1	sixie	1.7	// $Id: FakeRate.cc,v 1.6 2009/11/03 08:40:37 ceballos 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	sixie	1.7	cout << " check fake rate histogram : " << fElectronFRHistName << " from " << fElectronFRFilename << endl;
55			for (int b=0;b<=fElectronFakeRateHist_PtEta->GetXaxis()->GetNbins();b++) {
56			for (int c=0;c<=fElectronFakeRateHist_PtEta->GetYaxis()->GetNbins();c++) {
57			Double_t x = fElectronFakeRateHist_PtEta->GetXaxis()->GetBinCenter(b);
58			Double_t y = fElectronFakeRateHist_PtEta->GetYaxis()->GetBinCenter(c);
59			cout << "bin : " << x << " " << y << " " << fElectronFakeRateHist_PtEta->GetBinContent(b,c) << " \| " << fElectronFakeRateHist_PtEta->GetStatErrorLow(x,y) << " " << fElectronFakeRateHist_PtEta->GetStatErrorHigh(x,y) << " " << fElectronFakeRateHist_PtEta->GetSysErrorLow(x,y) << " " << fElectronFakeRateHist_PtEta->GetSysErrorHigh(x,y) << endl;
60			}
61			}
62
63
64	loizides	1.1	if (fUseFitFunction) {
65			//Currently unsupported
66			cerr << "Error: Using 2D Fake Rates with Fit Function is not currently supported.\n";
67	loizides	1.4	return kFALSE;
68	loizides	1.1
69			//Once supported, below code will load the functions.
70			TF2 ElectronFakeRateFit_PtEta_temp = (TF2)(ElectronFRFile->Get(fElectronFRFunctionName));
71			TF2 MuonFakeRateFit_PtEta_temp = (TF2)(MuonFRFile->Get(fMuonFRFunctionName));
72			if (!ElectronFakeRateFit_PtEta_temp) {
73			cout << "Error: Function " << fElectronFRFunctionName << " cannot be loaded from file "
74			<< fElectronFRFilename << endl;
75			}
76			if (!MuonFakeRateFit_PtEta_temp) {
77			cout << "Error: Function " << fMuonFRFunctionName << " cannot be loaded. from file"
78			<< fMuonFRFilename << endl;
79			}
80			fElectronFakeRateFit_PtEta = (TF2*)(ElectronFakeRateFit_PtEta_temp->Clone());
81			fMuonFakeRateFit_PtEta = (TF2*)(MuonFakeRateFit_PtEta_temp->Clone());
82			}
83	loizides	1.4
84	loizides	1.1	} else {
85
86			fElectronFakeRateHist_Pt = (TH1F*)(ElectronFRFile->Get(fElectronFRHistName));
87			fMuonFakeRateHist_Pt = (TH1F*)(MuonFRFile->Get(fMuonFRHistName));
88			if (!fElectronFakeRateHist_Pt) {
89			cout << "Error: Histogram " << fElectronFRHistName << " cannot be loaded from file "
90			<< fElectronFRFilename << endl;
91			}
92			if (!fMuonFakeRateHist_Pt) {
93			cout << "Error: Histogram " << fMuonFRHistName << " cannot be loaded. from file"
94			<< fMuonFRFilename << endl;
95			}
96			fElectronFakeRateHist_Pt->SetDirectory(0);
97			fMuonFakeRateHist_Pt->SetDirectory(0);
98
99			if (fUseFitFunction) {
100			TF1 ElectronFakeRateFit_Pt_temp = (TF1)(ElectronFRFile->Get(fElectronFRFunctionName));
101			TF1 MuonFakeRateFit_Pt_temp = (TF1)(MuonFRFile->Get(fMuonFRFunctionName));
102			if (!ElectronFakeRateFit_Pt_temp) {
103			cout << "Error: Function " << fElectronFRFunctionName << " cannot be loaded from file "
104			<< fElectronFRFilename << endl;
105			}
106			if (!MuonFakeRateFit_Pt_temp) {
107			cout << "Error: Function " << fMuonFRFunctionName << " cannot be loaded. from file"
108			<< fMuonFRFilename << endl;
109			}
110			fElectronFakeRateFit_Pt = (TF1*)(ElectronFakeRateFit_Pt_temp->Clone());
111			fMuonFakeRateFit_Pt = (TF1*)(MuonFakeRateFit_Pt_temp->Clone());
112			}
113			}
114
115			ElectronFRFile->Close();
116			MuonFRFile->Close();
117			delete ElectronFRFile;
118			delete MuonFRFile;
119
120			return true;
121			}
122
123
124			//--------------------------------------------------------------------------------------------------
125			Double_t FakeRate::ElectronFakeRate(Double_t pt, Double_t eta, Double_t phi)
126			{
127	loizides	1.4	// Calculate the electron fake rate given pt, eta, and phi.
128	phedex	1.3
129	loizides	1.1	Double_t prob = 0.0;
130
131			if (fIsInit) {
132			if (fUse2DFakeRate) {
133			if (fUseFitFunction) {
134			cerr << "Error: Using 2D Fake Rates with Fit Function is not currently supported.\n";
135			} else {
136			if (fElectronFakeRateHist_PtEta) {
137			Int_t ptbin = fElectronFakeRateHist_PtEta->GetXaxis()->FindFixBin(pt);
138			Int_t etabin = fElectronFakeRateHist_PtEta->GetYaxis()->FindFixBin(eta);
139			prob = fElectronFakeRateHist_PtEta->GetBinContent(ptbin,etabin);
140			} else {
141	phedex	1.5	Fatal("ElectronFakeRate","Error: fElectronFakeRateHist_PtEta was not loaded properly.");
142	loizides	1.1	}
143			}
144			} else {
145			if (fUseFitFunction) {
146			if (fElectronFakeRateFit_Pt) {
147			prob = fElectronFakeRateFit_Pt->Eval(pt);
148			} else {
149	phedex	1.5	Fatal("ElectronFakeRate","Error: fElectronFakeRateFit_Pt was not loaded properly.");
150	loizides	1.1	}
151			} else {
152			if (fElectronFakeRateHist_Pt) {
153			Int_t ptbin = fElectronFakeRateHist_Pt->GetXaxis()->FindFixBin(pt);
154			prob = fElectronFakeRateHist_Pt->GetBinContent(ptbin);
155			} else {
156	phedex	1.5	Fatal("ElectronFakeRate","Error: fElectronFakeRateHist_Pt was not loaded properly.");
157	loizides	1.1	}
158			}
159			}
160			} else {
161	phedex	1.5	Fatal("ElectronFakeRate","Error: FakeRate was not properly initialized.");
162	loizides	1.1	}
163	ceballos	1.6	if (prob > 1) {
164			cerr << "Fake Rate = " << prob << " is larger than 1.0" << endl;
165			}
166	loizides	1.1	return prob;
167			}
168
169			//--------------------------------------------------------------------------------------------------
170	phedex	1.3	Double_t FakeRate::ElectronFakeRateError(Double_t pt, Double_t eta, Double_t phi,
171	loizides	1.4	TH2DAsymErr::EErrType errorType)
172	loizides	1.1	{
173	phedex	1.3	// Calculate the electron fake rate error given pt, eta, and phi
174
175	loizides	1.1	Double_t error = 0.0;
176
177			if (fIsInit) {
178			if (fUse2DFakeRate) {
179			if (fUseFitFunction) {
180			} else {
181	ceballos	1.6	if (fElectronFakeRateHist_PtEta) {
182	phedex	1.5	return fElectronFakeRateHist_PtEta->GetError(pt, eta, errorType);
183	loizides	1.1	} else {
184	phedex	1.5	Fatal("ElectronFakeRate","Error: fElectronFakeRateHist_PtEta_sysError was not loaded properly.");
185	loizides	1.1	}
186			}
187			}
188			} else {
189	phedex	1.5	Fatal("ElectronFakeRate","Error: FakeRate was not properly initialized.");
190	loizides	1.1	}
191			return error;
192			}
193
194	phedex	1.3	//--------------------------------------------------------------------------------------------------
195			Double_t FakeRate::ElectronFakeRateStatErrorLow(Double_t pt, Double_t eta, Double_t phi)
196			{
197			// Calculate the electron fake rate lower statistical error given pt, eta, and phi
198	loizides	1.4	return ElectronFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kStatErrLow);
199	phedex	1.3	}
200
201			//--------------------------------------------------------------------------------------------------
202			Double_t FakeRate::ElectronFakeRateStatErrorHigh(Double_t pt, Double_t eta, Double_t phi)
203			{
204			// Calculate the electron fake rate upper statistical error given pt, eta, and phi
205	loizides	1.4	return ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh);
206	phedex	1.3	}
207
208			//--------------------------------------------------------------------------------------------------
209			Double_t FakeRate::ElectronFakeRateSysErrorLow(Double_t pt, Double_t eta, Double_t phi)
210			{
211			// Calculate the electron fake rate lower systematic error given pt, eta, and phi
212	loizides	1.4	return ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrLow);
213	phedex	1.3	}
214
215			//--------------------------------------------------------------------------------------------------
216			Double_t FakeRate::ElectronFakeRateSysErrorHigh(Double_t pt, Double_t eta, Double_t phi)
217			{
218			// Calculate the electron fake rate upper systematic error given pt, eta, and phi
219	loizides	1.4	return ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh);
220	phedex	1.3	}
221
222			//--------------------------------------------------------------------------------------------------
223			Double_t FakeRate::ElectronFakeRateErrorLow(Double_t pt, Double_t eta, Double_t phi)
224			{
225			// Calculate the electron fake rate total lower error given pt, eta, and phi
226	loizides	1.4	return TMath::Sqrt( ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrLow)*
227			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrLow) +
228			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrLow)*
229			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrLow)
230	phedex	1.3	);
231			}
232
233			//--------------------------------------------------------------------------------------------------
234			Double_t FakeRate::ElectronFakeRateErrorHigh(Double_t pt, Double_t eta, Double_t phi)
235			{
236			// Calculate the electron fake rate total upper error given pt, eta, and phi
237	loizides	1.4	return TMath::Sqrt( ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh)*
238			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh) +
239			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh)*
240			ElectronFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh)
241	phedex	1.3	);
242			}
243
244	loizides	1.1	//--------------------------------------------------------------------------------------------------
245			Double_t FakeRate::MuonFakeRate(Double_t pt, Double_t eta, Double_t phi)
246			{
247			// Calculate the muon fake rate given pt, eta, and phi
248			Double_t prob = 0.0;
249
250			if (fIsInit) {
251			if (fUse2DFakeRate) {
252			if (fUseFitFunction) {
253			cerr << "Error: Using 2D Fake Rates with Fit Function is not currently supported.\n";
254			} else {
255			if (fMuonFakeRateHist_PtEta) {
256			Int_t ptbin = fMuonFakeRateHist_PtEta->GetXaxis()->FindFixBin(pt);
257			Int_t etabin = fMuonFakeRateHist_PtEta->GetYaxis()->FindFixBin(eta);
258			prob = fMuonFakeRateHist_PtEta->GetBinContent(ptbin,etabin);
259			} else {
260	phedex	1.5	Fatal("ElectronFakeRate","Error: fMuonFakeRateHist_PtEta was not loaded properly.");
261	loizides	1.1	}
262			}
263			} else {
264			if (fUseFitFunction) {
265			if (fMuonFakeRateFit_Pt) {
266			prob = fMuonFakeRateFit_Pt->Eval(pt);
267			} else {
268	phedex	1.5	Fatal("ElectronFakeRate","Error: fMuonFakeRateFit_Pt was not loaded properly.");
269	loizides	1.1	}
270			} else {
271			if (fMuonFakeRateHist_Pt) {
272			Int_t ptbin = fMuonFakeRateHist_Pt->GetXaxis()->FindFixBin(pt);
273			prob = fMuonFakeRateHist_Pt->GetBinContent(ptbin);
274			} else {
275	phedex	1.5	Fatal("ElectronFakeRate","Error: fMuonFakeRateHist_Pt was not loaded properly.");
276	loizides	1.1	}
277			}
278			}
279			} else {
280	phedex	1.5	Fatal("ElectronFakeRate","Error: FakeRate was not properly initialized.");
281	loizides	1.1	}
282	ceballos	1.6	if (prob > 1) {
283			cerr << "Fake Rate is larger than 1.0" << endl;
284			}
285	loizides	1.1	return prob;
286			}
287
288			//--------------------------------------------------------------------------------------------------
289	phedex	1.3	Double_t FakeRate::MuonFakeRateError(Double_t pt, Double_t eta, Double_t phi,
290	loizides	1.4	TH2DAsymErr::EErrType errorType)
291	loizides	1.1	{
292	loizides	1.4	// Calculate the muon fake rate error given pt, eta, and phi.
293
294	loizides	1.1	Double_t error = 0.0;
295
296			if (fIsInit) {
297			if (fUse2DFakeRate) {
298			if (fUseFitFunction) {
299			cerr << "Error: Using 2D Fake Rates with Fit Function is not currently supported.\n";
300			} else {
301	phedex	1.3	if (fMuonFakeRateHist_PtEta) {
302	phedex	1.5	return fMuonFakeRateHist_PtEta->GetError(pt, eta, errorType);
303	loizides	1.1	} else {
304	phedex	1.5	Fatal("ElectronFakeRate","Error: fMuonFakeRateHist_PtEta_sysError was not loaded properly.");
305	loizides	1.1	}
306			}
307			}
308			} else {
309	phedex	1.5	Fatal("ElectronFakeRate","Error: FakeRate was not properly initialized.");
310	loizides	1.1	}
311			return error;
312			}
313	phedex	1.3
314			//--------------------------------------------------------------------------------------------------
315			Double_t FakeRate::MuonFakeRateStatErrorLow(Double_t pt, Double_t eta, Double_t phi)
316			{
317	loizides	1.4	// Calculate the muon fake rate lower statistical error given pt, eta, and phi.
318
319			return MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrLow);
320	phedex	1.3	}
321
322			//--------------------------------------------------------------------------------------------------
323			Double_t FakeRate::MuonFakeRateStatErrorHigh(Double_t pt, Double_t eta, Double_t phi)
324			{
325	loizides	1.4	// Calculate the muon fake rate upper statistical error given pt, eta, and phi.
326
327			return MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh);
328	phedex	1.3	}
329
330			//--------------------------------------------------------------------------------------------------
331			Double_t FakeRate::MuonFakeRateSysErrorLow(Double_t pt, Double_t eta, Double_t phi)
332			{
333	loizides	1.4	// Calculate the muon fake rate lower systematic error given pt, eta, and phi.
334
335			return MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrLow);
336	phedex	1.3	}
337
338			//--------------------------------------------------------------------------------------------------
339			Double_t FakeRate::MuonFakeRateSysErrorHigh(Double_t pt, Double_t eta, Double_t phi)
340			{
341	loizides	1.4	// Calculate the muon fake rate upper systematic error given pt, eta, and phi.
342
343			return MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh);
344	phedex	1.3	}
345
346			//--------------------------------------------------------------------------------------------------
347			Double_t FakeRate::MuonFakeRateErrorLow(Double_t pt, Double_t eta, Double_t phi)
348			{
349	loizides	1.4	// Calculate the muon fake rate total lower error given pt, eta, and phi.
350
351			return TMath::Sqrt( MuonFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kSysErrLow)*
352			MuonFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kSysErrLow) +
353			MuonFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kStatErrLow)*
354			MuonFakeRateError(pt, eta, phi, mithep::TH2DAsymErr::kStatErrLow)
355	phedex	1.3	);
356			}
357
358			//--------------------------------------------------------------------------------------------------
359			Double_t FakeRate::MuonFakeRateErrorHigh(Double_t pt, Double_t eta, Double_t phi)
360			{
361	loizides	1.4	// Calculate the muon fake rate total upper error given pt, eta, and phi.
362
363			return TMath::Sqrt( MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh)*
364			MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kSysErrHigh) +
365			MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh)*
366			MuonFakeRateError(pt, eta, phi, TH2DAsymErr::kStatErrHigh)
367	phedex	1.3	);
368			}