def buildComponentIntegrals(self, region, vals, errs, integrals):
fracMap = self.getComponentFractions(
self.workspace.pdf('bg_{}'.format(region)))
if isinstance(integrals, dict):
vals = vals[region]['']
errs = errs[region]['']
integrals = integrals[region]
allerrors = {}
allintegrals = {}
for component in fracMap:
#self.workspace.factory('{}_{}_norm[1,0,2]'.format(component,region))
subint = 1.
suberr2 = 0.
# TODO: errors are way larger than they should be, need to look into this
# dont use these uncertainties
for frac in fracMap.get(component, []):
key = frac.GetTitle()
if isinstance(frac, ROOT.RooRecursiveFraction):
subint *= frac.getVal()
#TODO correct this
#suberr2 += (frac.getError()/frac.getVal())**2
else:
subint *= frac.getVal()
suberr2 += (frac.getError() / frac.getVal())**2
suberr = suberr2**0.5
allerrors[component] = suberr
name = 'integral_{}_{}'.format(component, region)
if isinstance(integrals, dict):
paramValue = subint * integrals['']
paramShifts = {}
for shift in self.BACKGROUNDSHIFTS:
shiftValueUp = subint * integrals[shift + 'Up']
shiftValueDown = subint * integrals[shift + 'Down']
paramShifts[shift] = {
'up': shiftValueUp,
'down': shiftValueDown
}
param = Models.Param(
name,
value=paramValue,
shifts=paramShifts,
)
else:
paramValue = subint * integrals
param = Models.Param(
name,
value=paramValue,
)
param.build(self.workspace, name)
allintegrals[component] = paramValue
return allintegrals, allerrors
def addControlModels(self,
addUpsilon=True,
setUpsilonLambda=False,
voigtian=False,
logy=False):
region = 'control'
self.buildModel(region=region,
addUpsilon=addUpsilon,
setUpsilonLambda=setUpsilonLambda,
voigtian=voigtian)
#self.workspace.factory('bg_{}_norm[1,0,2]'.format(region))
vals, errs, ints = self.fitBackground(
region=region,
setUpsilonLambda=setUpsilonLambda,
addUpsilon=addUpsilon,
logy=logy)
# integral
name = 'integral_bg_{}'.format(region)
paramValue = ints
param = Models.Param(
name,
value=paramValue,
)
param.build(self.workspace, name)
allintegrals, errors = self.buildComponentIntegrals(
region, vals, errs, ints)
for k, v in allintegrals.items():
print k, v
self.control_vals = vals
self.control_errs = errs
self.control_integrals = ints
self.control_integralErrors = errors
self.control_integralValues = allintegrals
def buildModel(self,region='PP',**kwargs):
tag = kwargs.pop('tag',region)
# jpsi
jpsi1S = Models.Voigtian('jpsi1S',
mean = [3.1,2.9,3.2],
sigma = [0.1,0,1],
width = [0.1,0.01,1],
)
#nameJ1 = 'jpsi1S{}'.format('_'+tag if tag else '')
nameJ1 = 'jpsi1S'
jpsi1S.build(self.workspace,nameJ1)
jpsi2S = Models.Gaussian('jpsi2S',
mean = [3.7,3.6,3.8],
sigma = [0.1,0.01,1],
width = [0.1,0.01,1],
)
#nameJ2 = 'jpsi2S{}'.format('_'+tag if tag else '')
nameJ2 = 'jpsi2S'
jpsi2S.build(self.workspace,nameJ2)
#jpsi = Models.Sum('jpsi',
# **{
# nameJ1 : [0.5,0,1] if tag=='PP' else [0.5,0,1],
# nameJ2 : [0.6,0,1] if tag=='PP' else [0.2,0,1],
# 'recursive' : True,
# }
#)
##nameJ = 'jpsi{}'.format('_'+tag if tag else '')
#nameJ= 'jpsi'
#jpsi.build(self.workspace,nameJ)
# upsilon
upsilon1S = Models.Gaussian('upsilon1S',
mean = [9.5,9.3,9.7],
sigma = [0.1,0.01,0.3],
)
#nameU1 = 'upsilon1S{}'.format('_'+tag if tag else '')
nameU1 = 'upsilon1S'
upsilon1S.build(self.workspace,nameU1)
upsilon2S = Models.Gaussian('upsilon2S',
mean = [10.0,9.8,10.2],
sigma = [0.1,0.01,0.3],
)
#nameU2 = 'upsilon2S{}'.format('_'+tag if tag else '')
nameU2 = 'upsilon2S'
upsilon2S.build(self.workspace,nameU2)
upsilon3S = Models.Gaussian('upsilon3S',
mean = [10.3,10.2,10.5],
sigma = [0.1,0.02,0.3],
)
#nameU3 = 'upsilon3S{}'.format('_'+tag if tag else '')
nameU3 = 'upsilon3S'
upsilon3S.build(self.workspace,nameU3)
#upsilon = Models.Sum('upsilon',
# **{
# nameU1 : [0.43,0,1],
# nameU2 : [0.20,0,1],
# nameU3 : [1,0,1],
# 'recursive' : True,
# }
#)
##nameU = 'upsilon{}'.format('_'+tag if tag else '')
#nameU= 'upsilon'
#upsilon.build(self.workspace,nameU)
# continuum background
cont = Models.Chebychev('cont',
order = 2,
p0 = [-1,-1.4,0],
p1 = [0.25,0,0.5],
p2 = [0.03,-1,1],
)
nameC = 'cont{}'.format('_'+tag if tag else '')
cont.build(self.workspace,nameC)
cont1 = Models.Exponential('cont1',
lamb = [-0.20,-1,0],
)
nameC1 = 'cont1{}'.format('_'+tag if tag else '')
cont1.build(self.workspace,nameC1)
cont2 = Models.Exponential('cont2',
lamb = [-0.05,-1,0],
)
nameC2 = 'cont2{}'.format('_'+tag if tag else '')
cont2.build(self.workspace,nameC2)
cont3 = Models.Exponential('cont3',
lamb = [-0.75,-5,0],
)
nameC3 = 'cont3{}'.format('_'+tag if tag else '')
cont3.build(self.workspace,nameC3)
cont4 = Models.Exponential('cont4',
lamb = [-2,-5,0],
)
nameC4 = 'cont4{}'.format('_'+tag if tag else '')
cont4.build(self.workspace,nameC4)
#cont = Models.Sum('cont',
# **{
# nameC1 : [0.95,0,1],
# nameC2 : [0.05,0,1],
# 'recursive' : True,
# }
#)
#nameC = 'cont{}'.format('_'+tag if tag else '')
#cont.build(self.workspace,nameC)
# sum
if self.XRANGE[0]<4 and self.XRANGE[1]>10:
# jpsi and upsilon
bg = Models.Sum('bg',
**{
#nameC : [0.1,0,1],
nameC1: [0.2,0,1],
nameC2: [0.5,0,1],
nameC3: [0.8,0,1],
#nameC4: [0.1,0,1],
#nameJ : [0.9,0,1],
nameJ1: [0.9,0,1],
nameJ2: [0.9,0,1],
#nameU : [0.1,0,1],
nameU1: [0.1,0,1],
nameU2: [0.1,0,1],
nameU3: [0.1,0,1],
'recursive' : True,
}
)
elif self.XRANGE[0]<4:
# only jpsi
bg = Models.Sum('bg',
**{
#nameC : [0.1,0,1],
nameC3: [0.1,0,1],
nameC2: [0.1,0,1],
#nameJ : [0.9,0,1],
nameJ1: [0.9,0,1],
nameJ2: [0.9,0,1],
'recursive' : True,
}
)
else:
# only upsilon
bg = Models.Sum('bg',
**{
#nameC : [0.1,0,1],
nameC1: [0.5,0,1],
nameC2: [0.7,0,1],
#nameU : [0.5,0,1],
nameU1: [0.5,0,1],
nameU2: [0.5,0,1],
nameU3: [0.5,0,1],
'recursive' : True,
}
)
name = 'bg_{}'.format(region)
bg.build(self.workspace,name)
def buildSpline(self,h,region='PP',shift=''):
'''
Get the signal spline for a given Higgs mass.
Required arguments:
h = higgs mass
'''
histMap = self.histMap[region][shift]
tag= '{}{}'.format(region,'_'+shift if shift else '')
# initial fit
results = {}
errors = {}
results[h] = {}
errors[h] = {}
for a in self.AMASSES:
ws = ROOT.RooWorkspace('sig')
ws.factory('x[{0}, {1}]'.format(*self.XRANGE))
ws.var('x').setUnit('GeV')
ws.var('x').setPlotLabel(self.XLABEL)
ws.var('x').SetTitle(self.XLABEL)
model = Models.Voigtian('sig',
mean = [a,0,30],
width = [0.01*a,0,5],
sigma = [0.01*a,0,5],
)
model.build(ws, 'sig')
hist = histMap[self.SIGNAME.format(h=h,a=a)]
results[h][a], errors[h][a] = model.fit(ws, hist, 'h{}_a{}_{}'.format(h,a,tag), saveDir=self.plotDir, save=True, doErrors=True)
models = {
'mean' : Models.Chebychev('mean', order = 1, p0 = [0,-1,1], p1 = [0.1,-1,1], p2 = [0.03,-1,1]),
'width': Models.Chebychev('width', order = 1, p0 = [0,-1,1], p1 = [0.1,-1,1], p2 = [0.03,-1,1]),
'sigma': Models.Chebychev('sigma', order = 1, p0 = [0,-1,1], p1 = [0.1,-1,1], p2 = [0.03,-1,1]),
}
for param in ['mean', 'width', 'sigma']:
ws = ROOT.RooWorkspace(param)
ws.factory('x[{},{}]'.format(*self.XRANGE))
ws.var('x').setUnit('GeV')
ws.var('x').setPlotLabel(self.XLABEL)
ws.var('x').SetTitle(self.XLABEL)
model = models[param]
model.build(ws, param)
name = '{}_{}{}'.format(param,h,tag)
hist = ROOT.TH1D(name, name, len(self.AMASSES), 4, 22)
vals = [results[h][a]['{}_h{}_a{}_{}'.format(param,h,a,tag)] for a in self.AMASSES]
errs = [errors[h][a]['{}_h{}_a{}_{}'.format(param,h,a,tag)] for a in self.AMASSES]
for i,a in enumerate(self.AMASSES):
b = hist.FindBin(a)
hist.SetBinContent(b,vals[i])
hist.SetBinError(b,errs[i])
model.fit(ws, hist, name, saveDir=self.plotDir, save=True)
# create model
for a in self.AMASSES:
print h, a, results[h][a]
model = Models.VoigtianSpline(self.SPLINENAME.format(h=h),
**{
'masses' : self.AMASSES,
'means' : [results[h][a]['mean_h{0}_a{1}_{2}'.format(h,a,tag)] for a in self.AMASSES],
'widths' : [results[h][a]['width_h{0}_a{1}_{2}'.format(h,a,tag)] for a in self.AMASSES],
'sigmas' : [results[h][a]['sigma_h{0}_a{1}_{2}'.format(h,a,tag)] for a in self.AMASSES],
}
)
if self.binned:
integrals = [histMap[self.SIGNAME.format(h=h,a=a)].Integral() for a in self.AMASSES]
else:
integrals = [histMap[self.SIGNAME.format(h=h,a=a)].sumEntries('x>{} && x<{}'.format(*self.XRANGE)) for a in self.AMASSES]
model.setIntegral(self.AMASSES,integrals)
model.build(self.workspace,'{}_{}'.format(self.SPLINENAME.format(h=h),tag))
model.buildIntegral(self.workspace,'integral_{}_{}'.format(self.SPLINENAME.format(h=h),tag))
def buildModel(self, region='PP', addUpsilon=True, setUpsilonLambda=False, voigtian=False, **kwargs):
tag = kwargs.pop('tag',region)
bgRes = Models.Voigtian if voigtian else Models.Gaussian
# jpsi
jpsi1S = bgRes('jpsi1S',
mean = [3.1,2.9,3.2],
sigma = [0.1,0,0.5],
width = [0.1,0.01,0.5],
)
nameJ1 = 'jpsi1S'
jpsi1S.build(self.workspace,nameJ1)
jpsi2S = bgRes('jpsi2S',
mean = [3.7,3.6,3.8],
sigma = [0.1,0.01,0.5],
width = [0.1,0.01,0.5],
)
nameJ2 = 'jpsi2S'
jpsi2S.build(self.workspace,nameJ2)
jpsiErr = Models.Erf('jpsiErr',
erfScale = [-10,-500,-1],
erfShift = [6.5,5,8],
)
nameJE = 'jpsiErr'
jpsiErr.build(self.workspace,nameJE)
#jpsi = {'recursive': True}
#jpsi[nameJ1] = [0.9,0,1]
#jpsi[nameJ2] = [0.1,0,1]
#jpsi = Models.Sum('jpsi', **jpsi)
#nameJ = 'jpsi_{}'.format(region)
#jpsi.build(self.workspace,nameJ)
if self.XRANGE[0]<3.3:
jpsi = {'extended': True}
jpsi[nameJ1] = [0.9,0,1]
jpsi[nameJ2] = [0.1,0,1]
jpsi = Models.Sum('jpsi', **jpsi)
nameJ = 'jpsi'
jpsi.build(self.workspace,nameJ)
# upsilon
upsilon1S = bgRes('upsilon1S',
mean = [9.5,9.3,9.7],
sigma = [0.1,0.01,0.3],
)
nameU1 = 'upsilon1S'
upsilon1S.build(self.workspace,nameU1)
upsilon2S = bgRes('upsilon2S',
mean = [10.0,9.8,10.15],
sigma = [0.1,0.01,0.3],
)
nameU2 = 'upsilon2S'
upsilon2S.build(self.workspace,nameU2)
upsilon3S = bgRes('upsilon3S',
mean = [10.3,10.22,10.5],
sigma = [0.1,0.04,0.3],
)
nameU3 = 'upsilon3S'
upsilon3S.build(self.workspace,nameU3)
#upsilon = {'recursive': True}
#upsilon[nameU1] = [0.75,0,1]
#upsilon[nameU2] = [0.5,0,1]
#upsilon[nameU3] = [0.5,0,1]
#upsilon = Models.Sum('upsilon', **upsilon)
#nameU = 'upsilon_{}'.format(region)
#upsilon.build(self.workspace,nameU)
nameU23 = 'upsilon23'
upsilon23 = {'extended': True}
upsilon23[nameU2] = [0.5,0,1]
upsilon23[nameU3] = [0.5,0,1]
upsilon23 = Models.Sum(nameU23, **upsilon23)
upsilon23.build(self.workspace,nameU23)
nameU = 'upsilon'
upsilon = {'extended': True}
upsilon[nameU1] = [0.75,0,1]
upsilon[nameU23] = [0.5,0,1]
upsilon = Models.Sum(nameU, **upsilon)
upsilon.build(self.workspace,nameU)
# sum upsilon and jpsi
nameR = 'resonant'
resonant = {'extended': True}
resonant[nameU] = [0.75,0,1]
if self.XRANGE[0]<3.3:
resonant[nameJ] = [0.5,0,1]
elif self.XRANGE[0]<4.0:
resonant[nameJ2] = [0.5,0,1]
resonant = Models.Sum(nameR, **resonant)
resonant.build(self.workspace,nameR)
# continuum background
nameC = 'cont{}'.format('_'+tag if tag else '')
cont = Models.Chebychev(nameC,
order = 2,
p0 = [-1,-1.4,0],
p1 = [0.25,0,0.5],
p2 = [0.03,-1,1],
)
cont.build(self.workspace,nameC)
nameC1 = 'cont1{}'.format('_'+tag if tag else '')
#nameC1 = 'cont1'
cont1 = Models.Exponential(nameC1,
lamb = [-2,-4,0],
)
cont1.build(self.workspace,nameC1)
#nameC2 = 'cont2{}'.format('_'+tag if tag else '')
##nameC2 = 'cont2'
#cont2 = Models.Exponential(nameC2,
# lamb = [-0.5,-2,0],
#)
#cont2.build(self.workspace,nameC2)
nameC3 = 'cont3{}'.format('_'+tag if tag else '')
#nameC3 = 'cont3'
cont3 = Models.Exponential(nameC3,
lamb = [-0.75,-5,0],
)
cont3.build(self.workspace,nameC3)
#nameC4 = 'cont4{}'.format('_'+tag if tag else '')
##nameC4 = 'cont4'
#cont4 = Models.Exponential(nameC4,
# lamb = [-2,-5,0],
#)
#cont4.build(self.workspace,nameC4)
# sum
bgs = {'recursive': True}
# continuum background
bgs[nameC1] = [0.5,0,1]
if self.XRANGE[0]<=4 and self.XRANGE[1]>=11:
bgs[nameR] = [0.9,0,1]
bgs[nameC3] = [0.5,0,1]
else:
# jpsi
if self.XRANGE[0]<3.3:
bgs[nameJ] = [0.9,0,1]
bgs[nameC3] = [0.5,0,1]
elif self.XRANGE[0]<4:
bgs[nameJ2] = [0.9,0,1]
bgs[nameC3] = [0.5,0,1]
# upsilon
if self.XRANGE[0]<=9 and self.XRANGE[1]>=11:
#bgs[nameU1] = [0.9,0,1]
#bgs[nameU2] = [0.9,0,1]
#bgs[nameU3] = [0.9,0,1]
bgs[nameU] = [0.9,0,1]
bgs[nameC3] = [0.5,0,1]
bg = Models.Sum('bg', **bgs)
name = 'bg_{}'.format(region)
bg.build(self.workspace,name)
def buildSpline(self,h,region='PP',shift='',**kwargs):
'''
Get the signal spline for a given Higgs mass.
Required arguments:
h = higgs mass
'''
fit = kwargs.get('fit',False) # will fit the spline parameters rather than a simple spline
amasses = self.AMASSES
if h>125: amasses = [a for a in amasses if a not in ['3p6',4,6]]
avals = [float(str(x).replace('p','.')) for x in amasses]
histMap = self.histMap[region][shift]
tag= '{}{}'.format(region,'_'+shift if shift else '')
# initial fit
results = {}
errors = {}
results[h] = {}
errors[h] = {}
for a in amasses:
aval = float(str(a).replace('p','.'))
ws = ROOT.RooWorkspace('sig')
ws.factory('x[{0}, {1}]'.format(*self.XRANGE))
ws.var('x').setUnit('GeV')
ws.var('x').setPlotLabel(self.XLABEL)
ws.var('x').SetTitle(self.XLABEL)
model = Models.Voigtian('sig',
mean = [aval,0,30],
width = [0.01*aval,0,5],
sigma = [0.01*aval,0,5],
)
model.build(ws, 'sig')
hist = histMap[self.SIGNAME.format(h=h,a=a)]
saveDir = '{}/{}'.format(self.plotDir,shift if shift else 'central')
results[h][a], errors[h][a] = model.fit(ws, hist, 'h{}_a{}_{}'.format(h,a,tag), saveDir=saveDir, save=True, doErrors=True)
# Fit using ROOT rather than RooFit for the splines
fitFuncs = {
'mean' : 'pol1',
'width': 'pol2',
'sigma': 'pol2',
}
xs = []
x = self.XRANGE[0]
while x<=self.XRANGE[1]:
xs += [x]
x += float(self.XRANGE[1]-self.XRANGE[0])/100
fittedParams = {}
for param in ['mean','width','sigma']:
name = '{}_{}{}'.format(param,h,tag)
xerrs = [0]*len(amasses)
vals = [results[h][a]['{}_h{}_a{}_{}'.format(param,h,a,tag)] for a in amasses]
errs = [errors[h][a]['{}_h{}_a{}_{}'.format(param,h,a,tag)] for a in amasses]
graph = ROOT.TGraphErrors(len(avals),array('d',avals),array('d',vals),array('d',xerrs),array('d',errs))
savedir = '{}/{}'.format(self.plotDir,shift if shift else 'central')
python_mkdir(savedir)
savename = '{}/{}_Fit'.format(savedir,name)
canvas = ROOT.TCanvas(savename,savename,800,800)
graph.Draw()
graph.SetTitle('')
graph.GetHistogram().GetXaxis().SetTitle(self.SPLINELABEL)
graph.GetHistogram().GetYaxis().SetTitle(param)
if fit:
fitResult = graph.Fit(fitFuncs[param])
func = graph.GetFunction(fitFuncs[param])
fittedParams[param] = [func.Eval(x) for x in xs]
canvas.Print('{}.png'.format(savename))
# create model
for a in amasses:
print h, a, results[h][a]
if fit:
model = Models.VoigtianSpline(self.SPLINENAME.format(h=h),
**{
'masses' : xs,
'means' : fittedParams['mean'],
'widths' : fittedParams['width'],
'sigmas' : fittedParams['sigma'],
}
)
else:
model = Models.VoigtianSpline(self.SPLINENAME.format(h=h),
**{
'masses' : avals,
'means' : [results[h][a]['mean_h{0}_a{1}_{2}'.format(h,a,tag)] for a in amasses],
'widths' : [results[h][a]['width_h{0}_a{1}_{2}'.format(h,a,tag)] for a in amasses],
'sigmas' : [results[h][a]['sigma_h{0}_a{1}_{2}'.format(h,a,tag)] for a in amasses],
}
)
if self.binned:
integrals = [histMap[self.SIGNAME.format(h=h,a=a)].Integral() for a in amasses]
else:
integrals = [histMap[self.SIGNAME.format(h=h,a=a)].sumEntries('x>{} && x<{}'.format(*self.XRANGE)) for a in amasses]
print 'Integrals', tag, h, integrals
param = 'integral'
funcname = 'pol2'
name = '{}_{}{}'.format(param,h,tag)
vals = integrals
graph = ROOT.TGraph(len(avals),array('d',avals),array('d',vals))
savedir = '{}/{}'.format(self.plotDir,shift if shift else 'central')
python_mkdir(savedir)
savename = '{}/{}_Fit'.format(savedir,name)
canvas = ROOT.TCanvas(savename,savename,800,800)
graph.Draw()
graph.SetTitle('')
graph.GetHistogram().GetXaxis().SetTitle(self.SPLINELABEL)
graph.GetHistogram().GetYaxis().SetTitle('integral')
if fit:
fitResult = graph.Fit(funcname)
func = graph.GetFunction(funcname)
newintegrals = [func.Eval(x) for x in xs]
# dont fit integrals
#model.setIntegral(xs,newintegrals)
canvas.Print('{}.png'.format(savename))
model.setIntegral(avals,integrals)
model.build(self.workspace,'{}_{}'.format(self.SPLINENAME.format(h=h),tag))
model.buildIntegral(self.workspace,'integral_{}_{}'.format(self.SPLINENAME.format(h=h),tag))
savedir = '{}/{}'.format(self.fitsDir,shift if shift else 'central')
python_mkdir(savedir)
savename = '{}/h{}_{}.json'.format(savedir,h,tag)
jsonData = {'vals': results, 'errs': errors, 'integrals': {a:integral for a,integral in zip(avals,integrals)}}
self.dump(savename,jsonData)
# return the model
# this can be used to determine if you want to keep this shift
return model
def buildModel(self, region='PP', **kwargs):
tag = kwargs.pop('tag', region)
# continuum background
cont = Models.Chebychev(
'cont',
order=2,
p0=[-1, -1.4, 0],
p1=[0.25, 0, 0.5],
p2=[0.03, -1, 1],
)
nameC = 'cont{}'.format('_' + tag if tag else '')
cont.build(self.workspace, nameC)
cont1 = Models.Exponential(
'cont1',
lamb=[-0.20, -1, 0],
)
nameC1 = 'cont1{}'.format('_' + tag if tag else '')
cont1.build(self.workspace, nameC1)
cont2 = Models.Exponential(
'cont2',
lamb=[-0.05, -1, 0],
)
nameC2 = 'cont2{}'.format('_' + tag if tag else '')
cont2.build(self.workspace, nameC2)
cont3 = Models.Exponential(
'cont3',
lamb=[-0.75, -5, 0],
)
nameC3 = 'cont3{}'.format('_' + tag if tag else '')
cont3.build(self.workspace, nameC3)
cont4 = Models.Exponential(
'cont4',
lamb=[-2, -5, 0],
)
nameC4 = 'cont4{}'.format('_' + tag if tag else '')
cont4.build(self.workspace, nameC4)
#cont = Models.Sum('cont',
# **{
# nameC1 : [0.95,0,1],
# nameC2 : [0.05,0,1],
# 'recursive' : True,
# }
#)
#nameC = 'cont{}'.format('_'+tag if tag else '')
#cont.build(self.workspace,nameC)
# sum
bg = Models.Sum(
'bg',
**{
#nameC : [0.1,0,1],
nameC1: [0.5, 0, 1],
nameC2: [0.7, 0, 1],
'recursive': True,
})
name = 'bg_{}'.format(region)
bg.build(self.workspace, name)
def addBackgroundModels(self,
fixAfterControl=False,
fixAfterFP=False,
addUpsilon=True,
setUpsilonLambda=False,
voigtian=False,
logy=False):
if fixAfterControl:
self.fix()
if setUpsilonLambda:
self.workspace.arg('lambda_cont1_FP').setConstant(True)
self.workspace.arg('lambda_cont1_PP').setConstant(True)
vals = {}
errs = {}
integrals = {}
errors = {}
allintegrals = {}
for region in self.REGIONS:
vals[region] = {}
errs[region] = {}
integrals[region] = {}
if region == 'PP' and fixAfterFP and addUpsilon and self.XRANGE[
0] <= 9 and self.XRANGE[1] >= 11:
self.fix()
self.buildModel(region=region,
addUpsilon=addUpsilon,
setUpsilonLambda=setUpsilonLambda,
voigtian=voigtian)
#self.workspace.factory('bg_{}_norm[1,0,2]'.format(region))
for shift in self.BACKGROUNDSHIFTS + ['']:
if shift == '':
v, e, i = self.fitBackground(
region=region,
setUpsilonLambda=setUpsilonLambda,
addUpsilon=addUpsilon,
logy=logy)
vals[region][shift] = v
errs[region][shift] = e
integrals[region][shift] = i
print "\n\n\nVALS, ERRS, INTEGRALS", shift, region,
print "VALS:", v, "\nERRS:", e, "\nINTEGRALS:", i
else:
vUp, eUp, iUp = self.fitBackground(
region=region,
shift=shift + 'Up',
setUpsilonLambda=setUpsilonLambda,
addUpsilon=addUpsilon,
logy=logy)
vDown, eDown, iDown = self.fitBackground(
region=region,
shift=shift + 'Down',
setUpsilonLambda=setUpsilonLambda,
addUpsilon=addUpsilon,
logy=logy)
vals[region][shift + 'Up'] = vUp
errs[region][shift + 'Up'] = eUp
integrals[region][shift + 'Up'] = iUp
vals[region][shift + 'Down'] = vDown
errs[region][shift + 'Down'] = eDown
integrals[region][shift + 'Down'] = iDown
if region == 'PP' and fixAfterFP and addUpsilon and self.XRANGE[
0] <= 9 and self.XRANGE[1] >= 11:
self.fix(False)
# integral
name = 'integral_bg_{}'.format(region)
paramValue = integrals[region]['']
paramShifts = {}
for shift in self.BACKGROUNDSHIFTS:
shiftValueUp = integrals[region][shift + 'Up']
shiftValueDown = integrals[region][shift + 'Down']
paramShifts[shift] = {
'up': shiftValueUp,
'down': shiftValueDown
}
param = Models.Param(
name,
value=paramValue,
shifts=paramShifts,
)
param.build(self.workspace, name)
allintegrals[region], errors[
region] = self.buildComponentIntegrals(region, vals, errs,
integrals)
print "ALL INTEGRALS:", allintegrals[region], "\nERRORS:", errors[
region]
for k, v in allintegrals[region].items():
print k, v
if fixAfterControl:
self.fix(False)
self.background_values = vals
self.background_errors = errs
self.background_integrals = integrals
self.background_integralErrors = errors
self.background_integralValues = allintegrals
def buildSpline(self,
h,
vals,
errs,
integrals,
region='PP',
shifts=[],
**kwargs):
'''
Get the signal spline for a given Higgs mass.
Required arguments:
h = higgs mass
vals = dict with fitted param values
errs = dict with fitted param errors
integrals = dict with integrals for given distribution
The dict should be of the form:
vals = {
'' : vals_central,
'shift0Up': vals_shift0Up,
'shift0Down': vals_shift0Down,
...
}
where vals_central, etc ar the fitted values from "fitSignal"
each shift key to be used should be included in the argument "shifts"
shifts = [
'shift0',
'shift1',
...
]
and similarly for errors and integrals.
'''
fit = kwargs.get(
'fit', False
) # will fit the spline parameters rather than a simple spline
amasses = self.AMASSES
if h > 125: amasses = [a for a in amasses if a not in ['3p6', 4, 6]]
avals = [float(str(x).replace('p', '.')) for x in amasses]
# create parameter splines
params = ['mean', 'width', 'sigma']
splines = {}
for param in params:
name = '{param}_h{h}_{region}'.format(param=param,
h=h,
region=region)
paramMasses = avals
paramValues = [
vals[''][h][a]['{param}_h{h}_a{a}_{region}'.format(
param=param, h=h, a=a, region=region)] for a in amasses
]
paramShifts = {}
for shift in shifts:
shiftValuesUp = [
vals[shift + 'Up'][h][a][
'{param}_h{h}_a{a}_{region}_{shift}Up'.format(
param=param, h=h, a=a, region=region, shift=shift)]
for a in amasses
]
shiftValuesDown = [
vals[shift + 'Down'][h][a][
'{param}_h{h}_a{a}_{region}_{shift}Down'.format(
param=param, h=h, a=a, region=region, shift=shift)]
for a in amasses
]
paramShifts[shift] = {
'up': shiftValuesUp,
'down': shiftValuesDown
}
spline = Models.Spline(
name,
masses=paramMasses,
values=paramValues,
shifts=paramShifts,
)
spline.build(self.workspace, name)
splines[name] = spline
# integral spline
name = 'integral_{}_{}'.format(self.SPLINENAME.format(h=h), region)
paramMasses = avals
paramValues = [integrals[''][h][a] for a in amasses]
paramShifts = {}
for shift in shifts:
shiftValuesUp = [integrals[shift + 'Up'][h][a] for a in amasses]
shiftValuesDown = [
integrals[shift + 'Down'][h][a] for a in amasses
]
paramShifts[shift] = {'up': shiftValuesUp, 'down': shiftValuesDown}
spline = Models.Spline(
name,
masses=paramMasses,
values=paramValues,
shifts=paramShifts,
)
spline.build(self.workspace, name)
splines[name] = spline
# create model
if fit:
print 'Need to reimplement fitting'
raise
else:
model = Models.Voigtian(
self.SPLINENAME.format(h=h), **{
param: '{param}_h{h}_{region}'.format(param=param,
h=h,
region=region)
for param in params
})
model.build(self.workspace, '{}_{}'.format(self.SPLINENAME.format(h=h),
region))
return model