def test_arf1d_no_pha_zero_energy_bin_replace(): "What happens when the first bin starts at 0, with replacement" ethresh = 1e-5 exposure = 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=exposure, ethresh=ethresh) validate_zero_replacement(ws, 'ARF', 'user-arf', ethresh) arf = ARF1D(adata) mdl = MyPowLaw1D() tmdl = PowLaw1D() wrapped = arf(mdl) out = wrapped([0.1, 0.2]) elo[0] = ethresh expected = exposure * specresp * tmdl(elo, ehi) assert_allclose(out, expected) assert not np.isnan(out[0])
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 test_link_parameter_evaluation(): """See also test_link_parameter_setting A version of this test, using an XSPEC table model, is found in sherpa/astro/xspec/tests/test_xspec_unit::test_xstbl_link_parameter_evaluation """ # What happens when we try to evaluate a model whose # parameter is out-of-range thanks to a link? # mdl = PowLaw1D() lmdl = Const1D() grid = arange(1, 5) mdl.gamma = lmdl.c0 lmdl.c0 = 2 y2 = mdl(grid) assert (y2 > 0).all() lmdl.c0 = 12 emsg = 'parameter powlaw1d.gamma has a maximum of 10' with pytest.raises(ParameterErr, match=emsg): mdl(grid)
def test_rmf1d_delta_no_pha_zero_energy_bin_replace(): "What happens when the first bin starts at 0, with replacement" ethresh = 1e-8 egrid = np.asarray([0.0, 0.1, 0.2, 0.4, 0.5, 0.7, 0.8]) elo = egrid[:-1] ehi = egrid[1:] 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) rmf = RMF1D(rdata) mdl = MyPowLaw1D() tmdl = PowLaw1D() wrapped = rmf(mdl) out = wrapped([0.1, 0.2]) elo[0] = ethresh expected = tmdl(elo, ehi) assert_allclose(out, expected) assert not np.isnan(out[0])
def setUp(self): self.old_level = logger.getEffectiveLevel() logger.setLevel(logging.ERROR) self.data = DataPHA('', numpy.arange(10), numpy.ones(10), bin_lo=numpy.arange(0.1, 10, 0.1), bin_hi=numpy.arange(0.2, 10.1, 0.1)) self.data.units = "energy" self.src = PowLaw1D('p1') * AbsorptionGaussian('abs1')
def test_orderplot_check_title(): """Is the title set?""" oplot = OrderPlot() pha = example_pha_data() model = PowLaw1D('example-pl') assert oplot.title == 'Model' oplot.prepare(pha, model) assert oplot.title == 'Model Orders [1]'
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_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 setUp(self): self._old_logger_level = logger.getEffectiveLevel() logger.setLevel(logging.ERROR) ui.clean() self.ascii = self.make_path('sim.poisson.1.dat') self.wrong_stat_msg = "Fit statistic must be cash, cstat or wstat, not {}" self.wstat_err_msg = "No background data has been supplied. Use cstat" self.no_covar_msg = "covariance has not been performed" self.fail_msg = "Call should not have succeeded" self.right_stats = {'cash', 'cstat', 'wstat'} self.model = PowLaw1D("p1") ui.load_data(self.ascii) ui.set_model(self.model)
def test_cflux_calc_sherpa(): """Test the CFLUX convolution model calculations (sherpa model) This is a test of the convolution interface, as the results of the convolution can be easily checked. The model being convolved is a Sherpa model. See Also -------- test_cflux_calc_xspec """ mdl = PowLaw1D('sherpa') mdl.gamma = 1.7 mdl.ampl = 0.025 _test_cflux_calc(mdl, mdl.gamma.val, mdl.ampl.val)
def test_cflux_nbins(): """Check that the number of bins created by cflux is correct. The test_cflux_calc_xxx routines do include a test of the number of bins, but that is just for a Data1DInt dataset, so the model only ever gets called with explicit lo and hi edges. This test calls the model directly to check both 1 and 2 argument variants. Notes ----- There's no check of a non-contiguous grid. """ from sherpa.astro import xspec spl = PowLaw1D('sherpa') xpl = xspec.XSpowerlaw('xspec') spl.gamma = 0.7 xpl.phoindex = 0.7 egrid = np.arange(0.1, 2, 0.01) elo = egrid[:-1] ehi = egrid[1:] nbins = elo.size def check_bins(lbl, mdl): y1 = mdl(egrid) y2 = mdl(elo, ehi) assert y1.size == nbins + 1, '{}: egrid'.format(lbl) assert y2.size == nbins, '{}: elo/ehi'.format(lbl) # verify assumptions # check_bins('Sherpa model', spl) check_bins('XSPEC model', xpl) # Now try the convolved versions # cflux = xspec.XScflux("conv") check_bins('Convolved Sherpa', cflux(spl)) check_bins('Convolved XSPEC', cflux(xpl))
def test_cflux_nbins(): """Check that the number of bins created by cflux is correct. The test_cflux_calc_xxx routines do include a test of the number of bins, but that is just for a Data1DInt dataset, so the model only ever gets called with explicit lo and hi edges. Now that we no-longer support evaluating the model with a single grid this test may not add much power, but leave in for now. Notes ----- There's no check of a non-contiguous grid. """ from sherpa.astro import xspec spl = PowLaw1D('sherpa') xpl = xspec.XSpowerlaw('xspec') spl.gamma = 0.7 xpl.phoindex = 0.7 egrid = np.arange(0.1, 2, 0.01) elo = egrid[:-1] ehi = egrid[1:] nbins = elo.size def check_bins(lbl, mdl): y = mdl(elo, ehi) assert y.size == nbins, f'{lbl}: elo/ehi' # verify assumptions # check_bins('Sherpa model', spl) check_bins('XSPEC model', xpl) # Now try the convolved versions # cflux = xspec.XScflux("conv") check_bins('Convolved Sherpa', cflux(spl)) check_bins('Convolved XSPEC', cflux(xpl))
def test_link_parameter_setting(): """See https://github.com/sherpa/sherpa/issues/742 See also test_link_parameter_evaluation. """ mdl = PowLaw1D() lmdl = Const1D() # check we have the -10/10 range for the gamma # (so that if this changes we know to change this test) # assert mdl.gamma.min == pytest.approx(-10) assert mdl.gamma.max == pytest.approx(10) # Just check we can link the parameter lmdl.c0 = 2 mdl.gamma = lmdl.c0 assert mdl.gamma.val == pytest.approx(2) lmdl.c0 = 3 assert mdl.gamma.val == pytest.approx(3) # What happens when we set lmdl.c0 to a value outside # the valid range for mdl? # # The error is raised when we try to access the value # of the parameter with the link, and *not* when we set # the parameter that is linked to. # lmdl.c0 = 23 emsg = 'parameter powlaw1d.gamma has a maximum of 10' with pytest.raises(ParameterErr, match=emsg): mdl.gamma.val lmdl.c0 = -23 emsg = 'parameter powlaw1d.gamma has a minimum of -10' with pytest.raises(ParameterErr, match=emsg): mdl.gamma.val lmdl.c0 = -2 assert mdl.gamma.val == pytest.approx(-2)
def test_orderplot_checks_colors_explicit_orders(orders): """Check we raise a PlotErr. We check both the default orders setting (None) and an explicit setting as, when writing this test, I found an error in the handling of the None case. """ oplot = OrderPlot() pha = example_pha_data() model = PowLaw1D('example-pl') with pytest.raises(PlotErr) as pe: oplot.prepare(pha, model, orders=orders, colors=['green', 'orange']) assert str( pe.value ) == "orders list length '1' does not match colors list length '2'"
def test_regrid1d_int_flux(): """Check integration models using an XSPEC-style c[p]flux model. """ gamma = 1.7 pmdl = PowLaw1D() pmdl.gamma = gamma fluxmdl = ReNormalizerKernel1DInt() fluxmdl.flux = 20.0 fluxmdl.lo = 10.0 fluxmdl.hi = 20 grid = np.arange(1.0, 9.0, 0.01) glo = grid[:-1] ghi = grid[1:] mdl = fluxmdl(pmdl) regrid = ModelDomainRegridder1D() rmdl = regrid.apply_to(mdl) # ensure it covers the 10 - 20 range as well as 1-9. Pick # a smaller grid size than the output grid. # xfull = np.arange(0, 22, 0.005) regrid.grid = xfull[:-1], xfull[1:] y_regrid = rmdl(glo, ghi) assert y_regrid.shape == glo.shape # Model flux in lo/hi range is int_lo^hi x^-gamma dx (since norm # and reference of the power law are both 1.0). This is, since # gamma is not 1, [x^(1-gamma)]^hi_lo / (1 - gamma). # term = 1.0 - gamma renorm = (20**term - 10**term) / term y_expected = pmdl(glo, ghi) * 20 / renorm assert_allclose(y_regrid, y_expected, atol=1e-10, rtol=0)
def test_cflux_settings(): """Do the expected things happen when a model is calculated?""" from sherpa.astro import xspec kern = xspec.XScflux('cflux') assert isinstance(kern, xspec.XSConvolutionKernel), \ "cflux creates XSConvolutionKernel" cfluxpars = [('Emin', 0.5, True, 'keV'), ('Emax', 10.0, True, 'keV'), ('lg10Flux', -12, False, 'cgs')] _check_pars('cflux', kern, cfluxpars) mdl = kern(PowLaw1D('pl')) assert isinstance(mdl, xspec.XSConvolutionModel), \ "cflux(mdl) creates XSConvolutionModel" plpars = [('gamma', 1.0, False, ''), ('ref', 1.0, True, ''), ('ampl', 1.0, False, '')] _check_pars('model', mdl, cfluxpars + plpars)
def test_rmf1d_delta_pha_zero_energy_bin(): "What happens when the first bin starts at 0, with replacement" ethresh = 2e-7 egrid = np.asarray([0.0, 0.1, 0.2, 0.4, 0.5, 0.7, 0.8]) elo = egrid[:-1] ehi = egrid[1:] 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) exposure = 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=exposure) pha.set_rmf(rdata) pha.set_analysis('energy') mdl = MyPowLaw1D() tmdl = PowLaw1D() wrapped = RMFModelPHA(rdata, pha, mdl) out = wrapped([0.1, 0.2]) elo[0] = ethresh expected = tmdl(elo, ehi) assert_allclose(out, expected) assert not np.isnan(out[0])
def test_rsp1d_delta_no_pha_zero_energy_bin(): "What happens when the first bin starts at 0, with replacement" ethresh = 1.0e-9 exposure = 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=exposure, ethresh=ethresh) validate_zero_replacement(ws, 'ARF', 'test-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) mdl = MyPowLaw1D() tmdl = PowLaw1D() wrapped = RSPModelNoPHA(adata, rdata, 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 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") dump("inst(np.arange(1, 1025))") dump("inst([0.1, 0.2, 0.3])") dump("inst([0.1, 0.2, 0.3]).size") dump("inst([10, 20]) == inst([])")
y = pha.get_y(filter=True) dplot.plot(xlog=True, ylog=True) plt.plot(x, y) savefig('pha_data_compare.png') pha.set_analysis('wave') dump("pha.get_x().max()") wplot = DataPlot() wplot.prepare(pha) wplot.plot() savefig('pha_data_wave.png') pha.set_analysis('energy') from sherpa.models.basic import PowLaw1D from sherpa.astro.xspec import XSphabs pl = PowLaw1D() gal = XSphabs() mdl = gal * pl pl.gamma = 1.7 gal.nh = 0.2 report("mdl") egrid = np.arange(0.1, 10, 0.01) elo, ehi = egrid[:-1], egrid[1:] emid = (elo + ehi) / 2 plt.clf() plt.plot(emid, mdl(elo, ehi), label='Absorbed') plt.plot(emid, pl(elo, ehi), ':', label='Unabsorbed') plt.xscale('log')
def calc(self, pars, *args, **kwargs): out = PowLaw1D.calc(self, pars, *args, **kwargs) if args[0][0] <= 0.0: out[0] = np.nan return out
def setup_covar(make_data_path): print("A") ui.load_data(make_data_path('sim.poisson.1.dat')) ui.set_model(PowLaw1D("p1"))