def get_roofit_model( histograms, fit_boundaries, name = 'model' ):
data_label = 'data'
samples = sorted( histograms.keys() )
samples.remove( data_label )
roofit_histograms = {}
roofit_pdfs = {}
roofit_variables = {}
variables = RooArgList()
variable_set = RooArgSet()
fit_variable = RooRealVar( name , name, fit_boundaries[0], fit_boundaries[1] )
variables.add( fit_variable )
variable_set.add( fit_variable )
roofit_histograms[data_label] = RooDataHist( data_label,
data_label,
variables,
histograms[data_label] )
pdf_arglist = RooArgList()
variable_arglist = RooArgList()
N_total = histograms[data_label].Integral() * 2
N_min = 0
for sample in samples:
roofit_histogram = RooDataHist( sample, sample, variables, histograms[sample] )
roofit_histograms[sample] = roofit_histogram
roofit_pdf = RooHistPdf ( 'pdf' + sample, 'pdf' + sample, variable_set, roofit_histogram, 0 )
roofit_pdfs[sample] = roofit_pdf
roofit_variable = RooRealVar( sample, "number of " + sample + " events", histograms[sample].Integral(), N_min, N_total, "event" )
roofit_variables[sample] = roofit_variable
pdf_arglist.add( roofit_pdf )
variable_arglist.add( roofit_variable )
model = RooAddPdf( name, name, pdf_arglist, variable_arglist )
return model, roofit_histograms, fit_variable
def performFitInLeptonAbsEta(data_histogram, signal_histogram, bkg1_histogram,
bkg2_histogram):
N_Data = data_histogram.Integral()
N_signal = signal_histogram.Integral()
N_bkg1 = bkg1_histogram.Integral()
N_bkg2 = bkg2_histogram.Integral()
leptonAbsEta = RooRealVar("leptonAbsEta", "leptonAbsEta", 0., 3.)
variables = RooArgList()
variables.add(leptonAbsEta)
variable_set = RooArgSet()
variable_set.add(leptonAbsEta)
lowerBound = 0
upperBound = N_Data * 2
data_RooDataHist = RooDataHist("data", "dataset with leptonAbsEta",
variables, data_histogram)
signal_RooDataHist = RooDataHist("rh_signal", "signal", variables,
signal_histogram)
bkg1_RooDataHist = RooDataHist("rh_bkg1", "bkg1", variables,
bkg1_histogram)
bkg2_RooDataHist = RooDataHist("rh_bkg2", "bkg2", variables,
bkg2_histogram)
signal_RooHistPdf = RooHistPdf("pdf_signal", "Signal PDF", variable_set,
signal_RooDataHist, 0)
signal_RooHistPdf = RooHistPdf("pdf_signal", "Signal PDF", variable_set,
signal_RooDataHist, 0)
def makePlot(s):
if (type(s) == TH1D):
s.SetStats(0)
x = RooRealVar("x", "x", 0, 3)
l = RooArgList(x)
dh = RooDataHist("dh", "dh", l, s)
frame = x.frame()
dh.plotOn(frame)
#frame.SetTitle(name)
#frame.GetXaxis().SetTitle(s.GetXaxis().GetTitle())
frame.GetYaxis().SetTitle(s.GetYaxis().GetTitle())
# frame.GetYaxis().SetTopMargin(0.15)
#frame.Draw(draw)
return frame
elif (type(s) == TH2D):
s.SetStats(0)
x = RooRealVar("x", "x", 0, 3)
y = RooRealVar("y", "y", 0, 3)
l = RooArgList(x, y)
dh = RooDataHist("dh", "dh", l, s)
t = TGraph2D(s)
s.SetMarkerSize(1.0)
s.SetMarkerStyle(1)
#t.GetXaxis().SetTitle(s.GetXaxis().GetTitle())
return s
elif (type(s) == TGraph2D):
s.SetMarkerSize(1.0)
s.SetMarkerStyle(1)
return s
def fit(model, hists, fitmethod, eps=1.0e-7):
"""Fit beam shapes to Beam Imaging data.
model: Beam shape model (derived from BeamShapeCore).
hists: List of four TH2F with BI data.
fitmethod: Function(pdf, data) that fits pdf to data.
eps: Value of convergence criteria.
"""
RooAbsReal.defaultIntegratorConfig().setEpsAbs(eps)
RooAbsReal.defaultIntegratorConfig().setEpsRel(eps)
modfuncs = model.model_functions()
datahist = [
RooDataHist('scan{0}Beam{1}RestDataHist'.format(c, i),
'scan{0}Beam{1}RestDataHist'.format(c, i),
RooArgList(model.xvar(), model.yvar()), hists[j])
for j, (i, c) in enumerate(ic)
]
sample = RooCategory('sample', 'sample')
for (i, c) in ic:
sample.defineType('{0}_ScanData_Beam{1}Rest'.format(c, i))
combdata = RooDataHist('combdata', 'combined data',
RooArgList(model.xvar(), model.yvar()),
RooFit.Index(sample),
RooFit.Import('X_ScanData_Beam1Rest', datahist[0]),
RooFit.Import('Y_ScanData_Beam1Rest', datahist[1]),
RooFit.Import('X_ScanData_Beam2Rest', datahist[2]),
RooFit.Import('Y_ScanData_Beam2Rest', datahist[3]))
simpdf = RooSimultaneous('simpdf', 'simultaneous pdf', sample)
for j, (i, c) in enumerate(ic):
simpdf.addPdf(modfuncs[j], '{0}_ScanData_Beam{1}Rest'.format(c, i))
result = fitmethod(simpdf, combdata)
return result, modfuncs, datahist
def doFit(hist,output,rap="BB",flavour="DATA",trackType="TunePNew",funct="doubleCB"):
sig = []
sige = []
meanList = []
meanListe = []
nChi2 = []
gSystem.Load("./RooCruijff_cxx.so")
gSystem.Load("./RooDCBShape_cxx.so")
for i,h in enumerate(hist):
ws = RooWorkspace("tempWS")
mass = RooRealVar('mass','mass',91, xLow, xHigh )
getattr(ws,'import')(mass,RooCmdArg())
dataHist = RooDataHist("hist","hist",RooArgList(ws.var("mass")),h)
getattr(ws,'import')(dataHist,RooCmdArg())
ws.writeToFile("tmpWorkspace.root")
subprocess.call(["python","fitCapsule.py",output,rap,flavour,trackType,funct,"%d"%xLow,"%d"%xHigh,"%d"%rebinFactor,"%d"%i])
returnFile = TFile("tmpWorkspaceReturn.root","OPEN")
wsReturn = returnFile.Get("tempWS")
sig.append(wsReturn.var("Sig").getVal())
sige.append(wsReturn.var("Sige").getVal())
meanList.append(wsReturn.var("Mean").getVal())
meanListe.append(wsReturn.var("Meane").getVal())
nChi2.append(wsReturn.var("chi2").getVal()/wsReturn.var("nDOF").getVal())
return meanList,meanListe,sig,sige, nChi2
def addHistData(self,
ws,
ds_name,
item_title,
var_set_name,
var_set_type,
ds_object,
sets=None):
legend = '[exostConfig::addHistData]:'
arg_list = RooArgList()
if (var_set_type == 'set'):
#arg_list.add(ws.set(var_set_name))
arg_list.add(sets[var_set_name])
elif (var_set_type == 'var'):
arg_list.add(ws.var(var_set_name))
else:
print legend, 'error: unknown var_set_type, cannot create dataset', ds_name
return -1
#create the hist dataset
ds = RooDataHist(ds_name, item_title, arg_list, ds_object, 1)
# import the datahist. Note workaround 'import' being a reserved word
getattr(ws, 'import')(ds)
def _make_underlying_model(self):
self.pdfs = {}
self.yields = {} # yields are plain floats
self.ryields = {} # keep track of roofit objects for memory management
nbins, xmin, xmax = self.plot.histos[0].GetBinning()
self.xvar = RooRealVar("x", "x", xmin, xmax)
self.xvar.setBins(nbins)
self.pdfs = {}
self.hists = []
pdfs = RooArgList()
yields = RooArgList()
for compname, comp in self.plot.histosDict.iteritems():
if comp.weighted.Integral() == 0:
continue
assert (isinstance(comp, Histogram))
hist = RooDataHist(compname, compname, RooArgList(self.xvar),
comp.weighted)
SetOwnership(hist, False)
# self.hists.append(hist)
pdf = RooHistPdf(compname, compname, RooArgSet(self.xvar), hist)
self.pdfs[compname] = pdf
# self.pdfs[compname].Print()
pdfs.add(pdf)
nevts = comp.Integral(xmin=xmin, xmax=xmax)
nmin = min(0, nevts * (1 - comp.uncertainty))
nmax = nevts * (1 + comp.uncertainty)
theyield = RooRealVar('n{}'.format(compname),
'n{}'.format(compname), nevts, nmin, nmax)
self.ryields[compname] = theyield
self.yields[compname] = nevts
yields.add(theyield)
self.underlying_model = RooAddPdf('model', 'model', pdfs, yields)
def add_data(self, data_histogram):
print "[MjFit.add_data] INFO : Adding data histogram"
# Add a data histogram
self.data_histogram_ = data_histogram.Clone()
self.data_histogram_.SetDirectory(0)
self.data_roohistogram_ = RooDataHist('data_roohistogram','data_roohistogram',RooArgList(self.mjj_),self.data_histogram_)
self.data_roohistogram_.Print()
def makeHistPdf(hist, ws, x):
theVars = RooArgList(x)
v = RooArgSet(x)
dataHist = RooDataHist(hist.GetName() + '_dh', 'dataHist', theVars, hist)
hpdf = RooHistPdf(hist.GetName() + '_pdf', 'hist pdf', v, dataHist)
getattr(ws, 'import')(hpdf)
return hpdf
def generate_hist(self, hist, varname, n):
_var = RooRealVar(varname, varname, hist.GetMean())
_dh = RooDataHist("dh", "dh", RooArgList(_var), hist)
_pdf = RooHistPdf("pdf", "pdf", RooArgSet(_var), _dh)
_ds = _pdf.generateBinned(RooArgSet(_var), n)
_h = _ds.createHistogram('hist', _var)
#_h.Draw()
#raw_input('press <enter> to continue...')
return copy.deepcopy(_h)
def Gausintialization(self):
round_energy = round(float(self.energy),-1)
if round_energy ==240 : round_energy = 250
self.x = RooRealVar("signal_%s_%dGeV"%(self.crystal,round_energy),"signal_%s_%dGeV"%(self.crystal,round_energy),max(0.,self.peak_position*(1-self.xaxis_scale)),self.peak_position*(1+self.xaxis_scale))
self.roohist = RooDataHist("roohist_fit_%s_%s"%(self.crystal,self.energy),"roohist_fit_%s_%s"%(self.crystal,self.energy),RooArgList(self.x),self.hist)
self.m = RooRealVar("mean_%s_%s"%(self.crystal,self.energy),"mean_%s_%s"%(self.crystal,self.energy),self.peak_position,max(0.,self.peak_position*(1-self.xaxis_scale)),self.peak_position*(1+self.xaxis_scale))
self.s = RooRealVar("sigma_%s_%s"%(self.crystal,self.energy),"sigma_%s_%s"%(self.crystal,self.energy),self.s_initial,0.001,1.)
self.sig = RooGaussian("signal_%s_%s"%(self.crystal,self.energy),"signal_%s_%s"%(self.crystal,self.energy),self.x,self.m,self.s)
def DoRooFit(histo, title):
can = makeCMSCanvas(str(random.random()),"Fit result ",900,700)
#Varible
if "ele" in title:
x1 = RooRealVar("x1","m_{e^{+}e^{-}}",80,100)
if "mu" in title:
x1 = RooRealVar("x1","m_{#mu^{+}#mu^{-}}",80,100)
#Define CB function
m = RooRealVar("mean_{CB}","mean of gaussian",60,120)
s = RooRealVar("#sigma_{CB}","width of gaussian",0,3)
a = RooRealVar("#alpha_{CB}","mean of gaussian",0,100)
n = RooRealVar("n_{CB}","width of gaussian",0,5)
CB = RooCBShape("CB","CB PDF",x1, m, s, a, n)
m.setConstant(kFALSE)
s.setConstant(kFALSE)
a.setConstant(kFALSE)
n.setConstant(kFALSE)
#Define Gaussian function
mean1 = RooRealVar("mean_{G}","mean of gaussian",-60,60)
sigma1 = RooRealVar("#sigma_{G}","width of gaussian",0,10)
gauss1 = RooGaussian("gauss1","gaussian PDF",x1,mean1,sigma1)
mean1.setConstant(kFALSE)
sigma1.setConstant(kFALSE)
#Starting values of the parameters
mean1.setVal(1.0)
sigma1.setVal(1.0)
m.setVal(90.0)
s.setVal(1.0)
a.setVal(10.0)
n.setVal(2.0)
# Construct CB (x) gauss
x1.setBins(10000, "cache")
CBxG = RooFFTConvPdf("CBxG", "CB (X) gauss", x1, CB, gauss1)
can.cd()
d = RooDataHist("d","d",RooArgList(x1),RooFit.Import(histo))
CBxG.fitTo(d, RooLinkedList())
# Plot PDF and toy data overlaid
xframe2 = x1.frame(RooFit.Name("xframe"),RooFit.Title("")) # RooPlot
d.plotOn(xframe2, RooLinkedList() )
CBxG.paramOn(xframe2, RooFit.Layout(0.65,0.99,0.9))
xframe2.getAttText().SetTextSize(0.03)
CBxG.plotOn(xframe2)
xframe2.Draw()
can.SaveAs("DataVsMC/FitResults/"+title+"_Roofit.pdf")
can.SaveAs("DataVsMC/FitResults/"+title+"_Roofit.png")
return;
def get_num_sig_bkg(hist_DataTemplate, hist_SignalTemplate,
hist_BackgdTemplate, fit_range_min, fit_range_max):
'''Given 3 input histograms (TH1F), and a fit range, this function finds
the amount of signal and background that sum up to the data histogram.
It does histogram fits.'''
# Find range of data template
data_min = hist_DataTemplate.GetXaxis().GetXmin()
data_max = hist_DataTemplate.GetXaxis().GetXmax()
# Create basic variables
x = RooRealVar("x", "x", data_min, data_max)
x.setBins(hist_DataTemplate.GetXaxis().GetNbins()) # Binned x values
nsig = RooRealVar("nsig", "number of signal events", 0,
hist_DataTemplate.Integral())
nbkg = RooRealVar("nbkg", "number of background events", 0,
hist_DataTemplate.Integral())
# Create RooDataHists from input TH1Fs
dh = RooDataHist("dh", "dh", RooArgList(x), hist_DataTemplate)
ds = RooDataHist("ds", "ds", RooArgList(x), hist_SignalTemplate)
db = RooDataHist("db", "db", RooArgList(x), hist_BackgdTemplate)
# Create Probability Distribution Functions from Monte Carlo
sigPDF = RooHistPdf("sigPDF", "sigPDF", RooArgSet(x), ds)
bkgPDF = RooHistPdf("bkgPDF", "bkgPDF", RooArgSet(x), db)
model = RooAddPdf("model", "(g1+g2)+a", RooArgList(bkgPDF, sigPDF),
RooArgList(nbkg, nsig))
# Find the edges of the bins that contain the fit range min/max
data_min = hist_DataTemplate.GetXaxis().GetBinLowEdge(
hist_DataTemplate.GetXaxis().FindFixBin(fit_range_min))
data_max = hist_DataTemplate.GetXaxis().GetBinUpEdge(
hist_DataTemplate.GetXaxis().FindFixBin(fit_range_max))
r = model.fitTo(dh, RooFit.Save(), RooFit.Minos(0),
RooFit.PrintEvalErrors(0), RooFit.Extended(),
RooFit.Range(data_min, data_max))
r.Print("v")
#print nsig.getVal(), nsig.getError(), nbkg.getVal(), nbkg.getError()
return [nsig.getVal(), nsig.getError(), nbkg.getVal(), nbkg.getError()]
def Fit(h, Lc_M):
h_LcM = RooDataHist('h_LcM', 'h_LcM', RooArgList(Lc_M), h)
#Create a workspace named 'w' with the model to fit the Lc_Mass peak
nsig = RooRealVar("nsig", "N signal evts", 100000, 0, 5000000)
nbkg = RooRealVar("nbkg", "N bkg evts", 400000, 0, 1E10)
w = CreateMassFitModel(Lc_M, nsig, nbkg)
model = w.pdf("model")
model.fitTo(h_LcM, RF.Extended(True))
return model, w, h_LcM
def CB2intialization(self):
round_energy = round(float(self.energy),-1)
self.x = RooRealVar("signal_%s_%dGeV"%(self.crystal,round_energy),"signal_%s_%dGeV"%(self.crystal,round_energy),max(0.,self.peak_position*(1-self.xaxis_scale)),self.peak_position*(1+self.xaxis_scale))
self.roohist = RooDataHist("roohist_fit_%s_%s"%(self.crystal,self.energy),"roohist_fit_%s_%s"%(self.crystal,self.energy),RooArgList(self.x),self.hist)
self.m = RooRealVar("mean_%s_%s"%(self.crystal,self.energy),"mean_%s_%s"%(self.crystal,self.energy),self.peak_position,max(0.,self.peak_position*(1-self.xaxis_scale)),self.peak_position*(1+self.xaxis_scale))
self.s = RooRealVar("sigma_%s_%s"%(self.crystal,self.energy),"sigma_%s_%s"%(self.crystal,self.energy),self.s_initial,10,500)
self.a = RooRealVar("alpha_%s_%s"%(self.crystal,self.energy),"alpha_%s_%s"%(self.crystal,self.energy),self.a_initial,-10.,10)
self.a2 = RooRealVar("alpha2_%s_%s"%(self.crystal,self.energy),"alpha2_%s_%s"%(self.crystal,self.energy),self.a2_initial,-10.,10)
self.n = RooRealVar("exp_%s_%s"%(self.crystal,self.energy),"exp_%s_%s"%(self.crystal,self.energy),self.n_initial,0.,30)
self.n2 = RooRealVar("exp2_%s_%s"%(self.crystal,self.energy),"exp2_%s_%s"%(self.crystal,self.energy),self.n2_initial,0.,30)
self.sig = ROOT.My_double_CB("signal_%s_%s"%(self.crystal,self.energy),"signal_%s_%s"%(self.crystal,self.energy),self.x,self.m,self.s,self.a,self.n,self.a2,self.n2)
def CBintialization(self):
round_energy = round(float(self.energy),-1)
if round_energy ==240 : round_energy = 250
self.x = RooRealVar("signal_%s_%dGeV"%(self.crystal,round_energy),"signal_%s_%dGeV"%(self.crystal,round_energy),max(0.,self.peak_position*(1-self.xaxis_scale)),self.peak_position*(1+self.xaxis_scale))
self.roohist = RooDataHist("roohist_fit_%s_%s"%(self.crystal,self.energy),"roohist_fit_%s_%s"%(self.crystal,self.energy),RooArgList(self.x),self.hist)
self.m = RooRealVar("mean_%s_%s"%(self.crystal,self.energy),"mean_%s_%s"%(self.crystal,self.energy),self.peak_position,max(0.,self.peak_position*(1-self.xaxis_scale)),self.peak_position*(1+self.xaxis_scale))
self.s = RooRealVar("sigma_%s_%s"%(self.crystal,self.energy),"sigma_%s_%s"%(self.crystal,self.energy),self.s_initial,0.001,1.) #500.
self.a = RooRealVar("alpha_%s_%s"%(self.crystal,self.energy),"alpha_%s_%s"%(self.crystal,self.energy),self.a_initial,-10.,10)
self.n = RooRealVar("exp_%s_%s"%(self.crystal,self.energy),"exp_%s_%s"%(self.crystal,self.energy),self.n_initial,0.,30)
self.sig = RooCBShape("signal_%s_%s"%(self.crystal,self.energy),"signal_%s_%s"%(self.crystal,self.energy),self.x,self.m,self.s,self.a,self.n)
def compare_binning(filename):
scans = ('X1', 'Y1', 'X2', 'Y2')
with BareRootFile(filename) as f:
oldres = [f.get('residualHist{0}'.format(scan)) for scan in scans]
oldchi = [f.get_val('chisq{0}'.format(scan)) for scan in scans]
olddof = [f.get_val('dof{0}'.format(scan)) for scan in scans]
name = f.get_val('name')
bcidpos = name.find('bcid')
dataname = name[16:name.rfind('_', 0, bcidpos - 1)]
fitname = name[name.rfind('_', 0, bcidpos - 1) + 1:bcidpos - 1]
bcid = int(name[bcidpos + 4:])
model = {
'SG': SingleGauss,
'DG': DoubleGaussFit,
'TG': TripleGaussFit
}[fitname]()
model.load_root(filename)
modfuncs = model.model_functions()
with open('res/hist/{0}.json'.format(dataname)) as f:
json = load(f)
nbins = json['nbins']
scaling = json['scaling']
datafile = '{0}/{1}.root'.format(json['datapath'], json['name'])
hists = []
with BareRootFile(datafile) as f:
for histname in [
'hist_Beam2MoveX_bunch{0}Add', 'hist_Beam2MoveY_bunch{0}Add',
'hist_Beam1MoveX_bunch{0}Add', 'hist_Beam1MoveY_bunch{0}Add'
]:
hist = f.get(histname.format(bcid))
hists.append(hist)
datahist = [
RooDataHist('scan{0}Beam{1}RestDataHist'.format(c, i),
'scan{0}Beam{1}RestDataHist'.format(c, i),
RooArgList(model.xvar(), model.yvar()), hists[j])
for j, (i, c) in enumerate([('1', 'X'), ('1', 'Y'), ('2',
'X'), ('2', 'Y')])
]
chisq, dof, hdata, hmodel = compute_chisq(model, modfuncs, datahist, nbins)
scDat, scMod, scRes = residual_hist(hdata, hmodel, scaling)
for i, scan in enumerate(scans):
oldval = oldchi[i] / olddof[i]
newval = chisq[i] / dof[i]
print '{0}: {1:.4f} {2:.4f}'.format(scan, oldval, newval)
return scRes, oldres
def add_signal(self, signal_name, signal_histogram): print "[MjjFit.add_signal] INFO : Adding signal histogram " + signal_name # Add a signal histogram. # Scale to sigma=1 (in whatever units the data luminosity is given in), so the 'r' parameter corresponds to the limit on the cross section. if self.luminosity_ == 0: print "[MjjFit.add_signal] ERROR : Please set luminosity first (MjjFit.set_luminosity(###))." sys.exit(1) self.signal_names_.append(signal_name) self.signal_histograms_[signal_name] = signal_histogram.Clone() self.signal_histograms_[signal_name].SetDirectory(0) self.signal_histograms_[signal_name].Scale(1. * self.luminosity_ / self.signal_histograms_[signal_name].Integral()) self.signal_roohistograms_[signal_name] = RooDataHist(signal_histogram.GetName() + "_rdh", signal_histogram.GetName() + "_rdh", RooArgList(self.mjj_), signal_histograms[signal_name]) self.signal_roohistograms_[signal_name].Print()
def saveLandauHistoAmplitude(histo,
outfile,
canvas,
XaxisTitle="",
YaxisTitle="",
plotTitle="",
stats=0):
ex = "Null Fit"
amplitude = RooRealVar("amplitude", "Cluster Amplitude", 0, 5000)
landau_data = RooDataHist("landau_data", "landau_data",
RooArgList(amplitude), histo)
ml = RooRealVar("ml", "mean landau", 1500., 1000, 2000)
sl = RooRealVar("sl", "sigma landau", 250, 100, 1000)
landau = RooLandau("lx", "lx", amplitude, ml, sl)
mg = RooRealVar("mg", "mg", 0)
sg = RooRealVar("sg", "sg", 100, 20, 500)
gauss = RooGaussian("gauss", "gauss", amplitude, mg, sg)
lxg = RooNumConvPdf("lxg", "lxg", amplitude, landau, gauss)
result = lxg.fitTo(landau_data)
frame = amplitude.frame()
landau_data.plotOn(frame)
lxg.plotOn(frame)
frame.Draw("")
frame.SetTitle(plotTitle)
frame.GetXaxis().SetTitle(XaxisTitle)
frame.GetYaxis().SetTitle(YaxisTitle)
frame.SetStats(stats)
frame.Write(plotTitle)
canvas.Print(outfile + ".pdf")
peak = []
try:
mean = RooRealVar(result.floatParsFinal().find("landau_mean"))
err = RooRealVar(mean.errorVar())
peak.append(mean.GetVal())
peak.append(err.GetVal())
except Exception as ex:
print(ex)
peak.append(0)
peak.append(0)
return peak
def loadData(self, weight = False):
if self.ws.data('data_obs'):
return self.ws.data('data_obs')
unbinnedName = 'data_obs'
if self.pars.binData:
unbinnedName = 'data_unbinned'
data = self.utils.File2Dataset(self.pars.DataFile, unbinnedName,
self.ws, weighted = weight)
if self.pars.binData:
data = RooDataHist('data_obs', 'data_obs', self.ws.set('obsSet'),
data)
getattr(self.ws, 'import')(data)
data = self.ws.data('data_obs')
return data
def makePDFs(Files, pdf_list, evntCount):
for (inputMass, inputFilename) in Files:
histo = load_histos(inputFilename)
evntCount.append(histo.Integral())
# could construct name and title from inputmass
if 'nom' in inputFilename:
myString = inputFilename.partition("230_")[2].partition(
"_result")[0] + str(inputMass)
else:
myString = inputFilename.partition("jes_")[2].partition(
"_result")[0] + str(inputMass)
# Convert the TH1F Histogram (data_hist) into a RooDataHist object
data_hist = RooDataHist(myString, myString, RooArgList(x), histo)
# Turn the RooDataHist object into a RooHistPdf object
pdf = RooHistPdf(myString, myString, RooArgSet(x), data_hist)
# both the data_hist and pdf must survive
pdf_list.append([data_hist, pdf])
def histoToRooHistFunc(ws, cfg, section, histo, name):
nBins = len(cfg.get(section, 'obsBins').split(',')) - 1
makeLastBinOverflow(histo, nBins)
histo.SetName('%s_%s_input' % (section, name))
getattr(ws, 'import')(histo)
#make the histogram, using the binning defined by the histogram
rdh = RooDataHist(
'%s_%s_yields' % (section, name), '%s_%s_yields' % (section, name),
RooArgList(ws.var('%s_%s' % (cfg.get(section, 'obsVar'), section))),
RooFit.Import(ws.obj('%s_%s_input' % (section, name)), False))
getattr(ws, 'import')(rdh)
#make the hist func so we can get at the yield
ws.factory("""
RooHistFunc::%s_%s_model
({%s_%s},%s_%s_yields)
""" % (section, name, cfg.get(section, 'obsVar'), section, section, name))
def Hist2Pdf(self, hist, pdfName, ws, order=0):
if ws.pdf(pdfName):
return ws.pdf(pdfName)
try:
obs = [self.pars.varNames[x] for x in self.pars.var]
except AttributeError:
obs = self.pars.var
varList = RooArgList()
for v in obs:
varList.add(ws.var(v))
newHist = RooDataHist(pdfName + '_hist', pdfName + '_hist', varList,
hist)
thePdf = RooHistPdf(pdfName, pdfName, RooArgSet(varList), newHist,
order)
getattr(ws, 'import')(thePdf)
return ws.pdf(pdfName)
def loadDataFromWorkspace(self, other, cut = None):
#pull unbinned data from other workspace
unbinnedData = other.data('data_unbinned')
if not unbinnedData:
unbinnedData = other.data('data_obs')
if cut:
unbinnedData = unbinnedData.reduce(cut)
unbinnedData.Print()
if self.pars.binData:
#bin and import data
unbinnedData.SetName('data_unbinned')
getattr(self.ws, 'import')(unbinnedData)
data = RooDataHist('data_obs', 'data_obs', other.set('obsSet'),
unbinnedData)
getattr(self.ws, 'import')(data)
else:
#just import data
unbinnedData.SetName('data_obs')
getattr(self.ws, 'import')(unbinnedData)
def __init__( self, fit_data ):
MapStrRootPtr = stl.map( stl.string, "TH1*" )
StrHist = stl.pair( stl.string, "TH1*" )
self.fit_data = fit_data
self.models = {}
self.sample = RooCategory( 'sample', 'sample' )
self.roofit_variables = []
input_hists = MapStrRootPtr()
# first create observables
# Since we are looking for normalisation in equivalent regions
# the number of events in each sample has to be identical
# Hence, pick one fit_data to create the set of observables
fit_data_1 = fit_data.itervalues().next()
samples = fit_data_1.samples
self.observables = {}
N_min = 0
N_max = fit_data_1.n_data() * 2
for sample in samples:
self.observables[sample] = Observable( 'n_' + sample,
'number of ' + sample + " events",
fit_data_1.normalisation[sample],
N_min,
N_max,
"events" )
# next create the models
for variable, fit_input in fit_data.iteritems():
self.models[variable] = fit_input.get_roofit_model( variable, self.observables )
self.sample.defineType( variable )
self.sample.setLabel ( variable )
data = deepcopy( fit_input.real_data_histogram() )
input_hists.insert( StrHist( variable, data ) )
self.roofit_variables.append( fit_input.fit_variable )
self.comb_data = RooDataHist( "combData",
"combined data",
RooArgList( self.roofit_variables[0] ),
self.sample,
input_hists,
)
def generate(histList, varName, varLow, varHigh, histSig="", weightSig=0.):
"""
Generate toy data
@param histList List of histograms
@param varname Variable name to use
@param varLow Lower edge of left bin
@param varHigh Upper edge of right bin
@param histSig Optional signal histogram
@param weightSig Optional signal weight
"""
testHist_pred = TH1D()
for (iHist, hist) in enumerate(histList):
if not iHist:
testHist_pred = hist.Clone("hPRED")
else:
testHist_pred.Add(hist)
testHist_pred_ds = TH1D(
"hPSDATA", "hPSDATA", testHist_pred.GetNbinsX(),
testHist_pred.GetXaxis().GetBinLowEdge(1),
testHist_pred.GetXaxis().GetBinUpEdge(testHist_pred.GetNbinsX()))
nEvents_pred = int(testHist_pred.Integral())
print "nEvents_pred = %d" % nEvents_pred
var = RooRealVar(varName, varName, varLow, varHigh)
dh_pred = RooDataHist("dhPSDATA", "dhPSDATA", RooArgList(var),
RooFit.Import(testHist_pred))
ph_pred = RooHistPdf("phPSDATA", "phPSDATA", RooArgSet(var), dh_pred)
ds_pred = ph_pred.generate(RooArgSet(var), nEvents_pred)
testHist_pred_ds = ds_pred.fillHistogram(testHist_pred_ds, RooArgList(var))
return testHist_pred_ds
def _make_underlying_model(self):
self.pdfs = {}
self.yields = {} # yields are plain floats
self.ryields = {} # keep track of roofit objects for memory management
h = self._histos[0]
nbins = h.GetXaxis().GetNbins()
xmin = h.GetXaxis().GetXmin()
xmax = h.GetXaxis().GetXmax()
self.xvar = RooRealVar("x", "x", xmin, xmax)
self.xvar.setBins(nbins)
self.pdfs = {}
self.hists = []
pdfs = RooArgList()
yields = RooArgList()
for histo in self._histos:
if histo.Integral() == 0:
continue
compname = histo.GetName()
hist = RooDataHist(compname, compname, RooArgList(self.xvar),
histo)
SetOwnership(hist, False)
# self.hists.append(hist)
pdf = RooHistPdf(compname, compname, RooArgSet(self.xvar), hist)
self.pdfs[compname] = pdf
# self.pdfs[compname].Print()
pdfs.add(pdf)
nevts = histo.Integral()
uncertainty = self._uncertainty
nmin = min(0, nevts * (1 - uncertainty))
nmax = nevts * (1 + uncertainty)
theyield = RooRealVar('n{}'.format(compname),
'n{}'.format(compname), nevts, nmin, nmax)
self.ryields[compname] = theyield
self.yields[compname] = nevts
yields.add(theyield)
self.underlying_model = RooAddPdf('model', 'model', pdfs, yields)
def MakeRooDataHist(phys_process, fullrange_=False):
MPruned_Merged.Scale(0.0)
iweight = 0
for irootfile in Utils.samples[phys_process]['files']:
file01 = TFile('AnalysisHistograms_V7/' + irootfile, 'READ')
#file01 = TFile(irootfile, 'READ')
MPruned_ttbar_sb = file01.Get('histfacFatJet_ZLight/h_Mjj0')
MPruned_ttbar_sig = file01.Get(
'MonoHFatJetSelection_JetAndLeptonVeto/h_Mjj0')
if debug_:
print "before ", MPruned_ttbar_sb.Integral()
print "before ", MPruned_ttbar_sig.Integral()
if phys_process != 'data_obs':
MPruned_ttbar_sb.Scale(
Utils.samples[phys_process]['weight'][iweight])
MPruned_ttbar_sig.Scale(
Utils.samples[phys_process]['weight'][iweight])
if debug_:
print "weight = ", Utils.samples[phys_process]['weight'][iweight]
print "after ", MPruned_ttbar_sb.Integral()
print "after ", MPruned_ttbar_sig.Integral()
MPruned_Merged.Add(MPruned_ttbar_sb)
if fullrange_ | options.fullrange:
MPruned_Merged.Add(MPruned_ttbar_sig)
## convert Histogram to RooDataHist
MPruned_ttbar_hist = RooDataHist('MPruned_ttbar_hist',
'MPruned_ttbar_hist',
RooArgList(J_Mass), MPruned_Merged)
iweight = iweight + 1
print "final intgral = ", MPruned_Merged.Integral()
return MPruned_ttbar_hist
def broadenspec(ms, E_0):
spec = decayspec(ms, E_0)
smear = core(E_0_center)
newspec = TH1D("", "", spec.GetNbinsX(), -17.5, 17.5)
for i in range(1, spec.GetNbinsX() + 1):
newspec.SetBinContent(i, spec.GetBinContent(i))
#x = RooRealVar("x","x",-30+E_0_center, 5+E_0_center)
x = RooRealVar("x", "x", -17.5, 17.5)
data = RooDataHist("", "", RooArgList(x), newspec)
specpdf = RooHistPdf("", "", RooArgSet(x), data)
#y = RooRealVar("y","y",-30, 5)
x.setBins(10000)
smearpdf = RooFit.bindPdf(smear, x)
fft = RooFFTConvPdf("tt", "tt", x, specpdf, smearpdf)
#fft.setShift(0, -18574)
#c1 = TCanvas()
#frame = x.frame()
#fft.plotOn(frame)
#frame.Draw()
tf = fft.asTF(RooArgList(x))
tf.SetNpx(10000)
rtf = tf.Clone()
return rtf
def generate(histList,varName,varLow,varHigh,histSig="",weightSig=0.):
testHist_pred = TH1D()
for (iHist,hist) in enumerate(histList):
if not iHist:
testHist_pred = hist.Clone("hPRED")
else:
testHist_pred.Add(hist)
testHist_pred_ds = TH1D("hPSDATA","hPSDATA",testHist_pred.GetNbinsX(),testHist_pred.GetXaxis().GetBinLowEdge(1),testHist_pred.GetXaxis().GetBinUpEdge(testHist_pred.GetNbinsX()))
nEvents_pred = int(testHist_pred.Integral())
print "nEvents_pred = %d" % nEvents_pred
var = RooRealVar(varName,varName,varLow,varHigh)
dh_pred = RooDataHist("dhPSDATA","dhPSDATA",RooArgList(var),RooFit.Import(testHist_pred))
ph_pred = RooHistPdf("phPSDATA","phPSDATA",RooArgSet(var),dh_pred)
ds_pred = ph_pred.generate(RooArgSet(var),nEvents_pred)
testHist_pred_ds = ds_pred.fillHistogram(testHist_pred_ds,RooArgList(var))
return testHist_pred_ds
