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 prepare_truth_models(ws,cat,mass,channel,turnon,truth):
if channel in study_inputs:
bkg_data = RooDataSet("bkgdata_%s"%(channel),
"M_{ll#gamma} with Errors",
ws.set("observables_weight"),
"weight")
for k,file in enumerate(study_inputs[channel]):
f_in = TFile.Open(file,"READ")
gDirectory.cd(pwd)
n_events = f_in.Get("eventCount").GetBinContent(1)
tree = f_in.Get("selected_zg").CloneTree()
tree.SetName("tree_%s_%i"%(channel,k))
f_in.Close()
d_in = RooDataSet("temp",
"M_{ll#gamma} with Errors",
tree,
ws.set("observables"))
norm = RooConstVar("norm","norm",n_events)
weight = RooFormulaVar("weight",
"weight",
"1.3*@0*@1/@2", #1.3 gives 19.6/fb
RooArgList(ws.var("puWeight"),
ws.var("procWeight"),
norm)
)
d_in.addColumn(weight)
d_in_weight = RooDataSet("temp_weight",
"M_{ll#gamma} with Errors",
d_in,
ws.set("observables_weight"),
'','weight')
bkg_data.append(d_in_weight)
# split off data for each category, create the
# toy dataset truth models
data = bkg_data.reduce("Mz + Mzg > 185 && r94cat == %i"%cat)
getattr(ws,'import')(data,
RooFit.Rename('bkgdata_%s_%i'%(channel,
cat)))
nevts = data.sumEntries('Mzg > %f && Mzg < %f'%(mass-1.5,mass+1.5))
#for sigm turn on we want erf truth
if turnon == 'sigm' and truth == 'exp':
#make RooDecay 'truth' model with erf turn on
ws.factory(
'RooGaussModel::MzgResoShape_exp_erf_%s_cat%i(Mzg,'\
'bias_exp_erf_%s_cat%i[120,90,150],sigma_exp_erf_%s_cat%i[1,0.01,10])'%(
channel,cat,
channel,cat,
channel,cat)
)
ws.factory(
'RooDecay::MzgTruthModelBase_exp_erf_%s_cat%i(Mzg,'\
'tau_erf_%s_cat%i[25,0,50],MzgResoShape_exp_erf_%s_cat%i,'
'RooDecay::SingleSided)'%(channel,cat,
channel,cat,
channel,cat)
)
ws.factory(
'RooExtendPdf::MzgTruthModel_exp_erf_%s_cat%i('\
'MzgTruthModelBase_exp_erf_%s_cat%i,'\
'norm_truth_exp_%s_cat%i[%f,%f,%f],"ROI")'%(channel,cat,
channel,cat,
channel,cat,
nevts,
0.25*nevts,1.75*nevts)
)
ws.pdf('MzgTruthModel_exp_erf_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.Minimizer('Minuit2','scan'),
RooFit.SumW2Error(False)
)
ws.pdf('MzgTruthModel_exp_erf_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.Minimizer('Minuit','simplex'),
RooFit.SumW2Error(False)
)
ws.pdf('MzgTruthModel_exp_erf_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.SumW2Error(True)
)
if turnon == 'sigm' and truth == 'pow':
#make power-law truth model with erf turn on
ws.factory('EXPR::MzgTruthModelShape_pow_erf_%s_cat%i('\
'"1e-20 + (@0 > @1)*((@0)^(-@2))",'\
'{Mzg,step_pow_erf_%s_cat%i[105,100,130],'\
'pow_%s_cat%i[2,0,10]})'\
%(channel,cat,
channel,cat,
channel,cat))
ws.factory(
'RooGaussModel::MzgResoShape_pow_erf_%s_cat%i(Mzg,'\
'bias_pow_erf_%s_cat%i[0],sigma_pow_erf_%s_cat%i[1,0.01,10])'%(
channel,cat,
channel,cat,
channel,cat)
)
ws.factory('FCONV::MzgTruthModelBase_pow_erf_%s_cat%i(Mzg,'\
'MzgTruthModelShape_pow_erf_%s_cat%i,'\
'MzgResoShape_pow_erf_%s_cat%i)'%(channel,cat,
channel,cat,
channel,cat))
ws.factory(
'RooExtendPdf::MzgTruthModel_pow_erf_%s_cat%i('\
'MzgTruthModelBase_pow_erf_%s_cat%i,'\
'norm_truth_pow_erf_%s_cat%i[%f,%f,%f],"ROI")'%(channel,cat,
channel,cat,
channel,cat,
nevts,
0.25*nevts,1.75*nevts)
)
ws.pdf('MzgTruthModel_pow_erf_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.Minimizer('Minuit2','scan'),
RooFit.SumW2Error(False)
)
ws.pdf('MzgTruthModel_pow_erf_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.Minimizer('Minuit','simplex'),
RooFit.SumW2Error(False)
)
ws.pdf('MzgTruthModel_pow_erf_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.SumW2Error(True)
)
#for erf fitting turn on we want sigmoid truth
if turnon == 'erf' and truth == 'exp':
#build exponential convoluted with sigmoid turn-on
ws.factory('RooStepExponential::MzgTruthModelShape_exp_sigm_%s_cat%i'\
'(Mzg,tau_sigm_%s_cat%i[-0.05,-10,0],'\
'step_exp_sigm_%s_cat%i[110,100,130])'%(channel,cat,
channel,cat,
channel,cat))
ws.factory(
'RooLogistics::MzgResoShape_exp_sigm_%s_cat%i(%s)'%(
channel,cat,
','.join(['Mzg',
'bias_exp_sigm_%s_cat%i[0]'%(channel,cat),
'sigma_exp_sigm_%s_cat%i[5,0.01,20]'%(channel,cat)])
)
)
ws.factory('FCONV::MzgTruthModelBase_exp_sigm_%s_cat%i(Mzg,'\
'MzgTruthModelShape_exp_sigm_%s_cat%i,'\
'MzgResoShape_exp_sigm_%s_cat%i)'%(channel,cat,
channel,cat,
channel,cat))
ws.factory(
'RooExtendPdf::MzgTruthModel_exp_sigm_%s_cat%i('\
'MzgTruthModelBase_exp_sigm_%s_cat%i,'\
'norm_truth_exp_sigm_%s_cat%i[%f,%f,%f],"ROI")'%(channel,cat,
channel,cat,
channel,cat,
nevts,
0.25*nevts,1.75*nevts)
)
ws.pdf('MzgTruthModel_exp_sigm_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.Minimizer('Minuit2','scan'),
RooFit.SumW2Error(False)
)
ws.pdf('MzgTruthModel_exp_sigm_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.Minimizer('Minuit','simplex'),
RooFit.SumW2Error(False)
)
ws.pdf('MzgTruthModel_exp_sigm_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.SumW2Error(True)
)
if turnon == 'erf' and truth == 'pow':
#build power-law convoluted with sigmoid turn-on
ws.factory('EXPR::MzgTruthModelShape_pow_sigm_%s_cat%i('\
'"1e-20 + (@0 > @1)*((@0)^(-@2))",'\
'{Mzg,step_pow_sigm_%s_cat%i[105,100,130],'\
'pow_sigm_%s_cat%i[2,0,10]})'\
%(channel,cat,
channel,cat,
channel,cat))
ws.factory(
'RooLogistics::MzgResoShape_pow_sigm_%s_cat%i(%s)'%(
channel,cat,
','.join(['Mzg',
'bias_pow_sigm_%s_cat%i[0]'%(channel,cat),
'sigma_pow_sigm_%s_cat%i[5,0.01,20]'%(channel,cat)])
)
)
ws.factory('FCONV::MzgTruthModelBase_pow_sigm_%s_cat%i(Mzg,'\
'MzgTruthModelShape_pow_sigm_%s_cat%i,'\
'MzgResoShape_pow_sigm_%s_cat%i)'%(channel,cat,
channel,cat,
channel,cat))
ws.factory(
'RooExtendPdf::MzgTruthModel_pow_sigm_%s_cat%i('\
'MzgTruthModelBase_pow_sigm_%s_cat%i,'\
'norm_truth_pow_sigm_%s_cat%i[%f,%f,%f],"ROI")'%(channel,cat,
channel,cat,
channel,cat,
nevts,
0.25*nevts,1.75*nevts)
)
ws.pdf('MzgTruthModel_pow_sigm_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.Minimizer('Minuit2','scan'),
RooFit.SumW2Error(False)
)
ws.pdf('MzgTruthModel_pow_sigm_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.Minimizer('Minuit','simplex'),
RooFit.SumW2Error(False)
)
ws.pdf('MzgTruthModel_pow_sigm_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.SumW2Error(True)
)
dsetlist += [dataset]
decaycat = RooCategory('decaycat', 'Decay mode category')
decaycat.defineType('DsPi')
decaycat.defineType('DsK')
varlist += [decaycat]
for idx, mode in enumerate(['DsPi', 'DsK']):
decaycat.setLabel(mode)
dsetlist[idx].addColumn(decaycat)
dataset = RooDataSet('dataset', 'Combined dataset (DsK + DsPi)',
RooArgSet(time, decaycat),
RooFit.Import(dsetlist[0]))
dataset.append(dsetlist[1])
for dset in dsetlist:
dset.Print()
dataset.Print()
## Basic B decay pdf with time resolution
# Resolution model
mean = RooRealVar('mean', 'Mean', 0.)
# scale = RooRealVar('scale', 'Per-event time error scale factor', 1.19)
resmodel = RooGaussModel('resmodel', 'Time resolution model', time,
mean, RooRealConstant.value(0.044),
RooRealConstant.value(1.0),
RooRealConstant.value(1.0))
# RooRealConstant::value(0), scale, dt)
# RooRealConstant::value(0), scale,
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]
def Subtract_Distribution(dataset, DTF_D0sPi_M, LOG_D0_IPCHI2_OWNPV, bin = "undefined", silent = False):
dataset_sig = RooDataSet("dataset_sig", "Signal region",dataset, RooArgSet(DTF_D0sPi_M, LOG_D0_IPCHI2_OWNPV) ," ( DTF_D0sPi_M < 2015 ) ")
dataset_bckg = RooDataSet("dataset_bckg", "Background region",dataset, RooArgSet(DTF_D0sPi_M, LOG_D0_IPCHI2_OWNPV) ," ( DTF_D0sPi_M > 2015 ) && ( DTF_D0sPi_M < 2020 ) ")
#Introduce fit variables
## Johnson parameters
J_mu = RooRealVar("J_mu","J_mu", 2011, 2000, 2020)
J_sigma = RooRealVar("J_sigma","J_sigma", 0.045, 0.01, 0.1)
J_delta = RooRealVar("J_delta","J_delta", 0., -1, 1)
J_gamma = RooRealVar("J_gamma","J_gamma", 0., -1, 1)
## Gaussian parameters
G1_mu = RooRealVar("G1_mu","G1_mu", 2010, 2008, 2012)
G1_sigma = RooRealVar("G1_sigma","G1_sigma", 1.0, 0.01, 5)
G2_mu = RooRealVar("G2_mu","G2_mu", 2010, 2008, 2012)
G2_sigma = RooRealVar("G2_sigma","G2_sigma", 0.4, 0.01, 5)
G3_mu = RooRealVar("G3_mu","G3_mu", 2010, 2008, 2012)
G3_sigma = RooRealVar("G3_sigma","G3_sigma", 0.2, 0.01, 5)
## Signal yields ratios
fJ = RooRealVar("fJ","fJ", 0.5, 0., 1)
fG1 = RooRealVar("fG1","fG1", 0.5, 0., 1)
fG2 = RooRealVar("fG2","fG2", 0.5, 0., 1)
##Background parameters
B_b = RooRealVar("B_b","B_b", 1.09, 0.9, 1.5)
B_c = RooRealVar("B_c","B_c", 0.0837, 0.01, 0.2)
##Total yield
N_S = RooRealVar("N_S","N_S", 0.6*dataset.numEntries(), 0, 1.1*dataset.numEntries())
N_B = RooRealVar("N_B","N_B", 0.3*dataset.numEntries(), 0, 1.1*dataset.numEntries())
#Define shapes
s_Johnson = ROOT.Johnson("s_Johnson", "s_Johnson", DTF_D0sPi_M, J_mu, J_sigma, J_delta, J_gamma)
s_Gauss1 = ROOT.RooGaussian("s_Gauss1","s_Gauss1", DTF_D0sPi_M, G1_mu, G1_sigma)
s_Gauss2 = ROOT.RooGaussian("s_Gauss2","s_Gauss2", DTF_D0sPi_M, G2_mu, G2_sigma)
s_Gauss3 = ROOT.RooGaussian("s_Gauss3","s_Gauss3", DTF_D0sPi_M, G3_mu, G3_sigma)
s_Background = ROOT.Background("s_Background", "s_Background", DTF_D0sPi_M, B_b, B_c)
s_Signal = RooAddPdf("s_Signal", "s_Signal", RooArgList(s_Gauss1, s_Gauss2, s_Gauss3), RooArgList(fG1, fG2), True)
s_Total = RooAddPdf("s_Total", "s_Total", RooArgList(s_Signal, s_Background), RooArgList(N_S, N_B))
dataset_binned = RooDataHist("dataset_binned","Binned data", RooArgSet(DTF_D0sPi_M), dataset)
#Fit shapes
fit_hists = s_Total.fitTo(dataset_binned,RooFit.SumW2Error(True),RooFit.Save())
if not silent:
ipframe_1 = DTF_D0sPi_M.frame(RooFit.Title("Fit example"))
dataset_binned.plotOn(ipframe_1)
s_Total.plotOn(ipframe_1, RooFit.Components("s_Signal"), RooFit.LineColor(2),RooFit.LineWidth(4))
s_Total.plotOn(ipframe_1, RooFit.Components("s_Johnson"), RooFit.LineColor(5),RooFit.LineWidth(2), RooFit.LineStyle(3))
s_Total.plotOn(ipframe_1, RooFit.Components("s_Gauss1"), RooFit.LineColor(6),RooFit.LineWidth(2), RooFit.LineStyle(3))
s_Total.plotOn(ipframe_1, RooFit.Components("s_Gauss2"), RooFit.LineColor(7),RooFit.LineWidth(2), RooFit.LineStyle(3))
s_Total.plotOn(ipframe_1, RooFit.Components("s_Gauss3"), RooFit.LineColor(8),RooFit.LineWidth(2), RooFit.LineStyle(3))
s_Total.plotOn(ipframe_1, RooFit.Components("s_Background"), RooFit.LineColor(4),RooFit.LineWidth(4))
s_Total.plotOn(ipframe_1, RooFit.LineColor(1), RooFit.LineWidth(4))
DTF_D0sPi_M.setRange("Background_region", 2015, 2020)
DTF_D0sPi_M.setRange("Signal_region", 2002, 2015)
Bckg_int = s_Background.createIntegral(RooArgSet(DTF_D0sPi_M), RooArgSet(DTF_D0sPi_M), "Background_region")
Sig_int = s_Background.createIntegral(RooArgSet(DTF_D0sPi_M), RooArgSet(DTF_D0sPi_M), "Signal_region")
w = RooRealVar("w","w",-1,1)
w.setVal(1)
dataset_sig.addColumn(w, False)
w.setVal(-float(Sig_int.getVal())/float(Bckg_int.getVal()))
dataset_bckg.addColumn(w, False)
dataset_all = RooDataSet("dataset_all", "dataset_all",dataset_bckg, RooArgSet(DTF_D0sPi_M, LOG_D0_IPCHI2_OWNPV, w), "1>0", "w")
dataset_all.append(dataset_sig)
if not silent:
ipframe_2 = LOG_D0_IPCHI2_OWNPV.frame(RooFit.Title("IPChi2 distribution"))
dataset_bckg.plotOn(ipframe_2, RooFit.LineColor(4), RooFit.MarkerColor(4))
dataset_all.plotOn(ipframe_2, RooFit.LineColor(3), RooFit.MarkerColor(3))
dataset_sig.plotOn(ipframe_2, RooFit.LineColor(2), RooFit.MarkerColor(2))
c1 = TCanvas("c1","c1",900,900)
ipframe_1.Draw()
c1.SaveAs("plots/Subtraction_Control/Bin_"+str(bin)+"_frame1.pdf")
c1.SaveAs("plots/Subtraction_Control/Bin_"+str(bin)+"_frame1_C.C")
c2 = TCanvas("c2","c2",900,900)
ipframe_2.Draw()
c2.SaveAs("plots/Subtraction_Control/Bin_"+str(bin)+"_frame2.pdf")
c2.SaveAs("plots/Subtraction_Control/Bin_"+str(bin)+"_frame2_C.C")
ipframe_1.SaveAs("plots/Subtraction_Control/Bin_"+str(bin)+"_ipframe1.C")
ipframe_2.SaveAs("plots/Subtraction_Control/Bin_"+str(bin)+"_ipframe2.C")
return dataset_all
print '%s is weighted: %s' % (dataset.GetName(), dataset.isWeighted())
dsetlist += [dataset]
decaycat = RooCategory('decaycat', 'Decay mode category')
decaycat.defineType('DsPi')
decaycat.defineType('DsK')
varlist += [decaycat]
for idx, mode in enumerate(['DsPi', 'DsK']):
decaycat.setLabel(mode)
dsetlist[idx].addColumn(decaycat)
dataset = RooDataSet('dataset', 'Combined dataset (DsK + DsPi)',
RooArgSet(time, decaycat), RooFit.Import(dsetlist[0]))
dataset.append(dsetlist[1])
for dset in dsetlist:
dset.Print()
dataset.Print()
## Basic B decay pdf with time resolution
# Resolution model
mean = RooRealVar('mean', 'Mean', 0.)
# scale = RooRealVar('scale', 'Per-event time error scale factor', 1.19)
resmodel = RooGaussModel('resmodel', 'Time resolution model', time, mean,
RooRealConstant.value(0.044),
RooRealConstant.value(1.0),
RooRealConstant.value(1.0))
# RooRealConstant::value(0), scale, dt)
# RooRealConstant::value(0), scale,
# input dataset paths
inPath = '/project/bfys/vsyropou/data/Bs2JpsiKst/RealData/'
dataSetPaths = {}
dataSetName = 'DecayTree'
dataSetPaths['2011negKaons'] = inPath + 'P2VVDataSet_2011Reco14_Bs2JpsiKst_negKaons_fitNtuple_120614_%s_weighted.root'%weightName
dataSetPaths['2011posKaons'] = inPath + 'P2VVDataSet_2011Reco14_Bs2JpsiKst_posKaons_fitNtuple_120614_%s_weighted.root'%weightName
dataSetPaths['2012negKaons'] = inPath + 'P2VVDataSet_2012Reco14_Bs2JpsiKst_negKaons_fitNtuple_120614_%s_weighted.root'%weightName
dataSetPaths['2012posKaons'] = inPath + 'P2VVDataSet_2012Reco14_Bs2JpsiKst_posKaons_fitNtuple_120614_%s_weighted.root'%weightName
outPath = '/project/bfys/vsyropou/data/Bs2JpsiKst/RealData/'
outFileName = 'P2VVDataSet_20112012Reco14_Bs2JpsiKst_allKaons_fitNtuple_120614_%s_weighted.root'%weightName
outDataName = 'jpsiKst'
# read datasets into a combined dataset
from ROOT import TFile, RooDataSet, RooFit
dataSets = {}
for key, path in dataSetPaths.iteritems(): dataSets[key] = TFile.Open(path).Get(dataSetName)
combinedDataSet = RooDataSet( outDataName, outDataName, dataSets['2012posKaons'].get() )
for dataSet in dataSets.itervalues(): combinedDataSet.append(dataSet)
combinedDataSet.Print()
outFile = TFile.Open(outPath + outFileName,'recreate')
combinedDataSet.Write()
outFile.Close()
del outFile
print 'P2VV - INFO: Wrote dataset to file: %s'%outPath + outFileName
states = tuple( [ [ ( cat, observables[cat].GetName(), state.getVal() ) for state in observables[cat] ] for cat in splitDataSet ] )
from itertools import product
for state in product(*states) :
nameStr = '_'.join( '%s%d' % ( cState[0], cState[2] ) for cState in state ).replace( '-', 'm' )
selStr = '&&'.join( '%s==%d' % ( cState[1], cState[2] ) for cState in state )
samples.append( ( nameStr, selStr ) )
# create splitted data sets
from ROOT import RooDataSet, RooArgSet
obsSet = RooArgSet( obs._var for obs in obsSetMain )
mainDS = RooDataSet( 'JpsiKK', 'JpsiKK', obsSet )
for sample in samples :
preDS = dataSets['preS'][0].reduce( Cut = sample[1] )
mainDSList.append( dataTree.buildDataSet( Observables = obsSetMain, Name = 'JpsiKK_' + sample[0], Title = 'JpsiKK'
, IndexName = 'index', OrigDataSet = preDS ) )
mainDS.append( mainDSList[-1] )
else :
# create data set without splitting
mainDS = dataTree.buildDataSet( Observables = obsSetMain, Name = 'JpsiKK', Title = 'JpsiKK', IndexName = 'index'
, OrigDataSet = dataSets['preS'][0] )
dataSets['main'] = ( mainDS, mainDSList )
dataSets.pop('pre')
dataSets.pop('preS')
dataTreeFile.Close()
from ROOT import gROOT
gROOT.cd('PyROOT:/')
print 'P2VV - INFO: createB2CCFitNTuple: produced data set:\n' + ' ' * 13,
def prepare_truth_models(ws, cat, mass, channel, turnon, truth):
if channel in study_inputs:
bkg_data = RooDataSet("bkgdata_%s" % (channel),
"M_{ll#gamma} with Errors",
ws.set("observables_weight"), "weight")
for k, file in enumerate(study_inputs[channel]):
f_in = TFile.Open(file, "READ")
gDirectory.cd(pwd)
n_events = f_in.Get("eventCount").GetBinContent(1)
tree = f_in.Get("selected_zg").CloneTree()
tree.SetName("tree_%s_%i" % (channel, k))
f_in.Close()
d_in = RooDataSet("temp", "M_{ll#gamma} with Errors", tree,
ws.set("observables"))
norm = RooConstVar("norm", "norm", n_events)
weight = RooFormulaVar(
"weight",
"weight",
"1.3*@0*@1/@2", #1.3 gives 19.6/fb
RooArgList(ws.var("puWeight"), ws.var("procWeight"), norm))
d_in.addColumn(weight)
d_in_weight = RooDataSet("temp_weight", "M_{ll#gamma} with Errors",
d_in, ws.set("observables_weight"), '',
'weight')
bkg_data.append(d_in_weight)
# split off data for each category, create the
# toy dataset truth models
data = bkg_data.reduce("Mz + Mzg > 185 && r94cat == %i" % cat)
getattr(ws, 'import')(data,
RooFit.Rename('bkgdata_%s_%i' % (channel, cat)))
nevts = data.sumEntries('Mzg > %f && Mzg < %f' %
(mass - 1.5, mass + 1.5))
#for sigm turn on we want erf truth
if turnon == 'sigm' and truth == 'exp':
#make RooDecay 'truth' model with erf turn on
ws.factory(
'RooGaussModel::MzgResoShape_exp_erf_%s_cat%i(Mzg,'\
'bias_exp_erf_%s_cat%i[120,90,150],sigma_exp_erf_%s_cat%i[1,0.01,10])'%(
channel,cat,
channel,cat,
channel,cat)
)
ws.factory(
'RooDecay::MzgTruthModelBase_exp_erf_%s_cat%i(Mzg,'\
'tau_erf_%s_cat%i[25,0,50],MzgResoShape_exp_erf_%s_cat%i,'
'RooDecay::SingleSided)'%(channel,cat,
channel,cat,
channel,cat)
)
ws.factory(
'RooExtendPdf::MzgTruthModel_exp_erf_%s_cat%i('\
'MzgTruthModelBase_exp_erf_%s_cat%i,'\
'norm_truth_exp_%s_cat%i[%f,%f,%f],"ROI")'%(channel,cat,
channel,cat,
channel,cat,
nevts,
0.25*nevts,1.75*nevts)
)
ws.pdf('MzgTruthModel_exp_erf_%s_cat%i' % (channel, cat)).fitTo(
ws.data('bkgdata_%s_%i' % (channel, cat)),
RooFit.Minimizer('Minuit2', 'scan'), RooFit.SumW2Error(False))
ws.pdf('MzgTruthModel_exp_erf_%s_cat%i' % (channel, cat)).fitTo(
ws.data('bkgdata_%s_%i' % (channel, cat)),
RooFit.Minimizer('Minuit', 'simplex'),
RooFit.SumW2Error(False))
ws.pdf('MzgTruthModel_exp_erf_%s_cat%i' % (channel, cat)).fitTo(
ws.data('bkgdata_%s_%i' % (channel, cat)),
RooFit.SumW2Error(True))
if turnon == 'sigm' and truth == 'pow':
#make power-law truth model with erf turn on
ws.factory('EXPR::MzgTruthModelShape_pow_erf_%s_cat%i('\
'"1e-20 + (@0 > @1)*((@0)^(-@2))",'\
'{Mzg,step_pow_erf_%s_cat%i[105,100,130],'\
'pow_%s_cat%i[2,0,10]})'\
%(channel,cat,
channel,cat,
channel,cat))
ws.factory(
'RooGaussModel::MzgResoShape_pow_erf_%s_cat%i(Mzg,'\
'bias_pow_erf_%s_cat%i[0],sigma_pow_erf_%s_cat%i[1,0.01,10])'%(
channel,cat,
channel,cat,
channel,cat)
)
ws.factory('FCONV::MzgTruthModelBase_pow_erf_%s_cat%i(Mzg,'\
'MzgTruthModelShape_pow_erf_%s_cat%i,'\
'MzgResoShape_pow_erf_%s_cat%i)'%(channel,cat,
channel,cat,
channel,cat))
ws.factory(
'RooExtendPdf::MzgTruthModel_pow_erf_%s_cat%i('\
'MzgTruthModelBase_pow_erf_%s_cat%i,'\
'norm_truth_pow_erf_%s_cat%i[%f,%f,%f],"ROI")'%(channel,cat,
channel,cat,
channel,cat,
nevts,
0.25*nevts,1.75*nevts)
)
ws.pdf('MzgTruthModel_pow_erf_%s_cat%i' % (channel, cat)).fitTo(
ws.data('bkgdata_%s_%i' % (channel, cat)),
RooFit.Minimizer('Minuit2', 'scan'), RooFit.SumW2Error(False))
ws.pdf('MzgTruthModel_pow_erf_%s_cat%i' % (channel, cat)).fitTo(
ws.data('bkgdata_%s_%i' % (channel, cat)),
RooFit.Minimizer('Minuit', 'simplex'),
RooFit.SumW2Error(False))
ws.pdf('MzgTruthModel_pow_erf_%s_cat%i' % (channel, cat)).fitTo(
ws.data('bkgdata_%s_%i' % (channel, cat)),
RooFit.SumW2Error(True))
#for erf fitting turn on we want sigmoid truth
if turnon == 'erf' and truth == 'exp':
#build exponential convoluted with sigmoid turn-on
ws.factory('RooStepExponential::MzgTruthModelShape_exp_sigm_%s_cat%i'\
'(Mzg,tau_sigm_%s_cat%i[-0.05,-10,0],'\
'step_exp_sigm_%s_cat%i[110,100,130])'%(channel,cat,
channel,cat,
channel,cat))
ws.factory('RooLogistics::MzgResoShape_exp_sigm_%s_cat%i(%s)' %
(channel, cat, ','.join([
'Mzg',
'bias_exp_sigm_%s_cat%i[0]' % (channel, cat),
'sigma_exp_sigm_%s_cat%i[5,0.01,20]' %
(channel, cat)
])))
ws.factory('FCONV::MzgTruthModelBase_exp_sigm_%s_cat%i(Mzg,'\
'MzgTruthModelShape_exp_sigm_%s_cat%i,'\
'MzgResoShape_exp_sigm_%s_cat%i)'%(channel,cat,
channel,cat,
channel,cat))
ws.factory(
'RooExtendPdf::MzgTruthModel_exp_sigm_%s_cat%i('\
'MzgTruthModelBase_exp_sigm_%s_cat%i,'\
'norm_truth_exp_sigm_%s_cat%i[%f,%f,%f],"ROI")'%(channel,cat,
channel,cat,
channel,cat,
nevts,
0.25*nevts,1.75*nevts)
)
ws.pdf('MzgTruthModel_exp_sigm_%s_cat%i' % (channel, cat)).fitTo(
ws.data('bkgdata_%s_%i' % (channel, cat)),
RooFit.Minimizer('Minuit2', 'scan'), RooFit.SumW2Error(False))
ws.pdf('MzgTruthModel_exp_sigm_%s_cat%i' % (channel, cat)).fitTo(
ws.data('bkgdata_%s_%i' % (channel, cat)),
RooFit.Minimizer('Minuit', 'simplex'),
RooFit.SumW2Error(False))
ws.pdf('MzgTruthModel_exp_sigm_%s_cat%i' % (channel, cat)).fitTo(
ws.data('bkgdata_%s_%i' % (channel, cat)),
RooFit.SumW2Error(True))
if turnon == 'erf' and truth == 'pow':
#build power-law convoluted with sigmoid turn-on
ws.factory('EXPR::MzgTruthModelShape_pow_sigm_%s_cat%i('\
'"1e-20 + (@0 > @1)*((@0)^(-@2))",'\
'{Mzg,step_pow_sigm_%s_cat%i[105,100,130],'\
'pow_sigm_%s_cat%i[2,0,10]})'\
%(channel,cat,
channel,cat,
channel,cat))
ws.factory('RooLogistics::MzgResoShape_pow_sigm_%s_cat%i(%s)' %
(channel, cat, ','.join([
'Mzg',
'bias_pow_sigm_%s_cat%i[0]' % (channel, cat),
'sigma_pow_sigm_%s_cat%i[5,0.01,20]' %
(channel, cat)
])))
ws.factory('FCONV::MzgTruthModelBase_pow_sigm_%s_cat%i(Mzg,'\
'MzgTruthModelShape_pow_sigm_%s_cat%i,'\
'MzgResoShape_pow_sigm_%s_cat%i)'%(channel,cat,
channel,cat,
channel,cat))
ws.factory(
'RooExtendPdf::MzgTruthModel_pow_sigm_%s_cat%i('\
'MzgTruthModelBase_pow_sigm_%s_cat%i,'\
'norm_truth_pow_sigm_%s_cat%i[%f,%f,%f],"ROI")'%(channel,cat,
channel,cat,
channel,cat,
nevts,
0.25*nevts,1.75*nevts)
)
ws.pdf('MzgTruthModel_pow_sigm_%s_cat%i' % (channel, cat)).fitTo(
ws.data('bkgdata_%s_%i' % (channel, cat)),
RooFit.Minimizer('Minuit2', 'scan'), RooFit.SumW2Error(False))
ws.pdf('MzgTruthModel_pow_sigm_%s_cat%i' % (channel, cat)).fitTo(
ws.data('bkgdata_%s_%i' % (channel, cat)),
RooFit.Minimizer('Minuit', 'simplex'),
RooFit.SumW2Error(False))
ws.pdf('MzgTruthModel_pow_sigm_%s_cat%i' % (channel, cat)).fitTo(
ws.data('bkgdata_%s_%i' % (channel, cat)),
RooFit.SumW2Error(True))
print ' output name: %s' % args.outputName
print ' event weight name: %s' % args.weightName
# get input datasets
import P2VV.RooFitWrappers
from ROOT import TFile
inData = [ ]
for fileName, dataName in zip( args.inputFiles, args.inputNames ) :
inFile = TFile.Open(fileName)
inData.append( inFile.Get(dataName) )
inFile.Close()
assert inData[-1]
print 'P2VV - INFO: mergeDataSets: read dataset "%s" from file "%s"' % ( dataName, fileName )
inData[-1].Print()
# merge files
from ROOT import RooDataSet, RooArgSet
obsSet = RooArgSet( inData[0].get() )
outData = RooDataSet( args.outputName, args.outputName, obsSet )
for data in inData : outData.append(data)
outData = RooDataSet( args.outputName, args.outputName, obsSet, Import = outData, WeightVar = ( args.weightName, True ) )
# write dataset to file
print 'P2VV - INFO: mergeDataSets: writing dataset to file "%s"' % args.outputFile
outData.Print()
from ROOT import TObject
outFile = TFile.Open( args.outputFile, 'RECREATE' )
outFile.Add(outData)
outFile.Write( args.outputFile, TObject.kOverwrite )
outFile.Close()
break
if genMass :
# generate J/psiKK mass
genObs = RooArgSet( massPdfObs.find('mass') )
dataObs.add(genObs)
genData = RooDataSet( dataSet.GetName(), dataSet.GetTitle(), dataObs, WeightVar = 'wMC' )
for comp in comps :
splitData[comp]['total'] = RooDataSet( '%s_%s' % ( dataSet.GetName(), comp ), dataSet.GetTitle(), dataObs )
for state in splitCat :
stateName = state.GetName()
splitData[comp][stateName] = pdfs[comp][stateName].generate( genObs, ProtoData = ( splitData[comp][stateName], False, False ) )
splitData[comp]['total'].append( splitData[comp][stateName] )
splitData[comp]['total'] = RooDataSet( '%s_%s' % ( dataSet.GetName(), comp ), dataSet.GetTitle(), dataObs
, Import = splitData[comp]['total'], WeightVar = ( 'wMC', True ) )
genData.append( splitData[comp]['total'] )
# print datasets and write them to file
from ROOT import TFile, TObject
dataFile = TFile.Open( args.dataPathOut, 'RECREATE' )
print 'P2VV - INFO: produced datasets (%d entries, sum of weights = %.1f):'\
% ( sum( ds['total'].numEntries() for ds in splitData.itervalues() )
, sum( ds['total'].sumEntries() for ds in splitData.itervalues() )
)
if genMass :
genData.Print()
dataFile.Add(genData)
for comp in comps :
splitData[comp]['total'].Print()
dataFile.Add( splitData[comp]['total'] )
if genMass :
def readData( filePath, dataSetName, NTuple = False, observables = None, **kwargs ) :
"""reads data from file (RooDataSet or TTree(s))
"""
from ROOT import RooFit
noNAN = ( ' && '.join( '( %s==%s )' % ( obs, obs ) for obs in observables ) ) if hasattr( observables, '__iter__' ) else ''
cuts = kwargs.pop( 'cuts', '' )
tmp_file = None
if observables :
print 'P2VV - INFO: readData: reading data for observables [ %s ]' % ', '.join( obs.GetName() for obs in observables )
dataSetArgs = { }
if 'WeightVar' in kwargs : dataSetArgs['WeightVar'] = kwargs.pop('WeightVar')
if NTuple :
from ROOT import RooDataSet, TFile
assert observables != None, 'P2VV - ERROR: readData: set of observables is required for reading an n-tuple'
# create data set from NTuple file(s)
print 'P2VV - INFO: readData: reading NTuple "%s" from file "%s"' % ( dataSetName, filePath )
ntupleFile = TFile.Open(filePath)
ntupleOrig = ntupleFile.Get(dataSetName)
if not ntupleOrig : raise RuntimeError( 'P2VV - ERROR: could not locate tree "%s" in file "%s"' % ( dataSetName, filePath ) )
if 'ntupleCuts' in kwargs :
ntupleCuts = kwargs.pop( 'ntupleCuts', '' )
print 'P2VV - INFO: readData: applying cuts on n-tuple: %s' % ntupleCuts
import tempfile
import os
from ROOT import TFile, gFile
orig_file = gFile
d = None
if 'TMP' in os.environ:
d = os.environ['TMP']
elif 'TMPDIR' in os.environ:
d = os.environ['TMPDIR']
elif os.access(os.path.dirname(filePath), os.W_OK):
d = os.path.dirname(filePath)
else:
d = '/tmp'
fd, temp_name = tempfile.mkstemp(suffix = '.root', dir = d)
os.close(fd)
os.remove(temp_name)
tmp_file = TFile.Open(temp_name, 'recreate')
ntuple = ntupleOrig.CopyTree(ntupleCuts)
else :
ntuple = ntupleOrig
if cuts : print 'P2VV - INFO: readData: applying cuts on data set: %s' % cuts
data = RooDataSet( dataSetName, dataSetName
, [ obs._var for obs in observables ]
, Import = ntuple
, Cut = noNAN + ' && ' + cuts if cuts else noNAN
, **dataSetArgs
)
else :
from ROOT import TFile
# get data set from file
print 'P2VV - INFO: readData: reading RooDataset "%s" from file "%s"' % ( dataSetName, filePath )
file = TFile.Open( filePath, 'READ' )
assert file, 'P2VV - ERROR: readData: file "%s" could not be opened' % filePath
if cuts : print 'P2VV - INFO: readData: applying cuts: %s' % cuts
# loop over category states
states = tuple( [ [ ( cat[0], ind ) for ind in cat[1] ] for cat in kwargs.pop( 'Categories', [ ( '', [ '' ] ) ] ) ] )
from itertools import product
for it, state in enumerate( product(*states) ) :
# get data set
dsName = '_'.join( str(catSt[0]) + str(catSt[1]) for catSt in state )
dsName = dataSetName + ( ( '_' + dsName ) if dsName else '' )
dataSet = file.Get(dsName)
assert dataSet, 'P2VV - ERROR: data set "%s" not found' % dsName
if it == 0 :
if observables :
from ROOT import RooDataSet
data = RooDataSet( dataSetName, dataSetName
, [ obs._var for obs in observables ]
, Import = dataSet
, Cut = noNAN + ' && ' + cuts if cuts else noNAN
, **dataSetArgs
)
else :
data = dataSet
else :
data.append(dataSet)
file.Close()
print 'P2VV - INFO: read dataset with %s entries (%.1f weighted)' % ( data.numEntries(), data.sumEntries() )
# import data set into current workspace
from P2VV.RooFitWrappers import RooObject
importIntoWS = kwargs.pop( 'ImportIntoWS', True )
rData = None
if importIntoWS :
# import data set into current workspace
from P2VV.RooFitWrappers import RooObject
wsData = RooObject().ws().put( data, **kwargs )
rData = wsData
else :
rData = data
if tmp_file:
tmp_file.Close()
os.remove(tmp_file.GetName())
if orig_file: orig_file.cd()
return rData
