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 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(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(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)