def my_simulstat(self, data, model, *args, **kwargs):
tofit = data.to_fit(staterrfunc=self.calc_staterror)
modeldata = data.eval_model_to_fit(model)
fitdata = tofit[0]
staterror = tofit[1]
fvec = numpy.power((fitdata - modeldata) / staterror, 2)
stat = numpy.sum(fvec)
mstat = 0.0
mfvec = []
# It is not clear what separating the data sets does
# here, based on the original my_simulsat code.
#
stats = [Chi2DataVar(), Chi2DataVar()]
for mystat, dset, mexpr in zip(stats, data.datasets, model.parts):
thisstat, thisvec = mystat.calc_stat(dset, mexpr)
mstat += thisstat
mfvec.append(thisvec)
# return (mstat, numpy.concatenate(mfvec))
return (stat, fvec)
def setup():
data = Data1D('fake', _x, _y, _err)
g1 = Gauss1D('g1')
g1.fwhm.set(1.0, _tiny, _max, frozen=False)
g1.pos.set(1.0, -_max, _max, frozen=False)
g1.ampl.set(1.0, -_max, _max, frozen=False)
p1 = PowLaw1D('p1')
p1.gamma.set(1.0, -10, 10, frozen=False)
p1.ampl.set(1.0, 0.0, _max, frozen=False)
p1.ref.set(1.0, -_max, _max, frozen=True)
model = p1 + g1
method = LevMar()
method.config['maxfev'] = 10000
method.config['ftol'] = float(_eps)
method.config['epsfcn'] = float(_eps)
method.config['gtol'] = float(_eps)
method.config['xtol'] = float(_eps)
method.config['factor'] = float(100)
fit = Fit(data, model, Chi2DataVar(), method, Covariance())
results = fit.fit()
for key in ["succeeded", "numpoints", "nfev"]:
assert _fit_results_bench[key] == int(getattr(results, key))
for key in ["rstat", "qval", "statval", "dof"]:
# used rel and abs tol of 1e-7 with numpy allclose
assert float(getattr(results,
key)) == pytest.approx(_fit_results_bench[key])
for key in ["parvals"]:
try:
# used rel and abs tol of 1e-4 with numpy allclose
assert getattr(results,
key) == pytest.approx(_fit_results_bench[key])
except AssertionError:
print('parvals bench: ', _fit_results_bench[key])
print('parvals fit: ', getattr(results, key))
print('results', results)
raise
fields = [
'data', 'model', 'method', 'fit', 'results', 'covresults', 'dof', 'mu',
'num'
]
out = namedtuple('Results', fields)
out.data = data
out.model = model
out.method = method
out.fit = fit
out.results = results
out.covresults = fit.est_errors()
out.dof = results.dof
out.mu = numpy.array(results.parvals)
out.cov = numpy.array(out.covresults.extra_output)
out.num = 10
return out
def test_chisquare():
"""Is the chi square correct?
This uses the data-variance calculation.
"""
dset = setup_basic_dataset()
dset.ignore_bad()
cpt1 = Const1D()
cpt2 = StepHi1D()
cpt1.c0 = 20
cpt2.ampl = 20
cpt2.xcut = 6.5
mdl = cpt1 + cpt2
# Since the model does not contain a *PHA instrument model
# it will not include the area-scaling, so the data and
# errors should not be scaled.
#
scale = False
counts = expected_basic_counts(scale=scale)[1:]
errors = expected_basic_chisquare_errors(scale=scale)
mvals = mdl(dset.channel[1:])
expected = (counts - mvals)**2 / (errors**2)
expected = expected.sum()
stat = Chi2DataVar()
sval = stat.calc_stat(dset, mdl)
assert_allclose(sval[0], expected)
def test_get_yerr_scaling_bgnd():
"""What does get_yerr return when bgnd is subtracted.
This expands on test_get_yerr_bgnd by having different
BACKSCAL and EXPOSURE values in the source and background
data sets.
"""
dset = setup_basic_dataset_bgnd()
dset.exposure = 20.0
dset.backscal = 0.01
dset.ignore_bad()
dset.subtract()
bset = dset.get_background()
bset.exposure = 15.0
bset.backscal = 0.1
stat = Chi2DataVar()
errors = dset.get_yerr(filter=True,
staterrfunc=stat.calc_staterror)
expected = expected_basic_chisquare_errors_scaling_bgnd(scale=True)
expected = expected / dset.exposure
assert errors == pytest.approx(expected)
def my_simulstat(data, model, staterror, *args, **kwargs):
data_size = kwargs['extra_args']['data_size']
data1 = data[:data_size[0]]
data2 = data[data_size[0]:]
model1 = model[:data_size[0]]
model2 = model[data_size[0]:]
staterror1 = staterror[:data_size[0]]
staterror2 = staterror[data_size[0]:]
mystat1 = Chi2DataVar()
mystat2 = Chi2DataVar()
stat1, fvec1 = mystat1.calc_stat(data1, model1, staterror1)
stat2, fvec2 = mystat2.calc_stat(data2, model2, staterror2)
fvec = numpy.power((data - model) / staterror, 2)
stat = numpy.sum(fvec)
# print stat1 + stat2 - stat
return (stat, fvec)
return (stat1 + stat2, numpy.append(fvec1, fvec2))
def test_get_yerr():
"""What does get_yerr return?
This uses the data-variance calculation.
"""
dset = setup_basic_dataset()
dset.ignore_bad()
stat = Chi2DataVar()
errors = dset.get_yerr(filter=True, staterrfunc=stat.calc_staterror)
expected = expected_basic_chisquare_errors(scale=True)
assert_allclose(errors, expected)
def test_get_yerr_bgnd():
"""What does get_yerr return when bgnd is subtracted.
This is the easy case, since BACKSCAL and EXPOSURE are 1.
"""
dset = setup_basic_dataset_bgnd()
dset.ignore_bad()
dset.subtract()
stat = Chi2DataVar()
errors = dset.get_yerr(filter=True, staterrfunc=stat.calc_staterror)
expected = expected_basic_chisquare_errors_bgnd(scale=True)
assert_allclose(errors, expected)
def test_get_yerr_no_bgnd():
"""What does get_yerr return when bgnd is not subtracted.
This is the same as test_get_yerr, as the background is
ignored in this case.
"""
dset = setup_basic_dataset_bgnd()
dset.ignore_bad()
stat = Chi2DataVar()
errors = dset.get_yerr(filter=True, staterrfunc=stat.calc_staterror)
expected = expected_basic_chisquare_errors(scale=True)
assert_allclose(errors, expected)
def setUp(self):
data = Data1D('fake', self._x, self._y, self._err)
g1 = Gauss1D('g1')
g1.fwhm.set(1.0, _tiny, _max, frozen=False)
g1.pos.set(1.0, -_max, _max, frozen=False)
g1.ampl.set(1.0, -_max, _max, frozen=False)
p1 = PowLaw1D('p1')
p1.gamma.set(1.0, -10, 10, frozen=False)
p1.ampl.set(1.0, 0.0, _max, frozen=False)
p1.ref.set(1.0, -_max, _max, frozen=True)
model = p1 + g1
method = LevMar()
method.config['maxfev'] = 10000
method.config['ftol'] = float(_eps)
method.config['epsfcn'] = float(_eps)
method.config['gtol'] = float(_eps)
method.config['xtol'] = float(_eps)
method.config['factor'] = float(100)
self.fit = Fit(data, model, Chi2DataVar(), method, Covariance())
results = self.fit.fit()
for key in ["succeeded", "numpoints", "nfev"]:
assert self._fit_results_bench[key] == int(getattr(results, key))
for key in ["rstat", "qval", "statval", "dof"]:
assert numpy.allclose(float(self._fit_results_bench[key]),
float(getattr(results, key)),
1.e-7, 1.e-7)
for key in ["parvals"]:
try:
assert numpy.allclose(self._fit_results_bench[key],
getattr(results, key),
1.e-4, 1.e-4)
except AssertionError:
print('parvals bench: ', self._fit_results_bench[key])
print('parvals fit: ', getattr(results, key))
print('results', results)
raise
covresults = self.fit.est_errors()
self.dof = results.dof
self.mu = numpy.array(results.parvals)
self.cov = numpy.array(covresults.extra_output)
self.num = 10
def test_ignore_ylog_kwarg(plottype):
"""Do the "residual" style plots ignore the ylog keyword argument?"""
from matplotlib import pyplot as plt
data = Data1D('tst', np.asarray([1, 2, 3]), np.asarray([10, 12, 10.5]))
mdl = Const1D('tst-model')
mdl.c0 = 11.1
plot = plottype()
plot.prepare(data, mdl, stat=Chi2DataVar())
plot.plot(xlog=True, ylog=True)
fig = plt.gcf()
assert len(fig.axes) == 1
ax = plt.gca()
assert ax.get_xscale() == 'log'
assert ax.get_yscale() == 'linear'
