def main():
'''This is the entry point to execution.'''
print 'Welcome to parameterized_keys_pdf_fit_example!'
global data, model, x, fitresult
data = getdata()
data.SetName('zeeDataYong')
## Reduce data for debugging
data = data.reduce(roo.EventRange(0, 1000))
x = data.get()[variable]
initialize_fit_parameters(data, x)
old_precision = set_default_integrator_precision(1e-8, 1e-8)
model = ParameterizedKeysPdf('model',
'model',
x,
mode,
effsigma,
data,
rho=1,
forcerange=True)
fitresult = model.fitTo(data, roo.SumW2Error(True), roo.NumCPU(8),
roo.Strategy(2), roo.Save())
set_default_integrator_precision(*old_precision)
make_plot(x, data, model)
print '\n== Fitted parameters =='
mode.Print()
effsigma.Print()
save_result(fitresult)
print '\nExiting parameterized_keys_pdf_fit_example with success.'
def __init__(self, data, rho=1.5, printlevel=-1, option='monolithic'):
if data.get().getSize() != 1:
raise RuntimeError, 'Data must contain just one variable!'
self.w = ROOT.RooWorkspace('KeysResponseFitter',
'KeysResponseFitter Workspace')
self.w.Import(data)
self.data = self.w.data(data.GetName())
self.data.SetName('data')
self.x = self.w.var(data.get().first().GetName())
self.x.SetName('x')
self.rho = rho
self.printlevel = printlevel
## Define mode and effsigma.
self.mode = self.w.factory('mode[0, -50, 50]')
self.effsigma = self.w.factory('effsigma[1, 0.01, 50]')
for x in 'mode effsigma'.split():
getattr(self, x).setUnit(self.x.getUnit())
self.option = option
if option == 'monolithic':
self.model = ParameterizedKeysPdf('model', 'model', self.x,
self.mode,
self.effsigma, self.data, rho=rho,
forcerange=True)
elif 'split' in option:
self.initsplit()
else:
raise RuntimeError, 'Unknown option: %s' % option
def initsplit(self):
'''
Splits the dataset in two and builds a model for each half.
'''
global arg
self.resampler = Resampler(self.data)
self.subdata = []
self.submodel = []
if not self.option.replace('split', ''):
self.nsplit = 2
else:
self.nsplit = int(self.option.replace('split', ''))
self.part = ROOT.RooCategory('part', 'part')
self.model = ROOT.RooSimultaneous('model', 'model', self.part)
for i in range(self.nsplit):
cat = str(i)
name = 'subdata%d' % i
self.part.defineType(cat)
self.subdata.append(self.resampler.prescale(self.nsplit, [i], name, name))
name = 'submodel%d' % i
self.submodel.append(
ParameterizedKeysPdf(
name, name, self.x, self.mode, self.effsigma,
self.subdata[i], rho=self.rho, forcerange=True
)
)
self.model.addPdf(self.submodel[i], cat)
# Now shuffle the subdata and the categories
args = [roo.Index(self.part)]
cats = [str(i) for i in range(self.nsplit)]
cats.reverse()
for cat, subdata in zip(cats, self.subdata):
args.append(roo.Import(cat, subdata))
self.data = ROOT.RooDataSet('data', 'data', ROOT.RooArgSet(self.x),
*args)
def main():
'''This is the entry point to execution.'''
print 'Welcome to test_pkeys - test of the mode and effective sigma'
print 'extraction for a generic distribution using ParametrizedKeysPdf.'
w = ROOT.RooWorkspace('w', 'w')
truepdf = w.factory('Gaussian::truepdf(x[-5,5],m[0],s[1])')
data = truepdf.generate(ROOT.RooArgSet(w.var('x')), 10000)
canvases.next('truepdf')
plot = w.var('x').frame()
data.plotOn(plot)
truepdf.plotOn(plot)
plot.Draw()
toypdf = ParameterizedKeysPdf('toypdf',
'toypdf',
w.var('x'),
w.factory('mtoy[0,-5,5]'),
w.factory('stoy[1,0.1,5]'),
data,
rho=3)
toypdf.shape.plotOn(plot, roo.LineColor(ROOT.kRed))
toypdf.fitTo(data)
toypdf.plotOn(plot, roo.LineColor(ROOT.kGreen))
plot.Draw()
canvases.update()
print 'Exiting test_pkeys with success!'
def run(self):
## Set the range of deltaE to cover all the date plus a small margin.
mi = self.modal_interval
mi.setFraction(1.)
self.deltaE.setRange(mi.lowerBound() - 1, mi.upperBound() + 1)
self.model = ParameterizedKeysPdf(self.name + '_model',
self.name + '_model',
self.deltaE,
self.mode,
self.effsigma,
self.train_data,
rho=2)
mit = self.modal_interval_training
mit.setFraction(0.99)
fitrange = roo.Range(mit.lowerBound(), mit.upperBound())
self.fit_result = self.model.fitTo(self.fit_data, roo.NumCPU(8),
roo.Save(), fitrange)
self.fit_result.SetName(self.name + '_fit_result')
self.make_log_plot()
self.make_zoom_plot()
self.make_fixed_range_log_plot()
self.make_fixed_range_zoom_plot()
canvases.update()
