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 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 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)