def gendata(filename, q2Bin, nSample):
time_start = time.time()
obs = getobs()
file = TFile.Open(filename)
if not file:
print('File not found: ', filename)
return
wspname = 'ws_b{}p0'.format(q2Bin)
wsp = file.Get(wspname)
if not wsp:
print('Workspace not found in file: ', filename)
return
ctK = wsp.var('ctK')
ctL = wsp.var('ctL')
phi = wsp.var('phi')
rand = wsp.var("rand")
if (not ctK) or (not ctL) or (not phi):
print('Variables not found in file: ', filename)
return
vars = RooArgList(ctK, ctL, phi)
datasetname = 'data_genDen_ev_b{}'.format(q2Bin)
fullData = wsp.data(datasetname)
if not fullData:
print('DataSet ', datasetname, ' not found in file: ', filename)
return
data = RooDataSet()
if nSample == 0:
data = fullData
elif nSample <= 10000:
data = fullData.reduce(
RooArgSet(vars), 'rand > {:1.6f} && rand < {:1.6f}'.format(
(nSample - 1) * dataStat[q2Bin] / genStat[q2Bin],
nSample * dataStat[q2Bin] / genStat[q2Bin]))
else:
data = fullData.reduce(
RooArgSet(vars), 'rand > {:.6f} && rand < {:.6f}'.format(
(nSample % 10000 - 1) * d16Stat[q2Bin] / genStat[q2Bin],
(nSample % 10000) * d16Stat[q2Bin] / genStat[q2Bin]))
print('Fit ', data.numEntries(), ' events')
###convert the final dataset to pd.dataframe
datalist = []
for i in range(0, data.numEntries()):
ctKvalue = data.get(i).getRealValue('ctK')
ctLvalue = data.get(i).getRealValue('ctL')
phivalue = data.get(i).getRealValue('phi')
datalist.append([ctKvalue, ctLvalue, phivalue])
#print ('lenth of datalist ', len(datalist))
finaldata_df = pd.DataFrame(datalist, columns=['costk', 'costl', 'phi'])
finaldata = zfit.Data.from_pandas(finaldata_df, obs=obs)
print('generate zfit data from RooDataSet successfully')
time_end = time.time()
time_c = time_end - time_start
print('time used in fit data import: ', time_c, 's')
return finaldata
doubleCanvas = TCanvas();
frameList = []
print '\n\n',tupleDict.values(),'\n\n'
doubleCanvas.Divide(3,3,0,0)
for i in range(len(tupleDict)):
#varName = tupleDict.keys()[i];
frameList += [tupleDataSet.get().find(tupleDict.values()[i]).frame()];
tupleDataSet.plotOn(frameList[i], RooFit.DrawOption('b'));
doubleCanvas.cd(i+1);
frameList[i].Draw();
'''
for i in range(len(tupleDict)):
tupleDataSet.get().find(tupleDict.values()[i]).Print()
sys.exit(0)
'''
doubleCanvas.Update();
raw_input('Press Enter to continue');
#doubleCanvas.Clear();
#print tupleDict.keys()[i];
#a.Print();
#print
doubleCanvas.Close();'''
tupleDataSet.Print()
sys.exit(0)
dirName = "tupleTestPlots"
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
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
class SData( object ) :
def __init__( self, **kwargs ) :
# get input arguments
def getKwArg( keyword, member, kwargs ) :
if keyword in kwargs : setattr( self, '_' + member, kwargs.pop(keyword) )
else : raise KeyError, 'P2VV - ERROR: SData.__init__(): key %s not found in input arguments' % keyword
getKwArg( 'Name', 'name', kwargs )
getKwArg( 'Data', 'inputData', kwargs )
getKwArg( 'Pdf', 'pdf', kwargs )
# initialize dictionary for weighted data sets per specie
self._data = dict()
# get yields and observables
self._yields = [ par for par in self._pdf.Parameters() if par.getAttribute('Yield') ]
self._observables = self._pdf.Observables()
# calculate sWeights
self._sData = None
from ROOT import RooStats, RooArgList, RooSimultaneous
if isinstance( self._pdf._var, RooSimultaneous ) and kwargs.pop( 'Simultaneous', True ) :
import gc
# split data set in categories of the simultaneous PDF
splitCat = self._pdf.indexCat()
splitData = self._inputData.split(splitCat)
from ROOT import RooFormulaVar
for splitCatState in splitCat:
# calculate sWeights per category
cat = splitCatState.GetName()
data = filter(lambda d: d.GetName() == cat, splitData)[0]
origYieldVals = [ ( par.GetName(), par.getVal(), par.getError() ) for par in self._yields if par.GetName().endswith(cat) ]
splot = RooStats.SPlot( self._name + '_sData_' + cat, self._name + '_sData_' + cat, data, self._pdf.getPdf(cat)
, RooArgList( par._var for par in self._yields if par.GetName().endswith(cat)))
sdata = splot.GetSDataSet()
print 'P2VV - INFO: SData.__init__(): yields category %s:' % cat
print ' original:',
for vals in origYieldVals : print '%s = %.2f +/- %.2f ' % vals,
print '\n new: ',
for par in self._yields :
if par.GetName().endswith(cat) : print '%s = %.2f +/- %.2f ' % ( par.GetName(), par.getVal(), par.getError() ),
print
# add column for splitting category/categories (was removed when data set was split)
# FIXME: How can we do this more generally? These are special cases and it might go wrong here...
from ROOT import RooSuperCategory
splitCat.setLabel(cat)
__dref = lambda o : o._target_() if hasattr(o,'_target_') else o
if isinstance( __dref(splitCat), RooSuperCategory ) :
for fundCat in splitCat.inputCatList() :
if not sdata.get().find( fundCat.GetName() ) : sdata.addColumn(fundCat)
elif splitCat.isFundamental() and not sdata.get().find( splitCat.GetName() ) :
sdata.addColumn(splitCat)
# add general sWeight and PDF value columns (it must be possible to simplify this...)
# FIXME: in some cases "par.GetName().strip( '_' + cat )" goes wrong:
# use "par.GetName()[ : par.GetName().find(cat) - 1 ]" instead
# (case: 'N_bkgMass_notExclBiased'.strip('_notExclBiased') --> 'N_bkgM' ?!!!!!!)
weightVars = [ ( RooFormulaVar( par.GetName()[ : par.GetName().find(cat) - 1 ] + '_sw', '', '@0'
, RooArgList( sdata.get().find( par.GetName() + '_sw' ) ) )
, RooFormulaVar( 'L_' + par.GetName()[ : par.GetName().find(cat) - 1 ], '', '@0'
, RooArgList( sdata.get().find( 'L_' + par.GetName() ) ) )
) for par in self._yields if par.GetName().endswith(cat)
]
for weight, pdfVal in weightVars :
sdata.addColumn(weight)
sdata.addColumn(pdfVal)
if not self._sData:
# get set of variables in data
sDataVars = sdata.get()
for par in self._yields :
if cat in par.GetName() :
sDataVars.remove( sDataVars.find( par.GetName() + '_sw' ) )
sDataVars.remove( sDataVars.find( 'L_' + par.GetName() ) )
from ROOT import RooDataSet
self._sData = RooDataSet( self._name + '_splotdata', self._name + '_splotdata', sDataVars )
self._sData.append(sdata)
splitData.remove(data)
del data
del splot
gc.collect()
else :
# calculate sWeights with full data set
if isinstance( self._pdf._var, RooSimultaneous ) :
print 'P2VV - WARNING: SData.__init__(): computing sWeights with a simultaneous PDF'
self._sPlot = RooStats.SPlot( self._name + '_splotdata', self._name + '_splotdata', self._inputData, self._pdf._var
, RooArgList( par._var for par in self._yields ) )
self._sData = self._sPlot.GetSDataSet()
# check keyword arguments
if kwargs : raise KeyError, 'P2VV - ERROR: SData.__init__(): got unknown keywords %s for %s' % ( kwargs, type(self) )
def usedObservables( self ) : return self._observables
def components( self ) : return [ y.GetName()[2:] for y in self._yields ]
def Pdf( self ) : return self._pdf
def Yield( self, Component ) :
yName = 'N_%s' % Component
for y in self._yields :
if y.GetName() == yName : return y.getVal()
raise KeyError, 'P2VV - ERROR: SData.__init__(): unknown component %s' % Component
def data( self, Component = None ) :
if not Component : return self._sData
if Component not in self._data :
# check if component exists
yName = 'N_%s' % Component
if not any( yName in y.GetName() for y in self._yields ) :
raise KeyError, 'P2VV - ERROR: SData.__init__(): unknown component: %s' % Component
wName = '%s_sw' % yName
if wName not in [ w.GetName() for w in self._sData.get() ] :
raise KeyError, 'no weight in dataset for component %s' % Component
# create weighted data set
dName = '%s_weighted_%s' % ( self._sData.GetName(), Component )
from ROOT import RooDataSet
from P2VV.ROOTDecorators import ROOTversion
if ROOTversion[0] <= 5 and ROOTversion[1] <= 34 and ROOTversion[2] < 2 :
self._data[Component] = RooDataSet( dName, dName, self._sData.get(), Import = self._sData, WeightVar = ( wName ) )
else :
self._data[Component] = RooDataSet( dName, dName, self._sData.get(), Import = self._sData, WeightVar = ( wName, True ) )
return self._data[Component]
#Iteartion over the workspce files
for i, f_wsp in enumerate(wlist):
print "Processing workspace "+str(i)+"/"+str(len(wlist))
ws_file = TFile(f_wsp, "read")
wsp = ws_file.Get("wspace")
ws_file.Close()
dataset_RS = wsp.data("dataset_RS")
dataset_COMB_OS = wsp.data("dataset_COMB_OS")
dataset_COMB_OS_dtb = RooDataSet("dataset_COMB_OS_dtb", "Combinatorial shape",dataset_COMB_OS, varset_comb,combination_cut)
Runs = {}
#Getting list of runs in the workspace
start = datetime.now()
for i in range(dataset_COMB_OS_dtb.numEntries()):
i_runNumber = dataset_COMB_OS_dtb.get(i).getRealValue("runNumber")
if i_runNumber not in Runs:
Runs[i_runNumber]=[]
run_indexing_time = datetime.now()-start
start = datetime.now()
#Iterating over runs
for i, i_run in enumerate(Runs):
#For each run we create a lists of B and D* candidates and match them later using the Fill_shape() function
signals = {}
combs = []
i_dataset_COMB_OS_dtb = RooDataSet("i_dataset_COMB_OS_dtb", "Combinatorial shape",dataset_COMB_OS_dtb, varset_comb,"runNumber=="+str(i_run))
i_dataset_RS_dtb = RooDataSet("i_dataset_RS_dtb", "Signal shape",dataset_RS, varset, preselection_cut+" && ( runNumber=="+str(i_run)+" )")
for s_i in range(i_dataset_RS_dtb.numEntries()):
signals[str(i_dataset_RS_dtb.get(s_i).getRealValue("LOG_D0_IPCHI2_OWNPV"))+"__"+str(i_dataset_RS_dtb.get(s_i).getRealValue("D0_M"))] = [i_dataset_RS_dtb.get(s_i).getRealValue("LOG_D0_IPCHI2_OWNPV"),i_dataset_RS_dtb.get(s_i).getRealValue("D0_M"), i_dataset_RS_dtb.get(s_i).getRealValue("Dst_DTF_D0_CTAU"), i_dataset_RS_dtb.get(s_i).getRealValue("DTF_D0sPi_M")]
RooArgSet(*varList),
RooFit.Import(tree1))
tupleDataSet.Print();
tmt = RooRealVar('tMinusT','tMinusT',0,-maxV,maxV);
#tDataSet = RooDataSet('tDataSet','tDataSet',RooArgSet(tmt,weightvar), RooFit.WeightVar(weightvar));
from ROOT import TH1D
tHist = TH1D('tDataSet','tDataSet',100,-0.3,0.3)#RooArgSet(tmt,weightvar), RooFit.WeightVar(weightvar));
for i in range(tupleDataSet.numEntries()):
tmt.setVal(tupleDataSet.get(i).find('Bs_ct').getValV()-tupleDataSet.get(i).find('Bs_TRUETAU').getValV()*1000.0);
#tDataSet.add(RooArgSet(tmt,weightvar),tupleDataSet.get(i).find(weightVarName).getValV());
tHist.Fill(tmt.getValV(),tupleDataSet.get(i).find(weightVarName).getValV());
#print tupleDataSet.get(i).find(weightVarName).getValV()," ",tDataSet.weight()
#tupleDataSet.merge(tDataSet);
tHist.Fit('gaus');
from ROOT import TCanvas
aCanvas = TCanvas();
'''
tDataSet.Print();
tDataSet = tDataSet.reduce("tMinusT<1&&tMinusT>-1");
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
for name1 in funcNames :
for name2 in funcNames :
covs[name1][name2] /= float(nIters)
covsW[name1][name2] /= float(nIters)
# print data sets from last iteration
noWeightData.Print()
weightData.Print()
for evIt in range(10) :
print 'not weighted: %+.2f (%.2f) weighted: %+.2f (%.2f)'\
% ( noWeightData.get(evIt).getRealValue('x'), noWeightData.weight(), weightData.get(evIt).getRealValue('x'), weightData.weight() )
print
# print moments from last iteration and computed covariances
maxLenName = max( [ len(name) for name in funcNames ] )
from math import sqrt
def printCovs(covMat) :
print ' errors:'
for name in funcNames :
print ( ' {0:>%ds}: {1:>7.5f}' % maxLenName ).format( name, sqrt( covMat[name][name] ) )
print
print ' correlations:'
print ' ' * ( maxLenName + 5 ) + ' '.join( '{0:>6s}'.format(name) for name in funcNames )
for name1 in funcNames :
corrs = [ ( covMat[name1][name2] / sqrt( covMat[name1][name1] * covMat[name2][name2] ) )\
def reweigh(target, target_cat, source, source_cat, binning = None):
cats = {}
for cat, data, name in [(target_cat, target, 'target_cat'), (source_cat, source, 'source_cat')]:
if hasattr(cat, '_target_'):
cat = cat._target_()
elif type(cat) == str:
cat_name = cat
cat = data.get().find(cat_name)
if not cat:
data.Print()
raise RuntimeError('observable or category %s is not present in data' % cat_name)
if not any([isinstance(cat, t) for t in [RooCategory, RooRealVar]]):
raise RuntimeError('category must be either a RooRealVar or a RooCategory')
if isinstance(cat, RooRealVar):
assert(binning)
if type(binning) == array:
binning = RooBinning(len(binning) - 1, binning)
binning.SetName('reweigh')
cat.setBinning(binning, 'reweigh')
cat_name = cat.GetName() + '_cat_' + data.GetName()
test_cat = data.get().find(cat_name)
if not test_cat:
cat = BinningCategory(Name = cat_name, Observable = cat,
Binning = binning, Data = data, Fundamental = True)
else:
cat = test_cat
cats[name] = cat
target_cat = cats['target_cat']
source_cat = cats['source_cat']
print target_cat
print source_cat
target_bins = dict([(ct.getVal(), ct.GetName()) for ct in target_cat])
source_bins = dict([(ct.getVal(), ct.GetName()) for ct in source_cat])
print target_bins
print source_bins
target_table = target.table(target_cat)
source_table = source.table(source_cat)
target_table.Print('v')
source_table.Print('v')
from collections import defaultdict
reweigh_weights = {}
for i, l in sorted(target_bins.iteritems()):
sf = source_table.getFrac(source_bins[i])
if sf == 0:
w = 0
else:
try:
w = sf / target_table.getFrac(l)
except ZeroDivisionError:
print 'Warning bin %s in wpv_data is 0, setting weight to 0' % l
w = 0.
reweigh_weights[i] = w
# RooFit infinity
from ROOT import RooNumber
RooInf = RooNumber.infinity()
from RooFitWrappers import RealVar
weight_var = RealVar('reweigh_var', MinMax = (RooInf, RooInf))
from ROOT import RooDataSet
data_name = target.GetName() + 'weight_data'
from ROOT import RooArgSet
weight_data = RooDataSet(data_name, data_name, RooArgSet(weight_var))
weight_var = weight_data.get().find(weight_var.GetName())
for i in range(target.numEntries()):
r = target.get(i)
n = target_cat.getIndex()
w = reweigh_weights[n]
weight_var.setVal(target.weight() * w)
weight_data.fill()
target.merge(weight_data)
target = RooDataSet(target.GetName(), target.GetTitle(), target,
target.get(), '', weight_var.GetName())
return target, reweigh_weights
graphHolder.Draw("ap")
graphHolder.GetXaxis().SetLimits(0.0, 0.5)
graphHolder.SetMinimum(0.0)
graphHolder.SetMaximum(0.5)
#graphHolder.Draw("ap")
graphHolder.GetYaxis().SetTitleSize(0.05)
graphHolder.GetXaxis().SetTitleSize(0.05)
leg = TLegend(0.1, 0.7, 0.4, 0.9)
#,"a f*****g header","tlNDC");
ROOT.SetOwnership(leg, False)
#leg.AddEntry(TObject(),"crap");
p0E = pDataSet.meanVar(pDataSet.get().find('p0Var')).getError()
p0V = pDataSet.meanVar(pDataSet.get().find('p0Var')).getValV()
p1E = pDataSet.meanVar(pDataSet.get().find('p1Var')).getError()
p1V = pDataSet.meanVar(pDataSet.get().find('p1Var')).getValV()
etaE = pDataSet.meanVar(pDataSet.get().find('etaAvgVar')).getError()
etaV = pDataSet.meanVar(pDataSet.get().find('etaAvgVar')).getValV()
leg.AddEntry(mistagVsEtaGraph, "data points", "lep")
leg.AddEntry(linFuncList[-1], "linear fit", "l")
leg.AddEntry(None,
"#bar{p_{0}} = %.4f #pm %.4f" % (sumP0 / numP, sumP0E / numP), "")
leg.AddEntry(None,
"#bar{p_{1}} = %.4f #pm %.4f" % (sumP1 / numP, sumP1E / numP), "")
leg.AddEntry(
None, "#LT#eta#GT = %.4f #pm %.4f" % (sumAvgEta / numP, sumAvgEtaE / numP),
"")
# create weighted data set
from ROOT import RooProduct, RooArgSet, RooArgList
obsSet = RooArgSet( dataSetAsym.get() )
prodList = RooArgList( obsSet.find('sigWeight') )
if applyPlotWeights : prodList.add( obsSet.find('dilution') )
weightVar = RooProduct( 'weightVar', 'weightVar', prodList )
weightVar = dataSetAsym.addColumn(weightVar)
obsSet.add(weightVar)
from ROOT import RooDataSet
dataSetAsymW = RooDataSet( 'asymDataW', 'asymDataW', obsSet, Import = dataSetAsym, WeightVar = ( 'weightVar', True ) )
del dataSetAsym
ws.put(dataSetAsymW)
del dataSetAsymW
dataSetAsymW = ws['asymDataW']
obsSet = RooArgSet( dataSetAsymW.get() )
dataSetAsymW.Print()
# build PDF
from P2VV.Parameterizations.FullPDFs import Bs2Jpsiphi_RunIAnalysis as PdfConfig
pdfConfig = PdfConfig( RunPeriods = '3fb' )
timeEffFile2011 = dataPath + 'timeAcceptanceFit_2011.root'
timeEffFile2012 = dataPath + 'timeAcceptanceFit_2012.root'
pdfConfig['timeEffHistFiles'].getSettings( [ ( 'runPeriod', 'p2011' ) ] )['file'] = timeEffFile2011
pdfConfig['timeEffHistFiles'].getSettings( [ ( 'runPeriod', 'p2012' ) ] )['file'] = timeEffFile2012
pdfConfig['anglesEffType'] = 'basisSig6'
pdfConfig['angEffMomsFiles'] = dataPath + 'angEffNominalRew_5thOrder.par'
pdfConfig['signalData'] = dataSetAsymW
pdfConfig['readFromWS'] = True
varRenamedList += [RooFit.RenameVariable(varName, tupleDict[varName])]
#RooFit.RenameVariable(varName, tupleDict[varName]);
#varList[i].SetName(tupleDict.keys()[i]);
'''
for i in range(len(tupleDict)):
varList[i].Print()
'''
#def test(a,b,c,d):
# print "Yes"
#test(*(tupleDict.keys()))
tupleDataSet = RooDataSet("treeData", "treeData", tree1, RooArgSet(*varList))
tupleDataSet.get().find(varName).Print()
for i in range(len(tupleDict)):
varName = tupleDict.keys()[i]
a = tupleDataSet.get().find(varName)
a.SetName(tupleDict[varName])
a.SetTitle(tupleDict[varName])
tupleDataSet.get().find("SSKaon").SetMaximum(2)
tupleDataSet.get().find("SSKaon").SetMinimum(-2)
aFrame = tupleDataSet.get().find("SSKaon").frame()
tupleDataSet.get().find("SSKaon").Print()
tupleDataSet.plotOn(aFrame)
aFrame.Draw()
#keyList.At(0).ReadObj().Print();
#keyList.At(1).ReadObj().Print();
#tupleDataSet = rootInFile.Get('treeData');
in_file = TFile('../BsStuff.root')
tupleDataSet = in_file.Get('tupleDataSet')
#aCanvas = TCanvas();
#qtFrame = tupleDataSet.get().find('Bs_TAGDECISION_OS').frame();
#tupleDataSet.add
#tupleDataSet.Print();
'''
for i in tupleDataSet.numEntries():
tupleDataSet.get(i).find('Bs_TAGDECISION_OS').getVal
'''
tupleDataSet.get().find('Bs_TAGDECISION_OS').Print()
#tupleDataSet.plotOn(qtFrame, RooFit.DrawOption('b'));
#qtFrame.Draw();
#raw_input();
in_file.Close()
del in_file
#sys.exit(0);
tupleDict = importTupleDict(tupleDictFilename)
print tupleDict.keys()
#sys.exit(0);
varList = []
varRenamedList = []
def correctWeights( dataSet, splitCatNames, **kwargs ) :
"""correct weights in dataSet for background dilution
"""
if splitCatNames :
# get category that splits data sample
if type(splitCatNames) == str : splitCatNames = [ splitCatNames ]
if len(splitCatNames) == 1 :
splitCat = dataSet.get().find( splitCatNames[0] )
assert splitCat, 'P2VV - ERROR: correctWeights: unknown split category: "%s"' % splitCatNames[0]
else :
from ROOT import RooArgSet
catSet = RooArgSet()
for catName in splitCatNames :
cat = dataSet.get().find(catName)
assert cat, 'P2VV - ERROR: correctWeights: unknown split category: "%s"' % catName
catSet.add(cat)
from ROOT import RooSuperCategory
splitCat = RooSuperCategory( 'splitCat', 'splitCat', catSet)
indexDict = { }
for iter, catType in enumerate( splitCat ) : indexDict[ iter ] = ( catType.GetName(), catType.getVal() )
# get variable that contains original event weights
origWeightVar = None
origWeightName = kwargs.pop( 'WeightName', '' )
if origWeightName :
origWeightVar = dataSet.get().find(origWeightName)
from ROOT import RooAbsReal
assert origWeightVar and isinstance( origWeightVar, RooAbsReal )\
, 'P2VV - ERROR: correctWeights: unknown weight variable: "%s"' % origWeightName
corrFactors = kwargs.pop( 'CorrectionFactors', [ ] )
if not corrFactors :
if splitCatNames :
# initialize sums for the weights and the weights squared per category
sumWeights = [ 0. ] * ( splitCat.numTypes() + 1 )
sumSqWeights = [ 0. ] * ( splitCat.numTypes() + 1 )
posDict = { }
for iter, catType in enumerate( splitCat ) : posDict[ catType.getVal() ] = iter
else :
# initialize sums for the weights and the weights squared
sumWeights = [ 0. ]
sumSqWeights = [ 0. ]
# loop over events and get sums of weights and weights squared
for varSet in dataSet :
weight = origWeightVar.getVal() if origWeightVar else dataSet.weight()
sumWeights[0] += weight
sumSqWeights[0] += weight**2
if splitCatNames :
sumWeights[ posDict[ splitCat.getIndex() ] + 1 ] += weight
sumSqWeights[ posDict[ splitCat.getIndex() ] + 1 ] += weight**2
# get correction factors
corrFactors = ( ( sumWeights[0] / sumSqWeights[0], sumWeights[0] )
, [ ( sum / sumSq, sum ) for sum, sumSq in zip( sumWeights[ 1 : ], sumSqWeights[ 1 : ] ) ]
)
# add corrected weights to data set
from P2VV.Load import P2VVLibrary
from ROOT import RooCorrectedWeight
if splitCatNames :
from ROOT import std
corrFactorsVec = std.vector('Double_t')()
print 'P2VV - INFO: correctWeights: multiplying sWeights (-ln(L)) to correct for background dilution with factors (overall factor %.4f for %.1f events):'\
% corrFactors[0]
maxLenStateName = max( len( ind[0] ) for ind in indexDict.values() )
for iter, fac in enumerate( corrFactors[1] ) :
corrFactorsVec.push_back( fac[0] )
print ( ' {0:%ds} : {1:.4f} (events: {2:.1f})' % maxLenStateName ).format( indexDict[iter][0], fac[0], fac[1] )
if origWeightVar :
weightVar = RooCorrectedWeight( 'weightVar', 'weight variable', origWeightVar, splitCat, corrFactorsVec )
else :
weightVar = RooCorrectedWeight( 'weightVar', 'weight variable', dataSet, splitCat, corrFactorsVec )
else :
print 'P2VV - INFO: correctWeights: multiplying sWeights (-ln(L)) to correct for background dilution with a factor %.4f for %.1f events'\
% corrFactors[0]
if origWeightVar :
weightVar = RooCorrectedWeight( 'weightVar', 'weight variable', origWeightVar, corrFactors[0][0] )
else :
weightVar = RooCorrectedWeight( 'weightVar', 'weight variable', dataSet, corrFactors[0][0] )
from ROOT import RooDataSet
dataSet.addColumn(weightVar)
dataSet = RooDataSet( dataSet.GetName() + '_corrErrs', dataSet.GetTitle() + ' corrected errors', dataSet.get()
, Import = dataSet, WeightVar = ( 'weightVar', True ) )
importIntoWS = kwargs.pop( 'ImportIntoWS', True )
if importIntoWS :
# import data set into current workspace
from P2VV.RooFitWrappers import RooObject
return RooObject().ws().put( dataSet, **kwargs )
else :
return dataSet
def getData(workspace,
mean1 = 1., sigma1 = 0.01,
mean2 = 1., sigma2 = 0.01, nevents = 5000):
## Make a local workspace to use as a factory.
w = RooWorkspace('w', 'w')
## Define the PDF's for m, f1 and f2 in m*sqrt(f1*f2)
mPdf = w.factory("BreitWigner::mPdf(m[50,130], MZ[91.12], GammaZ[2.5])")
f1Pdf = w.factory("Gaussian::f1Pdf(f1[0.5, 2], mean1[%f], sigma1[%f])" %
(mean1, sigma1))
f2Pdf = w.factory("Gaussian::f2Pdf(f2[0.5, 2], mean2[%f], sigma2[%f])" %
(mean2, sigma2))
## Import the PDF's in the given workspace.
workspace.Import(mPdf, RenameAllVariables("True"))
workspace.Import(f1Pdf, RenameAllVariables("True"))
workspace.Import(f2Pdf, RenameAllVariables("True"))
## Generate samples of M, F1 and F2 with a 10% margin for boundaries.
moreEvents = int(2*nevents)
mData = mPdf.generate(RooArgSet(w.var("m")), moreEvents, NumCPU(3))
f1Data = f1Pdf.generate(RooArgSet(w.var("f1")), moreEvents, NumCPU(3))
f2Data = f2Pdf.generate(RooArgSet(w.var("f2")), moreEvents, NumCPU(3))
## Create the new data with toy reco mass
data = RooDataSet('data', 'toy reco Z->ll mass data',
RooArgSet(w.factory('mass[40,140]')))
entry = data.get()
## Loop over the generated values and fill the new reco mass data.
for i in range(moreEvents):
## Do we have enough entries already?
if data.sumEntries() >= nevents:
break
## Get the values of the random variables m, f1, f2.
m = mData.get(i).first().getVal()
f1 = f1Data.get(i).first().getVal()
f2 = f2Data.get(i).first().getVal()
## Here comes the formula!!
mass = m * sqrt(f1*f2)
## Is the reco mass within its range?
if 60. < mass and mass < 120.:
## Add the reco mass to the data
entry.first().setVal(mass)
data.addFast(entry)
## End of loop over the generated values
workspace.Import(data)
return data
