def test_arfmodelpha_call(ignore):
"""What happens calling an arf with a pha?
The ignore value indicates what channel to ignore (0 means
nothing is ignored). The aim is to check edge effects,
and as there are only a few channels, it was decided to
test all channels.
"""
# Note: the exposure is set in the PHA and ARF, but should not be
# used when evaluating the model; it's value has been
# set to a value that the test will fail it it is.
#
exposure = 200.1
estep = 0.01
egrid = np.arange(0.01, 0.06, estep)
svals = [1.1, 1.2, 1.3, 1.4]
specresp = np.asarray(svals)
adata = create_arf(egrid[:-1], egrid[1:], specresp, exposure=exposure)
constant = 2.3
mdl = Const1D('flat')
mdl.c0 = constant
channels = np.arange(1, 5, dtype=np.int16)
counts = np.asarray([10, 5, 12, 7], dtype=np.int16)
pha = DataPHA('test-pha',
channel=channels,
counts=counts,
exposure=exposure)
pha.set_arf(adata)
# force energy units (only needed if ignore is set)
pha.set_analysis('energy')
if ignore is not None:
de = estep * 0.9
e0 = egrid[ignore]
pha.notice(lo=e0, hi=e0 + de, ignore=True)
# The assert are intended to help people reading this
# code rather than being a useful check that the code
# is working.
mask = [True, True, True, True]
mask[ignore] = False
assert (pha.mask == mask).all()
wrapped = ARFModelPHA(adata, pha, mdl)
# The model is evaluated on the ARF grid, not whatever
# is sent in. It is also integrated across the bins,
# which is why there is a multiplication by the
# grid width (for this constant model).
#
# Note that the filter doesn't change the grid.
#
de = egrid[1:] - egrid[:-1]
expected = constant * np.asarray(svals) * de
out = wrapped([4, 5])
assert_allclose(out, expected)
def test_rsp_normf_error(analysis):
"""Check that an error is raised on set_analysis
"""
exposure = 200.1
# rdata is only used to define the grids
rdata = create_non_delta_rmf()
specresp = create_non_delta_specresp()
adata = create_arf(rdata.energ_lo,
rdata.energ_hi,
specresp,
exposure=exposure)
nchans = rdata.e_min.size
channels = np.arange(1, nchans + 1, dtype=np.int16)
counts = np.ones(nchans, dtype=np.int16)
pha = DataPHA('test-pha', channel=channels, counts=counts,
exposure=exposure)
pha.set_arf(adata)
with pytest.raises(DataErr) as exc:
pha.set_analysis(analysis)
emsg = "response incomplete for dataset test-pha, " + \
"check the instrument model"
assert str(exc.value) == emsg
def test_pha_get_filter_checks_ungrouped(chtype, expected, args):
"""Check we get the filter we expect
chtype is channel, energy, or wavelength
expected is the expected response
args is a list of 3-tuples of (flag, loval, hival) where
flag is True for notice and False for ignore; they define
the filter to apply
"""
chans = np.arange(1, 11, dtype=int)
counts = np.ones(10, dtype=int)
pha = DataPHA('data', chans, counts)
# Use an ARF to create a channel to energy mapping
# The 0.2-2.2 keV range maps to 5.636-61.992 Angstrom
#
egrid = 0.2 * np.arange(1, 12)
arf = DataARF('arf', egrid[:-1], egrid[1:], np.ones(10))
pha.set_arf(arf)
pha.units = chtype
for (flag, lo, hi) in args:
if flag:
pha.notice(lo, hi)
else:
pha.ignore(lo, hi)
assert pha.get_filter(format='%.1f') == expected
def test_rsp_normf_error(analysis):
"""Check that an error is raised on set_analysis
"""
exposure = 200.1
# rdata is only used to define the grids
rdata = create_non_delta_rmf()
specresp = create_non_delta_specresp()
adata = create_arf(rdata.energ_lo,
rdata.energ_hi,
specresp,
exposure=exposure)
nchans = rdata.e_min.size
channels = np.arange(1, nchans + 1, dtype=np.int16)
counts = np.ones(nchans, dtype=np.int16)
pha = DataPHA('test-pha',
channel=channels,
counts=counts,
exposure=exposure)
pha.set_arf(adata)
with pytest.raises(DataErr) as exc:
pha.set_analysis(analysis)
emsg = "response incomplete for dataset test-pha, " + \
"check the instrument model"
assert str(exc.value) == emsg
def test_288_a_energy():
"""The issue from #288 which was working
test_288_a but with a response so we test energy filters
"""
channels = np.arange(1, 6)
counts = np.asarray([5, 5, 10, 10, 2])
grouping = np.asarray([1, -1, 1, -1, 1], dtype=np.int16)
pha = DataPHA('x', channels, counts, grouping=grouping)
rlo = channels
rhi = channels + 1
rmf = create_delta_rmf(rlo, rhi, e_min=rlo, e_max=rhi)
pha.set_arf(rmf)
pha.set_analysis('energy')
assert pha.mask
pha.ignore(3, 4)
# I use approx because it gives a nice answer, even though
# I want equality not approximation in this test. Fortunately
# with bools the use of approx is okay (it can tell the
# difference between 0 and 1, aka False and True).
#
assert pha.mask == pytest.approx([True, False, True])
def test_stats_calc_stat_wstat_diffbins():
"""wstat statistic fails when src/bg bin sizes do not match"""
statobj = WStat()
data, model = setup_single_pha(True, False, background=True)
# Tweak data to have one-less bin than the background. This
# used to be easy but with data validation we need to
# create a new object.
#
data2 = DataPHA("faked",
channel=data.channel[:-1],
counts=data.counts[:-1],
staterror=data.staterror[:-1],
grouping=data.grouping[:-1],
exposure=data.exposure,
backscal=data.backscal,
areascal=data.areascal)
# We might expect the ARF/RMF calls to fail if we add validation
# (to check the ARF/RMF is valid for the PHA dataset).
#
data2.set_arf(data.get_arf())
data2.set_rmf(data.get_rmf())
data2.set_background(data.get_background())
# There is no Sherpa error for this, which seems surprising
with pytest.raises(TypeError) as err:
statobj.calc_stat(data2, model)
assert str(
err.value) == "input array sizes do not match, data: 5 vs group: 4"
def test_has_pha_response():
"""Check the examples from the docstring"""
exposure = 200.1
rdata = create_non_delta_rmf()
specresp = create_non_delta_specresp()
adata = create_arf(rdata.energ_lo,
rdata.energ_hi,
specresp,
exposure=exposure)
nchans = rdata.e_min.size
channels = np.arange(1, nchans + 1, dtype=np.int16)
counts = np.ones(nchans, dtype=np.int16)
pha = DataPHA('test-pha',
channel=channels,
counts=counts,
exposure=exposure)
pha.set_arf(adata)
pha.set_rmf(rdata)
rsp = Response1D(pha)
m1 = Gauss1D()
m2 = PowLaw1D()
assert not has_pha_response(m1)
assert has_pha_response(rsp(m1))
assert not has_pha_response(m1 + m2)
assert has_pha_response(rsp(m1 + m2))
assert has_pha_response(m1 + rsp(m2))
# reflexivity check
assert has_pha_response(rsp(m1) + m2)
assert has_pha_response(rsp(m1) + rsp(m2))
def example_pha_data():
"""Create an example data set."""
etime = 1201.0
d = DataPHA('example',
_data_chan.copy(),
_data_counts.copy(),
exposure=etime,
backscal=0.2)
a = DataARF('example-arf',
_energies_lo.copy(),
_energies_hi.copy(),
_arf.copy(),
exposure=etime)
r = create_delta_rmf(_energies_lo.copy(),
_energies_hi.copy(),
e_min=_energies_lo.copy(),
e_max=_energies_hi.copy(),
offset=1,
name='example-rmf')
d.set_arf(a)
d.set_rmf(r)
return d
def test_arfmodelpha_call(ignore):
"""What happens calling an arf with a pha?
The ignore value indicates what channel to ignore (0 means
nothing is ignored). The aim is to check edge effects,
and as there are only a few channels, it was decided to
test all channels.
"""
# Note: the exposure is set in the PHA and ARF, but should not be
# used when evaluating the model; it's value has been
# set to a value that the test will fail it it is.
#
exposure = 200.1
estep = 0.01
egrid = np.arange(0.01, 0.06, estep)
svals = [1.1, 1.2, 1.3, 1.4]
specresp = np.asarray(svals)
adata = create_arf(egrid[:-1], egrid[1:], specresp,
exposure=exposure)
constant = 2.3
mdl = Const1D('flat')
mdl.c0 = constant
channels = np.arange(1, 5, dtype=np.int16)
counts = np.asarray([10, 5, 12, 7], dtype=np.int16)
pha = DataPHA('test-pha', channel=channels, counts=counts,
exposure=exposure)
pha.set_arf(adata)
# force energy units (only needed if ignore is set)
pha.set_analysis('energy')
if ignore is not None:
de = estep * 0.9
e0 = egrid[ignore]
pha.notice(lo=e0, hi=e0 + de, ignore=True)
# The assert are intended to help people reading this
# code rather than being a useful check that the code
# is working.
mask = [True, True, True, True]
mask[ignore] = False
assert (pha.mask == mask).all()
wrapped = ARFModelPHA(adata, pha, mdl)
# The model is evaluated on the ARF grid, not whatever
# is sent in. It is also integrated across the bins,
# which is why there is a multiplication by the
# grid width (for this constant model).
#
# Note that the filter doesn't change the grid.
#
de = egrid[1:] - egrid[:-1]
expected = constant * np.asarray(svals) * de
out = wrapped([4, 5])
assert_allclose(out, expected)
def test_416_c():
"""The third test case from issue #416
This used to use channels but it has been changed to add an RMF so
we can filter in energy space, as it is not clear what non-integer
channels should mean.
"""
x = np.asarray([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
y = np.asarray([0, 0, 0, 2, 1, 1, 0, 0, 0, 0])
pha = DataPHA('416', x, y)
rmf = create_delta_rmf(x, x + 1, e_min=x, e_max=x + 1,
name='416')
pha.set_arf(rmf)
pha.set_analysis('energy')
# When using channels this used notice(3.5, 6.5)
# but using energy space we need to use a different
# range to match the ones the original channel filter
# used.
#
pha.notice(4.5, 6.5)
# this should be ~pha.mask
tabstops = [True] * 3 + [False] * 3 + [True] * 4
assert ~pha.mask == pytest.approx(tabstops)
pha.group_counts(3, tabStops=~pha.mask)
pha.ignore_bad()
grouping = [0] * 3 + [1, -1, 1] + [0] * 4
assert pha.grouping == pytest.approx(grouping)
# the second grouped bin has a quality of 2 as
# it only contains 1 count
quality = np.zeros(10, dtype=int)
quality[5] = 2
assert pha.quality == pytest.approx(quality)
dep = pha.get_dep(filter=False)
assert dep == pytest.approx(y)
# It is not at all obvious why we get 8 bins returned
# here. The ignore_bad has removed any existing
# filters, but why do we get 8, not 10, values?
# Well, one bin has been removed (quality=2)
# and two bins have merged into 1. Hence the 8.
#
dep = pha.get_dep(filter=True)
exp = np.zeros(8)
exp[3] = 3
assert dep == pytest.approx(exp)
def test_rsp1d_matrix_pha_zero_energy_bin():
"""What happens when the first bin starts at 0, with replacement.
Unlike test_rsp1d_delta_pha_zero_energy_bin this directly
calls Response1D to create the model.
"""
ethresh = 1.0e-5
rdata = create_non_delta_rmf()
# hack the first bin to have 0 energy
rdata.energ_lo[0] = 0.0
# PHA and ARF have different exposure ties
exposure_arf = 0.1
exposure_pha = 2.4
specresp = create_non_delta_specresp()
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter("always")
adata = create_arf(rdata.energ_lo,
rdata.energ_hi,
specresp,
exposure=exposure_arf,
ethresh=ethresh)
validate_zero_replacement(ws, 'ARF', 'user-arf', ethresh)
nchans = rdata.e_min.size
channels = np.arange(1, nchans + 1, dtype=np.int16)
counts = np.ones(nchans, dtype=np.int16)
pha = DataPHA('test-pha',
channel=channels,
counts=counts,
exposure=exposure_pha)
pha.set_rmf(rdata)
pha.set_arf(adata)
pha.set_analysis('energy')
mdl = MyPowLaw1D()
rsp = Response1D(pha)
wrapped = rsp(mdl)
# Evaluate the statistic / model. The value was calculated using
# commit a65fb94004664eab219cc09652172ffe1dad80a6 on a linux
# system (Ubuntu 17.04).
#
f = Fit(pha, wrapped)
ans = f.calc_stat()
assert ans == pytest.approx(37971.8716151947)
def test_rsp1d_matrix_pha_zero_energy_bin():
"""What happens when the first bin starts at 0, with replacement.
Unlike test_rsp1d_delta_pha_zero_energy_bin this directly
calls Response1D to create the model.
"""
ethresh = 1.0e-5
rdata = create_non_delta_rmf()
# hack the first bin to have 0 energy
rdata.energ_lo[0] = 0.0
# PHA and ARF have different exposure ties
exposure_arf = 0.1
exposure_pha = 2.4
specresp = create_non_delta_specresp()
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter("always")
adata = create_arf(rdata.energ_lo,
rdata.energ_hi,
specresp,
exposure=exposure_arf,
ethresh=ethresh)
validate_zero_replacement(ws, 'ARF', 'user-arf', ethresh)
nchans = rdata.e_min.size
channels = np.arange(1, nchans + 1, dtype=np.int16)
counts = np.ones(nchans, dtype=np.int16)
pha = DataPHA('test-pha', channel=channels, counts=counts,
exposure=exposure_pha)
pha.set_rmf(rdata)
pha.set_arf(adata)
pha.set_analysis('energy')
mdl = MyPowLaw1D()
rsp = Response1D(pha)
wrapped = rsp(mdl)
# Evaluate the statistic / model. The value was calculated using
# commit a65fb94004664eab219cc09652172ffe1dad80a6 on a linux
# system (Ubuntu 17.04).
#
f = Fit(pha, wrapped)
ans = f.calc_stat()
assert ans == pytest.approx(37971.8716151947)
def test_rsp1d_delta_pha_zero_energy_bin():
"What happens when the first bin starts at 0, with replacement"
ethresh = 2.0e-7
# PHA and ARF have different exposure ties
exposure1 = 0.1
exposure2 = 2.4
egrid = np.asarray([0.0, 0.1, 0.2, 0.4, 0.5, 0.7, 0.8])
elo = egrid[:-1]
ehi = egrid[1:]
specresp = np.asarray([10.2, 9.8, 10.0, 12.0, 8.0, 10.0])
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter("always")
adata = create_arf(elo,
ehi,
specresp,
exposure=exposure1,
ethresh=ethresh)
validate_zero_replacement(ws, 'ARF', 'user-arf', ethresh)
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter("always")
rdata = create_delta_rmf(elo, ehi, ethresh=ethresh)
validate_zero_replacement(ws, 'RMF', 'delta-rmf', ethresh)
channels = np.arange(1, 7, dtype=np.int16)
counts = np.ones(6, dtype=np.int16)
pha = DataPHA('test-pha',
channel=channels,
counts=counts,
exposure=exposure2)
pha.set_rmf(rdata)
pha.set_arf(adata)
pha.set_analysis('energy')
mdl = MyPowLaw1D()
tmdl = PowLaw1D()
wrapped = RSPModelPHA(adata, rdata, pha, mdl)
out = wrapped([0.1, 0.2])
elo[0] = ethresh
expected = specresp * tmdl(elo, ehi)
assert_allclose(out, expected)
assert not np.isnan(out[0])
def test_416_b(caplog):
"""The second test case from issue #416
This is to make sure this hasn't changed.
This used to use channels but it has been changed to add an RMF so
we can filter in energy space, as it is not clear what non-integer
channels should mean.
"""
x = np.asarray([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
y = np.asarray([0, 0, 0, 2, 1, 1, 0, 0, 0, 0])
pha = DataPHA('416', x, y)
rmf = create_delta_rmf(x, x + 1, e_min=x, e_max=x + 1,
name='416')
pha.set_arf(rmf)
pha.set_analysis('energy')
pha.notice(3.5, 6.5)
pha.group_counts(3)
with caplog.at_level(logging.INFO, logger='sherpa'):
pha.ignore_bad()
# It's not obvious why this has switched to a boolean
assert pha.mask
# Mask is also interesting (currently just reporting
# this behavior)
mask = [True] * 5 + [False] * 5
assert pha.get_mask() == pytest.approx(mask)
grouping = [1, -1, -1, -1, -1, 1, -1, -1, -1, -1.]
assert pha.grouping == pytest.approx(grouping)
quality = [0, 0, 0, 0, 0, 2, 2, 2, 2, 2]
assert pha.quality == pytest.approx(quality)
dep = pha.get_dep(filter=True)
assert dep == pytest.approx([3])
# check captured log
#
emsg = 'filtering grouped data with quality flags, previous filters deleted'
assert caplog.record_tuples == [
('sherpa.astro.data', logging.WARNING, emsg)
]
def test_rspmodelpha_matrix_call_xspec():
"""Check XSPEC constant is invariant to wavelength/energy setting.
As XSPEC models internally convert from Angstrom to keV,
do a simple check here.
"""
exposure = 200.1
rdata = create_non_delta_rmf()
specresp = create_non_delta_specresp()
adata = create_arf(rdata.energ_lo,
rdata.energ_hi,
specresp,
exposure=exposure)
constant = 2.3
mdl = XSconstant('flat')
mdl.factor = constant
nchans = rdata.e_min.size
channels = np.arange(1, nchans + 1, dtype=np.int16)
counts = np.ones(nchans, dtype=np.int16)
pha = DataPHA('test-pha',
channel=channels,
counts=counts,
exposure=exposure)
# The set_arf call isn't necessary, but leave in
pha.set_arf(adata)
pha.set_rmf(rdata)
# The XSPEC models are evaluated on an energy grid, even when
# the analysis setting is wavelength. Also, unlike the Sherpa
# Constant model, the XSPEC XSconstant model is defined
# over the integrated bin, so no correction is needed for the
# bin width.
#
modvals = constant * specresp
matrix = get_non_delta_matrix()
expected = np.matmul(modvals, matrix)
wrapped = RSPModelPHA(adata, rdata, pha, mdl)
pha.set_analysis('wave')
out_wl = wrapped([4, 5])
assert_allclose(out_wl, expected)
pha.set_analysis('energy')
out_en = wrapped([4, 5])
assert_allclose(out_en, expected)
def test_rspmodelpha_matrix_call_xspec():
"""Check XSPEC constant is invariant to wavelength/energy setting.
As XSPEC models internally convert from Angstrom to keV,
do a simple check here.
"""
exposure = 200.1
rdata = create_non_delta_rmf()
specresp = create_non_delta_specresp()
adata = create_arf(rdata.energ_lo,
rdata.energ_hi,
specresp,
exposure=exposure)
constant = 2.3
mdl = XSconstant('flat')
mdl.factor = constant
nchans = rdata.e_min.size
channels = np.arange(1, nchans + 1, dtype=np.int16)
counts = np.ones(nchans, dtype=np.int16)
pha = DataPHA('test-pha', channel=channels, counts=counts,
exposure=exposure)
# The set_arf call isn't necessary, but leave in
pha.set_arf(adata)
pha.set_rmf(rdata)
# The XSPEC models are evaluated on an energy grid, even when
# the analysis setting is wavelength. Also, unlike the Sherpa
# Constant model, the XSPEC XSconstant model is defined
# over the integrated bin, so no correction is needed for the
# bin width.
#
modvals = constant * specresp
matrix = get_non_delta_matrix()
expected = np.matmul(modvals, matrix)
wrapped = RSPModelPHA(adata, rdata, pha, mdl)
pha.set_analysis('wave')
out_wl = wrapped([4, 5])
assert_allclose(out_wl, expected)
pha.set_analysis('energy')
out_en = wrapped([4, 5])
assert_allclose(out_en, expected)
def test_arf1d_pha_zero_energy_bin():
"What happens when the first bin starts at 0, with replacement"
ethresh = 1.0e-10
# Note: the two exposures are different to check which is
# used (the answer is neither, which seems surprising)
#
exposure1 = 0.1
egrid = np.asarray([0.0, 0.1, 0.2, 0.4, 0.5, 0.7, 0.8])
elo = egrid[:-1]
ehi = egrid[1:]
specresp = np.asarray([10.2, 9.8, 10.0, 12.0, 8.0, 10.0])
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter("always")
adata = create_arf(elo,
ehi,
specresp,
exposure=exposure1,
ethresh=ethresh)
validate_zero_replacement(ws, 'ARF', 'user-arf', ethresh)
arf = ARF1D(adata)
exposure2 = 2.4
channels = np.arange(1, 7, dtype=np.int16)
counts = np.ones(6, dtype=np.int16)
pha = DataPHA('test-pha',
channel=channels,
counts=counts,
exposure=exposure2)
pha.set_arf(adata)
pha.set_analysis('energy')
mdl = MyPowLaw1D()
tmdl = PowLaw1D()
wrapped = ARFModelPHA(arf, pha, mdl)
out = wrapped([0.1, 0.2])
elo[0] = ethresh
expected = specresp * tmdl(elo, ehi)
assert_allclose(out, expected)
assert not np.isnan(out[0])
def test_rsp1d_delta_pha_zero_energy_bin():
"What happens when the first bin starts at 0, with replacement"
ethresh = 2.0e-7
# PHA and ARF have different exposure ties
exposure1 = 0.1
exposure2 = 2.4
egrid = np.asarray([0.0, 0.1, 0.2, 0.4, 0.5, 0.7, 0.8])
elo = egrid[:-1]
ehi = egrid[1:]
specresp = np.asarray([10.2, 9.8, 10.0, 12.0, 8.0, 10.0])
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter("always")
adata = create_arf(elo, ehi, specresp, exposure=exposure1,
ethresh=ethresh)
validate_zero_replacement(ws, 'ARF', 'user-arf', ethresh)
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter("always")
rdata = create_delta_rmf(elo, ehi, ethresh=ethresh)
validate_zero_replacement(ws, 'RMF', 'delta-rmf', ethresh)
channels = np.arange(1, 7, dtype=np.int16)
counts = np.ones(6, dtype=np.int16)
pha = DataPHA('test-pha', channel=channels, counts=counts,
exposure=exposure2)
pha.set_rmf(rdata)
pha.set_arf(adata)
pha.set_analysis('energy')
mdl = MyPowLaw1D()
tmdl = PowLaw1D()
wrapped = RSPModelPHA(adata, rdata, pha, mdl)
out = wrapped([0.1, 0.2])
elo[0] = ethresh
expected = specresp * tmdl(elo, ehi)
assert_allclose(out, expected)
assert not np.isnan(out[0])
def test_416_a():
"""The first test case from issue #416
This used to use channels but it has been changed to add an RMF so
we can filter in energy space, as it is not clear what non-integer
channels should mean.
"""
# if y is not a numpy array then group_counts errors out
# with a strange error. Another reason why DataPHA needs
# to validate input
#
x = np.asarray([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
y = np.asarray([0, 0, 0, 2, 1, 1, 0, 0, 0, 0])
pha = DataPHA('416', x, y)
rmf = create_delta_rmf(x, x + 1, e_min=x, e_max=x + 1,
name='416')
pha.set_arf(rmf)
pha.set_analysis('energy')
pha.notice(4.5, 6.5)
mask = [False, False, False, True, True, True, False, False, False, False]
assert pha.mask == pytest.approx(mask)
pha.group_counts(3)
# We have a simplified mask
mask = [True, True]
assert pha.mask == pytest.approx(mask)
# the "full" mask can be retrieved with get_mask
mask = [True] * 10
assert pha.get_mask() == pytest.approx(mask)
grouping = [1, -1, -1, -1, -1, 1, -1, -1, -1, -1.]
assert pha.grouping == pytest.approx(grouping)
quality = [0, 0, 0, 0, 0, 2, 2, 2, 2, 2]
assert pha.quality == pytest.approx(quality)
dep = pha.get_dep(filter=True)
assert dep == pytest.approx([3, 1])
def test_arf1d_pha_zero_energy_bin():
"What happens when the first bin starts at 0, with replacement"
ethresh = 1.0e-10
# Note: the two exposures are different to check which is
# used (the answer is neither, which seems surprising)
#
exposure1 = 0.1
egrid = np.asarray([0.0, 0.1, 0.2, 0.4, 0.5, 0.7, 0.8])
elo = egrid[:-1]
ehi = egrid[1:]
specresp = np.asarray([10.2, 9.8, 10.0, 12.0, 8.0, 10.0])
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter("always")
adata = create_arf(elo, ehi, specresp, exposure=exposure1,
ethresh=ethresh)
validate_zero_replacement(ws, 'ARF', 'user-arf', ethresh)
arf = ARF1D(adata)
exposure2 = 2.4
channels = np.arange(1, 7, dtype=np.int16)
counts = np.ones(6, dtype=np.int16)
pha = DataPHA('test-pha', channel=channels, counts=counts,
exposure=exposure2)
pha.set_arf(adata)
pha.set_analysis('energy')
mdl = MyPowLaw1D()
tmdl = PowLaw1D()
wrapped = ARFModelPHA(arf, pha, mdl)
out = wrapped([0.1, 0.2])
elo[0] = ethresh
expected = specresp * tmdl(elo, ehi)
assert_allclose(out, expected)
assert not np.isnan(out[0])
def test_288_b_energy():
"""The issue from #288 which was failing
test_288_b but with a response so we test energy filters
"""
channels = np.arange(1, 6)
counts = np.asarray([5, 5, 10, 10, 2])
grouping = np.asarray([1, -1, 1, -1, 1], dtype=np.int16)
pha = DataPHA('x', channels, counts, grouping=grouping)
rlo = channels
rhi = channels + 1
rmf = create_delta_rmf(rlo, rhi, e_min=rlo, e_max=rhi)
pha.set_arf(rmf)
pha.set_analysis('energy')
assert pha.mask
pha.ignore(3.1, 4)
assert pha.mask == pytest.approx([True, False, True])
def test_fake_pha_background_pha(reset_seed):
"""Sample from background pha"""
np.random.seed(1234)
data = DataPHA("any", channels, counts, exposure=1000.)
bkg = DataPHA("bkg", channels, bcounts, exposure=2000, backscal=2.5)
data.set_background(bkg, id="used-bkg")
data.set_arf(arf)
data.set_rmf(rmf)
mdl = Const1D("mdl")
mdl.c0 = 0
# Just make sure that the model does not contribute
fake_pha(data, mdl, is_source=True, add_bkgs=False)
assert data.counts.sum() == 0
fake_pha(data, mdl, is_source=True, add_bkgs=True)
# expected is [200, 200, 200]
assert data.counts.sum() > 400
assert data.counts.sum() < 1000
# Add several more backgrounds. Actual background should be average.
# We add 5 background with half the exposure time as this first oned
# and essentially 0 counts. So, we should find 1/11 of the counts
# we found in the last run.
for i in range(5):
bkg = DataPHA("bkg",
channels,
np.ones(3, dtype=np.int16),
exposure=1000,
backscal=2.5)
data.set_background(bkg, id=i)
fake_pha(data, mdl, is_source=True, add_bkgs=True)
# expected is about [18, 18, 18]
assert data.counts.sum() > 10
assert data.counts.sum() < 200
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"
def test_fake_pha_bkg_model(reset_seed):
"""Test background model
"""
np.random.seed(5329853)
data = DataPHA("any", channels, counts, exposure=1000.)
bkg = DataPHA("bkg", channels, bcounts, exposure=2000, backscal=1.)
data.set_background(bkg, id="used-bkg")
data.set_arf(arf)
data.set_rmf(rmf)
bkg.set_arf(arf)
bkg.set_rmf(rmf)
mdl = Const1D("mdl")
mdl.c0 = 0
bmdl = Const1D("bmdl")
bmdl.c0 = 2
# With no background model the simulated source counts
# are 0.
#
fake_pha(data,
mdl,
is_source=True,
add_bkgs=False,
bkg_models={"used-bkg": bmdl})
assert data.counts == pytest.approx([0, 0, 0])
# Check we have created source counts this time.
#
fake_pha(data,
mdl,
is_source=True,
add_bkgs=True,
bkg_models={"used-bkg": bmdl})
assert data.exposure == pytest.approx(1000.0)
assert (data.channel == channels).all()
assert data.name == "any"
assert data.get_arf().name == "user-arf"
assert data.get_rmf().name == "delta-rmf"
# The background itself is unchanged
assert data.background_ids == ["used-bkg"]
bkg = data.get_background("used-bkg")
assert bkg.name == "bkg"
assert bkg.counts == pytest.approx(bcounts)
assert bkg.exposure == pytest.approx(2000)
# Apply a number of regression checks to test the output. These
# can expect to change if the randomization changes (either
# explicitly or implicity). There used to be a number of checks
# that compares the simulated data to the input values, but these
# could occasionally fail, and so the seed was fixed for these
# tests.
#
# For reference the predicted signal is
# [200, 400, 400]
# but, unlike in the test above, this time it's all coming
# from the background.
#
assert data.counts == pytest.approx([186, 411, 405])
# Now add a second set of arf/rmf for the data.
# However, all the signal is background, so this does not change
# any of the results.
data.set_arf(arf, 2)
data.set_rmf(rmf, 2)
fake_pha(data,
mdl,
is_source=True,
add_bkgs=True,
bkg_models={"used-bkg": bmdl})
assert data.counts == pytest.approx([197, 396, 389])
def test_fake_pha_has_valid_ogip_keywords_all_fake(tmp_path, reset_seed):
"""See #1209
When everything is faked, what happens?
"""
np.random.seed(5)
data = DataPHA("any", channels, counts, exposure=1000.)
bkg = DataPHA("bkg", channels, bcounts, exposure=2000, backscal=1.)
data.set_background(bkg, id="used-bkg")
data.set_arf(arf)
data.set_rmf(rmf)
bkg.set_arf(arf)
bkg.set_rmf(rmf)
mdl = Const1D("mdl")
mdl.c0 = 0
bmdl = Const1D("bmdl")
bmdl.c0 = 2
fake_pha(data,
mdl,
is_source=True,
add_bkgs=True,
bkg_models={"used-bkg": bmdl})
outfile = tmp_path / "sim.pha"
io.write_pha(str(outfile), data, ascii=False)
inpha = io.read_pha(str(outfile))
assert inpha.channel == pytest.approx(channels)
# it is not required that we check counts (that is, we can drop this
# if it turns out not to be repeatable across platforms), but for
# now keep the check.
#
assert inpha.counts == pytest.approx([188, 399, 416])
for field in [
"staterror", "syserror", "bin_lo", "bin_hi", "grouping", "quality"
]:
assert getattr(inpha, field) is None
assert inpha.exposure == pytest.approx(1000.0)
assert inpha.backscal == pytest.approx(1.0)
assert inpha.areascal == pytest.approx(1.0)
assert not inpha.grouped
assert not inpha.subtracted
assert inpha.response_ids == []
assert inpha.background_ids == []
hdr = inpha.header
assert hdr["TELESCOP"] == "none"
assert hdr["INSTRUME"] == "none"
assert hdr["FILTER"] == "none"
for key in [
"EXPOSURE", "AREASCAL", "BACKSCAL", "ANCRFILE", "BACKFILE",
"RESPFILE"
]:
assert key not in hdr
def test_fake_pha_basic(has_bkg, is_source, reset_seed):
"""No background.
See also test_fake_pha_add_background
For simplicity we use perfect responses.
A background dataset can be added, but it should
not be used in the simulation with default settings
"""
np.random.seed(4276)
data = DataPHA("any", channels, counts, exposure=1000.)
if has_bkg:
bkg = DataPHA("bkg", channels, bcounts, exposure=2000, backscal=0.4)
data.set_background(bkg, id="unused-bkg")
data.set_arf(arf)
data.set_rmf(rmf)
mdl = Const1D("mdl")
mdl.c0 = 2
fake_pha(data, mdl, is_source=is_source, add_bkgs=False)
assert data.exposure == pytest.approx(1000.0)
assert (data.channel == channels).all()
assert data.name == "any"
assert data.get_arf().name == "user-arf"
assert data.get_rmf().name == "delta-rmf"
if has_bkg:
assert data.background_ids == ["unused-bkg"]
bkg = data.get_background("unused-bkg")
assert bkg.name == "bkg"
assert bkg.counts == pytest.approx(bcounts)
assert bkg.exposure == pytest.approx(2000)
else:
assert data.background_ids == []
if is_source:
# check we've faked counts (the scaling is such that it is
# very improbable that this condition will fail)
assert (data.counts > counts).all()
# For reference the predicted source signal is
# [200, 400, 400]
#
# What we'd like to say is that the predicted counts are
# similar, but this is not easy to do. What we can try
# is summing the counts (to average over the randomness)
# and then a simple check
#
assert data.counts.sum() > 500
assert data.counts.sum() < 1500
# This is more likely to fail by chance, but still very unlikely
assert data.counts[1] > data.counts[0]
else:
# No multiplication with exposure time, arf binning, etc.
# so we just expect very few counts
assert data.counts.sum() < 10
assert data.counts.sum() >= 2
# Essentially double the exposure by having two identical arfs
data.set_arf(arf, 2)
data.set_rmf(rmf, 2)
fake_pha(data, mdl, is_source=is_source, add_bkgs=False)
if is_source:
assert data.counts.sum() > 1200
assert data.counts.sum() < 3000
assert data.counts[1] > data.counts[0]
else:
assert data.counts.sum() < 20
assert data.counts.sum() >= 4
def test_rsp_normf_call(arfexp, phaexp):
"""Check out Response1D with no RMF.
analysis is the analysis setting
arfexp determines whether the arf has an exposure time
phaexp determines whether the PHA has an exposure time
This only uses the channel setting
"""
# Chose different exposure times for ARF and PHA to see which
# gets picked up.
#
if arfexp:
arf_exposure = 200.1
else:
arf_exposure = None
if phaexp:
pha_exposure = 220.9
else:
pha_exposure = None
if phaexp:
exposure = pha_exposure
mdl_label = '({} * flat)'.format(exposure)
elif arfexp:
exposure = arf_exposure
mdl_label = '({} * flat)'.format(exposure)
else:
exposure = 1.0
mdl_label = 'flat'
# rdata is only used to define the grids
rdata = create_non_delta_rmf()
specresp = create_non_delta_specresp()
adata = create_arf(rdata.energ_lo,
rdata.energ_hi,
specresp,
exposure=arf_exposure)
constant = 2.3
mdl = Const1D('flat')
mdl.c0 = constant
# Turn off integration on this model, so that it is not integrated
# across the bin width.
#
mdl.integrate = False
nchans = rdata.e_min.size
channels = np.arange(1, nchans + 1, dtype=np.int16)
counts = np.ones(nchans, dtype=np.int16)
pha = DataPHA('test-pha',
channel=channels,
counts=counts,
exposure=pha_exposure)
pha.set_arf(adata)
rsp = Response1D(pha)
wrapped = rsp(mdl)
assert isinstance(wrapped, ArithmeticModel)
expname = 'apply_arf({})'.format(mdl_label)
assert wrapped.name == expname
expected = exposure * constant * specresp
pha.set_analysis('channel')
out = wrapped([4, 5])
assert_allclose(out, expected)
def test_fake_pha_bkg_model():
"""Test background model
"""
data = DataPHA('any', channels, counts, exposure=1000.)
bkg = DataPHA('bkg', channels, bcounts, exposure=2000, backscal=1.)
data.set_background(bkg, id='used-bkg')
data.set_arf(arf)
data.set_rmf(rmf)
bkg.set_arf(arf)
bkg.set_rmf(rmf)
mdl = Const1D('mdl')
mdl.c0 = 0
bmdl = Const1D('bmdl')
bmdl.c0 = 2
fake_pha(data,
mdl,
is_source=True,
add_bkgs=True,
bkg_models={'used-bkg': bmdl})
assert data.exposure == pytest.approx(1000.0)
assert (data.channel == channels).all()
assert data.name == 'any'
assert data.get_arf().name == 'user-arf'
assert data.get_rmf().name == 'delta-rmf'
# The background itself is unchanged
assert data.background_ids == ['used-bkg']
bkg = data.get_background('used-bkg')
assert bkg.name == 'bkg'
assert bkg.counts == pytest.approx(bcounts)
assert bkg.exposure == pytest.approx(2000)
# check we've faked counts (the scaling is such that it is
# very improbable that this condition will fail)
assert (data.counts > counts).all()
# For reference the predicted signal is
# [200, 400, 400]
# but, unlike in the test above, this time it's all coming
# from the background.
#
# What we'd like to say is that the predicted counts are
# similar, but this is not easy to do. What we can try
# is summing the counts (to average over the randomness)
# and then a simple check
#
assert data.counts.sum() > 500
assert data.counts.sum() < 1500
# This is more likely to fail by chance, but still very unlikely
assert data.counts[1] > 1.5 * data.counts[0]
# Now add a second set of arf/rmf for the data.
# However, all the signal is background, so this does not change
# any of the results.
data.set_arf(arf, 2)
data.set_rmf(rmf, 2)
fake_pha(data,
mdl,
is_source=True,
add_bkgs=True,
bkg_models={'used-bkg': bmdl})
assert data.counts.sum() > 500
assert data.counts.sum() < 1500
assert data.counts[1] > 1.5 * data.counts[0]
def test_rsp_normf_call(arfexp, phaexp):
"""Check out Response1D with no RMF.
analysis is the analysis setting
arfexp determines whether the arf has an exposure time
phaexp determines whether the PHA has an exposure time
This only uses the channel setting
"""
# Chose different exposure times for ARF and PHA to see which
# gets picked up.
#
if arfexp:
arf_exposure = 200.1
else:
arf_exposure = None
if phaexp:
pha_exposure = 220.9
else:
pha_exposure = None
if phaexp:
exposure = pha_exposure
mdl_label = '({} * flat)'.format(exposure)
elif arfexp:
exposure = arf_exposure
mdl_label = '({} * flat)'.format(exposure)
else:
exposure = 1.0
mdl_label = 'flat'
# rdata is only used to define the grids
rdata = create_non_delta_rmf()
specresp = create_non_delta_specresp()
adata = create_arf(rdata.energ_lo,
rdata.energ_hi,
specresp,
exposure=arf_exposure)
constant = 2.3
mdl = Const1D('flat')
mdl.c0 = constant
# Turn off integration on this model, so that it is not integrated
# across the bin width.
#
mdl.integrate = False
nchans = rdata.e_min.size
channels = np.arange(1, nchans + 1, dtype=np.int16)
counts = np.ones(nchans, dtype=np.int16)
pha = DataPHA('test-pha', channel=channels, counts=counts,
exposure=pha_exposure)
pha.set_arf(adata)
rsp = Response1D(pha)
wrapped = rsp(mdl)
assert isinstance(wrapped, ArithmeticModel)
expname = 'apply_arf({})'.format(mdl_label)
assert wrapped.name == expname
expected = exposure * constant * specresp
pha.set_analysis('channel')
out = wrapped([4, 5])
assert_allclose(out, expected)
