SFrameTools/include/MCDataScaleFactors.h

#ifndef MCDataScaleFactors_H
#define MCDataScaleFactors_H

#include "TF1.h"
#include <TGraphAsymmErrors.h>

#include "include/Utils.h"
#include "include/EventCalc.h"

/**
 *  @short module to apply data-MC lepton scale factors for trigger and ID
 *
 *
 */
class LeptonScaleFactors {
public:
    /**
     * constructor
     *
     * first argument: list of corrections to be applied together with weight factors for luminosity, example: "MuonRunA 1.5 MuonRunB 2.6 MuonRunC 7.8"
     *
     * second argument: systematic shift
     * @see E_SystShift
     */
    LeptonScaleFactors(std::vector<std::string> correctionlist);
    ///Default destructor
    ~LeptonScaleFactors() {};

    ///browse configuration and fill all requested correction factors
    void FillWeights();

    ///return the total weight (muon*electron)
    ///derived from the weighted correction factor for muons (ID, trigger and isolation)
    ///and all electron weights
    double GetWeight();

    ///return the weighted correction factor for muon ID
    double GetMuonIDWeight();

    ///return the weighted correction factor for muon trigger
    double GetMuonTrigWeight();

    ///return the weighted correction factor for muon isolation
    double GetMuonIsoWeight();

    ///return the weighted correction factor for muons (ID, trigger and isolation)
    double GetMuonWeight();

    ///return the weighted correction factor for electron trigger
    double GetElectronTrigWeight();

    ///return the weighted correction factor for electrons (right now: only trigger)
    double GetElectronWeight();

    ///check if the scale factors are up-to-date, fill them only once per run
    ///implemented for run-dependent scale factors
    bool IsUpToDate();
    
    /// return the bin number of the muon eta bin
    int GetMuonEtaBin(double eta);

    /// return the bin number of a graph corresponding to a certain value of the x coordinate
    int GetBin(double x, TGraphAsymmErrors* graph);
    
    void DoUpVarMuonSF(bool f=true){m_muon_unc=true; m_syst_shift=e_Up;}
    void DoDownVarMuonSF(bool f=true){m_muon_unc=true; m_syst_shift=e_Down;}

    void DoUpVarEleSF(bool f=true){m_ele_unc=true; m_syst_shift=e_Up;}
    void DoDownVarEleSF(bool f=true){m_ele_unc=true; m_syst_shift=e_Down;}

    void DoUpVarTauSF(bool f=true){m_tau_unc=true; m_syst_shift=e_Up;}
    void DoDownVarTauSF(bool f=true){m_tau_unc=true; m_syst_shift=e_Down;}
    

private:
    E_SystShift m_syst_shift;
    std::vector<std::pair<std::string, double> > m_correctionlist;
    bool m_apply;                   // should any scale factors be applied?
    bool m_muon_unc;                // do shift of muon scale factors 
    bool m_ele_unc;                 // do shift of electron scale factors 
    bool m_tau_unc;                 // do shift of tau scale factors 
    int m_current_run;              // run for which the scale factors are valid
    std::vector< std::vector<TGraphAsymmErrors*> > m_mu_id;    // two arrays: first index stands for eta bin, second for run period
    std::vector< std::vector<TGraphAsymmErrors*> > m_mu_trig;  // two arrays: first index stands for eta bin, second for run period
    std::vector< std::vector<TGraphAsymmErrors*> > m_mu_iso;   // two arrays: first index stands for eta bin, second for run period
    std::vector<double> m_weights;  // weights for different runs
    std::vector<double> m_ele_trig; // two-parameter function of relative isolation times additional weight

};


/**
 *  @short modules to apply data-MC btagging corrections
 *
 *
 */


class BtagFunction {
public:
    BtagFunction(E_BtagType btagtype) {
        m_btagtype = btagtype;
    }

    virtual ~BtagFunction() {
    };

    virtual float value(const float &x) const = 0;
    virtual float value_plus(const float &x) const = 0;
    virtual float value_minus(const float &x) const = 0;

protected:
    E_BtagType m_btagtype;
};


class BtagScale: public BtagFunction {
public:

    BtagScale(E_BtagType);

    virtual float value(const float &jet_pt) const;
    virtual float value_plus(const float &jet_pt) const {
        return value(jet_pt) + error(jet_pt);
    }

    virtual float value_minus(const float &jet_pt) const {
        const float value_ = value(jet_pt) - error(jet_pt);
        return value_ > 0 ? value_ : 0;
    }

protected:

    virtual float error(const float &jet_pt) const;

private:

    TF1 * _scale;
    std::vector<float> _errors;
    std::vector<float> _bins;
    const unsigned int find_bin(const float &jet_pt) const;
};


class CtagScale: public BtagScale {
public:

    CtagScale(E_BtagType btagtype) : BtagScale(btagtype) {}

protected:

    virtual float error(const float &jet_pt) const;

};


class LtagScale: public BtagFunction {
public:

    LtagScale(E_BtagType btagtype);

    virtual float value(const float &jet_pt) const;
    virtual float value_plus(const float &jet_pt) const;
    virtual float value_minus(const float &jet_pt) const;

private:

    TF1 * _scale;
    TF1 * _scale_plus;
    TF1 * _scale_minus;

};


class BtagEfficiency: public BtagFunction {
public:

    BtagEfficiency(E_BtagType, E_LeptonSelection);

    virtual float value(const float &jet_pt) const;
    virtual float value_plus(const float &jet_pt) const {
        return value(jet_pt);
    }

    virtual float value_minus(const float &jet_pt) const {
        return value(jet_pt);
    }

protected:

    const unsigned int find_bin(const float &jet_pt) const;
    std::vector<float> _values;
    std::vector<float> _bins;

};


class CtagEfficiency: public BtagEfficiency {
public:

    CtagEfficiency(E_BtagType, E_LeptonSelection);

};


class LtagEfficiency: public BtagEfficiency {
public:

    LtagEfficiency(E_BtagType, E_LeptonSelection);

};


/**
 *  @short module to apply data-MC scale factors for b tagging
 *
 *
 */
class BTaggingScaleFactors {
public:
    /**
     * constructor
     *
     * second argument: systematic shift
     * @see E_SystShift
     */
    BTaggingScaleFactors(
        E_BtagType, E_LeptonSelection, E_SystShift sys_bjets=e_Default, E_SystShift sys_ljets=e_Default
    );
    ///Default destructor
    ~BTaggingScaleFactors() {};

    ///return the weighted correction factor
    double GetWeight();

private:

    E_SystShift m_sys_bjets;
    E_SystShift m_sys_ljets;
    E_BtagType m_btagtype;
    E_LeptonSelection m_lepton_selection;

    float scale(const bool &is_tagged,
                const float &jet_pt,
                const BtagFunction* sf,
                const BtagFunction* eff,
                const E_SystShift &sytematic);

    float scale_data(const bool &is_tagged,
                     const float &jet_pt,
                     const BtagFunction* sf,
                     const BtagFunction* eff,
                     const E_SystShift &sytematic);

    BtagFunction* _scale_btag;
    BtagFunction* _eff_btag;

    BtagFunction* _scale_ctag;
    BtagFunction* _eff_ctag;

    BtagFunction* _scale_light;
    BtagFunction* _eff_light;
};

#endif
Revision:	1.8
Committed:	Thu Feb 14 21:22:59 2013 UTC (12 years, 2 months ago) by rkogler
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Makefile, v1-00, Feb-15-2013-v1, HEAD
Changes since 1.7:	+14 -1 lines
Error occurred while calculating annotation data.
Log Message:	updated treatment of sys uncertainties
#	Content
1	#ifndef MCDataScaleFactors_H
2	#define MCDataScaleFactors_H
3
4	#include "TF1.h"
5	#include <TGraphAsymmErrors.h>
6
7	#include "include/Utils.h"
8	#include "include/EventCalc.h"
9
10	/**
11	* @short module to apply data-MC lepton scale factors for trigger and ID
12	*
13	*
14	*/
15	class LeptonScaleFactors {
16	public:
17	/**
18	* constructor
19	*
20	* first argument: list of corrections to be applied together with weight factors for luminosity, example: "MuonRunA 1.5 MuonRunB 2.6 MuonRunC 7.8"
21	*
22	* second argument: systematic shift
23	* @see E_SystShift
24	*/
25	LeptonScaleFactors(std::vector<std::string> correctionlist);
26	///Default destructor
27	~LeptonScaleFactors() {};
28
29	///browse configuration and fill all requested correction factors
30	void FillWeights();
31
32	///return the total weight (muon*electron)
33	///derived from the weighted correction factor for muons (ID, trigger and isolation)
34	///and all electron weights
35	double GetWeight();
36
37	///return the weighted correction factor for muon ID
38	double GetMuonIDWeight();
39
40	///return the weighted correction factor for muon trigger
41	double GetMuonTrigWeight();
42
43	///return the weighted correction factor for muon isolation
44	double GetMuonIsoWeight();
45
46	///return the weighted correction factor for muons (ID, trigger and isolation)
47	double GetMuonWeight();
48
49	///return the weighted correction factor for electron trigger
50	double GetElectronTrigWeight();
51
52	///return the weighted correction factor for electrons (right now: only trigger)
53	double GetElectronWeight();
54
55	///check if the scale factors are up-to-date, fill them only once per run
56	///implemented for run-dependent scale factors
57	bool IsUpToDate();
58
59	/// return the bin number of the muon eta bin
60	int GetMuonEtaBin(double eta);
61
62	/// return the bin number of a graph corresponding to a certain value of the x coordinate
63	int GetBin(double x, TGraphAsymmErrors* graph);
64
65	void DoUpVarMuonSF(bool f=true){m_muon_unc=true; m_syst_shift=e_Up;}
66	void DoDownVarMuonSF(bool f=true){m_muon_unc=true; m_syst_shift=e_Down;}
67
68	void DoUpVarEleSF(bool f=true){m_ele_unc=true; m_syst_shift=e_Up;}
69	void DoDownVarEleSF(bool f=true){m_ele_unc=true; m_syst_shift=e_Down;}
70
71	void DoUpVarTauSF(bool f=true){m_tau_unc=true; m_syst_shift=e_Up;}
72	void DoDownVarTauSF(bool f=true){m_tau_unc=true; m_syst_shift=e_Down;}
73
74
75	private:
76	E_SystShift m_syst_shift;
77	std::vector<std::pair<std::string, double> > m_correctionlist;
78	bool m_apply; // should any scale factors be applied?
79	bool m_muon_unc; // do shift of muon scale factors
80	bool m_ele_unc; // do shift of electron scale factors
81	bool m_tau_unc; // do shift of tau scale factors
82	int m_current_run; // run for which the scale factors are valid
83	std::vector< std::vector<TGraphAsymmErrors*> > m_mu_id; // two arrays: first index stands for eta bin, second for run period
84	std::vector< std::vector<TGraphAsymmErrors*> > m_mu_trig; // two arrays: first index stands for eta bin, second for run period
85	std::vector< std::vector<TGraphAsymmErrors*> > m_mu_iso; // two arrays: first index stands for eta bin, second for run period
86	std::vector<double> m_weights; // weights for different runs
87	std::vector<double> m_ele_trig; // two-parameter function of relative isolation times additional weight
88
89	};
90
91
92	/**
93	* @short modules to apply data-MC btagging corrections
94	*
95	*
96	*/
97
98
99	class BtagFunction {
100	public:
101	BtagFunction(E_BtagType btagtype) {
102	m_btagtype = btagtype;
103	}
104
105	virtual ~BtagFunction() {
106	};
107
108	virtual float value(const float &x) const = 0;
109	virtual float value_plus(const float &x) const = 0;
110	virtual float value_minus(const float &x) const = 0;
111
112	protected:
113	E_BtagType m_btagtype;
114	};
115
116
117	class BtagScale: public BtagFunction {
118	public:
119
120	BtagScale(E_BtagType);
121
122	virtual float value(const float &jet_pt) const;
123	virtual float value_plus(const float &jet_pt) const {
124	return value(jet_pt) + error(jet_pt);
125	}
126
127	virtual float value_minus(const float &jet_pt) const {
128	const float value_ = value(jet_pt) - error(jet_pt);
129	return value_ > 0 ? value_ : 0;
130	}
131
132	protected:
133
134	virtual float error(const float &jet_pt) const;
135
136	private:
137
138	TF1 * _scale;
139	std::vector<float> _errors;
140	std::vector<float> _bins;
141	const unsigned int find_bin(const float &jet_pt) const;
142	};
143
144
145	class CtagScale: public BtagScale {
146	public:
147
148	CtagScale(E_BtagType btagtype) : BtagScale(btagtype) {}
149
150	protected:
151
152	virtual float error(const float &jet_pt) const;
153
154	};
155
156
157	class LtagScale: public BtagFunction {
158	public:
159
160	LtagScale(E_BtagType btagtype);
161
162	virtual float value(const float &jet_pt) const;
163	virtual float value_plus(const float &jet_pt) const;
164	virtual float value_minus(const float &jet_pt) const;
165
166	private:
167
168	TF1 * _scale;
169	TF1 * _scale_plus;
170	TF1 * _scale_minus;
171
172	};
173
174
175	class BtagEfficiency: public BtagFunction {
176	public:
177
178	BtagEfficiency(E_BtagType, E_LeptonSelection);
179
180	virtual float value(const float &jet_pt) const;
181	virtual float value_plus(const float &jet_pt) const {
182	return value(jet_pt);
183	}
184
185	virtual float value_minus(const float &jet_pt) const {
186	return value(jet_pt);
187	}
188
189	protected:
190
191	const unsigned int find_bin(const float &jet_pt) const;
192	std::vector<float> _values;
193	std::vector<float> _bins;
194
195	};
196
197
198	class CtagEfficiency: public BtagEfficiency {
199	public:
200
201	CtagEfficiency(E_BtagType, E_LeptonSelection);
202
203	};
204
205
206	class LtagEfficiency: public BtagEfficiency {
207	public:
208
209	LtagEfficiency(E_BtagType, E_LeptonSelection);
210
211	};
212
213
214	/**
215	* @short module to apply data-MC scale factors for b tagging
216	*
217	*
218	*/
219	class BTaggingScaleFactors {
220	public:
221	/**
222	* constructor
223	*
224	* second argument: systematic shift
225	* @see E_SystShift
226	*/
227	BTaggingScaleFactors(
228	E_BtagType, E_LeptonSelection, E_SystShift sys_bjets=e_Default, E_SystShift sys_ljets=e_Default
229	);
230	///Default destructor
231	~BTaggingScaleFactors() {};
232
233	///return the weighted correction factor
234	double GetWeight();
235
236	private:
237
238	E_SystShift m_sys_bjets;
239	E_SystShift m_sys_ljets;
240	E_BtagType m_btagtype;
241	E_LeptonSelection m_lepton_selection;
242
243	float scale(const bool &is_tagged,
244	const float &jet_pt,
245	const BtagFunction* sf,
246	const BtagFunction* eff,
247	const E_SystShift &sytematic);
248
249	float scale_data(const bool &is_tagged,
250	const float &jet_pt,
251	const BtagFunction* sf,
252	const BtagFunction* eff,
253	const E_SystShift &sytematic);
254
255	BtagFunction* _scale_btag;
256	BtagFunction* _eff_btag;
257
258	BtagFunction* _scale_ctag;
259	BtagFunction* _eff_ctag;
260
261	BtagFunction* _scale_light;
262	BtagFunction* _eff_light;
263	};
264
265	#endif