def setup_two(make_data_path):
from sherpa.astro.io import read_pha, read_arf, read_rmf
from sherpa.astro import xspec
abs1 = xspec.XSphabs('abs1')
p1 = PowLaw1D('p1')
model = abs1 * p1 * 1e-4
pi2278 = make_data_path("pi2278.fits")
pi2286 = make_data_path("pi2286.fits")
data_pi2278 = read_pha(pi2278)
data_pi2286 = read_pha(pi2286)
data_pi2278.set_rmf(read_rmf(make_data_path('rmf2278.fits')))
data_pi2278.set_arf(read_arf(make_data_path('arf2278.fits')))
data_pi2286.set_rmf(read_rmf(make_data_path('rmf2286.fits')))
data_pi2286.set_arf(read_arf(make_data_path('arf2286.fits')))
rsp_pi2278 = Response1D(data_pi2278)
rsp_pi2286 = Response1D(data_pi2286)
return {
'data_pi2278': data_pi2278,
'data_pi2286': data_pi2286,
'model_pi2278': rsp_pi2278(model),
'model_pi2286': rsp_pi2286(model)
}
def test_read_rmf_crates_py3(make_data_path):
"""At present the RMF can not be read with the crates backend with
Python 3.5. This test will let us know when Crates has been fixed.
"""
if six.PY2 or (backend != "crates"):
pytest.skip('Test only needed for Crates with Python 3')
infile = make_data_path(RMFFILE)
with pytest.raises(ValueError) as excinfo:
io.read_rmf(infile)
assert str(excinfo.value) == "dmKeyRead() cound not find key. " + \
"'HDUCLAS1'"
def test_read_rmf_fails_pha(make_data_path):
"""Just check in we can't read in a PHA file as a RMF."""
if backend == 'pyfits':
emsg = ' does not appear to be an RMF'
elif backend == 'crates':
emsg = "Required column 'ENERG_LO' not found in "
else:
assert False, "Internal error: unknown backend {}".format(backend)
infile = make_data_path(PHAFILE)
with pytest.raises(IOErr) as excinfo:
io.read_rmf(infile)
assert emsg in str(excinfo.value)
def test_read_rmf_fails_pha(make_data_path):
"""Just check in we can't read in a PHA file as a RMF."""
if backend == 'pyfits':
emsg = ' does not appear to be an RMF'
elif backend == 'crates':
emsg = "Required column 'ENERG_LO' not found in "
else:
assert False, "Internal error: unknown backend {}".format(backend)
infile = make_data_path(PHAFILE)
with pytest.raises(IOErr) as excinfo:
io.read_rmf(infile)
assert emsg in str(excinfo.value)
def setup_bkg(make_data_path):
from sherpa.astro.io import read_pha, read_arf, read_rmf
from sherpa.astro import xspec
infile = make_data_path("9774_bg.pi")
bkg = read_pha(infile)
bkg.exposure = 1
arf = read_arf(make_data_path('9774.arf'))
rmf = read_rmf(make_data_path('9774.rmf'))
bkg.set_arf(arf)
bkg.set_rmf(rmf)
bkg.set_analysis('energy')
bkg.notice(0.5, 7.0)
# We stay with a linear scale for the absorption model
# here as the values don't seem to go below 0.1.
#
abs1 = xspec.XSwabs('abs1')
p1 = PowLaw1D('p1')
model = abs1 * p1
p1.ampl = 1e-4
rsp = Response1D(bkg)
return {'bkg': bkg, 'model': rsp(model)}
def test_rmf_real_bad_energy(make_data_path, override_plot_backend):
"""Read in a RMF that triggers the energy_thresh change"""
from sherpa.astro.io import read_rmf
infile = make_data_path("MNLup_2138_0670580101_EMOS1_S001_spec.rmf")
with warnings.catch_warnings(record=True) as ws:
d = read_rmf(infile)
expected = f"The minimum ENERG_LO in the RMF '{infile}' was 0 and has been replaced by 1e-10"
assert len(ws) == 1
assert ws[0].category == UserWarning
assert str(ws[0].message) == expected
d.name = 'test.rmf'
r = d._repr_html_()
check(r, 'RMF', 'test.rmf', 'N_GRP', nmeta=6)
assert '<div class="dataname">Identifier</div><div class="dataval">test.rmf</div>' in r
assert '<div class="dataname">Number of channels</div><div class="dataval">800</div>' in r
assert '<div class="dataname">Number of energies</div><div class="dataval">2400</div>' in r
assert '<div class="dataname">Energy range</div><div class="dataval">1e-10 - 12 keV, bin size 0.00500011 keV (minimum threshold of 1e-10 was used)</div>' in r
assert '<div class="dataname">Channel range</div><div class="dataval">0 - 799</div>' in r
assert '<div class="dataname">Mission or Satellite</div><div class="dataval">XMM</div>' in r
assert '<div class="dataname">Instrument or Detector</div><div class="dataval">EMOS1</div>' in r
assert '<div class="dataname">Instrument filter</div><div class="dataval">Medium</div>' in r
assert '<div class="dataname">The channel type</div><div class="dataval">PI</div>' in r
assert '<div class="dataname">The minimum probability threshold</div><div class="dataval">1e-06</div>' in r
assert '<div class="dataname">Matrix contents</div><div class="dataval">REDIST</div>' in r
def test_read_rmf_fails_pha(make_data_path):
"""Just check in we can't read in a PHA file as a RMF."""
if backend == 'pyfits':
emsg = ' does not appear to be an RMF'
etype = IOErr
elif backend == 'crates':
emsg = ' does not contain a Response Matrix.'
etype = TypeError
else:
assert False, "Internal error: unknown backend {}".format(backend)
infile = make_data_path(PHAFILE)
with pytest.raises(etype) as excinfo:
io.read_rmf(infile)
assert emsg in str(excinfo.value)
def test_read_rmf_fails_pha(make_data_path):
"""Just check in we can't read in a PHA file as a RMF."""
if backend_is("pyfits"):
emsg = " does not appear to be an RMF"
etype = IOErr
elif backend_is("crates"):
emsg = " does not contain a Response Matrix."
etype = TypeError
else:
assert False, f"Internal error: unknown backend {io.backend}"
infile = make_data_path(PHAFILE)
with pytest.raises(etype) as excinfo:
io.read_rmf(infile)
assert emsg in str(excinfo.value)
def test_read_rmf_fails_arf(make_data_path):
"""Just check in we can't read in a ARF as a RMF."""
if backend == 'pyfits':
emsg = " does not have a 'DETCHANS' keyword"
etype = IOErr
elif backend == 'crates':
emsg = ' does not contain a Response Matrix.'
etype = TypeError
else:
assert False, "Internal error: unknown backend {}".format(backend)
infile = make_data_path(ARFFILE)
with pytest.raises(etype) as excinfo:
io.read_rmf(infile)
assert emsg in str(excinfo.value)
def test_read_rmf_fails_arf(make_data_path):
"""Just check in we can't read in a ARF as a RMF."""
if backend == 'pyfits':
emsg = " does not have a 'DETCHANS' keyword"
etype = IOErr
elif backend == 'crates':
emsg = ' does not contain a Response Matrix.'
etype = TypeError
else:
assert False, "Internal error: unknown backend {}".format(backend)
infile = make_data_path(ARFFILE)
with pytest.raises(etype) as excinfo:
io.read_rmf(infile)
assert emsg in str(excinfo.value)
def test_read_rmf(make_data_path):
if not six.PY2 and (backend == "crates"):
pytest.skip('Python3 and Crates: known to fail')
infile = make_data_path(RMFFILE)
rmf = io.read_rmf(infile)
validate_rmf(rmf)
def test_read_rmf_fails_pha(make_data_path):
"""Just check in we can't read in a PHA file as a RMF."""
if backend == 'pyfits':
emsg = ' does not appear to be an RMF'
etype = IOErr
elif backend == 'crates':
emsg = ' does not contain a Response Matrix.'
etype = TypeError
else:
assert False, "Internal error: unknown backend {}".format(backend)
infile = make_data_path(PHAFILE)
with pytest.raises(etype) as excinfo:
io.read_rmf(infile)
assert emsg in str(excinfo.value)
def test_read_rmf(make_data_path, is_known_warning):
"""Can we read in a Swift RMF."""
infile = make_data_path(RMFFILE)
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter("always")
rmf = io.read_rmf(infile)
validate_replacement_warning(ws, 'RMF', infile, is_known_warning)
assert isinstance(rmf, DataRMF)
nchans = 1024
nbins = 2400
assert rmf.detchans == nchans
assert rmf.offset == 0
for field in ['energ_lo', 'energ_hi', 'n_grp', 'f_chan',
'n_chan']:
assert getattr(rmf, field).size == nbins
assert rmf.matrix.size == nchans * nbins
for field in ['e_min', 'e_max']:
assert getattr(rmf, field).size == nchans
assert (rmf.n_grp == 1).all()
assert (rmf.f_chan == 0).all()
assert (rmf.n_chan == nchans).all()
# Rather than check each element, use some simple summary
# statistics.
assert_allclose(rmf.matrix.min(), 0.0)
assert_allclose(rmf.matrix.max(), 0.05834391713142395)
assert_allclose(rmf.matrix.sum(), 1133.8128197300257)
assert np.argmax(rmf.matrix) == 269443
# Expect the upper edge of bin j to equal the lower
# edge of bin j + 1.
#
assert_allclose(rmf.energ_lo[1:], rmf.energ_hi[:-1])
assert_allclose(rmf.e_min[1:], rmf.e_max[:-1])
assert_allclose(rmf.energ_lo[0], EMIN)
assert_allclose(rmf.energ_hi[0], 0.005)
assert_allclose(rmf.energ_lo[-1], 11.995)
assert_allclose(rmf.energ_hi[-1], 12.0)
assert_allclose(rmf.e_min[0], 0.0)
assert_allclose(rmf.e_max[0], 0.01)
assert_allclose(rmf.e_min[-1], 10.23)
assert_allclose(rmf.e_max[-1], 10.24)
def test_read_rmf(make_data_path):
"""Can we read in a Swift RMF."""
infile = make_data_path(RMFFILE)
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter("always")
rmf = io.read_rmf(infile)
validate_replacement_warning(ws, 'RMF', infile)
assert isinstance(rmf, DataRMF)
nchans = 1024
nbins = 2400
assert rmf.detchans == nchans
assert rmf.offset == 0
for field in ['energ_lo', 'energ_hi', 'n_grp', 'f_chan',
'n_chan']:
assert getattr(rmf, field).size == nbins
assert rmf.matrix.size == nchans * nbins
for field in ['e_min', 'e_max']:
assert getattr(rmf, field).size == nchans
assert (rmf.n_grp == 1).all()
assert (rmf.f_chan == 0).all()
assert (rmf.n_chan == nchans).all()
# Rather than check each element, use some simple summary
# statistics.
assert_allclose(rmf.matrix.min(), 0.0)
assert_allclose(rmf.matrix.max(), 0.05834391713142395)
assert_allclose(rmf.matrix.sum(), 1133.8128197300257)
assert np.argmax(rmf.matrix) == 269443
# Expect the upper edge of bin j to equal the lower
# edge of bin j + 1.
#
assert_allclose(rmf.energ_lo[1:], rmf.energ_hi[:-1])
assert_allclose(rmf.e_min[1:], rmf.e_max[:-1])
assert_allclose(rmf.energ_lo[0], EMIN)
assert_allclose(rmf.energ_hi[0], 0.005)
assert_allclose(rmf.energ_lo[-1], 11.995)
assert_allclose(rmf.energ_hi[-1], 12.0)
assert_allclose(rmf.e_min[0], 0.0)
assert_allclose(rmf.e_max[0], 0.01)
assert_allclose(rmf.e_min[-1], 10.23)
assert_allclose(rmf.e_max[-1], 10.24)
def test_read_ideal_rmf():
"""Can a RMF similar to issue #862 be read in?
The MATRIX column in this file is a scalar rather than array,
and let's do EBOUNDS then MATRIX blocks.
"""
from sherpa.astro.io import read_rmf
ebins = np.arange(0.15, 0.2, 0.01)
elo = ebins[:-1]
ehi = ebins[1:]
with NamedTemporaryFile() as f:
fake_rmf(f.name)
r = read_rmf(f.name)
# Can we read in the data
#
assert r.detchans == 5
assert r.energ_lo == pytest.approx(elo)
assert r.energ_hi == pytest.approx(ehi)
assert (r.n_grp == [1, 1, 1, 1, 1]).all()
assert (r.f_chan == [1, 2, 3, 4, 5]).all()
assert (r.n_chan == [1, 1, 1, 1, 1]).all()
assert r.offset == 1
assert r.e_min == pytest.approx(elo)
assert r.e_max == pytest.approx(ehi)
assert r.ethresh == 1e-10
# Can we apply it?
#
# The cmdl evalutes to a value of 2 * bin width
# The bmdl evalates to the bin width * x
# where x = [0, 1, 0.5, 0, 0]
#
cmdl = Const1D()
cmdl.c0 = 2
bmdl = Box1D()
bmdl.xlow = 0.16
bmdl.xhi = 0.175
mdl = bmdl + cmdl
# Multiply by 100 so numbers are close to unity
expected = 100 * 0.01 * np.asarray([2, 3, 2.5, 2, 2])
y = 100 * r.eval_model(mdl)
assert y == pytest.approx(expected, rel=2e-6)
def test_xmmrgs_notice(make_data_path):
'''Test that notice and ignore works on XMMRGS dataset, which is
ordered in increasing wavelength, not energy'''
from sherpa.astro.io import read_pha, read_rmf
dat = read_pha(make_data_path('xmmrgs/P0112880201R1S004SRSPEC1003.FTZ'))
rmf = read_rmf(make_data_path('xmmrgs/P0112880201R1S004RSPMAT1003.FTZ'))
dat.set_rmf(rmf)
dat.units = 'wave'
dat.notice(18.8, 19.2)
assert len(dat.get_dep(filter=True)) == 41
assert dat.get_filter(format='%.2f') == '18.80:19.21'
dat.ignore(10, 19.)
assert len(dat.get_dep(filter=True)) == 20
assert dat.get_filter(format='%.2f') == '19.01:19.21'
def test_rmf_real(make_data_path, override_plot_backend):
"""Read in a RMF"""
from sherpa.astro.io import read_rmf
d = read_rmf(make_data_path('9774.rmf'))
d.name = '9774.rmf'
r = d._repr_html_()
check(r, 'RMF', '9774.rmf', 'N_GRP', nmeta=6)
assert '<div class="dataname">Identifier</div><div class="dataval">9774.rmf</div>' in r
assert '<div class="dataname">Number of channels</div><div class="dataval">1024</div>' in r
assert '<div class="dataname">Number of energies</div><div class="dataval">1078</div>' in r
assert '<div class="dataname">Energy range</div><div class="dataval">0.22 - 11 keV, bin size 0.0100002 keV</div>' in r
assert '<div class="dataname">Channel range</div><div class="dataval">1 - 1024</div>' in r
assert '<div class="dataname">The channel type</div><div class="dataval">PI</div>' in r
assert '<div class="dataname">Matrix contents</div><div class="dataval">REDIST</div>' in r
def test_1209_response(make_data_path):
"""Do we pick up the header keywords from the response?
This is related to issue #1209
"""
# We could set up channels and counts, but let's not.
#
d = DataPHA("dummy", None, None)
assert d.header["TELESCOP"] == "none"
assert d.header["INSTRUME"] == "none"
assert d.header["FILTER"] == "none"
infile = make_data_path(RMFFILE)
rmf = io.read_rmf(infile)
d.set_rmf(rmf)
assert d.header["TELESCOP"] == "ROSAT"
assert d.header["INSTRUME"] == "PSPCC"
assert d.header["FILTER"] == "NONE"
def test_1209_response(mode, make_data_path):
"""Do we pick up the header keywords from the response?
This is related to issue #1209
"""
# We could set up channels and counts, but let's not.
#
d = DataPHA("dummy", None, None)
assert d.header["TELESCOP"] == "none"
assert d.header["INSTRUME"] == "none"
assert d.header["FILTER"] == "none"
# We do not care about the warning messages here from
# ENERG_LO replacement.
#
if "arf" in mode:
infile = make_data_path(ARFFILE)
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter("ignore")
arf = io.read_arf(infile)
d.set_arf(arf)
if "rmf" in mode:
infile = make_data_path(RMFFILE)
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter("ignore")
rmf = io.read_rmf(infile)
d.set_rmf(rmf)
# The PHA file contains a FILTER keyword but the responses do not.
#
assert d.header["TELESCOP"] == "SWIFT"
assert d.header["INSTRUME"] == "XRT"
assert d.header["FILTER"] == "none"
print(repr(eval(name)))
print("----------------------------------------")
def savefig(name):
outfile = os.path.join(savedir, name)
plt.savefig(outfile)
print("# Created: {}".format(name))
os.chdir('../../../../sherpa-test-data/sherpatest/')
from sherpa.astro.io import read_arf, read_rmf
arf = read_arf('3c273.arf')
rmf = read_rmf('3c273.rmf')
dump("rmf.detchans")
from sherpa.models.basic import PowLaw1D
mdl = PowLaw1D()
from sherpa.astro.instrument import RSPModelNoPHA
inst = RSPModelNoPHA(arf, rmf, mdl)
dump("inst")
report("inst")
from sherpa.models.model import ArithmeticModel
dump("isinstance(inst, ArithmeticModel)")
dump("inst.pars")
def test_read_rmf(make_data_path):
infile = make_data_path(RMFFILE)
rmf = io.read_rmf(infile)
validate_rmf(rmf)
def test_read_rmf(make_data_path):
infile = make_data_path(RMFFILE)
rmf = io.read_rmf(infile)
validate_rmf(rmf)
