def test_get_bkg_fit_plot(idval):
"""Basic testing of get_bkg_fit_plot
"""
setup_example_bkg_model(idval)
if idval is None:
fp = ui.get_bkg_fit_plot()
else:
fp = ui.get_bkg_fit_plot(idval)
dp = fp.dataplot
mp = fp.modelplot
assert dp.title == 'example-bkg'
assert mp.title == 'Background Model Contribution'
for plot in [dp, mp]:
assert plot.xlabel == 'Channel'
assert plot.ylabel == 'Counts/sec/channel'
assert plot.x == pytest.approx(_data_chan)
yexp = _data_bkg / 1201.0 / _bexpscale
assert dp.y == pytest.approx(dp.y)
yexp = _arf / 100.0 / _bexpscale
assert mp.y == pytest.approx(yexp)
def test_get_bkg_fit_plot_energy(idval):
"""Basic testing of get_bkg_fit_plot: energy
"""
setup_example_bkg_model(idval)
if idval is None:
ui.set_analysis('energy')
ui.get_bkg().units = 'energy'
fp = ui.get_bkg_fit_plot()
else:
ui.set_analysis(idval, 'energy')
ui.get_bkg(idval).units = 'energy'
fp = ui.get_bkg_fit_plot(idval)
dp = fp.dataplot
mp = fp.modelplot
assert dp.title == 'example-bkg'
assert mp.title == 'Background Model Contribution'
for plot in [dp, mp]:
assert plot.xlabel == 'Energy (keV)'
assert plot.ylabel == 'Counts/sec/keV'
assert plot.x == pytest.approx(_data_chan)
yexp = _data_bkg / 1201.0 / _bexpscale
assert dp.y == pytest.approx(dp.y)
yexp = _arf / 100.0 / _bexpscale
assert mp.y == pytest.approx(yexp)
def fit(self):
# try a PCA decomposition of this spectrum
initial = self.decompose()
ui.set_method('neldermead')
bkgmodel = PCAModel('pca%s' % self.id, data=self.pca)
self.bkgmodel = bkgmodel
response = get_identity_response(self.id)
convbkgmodel = response(bkgmodel)
ui.set_bkg_full_model(self.id, convbkgmodel)
for p, v in zip(bkgmodel.pars, initial):
p.val = v
srcmodel = ui.get_model(self.id)
ui.set_full_model(self.id, srcmodel)
initial_v = self.calc_bkg_stat()
# print('before fit: stat: %s' % (initial_v))
ui.fit_bkg(id=self.id)
# print('fit: first full fit done')
final = [p.val for p in ui.get_bkg_model(self.id).pars]
# print('fit: parameters: %s' % (final))
initial_v = self.calc_bkg_stat()
# print('fit: stat: %s' % (initial_v))
# lets try from zero
# logf.info('fit: second full fit from zero')
for p in bkgmodel.pars:
p.val = 0
ui.fit_bkg(id=self.id)
initial_v0 = self.calc_bkg_stat()
# logf.info('fit: parameters: %s' % (final))
# logf.info('fit: stat: %s' % (initial_v0))
# pick the better starting point
if initial_v0 < initial_v:
# logf.info('fit: using zero-fit')
initial_v = initial_v0
final = [p.val for p in ui.get_bkg_model(self.id).pars]
else:
# logf.info('fit: using decomposed-fit')
for p, v in zip(bkgmodel.pars, final):
p.val = v
# start with the full fit and remove(freeze) parameters
print('%d parameters, stat=%.2f' % (len(initial), initial_v))
results = [(2 * len(final) + initial_v, final, len(final), initial_v)]
for i in range(len(initial) - 1, 0, -1):
bkgmodel.pars[i].val = 0
bkgmodel.pars[i].freeze()
ui.fit_bkg(id=self.id)
final = [p.val for p in ui.get_bkg_model(self.id).pars]
v = self.calc_bkg_stat()
print('--> %d parameters, stat=%.2f' % (i, v))
results.insert(0, (v + 2 * i, final, i, v))
print()
print('Background PCA fitting AIC results:')
print('-----------------------------------')
print()
print('stat Ncomp AIC')
for aic, params, nparams, val in results:
print('%-05.1f %2d %-05.1f' % (val, nparams, aic))
aic, final, nparams, val = min(results)
for p, v in zip(bkgmodel.pars, final):
p.val = v
for i in range(nparams):
bkgmodel.pars[i].thaw()
print()
print('Increasing parameters again...')
# now increase the number of parameters again
# results = [(aic, final, nparams, val)]
last_aic, last_final, last_nparams, last_val = aic, final, nparams, val
for i in range(last_nparams, len(bkgmodel.pars)):
next_nparams = i + 1
bkgmodel.pars[i].thaw()
for p, v in zip(bkgmodel.pars, last_final):
p.val = v
ui.fit_bkg(id=self.id)
next_final = [p.val for p in ui.get_bkg_model(self.id).pars]
v = self.calc_bkg_stat()
next_aic = v + 2 * next_nparams
if next_aic < last_aic: # accept
print('%d parameters, aic=%.2f ** accepting' %
(next_nparams, next_aic))
last_aic, last_final, last_nparams, last_val = next_aic, next_final, next_nparams, v
else:
print('%d parameters, aic=%.2f' % (next_nparams, next_aic))
# stop if we are 3 parameters ahead what we needed
if next_nparams >= last_nparams + 3:
break
print('Final choice: %d parameters, aic=%.2f' %
(last_nparams, last_aic))
# reset to the last good solution
for p, v in zip(bkgmodel.pars, last_final):
p.val = v
last_model = convbkgmodel
for i in range(10):
print('Adding Gaussian#%d' % (i + 1))
# find largest discrepancy
ui.set_analysis(self.id, "ener", "rate")
m = ui.get_bkg_fit_plot(self.id)
y = m.dataplot.y.cumsum()
z = m.modelplot.y.cumsum()
diff_rate = np.abs(y - z)
ui.set_analysis(self.id, "ener", "counts")
m = ui.get_bkg_fit_plot(self.id)
x = m.dataplot.x
y = m.dataplot.y.cumsum()
z = m.modelplot.y.cumsum()
diff = np.abs(y - z)
i = np.argmax(diff)
energies = x
e = x[i]
print(
'largest remaining discrepancy at %.3fkeV[%d], need %d counts'
% (x[i], i, diff[i]))
# e = x[i]
power = diff_rate[i]
# lets try to inject a gaussian there
g = ui.xsgaussian('g_%d_%d' % (self.id, i))
print('placing gaussian at %.2fkeV, with power %s' % (e, power))
# we work in energy bins, not energy
g.LineE.min = energies[0]
g.LineE.max = energies[-1]
g.LineE.val = e
if i > len(diff) - 2:
i = len(diff) - 2
if i < 2:
i = 2
g.Sigma = (x[i + 1] - x[i - 1])
g.Sigma.min = (x[i + 1] - x[i - 1]) / 3
g.Sigma.max = x[-1] - x[0]
g.norm.min = power * 1e-6
g.norm.val = power
convbkgmodel2 = response(g)
next_model = last_model + convbkgmodel2
ui.set_bkg_full_model(self.id, next_model)
ui.fit_bkg(id=self.id)
next_final = [p.val for p in ui.get_bkg_model(self.id).pars]
next_nparams = len(next_final)
v = self.calc_bkg_stat()
next_aic = v + 2 * next_nparams
print('with Gaussian:', next_aic,
'; change: %.1f (negative is good)' % (next_aic - last_aic))
if next_aic < last_aic:
print('accepting')
last_model = next_model
last_aic, last_final, last_nparams, last_val = next_aic, next_final, next_nparams, v
else:
print('not significant, rejecting')
ui.set_bkg_full_model(self.id, last_model)
for p, v in zip(last_model.pars, last_final):
p.val = v
if v == 0: # the parameter was frozen.
ui.freeze(p)
break
self.cstat, self.dof = self.calc_bkg_stat(
dof=True) # Save the final cstat and dof (dof = ihi - ilo)
self.filter_energy = ui.get_filter(
) # Save the filter for background fitting.
ui.set_analysis('channel')
ui.ignore()
ui.notice(self.filter0) # restore filter
ui.set_analysis('energy')