def predict(self, x, theta_true):
"""
Run the unbinned ML fit
"""
# Data
roodata = RooDataSet('data', 'data', RooArgSet(self.phistar))
for xval in x:
self.phistar.setVal(xval)
roodata.add(RooArgSet(self.phistar))
theta = RooRealVar('theta', 'theta', 0.5, self.theta_min, self.theta_max)
# The combined pdf
model = RooAddPdf('model', 'model',
RooArgList(self.pdfs['A'], self.pdfs['H']),
RooArgList(theta))
with stdout_redirected_to('%s/minuit_output.log' % self.outdir):
res = model.fitTo(roodata, Save(True))
nll = res.minNll()
fitted_theta = theta.getValV()
# Get Lambda(theta_true | theta_best)
with stdout_redirected_to():
logl = model.createNLL(roodata)
theta.setVal(theta_true)
nll_theta_true = logl.getValV()
nll_ratio = nll_theta_true - nll
return fitted_theta, nll, nll_ratio
def File2Dataset(self,
fnames,
dsName,
ws,
noCuts=False,
weighted=False,
CPweight=False,
cutOverride=None,
interference=0,
additionalWgt=1.0):
if ws.data(dsName):
return ws.data(dsName)
cols = RooArgSet(ws.set('obsSet'))
# print 'interference weight flag:',interference
if (weighted):
evtWgt = RooRealVar('evtWgt', 'evtWgt', 1.0)
cols.add(evtWgt)
ds = RooDataSet(dsName, dsName, cols, 'evtWgt')
print 'including weights for eff',
if CPweight:
print 'and CP weight',
if interference in [1, 2, 3]:
print 'and interference',
print
else:
ds = RooDataSet(dsName, dsName, cols)
if not (type(fnames) == type([])):
fnames = [fnames]
try:
obs = [self.pars.varNames[x] for x in self.pars.var]
except AttributeError:
obs = self.pars.var
for fname in fnames:
for (row, effWgt, cpw, iwt) in \
self.TreeLoopFromFile(fname, noCuts,
CPweight = CPweight,
cutOverride = cutOverride,
interference = interference):
inRange = True
for (i, v) in enumerate(obs):
inRange = (inRange and ws.var(v).inRange(row[i], ''))
cols.setRealValue(v, row[i])
if CPweight:
effWgt *= cpw
if interference in [1, 2, 3]:
effWgt *= iwt
if inRange:
ds.add(cols, effWgt * additionalWgt)
getattr(ws, 'import')(ds)
return ws.data(dsName)
def fillDataSet(data, x, N, dsName = 'ds'):
cols = RooArgSet(x)
ds = RooDataSet(dsName, dsName, cols)
#ds.Print()
print 'length data:', N
for datum in range(0,N):
if (data[datum] < x.getMax()) and (data[datum] > x.getMin()):
x.setVal(data[datum])
ds.add(cols)
ds.Print()
return ds
def fillDataSet(data, x, N, dsName='ds'):
cols = RooArgSet(x)
ds = RooDataSet(dsName, dsName, cols)
#ds.Print()
print 'length data:', N
for datum in range(0, N):
if (data[datum] < x.getMax()) and (data[datum] > x.getMin()):
x.setVal(data[datum])
ds.add(cols)
ds.Print()
return ds
def File2Dataset(self, fnames, dsName, ws, noCuts = False,
weighted = False, CPweight = False, cutOverride = None,
interference = 0, additionalWgt = 1.0):
if ws.data(dsName):
return ws.data(dsName)
cols = RooArgSet(ws.set('obsSet'))
# print 'interference weight flag:',interference
if (weighted):
evtWgt = RooRealVar('evtWgt', 'evtWgt', 1.0)
cols.add(evtWgt)
ds = RooDataSet(dsName, dsName, cols, 'evtWgt')
print 'including weights for eff',
if CPweight:
print 'and CP weight',
if interference in [1,2,3]:
print 'and interference',
print
else:
ds = RooDataSet(dsName, dsName, cols)
if not (type(fnames) == type([])):
fnames = [fnames]
try:
obs = [ self.pars.varNames[x] for x in self.pars.var ]
except AttributeError:
obs = self.pars.var
for fname in fnames:
for (row, effWgt, cpw, iwt) in \
self.TreeLoopFromFile(fname, noCuts,
CPweight = CPweight,
cutOverride = cutOverride,
interference = interference):
inRange = True
for (i,v) in enumerate(obs):
inRange = (inRange and ws.var(v).inRange(row[i], ''))
cols.setRealValue(v, row[i])
if CPweight:
effWgt *= cpw
if interference in [1,2,3]:
effWgt *= iwt
if inRange:
ds.add(cols, effWgt*additionalWgt)
getattr(ws, 'import')(ds)
return ws.data(dsName)
def roofit_poisson_unbinned(data):
"""returns lambda, error of lambda"""
x = RooRealVar('x', 'x', 0, max(data) * 10)
lam = RooRealVar('lambda', 'lambda', 0.1, 0.000001, max(data))
model = RooPoisson('model', 'model', x, lam)
dataset = RooDataSet('data', 'data', RooArgSet(x))
for val in data:
x.setVal(val)
dataset.add(RooArgSet(x))
model.fitTo(dataset, RooFit.Save(), RooFit.PrintLevel(-1))
return lam.getVal(), lam.getError()
def predict(self, x, theta_true):
"""
Run an unbinned ML fit to make predictions
"""
# Create RooDataSet
xs = self.scaler.transform(x)
preds = self.model.predict(xs)[:, 1]
min_nn_output_local, max_nn_output_local = np.min(preds), np.max(preds)
if min_nn_output_local < self.min_nn_output:
self.min_nn_output = min_nn_output_local
if max_nn_output_local > self.max_nn_output:
self.max_nn_output = max_nn_output_local
roodata = RooDataSet('data', 'data', RooArgSet(self.roopred))
for pred in preds:
self.roopred.setVal(pred)
roodata.add(RooArgSet(self.roopred))
# Fit
theta = RooRealVar('theta', 'theta', 0.5, self.theta_min, self.theta_max)
model = RooAddPdf('model', 'model',
RooArgList(self.pdfs['A'], self.pdfs['H']),
RooArgList(theta))
with stdout_redirected_to('%s/minuit_output.log' % self.outdir):
res = model.fitTo(roodata, Save(True))
nll = res.minNll()
fitstatus = res.status()
fitstatus |= (not subprocess.call(['grep', 'p.d.f value is less than zero', 'output_MLE_unbinned/minuit_output.log']))
fitted_theta = theta.getValV()
# Get Lambda(theta_true | theta_best)
logl = model.createNLL(roodata)
theta.setVal(theta_true)
nll_theta_true = logl.getValV()
nll_ratio = nll_theta_true - nll
return fitted_theta, nll, nll_ratio, fitstatus
def dump_simple_simul():
# idea: take two data sets, both low counts, but same lambda
# and fit said lambda simultanously with both sets
r_x = RooRealVar('x', 'x', 0, bins)
r_lam = RooRealVar('lam', 'lam', 0.5, 0.0, 1.5)
r_lam1 = RooRealVar('lam1', 'lam1', 0.5, 0.0, 1.5)
r_lam2 = RooRealVar('lam2', 'lam2', 0.5, 0.0, 1.5)
model1 = RooPoisson('pois1', 'pois1', r_x, r_lam1)
model2 = RooPoisson('pois2', 'pois2', r_x, r_lam2)
r_index = RooCategory('index', 'index')
r_index.defineType('1')
r_index.defineType('2')
simul_model = RooSimultaneous('model', 'model', r_index)
simul_model.addPdf(model1, '1')
simul_model.addPdf(model2, '2')
data1 = RooDataSet('', '', RooArgSet(r_x))
for val in unbinned_from_binned(xdata, ydata):
r_x.setVal(val)
data1.add(RooArgSet(r_x))
r_index.setLabel('1')
data1.addColumn(r_index)
data2 = RooDataSet('', '', RooArgSet(r_x))
for val in unbinned_from_binned(xdata, ydata2):
r_x.setVal(val)
data2.add(RooArgSet(r_x))
r_index.setLabel('2')
data2.addColumn(r_index)
data1.append(data2)
_result = simul_model.fitTo(data1)
print(r_lam.getVal(), '+-', r_lam.getError(), lam, np.abs(r_lam.getVal() - lam) / lam)
print(r_lam1.getVal(), '+-', r_lam1.getError(), lam, np.abs(r_lam1.getVal() - lam) / lam)
print(r_lam2.getVal(), '+-', r_lam2.getError(), lam, np.abs(r_lam2.getVal() - lam) / lam)
def fill_dataset(varargset, ftree, wt, wtvar, cut=""):
"""Return a dataset (slow, get_dataset is more efficient).
Return a dataset from the ntuple `ftree', also apply `cut'. Use
`wt' as the weight expression in the tree. `wtvar' is the
corresponding RooRealVar weight. Note, varargset should contain
wtvar.
The dataset is filled by iterating over the tree. This is needed
when you want to ensure different datasets have the same weight
variable names, so that they can be combined later on. This is
needed even if they are combined as different categories.
"""
from rplot.fixes import ROOT
from ROOT import RooDataSet, RooFit, TTreeFormula
from helpers import suppress_warnings
suppress_warnings()
from rplot.tselect import Tsplice
splice = Tsplice(ftree)
splice.make_splice("sel", cut)
formulae = {}
wtname = wtvar.GetName()
for var in varargset:
name = var.GetName()
expr = wt if name == wtname else name
formulae[name] = TTreeFormula(name, expr, ftree)
dataset = RooDataSet("dataset", "Dataset", varargset, RooFit.WeightVar(wtvar))
for i in xrange(ftree.GetEntries()):
ftree.GetEntry(i)
for var, expr in formulae.iteritems():
realvar = varargset.find(var)
realvar.setVal(expr.EvalInstance())
dataset.add(varargset, varargset[wtname].getVal())
return dataset
def dump_simple():
# try poisson
roo_lam = RooRealVar("lambda", ".", lam, 0.0, 1.5)
roo_x = RooRealVar('x', 'x range', 0, bins)
model = RooPoisson("poisson", "Poisson Model", roo_x, roo_lam)
#data = model.generate(RooArgSet(roo_x), n_events)
data = RooDataSet('data', 'Data', RooArgSet(roo_x))
for val in unbinned_from_binned(xdata, ydata):
roo_x.setVal(val)
data.add(RooArgSet(roo_x))
#// --- Perform extended ML fit of composite PDF to toy data ---
fitresult = model.fitTo(data, RooFit.Save(), RooFit.PrintLevel(-1)) ;
#// --- Plot toy data and composite PDF overlaid ---
mesframe = roo_x.frame(bins) ;
data.plotOn(mesframe) ;
model.plotOn(mesframe) ;
mesframe.Draw()
def fill_dataset(varargset, ftree, wt, wtvar, cut=''):
"""Return a dataset (slow, get_dataset is more efficient).
Return a dataset from the ntuple `ftree', also apply `cut'. Use
`wt' as the weight expression in the tree. `wtvar' is the
corresponding RooRealVar weight. Note, varargset should contain
wtvar.
The dataset is filled by iterating over the tree. This is needed
when you want to ensure different datasets have the same weight
variable names, so that they can be combined later on. This is
needed even if they are combined as different categories.
"""
from rplot.fixes import ROOT
from ROOT import RooDataSet, RooFit, TTreeFormula
from helpers import suppress_warnings
suppress_warnings()
from rplot.tselect import Tsplice
splice = Tsplice(ftree)
splice.make_splice('sel', cut)
formulae = {}
wtname = wtvar.GetName()
for var in varargset:
name = var.GetName()
expr = wt if name == wtname else name
formulae[name] = TTreeFormula(name, expr, ftree)
dataset = RooDataSet('dataset', 'Dataset', varargset,
RooFit.WeightVar(wtvar))
for i in xrange(ftree.GetEntries()):
ftree.GetEntry(i)
for var, expr in formulae.iteritems():
realvar = varargset.find(var)
realvar.setVal(expr.EvalInstance())
dataset.add(varargset, varargset[wtname].getVal())
return dataset
if k.pt < 250: continue
counters[0] = counters[0] + 1
if mu1.pt < 550 or mu2.pt < 550: continue
counters[1] = counters[1] + 1
if mu1.ipchi2 < 16 or mu2.ipchi2 < 16 or k.ipchi2 < 16: continue
counters[2] = counters[2] + 1
if psi_dls[jpsi_idx] < 5: continue
counters[3] = counters[3] + 1
if abs(jpsimass - jpsi.m) > 50: continue
counters[4] = counters[4] + 1
if k.pnn_k < 0.9: continue
counters[5] = counters[5] + 1
hist.Fill(bp0_m[j])
if ( bp0_m[j] > m.getMin() and bp0_m[j] < m.getMax() ):
m.setVal(bp0_m[j])
ds.add(argset)
aa.SetBranchStatus("bp1*",1)
aa.SetBranchStatus("piz*",1)
aa.SetBranchStatus("bp0*",0)
for i in range(aa.GetEntries()):
s = aa.GetEntry(i)
if s == -1:
print "Error reading event ",i,", skipping"
continue
if i%10000 == 0:
print i," entry of ",aa.GetEntries()
print counters2
bp1_m = aa.bp1_dtf_m
bp1_idx_psi = aa.bp1_idx_psi
fitresult = mistagVsEtaGraph.Fit(linFuncList[-1],"S","",0.0,0.5)
#print "FITRESULT"
#fitresult.Print();
p1Fit = fitresult.Parameter(1);
p1FitError = fitresult.ParError(1);
print "FITRESULT PARAMETER 0"
print fitresult.Parameter(0);
print "FITRESULT PARAMETER 1"
print fitresult.Parameter(1);
p1End = p1End.getValV();
p1Dev.setVal((p1Fit - p1End) / p1FitError);
p1DevSet.add(RooArgSet(p1Dev))
p0Fit = fitresult.Parameter(0)# - dsMeanVal.getValV();
p0FitError = fitresult.ParError(0);
p0End = p0End.getValV()-etaAvg.getValV();
print 'P0FIT = ', p0Fit, '\nDSMEANVAL = ', dsMeanVal.getValV(), '\nP0END = ', p0End, '\n'
p0Dev.setVal((p0Fit - p0End) / p0FitError);
p0DevSet.add(RooArgSet(p0Dev))
#graphHolder.Add(mistagVsEtaGraph)
#currentColor += 1
#break;
currentTime = time.time();
def predict_and_plot(self, x):
"""
Do the same as predict(), but add plots
Return -logL ratio, for external plotting
"""
rcParams['xtick.major.pad'] = 12
rcParams['ytick.major.pad'] = 12
roodata = RooDataSet('data', 'data', RooArgSet(self.phistar))
for xval in x:
self.phistar.setVal(xval)
roodata.add(RooArgSet(self.phistar))
theta = RooRealVar('theta', 'theta', self.theta_min, self.theta_max)
model = RooAddPdf('model', 'model',
RooArgList(self.pdfs['A'], self.pdfs['H']),
RooArgList(theta))
#with stdout_redirected_to():
print '\n\nPHISTAR FIT'
model.fitTo(roodata)
fitted_theta = theta.getValV()
# Histogram binning for data points
nbins = 10
xvals = np.linspace(0, 2*pi, 200)
yvals_H = []
yvals_A = []
# Get points for pdf curves
for xval in xvals:
self.phistar.setVal(xval)
yvals_H.append(self.pdfs['H'].getValV(RooArgSet(self.phistar)))
yvals_A.append(self.pdfs['A'].getValV(RooArgSet(self.phistar)))
yvals_H = np.array(yvals_H)
yvals_A = np.array(yvals_A)
# Plot pdfs by themselves
#print 'integral H =', np.trapz(yvals_H, dx=1.0/200.0)
fig = plt.figure()
plt.plot(xvals, yvals_H, color=self.colors['H'], label=r'$p_{H}(\varphi^{*})$')
plt.plot(xvals, yvals_A, color=self.colors['A'], label=r'$p_{A}(\varphi^{*})$')
plt.fill_between(xvals, 0, yvals_H, color=self.colors['H'], alpha=0.2)
plt.fill_between(xvals, 0, yvals_A, color=self.colors['A'], alpha=0.2)
plt.xlim([0, 2*pi])
plt.ylim([0, 0.295])
plt.xlabel(r'$\varphi^*$')
plt.ylabel('Probability density')
plt.legend(loc='upper right')
plt.tight_layout()
fig.show()
fig.savefig('phistar_pdfs.pdf')
# Scale to event yield
yvals_H *= roodata.numEntries()*(1-fitted_theta)/float(nbins)*2*pi
yvals_A *= roodata.numEntries()*(fitted_theta)/float(nbins)*2*pi
yvals_sum = yvals_H + yvals_A
# Make plot
fig, ax = plt.subplots(1)
histentries, binedges = np.histogram(x, bins=nbins, range=(0, 2*pi))
bincenters = (binedges[:-1] + binedges[1:])/2.0
yerr = np.sqrt(histentries)
plt.errorbar(bincenters, histentries, xerr=np.diff(binedges)*0.5, yerr=yerr, linestyle='None', ecolor='black', label='Data')
plt.plot(xvals, yvals_H, color=self.colors['H'], label=r'$p_{H}(\varphi^{*})$')
plt.plot(xvals, yvals_A, color=self.colors['A'], label=r'$p_{A}(\varphi^{*})$')
plt.plot(xvals, yvals_sum, color=self.colors['model'], label=r'$p(\varphi^{*} \,|\, \alpha = %.2f)$' % fitted_theta)
plt.fill_between(xvals, 0, yvals_H, color=self.colors['H'], alpha=0.2)
plt.fill_between(xvals, 0, yvals_A, color=self.colors['A'], alpha=0.2)
# Set correct legend order
handles, labels = ax.get_legend_handles_labels()
handles = [handles[3], handles[2], handles[0], handles[1]]
labels = [labels[3], labels[2], labels[0], labels[1]]
ax.legend(handles, labels, loc='upper right')
plt.xlabel(r'$\varphi^{*}$')
plt.ylabel('Events / %.2f' % ((2*pi)/nbins))
axes = plt.gca()
axes.set_xlim([0, 2*pi])
axes.set_ylim([0, max(histentries)*1.8])
plt.tight_layout()
fig.show()
fig.savefig('phistar_fit.pdf')
# Create likelihood curve
logl = model.createNLL(roodata)
# Extract curve
xvals = np.linspace(0, 1, 200)
yvals = []
ymin = 999.
for xval in xvals:
theta.setVal(xval)
yvals.append(logl.getValV())
if yvals[-1] < ymin:
ymin = yvals[-1]
# Shift minimum to zero
yvals = np.array(yvals)
yvals -= ymin
# Return points for the NLL curve
return xvals, yvals
ampMeasInds[ampName] = parList.index(ampName)
ampMeasSet = RooArgSet(ampMeasList)
# get covariances from likelihood fit
from ROOT import TMatrixDSym
ampMeasCovs = TMatrixDSym(len(ampMeasNames))
for ampIter, ampName in enumerate(ampMeasNames) :
for ampIter1, ampName1 in enumerate(ampMeasNames) :
ampMeasCovs[ampIter][ampIter1] = parCovs[ampMeasInds[ampName]][ampMeasInds[ampName1]]
# determine values of physics parameters
from ROOT import RooDataSet, RooMultiVarGaussian
ampsData = RooDataSet( 'ampsData', 'Measured transversity amplitudes', ampMeasSet )
ampsGauss = RooMultiVarGaussian( 'ampsGauss', 'Gaussian for measured transversity amplitudes'
, ampMeasList, ampFuncsList, ampMeasCovs )
ampsData.add(ampMeasSet)
ampsFitResult = ampsGauss.fitTo( ampsData, Save = True, **fitOpts )
print '\nJvLFit: reparameterization of transversity amplitudes:'
ampsData.Print()
ampMeasList.Print('v')
ampMeasCovs.Print()
ampsFitResult.Print()
ampsFitResult.covarianceMatrix().Print()
from P2VV.Imports import parNames, parValues4KKBins as parValues
print 'JvLFit: parameters:'
fitResult.PrintSpecial( text = True, LaTeX = True, normal = True, ParNames = parNames, ParValues = parValues )
fitResult.covarianceMatrix().Print()
fitResult.correlationMatrix().Print()
mc = RooDataSet('mc', '', getattr(ws, 'set')('observables'))
data = RooDataSet('data', '', getattr(ws, 'set')('observables'))
for ev in range(tree.GetEntries()):
tree.GetEntry(ev)
if tree.itype != -88 and tree.itype != 72 and tree.itype != 82: continue
if tree.bdtoutput < 0.2: continue
if tree.B0_MM < ws.var("mass").getMin() or tree.B0_MM > ws.var(
"mass").getMax():
continue
ws.var("mass").setVal(tree.B0_MM)
ws.var("gamgams_pt").setVal(tree.gamgams_PT)
if tree.itype == -88:
mc.add(getattr(ws, 'set')('observables'))
if tree.itype == 72 or tree.itype == 82:
data.add(getattr(ws, 'set')('observables'))
getattr(ws, 'import')(mc)
getattr(ws, 'import')(data)
ws.Print()
ws.factory("mean[5200,5300]")
ws.factory(
"CBShape:sig_cb1(mass,mean,sigma_1[10,200],alpha_1[0,1.],n_1[0.,50.])")
ws.factory(
"CBShape:sig_cb2(mass,mean,sigma_2[10,200],alpha_2[-1.,0.],n_2[0.,50.])")
ws.factory("SUM::mcsig( f[0.5,0,1]*sig_cb1, sig_cb2)")
tmp_jet_mass=getattr(treeIn,"mJJNoKinFit");
isGoodEvent = 0 ;
## event in the whole range
if options.channel == "em" :
if (getattr(treeIn,"categories")==1 or getattr(treeIn,"categories")==3) and getattr(treeIn,"mZZ")> rrv_mass_lvj.getMin() and getattr(treeIn,"mZZ")<rrv_mass_lvj.getMax() and tmp_jet_mass>=65 and tmp_jet_mass<=105 and options.category == "HP" :
isGoodEvent = 1 ;
if (getattr(treeIn,"categories")==0 or getattr(treeIn,"categories")==2) and getattr(treeIn,"mZZ")> rrv_mass_lvj.getMin() and getattr(treeIn,"mZZ")<rrv_mass_lvj.getMax() and tmp_jet_mass>=65 and tmp_jet_mass<=130 and options.category == "LP" :
isGoodEvent = 1 ;
if isGoodEvent == 1:
### weigh MC events
tmp_event_weight = getattr(treeIn,"weight")*luminosity;
rrv_mass_lvj.setVal(getattr(treeIn,"mZZ"));
rdataset4fit_mlvj.add(RooArgSet(rrv_mass_lvj),tmp_event_weight/tmp_scale_to_lumi);
### signal over convolution plot
mplot_sig = rrv_mass_lvj.frame(RooFit.Title(""),RooFit.Bins(rrv_mass_lvj.getBins()));
rdataset4fit_mlvj.plotOn(mplot_sig,RooFit.Name("data_invisible"),RooFit.MarkerSize(1.5),RooFit.DataError(RooAbsData.SumW2), RooFit.XErrorSize(0));
doubleCB_sig = ROOT.RooDoubleCrystalBall("DoubleCB_BulkG_WW_mlvj","DoubleCB_BulkG_WW_mlvj",rrv_mass_lvj,rrv_mean_CB,rrv_total_sigma_CB,rrv_alpha1_CB,rrv_n1_CB,rrv_alpha2_CB,rrv_n2_CB);
bw_sig = RooBreitWigner("bw_"+options.channel,"bw_"+options.channel,rrv_mass_lvj,rrv_total_mean_CB,rrv_width_BW);
original_bin = rrv_mass_lvj.getBins();
rrv_mass_lvj.setBins(1000,"cache");
model_pdf_sig = RooFFTConvPdf("sig_xww_%s_%s"%(options.channel,options.category),"sigxww_%s_%s"%(options.channel,options.category),rrv_mass_lvj,bw_sig,doubleCB_sig);
model_pdf_sig.setBufferFraction(1.0);
rrv_mass_lvj.setBins(int(original_bin));
def predict_and_plot(self, x):
"""
Do the same as predict(), but add plots
Return -logL ratio, for external plotting
"""
rcParams['xtick.major.pad'] = 12
rcParams['ytick.major.pad'] = 12
xs = self.scaler.transform(x)
preds = self.model.predict(xs)[:, 1]
roodata = RooDataSet('data', 'data', RooArgSet(self.roopred))
for pred in preds:
self.roopred.setVal(pred)
roodata.add(RooArgSet(self.roopred))
theta = RooRealVar('theta', 'theta', 0.5, self.theta_min, self.theta_max)
model = RooAddPdf('model', 'model',
RooArgList(self.pdfs['A'], self.pdfs['H']),
RooArgList(theta))
#with stdout_redirected_to():
print '\n\nNEURAL NETWORK FIT'
res = model.fitTo(roodata, PrintLevel(10))
fitted_theta = theta.getValV()
# Histogram binning for data points
nbins = 14
xvals = np.linspace(0, 1, 300)
yvals_H = []
yvals_A = []
# Get points for pdf curves
for xval in xvals:
self.roopred.setVal(xval)
yvals_H.append(self.pdfs['H'].getValV(RooArgSet(self.roopred)))
yvals_A.append(self.pdfs['A'].getValV(RooArgSet(self.roopred)))
yvals_H = np.array(yvals_H)
yvals_A = np.array(yvals_A)
# Plot pdfs by themselves
fig = plt.figure()
plt.plot(xvals, yvals_H, color=self.colors["H"], label=r'$p_{H}(y)$')
plt.plot(xvals, yvals_A, color=self.colors["A"], label=r'$p_{A}(y)$')
plt.fill_between(xvals, 0, yvals_H, color=self.colors["H"], alpha=0.2)
plt.fill_between(xvals, 0, yvals_A, color=self.colors["A"], alpha=0.2)
plt.xlim([0, 1])
plt.ylim([0, 11])
plt.xlabel(r'Network output ($y$)')
plt.ylabel('Probability density')
plt.legend(loc='upper right')
plt.tight_layout()
fig.show()
fig.savefig('mle_nn_pdfs.pdf')
# Scale to event yield
yvals_H *= roodata.numEntries()*(1-fitted_theta)/float(nbins)
yvals_A *= roodata.numEntries()*(fitted_theta)/float(nbins)
yvals_sum = yvals_H + yvals_A
# Make plot of fit to data
fig, ax = plt.subplots(1)
histentries, binedges = np.histogram(preds, bins=nbins, range=(0, 1))
bincenters = (binedges[:-1] + binedges[1:])/2.0
yerr = np.sqrt(histentries)
plt.errorbar(bincenters, histentries, xerr=np.diff(binedges)*0.5, yerr=yerr, linestyle='None', ecolor='black', label='Data')
plt.plot(xvals, yvals_H, color=self.colors["H"], label=r'$p_{H}(y)$')
plt.plot(xvals, yvals_A, color=self.colors["A"], label=r'$p_{A}(y)$')
plt.plot(xvals, yvals_sum, color=self.colors["model"], label=r'$p(y \,|\, \alpha = %.2f)$' % fitted_theta)
plt.fill_between(xvals, 0, yvals_H, color=self.colors["H"], alpha=0.2)
plt.fill_between(xvals, 0, yvals_A, color=self.colors["A"], alpha=0.2)
# Set correct legend order
handles, labels = ax.get_legend_handles_labels()
handles = [handles[3], handles[2], handles[0], handles[1]]
labels = [labels[3], labels[2], labels[0], labels[1]]
ax.legend(handles, labels, loc='upper right')
plt.xlabel(r'Network output ($y$)')
plt.ylabel('Events / %.2f' % (1.0/nbins))
axes = plt.gca()
axes.set_xlim([0, 1])
axes.set_ylim([0, max(histentries)*2.3])
plt.tight_layout()
fig.show()
fig.savefig('mle_nn_fit.pdf')
# Create likelihood curve
logl = model.createNLL(roodata)
xvals = np.linspace(0, 1, 200)
yvals = []
ymin = 999.
for xval in xvals:
theta.setVal(xval)
yvals.append(logl.getValV())
if yvals[-1] < ymin:
ymin = yvals[-1]
yvals = np.array(yvals)
yvals -= ymin
# Return points for the NLL curve
return xvals, yvals
class CouplingsFitter2(object):
def __init__(self):
self.poiLabels = []
self.BR = dict(b=0.577,
tau=0.063,
mu=2.2e-4,
c=2.91e-2,
g=8.57e-2,
gamma=3.82e-3,
W=0.215,
Z=0.0264,
t=0.0)
self.poi = dict()
self.poilabels = dict()
self.constraint = dict()
self.canvases = dict()
self._keep = []
def addPOI(self, poi, label='', minimum=-0.3, maximum=0.3):
'''Add a parameter of interest.
Example:
addPOI('Z','Z',-0.05,0.05)
->
Z[0,-0.05,0.05]
# adds variable Z with value 0,
# allow it to scale between -0.05 and 0.05
'''
self.poi[poi] = ROOT.RooRealVar(poi, poi, 0, minimum, maximum)
if label == '':
label = poi
self.poilabels[poi] = label
def createWidthDeviation(self):
'''Compute the width deviation (denoted \kappa_H^2 by M.Peskin in arxiv 1312.4974).
Note that we fit an additive modification of the coupling: (1 + dx)
is therefore equal to kappa_x
'''
expr = '0'
sumBR = sum(self.BR.values())
pwidths = []
for dcoupling, br in self.BR.iteritems():
pwidth = None
if dcoupling in self.poi:
pwidth = str(
br /
sumBR) + "*(1+" + dcoupling + ")*(1+" + dcoupling + ")"
else:
# using sm partial width
pwidth = str(br / sumBR)
pwidths.append(pwidth)
expr = '+'.join(pwidths)
if 'inv' in self.poi:
expr = '(' + expr + ')/(1.0-inv)'
else:
# setting invisible width to 0.
expr = '(' + expr + ')'
dependentlist = RooArgList()
for dep in self.poi.values():
dependentlist.add(dep)
self.width = RooGenericPdf('width', 'width', expr, dependentlist)
def addConstraint(self, name, expr, deplist, mean, sigma):
'''Add a constraint on one of the observables
For example, for ZH inclusive:
f.addConstraint('Zh','(1+Z)*(1+Z)','Z',1,0.004)
Z is an additive modification of the gZ coupling w/r to the standard model,
so 1+Z = \kappa_Z
Zh is the pdf of the ratio of the yield w/r to the one expected in the standard model.
This pdf depends on Z, as (1+Z)*(1+Z).
ZhObs is the measured value, here 1 so we assume that the SM yield is observed.
The fit varies the parameter of interest Z, thus modifying the pdf,
while ZhObs is fixed at 1. The likelihood of each value of Z is evaluated at ZhObs on the pdf.
'''
print 'constraint:', name
print expr
print deplist
print mean, '+/-', sigma
deps = self._getdeps(deplist)
self.constraint[name] = GaussianConstraint(name, expr, deps, mean,
sigma)
def _getdeps(self, deplist):
depnames = deplist
try:
depnames = deplist.split(',')
except:
pass
deps = []
for dep in depnames:
if dep == 'width':
deps.append(self.width)
else:
deps.append(self.poi[dep])
return deps
def addChannel(self, name, mean, sigma, prod, decay=None):
expr_prod = '(1+{prod})*(1+{prod})'.format(prod=prod)
expr = expr_prod
variables = [prod]
if decay:
if isinstance(decay, basestring):
expr_decay = '(1+{decay})*(1+{decay})'.format(decay=decay)
variables.append(decay)
else:
decay_exprs = []
for decay, fraction in decay:
n = mean * fraction
decay_expr = '{n}*(1+{decay})*(1+{decay})'.format(
n=n, decay=decay)
decay_exprs.append(decay_expr)
variables.append(decay)
expr_decay = ' + '.join(decay_exprs)
expr = '{expr_prod}*({expr_decay})/width'.format(
expr_prod=expr_prod,
expr_decay=expr_decay,
)
variables.append('width')
variables = list(set(variables))
deplist = ','.join(variables)
self.addConstraint(name, expr, deplist, mean, sigma)
def addUniformConstraint(self, name, expr):
'''Adds a uniform constraint with pdf name, and expression expr.
For example:
f.addPOI('inv','inv', 0, 0.01)
f.addUniformConstraint('Zhinv','inv') ####->Means free floating
inv (the invisible BR) is free to float between 0 and 1%
'''
deps = self._getdeps([expr])
self.constraint[name] = UniformConstraint(name, expr, deps)
def info(self):
for name, constraint in sorted(self.constraint.iteritems()):
constraint.info()
def fit(self):
pdfs = RooArgList()
obsvars = RooArgSet('set')
for constraint in self.constraint.values():
pdfs.add(constraint.pdf_constraint)
if hasattr(constraint, 'var_obs'):
obsvars.add(constraint.var_obs)
self.model = RooProdPdf('model', 'model', pdfs)
self.data = RooDataSet('data', 'data', obsvars)
self.data.add(obsvars)
self.data.Print()
self.fit_result = self.model.fitTo(self.data,
ROOT.RooFit.PrintLevel(3),
ROOT.RooFit.Optimize(1),
ROOT.RooFit.Hesse(1),
ROOT.RooFit.Minos(1),
ROOT.RooFit.Strategy(2),
ROOT.RooFit.Save(1))
def canvas(self, name, *args):
canvas = self.canvases.setdefault(name,
ROOT.TCanvas(name, name, *args))
canvas.cd()
return canvas
def keep(self, obj):
self._keep.append(obj)
return obj
def createSummary(self):
#sample the covariance matrix for the width
# ROOT.gStyle.SetOptTitle(0)
ROOT.gStyle.SetStatW(0.4)
ROOT.gStyle.SetStatH(0.4)
self.graph_couplings = ROOT.TGraphAsymmErrors(len(self.poi) + 2)
order_BR = ['Z', 'W', 'b', 'c', 'g', 'tau', 'mu', 'gamma', 'inv']
for br in order_BR:
if not self.poi.get(br, None):
order_BR.remove(br)
for i, poiname in enumerate(order_BR):
poi = self.poi.get(poiname)
self.graph_couplings.SetPoint(i, i + 0.5, poi.getVal())
self.graph_couplings.SetPointError(i, 0.0, 0.0,
-poi.getAsymErrorLo(),
poi.getAsymErrorHi())
print 'Sampling the covariance matrix to propagate error on width'
self.h_width = ROOT.TH1F('h_width', 'width', 1000, 0.5, 1.5)
ntoys = 10000
for i in range(ntoys):
randomizedPars = self.fit_result.randomizePars()
for j in range(0, randomizedPars.getSize()):
self.poi[randomizedPars.at(j).GetName()].setVal(
randomizedPars.at(j).getVal())
self.h_width.Fill(self.width.getVal())
for cstr in self.constraint.values():
cstr.fill_pull()
self.graph_couplings.SetMarkerStyle(20)
self.graph_couplings.SetLineWidth(3)
can_couplings = self.canvas('couplings')
self.graph_couplings.Draw("AP")
self.graph_couplings.GetYaxis().SetTitle("68% CL on d(A) ")
self.graph_couplings.GetXaxis().SetNdivisions(0)
l = self.keep(ROOT.TLine())
l.SetLineColor(ROOT.kRed)
l.SetLineWidth(3)
l.DrawLine(0.0, 0.0, len(self.poi) + 1.5, 0)
self.graph_couplings.SetPoint(len(self.poi), len(self.poi) + 0.5, 0.0)
self.graph_couplings.SetPointError(
len(self.poi), 0.0, 0.0,
self.h_width.GetRMS() / self.h_width.GetMean(),
self.h_width.GetRMS() / self.h_width.GetMean())
for i, poiname in enumerate(order_BR + ['#Gamma_{T}']):
label = self.poilabels.get(poiname, poiname)
tex = self.keep(
ROOT.TLatex(i + 0.5,
0.95 * self.graph_couplings.GetYaxis().GetXmin(),
label))
tex.Draw()
print """
###############################################################
###############################################################
###############################################################
RESULTS
###############################################################
###############################################################
###############################################################
"""
print 'RESULTS FOR THE CONFIDENCE INTERVALS------>'
for name in order_BR:
poi = self.poi[name]
poiLabel = self.poilabels.get(name, name)
mind = poi.getAsymErrorLo() * 100
maxd = poi.getAsymErrorHi() * 100
avd = abs(maxd - mind) / 2.
# print poiLabel+': ('+str(poi.getAsymErrorLo())+','+str(poi.getAsymErrorHi())+'), ' + str(avd)
print '{label:10}:\t{mind:5.3f}%\t{maxd:5.3f}%\t{avd:5.3f}%'.format(
label=poiLabel, mind=mind, maxd=maxd, avd=avd)
can_gamma = self.canvas('gamma')
self.h_width.GetXaxis().SetTitle("#Gamma_{T}")
self.h_width.GetYaxis().SetTitle("N toys")
self.h_width.Draw()
print 'Relative error on the total width ', self.h_width.GetRMS(
) / self.h_width.GetMean()
print 'Please check the histogram to see that the dist is Gaussian. If not the fit is biased'
print 'The fit can be biased when floating the width sometimes.'
can_pulls = self.canvas('pulls', 1000, 1000)
npulls = len(self.constraint)
nxy = int(math.ceil(math.sqrt(npulls)))
can_pulls.Divide(nxy, nxy)
for i, c in enumerate(self.constraint.values()):
can_pulls.cd(i + 1)
c.pulls.Draw()
def create_pdfs(self, paths_to_data, save=True):
"""
Create KDE pdfs for network output distribution
"""
if not isinstance(paths_to_data, list):
paths_to_data = [paths_to_data]
files_H = []
files_A = []
for path in paths_to_data:
# These are merged, so only one of each
if not path.endswith('/'): path += '/'
files_H.append(path+'model_H_merged.h5')
files_A.append(path+'model_A_merged.h5')
# Find background samples
files_bgnd = []
for path in paths_to_data:
for sample in self.samples:
if sample not in ['H', 'A']:
files_bgnd.append(path+'/model_%s_merged.h5' % sample)
# Read in the data
dataH_X, _, feats = self.read_array_from_files(files_H)
dataH_X, _ = select_features(dataH_X, feats, include_mass_variables=False)
dataH_X = self.scaler.transform(dataH_X)
rho = 0.8
#ntemplateevents = 1000000
ntemplateevents = 500000
#ntemplateevents = 50000
print 'Limiting events for pdf creation to %d' % ntemplateevents
# 700k -> 4h 42m
# 500k -> 2h 30m
# 200k -> 0h 27m
# 100k -> 0h 7m
# 50k -> 0h 2m
dataH_X = dataH_X[:ntemplateevents]
# Predict, fill a RooDataHist
starttime = time.time()
predsH = self.model.predict(dataH_X)[:,1]
self.roopred = RooRealVar('roopred', 'roopred', 0, 1)
roopreddataH = RooDataSet('roopreddataH', 'roopreddataH', RooArgSet(self.roopred))
for pred in predsH:
self.roopred.setVal(pred)
roopreddataH.add(RooArgSet(self.roopred))
# Create the KDE pdfs
def createKDE(self, data, htype):
starttime = time.time()
keys = RooKeysPdf('keys%s' % htype, 'keys%s' % htype, self.roopred, data)
self.pdfs[htype] = keys
print 'Creating KDE pdf for %s took %s' % (htype, time.strftime("%H:%M:%S", time.gmtime(time.time()-starttime)))
from ROOT.RooKeysPdf import NoMirror
keysH = RooKeysPdf('keysH', 'keysH', self.roopred, roopreddataH, NoMirror, rho)
self.pdfs['H'] = keysH
# Do the same for A
dataA_X, _, feats = self.read_array_from_files(files_A)
dataA_X, _ = select_features(dataA_X, feats, include_mass_variables=False)
dataA_X = self.scaler.transform(dataA_X)
dataA_X = dataA_X[:ntemplateevents]
starttime = time.time()
predsA = self.model.predict(dataA_X)[:,1]
roopreddataA = RooDataSet('roopreddataA', 'roopreddataA', RooArgSet(self.roopred))
for pred in predsA:
self.roopred.setVal(pred)
roopreddataA.add(RooArgSet(self.roopred))
keysA = RooKeysPdf('keysA', 'keysA', self.roopred, roopreddataA, NoMirror, rho)
self.pdfs['A'] = keysA
if save:
ws = RooWorkspace('ws', 'ws')
getattr(ws, 'import')(self.roopred)
getattr(ws, 'import')(self.pdfs['H'])
getattr(ws, 'import')(self.pdfs['A'])
ws.writeToFile('%s/pdfs_%s.root' % (self.outdir, self.title))
def setupWorkspace(ws, options):
cfg = options.config #for convenience
fit_sections = cfg.sections()
fit_sections.remove(
'Global') #don't need to iterate over the global configuration
if not isinstance(ws, RooWorkspace):
print "You didn't pass a RooWorkspace!"
exit(1)
cpling_type = cfg.get('Global', 'couplingType')
par1 = cfg.get('Global', 'par1Name')
par1bound = [
-cfg.getfloat('Global', 'par1Max'),
cfg.getfloat('Global', 'par1Max')
]
par2 = cfg.get('Global', 'par2Name')
par2bound = [
-cfg.getfloat('Global', 'par2Max'),
cfg.getfloat('Global', 'par2Max')
]
#create the parameters in the workspace
ws.factory('%s_%s[0,%f,%f]' %
(par1, cpling_type, par1bound[0], par1bound[1]))
ws.factory('%s_%s[0,%f,%f]' %
(par2, cpling_type, par2bound[0], par2bound[1]))
# since the lumi error is correlated among all channels we only need one penalty term for it
lumi_err = exp(options.config.getfloat(
'Global', 'lumi_err')) # exp because we use log normal
ws.factory('luminosityError[%f]' % lumi_err)
ws.factory('RooLognormal::lumiErr(err_gl[1,0.0001,50],1,luminosityError)')
channel_cat = RooCategory('channels', 'channels')
#first pass: process the backgrounds, signal and data into
# simultaneous counting pdfs over the bins
for section in fit_sections:
#create the basic observable, this is used behind the scenes
#in the background and signal models
channel_cat.defineType(section)
channel_cat.setLabel(section)
print 'Building pdf for configuration section:', section
for it, bkg in getBackgroundsInCfg(section, cfg).iteritems():
ws.factory('backgroundError_%s_%s[%f]' %
(section, it, exp(bkg[1])))
ws.factory('selectionError_%s[%f]' %
(section, exp(cfg.getfloat(section, 'selection_err'))))
processFittingData(ws, cfg, section)
processSignalModel(ws, cfg, section)
processBackgroundModel(ws, cfg, section)
createPdfForChannel(ws, cfg, section)
ws.data('countingdata_%s' % section).addColumn(channel_cat)
getattr(ws, 'import')(channel_cat)
top = RooSimultaneous('TopLevelPdf', 'TopLevelPdf', ws.cat('channels'))
alldatavars = RooArgSet(ws.cat('channels'))
conditionals = RooArgSet()
#second pass: process counting pdfs into simultaneous pdf over channels
for section in fit_sections:
top.addPdf(ws.pdf('countingpdf_%s' % section), section)
alldatavars.add(ws.var('%s_%s' %
(cfg.get(section, 'obsVar'), section)))
conditionals.add(
ws.var('%s_%s' % (cfg.get(section, 'obsVar'), section)))
alldatavars.add(ws.var('n_observed_%s' % section))
getattr(ws, 'import')(top)
ws.defineSet('condObs', conditionals)
allcountingdata = RooDataSet('allcountingdata', 'allcountingdata',
alldatavars)
getattr(ws, 'import')(allcountingdata)
allcountingdata = ws.data('allcountingdata')
#third pass: make the final combined dataset
for section in fit_sections:
current = ws.data('countingdata_%s' % section)
print 'countingdata_%s has %d entries' % (section,
current.numEntries())
for i in range(current.numEntries()):
alldatavars = current.get(i)
allcountingdata.add(alldatavars)
def gen_data_and_fit(ws, iterations, cat, mass, channel, turnon, truth):
if channel in channels:
#fit gaus(x)bern to sigm(x)pow and sigm(x)exp
#fit sigm(x)bern to erf(x)pow and erf(x)exp
n_sample = int(ws.data('bkgdata_%s_%i' % (channel, cat)).sumEntries())
if turnon == 'erf' and truth == 'exp':
ws.factory('pull_ROI_erf_on_sigmexp_%s_cat%i[0]' % (channel, cat))
ws.defineSet('biasVars_%s_cat%i' % (channel, cat),
'pull_ROI_erf_on_sigmexp_%s_cat%i,' % (channel, cat))
if turnon == 'erf' and truth == 'pow':
ws.factory('pull_ROI_erf_on_sigmpow_%s_cat%i[0]' % (channel, cat))
ws.defineSet('biasVars_%s_cat%i' % (channel, cat),
'pull_ROI_erf_on_sigmpow_%s_cat%i,' % (channel, cat))
if turnon == 'sigm' and truth == 'exp':
ws.factory('pull_ROI_sigm_on_erfexp_%s_cat%i[0]' % (channel, cat))
ws.defineSet('biasVars_%s_cat%i' % (channel, cat),
'pull_ROI_sigm_on_erfexp_%s_cat%i,' % (channel, cat))
if turnon == 'sigm' and truth == 'pow':
ws.factory('pull_ROI_sigm_on_erfpow_%s_cat%i[0]' % (channel, cat))
ws.defineSet('biasVars_%s_cat%i' % (channel, cat),
'pull_ROI_sigm_on_erfpow_%s_cat%i' % (channel, cat))
biasData = RooDataSet('biasData_%s_cat%i' % (channel, cat),
'bias data',
ws.set('biasVars_%s_cat%i' % (channel, cat)))
for i in xrange(iterations):
### SIGM
#build ERF toy data to fit with SIGM
if turnon == 'sigm' and truth == 'exp':
truth_exp_erf = ws.pdf('MzgTruthModel_exp_erf_%s_cat%i' %
(channel, cat))
toy_data_exp_erf = truth_exp_erf.generate(
RooArgSet(ws.var('Mzg')), n_sample, RooFit.Extended(),
RooFit.Name('toy_erfexp_%s_cat%i_%i' % (channel, cat, i)))
true_ROI_yield_erfexp = ws.var('norm_truth_exp_%s_cat%i' %
(channel, cat)).getVal()
#fit logistics(x)bern to erfexp
ws.var('norm_altrsb_cat%i' % cat).setMin(
true_ROI_yield_erfexp * 0.25)
ws.var('norm_altrsb_cat%i' % cat).setMax(
true_ROI_yield_erfexp * 1.75)
ws.var('norm_altrsb_cat%i' % cat).setVal(true_ROI_yield_erfexp)
minos_var = RooArgSet(ws.var('norm_altrsb_cat%i' % cat))
sigm_nll = ws.pdf('RSBFitModelAlt_cat%i' %
cat).createNLL(toy_data_exp_erf)
sigm_min = RooMinimizer(sigm_nll)
sigm_min.setPrintLevel(1)
sigm_min.minimize('Minuit2', 'scan')
sigm_min.minimize('Minuit2', 'simplex')
migrad_out = sigm_min.migrad()
migrad_out = sigm_min.migrad()
hesse_out = sigm_min.hesse()
fit_sigm_norm = ws.var('norm_altrsb_cat%i' % cat).getVal()
fit_sigm_err = ws.var('norm_altrsb_cat%i' % cat).getError()
fit_sigm_pull = (fit_sigm_norm -
true_ROI_yield_erfexp) / fit_sigm_err
#if fit failed run minos
if migrad_out != 0 or hesse_out != 0:
migrad_out = sigm_min.migrad()
if migrad_out != 0:
sigm_min.minos(minos_var)
fit_sigm_err = max(
abs(
ws.var('norm_altrsb_cat%i' %
cat).getErrorHi()),
abs(
ws.var('norm_altrsb_cat%i' %
cat).getErrorLo()))
else:
fit_sigm_err = ws.var('norm_altrsb_cat%i' %
cat).getError()
fit_sigm_norm = ws.var('norm_altrsb_cat%i' % cat).getVal()
fit_sigm_pull = (fit_sigm_norm -
true_ROI_yield_erfexp) / fit_sigm_err
print i, fit_sigm_norm, fit_sigm_err, true_ROI_yield_erfexp, fit_sigm_pull
ws.var('pull_ROI_sigm_on_erfexp_%s_cat%i' %
(channel, cat)).setVal(fit_sigm_pull)
biasData.add(ws.set('biasVars_%s_cat%i' % (channel, cat)))
var = ws.var('pull_ROI_sigm_on_erfexp_%s_cat%i' %
(channel, cat))
print 'cumulative median bias: %.3f' % calculate_median(
var, biasData)
var = None
del sigm_min
del sigm_nll
del truth_exp_erf
if turnon == 'sigm' and truth == 'pow':
truth_pow_erf = ws.pdf('MzgTruthModel_pow_erf_%s_cat%i' %
(channel, cat))
toy_data_pow_erf = truth_pow_erf.generate(
RooArgSet(ws.var('Mzg')), n_sample, RooFit.Extended(),
RooFit.Name('toy_erfpow_%s_cat%i_%i' % (channel, cat, i)))
true_ROI_yield_erfpow = ws.var('norm_truth_pow_erf_%s_cat%i' %
(channel, cat)).getVal()
#fit logistics(x)bern to erfpow
ws.var('norm_altrsb_cat%i' % cat).setMin(
true_ROI_yield_erfpow * 0.25)
ws.var('norm_altrsb_cat%i' % cat).setMax(
true_ROI_yield_erfpow * 1.75)
ws.var('norm_altrsb_cat%i' % cat).setVal(true_ROI_yield_erfpow)
minos_var = RooArgSet(ws.var('norm_altrsb_cat%i' % cat))
sigm_nll = ws.pdf('RSBFitModelAlt_cat%i' %
cat).createNLL(toy_data_pow_erf)
sigm_min = RooMinimizer(sigm_nll)
sigm_min.setPrintLevel(1)
sigm_min.minimize('Minuit2', 'scan')
sigm_min.minimize('Minuit2', 'simplex')
migrad_out = sigm_min.migrad()
migrad_out = sigm_min.migrad()
hesse_out = sigm_min.hesse()
fit_sigm_norm = ws.var('norm_altrsb_cat%i' % cat).getVal()
fit_sigm_err = ws.var('norm_altrsb_cat%i' % cat).getError()
fit_sigm_pull = (fit_sigm_norm -
true_ROI_yield_erfpow) / fit_sigm_err
#if fit failed run minos
if migrad_out != 0 or hesse_out != 0:
migrad_out = sigm_min.migrad()
if migrad_out != 0:
sigm_min.minos(minos_var)
fit_sigm_err = max(
abs(
ws.var('norm_altrsb_cat%i' %
cat).getErrorHi()),
abs(
ws.var('norm_altrsb_cat%i' %
cat).getErrorLo()))
else:
fit_sigm_err = ws.var('norm_altrsb_cat%i' %
cat).getError()
fit_sigm_norm = ws.var('norm_altrsb_cat%i' % cat).getVal()
fit_sigm_pull = (fit_sigm_norm -
true_ROI_yield_erfpow) / fit_sigm_err
ws.var('pull_ROI_sigm_on_erfpow_%s_cat%i' %
(channel, cat)).setVal(fit_sigm_pull)
print i, fit_sigm_norm, fit_sigm_err, true_ROI_yield_erfpow, fit_sigm_pull
biasData.add(ws.set('biasVars_%s_cat%i' % (channel, cat)))
var = ws.var('pull_ROI_sigm_on_erfpow_%s_cat%i' %
(channel, cat))
print 'cumulative median bias: %.3f' % calculate_median(
var, biasData)
var = None
del sigm_min
del sigm_nll
del truth_pow_erf
##### ERF
# generate SIGM data to fit with ERF
#### fit erf(x)bern models
if turnon == 'erf' and truth == 'exp':
truth_exp_sigm = ws.pdf('MzgTruthModel_exp_sigm_%s_cat%i' %
(channel, cat))
toy_data_exp_sigm = truth_exp_sigm.generate(
RooArgSet(ws.var('Mzg')), n_sample, RooFit.Extended(),
RooFit.Name('toy_sigmexp_%s_cat%i_%i' % (channel, cat, i)))
true_ROI_yield_sigmexp = ws.var(
'norm_truth_exp_sigm_%s_cat%i' % (channel, cat)).getVal()
#fit erf(x)bern to sigmexp
ws.var('norm_rsb_cat%i' % cat).setMin(true_ROI_yield_sigmexp *
0.25)
ws.var('norm_rsb_cat%i' % cat).setMax(true_ROI_yield_sigmexp *
1.75)
ws.var('norm_rsb_cat%i' % cat).setVal(true_ROI_yield_sigmexp)
minos_var = RooArgSet(ws.var('norm_rsb_cat%i' % cat))
gaus_nll = ws.pdf('RSBFitModel_cat%i' %
cat).createNLL(toy_data_exp_sigm)
gaus_min = RooMinimizer(gaus_nll)
gaus_min.setPrintLevel(1)
gaus_min.minimize('Minuit2', 'scan')
gaus_min.minimize('Minuit2', 'simplex')
migrad_out = gaus_min.migrad()
migrad_out = gaus_min.migrad()
hesse_out = gaus_min.hesse()
#get parabolic errors regardless
fit_erf_norm = ws.var('norm_rsb_cat%i' % cat).getVal()
fit_erf_err = ws.var('norm_rsb_cat%i' % cat).getError()
fit_erf_pull = (fit_erf_norm -
true_ROI_yield_sigmexp) / fit_erf_err
#if fit failed run minos
if migrad_out != 0 or hesse_out != 0:
migrad_out = gaus_min.migrad()
if migrad_out != 0:
gaus_min.minos(minos_var)
fit_erf_err = max(
abs(ws.var('norm_rsb_cat%i' % cat).getErrorHi()),
abs(ws.var('norm_rsb_cat%i' % cat).getErrorLo()))
else:
fit_erf_err = ws.var('norm_rsb_cat%i' % cat).getError()
fit_erf_norm = ws.var('norm_rsb_cat%i' % cat).getVal()
fit_erf_pull = (fit_erf_norm -
true_ROI_yield_sigmexp) / fit_erf_err
ws.var('pull_ROI_erf_on_sigmexp_%s_cat%i' %
(channel, cat)).setVal(fit_erf_pull)
print i, fit_erf_norm, fit_erf_err, true_ROI_yield_sigmexp, fit_erf_pull
biasData.add(ws.set('biasVars_%s_cat%i' % (channel, cat)))
var = ws.var('pull_ROI_erf_on_sigmerf_%s_cat%i' %
(channel, cat))
print 'cumulative median bias: %.3f' % calculate_median(
var, biasData)
var = None
del gaus_min
del gaus_nll
del truth_exp_sigm
if turnon == 'erf' and truth == 'pow':
truth_pow_sigm = ws.pdf('MzgTruthModel_pow_sigm_%s_cat%i' %
(channel, cat))
toy_data_pow_sigm = truth_pow_sigm.generate(
RooArgSet(ws.var('Mzg')), n_sample, RooFit.Extended(),
RooFit.Name('toy_sigmpow_%s_cat%i_%i' % (channel, cat, i)))
true_ROI_yield_sigmpow = ws.var(
'norm_truth_pow_sigm_%s_cat%i' % (channel, cat)).getVal()
#fit erf(x)bern to sigmpow
ws.var('norm_rsb_cat%i' % cat).setMin(true_ROI_yield_sigmpow *
0.25)
ws.var('norm_rsb_cat%i' % cat).setMax(true_ROI_yield_sigmpow *
1.75)
ws.var('norm_rsb_cat%i' % cat).setVal(true_ROI_yield_sigmpow)
minos_var = RooArgSet(ws.var('norm_rsb_cat%i' % cat))
gaus_nll = ws.pdf('RSBFitModel_cat%i' %
cat).createNLL(toy_data_pow_sigm)
gaus_min = RooMinimizer(gaus_nll)
gaus_min.setPrintLevel(1)
gaus_min.minimize('Minuit2', 'scan')
gaus_min.minimize('Minuit2', 'simplex')
migrad_out = gaus_min.migrad()
migrad_out = gaus_min.migrad()
hesse_out = gaus_min.hesse()
fit_erf_norm = ws.var('norm_rsb_cat%i' % cat).getVal()
fit_erf_err = ws.var('norm_rsb_cat%i' % cat).getError()
fit_erf_pull = (fit_erf_norm -
true_ROI_yield_sigmpow) / fit_erf_err
#if fit failed run minos
if migrad_out != 0 or hesse_out != 0:
migrad_out = gaus_min.migrad()
if migrad_out != 0:
gaus_min.minos(minos_var)
fit_erf_err = max(
abs(ws.var('norm_rsb_cat%i' % cat).getErrorHi()),
abs(ws.var('norm_rsb_cat%i' % cat).getErrorLo()))
else:
fit_erf_err = ws.var('norm_rsb_cat%i' % cat).getError()
fit_erf_norm = ws.var('norm_rsb_cat%i' % cat).getVal()
fit_erf_pull = (fit_erf_norm -
true_ROI_yield_sigmpow) / fit_erf_err
print i, fit_erf_norm, fit_erf_err, true_ROI_yield_sigmpow, fit_erf_pull
ws.var('pull_ROI_erf_on_sigmpow_%s_cat%i' %
(channel, cat)).setVal(fit_erf_pull)
biasData.add(ws.set('biasVars_%s_cat%i' % (channel, cat)))
var = ws.var('pull_ROI_erf_on_sigmpow_%s_cat%i' %
(channel, cat))
print 'cumulative median bias: %.3f' % calculate_median(
var, biasData)
var = None
#getattr(ws,'import')(toy_data_exp_sigm)
#getattr(ws,'import')(toy_data_pow_sigm)
del gaus_min
del gaus_nll
del truth_pow_sigm
getattr(ws, 'import')(biasData)
def makeRooDataSet(type,infile_name,outfile_name,tree_name,nevents):
""" Make RooDataSets from TTrees"""
inputfile = TFile.Open(infile_name,"READ")
print "Importing tree"
tree = TTree()
inputfile.GetObject(tree_name, tree) #get the tree from the data file
#define variables for the RooDataSet
m_mumu = RooRealVar("m_mumu", "m_mumu", 0.0, 4.0)
y_mumu = RooRealVar("y_mumu", "y_mumu", 0.0, 2.0 )
pt_mumu = RooRealVar("pt_mumu", "pt_mumu", 0.0, 260.0)
eta_gamma = RooRealVar("eta_gamma","eta_gamma",-3.5, 3.5)
pt_gamma = RooRealVar("pt_gamma", "pt_gamma", 0.0, 100.0)
m_gamma = RooRealVar("m_gamma", "m_gamma", -0.1,0.1)
m_chi_rf1S = RooRealVar("m_chi_rf1S", "m_chi_rf1S", 0.0, 7.0)
m_chi_rf2S = RooRealVar("m_chi_rf2S", "m_chi_rf2S", -1.0, 1.0)
#Qvalue = RooRealVar("Qvalue","Q", -15., 15.)
s = RooRealVar("s","s", -10., 10.)
ctpv = RooRealVar("ctpv","ctpv", -1.0, 3.5)
ctpv_error = RooRealVar("ctpv_err","ctpv_err", -1.0, 1.0)
pi0_abs_mass = RooRealVar("pi0_abs_mass","pi0_abs_mass", 0.0, 2.2)
psi1S_nsigma = RooRealVar("psi1S_nsigma","psi1S_nsigma",0.0,1.0)
psi2S_nsigma = RooRealVar("psi2S_nsigma","psi2S_nsigma",0.0,1.0)
psi3S_nsigma = RooRealVar("psi3S_nsigma","psi3S_nsigma",0.0,1.0)
rho_conv = RooRealVar("rho_conv", "rho_conv", 0.0, 70.0)
dz = RooRealVar("dz","dz", -1.0, 1.0)
probFit1S = RooRealVar("probFit1S","probFit1S",0,1)
probFit2S = RooRealVar("probFit2S","probFit2S",0,1)
dataArgSet = RooArgSet(m_mumu,
y_mumu,
pt_mumu,
eta_gamma,
pt_gamma,
m_gamma,
m_chi_rf1S)
dataArgSet.add( m_chi_rf2S )
dataArgSet.add( s )
dataArgSet.add( ctpv )
dataArgSet.add( ctpv_error )
dataArgSet.add( pi0_abs_mass )
dataArgSet.add( psi1S_nsigma )
dataArgSet.add( psi2S_nsigma )
dataArgSet.add( rho_conv )
dataArgSet.add( dz )
dataArgSet.add( probFit1S )
dataArgSet.add( probFit2S )
print "Creating DataSet"
dataSet = RooDataSet("chicds","Chic RooDataSet", dataArgSet)
entries = tree.GetEntries()
print entries
if nevents is not 0:
entries = nevents
for ientry in range(0,entries):
tree.GetEntry(ientry)
# unfort ntuples are slightly different for chic and chib
if type == 'chic':
m_mumu.setVal(tree.dimuon_mass)
y_mumu.setVal(tree.dimuon_rapidity)
pt_mumu.setVal(tree.dimuon_pt)
eta_gamma.setVal(tree.photon_eta)
pt_gamma.setVal(tree.photon_pt)
#m_gamma.setVal(tree.photon_p4.M())
m_chi_rf1S.setVal(tree.rf1S_chic_mass)
#m_chi_rf1S.setVal(tree.rf2S_chi_p4.M())
#Qvalue.setVal((tree.chi_p4).M() - tree.dimuon_p4.M())
#Qvalue.setVal((tree.chi_p4).M()**2 - tree.dimuon_p4.M()**2)
#Qvalue.setVal((tree.rf1S_chic_mass**2 -tree.dimuon_mass**2)
# / (3.5107**2 - 3.0969**2 ) -1)
# this should be the correct one if the refitted variable was available
# s.setVal((tree.rf1S_chic_mass**2 - tree.rf1S_dimuon_p4.M()**2)/ (3.5107**2 - 3.0969**2 ) -1)
s.setVal((tree.rf1S_chic_mass**2 - 3.0969**2)/ (3.5107**2 - 3.0969**2 ) -1)
psi1S_nsigma.setVal(tree.psi1S_nsigma)
psi2S_nsigma.setVal(0)
psi3S_nsigma.setVal(0)
elif type == 'chib':
m_mumu.setVal(tree.dimuon_mass)
y_mumu.setVal(tree.dimuon_rapidity)
pt_mumu.setVal(tree.dimuon_pt)
eta_gamma.setVal(tree.photon_eta)
pt_gamma.setVal(tree.photon_pt)
m_chi_rf1S.setVal(tree.rf1S_chib_mass)
m_chi_rf2S.setVal(tree.rf2S_chib_mass)
Qvalue.setVal(tree.chib_mass - tree.dimuon_mass)
psi1S_nsigma.setVal(tree.Y1S_nsigma)
psi2S_nsigma.setVal(tree.Y2S_nsigma)
psi3S_nsigma.setVal(tree.Y3S_nsigma)
ctpv.setVal(tree.ct_pv)
ctpv_error.setVal(tree.ct_pv_error)
#pi0_abs_mass.setVal(tree.pi0_abs_mass)
rho_conv.setVal(tree.Conv)
dz.setVal(tree.Dz)
probFit1S.setVal(tree.probfit1S)
#probFit2S.setVal(tree.probFit2S)
#if (tree.chic_pdgId == 20443):dataSet.add(dataArgSet)
dataSet.add(dataArgSet)
outfile = TFile(outfile_name,'recreate')
dataSet.Write()
print etaAvgValVarList.At(i).getError(), mistagList.At(i).getError()
#mistagVsEtaGraph.SetLineColor(currentColor)
linFuncList[-1].SetLineColor(currentColor)
fitresult = mistagVsEtaGraph.Fit(linFuncList[-1], "FQS", "", 0.0, 0.5)
p0 = fitresult.Parameter(0)
p1 = fitresult.Parameter(1)
p0Error = fitresult.ParError(0)
p1Error = fitresult.ParError(1)
p0Var.setVal(p0)
p0Var.setError(p0Error)
p1Var.setVal(p1)
p1Var.setError(p1Error)
pDataSet.add(RooArgSet(p0Var, p1Var, etaAvg))
sumP0 += float(p0)
sumP1 += float(p1)
sumP0E += float(p0Error)
sumP1E += float(p1Error)
sumAvgEta += etaAvg.getValV()
sumAvgEtaE += etaAvg.getError()
numP += 1
graphHolder.Add(mistagVsEtaGraph)
currentColor = currentColor % 9 + 1
#break;
os.chdir("..")
def FitMassPoint(filename, massin, massmin, massmax, rwCPS=1, nbins=50):
### take the input tree from the file
inputFile = ROOT.TFile(filename);
tree = inputFile.Get("WJet");
print "Lineshape Higgs mass --> n entries: ", tree.GetEntries();
# RooFitting
rrv_mass = RooRealVar("rrv_mass","rrv_mass",massin,massmin,massmax);
rrv_weight = RooRealVar("rrv_weight","rrv_weight",0. ,10000000.);
rrv_mH1 = RooRealVar("rrv_mH1","rrv_mH1", massin, massmin, massmax );
rrv_gamma1 = RooRealVar("rrv_gamma1","rrv_gamma1",20.,0.,massmax);
rrv_mH2 = RooRealVar("rrv_mH2","rrv_mH2", massin, massmin, massmax )
rrv_gamma2 = RooRealVar("rrv_gamma2","rrv_gamma2",20.,0.,massmax)
rrv_mH3 = RooRealVar("rrv_mH3","rrv_mH3", massin, massmin, massmax );
rrv_gamma3 = RooRealVar("rrv_gamma3","rrv_gamma3",20.,0.,massmax);
rds_raw = RooDataSet("rds_raw","rds_raw",RooArgSet(rrv_mass,rrv_weight),RooFit.WeightVar(rrv_weight)); ## created the raw dataset --> raw lineshape
rds_cps = RooDataSet("rds_cps","rds_cps",RooArgSet(rrv_mass,rrv_weight),RooFit.WeightVar(rrv_weight)); ## create the cps dataset --> cps lineshape
rds_cps_intf = ROOT.RooDataSet("rds_cps_intf","rds_cps_intf",RooArgSet(rrv_mass,rrv_weight),RooFit.WeightVar(rrv_weight)); ## create the cps + interference dataset
model1_pdf = ROOT.RooRelBWRunningWidth("model1_pdf","model1_pdf",rrv_mass,rrv_mH1,rrv_gamma1); ## BWRunningWidth Pdf from the dedicated library
model2_pdf = ROOT.RooRelBWRunningWidth("model2_pdf","model2_pdf",rrv_mass,rrv_mH2,rrv_gamma2); ## BWRunningWidth Pdf from the dedicated library
model3_pdf = ROOT.RooRelBWRunningWidth("model3_pdf","model3_pdf",rrv_mass,rrv_mH3,rrv_gamma3); ## BWRunningWidth Pdf from the dedicated library
### loop on Higgs signal events
for i in range(tree.GetEntries()):
if i % 10000 == 0: print "reweighter, i: ", i;
tree.GetEntry(i);
curmass = getattr(tree,"W_H_mass_gen"); ## take the higgs generated mass inside the window; point not in the window are neglected
if curmass < massmax and curmass > massmin:
rrv_mass.setVal( curmass ); ## set the value of the RooRealVar
tmpweight_cps = getattr(tree,"complexpolewtggH"+str(massin))*rwCPS/getattr(tree,"avecomplexpolewtggH"+str(massin)); ## take the cps weight from the tree
tmpweight_cps_intf = getattr(tree,"complexpolewtggH"+str(massin))*rwCPS*getattr(tree,"interferencewtggH"+str(massin))/getattr(tree,"avecomplexpolewtggH"+str(massin)); ## cps*int
rds_raw.add( RooArgSet( rrv_mass ), 1. );
rds_cps.add( RooArgSet( rrv_mass ), tmpweight_cps );
rds_cps_intf.add( RooArgSet( rrv_mass ), tmpweight_cps_intf );
print ">>>>"
RooTrace.dump(ROOT.cout,ROOT.kTRUE);
RooTrace.mark();
print "<<<<"
#### final fit
model1_pdf.fitTo(rds_raw,RooFit.Save(1), RooFit.SumW2Error(kTRUE));
model1_pdf.fitTo(rds_raw,RooFit.Save(1), RooFit.SumW2Error(kTRUE), RooFit.Minimizer("Minuit2"));
model2_pdf.fitTo(rds_cps,RooFit.Save(1), RooFit.SumW2Error(kTRUE));
model2_pdf.fitTo(rds_cps,RooFit.Save(1), RooFit.SumW2Error(kTRUE), RooFit.Minimizer("Minuit2"));
model3_pdf.fitTo(rds_cps_intf,RooFit.Save(1), RooFit.SumW2Error(kTRUE));
model3_pdf.fitTo(rds_cps_intf,RooFit.Save(1), RooFit.SumW2Error(kTRUE), RooFit.Minimizer("Minuit2"));
## plot of the fits
mplot = rrv_mass.frame(RooFit.Title("mass plot"));
rds_raw.plotOn(mplot, RooFit.MarkerColor(kBlack), RooFit.LineColor(kBlack), RooFit.Binning(nbins,massmin,massmax), RooFit.DataError(RooAbsData.SumW2) );
rds_cps.plotOn(mplot, RooFit.MarkerColor(kRed), RooFit.LineColor(kRed), RooFit.Binning(nbins,massmin,massmax), RooFit.DataError(RooAbsData.SumW2) );
rds_cps_intf.plotOn(mplot, RooFit.MarkerColor(kBlue), RooFit.LineColor(kBlue), RooFit.Binning(nbins,massmin,massmax), RooFit.DataError(RooAbsData.SumW2) );
model1_pdf.plotOn(mplot, RooFit.LineColor(kBlack));
model2_pdf.plotOn(mplot, RooFit.LineColor(kRed), RooFit.LineStyle(2) );
model3_pdf.plotOn(mplot, RooFit.LineColor(kBlue), RooFit.LineStyle(3) );
rds_raw.plotOn(mplot, RooFit.MarkerColor(kBlack), RooFit.LineColor(kBlack), RooFit.Binning(nbins,massmin,massmax), RooFit.DataError(RooAbsData.SumW2) );
rds_cps.plotOn(mplot, RooFit.MarkerColor(kRed), RooFit.LineColor(kRed), RooFit.Binning(nbins,massmin,massmax), RooFit.DataError(RooAbsData.SumW2) );
rds_cps_intf.plotOn(mplot, RooFit.MarkerColor(kBlue), RooFit.LineColor(kBlue), RooFit.Binning(nbins,massmin,massmax), RooFit.DataError(RooAbsData.SumW2) );
print "rds_raw.sumEntries() = ", rds_raw.sumEntries()
print "model1_pdf: mH = ", rrv_mH1.getVal(), ", gamma = ", rrv_gamma1.getVal();
print "rds_cps.sumEntries() = ", rds_cps.sumEntries()
print "model2_pdf: mH = ", rrv_mH2.getVal(), ", gamma = ", rrv_gamma2.getVal();
print "rds_cps_intf.sumEntries() = ", rds_cps_intf.sumEntries()
print "model3_pdf: mH = ", rrv_mH3.getVal(), ", gamma = ", rrv_gamma3.getVal();
dummy_h1 = ROOT.TH1F("dummy_h1","dummy_h1",1,0,1);
dummy_h1.SetMarkerColor( ROOT.kBlack );
dummy_h2 = ROOT.TH1F("dummy_h2","dummy_h2",1,0,1);
dummy_h2.SetMarkerColor( ROOT.kRed );
dummy_h3 = ROOT.TH1F("dummy_h3","dummy_h3",1,0,1);
dummy_h3.SetMarkerColor( ROOT.kBlue );
L = TLegend(0.65,0.60,0.93,0.85);
L.SetFillStyle(0);
L.AddEntry(dummy_h1,"Powheg","p");
L.AddEntry(dummy_h2,"w/CPS weight","p");
L.AddEntry(dummy_h3,"w/CPS,Intf weight","p");
can2 = ROOT.TCanvas("can2","can2",800,800);
mplot.Draw();
L.Draw();
os.system("mkdir -p massFits");
can2.SaveAs("massFits/mass_rf_"+str(massin)+".pdf");
can2.SaveAs("massFits/mass_rf_"+str(massin)+".png");
outputpar_1 = [];
outputpar_1.append( rrv_mH1.getVal() );
outputpar_1.append( rrv_gamma1.getVal() );
outputpar_2 = [];
outputpar_2.append( rrv_mH2.getVal() );
outputpar_2.append( rrv_gamma2.getVal() );
outputpar_3 = [];
outputpar_3.append( rrv_mH3.getVal() );
outputpar_3.append( rrv_gamma3.getVal() );
model1_pdf.Delete();
model2_pdf.Delete();
model3_pdf.Delete();
rds_raw.Delete(),
rds_cps.Delete(),
rds_cps_intf.Delete();
rrv_mH1.Delete(),
rrv_gamma1.Delete();
rrv_mH2.Delete(),
rrv_gamma2.Delete();
rrv_mH3.Delete(),
rrv_gamma3.Delete();
rrv_mass.Delete();
return outputpar_2
def makeRooDataSet(type, infile_name, outfile_name, tree_name, nevents):
""" Make RooDataSets from TTrees"""
inputfile = TFile.Open(infile_name, "READ")
print "Importing tree"
tree = TTree()
inputfile.GetObject(tree_name, tree) #get the tree from the data file
#define variables for the RooDataSet
m_mumu = RooRealVar("m_mumu", "m_mumu", 0.0, 4.0)
y_mumu = RooRealVar("y_mumu", "y_mumu", 0.0, 2.0)
pt_mumu = RooRealVar("pt_mumu", "pt_mumu", 0.0, 260.0)
eta_gamma = RooRealVar("eta_gamma", "eta_gamma", -3.5, 3.5)
pt_gamma = RooRealVar("pt_gamma", "pt_gamma", 0.0, 100.0)
m_gamma = RooRealVar("m_gamma", "m_gamma", -0.1, 0.1)
m_chi_rf1S = RooRealVar("m_chi_rf1S", "m_chi_rf1S", 0.0, 7.0)
m_chi_rf2S = RooRealVar("m_chi_rf2S", "m_chi_rf2S", -1.0, 1.0)
#Qvalue = RooRealVar("Qvalue","Q", -15., 15.)
s = RooRealVar("s", "s", -10., 10.)
ctpv = RooRealVar("ctpv", "ctpv", -1.0, 3.5)
ctpv_error = RooRealVar("ctpv_err", "ctpv_err", -1.0, 1.0)
pi0_abs_mass = RooRealVar("pi0_abs_mass", "pi0_abs_mass", 0.0, 2.2)
psi1S_nsigma = RooRealVar("psi1S_nsigma", "psi1S_nsigma", 0.0, 1.0)
psi2S_nsigma = RooRealVar("psi2S_nsigma", "psi2S_nsigma", 0.0, 1.0)
psi3S_nsigma = RooRealVar("psi3S_nsigma", "psi3S_nsigma", 0.0, 1.0)
rho_conv = RooRealVar("rho_conv", "rho_conv", 0.0, 70.0)
dz = RooRealVar("dz", "dz", -1.0, 1.0)
probFit1S = RooRealVar("probFit1S", "probFit1S", 0, 1)
probFit2S = RooRealVar("probFit2S", "probFit2S", 0, 1)
dataArgSet = RooArgSet(m_mumu, y_mumu, pt_mumu, eta_gamma, pt_gamma,
m_gamma, m_chi_rf1S)
dataArgSet.add(m_chi_rf2S)
dataArgSet.add(s)
dataArgSet.add(ctpv)
dataArgSet.add(ctpv_error)
dataArgSet.add(pi0_abs_mass)
dataArgSet.add(psi1S_nsigma)
dataArgSet.add(psi2S_nsigma)
dataArgSet.add(rho_conv)
dataArgSet.add(dz)
dataArgSet.add(probFit1S)
dataArgSet.add(probFit2S)
print "Creating DataSet"
dataSet = RooDataSet("chicds", "Chic RooDataSet", dataArgSet)
entries = tree.GetEntries()
print entries
if nevents is not 0:
entries = nevents
for ientry in range(0, entries):
tree.GetEntry(ientry)
# unfort ntuples are slightly different for chic and chib
if type == 'chic':
m_mumu.setVal(tree.dimuon_mass)
y_mumu.setVal(tree.dimuon_rapidity)
pt_mumu.setVal(tree.dimuon_pt)
eta_gamma.setVal(tree.photon_eta)
pt_gamma.setVal(tree.photon_pt)
#m_gamma.setVal(tree.photon_p4.M())
m_chi_rf1S.setVal(tree.rf1S_chic_mass)
#m_chi_rf1S.setVal(tree.rf2S_chi_p4.M())
#Qvalue.setVal((tree.chi_p4).M() - tree.dimuon_p4.M())
#Qvalue.setVal((tree.chi_p4).M()**2 - tree.dimuon_p4.M()**2)
#Qvalue.setVal((tree.rf1S_chic_mass**2 -tree.dimuon_mass**2)
# / (3.5107**2 - 3.0969**2 ) -1)
# this should be the correct one if the refitted variable was available
# s.setVal((tree.rf1S_chic_mass**2 - tree.rf1S_dimuon_p4.M()**2)/ (3.5107**2 - 3.0969**2 ) -1)
s.setVal((tree.rf1S_chic_mass**2 - 3.0969**2) /
(3.5107**2 - 3.0969**2) - 1)
psi1S_nsigma.setVal(tree.psi1S_nsigma)
psi2S_nsigma.setVal(0)
psi3S_nsigma.setVal(0)
elif type == 'chib':
m_mumu.setVal(tree.dimuon_mass)
y_mumu.setVal(tree.dimuon_rapidity)
pt_mumu.setVal(tree.dimuon_pt)
eta_gamma.setVal(tree.photon_eta)
pt_gamma.setVal(tree.photon_pt)
m_chi_rf1S.setVal(tree.rf1S_chib_mass)
m_chi_rf2S.setVal(tree.rf2S_chib_mass)
Qvalue.setVal(tree.chib_mass - tree.dimuon_mass)
psi1S_nsigma.setVal(tree.Y1S_nsigma)
psi2S_nsigma.setVal(tree.Y2S_nsigma)
psi3S_nsigma.setVal(tree.Y3S_nsigma)
ctpv.setVal(tree.ct_pv)
ctpv_error.setVal(tree.ct_pv_error)
#pi0_abs_mass.setVal(tree.pi0_abs_mass)
rho_conv.setVal(tree.Conv)
dz.setVal(tree.Dz)
probFit1S.setVal(tree.probfit1S)
#probFit2S.setVal(tree.probFit2S)
#if (tree.chic_pdgId == 20443):dataSet.add(dataArgSet)
dataSet.add(dataArgSet)
outfile = TFile(outfile_name, 'recreate')
dataSet.Write()
def process(file_name, max_events, n_bins, x_min, x_max, fit, peak_x_min, peak_x_max, draw_legend, verbose):
"""
A function that forms the main logic of the script
Args:
file_name (str): the name of the file to process
max_events (int): the maximum number of events that will be processed
n_bins (int): the number of bins to be used in the histogram
x_min (float): the left bound of the histogram
x_max (float): the right bound of the histogram
fit (bool): the flag that determines whether the data will be fitted
peak_x_min (float): the left bound of the peak
peak_x_max (float): the right bound of the peak
draw_legend (bool): the flag that determines whether the histogram legend will be drawn
verbose (bool): the flag that switches increased verbosity
"""
start_time = time.time()
last_timestamp = time.time()
# Opening the file and getting the branch
input_file = TFile(file_name, 'read')
input_tree = input_file.Get('Events')
# Event counters
processed_events = 0 # Number of processed events
reconstructable_events = 0 # Events with valid tau+ and tau- decay vertex
# Variables for RooFit
b_mass = RooRealVar('mB', 'm_{B}', x_min, x_max)
b_mass_data = RooDataSet('mB', 'm_{B} data', RooArgSet(b_mass)) # reconstructed B mass values container
q_square = RooRealVar('q2', 'q^{2}', 12.5, 17.5)
q_square_data = RooDataSet('q2_data', 'q^{2} data', RooArgSet(q_square)) # q^2 values container
# Loop through the events
for counter, event in enumerate(input_tree):
if counter < max_events:
processed_events += 1
if (counter + 1) % 100 == 0: # print status message every 100 events
print('Processing event {:.1f} ({:.1f} events / s)'.format(counter + 1, 100. / (time.time() - last_timestamp)))
last_timestamp = time.time()
try:
rec_ev = reconstruct(event, verbose)
reconstructable_events += 1
b_mass.setVal(rec_ev.m_b)
b_mass_data.add(RooArgSet(b_mass))
q_square.setVal(rec_ev.q_square())
q_square_data.add(RooArgSet(q_square))
except UnreconstructableEventError:
pass
end_time = time.time()
# printing some useful statistics
print('{} events have been processed'.format(processed_events))
print('Elapsed time: {:.1f} s ({:.1f} events / s)'.format(end_time - start_time, float(processed_events) / (end_time - start_time)))
print('Reconstruction efficiency: {} / {} = {:.3f}'.format(reconstructable_events, processed_events, float(reconstructable_events) / processed_events))
if fit:
# signal model
# ILD-like
signal_model = SignalModel(name = 'signal_model',
title = 'Signal Model',
x = b_mass,
mean = RooRealVar('mean_signal', '#mu_{signal}', 5.279, peak_x_min, peak_x_max),
width = RooRealVar('width_signal', '#sigma_{signal}', 0.03, 0.01, 0.1),
width_wide = RooRealVar('width_wide_gauss', '#sigma_{wide}', 0.165),
alpha = RooRealVar('alpha_signal', '#alpha_{signal}', -0.206),
n = RooRealVar('n_signal', 'n_{signal}', 2.056),
narrow_gauss_fraction = RooRealVar('narrow_gauss_fraction', 'Fraction of narrow Gaussian in signal', 0.127),
cb_fraction = RooRealVar('signal_cb_fraction', 'Fraction of CB in signal', 0.5)
)
# progressive
# signal_model = SignalModel(name = 'signal_model',
# title = 'Signal Model',
# x = b_mass,
# mean = RooRealVar('mean_signal', '#mu_{signal}', 5.279, peak_x_min, peak_x_max),
# width = RooRealVar('width_signal', '#sigma_{signal}', 0.03, 0.01, 0.1),
# width_wide = RooRealVar('width_wide_gauss', '#sigma_{wide}', 0.151),
# alpha = RooRealVar('alpha_signal', '#alpha_{signal}', -0.133),
# n = RooRealVar('n_signal', 'n_{signal}', 2.891),
# narrow_gauss_fraction = RooRealVar('narrow_gauss_fraction', 'Fraction of narrow Gaussian in signal', 0.301),
# cb_fraction = RooRealVar('signal_cb_fraction', 'Fraction of CB in signal', 0.330)
# )
# Bs -> Ds Ds K* (with Ds -> tau nu) background model
# ILD-like
bs_ds2taunu_model = BackgroundModel(name = 'bs_ds2taunu_model',
title = 'Bs (with Ds -> #tau #nu) background model',
x = b_mass,
mean = RooRealVar('mean_bs_ds2taunu', '#mu_{Bs (with Ds -> #tau #nu)}', 4.970),
width_gauss = RooRealVar('width_bs_ds2taunu_gauss', '#sigma_{Bs (with Ds -> #tau #nu) Gauss}', 0.196),
width_cb = RooRealVar('width_bs_ds2taunu_cb', '#sigma_{Bs (with Ds -> #tau #nu) CB}', 0.078),
alpha = RooRealVar('alpha_bs_ds2taunu', '#alpha_{Bs (with Ds -> #tau #nu)}', -0.746),
n = RooRealVar('n_bs_ds2taunu', 'n_{Bs (with Ds -> #tau #nu)}', 1.983),
gauss_fraction = RooRealVar('bs_ds2taunu_gauss_fraction', 'Fraction of Gaussian in Bs (with Ds -> #tau #nu) background', 0.243)
)
# progressive
# bs_ds2taunu_model = BackgroundModel(name = 'bs_ds2taunu_model',
# title = 'Bs (with Ds -> #tau #nu) background model',
# x = b_mass,
# mean = RooRealVar('mean_bs_ds2taunu', '#mu_{Bs (with Ds -> #tau #nu)}', 4.967),
# width_gauss = RooRealVar('width_bs_ds2taunu_gauss', '#sigma_{Bs (with Ds -> #tau #nu) Gauss}', 0.191),
# width_cb = RooRealVar('width_bs_ds2taunu_cb', '#sigma_{Bs (with Ds -> #tau #nu) CB}', 0.068),
# alpha = RooRealVar('alpha_bs_ds2taunu', '#alpha_{Bs (with Ds -> #tau #nu)}', -1.073),
# n = RooRealVar('n_bs_ds2taunu', 'n_{Bs (with Ds -> #tau #nu)}', 1.731),
# gauss_fraction = RooRealVar('bs_ds2taunu_gauss_fraction', 'Fraction of Gaussian in Bs (with Ds -> #tau #nu) background', 0.228)
# )
# Bs -> Ds Ds K* (with one Ds -> tau nu and other Ds -> pi pi pi pi) background model
# ILD-like
bs_ds2taunu_ds2pipipipi_model = BackgroundModel(name = 'bs_ds2taunu_ds2pipipipi_model',
title = 'Bs (with Ds -> #tau #nu and Ds -> #pi #pi #pi #pi) background model',
x = b_mass,
mean = RooRealVar('mean_bs_ds2taunu_ds2pipipipi', '#mu_{Bs (with Ds -> #tau #nu and Ds -> #pi #pi #pi #pi)}', 4.990),
width_gauss = RooRealVar('width_bs_ds2taunu_ds2pipipipi_gauss', '#sigma_{Bs (with Ds -> #tau #nu and Ds -> #pi #pi #pi #pi) Gauss}', 0.068),
width_cb = RooRealVar('width_bs_ds2taunu_ds2pipipipi_cb', '#sigma_{Bs (with Ds -> #tau #nu and Ds -> #pi #pi #pi #pi) CB}', 0.190),
alpha = RooRealVar('alpha_bs_ds2taunu_ds2pipipipi', '#alpha_{Bs (with Ds -> #tau #nu and Ds -> #pi #pi #pi #pi)}', -0.726),
n = RooRealVar('n_bs_ds2taunu_ds2pipipipi', 'n_{Bs (with Ds -> #tau #nu and Ds -> #pi #pi #pi #pi)}', 3.171),
gauss_fraction = RooRealVar('bs_ds2taunu_ds2pipipipi_gauss_fraction', 'Fraction of Gaussian in Bs (with Ds -> #tau #nu and Ds -> #pi #pi #pi #pi) background', 0.222)
)
# progressive
# bs_ds2taunu_ds2pipipipi_model = BackgroundModel(name = 'bs_ds2taunu_ds2pipipipi_model',
# title = 'Bs (with Ds -> #tau #nu and Ds -> #pi #pi #pi #pi) background model',
# x = b_mass,
# mean = RooRealVar('mean_bs_ds2taunu_ds2pipipipi', '#mu_{Bs (with Ds -> #tau #nu and Ds -> #pi #pi #pi #pi)}', 4.979),
# width_gauss = RooRealVar('width_bs_ds2taunu_ds2pipipipi_gauss', '#sigma_{Bs (with Ds -> #tau #nu and Ds -> #pi #pi #pi #pi) Gauss}', 0.073),
# width_cb = RooRealVar('width_bs_ds2taunu_ds2pipipipi_cb', '#sigma_{Bs (with Ds -> #tau #nu and Ds -> #pi #pi #pi #pi) CB}', 0.146),
# alpha = RooRealVar('alpha_bs_ds2taunu_ds2pipipipi', '#alpha_{Bs (with Ds -> #tau #nu and Ds -> #pi #pi #pi #pi)}', -0.725),
# n = RooRealVar('n_bs_ds2taunu_ds2pipipipi', 'n_{Bs (with Ds -> #tau #nu and Ds -> #pi #pi #pi #pi)}', 3.752),
# gauss_fraction = RooRealVar('bs_ds2taunu_ds2pipipipi_gauss_fraction', 'Fraction of Gaussian in Bs (with Ds -> #tau #nu and Ds -> #pi #pi #pi #pi) background', 0.417)
# )
# Bd -> Ds K* tau nu (with Ds -> tau nu) background model
# ILD-like
bd_ds2taunu_model = BackgroundModel(name = 'bd_ds2taunu_model',
title = 'Bd (with Ds -> #tau #nu) background model',
x = b_mass,
mean = RooRealVar('mean_bd_ds2taunu_ds2taunu', '#mu_{Bd (with Ds -> #tau #nu)}', 4.894),
width_gauss = RooRealVar('width_bd_ds2taunu_gauss', '#sigma_{Bd (with Ds -> #tau #nu) Gauss}', 0.331),
width_cb = RooRealVar('width_bd_ds2taunu_cb', '#sigma_{Bd (with Ds -> #tau #nu) CB}', 0.169),
alpha = RooRealVar('alpha_bd_ds2taunu', '#alpha_{Bd (with Ds -> #tau #nu)}', -0.904),
n = RooRealVar('n_bd_ds2taunu', 'n_{Bd (with Ds -> #tau #nu)}', 3.57),
gauss_fraction = RooRealVar('bd_ds2taunu_gauss_fraction', 'Fraction of Gaussian in Bd (with Ds -> #tau #nu) background', 0.01)
)
# progressive
# bd_ds2taunu_model = BackgroundModel(name = 'bd_ds2taunu_model',
# title = 'Bd (with Ds -> #tau #nu) background model',
# x = b_mass,
# mean = RooRealVar('mean_bd_ds2taunu_ds2taunu', '#mu_{Bd (with Ds -> #tau #nu)}', 4.891),
# width_gauss = RooRealVar('width_bd_ds2taunu_gauss', '#sigma_{Bd (with Ds -> #tau #nu) Gauss}', 0.565),
# width_cb = RooRealVar('width_bd_ds2taunu_cb', '#sigma_{Bd (with Ds -> #tau #nu) CB}', 0.148),
# alpha = RooRealVar('alpha_bd_ds2taunu', '#alpha_{Bd (with Ds -> #tau #nu)}', -5.23),
# n = RooRealVar('n_bd_ds2taunu', 'n_{Bd (with Ds -> #tau #nu)}', 1.497),
# gauss_fraction = RooRealVar('bd_ds2taunu_gauss_fraction', 'Fraction of Gaussian in Bd (with Ds -> #tau #nu) background', 0.29)
# )
signal_yield = RooRealVar('signal_yield', 'Yield of signal', reconstructable_events / 4., 0, reconstructable_events)
bs_ds2taunu_yield = RooRealVar('bs_ds2taunu_yield', 'Yield of Bs (with Ds -> #tau #nu) background', reconstructable_events / 4., 0, reconstructable_events)
bs_ds2pipipipi_yield = RooRealVar('bs_ds2pipipipi_yield', 'Yield of Bs (with Ds -> #pi #pi #pi #pi) background', reconstructable_events / 4., 0, reconstructable_events)
bd_ds2taunu_yield = RooRealVar('bd_ds2taunu_yield', 'Yield of Bd (with Ds -> #tau #nu) background', reconstructable_events / 4., 0, reconstructable_events)
# composite model
model = RooAddPdf('model', 'Model to fit', RooArgList(signal_model.pdf, bs_ds2taunu_model.pdf, bs_ds2taunu_ds2pipipipi_model.pdf, bd_ds2taunu_model.pdf), RooArgList(signal_yield, bs_ds2taunu_yield, bs_ds2pipipipi_yield, bd_ds2taunu_yield))
show_plot(b_mass, b_mass_data, 'GeV/#it{c}^{2}', n_bins, fit, model, extended = True, components_to_plot = RooArgList(signal_model.pdf, bs_ds2taunu_model.pdf, bs_ds2taunu_ds2pipipipi_model.pdf, bd_ds2taunu_model.pdf), draw_legend = draw_legend)
else:
show_plot(b_mass, b_mass_data, 'GeV/#it{c}^{2}', n_bins)
show_plot(q_square, q_square_data, 'GeV^{2}/#it{c}^{2}', n_bins)
class FitToy(Toy):
def __init__(self):
Toy.__init__(self)
def run(self, **kwargs):
from ROOT import RooArgSet
__check_req_kw__("Observables", kwargs)
__check_req_kw__("Pdf", kwargs)
observables = kwargs.pop("Observables")
obs_set = RooArgSet(*observables)
pdf = kwargs.pop("Pdf")
genPdf = kwargs.pop("GenPdf", pdf)
gen_obs_set = RooArgSet()
for o in list(observables) + list(genPdf.ConditionalObservables()):
gen_obs_set.add(o._target_())
gen_pdf_params = genPdf.getParameters(gen_obs_set).snapshot(True)
genPdf = genPdf.clone(genPdf.GetName() + "_toy_clone")
genPdf.recursiveRedirectServers(gen_pdf_params)
fit_obs_set = RooArgSet()
for o in list(observables) + list(pdf.ConditionalObservables()):
fit_obs_set.add(o._target_())
params = pdf.getParameters(fit_obs_set)
pdf_params = RooArgSet()
for p in params:
if p.isConstant():
continue
pdf_params.add(p)
## for param in pdf_params:
## if param.GetName() not in ['Gamma', 'dGamma']:
## param.setConstant()
self._gen_params = pdf_params.snapshot(True)
# Make another ArgSet to put the fit results in
result_params = RooArgSet(pdf_params, "result_params")
transform = self.transform()
if transform:
trans_params = transform.gen_params(gen_obs_set)
for p in trans_params:
result_params.add(p)
# Some extra numbers of interest
from ROOT import RooRealVar
NLL = RooRealVar("NLL", "-log(Likelihood)", 1.0)
ngen = RooRealVar("ngen", "number of generated events", self.options().nevents)
seed = RooRealVar("seed", "random seed", 0.0)
from ROOT import RooCategory
status = RooCategory("status", "fit status")
status.defineType("success", 0)
status.defineType("one", 1)
status.defineType("two", 2)
status.defineType("three", 3)
status.defineType("other", 4)
result_params.add(status)
result_params.add(NLL)
result_params.add(ngen)
result_params.add(seed)
# The dataset to store the results
from ROOT import RooDataSet
self._data = RooDataSet("result_data", "result_data", result_params)
data_params = self._data.get()
from ROOT import RooRandom
import struct, os
while self._data.numEntries() < self.options().ntoys:
# Get a good random seed, set it and store it
s = struct.unpack("I", os.urandom(4))[0]
RooRandom.randomGenerator().SetSeed(s)
seed.setVal(s)
# Reset pdf parameters to initial values. Note: this does not reset the estimated errors...
pdf_params.assignValueOnly(self.gen_params())
args = dict(NumEvents=self.options().nevents)
if "ProtoData" in kwargs:
args["ProtoData"] = kwargs.pop("ProtoData")
genPdf.getParameters(obs_set).assignValueOnly(gen_pdf_params)
data = genPdf.generate(obs_set, **args)
if transform:
data = transform(data)
if not data:
# Transform has failed
transform.set_params(data_params)
self._data.add(data_params)
continue
if data.isWeighted() and "SumW2Error" not in self.fit_opts():
self.fit_opts()["SumW2Error"] = False
j = 0
while j < 4:
fit_result = pdf.fitTo(data, NumCPU=self.options().ncpu, **(self.fit_opts()))
if fit_result.status() == 0:
fit_result.Print()
break
j += 1
if fit_result.status() != 0:
print "Fit result status = %s" % fit_result.status()
NLL.setVal(fit_result.minNll())
if fit_result.status() < 4:
status.setIndex(fit_result.status())
else:
status.setIndex(4)
for result_param in result_params:
data_param = data_params.find(result_param.GetName())
if isinstance(result_param, RooCategory):
data_param.setIndex(result_param.getIndex())
else:
data_param.setVal(result_param.getVal())
# This sets a symmetric error, but since we don't run Minos, that's ok
data_param.setError(result_param.getError())
if transform:
transform.set_params(data_params)
self._data.add(data_params)
return self.data()
def gen_params(self):
return self._gen_params
magnet_data = RooDataSet('magnet_data', 'magnet_data', obs_m)
magnet_results = {}
for entry in tree:
if entry.dx < pull_xm.getMin() or entry.dx > pull_xm.getMax():
continue
if entry.dy < pull_ym.getMin() or entry.dy > pull_ym.getMax():
continue
if entry.p < 3000:
continue
q.setIndex(entry.q)
pull_xm.setVal(entry.dx)
pull_ym.setVal(entry.dy)
p_inv.setVal(1000. / entry.p_match)
p_inv_values.append(1000. / entry.p_match)
p.setVal(entry.p_match / 1000.)
magnet_data.add(obs_m)
# Make a binning with equal entries.
p_inv_values = sorted(p_inv_values)
n_bins = 9
di = int(float(len(p_inv_values)) / n_bins)
bins_p_inv = [p_inv.getMin()]
for i in range(1, n_bins):
bins_p_inv += [p_inv_values[i * di]]
bins_p_inv += [p_inv.getMax()]
magnet_datas = {}
dp_inv = (p_inv.getMax() - p_inv.getMin()) / n_bins
dp = (p.getMax() - p.getMin()) / n_bins
bins_p = [0 + i * dp for i in range(n_bins + 1)]
def create_pdfs(self, paths_to_data, save=True):
"""
Fit amplitude and offset of sinusoidal pdfs
"""
if not isinstance(paths_to_data, list):
paths_to_data = [paths_to_data]
files_H = []
files_A = []
for path in paths_to_data:
# These are merged, so only one of each
if not path.endswith('/'): path += '/'
files_H.append(path+'model_H_merged.h5')
files_A.append(path+'model_A_merged.h5')
# TODO: Background samples: uniform pdf
self.phistar = RooRealVar('phistar', 'phistar', 0, 2*pi)
self.ampl = RooRealVar('ampl', 'ampl', 1, 0, 10) # Must remain in scope
self.offset = RooRealVar('offset', 'offset', 1, 0, 10) # - " -
# Read in the data
# Need only to fit pdf parameters for H, since the pdf for A is
# equal but with a 180 deg phase shift.
starttime = time.time()
dataH_X, _, feats = self.read_array_from_files(files_H)
dataH_X = self.select_features(dataH_X, feats)
print 'Limiting events for pdf creation to 1e6'
dataH_X = dataH_X[:1000000]
templatedataH = RooDataSet('templatedataH', 'templatedataH', RooArgSet(self.phistar))
for phi in dataH_X:
self.phistar.setVal(phi)
templatedataH.add(RooArgSet(self.phistar))
# Reset parameters
self.ampl = RooRealVar('ampl', 'ampl', 1, 0, 10)
self.offset = RooRealVar('offset', 'offset', 1, 0, 10)
# Pdf for scalar decay
scalar_pdf = RooGenericPdf('scalar_pdf', 'scalar_pdf', 'ampl*sin(phistar-1.570796) + offset', RooArgList(self.ampl, self.phistar, self.offset))
scalar_pdf.fitTo(templatedataH)
self.ampl.setConstant()
self.offset.setConstant()
# Fitting only the scalar pdf is enough to get the pseudoscalar parameters too
pseudoscalar_pdf = RooGenericPdf('pseudoscalar_pdf', 'pseudoscalar_pdf', 'ampl*sin(phistar+1.570796) + offset', RooArgList(self.ampl, self.phistar, self.offset))
self.pdfs['H'] = scalar_pdf
self.pdfs['A'] = pseudoscalar_pdf
print 'Creating phistar pdf took %s' % time.strftime("%H:%M:%S", time.gmtime(time.time()-starttime))
if save:
ws = RooWorkspace('ws', 'ws')
getattr(ws, 'import')(self.phistar)
getattr(ws, 'import')(self.ampl)
getattr(ws, 'import')(self.offset)
getattr(ws, 'import')(self.pdfs['H'])
getattr(ws, 'import')(self.pdfs['A'])
ws.writeToFile('%s/pdfs_%s.root' % (self.outdir, self.title))
def process(file_name, tree_name, max_events, n_bins, x_min, x_max, fit, background, peak_x_min, peak_x_max, draw_legend, plot_q_square, plot_momentum_resolution, mc_tree_name, verbose):
"""
A function that forms the main logic of the script
Args:
file_name (str): the name of the file to process
tree_name (str): the name of the tree to process
n_bins (int): the number of bins to be used in the histogram
x_min (float): the left bound of the histogram
x_max (float): the right bound of the histogram
fit (bool): the flag that determines whether the data will be fitted
background (bool): the flag that determines whether signal or background b_mass_data is processed
peak_x_min (float): the left bound of the peak
peak_x_max (float): the right bound of the peak
draw_legend (bool): the flag that determines whether the histogram legend will be drawn
plot_q_square (bool): the flag that determines whether the q^2 distribution will be plotted
plot_momentum_resolution (bool): the flag that determines whether the tau and neutrino momentum resolution distributions will be plotted
max_events (int): the maximum number of events that will be processed
verbose (bool): the flag that switches inreased verbosity
"""
start_time = time.time()
last_timestamp = time.time()
# Opening the file and getting the branch
input_file = TFile(file_name, 'read')
event_tree = input_file.Get(tree_name)
# Event counters
processed_events = 0 # Number of processed events
reconstructable_events = 0 # Events with valid tau+ and tau- decay vertex
# Variables for RooFit
b_mass = RooRealVar('mB', 'm_{B}', x_min, x_max)
b_mass_data = RooDataSet('mB', 'm_{B} data', RooArgSet(b_mass)) # Storage for reconstructed B mass values
if plot_q_square:
q_square = RooRealVar('q2', 'q^{2}', 12.5, 22.5)
q_square_data = RooDataSet('q2_data', 'q^{2} data', RooArgSet(q_square)) # q^2 values container
if plot_momentum_resolution:
error_p_tauplus_x = RooRealVar('error_p_tauplus_x', '#epsilon_{p_{#tau^{+}x}}', -2., 2.)
error_p_tauplus_x_data = RooDataSet('error_p_tauplus_x_data', '#epsilon_{p_{#tau^{+}x}} data', RooArgSet(error_p_tauplus_x))
error_p_tauplus_y = RooRealVar('error_p_tauplus_y', '#epsilon_{p_{#tau^{+}y}}', -2., 2.)
error_p_tauplus_y_data = RooDataSet('error_p_tauplus_y_data', '#epsilon_{p_{#tau^{+}y}} data', RooArgSet(error_p_tauplus_y))
error_p_tauplus_z = RooRealVar('error_p_tauplus_z', '#epsilon_{p_{#tau^{+}z}}', -2., 2.)
error_p_tauplus_z_data = RooDataSet('error_p_tauplus_z_data', '#epsilon_{p_{#tau^{+}z}} data', RooArgSet(error_p_tauplus_z))
error_p_tauminus_x = RooRealVar('error_p_tauminus_x', '#epsilon_{p_{#tau^{-}x}}', -2., 2.)
error_p_tauminus_x_data = RooDataSet('error_p_tauminus_x_data', '#epsilon_{p_{#tau^{-}x}} data', RooArgSet(error_p_tauminus_x))
error_p_tauminus_y = RooRealVar('error_p_tauminus_y', '#epsilon_{p_{#tau^{-}y}}', -2., 2.)
error_p_tauminus_y_data = RooDataSet('error_p_tauminus_y_data', '#epsilon_{p_{#tau^{-}y}} data', RooArgSet(error_p_tauminus_y))
error_p_tauminus_z = RooRealVar('error_p_tauminus_z', '#epsilon_{p_{#tau^{-}z}}', -2., 2.)
error_p_tauminus_z_data = RooDataSet('error_p_tauminus_z_data', '#epsilon_{p_{#tau^{-}z}} data', RooArgSet(error_p_tauminus_z))
error_p_nu_tauplus_x = RooRealVar('error_p_nu_tauplus_x', '#epsilon_{p_{#nu#tau^{+}x}}', -5., 5.)
error_p_nu_tauplus_x_data = RooDataSet('error_p_nu_tauplus_x_data', '#epsilon_{p_{#nu#tau^{+}x}} data', RooArgSet(error_p_nu_tauplus_x))
error_p_nu_tauplus_y = RooRealVar('error_p_nu_tauplus_y', '#epsilon_{p_{#nu#tau^{+}y}}', -5., 5.)
error_p_nu_tauplus_y_data = RooDataSet('error_p_nu_tauplus_y_data', '#epsilon_{p_{#nu#tau^{+}y}} data', RooArgSet(error_p_nu_tauplus_y))
error_p_nu_tauplus_z = RooRealVar('error_p_nu_tauplus_z', '#epsilon_{p_{#nu#tau^{+}z}}', -5., 5.)
error_p_nu_tauplus_z_data = RooDataSet('error_p_nu_tauplus_z_data', '#epsilon_{p_{#nu#tau^{+}z}} data', RooArgSet(error_p_nu_tauplus_z))
error_p_nu_tauminus_x = RooRealVar('error_p_nu_tauminus_x', '#epsilon_{p_{#nu#tau^{-}x}}', -5., 5.)
error_p_nu_tauminus_x_data = RooDataSet('error_p_nu_tauminus_x_data', '#epsilon_{p_{#nu#tau^{-}x}} data', RooArgSet(error_p_nu_tauminus_x))
error_p_nu_tauminus_y = RooRealVar('error_p_nu_tauminus_y', '#epsilon_{p_{#nu#tau^{-}y}}', -5., 5.)
error_p_nu_tauminus_y_data = RooDataSet('error_p_nu_tauminus_y_data', '#epsilon_{p_{#nu#tau^{-}y}} data', RooArgSet(error_p_nu_tauminus_y))
error_p_nu_tauminus_z = RooRealVar('error_p_nu_tauminus_z', '#epsilon_{p_{#nu#tau^{-}z}}', -5., 5.)
error_p_nu_tauminus_z_data = RooDataSet('error_p_nu_tauminus_z_data', '#epsilon_{p_{#nu#tau^{-}z}} data', RooArgSet(error_p_nu_tauminus_z))
# Loop through the events
# for counter, (event, mc_event) in enumerate(zip(event_tree, mc_event_tree)): # this finest construction doesn't work for some reason
for counter in xrange(event_tree.GetEntries()): # so we have to use an old one
if counter < max_events:
event_tree.GetEntry(counter)
if plot_momentum_resolution:
mc_event_tree.GetEntry(counter)
processed_events += 1
if (counter + 1) % 100 == 0: # print status message every 100 events
print('Processing event {} ({:.1f} events / s)'.format(counter + 1, 100. / (time.time() - last_timestamp)))
last_timestamp = time.time()
try:
rec_ev = reconstruct(event_tree, verbose)
reconstructable_events += 1
b_mass.setVal(rec_ev.m_b)
b_mass_data.add(RooArgSet(b_mass))
if plot_q_square:
q_square.setVal(rec_ev.q_square())
q_square_data.add(RooArgSet(q_square))
if plot_momentum_resolution:
error_p_tauplus_x.setVal((rec_ev.p_tauplus.px - mc_event_tree.tauplus_px) / mc_event_tree.tauplus_px)
error_p_tauplus_x_data.add(RooArgSet(error_p_tauplus_x))
error_p_tauplus_y.setVal((rec_ev.p_tauplus.py - mc_event_tree.tauplus_py) / mc_event_tree.tauplus_py)
error_p_tauplus_y_data.add(RooArgSet(error_p_tauplus_y))
error_p_tauplus_z.setVal((rec_ev.p_tauplus.pz - mc_event_tree.tauplus_pz) / mc_event_tree.tauplus_pz)
error_p_tauplus_z_data.add(RooArgSet(error_p_tauplus_z))
error_p_tauminus_x.setVal((rec_ev.p_tauminus.px - mc_event_tree.tauminus_px) / mc_event_tree.tauminus_px)
error_p_tauminus_x_data.add(RooArgSet(error_p_tauminus_x))
error_p_tauminus_y.setVal((rec_ev.p_tauminus.py - mc_event_tree.tauminus_py) / mc_event_tree.tauminus_py)
error_p_tauminus_y_data.add(RooArgSet(error_p_tauminus_y))
error_p_tauminus_z.setVal((rec_ev.p_tauminus.pz - mc_event_tree.tauminus_pz) / mc_event_tree.tauminus_pz)
error_p_tauminus_z_data.add(RooArgSet(error_p_tauminus_z))
error_p_nu_tauplus_x.setVal((rec_ev.p_nu_tauplus.px - mc_event_tree.nu_tauplus_px) / mc_event_tree.nu_tauplus_px)
error_p_nu_tauplus_x_data.add(RooArgSet(error_p_nu_tauplus_x))
error_p_nu_tauplus_y.setVal((rec_ev.p_nu_tauplus.py - mc_event_tree.nu_tauplus_py) / mc_event_tree.nu_tauplus_py)
error_p_nu_tauplus_y_data.add(RooArgSet(error_p_nu_tauplus_y))
error_p_nu_tauplus_z.setVal((rec_ev.p_nu_tauplus.pz - mc_event_tree.nu_tauplus_pz) / mc_event_tree.nu_tauplus_pz)
error_p_nu_tauplus_z_data.add(RooArgSet(error_p_nu_tauplus_z))
error_p_nu_tauminus_x.setVal((rec_ev.p_nu_tauminus.px - mc_event_tree.nu_tauminus_px) / mc_event_tree.nu_tauminus_px)
error_p_nu_tauminus_x_data.add(RooArgSet(error_p_nu_tauminus_x))
error_p_nu_tauminus_y.setVal((rec_ev.p_nu_tauminus.py - mc_event_tree.nu_tauminus_py) / mc_event_tree.nu_tauminus_py)
error_p_nu_tauminus_y_data.add(RooArgSet(error_p_nu_tauminus_y))
error_p_nu_tauminus_z.setVal((rec_ev.p_nu_tauminus.pz - mc_event_tree.nu_tauminus_pz) / mc_event_tree.nu_tauminus_pz)
error_p_nu_tauminus_z_data.add(RooArgSet(error_p_nu_tauminus_z))
except UnreconstructableEventError:
pass
end_time = time.time()
# printing some useful statistics
print('{} events have been processed'.format(processed_events))
print('Elapsed time: {:.1f} s ({:.1f} events / s)'.format(end_time - start_time, float(processed_events) / (end_time - start_time)))
print('Reconstruction efficiency: {} / {} = {:.3f}'.format(reconstructable_events, processed_events, float(reconstructable_events) / processed_events))
if fit:
if background:
model = BackgroundModel(name = 'background_model',
title = 'Background Model',
x = b_mass,
mean = RooRealVar('mean', '#mu', 5.279, peak_x_min, peak_x_max),
width_cb = RooRealVar('width_cb', '#sigma_{CB}', 0.2, 0.02, 1.),
width_gauss = RooRealVar('width_gauss', '#sigma_{Gauss}', 0.2, 0.02, 1.),
alpha = RooRealVar('alpha_cb', '#alpha_{CB}', -1., -10., -0.1),
n = RooRealVar('n_cb', 'n_{CB}', 1., 0., 10.),
gauss_fraction = RooRealVar('background_model_gauss_fraction', 'Fraction of Gaussian in Background Model', 0.3, 0.01, 1.)
)
else:
model = SignalModel(name = 'signal_model',
title = 'Signal Model',
x = b_mass,
mean = RooRealVar('mean', '#mu', 5.279, peak_x_min, peak_x_max),
width = RooRealVar('width_narrow_gauss', '#sigma', 0.03, 0.01, 0.1),
width_wide = RooRealVar('width_wide_gauss', '#sigma_{wide}', 0.3, 0.1, 1.),
alpha = RooRealVar('alpha', '#alpha', -1., -10., -0.1),
n = RooRealVar('n', 'n', 2., 0.1, 10.),
narrow_gauss_fraction = RooRealVar('signal_model_narrow_gauss_fraction', 'Fraction of Narrow Gaussian in Signal Model', 0.3, 0.01, 1.),
cb_fraction = RooRealVar('signal_model_cb_fraction', 'Fraction of Crystal Ball Shape in Signal Model', 0.3, 0.01, 1.)
)
show_plot(b_mass, b_mass_data, 'GeV/#it{c}^{2}', n_bins, fit, model.pdf, extended = False, components_to_plot = model.components, draw_legend = draw_legend)
else:
show_plot(b_mass, b_mass_data, 'GeV/#it{c}^{2}', n_bins)
if plot_q_square:
show_plot(q_square, q_square_data, 'GeV^{2}/#it{c}^{2}', n_bins)
if plot_momentum_resolution:
show_plot(error_p_tauplus_x, error_p_tauplus_x_data, None, n_bins)
show_plot(error_p_tauplus_y, error_p_tauplus_y_data, None, n_bins)
show_plot(error_p_tauplus_z, error_p_tauplus_z_data, None, n_bins)
show_plot(error_p_tauminus_x, error_p_tauminus_x_data, None, n_bins)
show_plot(error_p_tauminus_y, error_p_tauminus_y_data, None, n_bins)
show_plot(error_p_tauminus_z, error_p_tauminus_z_data, None, n_bins)
show_plot(error_p_nu_tauplus_x, error_p_nu_tauplus_x_data, None, n_bins)
show_plot(error_p_nu_tauplus_y, error_p_nu_tauplus_y_data, None, n_bins)
show_plot(error_p_nu_tauplus_z, error_p_nu_tauplus_z_data, None, n_bins)
show_plot(error_p_nu_tauminus_x, error_p_nu_tauminus_x_data, None, n_bins)
show_plot(error_p_nu_tauminus_y, error_p_nu_tauminus_y_data, None, n_bins)
show_plot(error_p_nu_tauminus_z, error_p_nu_tauminus_z_data, None, n_bins)
mc = RooDataSet('mc','',getattr(ws,'set')('observables'))
data = RooDataSet('data','',getattr(ws,'set')('observables'))
for ev in range(tree.GetEntries()):
tree.GetEntry(ev)
if tree.itype != -88 and tree.itype!=72 and tree.itype!=82: continue
if tree.bdtoutput<0.2: continue
if tree.B0_MM < ws.var("mass").getMin() or tree.B0_MM > ws.var("mass").getMax(): continue
ws.var("mass").setVal(tree.B0_MM)
ws.var("gamgams_pt").setVal(tree.gamgams_PT)
if tree.itype == -88:
mc.add(getattr(ws,'set')('observables'))
if tree.itype == 72 or tree.itype == 82:
data.add(getattr(ws,'set')('observables'))
getattr(ws,'import')(mc)
getattr(ws,'import')(data)
ws.Print()
ws.factory("mean[5200,5300]")
ws.factory("CBShape:sig_cb1(mass,mean,sigma_1[10,200],alpha_1[0,1.],n_1[0.,50.])");
ws.factory("CBShape:sig_cb2(mass,mean,sigma_2[10,200],alpha_2[-1.,0.],n_2[0.,50.])");
ws.factory("SUM::mcsig( f[0.5,0,1]*sig_cb1, sig_cb2)");
ws.pdf("mcsig").fitTo(ws.data("mc"))
class DilutionToy(Toy):
def __init__(self):
Toy.__init__(self)
self._gen_params = []
def run(self, **kwargs):
from ROOT import RooArgSet
__check_req_kw__("Observables", kwargs)
__check_req_kw__("Pdf", kwargs)
__check_req_kw__("Sigmat", kwargs)
__check_req_kw__("Time", kwargs)
__check_req_kw__("SigmaGen", kwargs)
sigma_gen = kwargs.pop("SigmaGen")
observables = kwargs.pop("Observables")
obs_set = RooArgSet(*observables)
pdf = kwargs.pop("Pdf")
sigmat = kwargs.pop("Sigmat")
time = kwargs.pop("Time")
gen_obs_set = RooArgSet(*observables)
# Make another ArgSet to put the fit results in
result_params = RooArgSet("result_params")
from P2VV.RooFitWrappers import RealVar
da = RealVar("da", Observable=True, MinMax=(0.01, 1.1))
dft = RealVar("dft", Observable=True, MinMax=(0.01, 1.1))
result_params.add(da._target_())
result_params.add(dft._target_())
transform = self.transform()
if transform:
trans_params = transform.gen_params(gen_obs_set)
self._gen_params.extend(trans_params)
for p in trans_params:
result_params.add(p)
# Some extra numbers of interest
from ROOT import RooRealVar
seed = RooRealVar("seed", "random seed", 0.0)
result_params.add(seed)
# The dataset to store the results
from ROOT import RooDataSet
self._data = RooDataSet("result_data", "result_data", result_params)
data_params = self._data.get()
from ROOT import RooRandom
import struct, os
# Reset pdf parameters to initial values. Note: this does not reset the estimated errors...
args = dict(NumEvents=self.options().nevents)
if "ProtoData" in kwargs:
args["ProtoData"] = kwargs.pop("ProtoData")
spec = pdf.prepareMultiGen(obs_set, **args)
while self._data.numEntries() < self.options().ntoys:
# Get a good random seed, set it and store it
s = struct.unpack("I", os.urandom(4))[0]
RooRandom.randomGenerator().SetSeed(s)
seed.setVal(s)
data = pdf.generate(spec)
if self.transform():
old_data = data
data = self.transform()(old_data)
if not data:
transform.set_params(data_params)
self._data.add(data_params)
continue
from P2VV import Dilution
d_ft = Dilution.dilution_ft(data, time, t_range=2, quiet=True)
d_a = Dilution.signal_dilution_dg(data, sigmat, *sigma_gen)
da.setVal(d_a[0])
da.setError(d_a[1] if d_a[1] != None else 0.0)
dft.setVal(d_ft[0])
dft.setError(d_ft[1] if d_ft[1] != None else 0.0)
if transform:
transform.set_params(data_params)
self._data.add(result_params)
return self.data()
def gen_params(self):
return self._gen_params
def buildDataAndCategories(ws, options, args):
#Get the input data
inputData = TChain(options.treeName, 'The input data')
for arg in args:
print 'Adding data from: ', arg
inputData.Add(arg)
foldname = ''
phirange = [0, 90]
if not options.folded:
foldname = ''
phirange = [-180, 180]
#variables necessary for j/psi mass,lifetime,polarization fit
jPsiMass = RooRealVar('JpsiMass', 'M [GeV]', 2.7, 3.5)
jPsiRap = RooRealVar('JpsiRap', '#nu', -2.3, 2.3)
jPsiPt = RooRealVar("JpsiPt", "pT [GeV]", 0, 40)
jPsicTau = RooRealVar('Jpsict', 'l_{J/#psi} [mm]', -1, 2.5)
jPsicTauError = RooRealVar('JpsictErr', 'Error on l_{J/#psi} [mm]', 0, 2)
jPsiVprob = RooRealVar('JpsiVprob', '', .01, 1)
jPsiHXcosth = None
jPsiHXphi = None
jPsicTau.setBins(10000, "cache")
if options.fitFrame is not None:
jPsiHXcosth = RooRealVar('costh_' + options.fitFrame + foldname,
'cos(#theta)_{' + options.fitFrame + '}', -1,
1)
jPsiHXphi = RooRealVar('phi_' + options.fitFrame + foldname,
'#phi_{' + options.fitFrame + '}', phirange[0],
phirange[1])
else:
jPsiHXcosth = RooRealVar('costh_CS' + foldname, 'cos(#theta)_{CS}', -1,
1)
jPsiHXphi = RooRealVar('phi_CS' + foldname, '#phi_{CS}', phirange[0],
phirange[1])
#vars needed for on the fly calc of polarization variables
jPsimuPosPx = RooRealVar('muPosPx', '+ Muon P_{x} [GeV]', 0)
jPsimuPosPy = RooRealVar('muPosPy', '+ Muon P_{y} [GeV]', 0)
jPsimuPosPz = RooRealVar('muPosPz', '+ Muon P_{z} [GeV]', 0)
jPsimuNegPx = RooRealVar('muNegPx', '- Muon P_{x} [GeV]', 0)
jPsimuNegPy = RooRealVar('muNegPy', '- Muon P_{y} [GeV]', 0)
jPsimuNegPz = RooRealVar('muNegPz', '- Muon P_{z} [GeV]', 0)
#create RooArgSet for eventual dataset creation
dataVars = RooArgSet(jPsiMass, jPsiRap, jPsiPt, jPsicTau, jPsicTauError,
jPsimuPosPx, jPsimuPosPy, jPsimuPosPz)
#add trigger requirement if specified
if options.triggerName:
trigger = RooRealVar(options.triggerName, 'Passes Trigger', 0.5, 1.5)
dataVars.add(trigger)
dataVars.add(jPsiVprob)
dataVars.add(jPsimuNegPx)
dataVars.add(jPsimuNegPy)
dataVars.add(jPsimuNegPz)
dataVars.add(jPsiHXcosth)
dataVars.add(jPsiHXphi)
redVars = RooArgSet(jPsiMass, jPsiRap, jPsiPt, jPsicTau, jPsicTauError)
redVars.add(jPsiHXcosth)
redVars.add(jPsiHXphi)
fitVars = redVars.Clone()
### HERE IS WHERE THE BIT FOR CALCULATING POLARIZATION VARS GOES
ctauStates = RooCategory('ctauRegion', 'Cut Region in lifetime')
ctauStates.defineType('prompt', 0)
ctauStates.defineType('nonPrompt', 1)
massStates = RooCategory('massRegion', 'Cut Region in mass')
massStates.defineType('signal', 1)
massStates.defineType('separation', 0)
massStates.defineType('leftMassSideBand', -2)
massStates.defineType('rightMassSideBand', -1)
states = RooCategory('mlRegion', 'Cut Region in mass')
states.defineType('nonPromptSignal', 2)
states.defineType('promptSignal', 1)
states.defineType('separation', 0)
states.defineType('leftMassSideBand', -2)
states.defineType('rightMassSideBand', -1)
#define corresponding ranges in roorealvars
#mass is a little tricky since the sidebands change definitions in each rap bin
#define the names here and change as we do the fits
#jPsiMass.setRange('NormalizationRangeFormlfit_promptSignal',2.7,3.5)
#jPsiMass.setRange('NormalizationRangeFormlfit_nonPromptSignal',2.7,3.5)
#jPsiMass.setRange('NormalizationRangeFormlfit_leftMassSideBand',2.7,3.1)
#jPsiMass.setRange('NormalizationRangeFormlfit_rightMassSideBand',3.1,3.5)
#want the prompt fit only done in prompt region
#non-prompt only in non-prompt region
#background over entire cTau range
#jPsicTau.setRange('NormalizationRangeFormlfit_promptSignal',-1,.1)
#jPsicTau.setRange('NormalizationRangeFormlfit_nonPromptSignal',.1,2.5)
#jPsicTau.setRange('NormalizationRangeFormlfit_leftMassSideBand',-1,2.5)
#jPsicTau.setRange('NormalizationRangeFormlfit_rightMassSideBand',-1,2.5)
#redVars.add(ctauStates)
#redVars.add(massStates)
#redVars.add(states)
fitVars.add(ctauStates)
fitVars.add(massStates)
fitVars.add(states)
fullData = RooDataSet('fullData',
'The Full Data From the Input ROOT Trees', dataVars,
ROOT.RooFit.Import(inputData))
for rap_bin in range(1, len(jpsi.pTRange)):
yMin = jpsi.rapForPTRange[rap_bin - 1][0]
yMax = jpsi.rapForPTRange[rap_bin - 1][-1]
for pt_bin in range(len(jpsi.pTRange[rap_bin])):
ptMin = jpsi.pTRange[rap_bin][pt_bin][0]
ptMax = jpsi.pTRange[rap_bin][pt_bin][-1]
sigMaxMass = jpsi.polMassJpsi[
rap_bin] + jpsi.nSigMass * jpsi.sigmaMassJpsi[rap_bin]
sigMinMass = jpsi.polMassJpsi[
rap_bin] - jpsi.nSigMass * jpsi.sigmaMassJpsi[rap_bin]
sbHighMass = jpsi.polMassJpsi[
rap_bin] + jpsi.nSigBkgHigh * jpsi.sigmaMassJpsi[rap_bin]
sbLowMass = jpsi.polMassJpsi[
rap_bin] - jpsi.nSigBkgLow * jpsi.sigmaMassJpsi[rap_bin]
ctauNonPrompt = .1
massFun = RooFormulaVar(
'massRegion', 'Function that returns the mass state.',
'(' + jPsiMass.GetName() + ' < ' + str(sigMaxMass) + ' && ' +
jPsiMass.GetName() + ' > ' + str(sigMinMass) + ') - (' +
jPsiMass.GetName() + ' > ' + str(sbHighMass) + ')' + '-2*(' +
jPsiMass.GetName() + ' < ' + str(sbLowMass) + ')',
RooArgList(jPsiMass, jPsicTau))
ctauFun = RooFormulaVar(
'ctauRegion', 'Function that returns the ctau state.',
'(' + jPsicTau.GetName() + ' > ' + str(ctauNonPrompt) + ')',
RooArgList(jPsiMass, jPsicTau))
mlFun = RooFormulaVar(
'mlRegion',
'Function that returns the mass and lifetime state.',
'(' + jPsiMass.GetName() + ' < ' + str(sigMaxMass) + ' && ' +
jPsiMass.GetName() + ' > ' + str(sigMinMass) + ') + (' +
jPsiMass.GetName() + ' < ' + str(sigMaxMass) + ' && ' +
jPsiMass.GetName() + ' > ' + str(sigMinMass) + ' && ' +
jPsicTau.GetName() + ' > ' + str(ctauNonPrompt) + ') - (' +
jPsiMass.GetName() + ' > ' + str(sbHighMass) + ')' + '-2*(' +
jPsiMass.GetName() + ' < ' + str(sbLowMass) + ')',
RooArgList(jPsiMass, jPsicTau))
cutStringPt = '(' + jPsiPt.GetName() + ' > ' + str(
ptMin) + ' && ' + jPsiPt.GetName() + ' < ' + str(ptMax) + ')'
cutStringY = '( abs(' + jPsiRap.GetName() + ') > ' + str(
yMin) + ' && abs(' + jPsiRap.GetName() + ') < ' + str(
yMax) + ')'
#cutStringM1 = '('+jPsiMass.GetName()+' < '+str(sigMinMass)+' && '+jPsiMass.GetName()+' > '+str(sbLowMass)+')'
#cutStringM2 = '('+jPsiMass.GetName()+' < '+str(sbHighMass)+' && '+jPsiMass.GetName()+' > '+str(sigMaxMass)+')'
#cutStringMT = '!('+cutStringM1+' || '+cutStringM2+')'
cutString = cutStringPt + ' && ' + cutStringY #+' && '+cutStringMT
print cutString
#get the reduced dataset we'll do the fit on
binData = fullData.reduce(
ROOT.RooFit.SelectVars(redVars), ROOT.RooFit.Cut(cutString),
ROOT.RooFit.Name('data_rap' + str(rap_bin) + '_pt' +
str(pt_bin + 1)),
ROOT.RooFit.Title('Data For Fitting'))
binDataWithCategory = RooDataSet(
'data_rap' + str(rap_bin) + '_pt' + str(pt_bin + 1),
'Data For Fitting', fitVars)
#categorize
binData.addColumn(ctauStates)
binData.addColumn(massStates)
binData.addColumn(states)
for ev in range(binData.numEntries()):
args = binData.get(ev)
jPsiMass.setVal(args.find(jPsiMass.GetName()).getVal())
jPsiRap.setVal(args.find(jPsiRap.GetName()).getVal())
jPsiPt.setVal(args.find(jPsiPt.GetName()).getVal())
jPsicTau.setVal(args.find(jPsicTau.GetName()).getVal())
jPsicTauError.setVal(
args.find(jPsicTauError.GetName()).getVal())
jPsiHXcosth.setVal(args.find(jPsiHXcosth.GetName()).getVal())
jPsiHXphi.setVal(args.find(jPsiHXphi.GetName()).getVal())
massStates.setIndex(int(massFun.getVal()))
ctauStates.setIndex(int(ctauFun.getVal()))
states.setIndex(int(mlFun.getVal()))
binDataWithCategory.add(fitVars)
getattr(ws, 'import')(binDataWithCategory)
for i in range(n_toys % n_p):
n_t[i] += 1
for n in n_t:
c = Calculator(pdf, sigmat_cat, t, st, n)
calculators.append(c)
c.start()
args = RooArgSet(da, dft)
while len(calculators):
for i, calculator in enumerate(calculators):
msg = calculator.queue().get()
if msg == 'done':
calculator.join()
calculators.pop(i)
continue
else:
d_a, d_ft = msg
da.setVal(d_a[0])
dft.setVal(d_ft[0])
dft.setError(d_ft[1])
test_data.add(args)
if test_data.numEntries() % 100 == 0:
print 'completed ', test_data.numEntries()
diff = FormulaVar(Name = 'diff', Formula = '@0 - @1', Arguments = (dft, da), data = test_data)
from ROOT import TFile
f = TFile("dilution.root", "recreate")
f.WriteTObject(test_data, "data")
f.Close()
dilution.setVal( resDil * tagDil )
asymCat.setIndex(tag)
# calculate angular weight
if applyAngWeights :
ctk = evSet.getRealValue('helcosthetaK')
ctl = evSet.getRealValue('helcosthetaL')
phi = evSet.getRealValue('helphi')
if applyAngWeights == 'ang' :
angWeight.setVal( 2. - 5. * ( 1. - ctl**2 ) * sin(phi)**2 )
elif applyAngWeights == 'para_perp' :
angWeight.setVal( ( 9. - 15. * ctk**2 ) * ( 1. - ctl**2 ) * sin(2. * phi) )
#angWeight.setVal( ( 1. - ctl**2 ) * sin(2. * phi) )
# add event to dataset
dataSetAsym.add(obsSet)
dataFile = TFile.Open( dataSetFileOut, 'RECREATE' )
dataFile.Add(dataSetAsym)
dataFile.Write( dataSetFileOut, TObject.kOverwrite )
dataFile.Close()
else :
# read data set with events in two asymmetry categories
print 'plotAsymmetry: reading dataset with events in two asymmetry categories'
dataFile = TFile.Open(dataSetFileOut)
dataSetAsym = dataFile.Get('asymData')
dataFile.Close()
dataSetAsym.Print()
def makeRooDataSet(type,infile_name,outfile_name,tree_name,nevents):
""" Make RooDataSets from TTrees"""
inputfile = TFile.Open(infile_name,"READ")
print "Importing tree"
tree = TTree()
inputfile.GetObject(tree_name, tree) #get the tree from the data file
#define variables for the RooDataSet
m_mumu = RooRealVar("m_mumu", "m_mumu", 0.0, 4.0)
y_mumu = RooRealVar("y_mumu", "y_mumu", 0.0, 2.0 )
pt_mumu = RooRealVar("pt_mumu", "pt_mumu", 0.0, 260.0)
eta_gamma = RooRealVar("eta_gamma","eta_gamma",-3.5, 3.5)
pt_gamma = RooRealVar("pt_gamma", "pt_gamma", 0.0, 100.0)
m_gamma = RooRealVar("m_gamma", "m_gamma", -0.1,0.1)
m_chi_rf1S = RooRealVar("m_chi_rf1S", "m_chi_rf1S", 0.0, 7.0)
m_chi_rf2S = RooRealVar("m_chi_rf2S", "m_chi_rf2S", -1.0, 1.0)
Qvalue = RooRealVar("Qvalue","Q", -15., 15.)
ctpv = RooRealVar("ctpv","ctpv", -1.0, 3.5)
ctpv_error = RooRealVar("ctpv_err","ctpv_err", -1.0, 1.0)
pi0_abs_mass = RooRealVar("pi0_abs_mass","pi0_abs_mass", 0.0, 2.2)
psi1S_nsigma = RooRealVar("psi1S_nsigma","psi1S_nsigma",0.0,1.0)
psi2S_nsigma = RooRealVar("psi2S_nsigma","psi2S_nsigma",0.0,1.0)
psi3S_nsigma = RooRealVar("psi3S_nsigma","psi3S_nsigma",0.0,1.0)
rho_conv = RooRealVar("rho_conv", "rho_conv", 0.0, 70.0)
dz = RooRealVar("dz","dz", -1.0, 1.0)
probFit1S = RooRealVar('probFit1S','probFit1S',0,1)
probFit2S = RooRealVar('probFit2S','probFit2S',0,1)
probFit3S = RooRealVar('probFit3S','probFit3S',0,1)
dataArgSet = RooArgSet(m_mumu,
y_mumu,
pt_mumu,
eta_gamma,
pt_gamma,
m_gamma,
m_chi_rf1S)
dataArgSet.add( m_chi_rf2S )
dataArgSet.add( Qvalue )
dataArgSet.add( ctpv )
dataArgSet.add( ctpv_error )
dataArgSet.add( pi0_abs_mass )
dataArgSet.add( psi1S_nsigma )
dataArgSet.add( psi2S_nsigma )
dataArgSet.add( psi3S_nsigma )
dataArgSet.add( rho_conv )
dataArgSet.add( dz )
dataArgSet.add( probFit1S)
dataArgSet.add( probFit2S)
dataArgSet.add( probFit3S)
print "Creating DataSet"
dataSet = RooDataSet("chicds","Chic RooDataSet", dataArgSet)
entries = tree.GetEntries()
print entries
if nevents is not 0:
entries = nevents
for ientry in range(0,entries):
tree.GetEntry(ientry)
# unfort ntuples are slightly different for chic and chib
if applyscale:
if usekinfit :
spatial = tree.rf3S_photon_p4.Vect()
#spatial = tree.photon_p4.Vect()
spatial *= (1/escale)
corr_photon_p4=TLorentzVector()
#corr_photon_p4.SetVectM(spatial,tree.rf1S_photon_p4.M())
corr_photon_p4.SetVectM(spatial,0)
corr_chi_p4 = tree.rf3S_dimuon_p4 + corr_photon_p4
else:
spatial = tree.photon_p4.Vect()
spatial *= (1/escale)
corr_photon_p4=TLorentzVector()
corr_photon_p4.SetVectM(spatial,tree.photon_p4.M())
corr_chi_p4 = tree.dimuon_p4 + corr_photon_p4
else :
corr_chi_p4 = tree.chi_p4
if type == 'chic':
m_mumu.setVal(tree.dimuon_p4.M())
y_mumu.setVal(tree.dimuon_p4.Rapidity())
pt_mumu.setVal(tree.dimuon_p4.Pt())
eta_gamma.setVal(tree.photon_p4.Eta())
pt_gamma.setVal(tree.photon_p4.Pt())
m_gamma.setVal(tree.photon_p4.M())
m_chi_rf1S.setVal(tree.rf1S_chi_p4.M())
m_chi_rf2S.setVal(tree.rf2S_chi_p4.M())
if usekinfit : Qvalue.setVal(corr_chi_p4.M())
else: Qvalue.setVal((corr_chi_p4).M() - tree.dimuon_p4.M())
#Qvalue.setVal((tree.chi_p4).M()**2 - tree.dimuon_p4.M()**2)
psi1S_nsigma.setVal(tree.psi1S_nsigma)
psi2S_nsigma.setVal(tree.psi2S_nsigma)
psi3S_nsigma.setVal(0)
elif type == 'chib':
m_mumu.setVal(tree.dimuon_p4.M())
y_mumu.setVal(tree.dimuon_p4.Rapidity())
pt_mumu.setVal(tree.dimuon_p4.Pt())
eta_gamma.setVal(tree.photon_p4.Eta())
pt_gamma.setVal(tree.photon_p4.Pt())
m_chi_rf1S.setVal(tree.rf1S_chi_p4.M())
m_chi_rf2S.setVal(tree.rf2S_chi_p4.M())
if usekinfit : Qvalue.setVal(corr_chi_p4.M())
#if usekinfit : Qvalue.setVal(tree.rf3S_chi_p4.M()) #uncorrected
else: Qvalue.setVal(corr_chi_p4.M() - tree.dimuon_p4.M())
psi1S_nsigma.setVal(tree.Y1S_nsigma)
psi2S_nsigma.setVal(tree.Y2S_nsigma)
psi3S_nsigma.setVal(tree.Y3S_nsigma)
ctpv.setVal(tree.ctpv)
ctpv_error.setVal(tree.ctpv_error)
pi0_abs_mass.setVal(tree.pi0_abs_mass)
rho_conv.setVal(tree.conv_vertex)
dz.setVal(tree.dz)
probFit1S.setVal(tree.probFit1S)
probFit2S.setVal(tree.probFit2S)
probFit3S.setVal(tree.probFit3S)
if selectchi1:
if ( tree.chic_pdgId == 20443): dataSet.add(dataArgSet)
else :
dataSet.add(dataArgSet)
outfile = TFile(outfile_name,'recreate')
dataSet.Write()
aa.SetBranchStatus("probe_EcalClusterEt",1)
aa.SetBranchStatus("Jpsi_M",1)
aa.SetBranchStatus("probe_VeloMatch",1)
aa.SetBranchStatus("probe_deltaR",1)
aa.SetBranchStatus("probe_deltaRt",1)
for i,e in enumerate(aa):
if i%10000 == 0:
print i," entry of ",aa.GetEntries()
if e.tag_PT < 1000 or e.probe_PT < 500: continue
if e.probe_TRACK_CHI2NDOF > 1.0 or e.probe_CaloHcalE/e.probe_P > 0.1: continue
if e.probe_IP_OWNPV < 0.1 or e.B_ENDVERTEX_CHI2/e.B_ENDVERTEX_NDOF > 2: continue
if e.tag_MC15TuneV1_ProbNNe < 0.2 or (e.K_MC15TuneV1_ProbNNk*(1-e.K_MC15TuneV1_ProbNNp)) < 0.05 : continue
if e.probe_EcalClusterEt/e.probe_PT < 0.6 or e.probe_EcalClusterEt/e.probe_PT > 1.4: continue
if e.B_FDCHI2_OWNPV < 15 or e.B_HOP_MASS < 3500 or e.B_ConsB_M < 5300: continue
if e.B_M < 4900 or e.B_BPVLTFITCHI2 > 4 : continue
jpsi_m.setVal(e.Jpsi_M)
pt.setVal(e.probe_PT)
eta.setVal(e.probe_ETA)
velomatch.setVal(e.probe_VeloMatch)
dR.setVal(e.probe_deltaR)
dRt.setVal(e.probe_deltaRt)
tagbrem.setVal(e.tag_BremMultiplicity)
ds.add(argset)
oFile = TFile("/user2/sfarry/workspaces/rkst/tuples/bjpsik_mc2016.root", "RECREATE")
ds.Write()
oFile.Close()
def makeRooDataSet(type, infile_name, outfile_name, tree_name, nevents):
""" Make RooDataSets from TTrees"""
inputfile = TFile.Open(infile_name, "READ")
print "Importing tree"
tree = TTree()
inputfile.GetObject(tree_name, tree) #get the tree from the data file
#define variables for the RooDataSet
m_mumu = RooRealVar("m_mumu", "m_mumu", 0.0, 4.0)
y_mumu = RooRealVar("y_mumu", "y_mumu", 0.0, 2.0)
pt_mumu = RooRealVar("pt_mumu", "pt_mumu", 0.0, 260.0)
eta_gamma = RooRealVar("eta_gamma", "eta_gamma", -3.5, 3.5)
pt_gamma = RooRealVar("pt_gamma", "pt_gamma", 0.0, 100.0)
m_gamma = RooRealVar("m_gamma", "m_gamma", -0.1, 0.1)
m_chi_rf1S = RooRealVar("m_chi_rf1S", "m_chi_rf1S", 0.0, 7.0)
m_chi_rf2S = RooRealVar("m_chi_rf2S", "m_chi_rf2S", -1.0, 1.0)
Qvalue = RooRealVar("Qvalue", "Q", -15., 15.)
ctpv = RooRealVar("ctpv", "ctpv", -1.0, 3.5)
ctpv_error = RooRealVar("ctpv_err", "ctpv_err", -1.0, 1.0)
pi0_abs_mass = RooRealVar("pi0_abs_mass", "pi0_abs_mass", 0.0, 2.2)
psi1S_nsigma = RooRealVar("psi1S_nsigma", "psi1S_nsigma", 0.0, 1.0)
psi2S_nsigma = RooRealVar("psi2S_nsigma", "psi2S_nsigma", 0.0, 1.0)
psi3S_nsigma = RooRealVar("psi3S_nsigma", "psi3S_nsigma", 0.0, 1.0)
rho_conv = RooRealVar("rho_conv", "rho_conv", 0.0, 70.0)
dz = RooRealVar("dz", "dz", -1.0, 1.0)
probFit1S = RooRealVar('probFit1S', 'probFit1S', 0, 1)
probFit2S = RooRealVar('probFit2S', 'probFit2S', 0, 1)
probFit3S = RooRealVar('probFit3S', 'probFit3S', 0, 1)
dataArgSet = RooArgSet(m_mumu, y_mumu, pt_mumu, eta_gamma, pt_gamma,
m_gamma, m_chi_rf1S)
dataArgSet.add(m_chi_rf2S)
dataArgSet.add(Qvalue)
dataArgSet.add(ctpv)
dataArgSet.add(ctpv_error)
dataArgSet.add(pi0_abs_mass)
dataArgSet.add(psi1S_nsigma)
dataArgSet.add(psi2S_nsigma)
dataArgSet.add(rho_conv)
dataArgSet.add(dz)
dataArgSet.add(probFit1S)
dataArgSet.add(probFit2S)
dataArgSet.add(probFit3S)
print "Creating DataSet"
dataSet = RooDataSet("chicds", "Chic RooDataSet", dataArgSet)
entries = tree.GetEntries()
print entries
if nevents is not 0:
entries = nevents
for ientry in range(0, entries):
tree.GetEntry(ientry)
# unfort ntuples are slightly different for chic and chib
if applyscale:
if usekinfit:
spatial = tree.rf1S_photon_p4.Vect()
spatial *= (1 / escale)
corr_photon_p4 = TLorentzVector()
#corr_photon_p4.SetVectM(spatial,tree.rf1S_photon_p4.M())
corr_photon_p4.SetVectM(spatial, 0)
corr_chi_p4 = tree.rf1S_dimuon_p4 + corr_photon_p4
else:
spatial = tree.photon_p4.Vect()
spatial *= (1 / escale)
corr_photon_p4 = TLorentzVector()
corr_photon_p4.SetVectM(spatial, tree.photon_p4.M())
corr_chi_p4 = tree.dimuon_p4 + corr_photon_p4
else:
corr_chi_p4 = tree.chi_p4
if type == 'chic':
m_mumu.setVal(tree.dimuon_p4.M())
y_mumu.setVal(tree.dimuon_p4.Rapidity())
pt_mumu.setVal(tree.dimuon_p4.Pt())
eta_gamma.setVal(tree.photon_p4.Eta())
pt_gamma.setVal(tree.photon_p4.Pt())
m_gamma.setVal(tree.photon_p4.M())
m_chi_rf1S.setVal(tree.rf1S_chi_p4.M())
m_chi_rf1S.setVal(tree.rf2S_chi_p4.M())
if usekinfit: Qvalue.setVal(corr_chi_p4.M())
else: Qvalue.setVal((corr_chi_p4).M() - tree.dimuon_p4.M())
print 'corr value ', corr_chi_p4.M()
#Qvalue.setVal((tree.chi_p4).M()**2 - tree.dimuon_p4.M()**2)
psi1S_nsigma.setVal(tree.psi1S_nsigma)
psi2S_nsigma.setVal(tree.psi2S_nsigma)
psi3S_nsigma.setVal(0)
elif type == 'chib':
m_mumu.setVal(tree.dimuon_p4.M())
y_mumu.setVal(tree.dimuon_p4.Rapidity())
pt_mumu.setVal(tree.dimuon_p4.Pt())
eta_gamma.setVal(tree.photon_p4.Eta())
pt_gamma.setVal(tree.photon_p4.Pt())
m_chi_rf1S.setVal(tree.rf1S_chi_p4.M())
m_chi_rf2S.setVal(tree.rf2S_chi_p4.M())
if usekinfit: Qvalue.setVal(corr_chi_p4.M())
else: Qvalue.setVal(corr_chi_p4.M() - tree.dimuon_p4.M())
psi1S_nsigma.setVal(tree.Y1S_nsigma)
psi2S_nsigma.setVal(tree.Y2S_nsigma)
psi3S_nsigma.setVal(tree.Y3S_nsigma)
probFit1S.setVal(tree.probFit1S)
probFit2S.setVal(tree.probFit2S)
probFit3S.setVal(tree.probFit3S)
ctpv.setVal(tree.ctpv)
ctpv_error.setVal(tree.ctpv_error)
pi0_abs_mass.setVal(tree.pi0_abs_mass)
rho_conv.setVal(tree.conv_vertex)
dz.setVal(tree.dz)
if selectchi1:
if (tree.chic_pdgId == 20443): dataSet.add(dataArgSet)
else:
dataSet.add(dataArgSet)
outfile = TFile(outfile_name, 'recreate')
dataSet.Write()
hist = swimming_histos(bins, t, sig_t, data, [signal])[signal]
from ROOT import TCanvas
canvas = TCanvas('canvas', 'canvas', 600, 400)
canvas.SetLogx(True)
hist.Draw()
assert(False)
coefs = acc_fun.coefficients()[acc_fun.GetName()]
for i, c in enumerate(coefs):
c.setVal(hist.GetBinContent(i + 1))
## RooMsgService.instance().addStream(RooFit.DEBUG, RooFit.Topic(RooFit.Integration))
result = sig_t.fitTo(data, **fitOpts)
tau_result.setVal(tau.getVal())
tau_result.setError(tau.getError())
result_data.add(RooArgSet(tau_result))
tau.setVal(tau_true.getVal())
tau.setError(0.1)
tau_pull = RooPullVar("tau_pull", "tau_pull", tau_result._target_(), tau_true._target_())
tau_pull = result_data.addColumn(tau_pull)
tau_pull = w.put(tau_pull)
mean = RealVar('mean', Value = 0, MinMax = (-4, 4))
sigma = RealVar('sigma', Value = 1, MinMax = (0.1, 5))
from ROOT import RooGaussian
gauss = Pdf(Name = 'gauss', Type = RooGaussian, Parameters = (tau_pull, mean, sigma))
result = gauss.fitTo(result_data, **fitOpts)
from ROOT import TPostScript
class CouplingsFitterTest(object):
def __init__(self):
self.poiLabels = []
self.poi = dict()
self.poilabels = dict()
self.constraint = dict()
self.canvases = dict()
self._keep = []
def addPOI(self, poi, label='', minimum=-0.3, maximum=0.3):
'''Add a parameter of interest.
Example:
addPOI('Z','Z',-0.05,0.05)
->
Z[0,-0.05,0.05]
# adds variable Z with value 0,
# allow it to scale between -0.05 and 0.05
'''
self.poi[poi] = ROOT.RooRealVar(poi, poi, 0, minimum, maximum)
if label == '':
label = poi
self.poilabels[poi] = label
def addConstraint(self, name, expr, deplist, mean, sigma):
'''Add a constraint on one of the observables
For example, for ZH inclusive:
f.addConstraint('Zh','(1+Z)*(1+Z)','Z',1,0.004)
Z is an additive modification of the gZ coupling w/r to the standard model,
so 1+Z = \kappa_Z
Zh is the pdf of the ratio of the yield w/r to the one expected in the standard model.
This pdf depends on Z, as (1+Z)*(1+Z).
ZhObs is the measured value, here 1 so we assume that the SM yield is observed.
The fit varies the parameter of interest Z, thus modifying the pdf,
while ZhObs is fixed at 1. The likelihood of each value of Z is evaluated at ZhObs on the pdf.
'''
deps = self._getdeps(deplist)
self.constraint[name] = GaussianConstraint(name, expr, deps, mean,
sigma)
def _getdeps(self, deplist):
depnames = deplist
try:
depnames = deplist.split(',')
except:
pass
deps = []
for dep in depnames:
if dep == 'width':
deps.append(self.width)
else:
deps.append(self.poi[dep])
return deps
def addUniformConstraint(self, name, expr):
'''Adds a uniform constraint with pdf name, and expression expr.
For example:
f.addPOI('inv','inv', 0, 0.01)
f.addUniformConstraint('Zhinv','inv') ####->Means free floating
inv (the invisible BR) is free to float between 0 and 1%
'''
deps = self._getdeps([expr])
self.constraint[name] = UniformConstraint(name, expr, deps)
def info(self):
for name, constraint in sorted(self.constraint.iteritems()):
constraint.info()
def fit(self):
pdfs = RooArgList()
obsvars = RooArgSet('set')
for constraint in self.constraint.values():
pdfs.add(constraint.pdf_constraint)
if hasattr(constraint, 'var_obs'):
obsvars.add(constraint.var_obs)
self.model = RooProdPdf('model', 'model', pdfs)
self.data = RooDataSet('data', 'data', obsvars)
self.data.add(obsvars)
self.data.Print()
self.fit_result = self.model.fitTo(self.data,
ROOT.RooFit.PrintLevel(3),
ROOT.RooFit.Optimize(1),
ROOT.RooFit.Hesse(1),
ROOT.RooFit.Minos(1),
ROOT.RooFit.Strategy(2),
ROOT.RooFit.Save(1))
def canvas(self, name, *args):
canvas = self.canvases.setdefault(name,
ROOT.TCanvas(name, name, *args))
canvas.cd()
return canvas
def keep(self, obj):
self._keep.append(obj)
return obj
def createSummary(self):
#sample the covariance matrix for the width
# ROOT.gStyle.SetOptTitle(0)
## ROOT.gStyle.SetStatW(0.4);
## ROOT.gStyle.SetStatH(0.4);
##
## self.graph_couplings = ROOT.TGraphAsymmErrors(len(self.poi)+2)
##
## order_BR = ['Z', 'W', 'b', 'c', 'g', 'tau', 'mu', 'gamma', 'inv']
##
## for br in order_BR:
## if not self.poi.get(br, None):
## order_BR.remove(br)
##
## for i, poiname in enumerate(order_BR):
## poi = self.poi.get(poiname)
## self.graph_couplings.SetPoint(i, i+0.5, poi.getVal())
## self.graph_couplings.SetPointError(i, 0.0, 0.0, -poi.getAsymErrorLo(), poi.getAsymErrorHi())
print 'Sampling the covariance matrix to propagate error on width'
## self.h_width = ROOT.TH1F('h_width','width',1000,0.5,1.5)
ntoys = 10000
for i in range(ntoys):
randomizedPars = self.fit_result.randomizePars()
for j in range(0, randomizedPars.getSize()):
self.poi[randomizedPars.at(j).GetName()].setVal(
randomizedPars.at(j).getVal())
## self.h_width.Fill(self.width.getVal())
## for cstr in self.constraint.values():
## cstr.fill_pull()
## self.graph_couplings.SetMarkerStyle(20)
## self.graph_couplings.SetLineWidth(3)
## can_couplings = self.canvas('couplings')
## self.graph_couplings.Draw("AP")
## self.graph_couplings.GetYaxis().SetTitle("68% CL on d(A) ")
## self.graph_couplings.GetXaxis().SetNdivisions(0)
## l= self.keep(ROOT.TLine())
## l.SetLineColor(ROOT.kRed)
## l.SetLineWidth(3)
## l.DrawLine(0.0,0.0,len(self.poi)+1.5,0)
## self.graph_couplings.SetPoint(len(self.poi),len(self.poi)+0.5,0.0)
## self.graph_couplings.SetPointError(len(self.poi),0.0,0.0,self.h_width.GetRMS()/self.h_width.GetMean(),
## self.h_width.GetRMS()/self.h_width.GetMean())
##
## for i, poiname in enumerate(order_BR+['#Gamma_{T}']):
## label = self.poilabels.get(poiname, poiname)
## tex = self.keep(ROOT.TLatex(i+0.5,0.95*self.graph_couplings.GetYaxis().GetXmin(),label))
## tex.Draw()
##
print """
###############################################################
###############################################################
###############################################################
RESULTS
###############################################################
###############################################################
###############################################################
"""
print 'RESULTS FOR THE CONFIDENCE INTERVALS------>'
for name in self.poi:
poi = self.poi[name]
poiLabel = self.poilabels.get(name, name)
mind = poi.getAsymErrorLo() * 100
maxd = poi.getAsymErrorHi() * 100
avd = abs(maxd - mind) / 2.
# print poiLabel+': ('+str(poi.getAsymErrorLo())+','+str(poi.getAsymErrorHi())+'), ' + str(avd)
print '{label:10}:\t{mind:5.3f}%\t{maxd:5.3f}%\t{avd:5.3f}%'.format(
label=poiLabel, mind=mind, maxd=maxd, avd=avd)
def gen_data_and_fit(ws, iterations,cat, mass,channel,turnon,truth):
if channel in channels:
#fit gaus(x)bern to sigm(x)pow and sigm(x)exp
#fit sigm(x)bern to erf(x)pow and erf(x)exp
n_sample = int(ws.data('bkgdata_%s_%i'%(channel,cat)).sumEntries())
if turnon == 'erf' and truth == 'exp':
ws.factory('pull_ROI_erf_on_sigmexp_%s_cat%i[0]'%(channel,cat))
ws.defineSet('biasVars_%s_cat%i'%(channel,cat),
'pull_ROI_erf_on_sigmexp_%s_cat%i,'%(channel,cat))
if turnon == 'erf' and truth == 'pow':
ws.factory('pull_ROI_erf_on_sigmpow_%s_cat%i[0]'%(channel,cat))
ws.defineSet('biasVars_%s_cat%i'%(channel,cat),
'pull_ROI_erf_on_sigmpow_%s_cat%i,'%(channel,cat)
)
if turnon == 'sigm' and truth == 'exp':
ws.factory('pull_ROI_sigm_on_erfexp_%s_cat%i[0]'%(channel,cat))
ws.defineSet('biasVars_%s_cat%i'%(channel,cat),
'pull_ROI_sigm_on_erfexp_%s_cat%i,'%(channel,cat)
)
if turnon == 'sigm' and truth == 'pow':
ws.factory('pull_ROI_sigm_on_erfpow_%s_cat%i[0]'%(channel,cat))
ws.defineSet('biasVars_%s_cat%i'%(channel,cat),
'pull_ROI_sigm_on_erfpow_%s_cat%i'%(channel,cat)
)
biasData = RooDataSet('biasData_%s_cat%i'%(channel,cat),
'bias data',
ws.set('biasVars_%s_cat%i'%(channel,cat)))
for i in xrange(iterations):
### SIGM
#build ERF toy data to fit with SIGM
if turnon == 'sigm' and truth == 'exp':
truth_exp_erf = ws.pdf('MzgTruthModel_exp_erf_%s_cat%i'%(channel,cat))
toy_data_exp_erf = truth_exp_erf.generate(
RooArgSet(ws.var('Mzg')),
n_sample,
RooFit.Extended(),
RooFit.Name('toy_erfexp_%s_cat%i_%i'%(channel,cat,i))
)
true_ROI_yield_erfexp = ws.var('norm_truth_exp_%s_cat%i'%(channel,cat)).getVal()
#fit logistics(x)bern to erfexp
ws.var('norm_altrsb_cat%i'%cat).setMin(true_ROI_yield_erfexp*0.25)
ws.var('norm_altrsb_cat%i'%cat).setMax(true_ROI_yield_erfexp*1.75)
ws.var('norm_altrsb_cat%i'%cat).setVal(true_ROI_yield_erfexp)
minos_var = RooArgSet(ws.var('norm_altrsb_cat%i'%cat))
sigm_nll = ws.pdf('RSBFitModelAlt_cat%i'%cat).createNLL(
toy_data_exp_erf
)
sigm_min = RooMinimizer(sigm_nll)
sigm_min.setPrintLevel(1)
sigm_min.minimize('Minuit2','scan')
sigm_min.minimize('Minuit2','simplex')
migrad_out = sigm_min.migrad()
migrad_out = sigm_min.migrad()
hesse_out = sigm_min.hesse()
fit_sigm_norm = ws.var('norm_altrsb_cat%i'%cat).getVal()
fit_sigm_err = ws.var('norm_altrsb_cat%i'%cat).getError()
fit_sigm_pull = (fit_sigm_norm - true_ROI_yield_erfexp)/fit_sigm_err
#if fit failed run minos
if migrad_out != 0 or hesse_out != 0:
migrad_out = sigm_min.migrad()
if migrad_out != 0:
sigm_min.minos(minos_var)
fit_sigm_err = max(abs(ws.var('norm_altrsb_cat%i'%cat).getErrorHi()),
abs(ws.var('norm_altrsb_cat%i'%cat).getErrorLo()))
else:
fit_sigm_err = ws.var('norm_altrsb_cat%i'%cat).getError()
fit_sigm_norm = ws.var('norm_altrsb_cat%i'%cat).getVal()
fit_sigm_pull = (fit_sigm_norm - true_ROI_yield_erfexp)/fit_sigm_err
print i, fit_sigm_norm, fit_sigm_err, true_ROI_yield_erfexp, fit_sigm_pull
ws.var('pull_ROI_sigm_on_erfexp_%s_cat%i'%(channel,cat)).setVal(
fit_sigm_pull
)
biasData.add(ws.set('biasVars_%s_cat%i'%(channel,cat)))
var = ws.var('pull_ROI_sigm_on_erfexp_%s_cat%i'%(channel,cat))
print 'cumulative median bias: %.3f'%calculate_median(var,biasData)
var = None
del sigm_min
del sigm_nll
del truth_exp_erf
if turnon =='sigm' and truth =='pow':
truth_pow_erf = ws.pdf('MzgTruthModel_pow_erf_%s_cat%i'%(channel,cat))
toy_data_pow_erf = truth_pow_erf.generate(
RooArgSet(ws.var('Mzg')),
n_sample,
RooFit.Extended(),
RooFit.Name('toy_erfpow_%s_cat%i_%i'%(channel,cat,i))
)
true_ROI_yield_erfpow = ws.var('norm_truth_pow_erf_%s_cat%i'%(channel,cat)).getVal()
#fit logistics(x)bern to erfpow
ws.var('norm_altrsb_cat%i'%cat).setMin(true_ROI_yield_erfpow*0.25)
ws.var('norm_altrsb_cat%i'%cat).setMax(true_ROI_yield_erfpow*1.75)
ws.var('norm_altrsb_cat%i'%cat).setVal(true_ROI_yield_erfpow)
minos_var = RooArgSet(ws.var('norm_altrsb_cat%i'%cat))
sigm_nll = ws.pdf('RSBFitModelAlt_cat%i'%cat).createNLL(
toy_data_pow_erf
)
sigm_min = RooMinimizer(sigm_nll)
sigm_min.setPrintLevel(1)
sigm_min.minimize('Minuit2','scan')
sigm_min.minimize('Minuit2','simplex')
migrad_out = sigm_min.migrad()
migrad_out = sigm_min.migrad()
hesse_out = sigm_min.hesse()
fit_sigm_norm = ws.var('norm_altrsb_cat%i'%cat).getVal()
fit_sigm_err = ws.var('norm_altrsb_cat%i'%cat).getError()
fit_sigm_pull = (fit_sigm_norm - true_ROI_yield_erfpow)/fit_sigm_err
#if fit failed run minos
if migrad_out != 0 or hesse_out != 0:
migrad_out = sigm_min.migrad()
if migrad_out != 0:
sigm_min.minos(minos_var)
fit_sigm_err = max(abs(ws.var('norm_altrsb_cat%i'%cat).getErrorHi()),
abs(ws.var('norm_altrsb_cat%i'%cat).getErrorLo()))
else:
fit_sigm_err = ws.var('norm_altrsb_cat%i'%cat).getError()
fit_sigm_norm = ws.var('norm_altrsb_cat%i'%cat).getVal()
fit_sigm_pull = (fit_sigm_norm - true_ROI_yield_erfpow)/fit_sigm_err
ws.var('pull_ROI_sigm_on_erfpow_%s_cat%i'%(channel,cat)).setVal(
fit_sigm_pull
)
print i, fit_sigm_norm, fit_sigm_err, true_ROI_yield_erfpow, fit_sigm_pull
biasData.add(ws.set('biasVars_%s_cat%i'%(channel,cat)))
var = ws.var('pull_ROI_sigm_on_erfpow_%s_cat%i'%(channel,cat))
print 'cumulative median bias: %.3f'%calculate_median(var,biasData)
var = None
del sigm_min
del sigm_nll
del truth_pow_erf
##### ERF
# generate SIGM data to fit with ERF
#### fit erf(x)bern models
if turnon == 'erf' and truth == 'exp':
truth_exp_sigm = ws.pdf('MzgTruthModel_exp_sigm_%s_cat%i'%(channel,cat))
toy_data_exp_sigm = truth_exp_sigm.generate(
RooArgSet(ws.var('Mzg')),
n_sample,
RooFit.Extended(),
RooFit.Name('toy_sigmexp_%s_cat%i_%i'%(channel,cat,i))
)
true_ROI_yield_sigmexp = ws.var('norm_truth_exp_sigm_%s_cat%i'%(channel,cat)).getVal()
#fit erf(x)bern to sigmexp
ws.var('norm_rsb_cat%i'%cat).setMin(true_ROI_yield_sigmexp*0.25)
ws.var('norm_rsb_cat%i'%cat).setMax(true_ROI_yield_sigmexp*1.75)
ws.var('norm_rsb_cat%i'%cat).setVal(true_ROI_yield_sigmexp)
minos_var = RooArgSet(ws.var('norm_rsb_cat%i'%cat))
gaus_nll = ws.pdf('RSBFitModel_cat%i'%cat).createNLL(
toy_data_exp_sigm
)
gaus_min= RooMinimizer(gaus_nll)
gaus_min.setPrintLevel(1)
gaus_min.minimize('Minuit2','scan')
gaus_min.minimize('Minuit2','simplex')
migrad_out = gaus_min.migrad()
migrad_out = gaus_min.migrad()
hesse_out = gaus_min.hesse()
#get parabolic errors regardless
fit_erf_norm = ws.var('norm_rsb_cat%i'%cat).getVal()
fit_erf_err = ws.var('norm_rsb_cat%i'%cat).getError()
fit_erf_pull = (fit_erf_norm - true_ROI_yield_sigmexp)/fit_erf_err
#if fit failed run minos
if migrad_out != 0 or hesse_out != 0:
migrad_out = gaus_min.migrad()
if migrad_out != 0:
gaus_min.minos(minos_var)
fit_erf_err = max(abs(ws.var('norm_rsb_cat%i'%cat).getErrorHi()),
abs(ws.var('norm_rsb_cat%i'%cat).getErrorLo()))
else:
fit_erf_err = ws.var('norm_rsb_cat%i'%cat).getError()
fit_erf_norm = ws.var('norm_rsb_cat%i'%cat).getVal()
fit_erf_pull = (fit_erf_norm - true_ROI_yield_sigmexp)/fit_erf_err
ws.var('pull_ROI_erf_on_sigmexp_%s_cat%i'%(channel,cat)).setVal(
fit_erf_pull
)
print i,fit_erf_norm, fit_erf_err, true_ROI_yield_sigmexp, fit_erf_pull
biasData.add(ws.set('biasVars_%s_cat%i'%(channel,cat)))
var = ws.var('pull_ROI_erf_on_sigmerf_%s_cat%i'%(channel,cat))
print 'cumulative median bias: %.3f'%calculate_median(var,biasData)
var = None
del gaus_min
del gaus_nll
del truth_exp_sigm
if turnon == 'erf' and truth == 'pow':
truth_pow_sigm = ws.pdf('MzgTruthModel_pow_sigm_%s_cat%i'%(channel,cat))
toy_data_pow_sigm = truth_pow_sigm.generate(
RooArgSet(ws.var('Mzg')),
n_sample,
RooFit.Extended(),
RooFit.Name('toy_sigmpow_%s_cat%i_%i'%(channel,cat,i))
)
true_ROI_yield_sigmpow = ws.var('norm_truth_pow_sigm_%s_cat%i'%(channel,cat)).getVal()
#fit erf(x)bern to sigmpow
ws.var('norm_rsb_cat%i'%cat).setMin(true_ROI_yield_sigmpow*0.25)
ws.var('norm_rsb_cat%i'%cat).setMax(true_ROI_yield_sigmpow*1.75)
ws.var('norm_rsb_cat%i'%cat).setVal(true_ROI_yield_sigmpow)
minos_var = RooArgSet(ws.var('norm_rsb_cat%i'%cat))
gaus_nll = ws.pdf('RSBFitModel_cat%i'%cat).createNLL(
toy_data_pow_sigm
)
gaus_min= RooMinimizer(gaus_nll)
gaus_min.setPrintLevel(1)
gaus_min.minimize('Minuit2','scan')
gaus_min.minimize('Minuit2','simplex')
migrad_out = gaus_min.migrad()
migrad_out = gaus_min.migrad()
hesse_out = gaus_min.hesse()
fit_erf_norm = ws.var('norm_rsb_cat%i'%cat).getVal()
fit_erf_err = ws.var('norm_rsb_cat%i'%cat).getError()
fit_erf_pull = (fit_erf_norm - true_ROI_yield_sigmpow)/fit_erf_err
#if fit failed run minos
if migrad_out != 0 or hesse_out != 0:
migrad_out = gaus_min.migrad()
if migrad_out != 0:
gaus_min.minos(minos_var)
fit_erf_err = max(abs(ws.var('norm_rsb_cat%i'%cat).getErrorHi()),
abs(ws.var('norm_rsb_cat%i'%cat).getErrorLo()))
else:
fit_erf_err = ws.var('norm_rsb_cat%i'%cat).getError()
fit_erf_norm = ws.var('norm_rsb_cat%i'%cat).getVal()
fit_erf_pull = (fit_erf_norm - true_ROI_yield_sigmpow)/fit_erf_err
print i, fit_erf_norm, fit_erf_err, true_ROI_yield_sigmpow, fit_erf_pull
ws.var('pull_ROI_erf_on_sigmpow_%s_cat%i'%(channel,cat)).setVal(
fit_erf_pull
)
biasData.add(ws.set('biasVars_%s_cat%i'%(channel,cat)))
var = ws.var('pull_ROI_erf_on_sigmpow_%s_cat%i'%(channel,cat))
print 'cumulative median bias: %.3f'%calculate_median(var,biasData)
var = None
#getattr(ws,'import')(toy_data_exp_sigm)
#getattr(ws,'import')(toy_data_pow_sigm)
del gaus_min
del gaus_nll
del truth_pow_sigm
getattr(ws,'import')(biasData)
bin = splitPars[cat][2][-1]
for thresh in splitPars[cat][3] :
if val < thresh[0] :
bin = thresh[1]
break
state.append(bin)
# draw event from input n-tuple
input = inNTuples[ tuple(state) ]
while True :
nEv = input[0].GetEntries()
assert nEv - len(input[1]) > 0
ev = int( float(nEv) * ( 1. - randGen.Rndm() ) )
if ev in input[1] : continue
input[1].append(ev)
break
input[0].GetEntry(ev)
for obs in obsNames :
protoSet.setRealValue( obs, getattr( input[0], obs ) )
outputData.add(protoSet)
inputFile.Close()
# write generated dataset to file
print 'P2VV - INFO: generateFromFile(): writing generated data to %s' % args.outputFile
outputData.Print()
from ROOT import TObject
outputFile = TFile.Open( args.outputFile, 'RECREATE' )
outputFile.Add(outputData)
outputFile.Write( args.outputFile, TObject.kOverwrite )
def main(options,args):
inputfiles = [ 'default', 'default' ]
# inputfiles = [ 'file:/scratch/knuenz/Polarization/RootInput/Chib/chibstep5_2011A.root', 'file:/scratch/knuenz/Polarization/RootInput/Chib/chibstep5_2011B.root' ]
# inputfiles = [ 'file:/scratch/knuenz/Polarization/RootInput/Chib/chib_2011A_gtV21A_2082pb.root', 'file:/scratch/knuenz/Polarization/RootInput/Chib/chib_2011B_gtV21A_2613pb.root' ]
# inputfiles = [ 'file:/scratch/knuenz/Polarization/RootInput/Chib/chicstep5_chibV1_A.root', 'file:/scratch/knuenz/Polarization/RootInput/Chib/chicstep5_chibV1_B.root' ]
# inputfiles = [ 'file:/scratch/knuenz/Polarization/RootInput/Chib/chibstep5_v13d_A_17Jan.root', 'file:/scratch/knuenz/Polarization/RootInput/Chib/chibstep5_v13d_B_17Jan.root' ]
inputfiles = [ 'file:/scratch/knuenz/Polarization/RootInput/Chib/chibstep5_chibV1_A_20Jan.root', 'file:/scratch/knuenz/Polarization/RootInput/Chib/chibstep5_chibV1_B_20Jan.root' ]
# inputfiles = [ 'file:/scratch/knuenz/Polarization/RootInput/Chib/chibstep5_pi0Rej_false_A_27jan.root', 'file:/scratch/knuenz/Polarization/RootInput/Chib/chibstep5_pi0Rej_false_B_27jan.root' ]
# inputfiles = [ 'file:/scratch/knuenz/Polarization/RootInput/Chib/chibstep5_pi0Rej_false_A_27jan.root' ]
# inputfiles = [ 'file:/scratch/knuenz/Polarization/RootInput/Chib/chibstep5_pi0Rej_false_A_30jan.root', 'file:/scratch/knuenz/Polarization/RootInput/Chib/chibstep5_pi0Rej_false_B_30jan.root' ]
# inputfiles = [ 'file:/scratch/knuenz/Polarization/RootInput/Chib/chibstep5_pi0Rej_false_B_30jan.root' ]
# inputfiles = [ 'file:/scratch/knuenz/Polarization/RootInput/Chib/chibstep5_chibV1_A_20Jan.root' ]
# gROOT.ProcessLine('.L /afs/hephy.at/scratch/k/knuenz/CMSSW_4_2_4_patch2/src/CommonTools/Statistics/src/ChiSquaredProbability.cc+')
# gROOT.ProcessLine('.L /afs/hephy.at/scratch/k/knuenz/CMSSW_4_2_4_patch2/src/CommonTools/Statistics/src/IncompleteGammaComplement.cc+')
# from ROOT import ChiSquaredProbability
# from ROOT import IncompleteGammaComplement
Y1Smass0=9.46030
Y2Smass0=10.02326
Y3Smass0=10.3552
Ymass_a=0.058
Ymass_b=0.047
Ymass_c=0.22
events= Events(inputfiles)
# candidate Chi
chicCand_h = Handle ("vector<reco::CompositeCandidate>")
chicCand_l = ( "chib","chicCompCand","chibs5" )
#candidate J/Psi
jpsiCand_h = Handle ("vector<reco::CompositeCandidate>")
jpsiCand_l = ( "chib","jpsiCompCand" ,"chibs5")
jpsiCandPAT_h = Handle ("vector<pat::CompositeCandidate>")
jpsiCandPAT_l = ( "onia2MuMuPatTrkTrk","" )
#candidate gamma
gammaCand_h = Handle ("vector<reco::CompositeCandidate>")
gammaCand_l = ( "chib","gammaCompCand" ,"chibs5")
convCand_h = Handle ("vector<reco::Conversion>")
convCand_l = ( "allConversions","" )
# Create histograms, etc.
gROOT.SetBatch() # don't pop up canvases
gROOT.SetStyle('Plain') # white background
#fill a RooDataSet
invm1S = RooRealVar("invm1S", "invm1S",9,50)
invm2S = RooRealVar("invm2S", "invm2S",9,50)
invm3S = RooRealVar("invm3S", "invm3S",9,50)
jpsipt = RooRealVar("jpsipt", "jpsipt",0,100)
jpsimass = RooRealVar("jpsimass", "jpsimass",8,12)
gammapt = RooRealVar("gammapt", "gammapt",0,100)
deltaRChiJpsi = RooRealVar("deltaRChiJpsi","deltaRChiJpsi",0,1)
deltaRJpsig = RooRealVar("deltaRJpsig","deltaRJpsig",0,1)
jpsieta = RooRealVar("jpsieta","jpsieta",-5,5)
ctpv = RooRealVar("ctpv", "ctpv",-5,5)
ctpverr = RooRealVar("ctpverr","ctpverr",0,10)
ctbs = RooRealVar("ctbs", "ctbs",-5,5)
ctbserr = RooRealVar("ctbserr","ctbserr",0,10)
ctpvsig = RooRealVar("ctpvsig", "ctpvsig",0,1000)
ctbssig = RooRealVar("ctbssig", "ctbssig",0,1000)
weight = RooRealVar("weight", "weight",0,1)
Rconv = RooRealVar("Rconv","Rconv",0,100)
jpsiVprob = RooRealVar("jpsiVprob","jpsiVprob",0,1.5)
Y1Smass_nSigma = RooRealVar("Y1Smass_nSigma","Y1Smass_nSigma",-100,100)
Y2Smass_nSigma = RooRealVar("Y2Smass_nSigma","Y2Smass_nSigma",-100,100)
Y3Smass_nSigma = RooRealVar("Y3Smass_nSigma","Y3Smass_nSigma",-100,100)
jpsipx = RooRealVar("jpsipx", "jpsipx",-100,100)
jpsipy = RooRealVar("jpsipy", "jpsipy",-100,100)
jpsipz = RooRealVar("jpsipz", "jpsipz",-100,100)
gammapx = RooRealVar("gammapx", "gammapx",-100,100)
gammapy = RooRealVar("gammapy", "gammapy",-100,100)
gammapz = RooRealVar("gammapz", "gammapz",-100,100)
vertexChi2ProbGamma = RooRealVar("vertexChi2ProbGamma", "vertexChi2ProbGamma",0,1)
Q = RooRealVar("Q", "Q",0,100)
argSet = RooArgSet()
argSet.add(invm1S)
argSet.add(invm2S)
argSet.add(invm3S)
argSet.add(jpsipt)
argSet.add(jpsieta)
argSet.add(jpsimass)
argSet.add(gammapt)
argSet.add(deltaRJpsig)
argSet.add(deltaRChiJpsi)
argSet.add(ctpv)
argSet.add(ctpverr)
argSet.add(ctpvsig)
argSet.add(ctbs)
argSet.add(ctbserr)
argSet.add(ctbssig)
argSet.add(Rconv)
argSet.add(jpsiVprob)
argSet.add(Y1Smass_nSigma)
argSet.add(Y2Smass_nSigma)
argSet.add(Y3Smass_nSigma)
argSet.add(jpsipx)
argSet.add(jpsipy)
argSet.add(jpsipz)
argSet.add(gammapx)
argSet.add(gammapy)
argSet.add(gammapz)
argSet.add(vertexChi2ProbGamma)
argSet.add(Q)
rds = RooDataSet("d","d",argSet,"weight")
hmass = TH1F("hmass","hmass",400,9.0,25)
Ymass = TH1F("Ymass","Ymass",400,9.0,13)
hmass_DeltaRChiJpsi = TH2F("hmass_DeltaRChiJpsi","hmass_DeltaRChiJpsi",10,0,0.5,400,9.0,13)
hmass_DeltaRJpsig = TH2F("hmass_DeltaRJpsig","hmass_DeltaRJpsig",80,0,4,400,9.0,13)
hmass_DeltaPhiJpsig = TH2F("hmass_DeltaPhiJpsig","hmass_DeltaPhiJpsig",80,0,4,400,9.0,13)
hmass_DeltaEtaJpsig = TH2F("hmass_DeltaEtaJpsig","hmass_DeltaEtaJpsig",80,0,4,400,9.0,13)
hmass_gammapt = TH2F("hmass_gammaPt","hmass_gammaPt",80,0,4,400,9.0,13)
hgammapt_DeltaRJpsig = TH2F("hgammaPt_DeltaRJpsig","hgammaPt_DeltaRJpsig",80,0,4,100,0,10)
hgammapt = TH1F("gpt","gpt",100,0,10)
hct = TH1F("ct","ct",100,-0.5,0.5)
hmass_Rconv = TH2F("hmass_Rconv","hmass_Rconv",100,0,50,400,9.0,13)
hGammaP = TH1F("hGammaP","hGammaP",100,-15,15)
hUpsP = TH1F("hUpsP","hUpsP",100,-50,50)
hCosAlphaP = TH1F("hCosAlphaP","hCosAlphaP",100,-1,1)
# loop over events
ncands=0
nevents=0
ncoll=0
nSel=0
countExceptions=0
for event in events:
nevents+=1
#print 'nevents', nevents
#print dir(event._event.getTFile().GetName())
#print dir(event._event.time())
#if nevents>200:
#print "run %d \t lumi %d \t orbit %d \t file %s" % (event._event.getRun().run(),event._event.luminosityBlock(), event._event.orbitNumber(),event._event.getTFile().GetName())
#break
#print event._event.getEvent()
#print event
#if not event.getByLabel (chicCand_l,chicCand_h) : continue
# if nevents>0:
try:
event.getByLabel (chicCand_l,chicCand_h)
event.getByLabel (jpsiCand_l,jpsiCand_h)
event.getByLabel (jpsiCandPAT_l,jpsiCandPAT_h)
event.getByLabel (gammaCand_l,gammaCand_h)
event.getByLabel (convCand_l,convCand_h)
if not chicCand_h.isValid() : continue
chicColl = chicCand_h.product()
jpsiColl = jpsiCand_h.product()
jpsiCollPAT = jpsiCandPAT_h.product()
gammaColl = gammaCand_h.product()
convColl = convCand_h.product()
except:
countExceptions = countExceptions+1
print "exception", countExceptions
continue
#loop over candidates
for i in range(chicColl.size()):
ncands+=1
#print 'ncands', ncands
chicCand = chicColl[i]
jpsiCand = jpsiColl[i]
jpsiCandPAT = jpsiCollPAT[0]
gammaCand = gammaColl[i]
#convCand = convColl[0]
#match gamma candidate and conversion candidate crudely
dptmin = 9999
for c in convColl:
ncoll+=1
# print 'ncoll', ncoll
diff = abs(c.pairMomentum().rho() - gammaCand.pt())
if diff < dptmin:
dptmin = diff
convCand = c
#print 'dptmin',dptmin
#print chicCand.mass() , jpsiCand.mass(), gammaCand.pt(),
#if abs(chicCand.eta()) > 1.1 : continue
# if abs(jpsiCand.eta()) > YrapCut : continue
#reject conversions outside pixles
# if jpsiCandPAT.userFloat('ppdlPV') > YLTCut : continue
# if convCand.conversionVertex().position().rho() > 12 : continue
# if convCand.conversionVertex().position().rho() < 2 : continue
#if gammaCand.pt() < 1.0 :continue
# if gammaCand.pt() < 1.0 :continue
# if jpsiCand.mass() > YmassMin or jpsiCand.mass() < YmassMax : continue
deltaR_Jpsig = deltaR(jpsiCand.eta(),jpsiCand.phi(),gammaCand.eta(),gammaCand.phi())
deltaPhi_Jpsig = deltaPhi(jpsiCand.phi(),gammaCand.phi())
deltaEta_Jpsig = abs(jpsiCand.eta()-gammaCand.eta())
deltaR_ChiJpsi = deltaR(jpsiCand.eta(),jpsiCand.phi(),chicCand.eta(),chicCand.phi())
#if deltaR_Jpsig > 1.3 : continue
Qval = chicCand.mass()-jpsiCand.mass()
#if mass < 10.43 and mass > 10.42:
#print "\n--------------\nmass : %f\tgammapt : %f\tjpsiPt :%f \t run %d \t lumi %d \t orbit %d \t file %s" %(mass, gammaCand.pt(), jpsiCand.pt(),event._event.getRun().run(),event._event.luminosityBlock(), event._event.orbitNumber(),event._event.getTFile().GetName())
#print "\n--------------\nrun %d \t event %015d \t lumi %06d \t orbit %010d \t file %s" %(event._event.getRun().run(),event._event.id().event(),event._event.luminosityBlock(), event._event.orbitNumber(),event._event.getTFile().GetName())
#print "\n--------------\nrun %d \t event %015d \t mass : %f\tgammapt : %f\tjpsiPt :%f \t file %s" %(event._event.getRun().run(),event._event.id().event(),mass, gammaCand.pt(), jpsiCand.pt(),event._event.getTFile().GetName())
nSel+=1
Ymass.Fill(jpsiCand.mass())
hmass.Fill(Qval)
hgammapt.Fill(gammaCand.pt())
hgammapt_DeltaRJpsig.Fill(deltaR_Jpsig,gammaCand.pt())
hct.Fill(jpsiCandPAT.userFloat('ppdlPV'))
hmass_DeltaRJpsig.Fill(deltaR_Jpsig,Qval)
hmass_DeltaRChiJpsi.Fill(deltaR_ChiJpsi,Qval)
hmass_DeltaPhiJpsig.Fill(deltaPhi_Jpsig,Qval)
hmass_DeltaEtaJpsig.Fill(deltaEta_Jpsig,Qval)
hmass_gammapt.Fill(gammaCand.pt(),Qval)
hmass_Rconv.Fill(convCand.conversionVertex().position().rho(),Qval)
gammaP=sqrt(gammaCand.px()*gammaCand.px()+gammaCand.py()*gammaCand.py()+gammaCand.pz()*gammaCand.pz())
UpsP=sqrt(jpsiCand.px()*jpsiCand.px()+jpsiCand.py()*jpsiCand.py()+jpsiCand.pz()*jpsiCand.pz())
hGammaP.Fill(gammaP)
hUpsP.Fill(UpsP)
hCosAlphaP.Fill((gammaCand.px()*jpsiCand.px()+gammaCand.py()*jpsiCand.py()+gammaCand.pz()*jpsiCand.pz())/(gammaP*UpsP))
#fill RooDataSet
#if mass > 3.2 and mass < 4.0:
sigma=Ymass_a+Ymass_b*(abs(jpsiCand.y())-Ymass_c)
if abs(jpsiCand.y())<Ymass_c:
sigma=Ymass_a
deltaRChiJpsi.setVal(deltaR_ChiJpsi)
deltaRJpsig.setVal(deltaR_Jpsig)
invm1S.setVal( Qval + Y1Smass0 )
invm2S.setVal( Qval + Y2Smass0 )
invm3S.setVal( Qval + Y3Smass0 )
jpsipt.setVal(jpsiCand.pt())
jpsimass.setVal(jpsiCand.mass())
jpsieta.setVal(jpsiCand.y())
ctpv.setVal(jpsiCandPAT.userFloat('ppdlPV'))
ctpverr.setVal(jpsiCandPAT.userFloat('ppdlErrPV'))
ctbs.setVal(jpsiCandPAT.userFloat('ppdlBS'))
ctbserr.setVal(jpsiCandPAT.userFloat('ppdlErrBS'))
gammapt.setVal(gammaCand.pt())
Rconv.setVal(convCand.conversionVertex().position().rho())
ctpvsig.setVal(abs(jpsiCandPAT.userFloat('ppdlPV'))/jpsiCandPAT.userFloat('ppdlErrPV'))
ctbssig.setVal(abs(jpsiCandPAT.userFloat('ppdlBS'))/jpsiCandPAT.userFloat('ppdlErrBS'))
jpsiVprob.setVal(jpsiCandPAT.userFloat('vProb'))
Y1Smass_nSigma.setVal((jpsiCand.mass()-Y1Smass0)/sigma)
Y2Smass_nSigma.setVal((jpsiCand.mass()-Y2Smass0)/sigma)
Y3Smass_nSigma.setVal((jpsiCand.mass()-Y3Smass0)/sigma)
vertexChi2ProbGamma.setVal(TMath.Prob(convCand.conversionVertex().chi2(),int(convCand.conversionVertex().ndof())))
# vertexChi2ProbGamma.setVal(1)
jpsipx.setVal(jpsiCand.px())
jpsipy.setVal(jpsiCand.py())
jpsipz.setVal(jpsiCand.pz())
gammapx.setVal(gammaCand.px())
gammapy.setVal(gammaCand.py())
gammapz.setVal(gammaCand.pz())
Q.setVal(Qval)
weight.setVal(1)
rds.add(argSet)
# print TMath.Prob(convCand.conversionVertex().chi2(),int(convCand.conversionVertex().ndof())), "from ", int(convCand.conversionVertex().ndof()), " and " ,convCand.conversionVertex().ndof(), " and ", convCand.conversionVertex().chi2()
if ncands%1000==0:
print ncands
#break
print "countExceptions: ", countExceptions
print "Number of chib candidates: ", ncands
print "Number of selected chib candidates: ", nSel
outdataset= TFile("rooDS_"+str(options.cutName)+".root","recreate")
outdataset.cd()
rds.Write()
tree = rds.tree()
tree.SetName("tree")
tree.Write()
hlist = [hmass,Ymass,hgammapt,hct, hgammapt_DeltaRJpsig , hmass_DeltaRJpsig ,hmass_DeltaPhiJpsig ,hmass_DeltaEtaJpsig , hmass_gammapt, hmass_DeltaRChiJpsi, hmass_Rconv,hCosAlphaP,hGammaP,hUpsP]
for h in hlist : h.Write()
def setupWorkspace(ws,options):
cfg = options.config #for convenience
fit_sections = cfg.sections()
fit_sections.remove('Global') #don't need to iterate over the global configuration
if not isinstance(ws,RooWorkspace):
print "You didn't pass a RooWorkspace!"
exit(1)
cpling_type = cfg.get('Global','couplingType')
par1 = cfg.get('Global','par1Name')
par1bound = [-cfg.getfloat('Global','par1Max'),
cfg.getfloat('Global','par1Max')]
par2 = cfg.get('Global','par2Name')
par2bound = [-cfg.getfloat('Global','par2Max'),
cfg.getfloat('Global','par2Max')]
#create the parameters in the workspace
ws.factory('%s_%s[0,%f,%f]'%(par1,cpling_type,par1bound[0],par1bound[1]))
ws.factory('%s_%s[0,%f,%f]'%(par2,cpling_type,par2bound[0],par2bound[1]))
# since the lumi error is correlated among all channels we only need one penalty term for it
lumi_err = exp(options.config.getfloat('Global','lumi_err')) # exp because we use log normal
ws.factory('luminosityError[%f]'%lumi_err)
ws.factory('RooLognormal::lumiErr(err_gl[1,0.0001,50],1,luminosityError)')
channel_cat = RooCategory('channels','channels')
#first pass: process the backgrounds, signal and data into
# simultaneous counting pdfs over the bins
for section in fit_sections:
#create the basic observable, this is used behind the scenes
#in the background and signal models
channel_cat.defineType(section)
channel_cat.setLabel(section)
print 'Building pdf for configuration section:',section
for it,bkg in getBackgroundsInCfg(section,cfg).iteritems():
ws.factory('backgroundError_%s_%s[%f]'%(section,it,exp(bkg[1])))
ws.factory('selectionError_%s[%f]'%(section,exp(cfg.getfloat(section,'selection_err'))))
processFittingData(ws,cfg,section)
processSignalModel(ws,cfg,section)
processBackgroundModel(ws,cfg,section)
createPdfForChannel(ws,cfg,section)
ws.data('countingdata_%s'%section).addColumn(channel_cat)
getattr(ws,'import')(channel_cat)
top = RooSimultaneous('TopLevelPdf',
'TopLevelPdf',
ws.cat('channels'))
alldatavars = RooArgSet(ws.cat('channels'))
conditionals = RooArgSet()
#second pass: process counting pdfs into simultaneous pdf over channels
for section in fit_sections:
top.addPdf(ws.pdf('countingpdf_%s'%section),section)
alldatavars.add(ws.var('%s_%s'%(cfg.get(section,'obsVar'),section)))
conditionals.add(ws.var('%s_%s'%(cfg.get(section,'obsVar'),section)))
alldatavars.add(ws.var('n_observed_%s'%section))
getattr(ws,'import')(top)
ws.defineSet('condObs',conditionals)
allcountingdata = RooDataSet('allcountingdata',
'allcountingdata',
alldatavars)
getattr(ws,'import')(allcountingdata)
allcountingdata = ws.data('allcountingdata')
#third pass: make the final combined dataset
for section in fit_sections:
current = ws.data('countingdata_%s'%section)
print 'countingdata_%s has %d entries'%(section,current.numEntries())
for i in range(current.numEntries()):
alldatavars = current.get(i)
allcountingdata.add(alldatavars)
import sys
from ROOT import RooRandom
for it in range(nIters) :
if it % 100 == 0 :
print 'iteration %d' % it
sys.stdout.flush()
# generate data with (1 + x) / 2
RooRandom.randomGenerator().SetSeed( 100000 + it )
noWeightData.reset()
weightData.reset()
for evIt in range(nEvents) :
weight = RooRandom.uniform()
obs.setVal( 2. * weight - 1. )
if RooRandom.uniform() <= weight :
noWeightData.add(obsSet)
weightData.add( obsSet, weight )
# compute moments of functions
moms.compute( noWeightData, ResetFirst = True, Verbose = False )
momsW.compute( weightData, ResetFirst = True, Verbose = False )
# update covariance sums
momCoefs = moms.coefficients()
momCoefsW = momsW.coefficients()
for name1 in funcNames :
for name2 in funcNames :
covs[name1][name2] += ( momCoefs[name1][0] - funcMeans[name1] ) * ( momCoefs[name2][0] - funcMeans[name2] )
covsW[name1][name2] += ( momCoefsW[name1][0] - funcMeans[name1] ) * ( momCoefsW[name2][0] - funcMeans[name2] )
# divide covariance sums by number of entries to get covariances
# make dataset from tree
wt = RooRealVar('wt', '', 1.0, 0.0, 1.0)
dst = RooDataSet('dst', '', RooArgSet(time, wt), RooFit.WeightVar(wt))
for tp in ntuples:
print '{}: {}'.format(tp.GetName(), tp.GetEntries())
tp.SetBranchStatus('*', 0)
tp.SetBranchStatus('wt', 1)
tp.SetBranchStatus('Bid', 1)
tp.SetBranchStatus('hid', 1)
tp.SetBranchStatus('time', 1)
for i in range(tp.GetEntries()):
tp.GetEntry(i)
# choose decay equation (1 of 2 for Dspi)
if (tp.Bid == 531 and tp.hid == 211):
time.setVal(tp.time)
dst.add(RooArgSet(time), tp.wt)
dst.Print()
# model.fitTo(dst)
# plot
tfr = time.frame()
dst.plotOn(tfr)
model.plotOn(tfr)
tfr.Draw()
mode_title = get_title_from_mode(mode)
if nokfactor:
k_title = 'no'
else:
k_title = 'with'
tfr.SetTitle('{} ({} #it{{k}}-factor smearing)'.format(mode_title, k_title))
(900, (2.1511503582230613, 0.10749890705342333)),
(1000, (1.2694182781976522, 0.06340890314406443)),
(1100, (0.643681492794392, 0.03217545331472744)),
(1500, (0.08287990689532962, 0.004117232695182858)),
(1750, (0.026150402908862617, 0.0013037026701146663)),
(2000, (0.008063601507094236, 0.00040306052931164015)),
(2250, (0.003056637009041868, 0.00015253920943590022)),
(4000, (1.5147902166034461e-06, 7.553510014249738e-08)),
#(5000, (6.7752618437184105e-09, 3.3855147194005573e-10)),
#(6000, (1.673646004156878e-10, 8.333326606880855e-12)),
#(7000, (4.7172685387069244e-11, 2.356523443723669e-12))
]
for massval, (xsval, xserrval) in data:
mass.setVal(massval); xs.setVal(xsval); xs.setError(xserrval)
ds.add(RooArgSet(mass, xs))
#c0pr = RooRealVar("c0pr", "c0pr", 1, 1e-5, 1e5)
c0 = RooRealVar("c0", "c0", 3.13e-06, 1e-8, 1e5)
c1 = RooRealVar("c1", "c1", -1.59e+01, -1e+2, 1e2)
c2 = RooRealVar("c2", "c2", 1.08e+00, 1e-5, 1e1)
c3 = RooRealVar("c3", "c3", 7.66e+01, 0, 1e2)
c4 = RooRealVar("c4", "c4", -4.97e-03, -1e-5, 1)
#c5 = RooRealVar("c5", "c5", 0.01); c5.setConstant()
partial_pdf = RooGenericPdf("xspdf", "xspdf", "(mass^(c1+c2*log(mass))*exp(c3+c4*mass))",
RooArgList(mass, c1, c2, c3, c4))
pdf = R.RooExtendPdf("fullpdf", "fullpdf", partial_pdf, c0)
fr = mass.frame()
def buildDataAndCategories(ws,options,args):
#Get the input data
inputData = TChain(options.treeName,'The input data')
for arg in args:
print 'Adding data from: ',arg
inputData.Add(arg)
foldname = ''
phirange = [0,90]
if not options.folded:
foldname=''
phirange = [-180,180]
#variables necessary for j/psi mass,lifetime,polarization fit
jPsiMass = RooRealVar('JpsiMass','M [GeV]',2.7,3.5)
jPsiRap = RooRealVar('JpsiRap','#nu',-2.3,2.3)
jPsiPt = RooRealVar("JpsiPt","pT [GeV]",0,40);
jPsicTau = RooRealVar('Jpsict','l_{J/#psi} [mm]',-1,2.5)
jPsicTauError = RooRealVar('JpsictErr','Error on l_{J/#psi} [mm]',0,2)
jPsiVprob = RooRealVar('JpsiVprob','',.01,1)
jPsiHXcosth = None
jPsiHXphi = None
jPsicTau.setBins(10000,"cache")
if options.fitFrame is not None:
jPsiHXcosth = RooRealVar('costh_'+options.fitFrame+foldname,'cos(#theta)_{'+options.fitFrame+'}',-1,1)
jPsiHXphi = RooRealVar('phi_'+options.fitFrame+foldname,'#phi_{'+options.fitFrame+'}',phirange[0],phirange[1])
else:
jPsiHXcosth = RooRealVar('costh_CS'+foldname,'cos(#theta)_{CS}',-1,1)
jPsiHXphi = RooRealVar('phi_CS'+foldname,'#phi_{CS}',phirange[0],phirange[1])
#vars needed for on the fly calc of polarization variables
jPsimuPosPx = RooRealVar('muPosPx','+ Muon P_{x} [GeV]',0)
jPsimuPosPy = RooRealVar('muPosPy','+ Muon P_{y} [GeV]',0)
jPsimuPosPz = RooRealVar('muPosPz','+ Muon P_{z} [GeV]',0)
jPsimuNegPx = RooRealVar('muNegPx','- Muon P_{x} [GeV]',0)
jPsimuNegPy = RooRealVar('muNegPy','- Muon P_{y} [GeV]',0)
jPsimuNegPz = RooRealVar('muNegPz','- Muon P_{z} [GeV]',0)
#create RooArgSet for eventual dataset creation
dataVars = RooArgSet(jPsiMass,jPsiRap,jPsiPt,
jPsicTau,jPsicTauError,
jPsimuPosPx,jPsimuPosPy,jPsimuPosPz)
#add trigger requirement if specified
if options.triggerName:
trigger = RooRealVar(options.triggerName,'Passes Trigger',0.5,1.5)
dataVars.add(trigger)
dataVars.add(jPsiVprob)
dataVars.add(jPsimuNegPx)
dataVars.add(jPsimuNegPy)
dataVars.add(jPsimuNegPz)
dataVars.add(jPsiHXcosth)
dataVars.add(jPsiHXphi)
redVars = RooArgSet(jPsiMass,jPsiRap,jPsiPt,
jPsicTau,jPsicTauError)
redVars.add(jPsiHXcosth)
redVars.add(jPsiHXphi)
fitVars = redVars.Clone()
### HERE IS WHERE THE BIT FOR CALCULATING POLARIZATION VARS GOES
ctauStates = RooCategory('ctauRegion','Cut Region in lifetime')
ctauStates.defineType('prompt',0)
ctauStates.defineType('nonPrompt',1)
massStates = RooCategory('massRegion','Cut Region in mass')
massStates.defineType('signal',1)
massStates.defineType('separation',0)
massStates.defineType('leftMassSideBand',-2)
massStates.defineType('rightMassSideBand',-1)
states = RooCategory('mlRegion','Cut Region in mass')
states.defineType('nonPromptSignal',2)
states.defineType('promptSignal',1)
states.defineType('separation',0)
states.defineType('leftMassSideBand',-2)
states.defineType('rightMassSideBand',-1)
#define corresponding ranges in roorealvars
#mass is a little tricky since the sidebands change definitions in each rap bin
#define the names here and change as we do the fits
#jPsiMass.setRange('NormalizationRangeFormlfit_promptSignal',2.7,3.5)
#jPsiMass.setRange('NormalizationRangeFormlfit_nonPromptSignal',2.7,3.5)
#jPsiMass.setRange('NormalizationRangeFormlfit_leftMassSideBand',2.7,3.1)
#jPsiMass.setRange('NormalizationRangeFormlfit_rightMassSideBand',3.1,3.5)
#want the prompt fit only done in prompt region
#non-prompt only in non-prompt region
#background over entire cTau range
#jPsicTau.setRange('NormalizationRangeFormlfit_promptSignal',-1,.1)
#jPsicTau.setRange('NormalizationRangeFormlfit_nonPromptSignal',.1,2.5)
#jPsicTau.setRange('NormalizationRangeFormlfit_leftMassSideBand',-1,2.5)
#jPsicTau.setRange('NormalizationRangeFormlfit_rightMassSideBand',-1,2.5)
#redVars.add(ctauStates)
#redVars.add(massStates)
#redVars.add(states)
fitVars.add(ctauStates)
fitVars.add(massStates)
fitVars.add(states)
fullData = RooDataSet('fullData','The Full Data From the Input ROOT Trees',
dataVars,
ROOT.RooFit.Import(inputData))
for rap_bin in range(1,len(jpsi.pTRange)):
yMin = jpsi.rapForPTRange[rap_bin-1][0]
yMax = jpsi.rapForPTRange[rap_bin-1][-1]
for pt_bin in range(len(jpsi.pTRange[rap_bin])):
ptMin = jpsi.pTRange[rap_bin][pt_bin][0]
ptMax = jpsi.pTRange[rap_bin][pt_bin][-1]
sigMaxMass = jpsi.polMassJpsi[rap_bin] + jpsi.nSigMass*jpsi.sigmaMassJpsi[rap_bin]
sigMinMass = jpsi.polMassJpsi[rap_bin] - jpsi.nSigMass*jpsi.sigmaMassJpsi[rap_bin]
sbHighMass = jpsi.polMassJpsi[rap_bin] + jpsi.nSigBkgHigh*jpsi.sigmaMassJpsi[rap_bin]
sbLowMass = jpsi.polMassJpsi[rap_bin] - jpsi.nSigBkgLow*jpsi.sigmaMassJpsi[rap_bin]
ctauNonPrompt = .1
massFun = RooFormulaVar('massRegion','Function that returns the mass state.',
'('+jPsiMass.GetName()+' < '+str(sigMaxMass)+' && '+jPsiMass.GetName()+' > '+str(sigMinMass)+
') - ('+jPsiMass.GetName()+' > '+str(sbHighMass)+')'+
'-2*('+jPsiMass.GetName()+' < '+str(sbLowMass)+')',
RooArgList(jPsiMass,jPsicTau))
ctauFun = RooFormulaVar('ctauRegion','Function that returns the ctau state.',
'('+jPsicTau.GetName()+' > '+str(ctauNonPrompt)+')',
RooArgList(jPsiMass,jPsicTau))
mlFun = RooFormulaVar('mlRegion','Function that returns the mass and lifetime state.',
'('+jPsiMass.GetName()+' < '+str(sigMaxMass)+' && '+jPsiMass.GetName()+' > '+str(sigMinMass)+
') + ('+jPsiMass.GetName()+' < '+str(sigMaxMass)+' && '+jPsiMass.GetName()+' > '+
str(sigMinMass)+' && '+jPsicTau.GetName()+' > '+str(ctauNonPrompt)+
') - ('+jPsiMass.GetName()+' > '+str(sbHighMass)+')'+
'-2*('+jPsiMass.GetName()+' < '+str(sbLowMass)+')',
RooArgList(jPsiMass,jPsicTau))
cutStringPt = '('+jPsiPt.GetName()+' > '+str(ptMin)+' && '+jPsiPt.GetName()+' < '+str(ptMax)+')'
cutStringY = '( abs('+jPsiRap.GetName()+') > '+str(yMin)+' && abs('+jPsiRap.GetName()+') < '+str(yMax)+')'
#cutStringM1 = '('+jPsiMass.GetName()+' < '+str(sigMinMass)+' && '+jPsiMass.GetName()+' > '+str(sbLowMass)+')'
#cutStringM2 = '('+jPsiMass.GetName()+' < '+str(sbHighMass)+' && '+jPsiMass.GetName()+' > '+str(sigMaxMass)+')'
#cutStringMT = '!('+cutStringM1+' || '+cutStringM2+')'
cutString = cutStringPt+' && '+cutStringY #+' && '+cutStringMT
print cutString
#get the reduced dataset we'll do the fit on
binData = fullData.reduce(ROOT.RooFit.SelectVars(redVars),
ROOT.RooFit.Cut(cutString),
ROOT.RooFit.Name('data_rap'+str(rap_bin)+'_pt'+str(pt_bin+1)),
ROOT.RooFit.Title('Data For Fitting'))
binDataWithCategory = RooDataSet('data_rap'+str(rap_bin)+'_pt'+str(pt_bin+1),
'Data For Fitting',
fitVars)
#categorize
binData.addColumn(ctauStates)
binData.addColumn(massStates)
binData.addColumn(states)
for ev in range(binData.numEntries()):
args = binData.get(ev)
jPsiMass.setVal(args.find(jPsiMass.GetName()).getVal())
jPsiRap.setVal(args.find(jPsiRap.GetName()).getVal())
jPsiPt.setVal(args.find(jPsiPt.GetName()).getVal())
jPsicTau.setVal(args.find(jPsicTau.GetName()).getVal())
jPsicTauError.setVal(args.find(jPsicTauError.GetName()).getVal())
jPsiHXcosth.setVal(args.find(jPsiHXcosth.GetName()).getVal())
jPsiHXphi.setVal(args.find(jPsiHXphi.GetName()).getVal())
massStates.setIndex(int(massFun.getVal()))
ctauStates.setIndex(int(ctauFun.getVal()))
states.setIndex(int(mlFun.getVal()))
binDataWithCategory.add(fitVars)
getattr(ws,'import')(binDataWithCategory)
canv.SetTopMargin(0.05)
graph.Draw('ALP')
label.DrawLatex( timeValsArr[-1], graph.GetMinimum() + 0.15 * ( graph.GetMaximum() - graph.GetMinimum() ), 'LHCb unofficial' )
canvs.append(canv)
from ROOT import RooArgSet
print 'reading data file %s' % combDataFile.GetName()
combConstr = combDataFile.Get(constrName)
combConstrSet = RooArgSet(combConstr)
combPars = combConstr.getVariables()
from ROOT import RooRealVar, RooDataSet
xVar = RooRealVar( 'x', 'x', 0., 0., 1. )
xSet = RooArgSet(xVar)
dummyData = RooDataSet( 'dummyData', 'dummyData', xSet )
dummyData.add(xSet)
from ROOT import RooUniform
combSet = RooArgSet(xVar)
combSet.add(combPars)
combPdf = RooUniform( 'combPdf', 'combPdf', combSet )
print '-' * 120
print 'fitting combined acceptance'
setParameters( 'default', combPars, None, None )
fitResult = combPdf.fitTo( dummyData, Minimizer = 'Minuit2', Save = True, PrintLevel = -1, ExternalConstraints = combConstrSet
, Minos = combPars )
fitResult.Print('v')
fitResult.correlationMatrix().Print()
combConstrChiSq = -2. * combConstr.getLogVal()
print 'chi^2 combined constraint = %.2f^2' % ( cmp( combConstrChiSq, 0. ) * sqrt( abs(combConstrChiSq) ) )
