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 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 run(self):
            wrp = tmpl_fit.get_merged_sbbkg_histo(sample)

            # multiply with weight
            if tmpl_fit.do_dist_reweighting:
                wrp = gen.op.prod((
                    settings.post_proc_dict["TemplateFitToolChHadIsoSbBkgInputBkgWeight"],
                    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
                )
            )
    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 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
                )
            )