def makeSysSamplesBTagWeight():
mc_samples = settings.mc_samples()
for name in mc_samples.iterkeys():
makeSysSample(
name,
name + "_BTagWeightBCMinus",
{}
)
makeSysSample(
name,
name + "_BTagWeightBCPlus",
{}
)
makeSysSample(
name,
name + "_BTagWeightUDSGMinus",
{}
)
makeSysSample(
name,
name + "_BTagWeightUDSGPlus",
{}
)
settings.samples[name + "_BTagWeightBCMinus"].cfg_add_lines += (
"process.bTagWeight.errorModeBC = -1",
)
settings.samples[name + "_BTagWeightBCPlus"].cfg_add_lines += (
"process.bTagWeight.errorModeBC = +1",
)
settings.samples[name + "_BTagWeightUDSGMinus"].cfg_add_lines += (
"process.bTagWeight.errorModeUDSG = -1",
)
settings.samples[name + "_BTagWeightUDSGPlus"].cfg_add_lines += (
"process.bTagWeight.errorModeUDSG = +1",
)
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 makeSysSamplesPU():
mc_samples = settings.mc_samples()
for name in mc_samples.iterkeys():
makeSysSample(
name,
name + "_PU",
{"puWeightInput": "PU_Run2012_73500.root"}
)
def get_shilp_counts(self, c):
data_lumi_sum = settings.data_lumi_sum()
for smp in settings.mc_samples().itervalues():
norm = data_lumi_sum / smp.lumi
tight = smp.log_event_counts[self.tight_cnt] * norm
real = smp.log_event_counts["realFullTightIDCount,"] * norm
c.tight += tight
c.shilp += tight - real
def makeSysSamplesTrig():
mc_samples = settings.mc_samples()
for name in mc_samples.iterkeys():
makeSysSample(
name,
name + "_TrigPlus",
{}
)
makeSysSample(
name,
name + "_TrigMinus",
{}
)
settings.samples[name + "_TrigPlus"].cfg_add_lines += (
"process.trigWeight.uncertMode = 1",
)
settings.samples[name + "_TrigMinus"].cfg_add_lines += (
"process.trigWeight.uncertMode = -1",
)
def get_purity_counts(self, c):
for smp in settings.mc_samples().itervalues():
l = smp.legend
c.mc_sum += smp.log_event_counts[self.cnt_name] / smp.lumi
if l == "t#bar{t}#gamma (Signal)":
c.mc_ttgam += smp.log_event_counts[self.cnt_name] / smp.lumi
def run(self):
self.configure()
if not self.n_sig_ttgam_wrp:
self.message("WARNING Did not find result in post_proc_dict. Skipping...")
return
# store results in wrapper
r = copy.deepcopy(self.n_sig_ttgam_wrp)
r.name = self.name
self.result = r
# prepare mc counts
class counts(object): pass
c = counts()
c.sig_pre = 0.
c.sig_fid = 0.
c.sig_post = 0.
c.bkg_pre = 0.
c.bkg_post = 0.
c.tt_pre = 0.
c.tt_post = 0
for smp in settings.mc_samples().itervalues():
legend = smp.legend
if legend == "t#bar{t}#gamma (Signal)":
c.sig_pre += smp.log_event_counts[self.get_sig_count_name(self.pre_count_name)] / smp.lumi
c.sig_fid += smp.log_event_counts[self.get_sig_count_name(self.fid_count_name)] / smp.lumi
c.sig_post += smp.log_event_counts[self.get_sig_count_name(self.post_count_name)] / smp.lumi
else:
c.bkg_pre += smp.log_event_counts[self.pre_count_name] / smp.lumi
c.bkg_post += smp.log_event_counts[self.post_count_name] / smp.lumi
if legend == "t#bar{t} inclusive":
c.tt_pre += smp.log_event_counts[self.pre_count_name] / smp.lumi
c.tt_post += smp.log_event_counts[self.post_count_name] / smp.lumi
data_lumi_sum = settings.data_lumi_sum()
for k in c.__dict__.keys():
c.__dict__[k] *= data_lumi_sum
# prepare data counts
c.data_pre = 0.
c.data_post = 0.
for smp in settings.data_samples().itervalues():
c.data_pre += smp.log_event_counts[self.pre_count_name]
c.data_post += smp.log_event_counts[self.post_count_name]
# selection performance
r.eff_gamma = c.sig_post / c.sig_fid
r.eff_gamma_fid = c.sig_fid / c.sig_pre
r.pur_tt = (c.tt_pre + c.sig_pre) / (c.bkg_pre + c.sig_pre)
r.N_presel_data = c.data_pre
r.N_sel_data = c.data_post
r.StoB_gamma = c.sig_post / c.bkg_post
r.StoB_presel = c.tt_pre / (c.bkg_pre - c.tt_pre)
# background-substracted number of ttgamma signal events
# r.n_sig_ttgam = self.n_sig_ttgam_wrp.n_sig_ttgam
# R_fid
R_fid_denom = r.eff_gamma * r.N_presel_data * r.pur_tt
r.R_fid = r.n_sig_ttgam / R_fid_denom
r.R_fid_err_stat= r.n_sig_ttgam_err / R_fid_denom
# R
R_denom = r.eff_gamma_fid * r.eff_gamma * r.N_presel_data * r.pur_tt
r.R = r.n_sig_ttgam / R_denom
r.R_err_stat = r.n_sig_ttgam_err / R_denom
# xsec
r.xsec = r.R * settings.ttbar_xsec_cms
r.xsec_err_stat = r.xsec * r.R_err_stat / r.R
self.message(str(r))
def prepare_for_systematic(self):
mc_samples = settings.mc_samples().keys()
da_samples = settings.data_samples().keys()
pu_samples = list(s + "_TrigMinus" for s in mc_samples)
settings.active_samples = pu_samples + da_samples
super(SysTrigMinus, self).prepare_for_systematic()
def prepare_for_systematic(self):
mc_samples = settings.mc_samples().keys()
da_samples = settings.data_samples().keys()
btag_samples = list(s + "_BTagWeightUDSGPlus" for s in mc_samples)
settings.active_samples = btag_samples + da_samples
super(SysBTagWeightUDSGPlus, self).prepare_for_systematic()
def get_shilp_counts(self, c):
data_lumi_sum = settings.data_lumi_sum()
for smp in settings.mc_samples().itervalues():
norm = data_lumi_sum / smp.lumi
c.tight += smp.log_event_counts[self.tight_cnt] * norm
c.shilp += smp.log_event_counts[self.shilp_cnt] * norm
import cmstoolsac3b.main as main
import cmstoolsac3b.settings as settings
settings.ttbar_xsec = 245.8
settings.ttbar_xsec_err = 2.6 * settings.ttbar_xsec
from cmstoolsac3b.sample import load_samples
import MyPackage.TtGamma8TeV.samples_cern as samples_cern
settings.samples = {}
settings.samples.update(load_samples(samples_cern))
settings.active_samples = settings.samples.keys() # add all MC and data
settings.samples = dict(settings.mc_samples())
settings.active_samples = settings.samples.keys()
settings.cfg_main_import_path="MyPackage.ShilpiNTuple.cfg_produce_ntuple"
settings.try_reuse_results = True
settings.max_num_processes = 4
if __name__ == '__main__':
main.main()