def test_gen_filter(self):
import re
aliases = list(gen.fs_content())
data = gen.filter(aliases, {"is_data": True})
tmplt = gen.filter(aliases, {"analyzer": "fakeTemplate"})
crtlplt = gen.filter(aliases, {"analyzer": re.compile("CrtlFilt*")})
crtlplt2 = gen.filter(aliases, {"analyzer": [re.compile("CrtlFilt*")]})
ttgam_cf = gen.filter(aliases, {"name": "cutflow", "sample": ["ttgamma", "tt"]})
self.assertEqual(gen.consume_n_count(data), 52)
self.assertEqual(gen.consume_n_count(tmplt), 9)
self.assertEqual(gen.consume_n_count(crtlplt), 39)
self.assertEqual(gen.consume_n_count(crtlplt2), 39)
self.assertEqual(gen.consume_n_count(ttgam_cf), 2)
def configure(self):
super(TemplateFitToolChHadIso, self).configure()
self.fitter = ThetaFitter()
self.fitbox_bounds = 0.33, 0.62, 0.88
self.mc_tmplts = gen.filter(
settings.post_proc_dict["TemplateStacks"], {
"analyzer" : ("TemplateChHadIsoreal", "PlotSBIDfake"),
}
)
self.fitted = rebin_chhadiso(
gen.fs_filter_active_sort_load({
"analyzer" : "TemplateChHadIso",
"is_data" : True,
})
)
self.gen_bkg_tmplt = iter(
settings.post_proc_dict["TemplateFitToolChHadIsoSBIDInputBkg"]
)
self.gen_sig_tmplt = rebin_chhadiso(
gen.gen_norm_to_data_lumi(
gen.fs_filter_active_sort_load({
"analyzer" : "TemplateChHadIsoreal",
"sample" : re.compile("whiz2to5"),
})
)
)
def configure(self):
super(TemplateFitToolChHadIso, self).configure()
self.fitter = Fitter()
self.fitbox_bounds = 0.33, 0.62, settings.defaults_Legend["y_pos"]
# here the stacked templates are taken for purity calculation
# but they are replaced in fetch_mc_templates(..)
self.mc_tmplts = gen.filter(
settings.post_proc_dict["TemplateStacks"], {
"analyzer" : ("TemplateChHadIsoreal", "TemplateChHadIsofake"),
})
self.fitted = rebin_chhadiso(
gen.fs_filter_active_sort_load({
"analyzer" : "TemplateChHadIso",
"is_data" : True,
})
)
ttbar_sample = next((
s.name
for s in settings.mc_samples().values()
if s.legend == "t#bar{t} inclusive"
))
self.gen_bkg_tmplt = rebin_chhadiso(
gen.gen_norm_to_data_lumi(
gen.fs_filter_active_sort_load({
"analyzer" : "TemplateChHadIsofake",
"sample" : ttbar_sample,
})))
self.gen_sig_tmplt = rebin_chhadiso(
gen.gen_norm_to_data_lumi(
gen.fs_filter_active_sort_load({
"analyzer" : "TemplateChHadIsoreal",
"sample" : re.compile("whiz2to5"),
})))
def test_gen_filter(self):
import re
aliases = list(gen.fs_content())
data = gen.filter(aliases, {"is_data": True})
tmplt = gen.filter(aliases, {"analyzer": "fakeTemplate"})
crtlplt = gen.filter(aliases, {"analyzer": re.compile("CrtlFilt*")})
crtlplt2 = gen.filter(aliases, {"analyzer": [re.compile("CrtlFilt*")]})
ttgam_cf = gen.filter(aliases, {
"name": "cutflow",
"sample": ["ttgamma", "tt"]
})
self.assertEqual(gen.consume_n_count(data), 52)
self.assertEqual(gen.consume_n_count(tmplt), 9)
self.assertEqual(gen.consume_n_count(crtlplt), 39)
self.assertEqual(gen.consume_n_count(crtlplt2), 39)
self.assertEqual(gen.consume_n_count(ttgam_cf), 2)
def test_gen_load(self):
aliases = gen.fs_content()
zjets_cutflow = gen.filter(aliases, {
"name": "cutflow",
"sample": "zjets"
})
wrp = gen.load(zjets_cutflow).next()
self.assertTrue(isinstance(wrp.histo, TH1F))
self.assertAlmostEqual(wrp.histo.Integral(), 2889.0)
def test_gen_sort(self):
aliases = list(gen.fs_content())
tmplt = gen.filter(aliases, {"analyzer": "fakeTemplate"})
sorted = list(gen.sort(tmplt))
s_name = map(lambda x: x.name, sorted)
s_sample = map(lambda x: x.sample, sorted)
s_is_data = map(lambda x: x.is_data, sorted)
self.assertTrue(s_sample.index("ttgamma") < s_sample.index("zjets"))
self.assertTrue(s_name.index("sihihEB") < s_name.index("sihihEE"))
self.assertTrue(s_is_data.index(False) < s_is_data.index(True))
def test_gen_sort(self):
aliases = list(gen.fs_content())
tmplt = gen.filter(aliases, {"analyzer": "fakeTemplate"})
sorted = list(gen.sort(tmplt))
s_name = map(lambda x: x.name, sorted)
s_sample = map(lambda x: x.sample, sorted)
s_is_data = map(lambda x: x.is_data, sorted)
self.assertTrue(s_sample.index("ttgamma") < s_sample.index("zjets"))
self.assertTrue(s_name.index("sihihEB") < s_name.index("sihihEE"))
self.assertTrue(s_is_data.index(False) < s_is_data.index(True))
def gen_mixer_input(input_dict):
for d in input_dict:
yield op.norm_to_integral(
op.merge(
list(
gen.load(
gen.filter(
gen.fs_content(),
d
)))))
def get_input_histos(self):
mcee = gen.gen_prod( # need to norm to lumi
itertools.izip(
gen.gen_norm_to_lumi(
gen.filter(
settings.post_proc_dict["CutflowHistos"],
{"is_data": False}
)
),
itertools.repeat(
settings.data_lumi_sum_wrp()
)
)
)
data = gen.filter(
settings.post_proc_dict["CutflowHistos"],
{"is_data": True}
)
self.input_mc = sorted(mcee, key = legend_key_func)
self.input_data = sorted(data, key = legend_key_func)
def configure(self):
super(TemplateFitToolSihih, self).configure()
# self.fitter = FractionFitter()
self.fitbox_bounds = 0.63, 0.93, 0.60
self.mc_tmplts = gen.filter(
settings.post_proc_dict["TemplateStacks"], {
"analyzer" : ("TemplateSihihreal", "TemplateSihihfake"),
})
self.fitted = gen.fs_filter_active_sort_load({
"analyzer" : "TemplateSihih",
"is_data" : True,
})
def set_up_stacking(self):
wrps = gen.pool_content()
wrps = gen.filter(
wrps,
{"analyzer": re.compile("CutFlow")}
)
wrps = gen.group(wrps)
stream_stack = gen.mc_stack_n_data_sum(
wrps,
use_all_data_lumi=True
)
def assign_name(wrp): wrp.name = "CombinedCutflow"
self.stream_stack = gen.pool_store_items(stream_stack, assign_name)
def test_gen_group(self):
from_fs = gen.fs_content()
filtered = gen.filter(from_fs, {"name": "histo"})
sorted = gen.sort(filtered)
grouped = gen.group(sorted)
group_list = []
for group in grouped:
group_list.append(list(group))
# length: 3 samples: 3 histos per group
self.assertEqual(len(group_list), 26)
for g in group_list:
self.assertEqual(len(g), 3)
self.assertEqual(g[0].analyzer, g[1].analyzer)
self.assertEqual(g[0].analyzer, g[2].analyzer)
def test_gen_group(self):
from_fs = gen.fs_content()
filtered = gen.filter(from_fs, {"name": "histo"})
sorted = gen.sort(filtered)
grouped = gen.group(sorted)
group_list = []
for group in grouped:
group_list.append(list(group))
# length: 3 samples: 3 histos per group
self.assertEqual(len(group_list), 26)
for g in group_list:
self.assertEqual(len(g), 3)
self.assertEqual(g[0].analyzer, g[1].analyzer)
self.assertEqual(g[0].analyzer, g[2].analyzer)
def run(self):
wrps = gen.fs_content()
wrps = gen.filter(
wrps,
{"analyzer": re.compile("CutFlow*")}
)
wrps = gen.filter_active_samples(wrps)
wrps = sorted(wrps, key = sample_key_func)
wrps = gen.load(wrps)
grps = gen.group(wrps, sample_key_func)
wrps = (self.combine_cutflow_histo(g) for g in grps)
wrps = gen.pool_store_items(wrps)
wrps = list(wrps)
self.result = wrps
count = len(wrps)
self.message("INFO: "+self.name+" stored "+str(count)+" histos in pool.")
def run(self):
wrp = next(rebin_chhadiso(
gen.gen_sum(
[gen.fs_filter_active_sort_load({
"analyzer" : "TemplateRandConereal",
"is_data" : True
})]
)
))
# normalize to mc expectation
integral_real = next(
gen.gen_integral(
gen.gen_norm_to_data_lumi(
gen.filter(
settings.post_proc_dict["TemplateStacks"],
{"analyzer": "TemplateRandConereal"}
)
)
)
)
print integral_real
wrp = gen.op.prod((
gen.op.norm_to_integral(wrp),
integral_real
))
# multiply with weight
if do_dist_reweighting:
wrp = gen.op.prod((
settings.post_proc_dict["TemplateFitToolRandConeIsoInputSigWeight"],
wrp,
))
wrp.lumi = settings.data_lumi_sum()
self.result = [wrp]
gen.consume_n_count(
gen.save(
gen.canvas((self.result,)),
lambda c: self.plot_output_dir + c.name
)
)
def set_up_stacking(self):
mc_tmplts = rebin_chhadiso(
gen.fs_filter_active_sort_load({
"analyzer" : all_analyzers,
})
)
mc_tmplts = gen.gen_norm_to_lumi(mc_tmplts)
mc_tmplts = gen.group(mc_tmplts)
def stack_with_purity_info(grps):
for grp in grps:
sub_tot_list = [0., 0.]
grp = list(com.count_ttgamma_photons(grp,sub_tot_list))
grp = gen.mc_stack((grp,))
grp = grp.next()
grp.sub_tot_list = sub_tot_list
yield grp
mc_tmplts = list(stack_with_purity_info(mc_tmplts))
mc_tmplts_plot = list(
gen.filter(mc_tmplts, {"analyzer": analyzers_mc})
)
self.result = mc_tmplts_plot
self.stream_stack = mc_tmplts_plot
def test_gen_load(self):
aliases = gen.fs_content()
zjets_cutflow = gen.filter(aliases, {"name": "cutflow", "sample": "zjets"})
wrp = gen.load(zjets_cutflow).next()
self.assertTrue(isinstance(wrp.histo, TH1F))
self.assertAlmostEqual(wrp.histo.Integral(), 2889.0)
