def __init__(self, cfg_ana, cfg_comp, looperName):
self.conf = cfg_ana._conf
self.algo = self.conf.jets["btagAlgo"]
tf = ROOT.TFile.Open( self.conf.bran["pdfFile"], "READ" )
h3_b = tf.Get(self.algo + "_b_pt_eta")
h3_c = tf.Get(self.algo + "_c_pt_eta")
h3_l = tf.Get(self.algo + "_l_pt_eta")
#print h3_b, h3_c, h3_l, tf.Get("csv_s_pt_eta"), tf.Get("csv_u_pt_eta"), tf.Get("csv_g_pt_eta")
btag_pdfs = maptype()
btag_pdfs[MEM.DistributionType.csv_b] = h3_b
btag_pdfs[MEM.DistributionType.csv_c] = h3_c
btag_pdfs[MEM.DistributionType.csv_l] = h3_l
if tf.Get(self.algo + "_s_pt_eta") != None:
btag_pdfs[MEM.DistributionType.csv_s] = tf.Get(self.algo + "_s_pt_eta")
if tf.Get(self.algo + "_u_pt_eta") != None:
btag_pdfs[MEM.DistributionType.csv_u] = tf.Get(self.algo + "_u_pt_eta")
if tf.Get(self.algo + "_g_pt_eta") != None:
btag_pdfs[MEM.DistributionType.csv_g] = tf.Get(self.algo + "_g_pt_eta")
self.rnd = MEM.BTagRandomizer(0, 1, btag_pdfs, 1)
self.btagWP = self.conf.jets["btagWPs"][self.conf.jets["btagWP"]][1]
self.jet_categories = []
for cat in self.conf.bran["jetCategories"].items():
jetcat = MEM.JetCategory(cat[1][0], cat[1][1], self.btagWP, cat[1][2], cat[0] )
self.jet_categories.append( jetcat )
self.vec_jet_categories = vectype()
for jc in self.jet_categories:
self.vec_jet_categories.push_back(jc)
super(BTagRandomizerAnalyzer, self).__init__(cfg_ana, cfg_comp, looperName)
def add_obj(integrator, objtype, **kwargs):
"""
Add an event object (jet, lepton, MET) to the ME integrator.
objtype: specifies the object type
kwargs: p4s: spherical 4-momentum (pt, eta, phi, M) as a tuple
obsdict: dict of additional observables to pass to MEM
tf_dict: Dictionary of MEM.TFType->TF1 of transfer functions
"""
if kwargs.has_key("p4s"):
pt, eta, phi, mass = kwargs.pop("p4s")
v = ROOT.TLorentzVector()
v.SetPtEtaPhiM(pt, eta, phi, mass)
elif kwargs.has_key("p4c"):
v = ROOT.TLorentzVector(*kwargs.pop("p4c"))
obs_dict = kwargs.pop("obs_dict", {})
tf_dict = kwargs.pop("tf_dict", {})
o = MEM.Object(v, objtype)
#Add observables from observable dictionary
for k, v in obs_dict.items():
o.addObs(k, v)
for k, v in tf_dict.items():
o.addTransferFunction(k, v)
integrator.push_back_object(o)
def __init__(self, conf):
self.cfg = MEM.MEMConfig()
#Specify the MEM precision.
self.cfg.defaultCfg(conf.mem["n_integration_points_mult"])
self.cfg.save_permutations = True
self.b_quark_candidates = lambda event: event.selected_btagged_jets_high
self.l_quark_candidates = lambda event: event.wquark_candidate_jets
self.lepton_candidates = lambda event: event.good_leptons
self.met_candidates = lambda event: event.MET
self.cfg.transfer_function_method = MEM.TFMethod.External
self.do_calculate = lambda event, config: False
self.mem_assumptions = set([])
self.maxBJets = 4
self.maxLJets = 5
self.btagMethod = "btagCSV"
def add_obj(mem, typ, **kwargs):
if kwargs.has_key("p4s"):
pt, eta, phi, mass = kwargs.pop("p4s")
v = TLorentzVector()
v.SetPtEtaPhiM(pt, eta, phi, mass)
elif kwargs.has_key("p4c"):
v = TLorentzVector(*kwargs.pop("p4c"))
obsdict = kwargs.pop("obsdict", {})
o = MEM.Object(v, typ)
if typ == MEM.ObjectType.Jet:
tb, tl = attach_jet_transfer_function(v.Pt(), v.Eta())
o.addTransferFunction(MEM.TFType.qReco, tl)
o.addTransferFunction(MEM.TFType.bReco, tb)
for k, v in obsdict.items():
o.addObs(k, v)
mem.push_back_object(o)
def __init__(self, cfg_ana, cfg_comp, looperName):
self.conf = cfg_ana._conf
super(MEAnalyzer, self).__init__(cfg_ana, cfg_comp, looperName)
self.mem_configs = self.conf.mem_configs
for k, v in self.mem_configs.items():
#v.configure_btag_pdf(self.conf)
v.configure_transfer_function(self.conf)
self.memkeysToRun = self.conf.mem["methodsToRun"]
#Create an empty vector for the integration variables
self.vars_to_integrate = CvectorPSVar()
self.vars_to_marginalize = CvectorPSVar()
cfg = MEMConfig(self.conf)
#cfg.configure_btag_pdf(self.conf)
cfg.configure_transfer_function(self.conf)
self.integrator = MEM.Integrand(
MEM.output, #verbosity level
cfg.cfg)
def add_obj(mem, typ, **kwargs):
if kwargs.has_key("p4s"):
pt, eta, phi, mass = kwargs.pop("p4c")
v = TLorentzVector()
v.SetPtEtaPhiM(pt, eta, phi, mass)
elif kwargs.has_key("p4c"):
v = TLorentzVector(*kwargs.pop("p4c"))
obsdict = kwargs.pop("obsdict", {})
o = MEM.Object(v, typ)
t1 = kwargs.get("tf", None)
if t1 != None:
o.addTransferFunction(MEM.TFType.qReco, t1)
o.addTransferFunction(MEM.TFType.bReco, t1)
o.addTransferFunction(MEM.TFType.qLost, t1)
o.addTransferFunction(MEM.TFType.bLost, t1)
for k, v in obsdict.items():
o.addObs(k, v)
mem.push_back_object(o)
def _process(self, event):
if "debug" in self.conf.general["verbosity"]:
autolog("BTagRandomizer started")
event.b_ran_results = []
for jet in event.good_jets:
add_obj(
self.rnd,
MEM.ObjectType.Jet,
p4s=(jet.pt, jet.eta, jet.phi, jet.mass),
obs_dict={
MEM.Observable.BTAG: getattr(jet, self.algo) > self.btagWP,
MEM.Observable.PDGID: jet.mcFlavour,
MEM.Observable.CSV: getattr(jet, self.algo)
}
)
run_vec_jet_categories = vectype()
posrun = []
pos = -1
for jc in self.vec_jet_categories:
pos += 1
jc.seed = (event.input.evt + event.input.lumi*jc.tag)
if jc.ntags_l <= event.numJets:
run_vec_jet_categories.push_back(jc)
posrun.append( pos )
if self.conf.bran["enabled"]:
ret = self.rnd.run_all(run_vec_jet_categories)
pos = -1
for jc in self.vec_jet_categories:
pos += 1
catname = jc.name_tag
catid = jc.tag
out = MEM.BTagRandomizerOutput()
wasrun = pos in posrun
if wasrun:
out = ret[ posrun.index(pos) ]
setattr(event, "b_rnd_results_"+catname, [out.p, out.ntoys, out.pass_rnd, out.tag_id] )
setattr(event, "b_inp_results_"+catname, [1.0, 0, getattr(out,"pass",0), out.tag_id] )
else:
setattr(event, "b_rnd_results_"+catname, [0,0,0,0] )
setattr(event, "b_inp_results_"+catname, [0,0,0,0] )
for j in range(event.numJets):
inpval = getattr(event.good_jets[j], self.algo)
rndval = inpval
if wasrun:
inpval = out.input_btag[j]
rndval = out.rnd_btag[j]
setattr(event.good_jets[j], "btagCSVInp"+catname, inpval )
setattr(event.good_jets[j], "btagCSVRnd"+catname, rndval )
countTags = 0
for jet in event.good_jets:
if wasrun and getattr( jet, "btagCSVRnd"+catname ) > self.btagWP:
countTags += 1
setattr(event, "nBCSVMRnd"+catname, countTags)
self.rnd.next_event();
event.passes_bran = True
return event
import ROOT
ROOT.gSystem.Load("libTTHMEIntegratorStandalone")
from ROOT import MEM
jlh = MEM.JetLikelihood()
Cvectoruint = getattr(ROOT, "std::vector<unsigned int>")
for i in range(2):
jp1 = ROOT.MEM.JetProbability()
jp1.setProbability(MEM.JetInterpretation.l, 0.2)
jp1.setProbability(MEM.JetInterpretation.b, 0.8)
jp2 = ROOT.MEM.JetProbability()
jp2.setProbability(MEM.JetInterpretation.l, 0.2)
jp2.setProbability(MEM.JetInterpretation.b, 0.8)
jlh.push_back_object(jp1)
jlh.push_back_object(jp2)
bperm = Cvectoruint()
print jlh.calcProbability(MEM.JetInterpretation.b, MEM.JetInterpretation.l,
0, bperm)
print jlh.calcProbability(MEM.JetInterpretation.b, MEM.JetInterpretation.l,
1, bperm)
print jlh.calcProbability(MEM.JetInterpretation.b, MEM.JetInterpretation.l,
2, bperm)
print bperm.size(), [bperm.at(i) for i in range(bperm.size())]
jlh.next_event()
def _process(self, event):
if "debug" in self.conf.general["verbosity"]:
autolog("MEMAnalyzer started")
#Clean up any old MEM state
self.vars_to_integrate.clear()
self.vars_to_marginalize.clear()
self.integrator.next_event()
#Initialize members for tree filler
event.mem_results_tth = []
event.mem_results_ttbb = []
res = {}
if "meminput" in self.conf.general["verbosity"]:
print "-----"
print "MEM id={0},{1},{2} cat={3} cat_b={4} nj={5} nt={6} nel={7} nmu={8} syst={9}".format(
event.input.run,
event.input.lumi,
event.input.evt,
event.is_sl,
event.is_dl,
event.cat,
event.cat_btag,
event.numJets,
event.nBCSVM,
event.n_el_SL,
event.n_mu_SL,
getattr(event, "systematic", None),
getattr(event, "systematic", None),
)
for hypo in [MEM.Hypothesis.TTH, MEM.Hypothesis.TTBB]:
skipped = []
for confname in self.memkeysToRun:
mem_cfg = self.conf.mem_configs[confname]
fstate = MEM.FinalState.Undefined
if "dl" in mem_cfg.mem_assumptions:
fstate = MEM.FinalState.LL
elif "sl" in mem_cfg.mem_assumptions:
fstate = MEM.FinalState.LH
elif "fh" in mem_cfg.mem_assumptions:
fstate = MEM.FinalState.HH
else:
if confname in self.memkeysToRun:
raise ValueError(
"Need to specify sl, dl of fh in assumptions but got {0}"
.format(str(mem_cfg.mem_assumptions)))
else:
res[(hypo, confname)] = MEM.MEMOutput()
continue
#if "meminput" in self.conf.general["verbosity"]:
if ("meminput" in self.conf.general["verbosity"]
or "debug" in self.conf.general["verbosity"]):
autolog(
"MEMconf={0} fstate={1} MEMCand[l={2} b={3} q={4}] Reco[j={5} b={6} bLR={7}] MEMconf.doCalc={8} event.selection={9} toBeRun={10} isMC={11}"
.format(confname, fstate,
len(mem_cfg.lepton_candidates(event)),
len(mem_cfg.b_quark_candidates(event)),
len(mem_cfg.l_quark_candidates(event)),
event.numJets, event.nBCSVM,
event.btag_LR_4b_2b,
mem_cfg.do_calculate(event, mem_cfg),
self.conf.mem["selection"](event), confname
in self.memkeysToRun, self.cfg_comp.isMC))
#Run MEM if we did not explicitly disable it
if (self.conf.mem["calcME"]
and mem_cfg.do_calculate(event, mem_cfg)
and self.conf.mem["selection"](event)
and confname in self.memkeysToRun):
print "Integrator::run started hypo={0} conf={1} run:lumi:evt={2}:{3}:{4} {5} blr={6}".format(
hypo, confname, event.input.run, event.input.lumi,
event.input.evt, event.category_string,
event.btag_LR_4b_2b)
print "Integrator conf: b={0} l={1}".format(
len(mem_cfg.b_quark_candidates(event)),
len(mem_cfg.l_quark_candidates(event)))
self.configure_mem(event, mem_cfg)
r = self.integrator.run(fstate, hypo,
self.vars_to_integrate,
self.vars_to_marginalize)
print "Integrator::run done hypo={0} conf={1} cat={2}".format(
hypo, confname, event.cat) #DS
res[(hypo, confname)] = r
else:
skipped += [confname]
r = MEM.MEMOutput()
res[(hypo, confname)] = r
if "meminput" in self.conf.general["verbosity"]:
print "skipped confs", skipped
#Add MEM results to event
for key in self.memkeysToRun:
for (hypo_name, hypo) in [("tth", MEM.Hypothesis.TTH),
("ttbb", MEM.Hypothesis.TTBB)]:
mem_res = res[(hypo, key)]
setattr(event, "mem_{0}_{1}".format(hypo_name, key), mem_res)
#Create MEM permutations
perms = []
for iperm in range(mem_res.num_perm):
perm = mem_res.permutation_indexes[iperm]
v_p = normalize_proba(
[v for v in mem_res.permutation_probas[iperm]])
v_p_tf = normalize_proba([
v for v in mem_res.permutation_probas_transfer[iperm]
])
v_p_me = normalize_proba(
[v for v in mem_res.permutation_probas_me[iperm]])
mem_perm = MEMPermutation(
iperm,
[_p for _p in perm],
np.mean(v_p),
np.std(v_p),
np.mean(v_p_tf),
np.std(v_p_tf),
np.mean(v_p_me),
np.std(v_p_me),
)
perms += [mem_perm]
setattr(event, "mem_{0}_{1}_perm".format(hypo_name, key),
perms)
#print out the JSON format for the standalone integrator
for confname in self.memkeysToRun:
mem_cfg = self.mem_configs[confname]
if "commoninput" in self.conf.general[
"verbosity"] and mem_cfg.do_calculate(event, mem_cfg):
self.printInputs(event, confname)
event.passes_mem = True
return event
import ROOT
ROOT.gSystem.Load("libFWCoreFWLite")
ROOT.gROOT.ProcessLine('AutoLibraryLoader::enable();')
ROOT.gSystem.Load("libFWCoreFWLite")
ROOT.gSystem.Load("libCintex")
ROOT.gROOT.ProcessLine('ROOT::Cintex::Cintex::Enable();')
ROOT.gSystem.Load("libTTHMEIntegratorStandalone")
from ROOT import MEM
from ROOT import TLorentzVector
import math
CvectorPermutations = getattr(ROOT, "std::vector<MEM::Permutations::Permutations>")
CvectorPSVar = getattr(ROOT, "std::vector<MEM::PSVar::PSVar>")
cfg = MEM.MEMConfig()
cfg.defaultCfg()
cfg.transfer_function_method = MEM.TFMethod.Builtin
infiles = sys.argv[1:]
#enum DebugVerbosity { output=1, input=2, init=4, init_more=8, event=16, integration=32};
verbosity = 3+4
try:
pi_file = open("testdata/transfers.pickle", 'rb')
tf_matrix = pickle.load(pi_file)
except Exception as e:
print e
tf_matrix = None
for nb in [0, 1]:
tf_matrix = pickle.load(pi_file)
pi_file.close()
#set transfer functions on config objects
map(configure_transfer_function, confs)
events = map(json.loads, inlines)
for jsev in events:
results_d = {}
results_d["evt"] = jsev["input"]["evt"]
results_d["run"] = jsev["input"]["run"]
results_d["lumi"] = jsev["input"]["lumi"]
for cfg in confs:
mem = MEM.Integrand(MEM.output, cfg)
jets_p4 = jsev["input"]["selectedJetsP4"]
jets_csv = jsev["input"]["selectedJetsCSV"]
jets_btag = jsev["input"]["selectedJetsBTag"]
njet = 0
nlep = 0
for p4, btag in zip(jets_p4, jets_btag):
if cfg.do_add_jet(p4, btag):
add_obj(
mem,
MEM.ObjectType.Jet,
p4s=p4,
obsdict={MEM.Observable.BTAG: btag},
)
njet += 1
import ROOT
ROOT.gSystem.Load("libFWCoreFWLite")
ROOT.gROOT.ProcessLine('AutoLibraryLoader::enable();')
ROOT.gSystem.Load("libFWCoreFWLite")
ROOT.gSystem.Load("libCintex")
ROOT.gROOT.ProcessLine('ROOT::Cintex::Cintex::Enable();')
ROOT.gSystem.Load("libTTHMEIntegratorStandalone")
from ROOT import MEM
from ROOT import TLorentzVector
import math
cfg = MEM.MEMConfig()
cfg.transfer_function_method = MEM.TFMethod.External
mem = MEM.Integrand(MEM.output, cfg)
print mem
def add_obj(mem, typ, **kwargs):
if kwargs.has_key("p4s"):
pt, eta, phi, mass = kwargs.pop("p4c")
v = TLorentzVector()
v.SetPtEtaPhiM(pt, eta, phi, mass)
elif kwargs.has_key("p4c"):
v = TLorentzVector(*kwargs.pop("p4c"))
obsdict = kwargs.pop("obsdict", {})
o = MEM.Object(v, typ)
t1 = kwargs.get("tf", None)