def test_more_ui_string_model_with_rmf(make_data_path):
ui.load_pha("foo", make_data_path('pi2286.fits'))
ui.load_rmf("foo", make_data_path('rmf2286.fits'))
# Check that get_rmf(id)('modelexpression') works. If it
# raises an error the test will fail.
#
m = ui.get_rmf("foo")("powlaw1d.pl1")
assert isinstance(m, RMFModelPHA)
def test_string_model_with_rmf(self):
ui.load_pha("foo", self.pha)
ui.load_rmf("foo", self.rmf)
# Check that get_rmf(id)('modelexpression') works
caught = False
try:
m = ui.get_rmf("foo")("powlaw1d.pl1")
except:
caught = True
if caught:
self.fail("Exception caught when it shouldn't")
from sherpa.astro.instrument import RMFModelPHA
self.assertTrue(isinstance(m, RMFModelPHA))
def test_string_model_with_rmf(self):
ui.load_pha("foo", self.pha)
ui.load_rmf("foo", self.rmf)
# Check that get_rmf(id)('modelexpression') works
caught = False
try:
m = ui.get_rmf("foo")("powlaw1d.pl1")
except:
caught = True
if caught:
self.fail("Exception caught when it shouldn't")
from sherpa.astro.instrument import RMFModelPHA
self.assertTrue(isinstance(m, RMFModelPHA))
def test_missmatch_arf(make_data_path):
ui.load_pha(1, make_data_path("source1.pi"))
ui.load_bkg(1, make_data_path("back1.pi"))
ui.load_arf(1, make_data_path("arf_1024.fits"))
ui.load_rmf(1, make_data_path("rmf_1024.fits"))
ui.set_method('levmar')
ui.set_model(ui.powlaw1d.p1 * ui.xswabs.abs1)
ui.set_par('p1.ampl', 0.0001)
ui.set_stat('cash')
ui.fit()
parvals = ui.get_fit_results().parvals
assert parvals[0] == approx(1.47969, rel=1.0e-3)
assert parvals[1] == approx(0.0019491, rel=1.0e-3)
assert parvals[2] == approx(2.35452, rel=1.0e-3)
def test_can_use_pspc_data(make_data_path):
"""A basic check that we can read in and use the ROSAT PSPC data.
Unlike the previous tests, that directly access the io module,
this uses the ui interface.
"""
if not six.PY2 and (backend == "crates"):
pytest.skip('Python3 and Crates: known to fail')
# The PSPC PHA file does not have the ANCRFILE/RESPFILE keywords
# set up, so the responses has to be manually added.
#
ui.load_pha(make_data_path(PHAFILE), use_errors=True)
assert ui.get_analysis() == 'channel'
ui.load_rmf(make_data_path(RMFFILE))
assert ui.get_analysis() == 'energy'
ui.set_source(ui.powlaw1d.pl)
ui.set_par('pl.gamma', 1.7)
ui.set_par('pl.ampl', 2e-6)
s = ui.get_stat_info()[0]
assert s.numpoints == 63
assert s.dof == 61
# Value obtained from XSPEC 12.9.1p; Sherpa returns
# sexpected = 973.2270845920297
sexpected = 973.23
assert_allclose(s.statval, sexpected, rtol=0, atol=0.005)
# apply an energy filter to remove the "bogus" points
ui.ignore(None, 0.05)
s = ui.get_stat_info()[0]
assert s.numpoints == 62
assert s.dof == 60
assert_allclose(s.statval, sexpected, rtol=0, atol=0.005)
ui.ignore(2.01, None)
s = ui.get_stat_info()[0]
assert s.numpoints == 7
assert s.dof == 5
assert_allclose(s.statval, sexpected, rtol=0, atol=0.005)
def test_can_use_pspc_data(make_data_path):
"""A basic check that we can read in and use the ROSAT PSPC data.
Unlike the previous tests, that directly access the io module,
this uses the ui interface.
"""
# The PSPC PHA file does not have the ANCRFILE/RESPFILE keywords
# set up, so the responses has to be manually added.
#
ui.load_pha(make_data_path(PHAFILE), use_errors=True)
assert ui.get_analysis() == 'channel'
ui.load_rmf(make_data_path(RMFFILE))
assert ui.get_analysis() == 'energy'
ui.set_source(ui.powlaw1d.pl)
ui.set_par('pl.gamma', 1.7)
ui.set_par('pl.ampl', 2e-6)
s = ui.get_stat_info()[0]
assert s.numpoints == 63
assert s.dof == 61
# Value obtained from XSPEC 12.9.1p; Sherpa returns
# sexpected = 973.2270845920297
sexpected = 973.23
assert_allclose(s.statval, sexpected, rtol=0, atol=0.005)
# apply an energy filter to remove the "bogus" points
ui.ignore(None, 0.05)
s = ui.get_stat_info()[0]
assert s.numpoints == 62
assert s.dof == 60
assert_allclose(s.statval, sexpected, rtol=0, atol=0.005)
ui.ignore(2.01, None)
s = ui.get_stat_info()[0]
assert s.numpoints == 7
assert s.dof == 5
assert_allclose(s.statval, sexpected, rtol=0, atol=0.005)
def setup_order_plot(make_data_path):
"""Set up a faked dataset with multiple orders."""
pha = make_data_path('3c273.pi')
ui.load_pha(pha)
# It has already loaded in one response
arf = ui.get_arf(resp_id=1)
arf.specresp *= 0.5
for order, scale in enumerate([0.4, 0.25], 2):
ui.load_arf(make_data_path('3c273.arf'), resp_id=order)
ui.load_rmf(make_data_path('3c273.rmf'), resp_id=order)
arf = ui.get_arf(resp_id=order)
arf.specresp *= scale
ui.set_source(ui.powlaw1d.pl)
ui.notice(0.5, 7)
ui.ignore(3, 4)
def test_scaling_staterr(make_data_path, use_errors):
'''Regression test for https://github.com/sherpa/sherpa/issues/800
Notes
-----
Test files are made with (in sherpa-test-data/sherpatest)
dmtcalc source.pi source_edit.pi expression="stat_err=stat_err/exposure"
dmcopy "source_edit.pi[cols channel,pi,RATE=count_rate,stat_err]" source_rate.pi clobber=yes
# Then fix units to counts/s manually in the header
'''
ui.load_pha("phacounts",
make_data_path("source.pi"),
use_errors=use_errors)
ui.load_pha("pharate",
make_data_path("source_rate.pi"),
use_errors=use_errors)
for n in ['phacounts', 'pharate']:
ui.load_arf(n, make_data_path("source.arf"))
ui.load_rmf(n, make_data_path("source.rmf"))
assert_staterr(use_errors)
def test_scaling_staterr_pha2(make_data_path, use_errors):
'''Regression test for https://github.com/sherpa/sherpa/issues/800
Notes
-----
Test files are made with (in sherpa-test-data/sherpatest)
dmtcalc 3c120_pha2.gz 3c120_pha2_edit.gz expression="RATE=(float)counts/exposure" clobber=yes
dmtcalc 3c120_pha2_edit.gz 3c120_pha2_edit2.gz expression="stat_err=stat_err/exposure" clobber=yes
dmtcalc 3c120_pha2_edit2.gz 3c120_pha2_edit3.gz expression="backgroun_up=(float)background_up/exposure" clobber=yes
dmtcalc 3c120_pha2_edit3.gz 3c120_pha2_edit4.gz expression="backgroun_down=(float)background_down/exposure" clobber=yes
dmcopy "3c120_pha2_edit4.gz[cols -COUNTS,-BACKGROUND_UP,-BACKGROUND_DOWN][cols *,BACKGROUND_UP=backgroun_up,BACKGROUND_DOWN=backgroun_down][col -COUNTS]" 3c120_pha2_rate.gz clobber=yes
Then fix units manually.
'''
ui.load_pha(make_data_path("3c120_pha2_rate.gz"), use_errors=use_errors)
ui.copy_data(9, "phacounts")
ui.load_pha(make_data_path("3c120_pha2_rate.gz"), use_errors=use_errors)
ui.copy_data(9, "pharate")
for n in ['phacounts', 'pharate']:
ui.load_arf(n, make_data_path("3c120_meg_-1.arf.gz"))
ui.load_rmf(n, make_data_path("3c120_meg_-1.rmf.gz"))
assert_staterr(use_errors)
def test_can_use_swift_data(make_data_path, is_known_warning):
"""A basic check that we can read in and use the Swift data.
Unlike the previous tests, that directly access the io module,
this uses the ui interface.
"""
# QUS are there pytest fixtures that ensure the state is
# clean on entry and exit?
ui.clean()
# The Swift PHA file does not have the ANCRFILE/RESPFILE keywords
# set up, so the responses have to be manually added.
#
ui.load_pha(make_data_path(PHAFILE))
rmffile = make_data_path(RMFFILE)
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter("always")
ui.load_rmf(rmffile)
validate_replacement_warning(ws, 'RMF', rmffile, is_known_warning)
arffile = make_data_path(ARFFILE)
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter("always")
ui.load_arf(arffile)
validate_replacement_warning(ws, 'ARF', arffile, is_known_warning)
assert ui.get_analysis() == 'energy'
arf = ui.get_arf()
rmf = ui.get_rmf()
assert arf.energ_lo[0] == EMIN
assert rmf.energ_lo[0] == EMIN
assert rmf.e_min[0] == 0.0
ui.set_source(ui.powlaw1d.pl)
ui.set_par('pl.ampl', 0.0003)
stat = ui.calc_stat()
# This check is purely a regression test, so the value has
# not been externally validated.
#
assert_allclose(stat, 58.2813692358182)
# Pick an energy range which isn't affected by the first
# bin.
#
# Unfortunately, using a range of 0.3-8.0 gives 771 bins
# in XSPEC - channels 30 to 800 - but 772 bins in Sherpa.
# If I use ignore(None, 0.3); ignore(8.0, None) instead
# then the result is 771 bins. This is because the e_min/max
# of the RMF has channel widths of 0.01 keV, starting at 0,
# so both 0.3 and 8.0 fall on a bin boundary. So, it's either
# a difference in < or <= (or > vs >=), or a rounding issue
# due to floating-point conversion leading to one bin boundary
# being slightly different in Sherpa vs XSPEC).
#
# When using ui.notice(0.3, 8.0); ui.get_indep(filter=True)
# returns 772 channels, 30 to 801.
#
# Using ui.notice(0.3, 7.995) selects channels 30 to 800. So
# this range is used. Alternatively, channel 801 could have been
# excluded explicitly.
#
# ui.notice(0.3, 8.0)
ui.notice(0.3, 7.995)
# XSPEC 12.9.1b calculation of the statistic:
# chi sq = 203.88 from 771 bins with 769 dof
# cstat = 568.52
#
# There are known differences between XSPEC and Sherpa
# with chi2xspecvar. This only affects data sets where
# there is background subtraction, which is not the case
# here. See https://github.com/sherpa/sherpa/issues/356
#
ui.set_stat('chi2xspecvar')
stat_xvar = ui.get_stat_info()
assert len(stat_xvar) == 1
stat_xvar = stat_xvar[0]
assert stat_xvar.numpoints == 771
assert stat_xvar.dof == 769
assert_allclose(stat_xvar.statval, 203.88,
rtol=0, atol=0.005)
ui.set_stat('cstat')
stat_cstat = ui.get_stat_info()
assert len(stat_cstat) == 1
stat_cstat = stat_cstat[0]
assert stat_cstat.numpoints == 771
assert stat_cstat.dof == 769
assert_allclose(stat_cstat.statval, 568.52,
rtol=0, atol=0.005)
ui.clean()
def test_can_use_swift_data(make_data_path, clean_astro_ui):
"""A basic check that we can read in and use the Swift data.
Unlike the previous tests, that directly access the io module,
this uses the ui interface.
"""
# The Swift PHA file does not have the ANCRFILE/RESPFILE keywords
# set up, so the responses have to be manually added.
#
ui.load_pha(make_data_path(PHAFILE))
rmffile = make_data_path(RMFFILE)
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter("always")
ui.load_rmf(rmffile)
validate_replacement_warning(ws, 'RMF', rmffile)
arffile = make_data_path(ARFFILE)
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter("always")
ui.load_arf(arffile)
validate_replacement_warning(ws, 'ARF', arffile)
assert ui.get_analysis() == 'energy'
arf = ui.get_arf()
rmf = ui.get_rmf()
assert arf.energ_lo[0] == EMIN
assert rmf.energ_lo[0] == EMIN
assert rmf.e_min[0] == 0.0
ui.set_source(ui.powlaw1d.pl)
ui.set_par('pl.ampl', 0.0003)
stat = ui.calc_stat()
# This check is purely a regression test, so the value has
# not been externally validated.
#
assert_allclose(stat, 58.2813692358182)
# Pick an energy range which isn't affected by the first
# bin.
#
# Unfortunately, using a range of 0.3-8.0 gives 771 bins
# in XSPEC - channels 30 to 800 - but 770 bins in Sherpa,
# channels 31 to 800.
#
# Note that the channel numbering starts at 0:
# % dmlist target_sr.pha header,clean,raw | grep TLMIN
# TLMIN1 = 0 / Lowest legal channel number
#
# and so it's not clear when XSPEC says 30-800 what it
# means. From https://github.com/sherpa/sherpa/issues/1211#issuecomment-881647128
# we have that the first bin it is using is
# 0.29-0.30
# and the last bin is
# 7.99-8.00
# and I've checked with iplot that it has renumbered the
# channels to 1-1024 from 0-1023
#
# % dmlist swxpc0to12s6_20130101v014.rmf.gz"[ebounds][channel=28:31]" data,clean
# CHANNEL E_MIN E_MAX
# 28 0.28000000119209 0.28999999165535
# 29 0.28999999165535 0.30000001192093
# 30 0.30000001192093 0.31000000238419
# 31 0.31000000238419 0.31999999284744
# % dmlist swxpc0to12s6_20130101v014.rmf.gz"[ebounds][channel=798:801]" data,clean
# CHANNEL E_MIN E_MAX
# 798 7.9800000191 7.9899997711
# 799 7.9899997711 8.0
# 800 8.0 8.0100002289
# 801 8.0100002289 8.0200004578
#
# If I use ignore(None, 0.3); ignore(8.0, None) instead then the
# result is 771 bins (channels 31 to 800). This is because the
# e_min/max of the RMF has channel widths of 0.01 keV, starting at
# 0, so both 0.3 and 8.0 fall on a bin boundary. So, it's either a
# difference in < or <= (or > vs >=), or a rounding issue due to
# floating-point conversion leading to one bin boundary being
# slightly different in Sherpa vs XSPEC).
#
# When using ui.notice(0.3, 8.0); ui.get_indep(filter=True)
# returns 770 channels, 31 to 800.
#
# Using ui.notice(0.3, 7.995) selects channels 31 to 800.
# Using ui.notice(0.299, 8.0) selects channels 30 to 800.
# Using ui.notice(0.299, 7.995) selects channels 30 to 800.
#
ui.notice(0.299, 8.0)
# Check the selected range
pha = ui.get_data()
expected = np.zeros(1024, dtype=bool)
expected[29:800] = True
assert pha.mask == pytest.approx(expected)
assert pha.get_mask() == pytest.approx(expected)
# XSPEC 12.9.1b calculation of the statistic:
# chi sq = 203.88 from 771 bins with 769 dof
# cstat = 568.52
#
# There are known differences between XSPEC and Sherpa
# with chi2xspecvar. This only affects data sets where
# there is background subtraction, which is not the case
# here. See https://github.com/sherpa/sherpa/issues/356
#
ui.set_stat('chi2xspecvar')
stat_xvar = ui.get_stat_info()
assert len(stat_xvar) == 1
stat_xvar = stat_xvar[0]
assert stat_xvar.numpoints == 771
assert stat_xvar.dof == 769
assert_allclose(stat_xvar.statval, 203.88, rtol=0, atol=0.005)
ui.set_stat('cstat')
stat_cstat = ui.get_stat_info()
assert len(stat_cstat) == 1
stat_cstat = stat_cstat[0]
assert stat_cstat.numpoints == 771
assert stat_cstat.dof == 769
assert_allclose(stat_cstat.statval, 568.52, rtol=0, atol=0.005)
def test_load_pha2_compare_meg_order1(make_data_path):
"""Do we read in the MEG +/-1 orders?"""
# The MEG -1 order is dataset 9
# The MEG +1 order is dataset 10
#
pha2file = make_data_path('3c120_pha2')
meg_p1file = make_data_path('3c120_meg_1.pha')
meg_m1file = make_data_path('3c120_meg_-1.pha')
ui.load_pha('meg_p1', meg_p1file)
ui.load_pha('meg_m1', meg_m1file)
orig_ids = set(ui.list_data_ids())
assert 'meg_p1' in orig_ids
assert 'meg_m1' in orig_ids
ui.load_pha(pha2file)
for n, lbl in zip([9, 10], ["-1", "1"]):
h = '3c120_meg_{}'.format(lbl)
ui.load_arf(n, make_data_path(h + '.arf'))
ui.load_rmf(n, make_data_path(h + '.rmf'))
# check that loading the pha2 file doesn't overwrite existing
# data
new_ids = set(ui.list_data_ids())
for i in range(1, 13):
orig_ids.add(i)
assert orig_ids == new_ids
# Check that the same model gives the same statistic
# value; this should check that the data and response are
# read in, that grouping and filtering work, and that
# model evaluation is the same, without having to
# check these steps individually.
#
# The model is not meant to be physically meaningful,
# just one that reasonably represents the data and
# can be evaluated without requiring XSPEC.
#
pmdl = ui.create_model_component('powlaw1d', 'pmdl')
pmdl.gamma = 0.318
pmdl.ampl = 2.52e-3
ncts = 20
for i in [9, 10, "meg_m1", "meg_p1"]:
ui.set_analysis(i, 'wave')
ui.group_counts(i, ncts)
ui.notice_id(i, 2, 12)
ui.set_source(i, pmdl)
ui.set_stat('chi2datavar')
s9 = ui.calc_stat(9)
s10 = ui.calc_stat(10)
sm1 = ui.calc_stat('meg_m1')
sp1 = ui.calc_stat('meg_p1')
# Since these should be the same, we use an equality test
# rather than approximation. At least until it becomes
# a problem.
#
assert s9 == sm1
assert s10 == sp1
# The values were calculated using CIAO 4.9, Linux64, with
# Python 3.5.
#
assert s9 == pytest.approx(1005.4378559390879)
assert s10 == pytest.approx(1119.980439489647)
def test_plot_order_multi(make_data_path, clean_astro_ui):
"""Rather than fake data, use a known dataset.
Here we pretend we have three orders but with the same
response (except that the ARF is 0.5, 0.4, 0.25 of the
normal ARF).
"""
pha = make_data_path('3c273.pi')
ui.load_pha(pha)
# It has already loaded in one response
arf = ui.get_arf(resp_id=1)
arf.specresp *= 0.5
for order, scale in enumerate([0.4, 0.25], 2):
ui.load_arf(make_data_path('3c273.arf'), resp_id=order)
ui.load_rmf(make_data_path('3c273.rmf'), resp_id=order)
arf = ui.get_arf(resp_id=order)
arf.specresp *= scale
ui.set_source(ui.powlaw1d.pl)
ui.notice(0.5, 7)
ui.ignore(3, 4)
fplot = ui.get_fit_plot()
oplot = ui.get_order_plot()
# The idea is to compare the X range of plot_fit to plot_order
# (but accessed just using the plot objects rather than creating
# an actual plot).
#
# First some safety checks
assert fplot.dataplot.xlo == pytest.approx(fplot.modelplot.xlo)
assert fplot.dataplot.xhi == pytest.approx(fplot.modelplot.xhi)
assert len(oplot.xlo) == 3
assert len(oplot.xhi) == 3
assert len(oplot.y) == 3
assert oplot.xlo[1] == pytest.approx(oplot.xlo[0])
assert oplot.xlo[2] == pytest.approx(oplot.xlo[0])
assert oplot.xhi[1] == pytest.approx(oplot.xhi[0])
assert oplot.xhi[2] == pytest.approx(oplot.xhi[0])
# We know the y values are 0.5, 0.4, 0.25 times the original arf
# so we can compare them.
#
assert oplot.y[1] == pytest.approx(oplot.y[0] * 0.4 / 0.5)
assert oplot.y[2] == pytest.approx(oplot.y[0] * 0.25 / 0.5)
xlo = oplot.xlo[0]
xhi = oplot.xhi[0]
assert len(xlo) == 564
assert xlo[0] == pytest.approx(0.46720001101493835)
assert xhi[-1] == pytest.approx(9.869600296020508)
# The model plot is technically drawn the same way as the order plot
# (ungrouped) but it uses different code (sherpa.astro.plot.ModelHistogram)
# so let's compare.
#
mplot = ui.get_model_plot()
assert mplot.xlo[0] == pytest.approx(0.46720001101493835)
assert mplot.xhi[-1] == pytest.approx(9.869600296020508)
# Also compare to the fit plot (which is grouped)
#
assert fplot.modelplot.xlo[0] == pytest.approx(0.46720001101493835)
assert fplot.modelplot.xhi[-1] == pytest.approx(9.869600296020508)
def test_746(make_data_path, clean_astro_ui):
"""Test https://github.com/sherpa/sherpa/issues/746
Something in #444 (reverted in #759) caused:
- the fit to fail (niter=2)
- the line amplitude not to change significantly
- the statistic reported by the fit to be different to
that returned by calc_stat
Something with how the cache code handles analysis=wave
appears to be the problem. This test takes the line data
from 746 and adds it into the existing PHA2 file we have
(3c120) to replicate the problem. Fortunately this
wavelength range contains essentially no counts, so we
can just add in the counts to make a fake line and check
we can fit it.
"""
ui.load_pha(make_data_path('3c120_pha2.gz'))
ui.load_arf(10, make_data_path('3c120_meg_1.arf.gz'))
ui.load_rmf(10, make_data_path('3c120_meg_1.rmf.gz'))
# Add in the line
d10 = ui.get_data(10)
idx = np.arange(4068, 4075, dtype=np.int)
d10.counts[idx] = [1, 1, 1, 2, 3, 1, 1]
# group the data
ui.group_width(id=10, num=2)
ui.set_analysis('wave')
ui.notice(21.4, 21.7)
# internal check that getting the expected data
expected = np.zeros(32)
expected[[9, 10, 11, 12]] = [2, 3, 4, 1]
expected[26] = 1 # this count is from the 3c120 data
d = d10.get_dep(filter=True)
assert d == pytest.approx(expected)
line = ui.create_model_component('gauss1d', 'name')
# treat the line as a delta function
line.fwhm.val = 0.00001
line.fwhm.frozen = True
line.pos = 21.6
line.pos.frozen = True
line.ampl = 2
ui.set_source(10, line)
# the original fit used levmar, so use that here
# (it looks like it also fails with simplex)
ui.set_method('levmar')
ui.set_stat('cstat')
sinit = ui.calc_stat(10)
ui.fit(10)
fr = ui.get_fit_results()
sfinal = ui.calc_stat(10)
# Did the
# - fit improve
# - take more than two iterations
# - report the same statistic values as calc_stat
# - change the fit parameter
#
assert sfinal < sinit
assert fr.succeeded
assert fr.nfev > 2
assert fr.istatval == sinit
assert fr.statval == sfinal
assert line.ampl.val > 100
assert len(fr.parvals) == 1
assert fr.parvals[0] == line.ampl.val
# some simple checks to throw in because we can
assert fr.parnames == ('name.ampl', )
assert fr.datasets == (10,)
assert fr.statname == 'cstat'
assert fr.methodname == 'levmar'
assert fr.itermethodname == 'none'
assert fr.numpoints == 32
assert fr.dof == 31
# Now add in some "absolute" checks to act as regression tests.
# If these fail then it doesn't necessarily mean something bad
# has happened.
#
assert fr.nfev == 15
assert sinit == pytest.approx(82.72457294394245)
assert sfinal == pytest.approx(15.39963248224592)
assert line.ampl.val == pytest.approx(113.95646989927054)
def test_can_use_swift_data(make_data_path):
"""A basic check that we can read in and use the Swift data.
Unlike the previous tests, that directly access the io module,
this uses the ui interface.
"""
# QUS are there pytest fixtures that ensure the state is
# clean on entry and exit?
ui.clean()
# The Swift PHA file does not have the ANCRFILE/RESPFILE keywords
# set up, so the responses have to be manually added.
#
ui.load_pha(make_data_path(PHAFILE))
rmffile = make_data_path(RMFFILE)
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter("always")
ui.load_rmf(rmffile)
validate_replacement_warning(ws, 'RMF', rmffile)
arffile = make_data_path(ARFFILE)
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter("always")
ui.load_arf(arffile)
validate_replacement_warning(ws, 'ARF', arffile)
assert ui.get_analysis() == 'energy'
arf = ui.get_arf()
rmf = ui.get_rmf()
assert arf.energ_lo[0] == EMIN
assert rmf.energ_lo[0] == EMIN
assert rmf.e_min[0] == 0.0
ui.set_source(ui.powlaw1d.pl)
ui.set_par('pl.ampl', 0.0003)
stat = ui.calc_stat()
# This check is purely a regression test, so the value has
# not been externally validated.
#
assert_allclose(stat, 58.2813692358182)
# Pick an energy range which isn't affected by the first
# bin.
#
# Unfortunately, using a range of 0.3-8.0 gives 771 bins
# in XSPEC - channels 30 to 800 - but 772 bins in Sherpa.
# If I use ignore(None, 0.3); ignore(8.0, None) instead
# then the result is 771 bins. This is because the e_min/max
# of the RMF has channel widths of 0.01 keV, starting at 0,
# so both 0.3 and 8.0 fall on a bin boundary. So, it's either
# a difference in < or <= (or > vs >=), or a rounding issue
# due to floating-point conversion leading to one bin boundary
# being slightly different in Sherpa vs XSPEC).
#
# When using ui.notice(0.3, 8.0); ui.get_indep(filter=True)
# returns 772 channels, 30 to 801.
#
# Using ui.notice(0.3, 7.995) selects channels 30 to 800. So
# this range is used. Alternatively, channel 801 could have been
# excluded explicitly.
#
# ui.notice(0.3, 8.0)
ui.notice(0.3, 7.995)
# XSPEC 12.9.1b calculation of the statistic:
# chi sq = 203.88 from 771 bins with 769 dof
# cstat = 568.52
#
# There are known differences between XSPEC and Sherpa
# with chi2xspecvar. This only affects data sets where
# there is background subtraction, which is not the case
# here. See https://github.com/sherpa/sherpa/issues/356
#
ui.set_stat('chi2xspecvar')
stat_xvar = ui.get_stat_info()
assert len(stat_xvar) == 1
stat_xvar = stat_xvar[0]
assert stat_xvar.numpoints == 771
assert stat_xvar.dof == 769
assert_allclose(stat_xvar.statval, 203.88,
rtol=0, atol=0.005)
ui.set_stat('cstat')
stat_cstat = ui.get_stat_info()
assert len(stat_cstat) == 1
stat_cstat = stat_cstat[0]
assert stat_cstat.numpoints == 771
assert stat_cstat.dof == 769
assert_allclose(stat_cstat.statval, 568.52,
rtol=0, atol=0.005)
ui.clean()
def test_can_use_swift_data(make_data_path):
"""A basic check that we can read in and use the Swift data.
Unlike the previous tests, that directly access the io module,
this uses the ui interface.
"""
# QUS are there pytest fixtures that ensure the state is
# clean on entry and exit?
ui.clean()
# The Swift PHA file does not have the ANCRFILE/RESPFILE keywords
# set up, so the responses have to be manually added.
#
ui.load_pha(make_data_path(PHAFILE))
ui.load_rmf(make_data_path(RMFFILE))
ui.load_arf(make_data_path(ARFFILE))
assert ui.get_analysis() == 'energy'
ui.set_source(ui.powlaw1d.pl)
ui.set_par('pl.ampl', 0.0003)
# The responses have the first bin start at an energy of 0,
# which causes issues for Sherpa. There should be a
# RuntimeWarning due to a divide by zero.
#
with pytest.warns(RuntimeWarning) as record:
stat = ui.calc_stat()
# The exact form of the message depends on the Python version;
# this could be checked, but it feels excessive for this
# particular test, which is just a regression check, so use a
# more lax approach.
#
assert len(record) == 1
assert record[0].message.args[0] in \
['divide by zero encountered in divide',
'divide by zero encountered in true_divide']
# The stat value depends on what power-law model is used. With
# xspowerlaw it is NaN, but with powlaw1d it is finite.
#
# This check is purely a regression test, so the value has
# not been externally validated.
#
# assert np.isnan(stat)
assert_allclose(stat, 58.2813692358182)
# Manually adjust the first bin to avoid this problem.
# Add in asserts just in case this gets "fixed" in the
# I/O layer (as XSPEC does).
#
arf = ui.get_arf()
rmf = ui.get_rmf()
assert arf.energ_lo[0] == 0.0
assert rmf.energ_lo[0] == 0.0
assert rmf.e_min[0] == 0.0
# The bin widths are ~ 0.005 or ~ 0.01 keV, so pick a value
# smaller than this.
#
ethresh = 1e-6
arf.energ_lo[0] = ethresh
rmf.energ_lo[0] = ethresh
rmf.e_min[0] = ethresh
# Pick an energy range which isn't affected by the first
# bin.
#
# Unfortunately, using a range of 0.3-8.0 gives 771 bins
# in XSPEC - channels 30 to 800 - but 772 bins in Sherpa.
# If I use ignore(None, 0.3); ignore(8.0, None) instead
# then the result is 771 bins. This is because the e_min/max
# of the RMF has channel widths of 0.01 keV, starting at 0,
# so both 0.3 and 8.0 fall on a bin boundary. So, it's either
# a difference in < or <= (or > vs >=), or a rounding issue
# due to floating-point conversion leading to one bin boundary
# being slightly different in Sherpa vs XSPEC).
#
# When using ui.notice(0.3, 8.0); ui.get_indep(filter=True)
# returns 772 channels, 30 to 801.
#
# Using ui.notice(0.3, 7.995) selects channels 30 to 800. So
# this range is used. Alternatively, channel 801 could have been
# excluded explicitly.
#
# ui.notice(0.3, 8.0)
ui.notice(0.3, 7.995)
# XSPEC 12.9.1b calculation of the statistic:
# chi sq = 203.88 from 771 bins with 769 dof
# cstat = 568.52
#
# There are known differences between XSPEC and Sherpa
# with chi2xspecvar. This only affects data sets where
# there is background subtraction, which is not the case
# here. See https://github.com/sherpa/sherpa/issues/356
#
ui.set_stat('chi2xspecvar')
stat_xvar = ui.get_stat_info()
assert len(stat_xvar) == 1
stat_xvar = stat_xvar[0]
assert stat_xvar.numpoints == 771
assert stat_xvar.dof == 769
assert_allclose(stat_xvar.statval, 203.88,
rtol=0, atol=0.005)
ui.set_stat('cstat')
stat_cstat = ui.get_stat_info()
assert len(stat_cstat) == 1
stat_cstat = stat_cstat[0]
assert stat_cstat.numpoints == 771
assert stat_cstat.dof == 769
assert_allclose(stat_cstat.statval, 568.52,
rtol=0, atol=0.005)
ui.clean()
