def test_fitresults_multi(method):
"""Fit multiple datasets"""
d1 = Data1D('dx', [1, 2, 3], [4, 2, 2])
d2 = Data1D('dx', [4, 5, 6, 10], [4, 4, 2, 4])
d = DataSimulFit('combined', (d1, d2))
m1 = Const1D()
m1.c0 = 3
m = SimulFitModel('silly', (m1, m1))
fr = fit.Fit(d, m, method=method(), stat=LeastSq()).fit()
fr.datasets = ['ddx', 'ddy']
r = fr._repr_html_()
assert r is not None
assert '<summary>Summary (9)</summary>' in r
assert '<td>const1d.c0</td>' in r
assert '<div class="dataname">Datasets</div><div class="dataval">ddx,ddy</div>' in r
assert '<div class="dataname">Method</div><div class="dataval">{}</div>'.format(fr.methodname) in r
assert '<div class="dataname">Statistic</div><div class="dataval">leastsq</div>' in r
assert '<div class="dataname">Δ statistic</div><div class="dataval">0.142857</div>' in r
assert '<div class="dataname">Number of data points</div><div class="dataval">7</div>' in r
assert '<div class="dataname">Degrees of freedom</div><div class="dataval">6</div>' in r
def setUp(self):
self._old_logger_level = logger.getEffectiveLevel()
logger.setLevel(logging.ERROR)
x = numpy.linspace(1.0, 101., num=101)[0::2]
y1 = [ 1., 5., 2., 4., 7.,11., 9., 8.,12.,18.,12.,11.,13.,12.,13.,
13.,20.,23.,16.,20.,24.,17.,21.,26.,22.,24.,24.,21.,28.,
28.,26.,25.,34.,26.,34.,33.,25.,38.,31.,43.,35.,42.,50.,
41.,43.,47.,57.,53.,60.,46.,54.]
y2 = [ 0., 7., 6., 3., 5., 5., 9.,11.,13., 8.,14.,13.,14.,18.,11.,
15.,17.,26., 15.,19.,25.,30.,15.,29.,16.,25.,27.,29.,36.,
41.,22.,27.,33.,32.,45.,37.,38.,38.,34.,52.,40.,41.,31.,
47.,38.,52.,57.,33.,48.,53.,45.]
y3 = [ 1., 2., 4., 2., 5., 8.,15.,10.,13.,10.,16.,10.,13.,12.,16.,
17.,17.,20., 23.,16.,25.,22.,19.,31.,26.,24.,21.,29.,36.,
30.,33.,30.,37.,27.,36.,32., 42.,44.,39.,30.,40.,33.,39.,
49.,56.,47.,46.,35.,63.,40.,57.]
self.d1 = Data1D('1', x, y1)
self.d2 = Data1D('2', x, y2)
self.d3 = Data1D('3', x, y3)
x = numpy.linspace(-5., 5., 100)
g1, g2 = Gauss1D(), Gauss1D()
g1.fwhm = 1.14
g1.pos = 1.2
g2.fwhm = 4.13
g2.pos = -1.3
numpy.random.seed(0)
y1 = g1(x) + numpy.random.normal(0.0, 0.05, x.shape)
y2 = g2(x) + numpy.random.normal(0.0, 0.05, x.shape)
self.d4 = Data1D('4', x, y1)
self.d5 = Data1D('5', x, y2)
def setUp3(hide_logging):
x = numpy.linspace(1.0, 101., num=101)[0::2]
y1 = [
1., 5., 2., 4., 7., 11., 9., 8., 12., 18., 12., 11., 13., 12., 13.,
13., 20., 23., 16., 20., 24., 17., 21., 26., 22., 24., 24., 21., 28.,
28., 26., 25., 34., 26., 34., 33., 25., 38., 31., 43., 35., 42., 50.,
41., 43., 47., 57., 53., 60., 46., 54.
]
y2 = [
0., 7., 6., 3., 5., 5., 9., 11., 13., 8., 14., 13., 14., 18., 11., 15.,
17., 26., 15., 19., 25., 30., 15., 29., 16., 25., 27., 29., 36., 41.,
22., 27., 33., 32., 45., 37., 38., 38., 34., 52., 40., 41., 31., 47.,
38., 52., 57., 33., 48., 53., 45.
]
y3 = [
1., 2., 4., 2., 5., 8., 15., 10., 13., 10., 16., 10., 13., 12., 16.,
17., 17., 20., 23., 16., 25., 22., 19., 31., 26., 24., 21., 29., 36.,
30., 33., 30., 37., 27., 36., 32., 42., 44., 39., 30., 40., 33., 39.,
49., 56., 47., 46., 35., 63., 40., 57.
]
d1 = Data1D('1', x, y1)
d2 = Data1D('2', x, y2)
d3 = Data1D('3', x, y3)
return d1, d2, d3
def data_simul_fit():
data_one = Data1D("data_one", X_ARRAY, Y_ARRAY, STATISTICAL_ERROR_ARRAY,
SYSTEMATIC_ERROR_ARRAY)
data_two = Data1D("data_two", MULTIPLIER * X_ARRAY, MULTIPLIER * Y_ARRAY,
MULTIPLIER * STATISTICAL_ERROR_ARRAY,
MULTIPLIER * SYSTEMATIC_ERROR_ARRAY)
return DataSimulFit(NAME, (data_one, data_two))
def test_psf1d_kernel_data(caplog):
"""Access the kernel data: subkernel=True"""
k = np.asarray([2, 5, 3])
x = 5 + np.arange(k.size)
d = Data1D('my-kernel', x, k)
m = PSFModel(kernel=d)
dfold = Data1D('fold', np.arange(10), np.zeros(10))
with caplog.at_level(logging.INFO, logger='sherpa'):
ans = m.get_kernel(dfold)
assert len(caplog.records) == 1
r = caplog.record_tuples[0]
assert r[0] == 'sherpa.instrument'
assert r[1] == logging.INFO
assert r[2] == "PSF frac: 1.0"
assert isinstance(ans, Data1D)
assert ans.name == 'kernel'
# integers, so treat as exact
assert (ans.x == np.arange(5, 8)).all()
assert ans.y == pytest.approx(k / k.sum())
assert ans.staterror is None
assert ans.syserror is None
def test_psf1d_combined_v2():
"""See test_psf1d_step_v2"""
smdl = StepLo1D()
smdl.xcut = 100
smdl.ampl = 10
cmdl = Const1D()
cmdl.c0 = -500
imdl = smdl + cmdl
gsmooth = Gauss1D()
psf = PSFModel('psf', gsmooth)
x = np.arange(0, 200, 0.5)
d = Data1D('fake', x, x * 0)
psf.fold(d)
smoothed = psf(imdl)
y = smoothed(x)
# So the output is not easy to describe analytically, hence
# we just check parts of it.
#
assert y[(x >= 19.5) & (x <= 100)] == pytest.approx([-490] * 162, abs=1e-4)
assert y[x >= 119] == pytest.approx([-500] * 162, abs=1e-4)
# check that the x <= 19 values are in ascending order
y1 = y[x <= 19]
assert (y1[1:] > y1[:-1]).all()
def test_psf1d_combined():
"""This is based on
sherpa.models.tests.test_regrid_unit.test_regrid1_works_with_convolution_style
but I wanted to make sure we have an explicit check of the underlying
code.
"""
smdl = StepLo1D()
smdl.xcut = 12.5
smdl.ampl = 10
cmdl = Const1D()
cmdl.c0 = -500
imdl = smdl + cmdl
gsmooth = Gauss1D()
gsmooth.fwhm = 3
psf = PSFModel('psf', gsmooth)
x = np.arange(5, 23, 3)
d = Data1D('fake', x, x * 0)
psf.fold(d)
smoothed = psf(imdl)
y = smoothed(x)
assert y == pytest.approx([-490, -490, -490, -500, -500, -500], rel=7e-3)
def test_psf1d_step_v2():
"""Trying to track down why we have seen different behavior in
test_regrid_unit.py.
"""
smdl = StepLo1D()
smdl.xcut = 100
smdl.ampl = 10
gsmooth = Gauss1D()
psf = PSFModel('psf', gsmooth)
x = np.arange(0, 200, 0.5)
d = Data1D('fake', x, x * 0)
psf.fold(d)
smoothed = psf(smdl)
y = smoothed(x)
# So the output is not easy to describe analytically, hence
# we just check parts of it.
#
assert y[(x >= 19.5) & (x <= 100)] == pytest.approx([10] * 162, abs=1e-4)
assert y[x >= 119] == pytest.approx([0] * 162, abs=1e-4)
# check that the x <= 19 values are in ascending order
y1 = y[x <= 19]
assert (y1[1:] > y1[:-1]).all()
def test_psf1d_kernel_model(caplog):
"""Access the kernel data: subkernel=True"""
k = Box1D()
k.xlow = 1
k.xhi = 3
m = PSFModel(kernel=k)
dfold = Data1D('fold', np.arange(10), np.zeros(10))
with caplog.at_level(logging.INFO, logger='sherpa'):
ans = m.get_kernel(dfold)
assert len(caplog.records) == 1
r = caplog.record_tuples[0]
assert r[0] == 'sherpa.instrument'
assert r[1] == logging.INFO
assert r[2] == "PSF frac: 1.0"
assert isinstance(ans, Data1D)
assert ans.name == 'kernel'
# integers, so treat as exact
assert (ans.x == np.arange(10)).all()
# box1D between 1 and 3 inclusive
y = np.asarray([0, 1, 1, 1, 0, 0, 0, 0, 0, 0])
assert ans.y == pytest.approx(y / y.sum())
assert ans.staterror is None
assert ans.syserror is None
def test_psf1d_model_show():
"""What happens when the kernel is a model?"""
box1 = make_1d_model()
m = PSFModel("pmodel1", box1)
dfold = Data1D('fold', np.arange(10), np.zeros(10))
m.fold(dfold)
out = str(m).split("\n")
assert len(out) == 8
assert out[0] == "pmodel1"
assert out[
1] == " Param Type Value Min Max Units"
assert out[
2] == " ----- ---- ----- --- --- -----"
assert out[3] == " pmodel1.kernel frozen box1"
assert out[
4] == " pmodel1.size frozen 10 10 10"
assert out[
5] == " pmodel1.center frozen 5 5 5"
assert out[
6] == " pmodel1.radial frozen 0 0 1 "
assert out[
7] == " pmodel1.norm frozen 1 0 1 "
def test_manual_setting_mask():
d = Data1D(name='test', x=[1, 2, 3], y=[0, 0, 0])
d.mask = True
assert len(d.get_dep(filter=True)) == 3
d.mask = False
# This test looks like it does not do anything, but in fact "mask"
# is a property with complext logic, so the fact that setting it to
# False makes is False is non-trivial.
# I don't want to test for
# len(d.get_dep(filter=True)) == 0
# because the get_dep raises and error when no data is noticed
# and I don't want to test get_dep here, but the fact that setting
# the mask itself works.
assert d.mask is False
d.mask = [True, False, True]
assert len(d.get_dep(filter=True)) == 2
arr = numpy.ma.array([3, 4, 5])
d.mask = arr.mask # aka numpy.ma.nomask, but used in a more
# natural way
assert len(d.get_dep(filter=True)) == 3
with pytest.raises(DataErr) as e:
d.mask = None
assert 'True, False, or a mask array' in str(e.value)
def test_regrid_binaryop_1d(reset_seed):
"""issue #762, Cannot regrid a composite model (BinaryOpModel)"""
np.random.seed(0)
leastsq = LeastSq()
levmar = LevMar()
mygauss = MyGauss()
myconst = MyConst1D()
mymodel = mygauss + myconst
x = np.linspace(-5., 5., 5)
err = 0.25
y = mymodel(x) + np.random.normal(mygauss.pos.val, err, x.shape)
mygauss.counter = 0
myconst.counter = 0
data = Data1D('one', x, y)
fit = Fit(data, mymodel, leastsq, levmar)
result = fit.fit()
assert result.numpoints == x.size
assert result.statval < 1.0
assert mygauss.counter == myconst.counter
assert (result.nfev + 4) * x.size == mygauss.counter
mygauss.counter = 0
myconst.counter = 0
x_regrid = np.linspace(-5., 5., 25)
mymodel_regrid = mymodel.regrid(x_regrid)
fit = Fit(data, mymodel_regrid, leastsq, levmar)
result = fit.fit()
assert result.numpoints == x.size
assert result.statval < 1.0
assert mygauss.counter == myconst.counter
assert (result.nfev + 4) * x_regrid.size == mygauss.counter
def test_errresults_limits_interval():
"""Missing an error limit"""
d = Data1D('dx', [1, 2, 3], [4, 2, 2], [1.2, 0.9, 0.9])
m = Const1D()
m.c0 = 3
f = fit.Fit(d, m, stat=Chi2())
er = f.est_errors()
# perhaps should just fake this instead?
assert len(er.parmaxes) == 1
er.parmaxes = ([0.1, 0.2], )
r = er._repr_html_()
assert r is not None
print(r)
assert '<summary>covariance 1σ (68.2689%) bounds</summary>' in r
assert '<summary>Summary (2)' in r
assert '<td>const1d.c0</td>' in r
assert '<div class="dataname">Fitting Method</div><div class="dataval">levmar</div>' in r
assert '<div class="dataname">Statistic</div><div class="dataval">chi2</div>' in r
assert '<tr><td>const1d.c0</td><td> 3</td><td> -0.562226</td><td>(1.000000e-01, 2.000000e-01)</td></tr>' in r
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_errors_with_no_stat():
"""Check we get no errors when stat is None"""
d = Data1D('x', numpy.asarray([2, 4, 10]), numpy.asarray([2, 4, 0]))
dp = sherpaplot.DataPlot()
dp.prepare(d, stat=None)
assert dp.yerr is None
def test_intproj(old_numpy_printing, override_plot_backend):
p = plot.IntervalProjection()
r = p._repr_html_()
check_empty(r, 'IntervalProjection', nsummary=8)
x = np.arange(5, 8, 0.5)
y = np.asarray([2, 3, 4, 5, 4, 3])
dy = y / 2
d = Data1D('n n', x, y, staterror=dy)
m = Const1D()
fit = Fit(d, m, stat=Chi2())
fr = fit.fit()
assert fr.succeeded
p.prepare(min=1, max=6, nloop=10)
p.calc(fit, m.c0)
r = p._repr_html_()
assert r is not None
if plot.backend.name == 'pylab':
assert '<summary>IntervalProjection</summary>' in r
assert '<svg ' in r
return
assert '<summary>IntervalProjection (8)</summary>' in r
assert '<div class="dataname">x</div><div class="dataval">[ 1. 1.555556 2.111111 2.666667 3.222222 3.777778 4.333333 4.888889\n 5.444444 6. ]</div>' in r
assert '<div class="dataname">nloop</div><div class="dataval">10</div>' in r
def call(self, niter, seed):
pars = {}
pars_index = {}
index = 0
for par in self.model.pars:
if par.frozen is False:
name = '%s.%s' % (par.modelname, par.name)
pars_index[index] = name
pars[name] = []
index += 1
data = self.data
y = data.y
x = data.x
if type(data) == Data1DAsymmetricErrs:
y_l = y - data.elo
y_h = y + data.ehi
elif isinstance(data, (Data1D,)):
y_l = data.staterror
y_h = data.staterror
else:
msg ="{0} {1}".format(ReSampleData.__name__, type(data))
raise NotImplementedError(msg)
numpy.random.seed(seed)
for j in range(niter):
ry = []
for i in range(len(y_l)):
a = y_l[i]
b = y_h[i]
r = -1
while r < a or r > b:
sigma = b - y[i]
u = numpy.random.random_sample()
if u < 0.5:
sigma=y[i]-a
r = numpy.random.normal(loc=y[i],scale=sigma,size=None)
if u < 0.5 and r > y[i]:
r = -1
if u > 0.5 and r < y[i]:
r = -1
ry.append(r)
# fit is performed for each simulated data point
fit = Fit(Data1D('tmp', x, ry), self.model, LeastSq( ), LevMar())
fit_result = fit.fit()
for index, val in enumerate(fit_result.parvals):
name = pars_index[index]
pars[name].append(val)
result = {}
for index, name in pars_index.items():
avg = numpy.average(pars[name])
std = numpy.std(pars[name])
print(name, ': avg =', avg, ', std =', std)
result[name] = pars[name]
return result
def test_low_level_regrid1d_partial_overlap(requested):
"""What happens if there is partial overlap of the grid?
The question becomes how do we evaluate the model
"outside" the regrid range. There's at least two
options:
a) set to 0
b) use the original grid
This test is chosen so that it holds with both
possibilities: the model evaluates to 0 outside
of x=3.1 - 4.2, and the partial overlaps are
carefully chosen to always include this full
range.
See https://github.com/sherpa/sherpa/issues/722
"""
# The range over which we want the model evaluated
xgrid = np.arange(2, 6, 0.1)
d = Data1D('tst', xgrid, np.ones_like(xgrid))
mdl = Box1D()
mdl.xlow = 3.1
mdl.xhi = 4.2
mdl.ampl = 0.4
yexpected = d.eval_model(mdl)
assert yexpected.min() == pytest.approx(0.0)
assert yexpected.max() == pytest.approx(0.4)
ygot = d.eval_model(mdl.regrid(requested))
assert ygot == pytest.approx(yexpected)
def test_fit(override_plot_backend):
p = plot.FitPlot()
r = p._repr_html_()
assert r is None # note: always None
x = np.arange(5, 8, 0.5)
y = np.ones(x.size)
d = Data1D('n n', x, y)
m = Const1D()
dplot = plot.DataPlot()
dplot.prepare(d)
mplot = plot.ModelPlot()
mplot.prepare(d, m)
p.prepare(dplot, mplot)
r = p._repr_html_()
# different to previous checks
assert r is not None
if plot.backend.name == 'pylab':
assert '<summary>FitPlot</summary>' in r
assert '<svg ' in r
return
assert '<summary>DataPlot (' in r
assert '<summary>ModelPlot (' in r
assert '<div class="dataval">n n</div>' in r
assert '<div class="dataval">Model</div>' in r
def test_parallel_map_funcs2():
def tst(ncores, sg, stat, opt):
sd = DataSimulFit('sd', [d, d], numcores=2)
f = Fit(sd, sg, stat, opt)
result = f.fit()
return result
def cmp_results(result, tol=1.0e-3):
assert result.succeeded
parvals = (1.7555670572301785, 1.5092728216164186, 4.893136872267538)
assert result.numpoints == 200
# use tol in approx?
assert result.parvals == pytest.approx(parvals)
numpy.random.seed(0)
x = numpy.linspace(-5., 5., 100)
ampl = 5
pos = 1.5
sigma = 0.75
err = 0.25
y = ampl * numpy.exp(-0.5 * (x - pos)**2 / sigma**2)
y += numpy.random.normal(0., err, x.shape)
d = Data1D('junk', x, y)
g = Gauss1D()
opt = LevMar()
stat = LeastSq()
sg = SimulFitModel('sg', [g, g])
result = tst(1, sg, stat, opt)
cmp_results(result)
result = tst(2, sg, stat, opt)
cmp_results(result)
def test_runtime_interp():
def tst_runtime_interp(model, requested, interp):
regrid_model = mdl.regrid(requested, interp=interp)
yregrid = regrid_model(xgrid)
return yregrid
xgrid = np.arange(2, 6, 0.1)
requested = np.arange(2.5, 5.1, 0.075)
mdl = Box1D()
mdl.xlow = 3.1
mdl.xhi = 4.2
mdl.ampl = 0.4
yregrid = tst_runtime_interp(mdl, requested, akima.akima)
assert 4.4 == approx(yregrid.sum())
yregrid = tst_runtime_interp(mdl, requested, linear_interp)
assert 4.4 == approx(yregrid.sum())
yregrid = tst_runtime_interp(mdl, requested, neville)
assert -5.0e6 > yregrid.sum()
d = Data1D('tst', xgrid, np.ones_like(xgrid))
yexpected = d.eval_model(mdl)
requested = np.arange(2.5, 7, 0.2)
rmdl = mdl.regrid(requested)
ygot = d.eval_model(rmdl)
assert ygot == approx(yexpected)
def setUp(self):
# defensive programming (one of the tests has been seen to fail
# when the whole test suite is run without this)
ui.clean()
self._old_logger_level = logger.getEffectiveLevel()
logger.setLevel(logging.ERROR)
self.data = Data1D('tst', self._x, self._y, self._e)
self.mdl = Polynom1D('mdl')
def test_wrong_kwargs():
xgrid = np.arange(2, 6, 0.1)
d = Data1D('tst', xgrid, np.ones_like(xgrid))
mdl = Box1D()
requested = np.arange(1, 7, 0.1)
with pytest.raises(TypeError) as excinfo:
ygot = d.eval_model(mdl.regrid(requested, fubar='wrong_kwargs'))
assert "unknown keyword argument: 'fubar'" in str(excinfo.value)
def setUp(hide_logging):
x = [-13, -5, -3, 2, 7, 12]
y = np.asarray([102.3, 16.7, -0.6, -6.7, -9.9, 33.2])
err = np.ones(6) * 5
data = Data1D('tst', x, y, err)
mdl = Polynom1D('mdl')
return data, mdl
def setUp2(hide_logging, reset_seed):
x = numpy.linspace(-5., 5., 100)
g1, g2 = Gauss1D(), Gauss1D()
g1.fwhm = 1.14
g1.pos = 1.2
g2.fwhm = 4.13
g2.pos = -1.3
numpy.random.seed(0)
y1 = g1(x) + numpy.random.normal(0.0, 0.05, x.shape)
y2 = g2(x) + numpy.random.normal(0.0, 0.05, x.shape)
d4 = Data1D('4', x, y1)
d5 = Data1D('5', x, y2)
return d4, d5
def test_psf1d_show():
"""Test the __str__ method
Loop through basic data and then add in the options
(but not all possible combinations).
"""
def check(x, n, ans):
toks = x[n].split()
assert toks == ans
NAME = ['psfmodel']
PARAMS = ['Param', 'Type', 'Value', 'Min', 'Max', 'Units']
LINES = ['-----', '----', '-----', '---', '---', '-----']
KERNEL = ['psfmodel.kernel', 'frozen', 'oned']
SIZE = ['psfmodel.size', 'frozen', '7', '7', '7']
CENTER = ['psfmodel.center', 'frozen', '3', '3', '3']
RADIAL = ['psfmodel.radial', 'frozen', '0', '0', '1']
NORM = ['psfmodel.norm', 'frozen', '1', '0', '1']
m = PSFModel()
# basic settings
out = str(m).split('\n')
assert len(out) == 5
check(out, 0, NAME)
check(out, 1, PARAMS)
check(out, 2, LINES)
check(out, 3, RADIAL)
check(out, 4, NORM)
m.kernel = make_1d_data()
# before a fold you don't get the size and center parameters
out = str(m).split('\n')
assert len(out) == 6
check(out, 0, NAME)
check(out, 1, PARAMS)
check(out, 2, LINES)
check(out, 3, KERNEL)
check(out, 4, RADIAL)
check(out, 5, NORM)
dfold = Data1D('fold', np.arange(10), np.zeros(10))
m.fold(dfold)
out = str(m).split('\n')
assert len(out) == 8
check(out, 0, NAME)
check(out, 1, PARAMS)
check(out, 2, LINES)
check(out, 3, KERNEL)
check(out, 4, SIZE)
check(out, 5, CENTER)
check(out, 6, RADIAL)
check(out, 7, NORM)
def test_psf1d_fold_no_kernel():
"""Error out if there's no kernel"""
m = PSFModel('bob')
dfold = Data1D('fold', np.arange(10), np.zeros(10))
with pytest.raises(PSFErr) as exc:
m.fold(dfold)
assert "model 'bob' does not have an associated PSF function" == str(exc.value)
def test_cache():
"""To make sure that the runtime fit(cache=???) works"""
x = np.array([1.0, 2.0, 3.0])
model = MyCacheTestModel()
par = np.array([1.1, 2.0, 3.0])
y = model.calc(par, x)
data = Data1D('tmp', x, y)
fit = Fit(data, model, LeastSq())
fit.fit(cache=False)
def make_data(data_class):
"""Create a test data object of the given class.
Using a string means it is easier to support the various PHA
"types" - eg basic, grouping, grouping+quality.
"""
x0 = np.asarray([1, 3, 7, 12])
y = np.asarray([2, 3, 4, 5])
if data_class == "1d":
return Data1D('x1', x0, y)
if data_class == "1dint":
return Data1DInt('xint1', x0, np.asarray([3, 5, 8, 15]), y)
chans = np.arange(1, 5)
if data_class == "pha":
return DataPHA('pha', chans, y)
# We want to provide PHA tests that check out the grouping and
# quality handling (but it is not worth trying all different
# variants), so we have "grp" for grouping and no quality [*], and
# "qual" for grouping and quality.
#
# [*] by which I mean we have not called ignore_bad, not that
# there is no quality array.
#
grp = np.asarray([1, -1, 1, 1])
qual = np.asarray([0, 0, 2, 0])
pha = DataPHA('pha', chans, y, grouping=grp, quality=qual)
if data_class == "grp":
return pha
if data_class == "qual":
pha.ignore_bad()
return pha
x0 = np.asarray([1, 2, 3] * 2)
x1 = np.asarray([1, 1, 1, 2, 2, 2])
y = np.asarray([2, 3, 4, 5, 6, 7])
if data_class == "2d":
return Data2D('x2', x0, x1, y, shape=(2, 3))
if data_class == "2dint":
return Data2DInt('xint2', x0, x1, x0 + 1, x1 + 1, y, shape=(2, 3))
if data_class == "img":
return DataIMG('img', x0, x1, y, shape=(2, 3))
if data_class == "imgint":
return DataIMGInt('imgi', x0, x1, x0 + 1, x1 + 1, y, shape=(2, 3))
assert False
def test_data(override_plot_backend):
p = plot.DataPlot()
r = p._repr_html_()
check_full(r, 'DataPlot', 'None', 'None', nsummary=7) # NOT empty
x = np.arange(5, 8, 0.5)
y = np.ones(x.size)
dr = y / 0.1
d = Data1D('n n', x, y, staterror=dr)
p.prepare(d)
r = p._repr_html_()
check_full(r, 'DataPlot', 'y', 'n n', nsummary=7)