def run(self):
## P e r f o r m c h i 2 f i t t o X + / - d x a n d Y + / - d Y v a l u e s
## ---------------------------------------------------------------------------------------
if self.noxerrors:
## Fit chi^2 using Y errors only
self.fresult = self.f.chi2FitTo(self.dxy_noxerrors,
roo.YVar(self.y), roo.Save(),
roo.Minos())
else:
## Fit chi^2 using X and Y errors
self.fresult = self.f.chi2FitTo(self.dxy, roo.YVar(self.y), roo.Save(),
roo.Minos())
self.frame = self.make_plot()
self.draw_plot(self.frame)
self.decorate_plot()
canvases.update()
def make_plot(self):
frame = self.x.frame(roo.Title(self.title))
## Visualize 2- and 1-sigma errors using linear error propagation.
self.f.plotOn(frame, roo.VisualizeError(self.fresult, 2),
roo.FillColor(ROOT.kGreen))
self.f.plotOn(frame, roo.VisualizeError(self.fresult, 1),
roo.FillColor(ROOT.kYellow))
## Visualize 1-sigma errors using a curve sampling method.
#self.f.plotOn(frame, roo.VisualizeError(self.fresult, 1, False),
#roo.DrawOption("L"), roo.LineWidth(2),
#roo.LineColor(ROOT.kRed))
## Plot fitted function
self.f.plotOn(frame)
## Overlay dataset in X-Y interpretation
self.dxy.plotOnXY(frame, roo.YVar(self.y))
return frame
def plot_sanity_checks(data):
pdfname = '_'.join(['bananaPdf', data.GetName()])
pdf = ROOT.RooNDKeysPdf(pdfname, pdfname, ROOT.RooArgList(mmMass, mmgMass),
data, "a", 1.5)
canvases.next(pdf.GetName() + '_mmgMassProj')
plot = mmgMass.frame(roo.Range(60, 120))
data.plotOn(plot)
pdf.plotOn(plot)
plot.Draw()
canvases.next(pdf.GetName() + '_mmMassProj')
plot = mmMass.frame(roo.Range(10, 120))
data.plotOn(plot)
pdf.plotOn(plot)
plot.Draw()
canvases.next(pdf.GetName()).SetGrid()
h_pdf = pdf.createHistogram('h_' + pdf.GetName(), mmMass,
roo.Binning(40, 40, 80),
roo.YVar(mmgMass, roo.Binning(40, 70, 110)))
h_pdf.Draw("cont1")
canvases.next(data.GetName()).SetGrid()
h_data = data.createHistogram(mmMass, mmgMass, 130, 100, '',
'h_' + data.GetName())
h_data.GetXaxis().SetRangeUser(40, 80)
h_data.GetYaxis().SetRangeUser(70, 110)
h_data.Draw("cont1")
canvases.next('_'.join([pdf.GetName(), 'mmgMassSlices']))
plot = mmgMass.frame(roo.Range(60, 120))
for mmmassval, color in zip([55, 60, 65, 70],
'Red Orange Green Blue'.split()):
mmMass.setVal(mmmassval)
color = getattr(ROOT, 'k' + color)
pdf.plotOn(plot, roo.LineColor(color))
plot.Draw()
canvases.update()
c1 = canvases.next('xt1')
c1.SetWindowSize(800, 400)
c1.Divide(2,1)
c1.cd(1).SetGrid()
t.setRange(*t1range)
t.SetTitle('log(m_{#mu#mu#gamma,E_{gen}^{#gamma}}^{2} - m_{#mu#mu}^{2})')
hxt1d = xt1data.createHistogram(mmMass, t, 100, 100, '', 'hxt1')
hxt1d.SetTitle('Data')
hxt1d.GetXaxis().SetTitle(mmMass.GetTitle() + ' (GeV)')
hxt1d.GetYaxis().SetTitle(t.GetTitle())
hxt1d.GetXaxis().SetRangeUser(*mmMass_range)
hxt1d.GetYaxis().SetRangeUser(*t1range)
hxt1d.Draw('cont0')
c1.cd(2).SetGrid()
hxt1f = xt1pdf.createHistogram('hxt1f', mmMass, roo.YVar(t))
hxt1f.SetTitle('PDF')
hxt1f.Draw("cont0")
## Plot fXT1(x, t1) projected on x axis
canvases.next('xt1_proj_x')
plot = mmMass.frame()
xt1data.plotOn(plot)
xt1pdf.plotOn(plot)
plot.Draw()
## Plot fXT1(x, t1) projected on t1 axis
canvases.next('xt1_proj_t1')
t.setRange(*t1range)
t.SetTitle('log(m_{#mu#mu#gamma,E_{gen}^{#gamma}}^{2} - m_{#mu#mu}^{2})')
plot = t.frame()
def __init__(self,
name,
title,
mass,
phos,
phor,
data,
workspace,
phostarget,
phortargets,
rho=1.5,
mirror=ROOT.RooKeysPdf.NoMirror,
mrangetrain=(40, 140),
mrangenorm=(50, 130),
mrangefit=(60, 120)):
'''PhosphorModel4(str name, str title, RooRealVar mass, RooRealVar phos,
RooRealVar phor, RooDataSet data, float phostarget,
[float] phortargets, float rho=1.5,
int mirror=ROOT.RooKeysPdf.NoMirror)
name - PDF name
title - PDF title
mass - mumugamma invariant mass (GeV), observable
phos - photon energy scale (%), parameter
phor - photon energy resolution (%), paramter
data - (mmMass, mmgMass, phoERes = 100*(phoEreco/phoEgen - 1), dataset
on which the shapes of reference PDFs are trained.
phostarget - target reference value of the photon energy scale at which
the model is being trained
phortargetss - a list of target photon energy resolution values for the
moment morphing
rho - passed to trained RooKeysPdfs
mirror - passed to trained RooKeysPdfs
'''
## Attach args.
self._name = name
self._title = title
self._mass = mass
self._phos = phos
self._phor = phor
self._data = data
self._phostarget = phostarget
self._phortargets = phortargets[:]
self._rho = rho
self._mirror = mirror
## Attach other attributes.
self._massrange = (mass.getMin(), mass.getMax())
self._sdata_list = []
self._phostrue_list = []
self._phortrue_list = []
self._dm_dphos_list = []
self._msubs_list = []
self._keys_pdfs = []
self._keys_modes = []
self._keys_effsigmas = []
self._keys_fitresults = []
self._pdfs = []
self._custs = []
# self._pdfrefs = []
self._mrefs = []
self._phormorphs = []
self._phorhists = []
self._workspace = workspace
## self._workspace = ROOT.RooWorkspace(name + '_workspace',
## title + ' workspace')
w = self._workspace
self.w = w
## Import important args in workspace.
# w.Import(ROOT.RooArgSet(mass, phos, phor))
w.Import(mass)
w.Import(phos)
w.Import(phor)
w.Import(self._data)
w.factory('ConstVar::{name}_phostarget({value})'.format(
name=name, value=self._phostarget))
## Define the morphing parameter. This an identity with the
## photon resolution for now.
mpar = self._mpar = w.factory(
'expr::{name}_mpar("{phor}", {{{phor}}})'.format(
## 'expr::{name}_mpar("2 + sqrt(0.5^2 + 0.05 * {phor}^2)", {{{phor}}})'.format(
## 'expr::{name}_mpar("2.325+sqrt(0.4571 + (0.1608*{phor})^2)", {{{phor}}})'.format(
name=name,
phor=phor.GetName()))
## Define the formula for dlog(m)/dphos.
self._dm_dphos_func = w.factory('''
expr::dm_dphos_func("0.5 * (1 - mmMass^2 / mmgMass^2) * mmgMass",
{mmMass, mmgMass})
''')
## Get the calibrator.
self._calibrator = MonteCarloCalibrator(self._data)
## Loop over target reference photon energy resolutions in phortargets.
for index, phortarget in enumerate(self._phortargets):
## Store the target photon resolution value.
w.factory('ConstVar::{name}_phortarget_{index}({value})'.format(
name=name, index=index, value=phortarget))
## Get the corresponding smeared RooDataSet sdata named
## {name}_sdata_{index} and attach it to self._sdata
sdata = self._calibrator.get_smeared_data(
self._phostarget,
phortarget,
name + '_sdata_%d' % index,
title + ' sdata %d' % index,
## Get the true scale and resolution with errors. (This can be
## added to the calibrator and snapshots of
## self._calibrator.s and self._calibrator.r stored as
## {name}_sdata_{index}_sr in self._calibrator.w)
dofit=True)
self._sdata_list.append(sdata)
w.Import(sdata)
phostrue = ROOT.RooRealVar(self._calibrator.s,
name + '_phostrue_%d' % index)
phortrue = ROOT.RooRealVar(self._calibrator.r,
name + '_phortrue_%d' % index)
phostrue.setConstant(True)
phortrue.setConstant(True)
self._phostrue_list.append(phostrue)
self._phortrue_list.append(phortrue)
w.Import(phostrue)
w.Import(phortrue)
## Calculate the dlogm/dphos {name}_dm_dphos_{index}
## for the smeared dataset.
sdata.addColumn(self._dm_dphos_func)
dm_dphos = w.factory('''
{name}_dm_dphos_{index}[{mean}, 0, 1]
'''.format(name=name,
index=index,
mean=sdata.mean(sdata.get()['dm_dphos_func'])))
dm_dphos.setConstant(True)
self._dm_dphos_list.append(dm_dphos)
## Define the mass scaling {name}_msubs{i} introducing
## the dependence on phos. This needs self._calibrator.s and
## dm_dphos.
## msubs = w.factory(
## '''
## LinearVar::{msubs}(
## {mass}, 1,
## expr::{offset}(
## "- 0.01 * {dm_dphos} * ({phos} - {phostrue})",
## {{ {dm_dphos}, {phos}, {phostrue} }}
## )
## )
## '''.format(msubs = name + '_msubs_%d' % index,
## offset = name + '_msubs_offset_%d' % index,
## mass = self._mass.GetName(),
## dm_dphos = dm_dphos.GetName(),
## phos = self._phos.GetName(),
## phostrue = phostrue.GetName())
## )
## LinearVar cannot be persisted.
msubs = w.factory('''
expr::{msubs}(
"{mass} - 0.01 * {dm_dphos} * ({phos} - {phostrue})",
{{ {mass}, {dm_dphos}, {phos}, {phostrue} }}
)
'''.format(msubs=name + '_msubs_%d' % index,
mass=self._mass.GetName(),
dm_dphos=dm_dphos.GetName(),
phos=self._phos.GetName(),
phostrue=phostrue.GetName()))
self._msubs_list.append(msubs)
## Build the corresponding parametrized KEYS PDF {name}_kyes_{index}
## with {name}_keys_mode_{index} and
## {name}_keys_effsigma_{index}.
keys_mode = w.factory(
'{name}_keys_mode_{index}[91.2, 60, 120]'.format(name=name,
index=index))
keys_effsigma = w.factory(
'{name}_keys_effsigma_{index}[3, 0.1, 60]'.format(name=name,
index=index))
mass.setRange(*mrangetrain)
keys_pdf = ParametrizedKeysPdf(name + '_keys_pdf_%d' % index,
name + '_keys_pdf_%d' % index,
mass,
keys_mode,
keys_effsigma,
sdata,
rho=self._rho)
self._keys_modes.append(keys_mode)
self._keys_effsigmas.append(keys_effsigma)
self._keys_pdfs.append(keys_pdf)
## Fit the KEYS PDF to the training data and save the result
## {name}_keys_fitresult_{index} and parameter snapshots
## {name}_keys_mctrue_{index}.
mass.setRange(*mrangenorm)
keys_fitresult = keys_pdf.fitTo(sdata, roo.Range(*mrangefit),
roo.Strategy(2), roo.NumCPU(8),
roo.Save(True))
self._keys_fitresults.append(keys_fitresult)
w.Import(keys_fitresult, name + '_keys_fitresult_%d' % index)
w.saveSnapshot(
name + '_mctrue_%d' % index, ','.join([
phostrue.GetName(),
phortrue.GetName(),
keys_mode.GetName(),
keys_effsigma.GetName()
]))
## Sample the fitted KEYS PDF to a histogram {name}_hist_{index}.
mass.setRange(*mrangetrain)
hist = keys_pdf.createHistogram(name + '_hist_%d' % index, mass,
roo.Binning('cache'))
## Build a RooDataHist {name}_dhist{index} of the sampled histogram.
dhist = ROOT.RooDataHist(name + '_dhist_%d' % index,
name + '_dhist_%d' % index,
ROOT.RooArgList(mass), hist)
w.Import(dhist)
## Build a RooHistPdf {name}_pdf_{index} using the dhist and msubs.
## pdf = w.factory(
pdf = w.factory('HistPdf::{name}({{{mass}}}, {dhist}, 1)'.format(
name=name + '_pdf_%d' % index,
msubs=msubs.GetName(),
mass=mass.GetName(),
dhist=dhist.GetName()))
self._pdfs.append(pdf)
mass.setRange(*self._massrange)
## Calculate morphing parameter reference values float mref[index].
phorval = phor.getVal()
phor.setVal(phortrue.getVal())
self._mrefs.append(mpar.getVal())
phor.setVal(phorval)
## End of loop over target phortargets
## Make the reference and cache binnings in phor
self._check_phor_ranges()
partitions = self._partition_binning(self._phor, 'cache', 'reference')
## Loop over phor reference bins and define pairwise RooMomentMorphs.
for ilo in range(len(self._mrefs) - 1):
ihi = ilo + 1
mlo = self._mrefs[ilo]
mhi = self._mrefs[ihi]
pdflo = self._pdfs[ilo]
pdfhi = self._pdfs[ihi]
phormorph = w.factory('''
MomentMorph::{name}_phormorph_{ilo}to{ihi}(
{mpar}, {{{mass}}}, {{{pdfs}}}, {{{mrefs}}}
)
'''.format(name=name,
ilo=ilo,
ihi=ihi,
mpar=mpar.GetName(),
mass=mass.GetName(),
pdfs='%s, %s' % (pdflo.GetName(), pdfhi.GetName()),
mrefs='%f, %f' % (mlo, mhi)))
self._phormorphs.append(phormorph)
## Sample the morph in a 2D histogram in mass and phor.
phorhist = phormorph.createHistogram(
name + '_phorhist_%dto%d' % (ilo, ihi), mass,
roo.Binning('cache'),
roo.YVar(phor, roo.Binning(partitions[ilo])))
self._phorhists.append(phorhist)
## End of loop over phor reference bins.
self._stitch_phorhists()
self._phor_dhist = phor_dhist = ROOT.RooDataHist(
name + '_phor_dhist', name + '_phor_dhist',
ROOT.RooArgList(mass, phor), self._phorhist)
average_index = (len(self._msubs_list) + 1) / 2
msubs = self._msubs_list[average_index]
## self._model = model = ROOT.RooHistPdf(
## name + '_phor_histpdf', name + '_phor_histpdf',
## ROOT.RooArgList(msubs, phor), ROOT.RooArgList(mass, phor), phor_dhist, 2
## )
## self._model = model = ROOT.RooPhosphorPdf(
## name + '_phor_histpdf', name + '_phor_histpdf', mass, msubs, phor, phor_dhist, 2
## )
## ## Quick hack to make things work.
## self._customizer = customizer = ROOT.RooCustomizer(model, 'msub')
## customizer.replaceArg(mass, msubs)
## model = customizer.build()
# ROOT.RooHistPdf.__init__(self, model)
ROOT.RooPhosphorPdf.__init__(self, name, title, mass, msubs, phos,
phor, phor_dhist, 2)
self.SetName(name)
self.SetTitle(title)
def test_substituting_for_mmgMassPhoGenE():
pdfname = '_'.join(['pdf_mmMass_mmgMassPhoGenE', data.GetName()])
pdf_mmMass_mmgMassPhoGenE = ROOT.RooNDKeysPdf(
pdfname, pdfname, ROOT.RooArgList(mmMass, mmgMassPhoGenE), data, "a",
1.5)
## Test substituting for mmgMassPhoGenE
## This formula is approximate for s = phoERes << 1
## 1/(1+s) - 1 ~ -s
## chachebins = ROOT.RooUniformBinning(-10, 10, 2, 'cache')
## phoERes.setBinning(chachebins)
phoERes.setBins(3, 'cache')
mmgMassFunc = w.factory('''expr::mmgMassFunc(
"sqrt(mmgMass^2 - 0.01 * phoERes * (mmgMass^2 - mmMass^2))",
{mmMass, mmgMass, phoERes}
)''')
## mmgMassFunc = w.factory('''cexpr::mmgMassFunc(
## "sqrt(mmgMass*mmgMass - 0.01 * phoERes * (mmgMass*mmgMass - mmMass*mmMass))",
## {mmMass, mmgMass, phoERes}
## )'''
## )
cust = ROOT.RooCustomizer(pdf_mmMass_mmgMassPhoGenE, 'subs')
cust.replaceArg(mmgMassPhoGenE, mmgMassFunc)
pdf_mmMass_mmgMass = cust.build()
pdf_mmMass_mmgMass.addOwnedComponents(ROOT.RooArgSet(mmgMassFunc))
pdf_mmMass_mmgMass.SetName('pdf_mmMass_mmgMass')
## WARNING: The caching related lines below cause segmentation violation!
## pdf_mmMass_mmgMass.setNormValueCaching(2)
## print '-- Before chache --'
## w.Print()
## print '-- Calculating cache ... --'
## ## Trigger the cache calculation
## pdf_mmMass_mmgMass.getVal(ROOT.RooArgSet(mmMass, mmgMass))
## print '-- After chache --'
## w.Print()
pdf = pdf_mmMass_mmgMassPhoGenE
canvases.next(pdf.GetName()).SetGrid()
h_pdf = pdf.createHistogram(
'h_' + pdf.GetName(), mmMass, roo.Binning(40, 40, 80),
roo.YVar(mmgMassPhoGenE, roo.Binning(40, 70, 110)))
h_pdf.Draw("cont1")
pdf = pdf_mmMass_mmgMass
phoERes.setVal(0)
canvases.next(pdf.GetName() + '_s0').SetGrid()
h_pdf = pdf.createHistogram('h_' + pdf.GetName() + '_s0', mmMass,
roo.Binning(40, 40, 80),
roo.YVar(mmgMass, roo.Binning(40, 70, 110)))
h_pdf.Draw("cont1")
phoERes.setVal(10)
canvases.next(pdf.GetName() + '_s10').SetGrid()
h_pdf = pdf.createHistogram('h_' + pdf.GetName() + '_s10', mmMass,
roo.Binning(40, 40, 80),
roo.YVar(mmgMass, roo.Binning(40, 70, 110)))
h_pdf.Draw("cont1")
phoERes.setVal(-10)
canvases.next(pdf.GetName() + '_sm10').SetGrid()
h_pdf = pdf.createHistogram('h_' + pdf.GetName() + '_sm10', mmMass,
roo.Binning(40, 40, 80),
roo.YVar(mmgMass, roo.Binning(40, 70, 110)))
h_pdf.Draw("cont1")