Пример #1
0
 def run(self):
         top_sample = next(s for s in settings.active_samples if s[:2] == "TT")
         wrp_fake = next(rebin_chhadiso(gen.fs_filter_sort_load({
             "analyzer": "TemplateChHadIsoreal",
             "sample":   top_sample,#"TTMadG",
         })))
         wrp_sb = gen.op.merge(rebin_chhadiso(gen.fs_filter_sort_load({
             "analyzer": "TemplateRandConereal",
             "sample": top_sample,#"TTMadG",
         })))
         wrp = gen.op.div((
             gen.op.norm_to_integral(wrp_fake),
             gen.op.norm_to_integral(wrp_sb),
         ))
         wrp.lumi = 1.
         wrp.draw_option = "E1"
         self.result = wrp
         cnvs = list(gen.canvas(((wrp,),)),)
         cnvs[0].canvas.SetGridy(1)
         gen.consume_n_count(
             gen.save(
                 cnvs,
                 lambda c: self.plot_output_dir + c.name
             )
         )
         del wrp.draw_option
Пример #2
0
    def test_gen_fs_filter_sort_load(self):
        wrps = list(gen.fs_filter_sort_load({"name": "cutflow", "sample": ["ttgamma", "tt"]}))
        s_is_data = map(lambda x: x.is_data, wrps)

        # just check for sorting and overall length
        self.assertTrue(s_is_data.index(False) < s_is_data.index(True))
        self.assertEqual(len(wrps), 2)
        self.assertEqual(wrps[1].lumi, 3.0)
Пример #3
0
    def test_gen_fs_filter_sort_load(self):
        wrps = list(
            gen.fs_filter_sort_load({
                "name": "cutflow",
                "sample": ["ttgamma", "tt"]
            }))
        s_is_data = map(lambda x: x.is_data, wrps)

        # just check for sorting and overall length
        self.assertTrue(s_is_data.index(False) < s_is_data.index(True))
        self.assertEqual(len(wrps), 2)
        self.assertEqual(wrps[1].lumi, 3.0)
Пример #4
0
 def set_up_stacking(self):
     mc_tmplts = gen.fs_filter_sort_load({
         "sample"    : self.sample_name,
         "analyzer"  : ("TemplateChHadIsofake", "PlotSBID")
     })
     sb_wrp = get_merged_sbbkg_histo(self.sample_name)
     mc_tmplts = [sb_wrp] + list(mc_tmplts)
     mc_tmplts = gen.gen_norm_to_integral(mc_tmplts)
     mc_tmplts = cosmetica1(mc_tmplts)
     mc_tmplts = rebin_chhadiso(mc_tmplts)
     mc_tmplts = gen.apply_histo_linecolor(mc_tmplts, [625, 618, 596])
     mc_tmplts = apply_overlay_draw_mode(mc_tmplts)
     mc_tmplts = gen.group(mc_tmplts, key_func=lambda w: w.sample)
     self.stream_stack = mc_tmplts
Пример #5
0
 def set_up_stacking(self):
     def sum_up_two(wrps):
         while True:
             try:
                 h = gen.op.sum((next(wrps), next(wrps)))
             except StopIteration:
                 return
             yield h
     mc_tmplts = list(sum_up_two(gen.fs_filter_sort_load({
         "sample"    : self.sample_name,
         "analyzer"  : re.compile("PlotLooseIDSliceSihihSB"),
         })))
     mc_tmplts = itertools.chain(gen.fs_filter_sort_load({
         "sample"    : self.sample_name,
         "analyzer"  : "TemplateChHadIsofake",
         }),
         mc_tmplts
     )
     mc_tmplts = gen.gen_norm_to_integral(mc_tmplts)
     mc_tmplts = cosmetica1(mc_tmplts)
     mc_tmplts = rebin_chhadiso(mc_tmplts)
     mc_tmplts = gen.apply_histo_linecolor(mc_tmplts, [409, 625, 618, 596, 430])
     mc_tmplts = gen.group(mc_tmplts, key_func=lambda w: w.sample)
     self.stream_stack = mc_tmplts
Пример #6
0
    def test_gen_save(self):
        wrps = gen.fs_filter_sort_load({"name": "cutflow", "sample": ["zjets", "ttgamma"]})

        # create dir and go
        if not os.path.exists("test"):
            os.mkdir("test")
        gen.consume_n_count(gen.save(wrps, lambda w: "test/" + w.name + "_" + w.sample))

        # check the new files
        self.assertTrue(os.path.exists("test/cutflow_ttgamma.root"))
        self.assertTrue(os.path.exists("test/cutflow_ttgamma.info"))
        self.assertTrue(os.path.exists("test/cutflow_zjets.root"))
        self.assertTrue(os.path.exists("test/cutflow_zjets.info"))
        self.tfile = TFile.Open("test/cutflow_ttgamma.root")
        self.assertTrue(self.tfile.GetKey("histo"))
Пример #7
0
 def set_up_stacking(self):
     mc_tmplts = gen.fs_filter_sort_load({
         "sample"    : ("whiz2to5", "TTGamRD1"),
         "analyzer"  : "TemplateChHadIsoreal",
         })
     mc_tmplts = gen.gen_norm_to_integral(mc_tmplts)
     mc_tmplts = cosmetica1(mc_tmplts)
     def leg(wrps):
         for w in wrps:
             w.legend = w.sample
             w.draw_option = "E1"
             w.histo.SetMarkerStyle(24)
             yield w
     mc_tmplts = leg(mc_tmplts)
     mc_tmplts = rebin_chhadiso(mc_tmplts)
     mc_tmplts = gen.apply_histo_linecolor(mc_tmplts, [409, 625, 618, 596, 430])
     mc_tmplts = gen.group(mc_tmplts, key_func=lambda w: w.analyzer)
     self.stream_stack = mc_tmplts
Пример #8
0
    def test_gen_save(self):
        wrps = gen.fs_filter_sort_load({
            "name": "cutflow",
            "sample": ["zjets", "ttgamma"]
        })

        # create dir and go
        if not os.path.exists("test"):
            os.mkdir("test")
        gen.consume_n_count(
            gen.save(wrps, lambda w: "test/" + w.name + "_" + w.sample))

        # check the new files
        self.assertTrue(os.path.exists("test/cutflow_ttgamma.root"))
        self.assertTrue(os.path.exists("test/cutflow_ttgamma.info"))
        self.assertTrue(os.path.exists("test/cutflow_zjets.root"))
        self.assertTrue(os.path.exists("test/cutflow_zjets.info"))
        self.tfile = TFile.Open("test/cutflow_ttgamma.root")
        self.assertTrue(self.tfile.GetKey("histo"))
        def run(self):
            wrps = tmpl_fit.rebin_chhadiso(gen.fs_filter_sort_load({
                "analyzer": "PlotSBID",
                "sample": sample,
            }))
            wrp = gen.op.merge(wrps)

            # multiply with weight
            if tmpl_fit.do_dist_reweighting:
                wrp = gen.op.prod((
                    settings.post_proc_dict["TemplateFitToolChHadIsoSBIDInputBkgWeight"],
                    wrp,
                ))

            wrps = gen.gen_norm_to_data_lumi((wrp,))
            wrps = list(wrps)
            self.result = wrps
            gen.consume_n_count(
                gen.save(
                    gen.canvas((wrps,)),
                    lambda c: self.plot_output_dir + c.name
                )
            )
Пример #10
0
def get_merged_sbbkg_histo(sample):
    wrps = rebin_chhadiso(gen.fs_filter_sort_load({
        "analyzer": sb_anzlrs,
        "sample": sample,
    }))
    return gen.op.merge(wrps)