def test_cstat_comparison_xspec(make_data_path, l, h, ndp, ndof, statval):
"""Compare CSTAT values for a data set to XSPEC.
This checks that the "UI layer" works, although ideally there
should be a file that can be read in rather than having to
manipulate it (the advantage here is that it means there is
no messing around with adding a file to the test data set).
The XSPEC version used was 12.9.0o.
"""
dset = create_xspec_comparison_dataset(make_data_path,
keep_background=False)
ui.clean()
ui.set_data(dset)
# use powlaw1d rather than xspowerlaw so do not need XSPEC
ui.set_source(ui.powlaw1d.pl)
ui.set_par('pl.ampl', 1e-4)
ui.set_stat('cstat')
ui.set_analysis('channel')
validate_xspec_result(l, h, ndp, ndof, statval)
ui.clean()
def test_cstat_comparison_xspec(make_data_path, l, h, ndp, ndof, statval):
"""Compare CSTAT values for a data set to XSPEC.
This checks that the "UI layer" works, although ideally there
should be a file that can be read in rather than having to
manipulate it (the advantage here is that it means there is
no messing around with adding a file to the test data set).
The XSPEC version used was 12.9.0o.
"""
dset = create_xspec_comparison_dataset(make_data_path,
keep_background=False)
ui.clean()
ui.set_data(dset)
# use powlaw1d rather than xspowerlaw so do not need XSPEC
ui.set_source(ui.powlaw1d.pl)
ui.set_par('pl.ampl', 1e-4)
ui.set_stat('cstat')
ui.set_analysis('channel')
validate_xspec_result(l, h, ndp, ndof, statval)
ui.clean()
def setup_example_bkg_model(idval):
"""Set up a simple dataset + background for use in the tests.
This includes a model for the background, unlike
setup-example_bkg.
Parameters
----------
idval : None, int, str
The dataset identifier.
See Also
--------
setup_example_bkg
"""
d = example_pha_with_bkg_data()
m = example_model()
bm = example_bkg_model()
if idval is None:
ui.set_data(d)
ui.set_source(m)
ui.set_bkg_model(bm)
else:
ui.set_data(idval, d)
ui.set_source(idval, m)
ui.set_bkg_model(idval, bm)
def test_xspecvar_no_grouping_no_bg_comparison_xspec(make_data_path,
l, h, ndp, ndof, statval):
"""Compare chi2xspecvar values for a data set to XSPEC.
The data set has no background.
See test_cstat_comparison_xspec. Note that at present
Sherpa and XSPEC treat bins with 0 values in them differently:
see https://github.com/sherpa/sherpa/issues/356
so for this test all bins are forced to have at least one
count in them (source -> 5 is added per channel,background ->
3 is added per channel).
The XSPEC version used was 12.9.0o.
"""
dset = create_xspec_comparison_dataset(make_data_path,
keep_background=False)
# Lazy, so add it to "bad" channels too
dset.counts += 5
ui.clean()
ui.set_data(dset)
ui.set_source(ui.powlaw1d.pl)
ui.set_par('pl.ampl', 5e-4)
ui.set_stat('chi2xspecvar')
ui.set_analysis('energy')
validate_xspec_result(l, h, ndp, ndof, statval)
ui.clean()
def setup_example(idval):
"""Set up a simple dataset for use in the tests.
A *very basic* ARF is used, along with an ideal RMF. The
way this is created means the analysis is in channel space
by default.
Parameters
----------
idval : None, int, str
The dataset identifier.
See Also
--------
setup_example_bkg
"""
d = example_pha_data()
m = example_model()
if idval is None:
ui.set_data(d)
ui.set_source(m)
else:
ui.set_data(idval, d)
ui.set_source(idval, m)
def test_xspecvar_no_grouping_comparison_xspec(make_data_path,
l, h, ndp, ndof, statval):
"""Compare chi2xspecvar values for a data set to XSPEC.
The data set has a background. See
test_xspecvar_no_grouping_no_bg_comparison_xspec
The XSPEC version used was 12.9.0o.
"""
dset = create_xspec_comparison_dataset(make_data_path,
keep_background=True)
# Lazy, so add it to "bad" channels too
dset.counts += 5
dset.get_background().counts += 3
ui.clean()
ui.set_data(dset)
ui.subtract()
ui.set_source(ui.powlaw1d.pl)
ui.set_par('pl.ampl', 5e-4)
ui.set_stat('chi2xspecvar')
ui.set_analysis('energy')
validate_xspec_result(l, h, ndp, ndof, statval)
ui.clean()
def test_delete_bkg_model(clean_astro_ui):
"""Check we can delete a background model"""
channels = np.arange(1, 5)
counts = np.zeros(channels.size)
d = ui.DataPHA('src', channels, counts)
b = ui.DataPHA('bkg', channels, counts)
d.set_background(b, id=2)
ui.set_data(d)
ui.set_bkg_source(ui.const1d.bmdl + ui.gauss1d.gmdl, bkg_id=2)
assert ui.get_bkg_source(bkg_id=2) is not None
ui.delete_bkg_model(bkg_id=2)
# Expression has been removed
#
with pytest.raises(ModelErr) as exc:
ui.get_bkg_source(bkg_id=2)
assert str(
exc.value) == 'background model 2 for data set 1 has not been set'
# components still exist
mdls = ui.list_model_components()
assert set(mdls) == set(['bmdl', 'gmdl'])
def test_xspecvar_no_grouping_no_bg_comparison_xspec(make_data_path, l, h, ndp,
ndof, statval):
"""Compare chi2xspecvar values for a data set to XSPEC.
The data set has no background.
See test_cstat_comparison_xspec. Note that at present
Sherpa and XSPEC treat bins with 0 values in them differently:
see https://github.com/sherpa/sherpa/issues/356
so for this test all bins are forced to have at least one
count in them (source -> 5 is added per channel,background ->
3 is added per channel).
The XSPEC version used was 12.9.0o.
"""
dset = create_xspec_comparison_dataset(make_data_path,
keep_background=False)
# Lazy, so add it to "bad" channels too
dset.counts += 5
ui.clean()
ui.set_data(dset)
ui.set_source(ui.powlaw1d.pl)
ui.set_par('pl.ampl', 5e-4)
ui.set_stat('chi2xspecvar')
ui.set_analysis('energy')
validate_xspec_result(l, h, ndp, ndof, statval)
ui.clean()
def test_xspecvar_no_grouping_comparison_xspec(make_data_path, l, h, ndp, ndof,
statval):
"""Compare chi2xspecvar values for a data set to XSPEC.
The data set has a background. See
test_xspecvar_no_grouping_no_bg_comparison_xspec
The XSPEC version used was 12.9.0o.
"""
dset = create_xspec_comparison_dataset(make_data_path,
keep_background=True)
# Lazy, so add it to "bad" channels too
dset.counts += 5
dset.get_background().counts += 3
ui.clean()
ui.set_data(dset)
ui.subtract()
ui.set_source(ui.powlaw1d.pl)
ui.set_par('pl.ampl', 5e-4)
ui.set_stat('chi2xspecvar')
ui.set_analysis('energy')
validate_xspec_result(l, h, ndp, ndof, statval)
ui.clean()
def test_eval_multi_arf(clean_astro_ui):
"""See also test_eval_multi_arf_reorder"""
arf1, arf2, dset = make_arf2()
ui.set_data(1, dset)
ui.set_arf(id=1, arf=arf1, resp_id=1)
ui.set_arf(id=1, arf=arf2, resp_id=2)
check_eval_multi_arf()
def test_eval_multi_rmf(clean_astro_ui):
"""See also test_eval_multi_rmf_reorder"""
rmf1, rmf2, dset = make_rmf2()
ui.set_data(1, dset)
ui.set_rmf(id=1, rmf=rmf1, resp_id=1)
ui.set_rmf(id=1, rmf=rmf2, resp_id=2)
check_eval_multi_rmf()
def test_calc_flux_pha_density_bin_edges(clean_astro_ui):
"""What happens when filter edges partially overlap bins? flux density
Later tests may also cover this condition, but here we use
faked data that is made to make the behavior "obvious".
"""
chans = np.arange(1, 11, 1, dtype=np.int)
counts = np.zeros(chans.size, dtype=np.int)
# "perfect" response
energies = np.arange(1, 12, 1)
elo, ehi = energies[:-1], energies[1:]
flat = np.ones(chans.size, dtype=np.int)
d = ui.DataPHA('example', chans, counts)
arf = ui.create_arf(elo, ehi, flat)
rmf = ui.create_rmf(elo,
ehi,
e_min=elo,
e_max=elo,
startchan=1,
fname=None)
d.set_arf(arf)
d.set_rmf(rmf)
ui.set_data(1, d)
ui.set_source(ui.powlaw1d.pl)
pl.ampl = 1e-4
pl.gamma = 1.7
# choose an energy that is not equal to the center of the bin
# just to check how this is handled
#
pdens = ui.calc_photon_flux(2.6)
edens = ui.calc_energy_flux(2.6)
enscale = sherpa.astro.utils._charge_e
# Evaluate the model over the bin 2-3 keV; since the grid
# has a width of 1 keV we do not need to divide by the bin
# width when calculating the density.
#
ymdl = pl([2], [3])
expected_pdens = ymdl.sum()
expected_edens = enscale * 2.5 * expected_pdens
# Prior to fixing #619, Sherpa returns 0 for both densities
#
assert pdens == pytest.approx(expected_pdens)
# check against log as values ~ 5e-13
edens = np.log10(edens)
expected_edens = np.log10(expected_edens)
assert edens == pytest.approx(expected_edens)
def test_eval_multi_arf_reorder(clean_astro_ui):
"""Change the order of setting the ARFs
Should be the same as test_eval_multi_arf
"""
arf1, arf2, dset = make_arf2()
ui.set_data(1, dset)
ui.set_arf(id=1, arf=arf2, resp_id=2)
ui.set_arf(id=1, arf=arf1, resp_id=1)
check_eval_multi_arf()
def test_eval_multi_rmf_reorder(clean_astro_ui):
"""Change the order of setting the RMFs
Should be the same as test_eval_multi_rmf
"""
rmf1, rmf2, dset = make_rmf2()
ui.set_data(1, dset)
ui.set_rmf(id=1, rmf=rmf2, resp_id=2)
ui.set_rmf(id=1, rmf=rmf1, resp_id=1)
check_eval_multi_rmf()
def test_set_multi_arfs_reorder(id, clean_astro_ui):
arf1, arf2, dset = make_arf2()
ui.set_data(id, dset)
d = ui.get_data(id=id)
assert d.response_ids == []
ui.set_arf(id=id, arf=arf2, resp_id=2)
assert d.response_ids == [2]
ui.set_arf(id=id, arf=arf1, resp_id=1)
assert d.response_ids == [2, 1]
def test_set_multi_rmfs_reorder(id, clean_astro_ui):
rmf1, rmf2, dset = make_rmf2()
ui.set_data(id, dset)
d = ui.get_data(id=id)
assert d.response_ids == []
ui.set_rmf(id=id, rmf=rmf2, resp_id=2)
assert d.response_ids == [2]
ui.set_rmf(id=id, rmf=rmf1, resp_id=1)
assert d.response_ids == [2, 1]
def test_grouped_pha_all_bad_response(arf, rmf, chantype, exp_counts, exp_xlo,
exp_xhi, lo1, hi1, lo2, hi2,
clean_astro_ui):
"""Helpdesk ticket: low-count data had no valid bins after grouping #790
A simple PHA dataset is created, which has no "good" grouped data
(1 group, but with a quality of 2). Several checks are made to
ensure we can filter/notice/plot the data even when it is empty.
Checks are done for
- arf-only
- rmf-only
- arf+rmf
analysis in case there's a difference in the code paths
"""
chans = numpy.arange(1, 6, dtype=numpy.int16)
counts = numpy.asarray([0, 1, 2, 0, 1], dtype=numpy.int16)
grouping = numpy.asarray([1, -1, -1, -1, -1], dtype=numpy.int16)
quality = numpy.asarray([2, 2, 2, 2, 2], dtype=numpy.int16)
dset = ui.DataPHA('low', chans, counts, grouping=grouping, quality=quality)
ui.set_data(dset)
egrid = numpy.asarray([0.1, 0.2, 0.3, 0.4, 0.5, 0.6])
elo = egrid[:-1]
ehi = egrid[1:]
# it is required that at least one of arf or rmf is set but this
# is not enforced
#
if arf:
ui.set_arf(ui.create_arf(elo, ehi))
if rmf:
# NOTE: need to set e_min/max otherwise get a 'noenergybins'
# error from sherpa.astro.data.DataPHA._get_ebins
#
ui.set_rmf(ui.create_rmf(elo, ehi, e_min=elo, e_max=ehi))
# plot units depend on analysis type;
#
ui.set_analysis(chantype)
# Run tests
check_bad_grouping(exp_xlo, exp_xhi, exp_counts, lo1, hi1, lo2, hi2)
def test_cache_copy(self):
# fake up a PHA data set
chans = numpy.arange(1, 11, dtype=numpy.int8)
counts = numpy.ones(chans.size)
# bin width is not 0.1 but something slightly different
ebins = numpy.linspace(0.1, 1.2, num=chans.size + 1)
elo = ebins[:-1]
ehi = ebins[1:]
dset = ui.DataPHA('test', chans, counts)
# make sure ARF isn't 1 to make sure it's being applied
arf = ui.create_arf(elo, ehi, specresp=0.7 * numpy.ones(chans.size))
rmf = ui.create_rmf(elo, ehi, e_min=elo, e_max=ehi)
ui.set_data(1, dset)
ui.set_arf(1, arf)
ui.set_rmf(1, rmf)
ui.set_source(ui.const1d.mdl)
# again not 1
mdl.c0 = 8
# Copy the values from the plot structures, since get_xxx_plot
# returns the same object so m1.y == m2.y will not note a difference.
#
d1y = ui.get_data_plot().y.copy()
m1y = ui.get_model_plot().y.copy()
s1y = ui.get_source_plot().y.copy()
d2y = ui.get_data_plot().y.copy()
m2y = ui.get_model_plot().y.copy()
s2y = ui.get_source_plot().y.copy()
rtol = 1.0e-4
atol = 1.0e-4
numpy.testing.assert_allclose(d1y, d2y, rtol, atol)
numpy.testing.assert_allclose(m1y, m2y, rtol, atol)
numpy.testing.assert_allclose(s1y, s2y, rtol, atol)
def test_wstat_comparison_xspec(make_data_path, l, h, ndp, ndof, statval):
"""Compare WSTAT values for a data set to XSPEC.
See test_cstat_comparison_xspec.
The XSPEC version used was 12.9.0o.
"""
dset = create_xspec_comparison_dataset(make_data_path,
keep_background=True)
ui.clean()
ui.set_data(dset)
ui.set_source(ui.powlaw1d.pl)
ui.set_par('pl.ampl', 1e-4)
ui.set_stat('wstat')
ui.set_analysis('channel')
validate_xspec_result(l, h, ndp, ndof, statval)
ui.clean()
def test_wstat_comparison_xspec(make_data_path, l, h, ndp, ndof, statval):
"""Compare WSTAT values for a data set to XSPEC.
See test_cstat_comparison_xspec.
The XSPEC version used was 12.9.0o.
"""
dset = create_xspec_comparison_dataset(make_data_path,
keep_background=True)
ui.clean()
ui.set_data(dset)
ui.set_source(ui.powlaw1d.pl)
ui.set_par('pl.ampl', 1e-4)
ui.set_stat('wstat')
ui.set_analysis('channel')
validate_xspec_result(l, h, ndp, ndof, statval)
ui.clean()
def test_grouped_pha_all_bad_channel(clean_astro_ui):
"""Helpdesk ticket: low-count data had no valid bins after grouping #790
A simple PHA dataset is created, with no response, which has no
"good" grouped data (1 group, but with a quality of 2). Several
checks are made to ensure we can filter/notice/plot the data even
when it is empty. This is in channel space.
See also test_grouped_pha_all_bad_response which is essentially the
same test but with a response model.
"""
chans = numpy.arange(1, 6, dtype=numpy.int16)
counts = numpy.asarray([0, 1, 2, 0, 1], dtype=numpy.int16)
grouping = numpy.asarray([1, -1, -1, -1, -1], dtype=numpy.int16)
quality = numpy.asarray([2, 2, 2, 2, 2], dtype=numpy.int16)
dset = ui.DataPHA('low', chans, counts, grouping=grouping, quality=quality)
ui.set_data(dset)
# Run tests
check_bad_grouping(1, 6, 0.8, 0, 6, 2, 10)
def setup_example_bkg(idval):
"""Set up a simple dataset + background for use in the tests.
Parameters
----------
idval : None, int, str
The dataset identifier.
See Also
--------
setup_example, setup_example_bkg_model
"""
d = example_pha_with_bkg_data()
m = example_model()
if idval is None:
ui.set_data(d)
ui.set_source(m)
else:
ui.set_data(idval, d)
ui.set_source(idval, m)
def load_pha(self, specfile, annulus):
"""Load a pha file and add to the datasets for stacked analysis.
It is required that datasets for all annuli are loaded before
the source model is created (to ensure that components are
created for each annulus).
Parameters
----------
specfile : str or sherpa.astro.data.DataPHA object
If a string, the name of the file containing the source spectrum,
which must be in PHA format (the data is expected to be extracted
on the PI column). If a DataPHA object, then this is used (and
is assumed to contain any needed background data).
annulus : int
The annulus number for the data.
Returns
-------
dataid : int
The Sherpa dataset identifier used for this spectrum.
Examples
--------
Load the data for four annuli from the files 'ann1.pi' to 'ann4.pi'.
>>> dep.load_pha('ann1.pi', 0)
>>> dep.load_pha('ann2.pi', 1)
>>> dep.load_pha('ann3.pi', 2)
>>> dep.load_pha('ann4.pi', 3)
Load in the PHA files into Sherpa DataPHA objects, and then use
these objects:
>>> s1 = ui.unpack_pha('src1.pi')
>>> s2 = ui.unpack_pha('src2.pi')
>>> s3 = ui.unpack_pha('src3.pi')
>>> dep.load_pha(s1, 0)
>>> dep.load_pha(s2, 1)
>>> dep.load_pha(s3, 2)
"""
dataid = len(self.datasets)
# If the input has a counts attribute then assume a DataPHA
# style object.
#
if hasattr(specfile, 'counts'):
print('Using spectrum {} '.format(specfile.name) +
' as dataset id {}'.format(dataid))
ui.set_data(dataid, specfile)
else:
print('Loading spectrum file {} '.format(specfile) +
' as dataset id {}'.format(dataid))
ui.load_pha(dataid, specfile)
data = ui.get_data(dataid)
try:
obsid = int(data.header['OBS_ID'])
except (KeyError, TypeError, ValueError):
obsid = 0
dataset = dict(file=specfile,
obsid=obsid,
id=dataid,
annulus=annulus
)
self.datasets.append(dataset)
self.obsids.add(obsid)
return dataid
def prepare_spectra(nH: float,
group: int = 1,
add_gal: bool = False,
redshift: Optional[float] = None,
**kwargs) -> float:
"""
Fit the spectra using an absorbed powerlaw model using the Wstat statistic. The function also returns a p-value for the gof.
:param nH: The galactic absorption column density in units of 10^22 /cm3
:param group: The number of counts per energy bin
:param add_gal: Setting this to True would add an intrinsic abrosption column density along side the galactic one
:param redshift: The redshift to use in the fit. Only takes effect if add_gal is set to True
...
:return: Returns the p-value of the gof. The null hypothesis states that the model and the observation differ while alternate says that the model explains the data
"""
pha = read_pha("core_spectrum.pi")
pha.set_analysis("energy")
pha.notice(0.5, 7.0)
tabs = ~pha.mask
pha.group_counts(group, tabStops=tabs)
x = pha.get_x()
x = pha.apply_filter(x, pha._middle)
y = pha.get_y(filter=True)
pha.set_analysis("energy")
model = xsphabs.abs1 * powlaw1d.srcp1
print("Fitting the spectrum")
zFlag = False
if (nH is not None) and (nH > 0.0):
if add_gal == 1:
model = xsphabs.gal * xszphabs.abs1 * powlaw1d.srcp
gal.nH = nH
freeze(gal.nH)
zFlag = True
else:
model = xsphabs.abs1 * powlaw1d.srcp1
abs1.nH = nH
freeze(abs1.nH)
else:
model = xszphabs.abs1 * powlaw1d.srcp1
zFlag = True
if zFlag is True and add_gal == 1:
# print('REDSHIFT',redshift)
abs1.redshift = redshift
freeze(abs1.redshift)
full_model = RSPModelPHA(pha.get_arf(), pha.get_rmf(), pha,
pha.exposure * model)
print(full_model)
fit = Fit(pha, full_model, method=MonCar(), stat=WStat())
res = fit.fit()
print(res.format())
print(fit.est_errors())
# calculate the p-value for wstat
mplot2 = ModelPlot()
mplot2.prepare(pha, full_model)
miu = mplot2.y * pha.exposure * 0.0146
obs = y * pha.exposure * 0.0146
c, ce, cv = SpecUtils.estimate_gof_cstat(miu, obs)
#print(f"C0={c},C_e={ce},C_v={cv}")
zval = (fit.calc_stat() - ce) / np.sqrt(cv)
if zval > 0:
pval = special.erfc(zval / np.sqrt(2))
else:
pval = special.erf(abs(zval) / np.sqrt(2))
print(f"p-value for wstat = {pval}")
set_data(pha)
set_model(model)
save_chart_spectrum("core_flux_chart.dat", elow=0.5, ehigh=7.0)
# save_chart_spectrum("core_flux_chart.rdb",format='text/tsv', elow=0.5, ehigh=7.0)
SAOTraceUtils.save_spectrum_rdb("core_flux_chart.dat")
return pval
def test_calc_flux_pha_bin_edges(clean_astro_ui):
"""What happens when filter edges partially overlap bins?
Later tests may also cover this condition, but here we use
faked data that is made to make the behavior "obvious".
"""
chans = np.arange(1, 11, 1, dtype=np.int)
counts = np.zeros(chans.size, dtype=np.int)
# "perfect" response
energies = np.arange(1, 12, 1)
elo, ehi = energies[:-1], energies[1:]
flat = np.ones(chans.size, dtype=np.int)
d = ui.DataPHA('example', chans, counts)
arf = ui.create_arf(elo, ehi, flat)
rmf = ui.create_rmf(elo,
ehi,
e_min=elo,
e_max=elo,
startchan=1,
fname=None)
d.set_arf(arf)
d.set_rmf(rmf)
ui.set_data(1, d)
ui.set_source(ui.powlaw1d.pl)
pl.ampl = 1e-4
pl.gamma = 1.7
# Evaluate the model on the energy grid
ymdl = pl(elo, ehi)
pflux = ui.calc_photon_flux(2.6, 7.8)
eflux = ui.calc_energy_flux(2.6, 7.8)
enscale = sherpa.astro.utils._charge_e
# Left in as notes:
#
# This are the true values. Given that the edge bins (should be)
# using linear interpolation, how close do we get to this?
#
# gterm1 = 1.0 - 1.7
# gterm2 = 2.0 - 1.7
# true_pflux = 1e-4 * (7.8**gterm1 - 2.6**gterm1) / gterm1
# true_eflux = enscale * 1e-4 * (7.8**gterm2 - 2.6**gterm2) / gterm2
#
# Comparing the linear interpolation scheme to that used by
# Sherpa prior to fixing #619, I find
#
# Photon fluxes:
# linear_interp / true_pflux = 1.042251
# sherpa / true_pflux = 0.837522
#
# Energy fluxes:
# linear_interp / true_eflux = 1.017872
# sherpa / true_eflux = 0.920759
#
scale = np.asarray([0.0, 0.4, 1.0, 1.0, 1.0, 1.0, 0.8, 0, 0.0, 0.0])
expected_pflux = (ymdl * scale).sum()
emid = enscale * (elo + ehi) / 2
expected_eflux = (emid * ymdl * scale).sum()
assert pflux == pytest.approx(expected_pflux)
# check against log as values ~ 3e-13
eflux = np.log10(eflux)
expected_eflux = np.log10(expected_eflux)
assert eflux == pytest.approx(expected_eflux)
