def check_integrals(): """Check that Sherpa normed models integrate to 1.""" from sherpa.astro import ui from sherpa.astro.ui import normgauss2d from models import normdisk2d, normshell2d ui.clean() g = normgauss2d('g') g.xpos, g.ypos, g.ampl, g.fwhm = 100, 100, 42, 5 d = normdisk2d('d') d.xpos, d.ypos, d.ampl, d.r0 = 100, 100, 42, 50 s = normshell2d('s') s.xpos, s.ypos, s.ampl, s.r0, s.width = 100, 100, 42, 30, 20 models = [g, d, s] ui.dataspace2d((200, 200)) for model in models: ui.set_model(model) # In sherpa normed model values are flux per pixel area. # So to get the total flux (represented by the `ampl` parameter) # one can simply sum over all pixels, because a pixel has area 1 pix^2. # :-) integral = ui.get_model_image().y.sum() print model.name, integral
def test_eqwith_err1(make_data_path, restore_xspec_settings): def check1(e0, e1, e2): assert e0 == pytest.approx(0.028335201547206704, rel=1.0e-3) assert e1 == pytest.approx(-0.00744118799274448756, rel=1.0e-3) assert e2 == pytest.approx(0.0706249544851336, rel=1.0e-3) ui.set_xsabund('angr') ui.set_xsxsect('bcmc') ui.load_pha(make_data_path('3c273.pi')) ui.notice(0.5, 7.0) ui.set_stat("chi2datavar") ui.set_method("simplex") ui.set_model('powlaw1d.p1+gauss1d.g1') g1.fwhm = 0.1 g1.pos = 2.0 ui.freeze(g1.pos, g1.fwhm) ui.fit() np.random.seed(2345) e = ui.eqwidth(p1, p1 + g1, error=True, niter=100) check1(e[0], e[1], e[2]) params = e[3] np.random.seed(2345) e = ui.eqwidth(p1, p1 + g1, error=True, params=params, niter=100) check1(e[0], e[1], e[2]) parvals = ui.get_fit_results().parvals assert parvals[0] == pytest.approx(1.9055272902160334, rel=1.0e-3) assert parvals[1] == pytest.approx(0.00017387966749772638, rel=1.0e-3) assert parvals[2] == pytest.approx(1.279415076070516e-05, rel=1.0e-3)
def test_ARFModelPHA(self): from sherpa.astro import ui ui.load_pha(self.make_path("3c120_meg_1.pha")) # remove the RMF to ensure this is an ARF-only analysis # (which is what is needed to trigger the bug that lead to #699) ui.get_data().set_rmf(None) ui.group_counts(20) ui.notice(0.5, 6) ui.subtract() ui.set_model(ui.xsphabs.abs1 * (ui.xsapec.bubble + ui.powlaw1d.p1)) ui.set_xsabund('angr') ui.set_xsxsect('vern') abs1.nh = 0.163 abs1.nh.freeze() p1.ampl = 0.017 p1.gamma = 1.9 bubble.kt = 0.5 bubble.norm = 4.2e-5 tol = 1.0e-2 ui.set_method_opt('ftol', tol) ui.fit() result = ui.get_fit_results() assert result.numpoints == self._fit_using_ARFModelPHA['numpoints'] assert result.dof == self._fit_using_ARFModelPHA['dof']
def test_eqwith_err1(make_data_path, restore_xspec_settings): def check1(e0, e1, e2): assert e0 == approx(0.028335201547206704, rel=1.0e-3) assert e1 == approx(-0.00744118799274448756, rel=1.0e-3) assert e2 == approx(0.0706249544851336, rel=1.0e-3) ui.set_xsabund('angr') ui.set_xsxsect('bcmc') ui.load_pha(make_data_path('3c273.pi')) ui.notice(0.5, 7.0) ui.set_stat("chi2datavar") ui.set_method("simplex") ui.set_model('powlaw1d.p1+gauss1d.g1') g1.fwhm = 0.1 g1.pos = 2.0 ui.freeze(g1.pos, g1.fwhm) ui.fit() numpy.random.seed(2345) e = ui.eqwidth(p1, p1 + g1, error=True, niter=100) check1(e[0], e[1], e[2]) params = e[3] numpy.random.seed(2345) e = ui.eqwidth(p1, p1 + g1, error=True, params=params, niter=100) check1(e[0], e[1], e[2]) parvals = ui.get_fit_results().parvals assert parvals[0] == approx(1.9055272902160334, rel=1.0e-3) assert parvals[1] == approx(0.00017387966749772638, rel=1.0e-3) assert parvals[2] == approx(1.279415076070516e-05, rel=1.0e-3)
def test_sherpa_fit(self, tmpdir): # this is to make sure that the written PHA files work with sherpa import sherpa.astro.ui as sau from sherpa.models import PowLaw1D # TODO: this works a little bit, but some info and warnings # from Sherpa remain. Not sure what to do, OK as-is for now. import logging logging.getLogger("sherpa").setLevel("ERROR") for obs in self.obs_list: obs.to_ogip_files(str(tmpdir), use_sherpa=True) filename = tmpdir / "pha_obs23523.fits" sau.load_pha(str(filename)) sau.set_stat("wstat") model = PowLaw1D("powlaw1d.default") model.ref = 1e9 model.ampl = 1 model.gamma = 2 sau.set_model(model * 1e-20) sau.fit() assert_allclose(model.pars[0].val, 2.732, rtol=1e-3) assert_allclose(model.pars[2].val, 4.647, rtol=1e-3)
def test_bug_276(make_data_path): ui.load_pha(make_data_path('3c273.pi')) ui.set_model('polynom1d.p1') ui.fit() ui.covar() scal = ui.get_covar_results().parmaxes ui.sample_flux(ui.get_model_component('p1'), 0.5, 1, num=5, correlated=False, scales=scal)
def fit_coeffs(method='simplex'): method = method dummy_data = np.zeros(100) dummy_times = np.arange(100) ui.load_arrays(1, dummy_times, dummy_data) ui.set_method(method) ui.get_method().config.update(SHERPA_CONFIGS.get(method, {})) calc_model = CalcModel() ui.load_user_model(calc_model, 'axo_mod') # sets global axo_mod parnames = [] for row in range(N_ROWS): for col in range(N_COLS): parnames.append('adj_{}_{}'.format(row, col)) ui.add_user_pars('axo_mod', parnames) ui.set_model(1, 'axo_mod') calc_stat = CalcStat(axo_mod, M_2d, displ_x) ui.load_user_stat('axo_stat', calc_stat, lambda x: np.ones_like(x)) ui.set_stat(axo_stat) calc_model.set_calc_stat(calc_stat) # Set frozen, min, and max attributes for each axo_mod parameter for par in axo_mod.pars: par.val = 0.0 par.min = -5 par.max = 5 ui.fit(1) coeffs = np.array([(par.val) for pars in axo_mod.pars]) return coeffs
def test_user_stat_unit(): given_stat_error = [1.1, 2.2, 3.3] given_sys_error = [10.1, 10.2, 10.3] def calc_stat(data, _model, staterror, syserror=None, weight=None): # Make sure values are being injected correctly np.testing.assert_array_equal(given_stat_error, staterror) np.testing.assert_array_equal(given_sys_error, syserror) return 3.235, np.ones_like(data) xdata = [1, 2, 3] ydata = xdata ui.load_arrays(1, xdata, ydata, None, given_sys_error, Data1D) ui.set_model(1, 'polynom1d.p') ui.load_user_stat('customstat', calc_stat, lambda x: given_stat_error) ui.set_stat(eval('customstat')) try: ui.fit(1) except StatErr: pytest.fail("Call should not be throwing any exception (bug #341)") # Test the result is what we made the user stat return assert 3.235 == ui.get_fit_results().statval
def match_wcs(wcs_img, sky_img, sky_ref, opt_alg='scipy'): """Adjust ``wcs_img`` (CRVAL{1,2} and CD{1,2}_{1,2}) using a rotation and linear offset so that ``coords_img`` matches ``coords_ref``. :param sky_img: list of (world_x, world_y) [aka RA, Dec] coords in input image :param sky_ref: list of reference (world_x, world_y) coords to match :param wcs_img: pywcs WCS object for input image :returns: d_ra, d_dec, d_theta """ pix_img = wcs_img.wcs_sky2pix(sky_img, 1) wcsmodel = WcsModel(wcs_img, sky_ref, pix_img) y = np.array(pix_img).flatten() if opt_alg == 'sherpa': x = np.arange(len(y)) import sherpa.astro.ui as ui ui.load_user_model(wcsmodel.calc_pix, 'wcsmod') ui.add_user_pars('wcsmod', ['d_ra', 'd_dec', 'd_theta']) wcsmod.d_ra = 0.0 wcsmod.d_dec = 0.0 wcsmod.d_theta = 0.0 ui.load_arrays(1, x, y, np.ones(len(y))) ui.set_model(1, wcsmod) ui.set_method('simplex') ui.fit() else: import scipy.optimize x0 = np.array([0.0, 0.0, 0.0]) d_ra, d_dec, d_theta = scipy.optimize.fmin(wcsmodel.calc_resid2, x0) print 'Scipy fit values:', d_ra, d_dec, d_theta return wcsmodel.wcs
def test_plot_pvalue(make_data_path, clean_astro_ui, hide_log_output): fname = make_data_path("qso.pi") ui.load_pha(fname) ui.set_stat('cstat') ui.set_method("neldermead") ui.group_counts(10) ui.notice(0.3, 8) ui.set_model("xsphabs.abs1*xspowerlaw.p1") ui.set_model("abs1*(p1+gauss1d.g1)") # move the fit close to the best fit to save a small amount # of time. abs1.nh = 0.05 p1.phoindex = 1.28 p1.norm = 2e-4 g1.ampl = 1.8e-5 g1.pos = 3. ui.freeze(g1.pos) g1.fwhm = 0.1 ui.freeze(g1.fwhm) ui.fit() ui.plot_pvalue(p1, p1 + g1, num=100) tmp = ui.get_pvalue_results() assert tmp.null == pytest.approx(210.34566845619273) assert tmp.alt == pytest.approx(207.66618095925094) assert tmp.lr == pytest.approx(2.679487496941789)
def test_background(): tmpdir = tempfile.mkdtemp() curdir = os.getcwd() os.chdir(tmpdir) kT_sim = 1.0 Z_sim = 0.0 norm_sim = 4.0e-2 nH_sim = 0.04 redshift = 0.01 exp_time = (200., "ks") area = (1000., "cm**2") wcs = create_dummy_wcs() abs_model = WabsModel(nH_sim) events = EventList.create_empty_list(exp_time, area, wcs) spec_model = TableApecModel(0.05, 12.0, 5000, thermal_broad=False) spec = spec_model.return_spectrum(kT_sim, Z_sim, redshift, norm_sim) new_events = events.add_background(spec_model.ebins, spec, prng=prng, absorb_model=abs_model) new_events = ACIS_I(new_events, rebin=False, convolve_psf=False, prng=prng) new_events.write_spectrum("background_evt.pi", clobber=True) os.system("cp %s ." % new_events.parameters["ARF"]) os.system("cp %s ." % new_events.parameters["RMF"]) load_user_model(mymodel, "wapec") add_user_pars("wapec", ["nH", "kT", "metallicity", "redshift", "norm"], [0.01, 4.0, 0.2, redshift, norm_sim*0.8], parmins=[0.0, 0.1, 0.0, -20.0, 0.0], parmaxs=[10.0, 20.0, 10.0, 20.0, 1.0e9], parfrozen=[False, False, False, True, False]) load_pha("background_evt.pi") set_stat("cstat") set_method("simplex") ignore(":0.5, 8.0:") set_model("wapec") fit() set_covar_opt("sigma", 1.6) covar() res = get_covar_results() assert np.abs(res.parvals[0]-nH_sim) < res.parmaxes[0] assert np.abs(res.parvals[1]-kT_sim) < res.parmaxes[1] assert np.abs(res.parvals[2]-Z_sim) < res.parmaxes[2] assert np.abs(res.parvals[3]-norm_sim) < res.parmaxes[3] os.chdir(curdir) shutil.rmtree(tmpdir)
def test_background(): tmpdir = tempfile.mkdtemp() curdir = os.getcwd() os.chdir(tmpdir) kT_sim = 1.0 Z_sim = 0.0 norm_sim = 4.0e-2 nH_sim = 0.04 redshift = 0.01 exp_time = (200., "ks") area = (1000., "cm**2") fov = (10.0, "arcmin") prng = 24 agen = ApecGenerator(0.05, 12.0, 5000, broadening=False) spec = agen.get_spectrum(kT_sim, Z_sim, redshift, norm_sim) spec.apply_foreground_absorption(norm_sim) events = make_background(area, exp_time, fov, (30.0, 45.0), spec, prng=prng) events.write_simput_file("bkgnd", overwrite=True) instrument_simulator("bkgnd_simput.fits", "bkgnd_evt.fits", exp_time, "sq_acisi_cy19", [30.0, 45.0], overwrite=True, foreground=False, ptsrc_bkgnd=False, instr_bkgnd=False, prng=prng) write_spectrum("bkgnd_evt.fits", "background_evt.pi", overwrite=True) os.system("cp %s %s ." % (arf.filename, rmf.filename)) load_user_model(mymodel, "wapec") add_user_pars("wapec", ["nH", "kT", "metallicity", "redshift", "norm"], [0.01, 4.0, 0.2, redshift, norm_sim*0.8], parmins=[0.0, 0.1, 0.0, -20.0, 0.0], parmaxs=[10.0, 20.0, 10.0, 20.0, 1.0e9], parfrozen=[False, False, False, True, False]) load_pha("background_evt.pi") set_stat("cstat") set_method("simplex") ignore(":0.5, 8.0:") set_model("wapec") fit() res = get_fit_results() assert np.abs(res.parvals[0]-nH_sim)/nH_sim < 0.1 assert np.abs(res.parvals[1]-kT_sim)/kT_sim < 0.05 assert np.abs(res.parvals[2]-Z_sim) < 0.05 assert np.abs(res.parvals[3]-norm_sim)/norm_sim < 0.05 os.chdir(curdir) shutil.rmtree(tmpdir)
def test_point_source(): tmpdir = tempfile.mkdtemp() curdir = os.getcwd() os.chdir(tmpdir) nH_sim = 0.02 norm_sim = 1.0e-4 alpha_sim = 0.95 redshift = 0.02 exp_time = (100., "ks") area = (3000., "cm**2") spec = Spectrum.from_powerlaw(alpha_sim, redshift, norm_sim, emin=0.1, emax=11.5, nbins=2000) spec.apply_foreground_absorption(nH_sim, model="tbabs") positions = [(30.01, 45.0)] events = make_point_sources(area, exp_time, positions, (30.0, 45.0), spec, prng=prng) events.write_simput_file("ptsrc", overwrite=True) instrument_simulator("ptsrc_simput.fits", "ptsrc_evt.fits", exp_time, "sq_aciss_cy19", [30.0, 45.0], overwrite=True, foreground=False, ptsrc_bkgnd=False, instr_bkgnd=False, prng=prng) write_spectrum("ptsrc_evt.fits", "point_source_evt.pi", overwrite=True) os.system("cp %s %s ." % (arf.filename, rmf.filename)) load_user_model(mymodel, "tplaw") add_user_pars("tplaw", ["nH", "norm", "redshift", "alpha"], [0.02, norm_sim*0.8, redshift, 0.9], parmins=[0.0, 0.0, 0.0, 0.1], parmaxs=[10.0, 1.0e9, 10.0, 10.0], parfrozen=[True, False, True, False]) load_pha("point_source_evt.pi") set_stat("cstat") set_method("simplex") ignore(":0.4, 9.0:") set_model("tplaw") fit() res = get_fit_results() assert np.abs(res.parvals[0]-norm_sim)/norm_sim < 0.05 assert np.abs(res.parvals[1]-alpha_sim)/alpha_sim < 0.05 os.chdir(curdir) shutil.rmtree(tmpdir)
def test_point_source(): tmpdir = tempfile.mkdtemp() curdir = os.getcwd() os.chdir(tmpdir) nH_sim = 0.02 norm_sim = 1.0e-4 alpha_sim = 0.95 redshift = 0.02 exp_time = (100., "ks") area = (3000., "cm**2") spec = Spectrum.from_powerlaw(alpha_sim, redshift, norm_sim, emin=0.1, emax=11.5, nbins=2000) spec.apply_foreground_absorption(nH_sim, model="tbabs") positions = [(30.01, 45.0)] events = make_point_sources(area, exp_time, positions, (30.0, 45.0), spec, prng=prng) events.write_simput_file("ptsrc", overwrite=True) instrument_simulator("ptsrc_simput.fits", "ptsrc_evt.fits", exp_time, "sq_aciss_cy20", [30.0, 45.0], overwrite=True, foreground=False, ptsrc_bkgnd=False, instr_bkgnd=False, prng=prng) write_spectrum("ptsrc_evt.fits", "point_source_evt.pi", overwrite=True) os.system("cp %s %s ." % (arf.filename, rmf.filename)) load_user_model(mymodel, "tplaw") add_user_pars("tplaw", ["nH", "norm", "redshift", "alpha"], [0.02, norm_sim*0.8, redshift, 0.9], parmins=[0.0, 0.0, 0.0, 0.1], parmaxs=[10.0, 1.0e9, 10.0, 10.0], parfrozen=[True, False, True, False]) load_pha("point_source_evt.pi") set_stat("cstat") set_method("simplex") ignore(":0.4, 9.0:") set_model("tplaw") fit() res = get_fit_results() assert np.abs(res.parvals[0]-norm_sim)/norm_sim < 0.05 assert np.abs(res.parvals[1]-alpha_sim)/alpha_sim < 0.05 os.chdir(curdir) shutil.rmtree(tmpdir)
def test_load_multi_arfsrmfs(make_data_path, clean_astro_ui): """Added in #728 to ensure cache parameter is sent along by MultiResponseSumModel (fix #717). This has since been simplified to switch from xsapec to powlaw1d as it drops the need for XSPEC and is a simpler model, so is less affected by changes in the model code. A fit of the Sherpa powerlaw-model to 3c273.pi with a single response in CIAO 4.11 (background subtracted, 0.5-7 keV) returns gamma = 1.9298, ampl = 1.73862e-4 so doubling the response should halve the amplitude but leave the gamma value the same when using two responses, as below. This is with chi2datavar. """ pha_pi = make_data_path("3c273.pi") ui.load_pha(1, pha_pi) ui.load_pha(2, pha_pi) arf = make_data_path("3c273.arf") rmf = make_data_path("3c273.rmf") ui.load_multi_arfs(1, [arf, arf], [1, 2]) ui.load_multi_arfs(2, [arf, arf], [1, 2]) ui.load_multi_rmfs(1, [rmf, rmf], [1, 2]) ui.load_multi_rmfs(2, [rmf, rmf], [1, 2]) ui.notice(0.5, 7) ui.subtract(1) ui.subtract(2) src = ui.create_model_component('powlaw1d', 'src') ui.set_model(1, src) ui.set_model(2, src) # ensure the test is repeatable by running with a known # statistic and method # ui.set_method('levmar') ui.set_stat('chi2datavar') # Really what we care about for fixing #717 is that # fit does not error out, but it's useful to know that # the fit has changed the parameter values (which were # both 1 before the fit). # ui.fit() fr = ui.get_fit_results() assert fr.succeeded assert fr.datasets == (1, 2) assert src.gamma.val == pytest.approx(1.9298, rel=1.0e-4) assert src.ampl.val == pytest.approx(1.73862e-4 / 2, rel=1.0e-4)
def test_ui(self, tol=1.0e-3): # from shepa.astro.ui import * ui.load_ascii_with_errors(1, self.gro_delta_fname, delta=True) ui.set_stat('leastsq') ui.set_model('powlaw1d.p1') ui.fit() sample = ui.resample_data(1, 10, seed=123) self.assertEqualWithinTol(self._resample_bench_10['p1.gamma'], sample['p1.gamma']) self.assertEqualWithinTol(self._resample_bench_10['p1.ampl'], sample['p1.ampl'])
def test_warning(self): ui.load_ascii_with_errors(1, self.gro_fname) data = ui.get_data(1) powlaw1d = PowLaw1D('p1') ui.set_model(powlaw1d) fit = Fit(data, powlaw1d) results = fit.fit() with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") ui.resample_data(1, 3) assert len(w) == 0
def test_ui(make_data_path): infile = make_data_path('gro_delta.txt') ui.load_ascii_with_errors(1, infile, delta=True) ui.set_stat('leastsq') ui.set_model('powlaw1d.p1') ui.fit() sample = ui.resample_data(1, 10, seed=123) for p in ['p1.gamma', 'p1.ampl']: assert sample[p] == pytest.approx(RESAMPLE_BENCH_10[p], rel=1e-4)
def test_warning(make_data_path): infile = make_data_path('gro.txt') ui.load_ascii_with_errors(1, infile) powlaw1d = PowLaw1D('p1') ui.set_model(powlaw1d) ui.fit() with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") ui.resample_data(1, 3) assert len(w) == 0
def fit_adjuster_set(coeffs, adj_idxs, method='simplex'): """ Find best fit parameters for an arbitrary subset of adjustors specified by the array ``adj_idxs``. The input ``coeffs`` are the best-fit adjustor coefficients for the last iteration. """ import sherpa.astro.ui as ui dummy_data = np.zeros(100) dummy_times = np.arange(100) ui.load_arrays(1, dummy_times, dummy_data) ui.set_method(method) ui.get_method().config.update(SHERPA_CONFIGS.get(method, {})) calc_model = CalcModel() ui.load_user_model(calc_model, 'axo_mod') # sets global axo_mod parnames = [] for adj_idx in adj_idxs: parnames.append('adj_{}'.format(adj_idx)) ui.add_user_pars('axo_mod', parnames) ui.set_model(1, 'axo_mod') coeffs = coeffs.copy() # Don't modify input coeffs coeffs[coeffs < 0] = 0 # Don't allow negative coeffs # Set frozen, min, and max attributes for each axo_mod parameter for adj_idx, par in zip(adj_idxs, axo_mod.pars): par.min = -1000 par.max = 1000 par.val = coeffs[adj_idx] print 'Setting {} to {}'.format(adj_idx, par.val) # Compute base adjusted displacements assuming all the fitted actuators # have zero drive level. coeffs[adj_idxs] = 0 base_adj_displ = M_2d.dot(coeffs) m_2d = M_2d[:, adj_idxs].copy() print m_2d.shape calc_stat = CalcStat(base_adj_displ, m_2d, DISPL_X) ui.load_user_stat('axo_stat', calc_stat, lambda x: np.ones_like(x)) ui.set_stat(axo_stat) calc_model.set_calc_stat(calc_stat) ui.fit(1) # Update coeffs with the values determined in fitting for adj_idx, par in zip(adj_idxs, axo_mod.pars): coeffs[adj_idx] = abs(par.val) return coeffs, ui.get_fit_results()
def test_missmatch_arf(make_data_path): ui.load_pha(1, make_data_path("source1.pi")) ui.load_bkg(1, make_data_path("back1.pi")) ui.load_arf(1, make_data_path("arf_1024.fits")) ui.load_rmf(1, make_data_path("rmf_1024.fits")) ui.set_method('levmar') ui.set_model(ui.powlaw1d.p1 * ui.xswabs.abs1) ui.set_par('p1.ampl', 0.0001) ui.set_stat('cash') ui.fit() parvals = ui.get_fit_results().parvals assert parvals[0] == approx(1.47969, rel=1.0e-3) assert parvals[1] == approx(0.0019491, rel=1.0e-3) assert parvals[2] == approx(2.35452, rel=1.0e-3)
def test_ui_regrid1d_non_overlapping_not_allowed(): """Integrated data space must not overlap""" ui.dataspace1d(1, 100, 2, dstype=Data1DInt) b1 = Box1D() ui.set_model(b1) b1.xlow = 10 b1.xhi = 80 b1.ampl.max = 100 grid_hi = np.linspace(2, 101, 600) grid_lo = np.linspace(1, 100, 600) with pytest.raises(ModelErr) as excinfo: rb1 = b1.regrid(grid_lo, grid_hi) assert ModelErr.dict['needsint'] in str(excinfo.value)
def test_sherpa_fit(tmpdir): # this is to make sure that the written PHA files work with sherpa pha1 = gammapy_extra.filename("datasets/hess-crab4_pha/pha_obs23592.fits") import sherpa.astro.ui as sau from sherpa.models import PowLaw1D sau.load_pha(pha1) sau.set_stat('wstat') model = PowLaw1D('powlaw1d.default') model.ref = 1e9 model.ampl = 1 model.gamma = 2 sau.set_model(model * 1e-20) sau.fit() assert_allclose(model.pars[0].val, 2.0281484215403616, atol=1e-4) assert_allclose(model.pars[2].val, 2.3528406790143097, atol=1e-4)
def test_sherpa_fit(self, tmpdir): # this is to make sure that the written PHA files work with sherpa import sherpa.astro.ui as sau from sherpa.models import PowLaw1D self.obs_list.write(tmpdir, use_sherpa=True) filename = tmpdir / 'pha_obs23523.fits' sau.load_pha(str(filename)) sau.set_stat('wstat') model = PowLaw1D('powlaw1d.default') model.ref = 1e9 model.ampl = 1 model.gamma = 2 sau.set_model(model * 1e-20) sau.fit() assert_allclose(model.pars[0].val, 2.0881699260935838) assert_allclose(model.pars[2].val, 1.6234222129479836)
def test_sherpa_fit(tmpdir): # this is to make sure that the written PHA files work with sherpa import sherpa.astro.ui as sau from sherpa.models import PowLaw1D filename = gammapy_extra.filename( "datasets/hess-crab4_pha/pha_obs23592.fits") sau.load_pha(filename) sau.set_stat('wstat') model = PowLaw1D('powlaw1d.default') model.ref = 1e9 model.ampl = 1 model.gamma = 2 sau.set_model(model * 1e-20) sau.fit() assert_allclose(model.pars[0].val, 2.0033101181778026) assert_allclose(model.pars[2].val, 2.2991681244938498)
def test_sherpa_fit(self, tmpdir): # this is to make sure that the written PHA files work with sherpa import sherpa.astro.ui as sau from sherpa.models import PowLaw1D self.obs_list.write(tmpdir, use_sherpa=True) filename = tmpdir / 'pha_obs23523.fits' sau.load_pha(str(filename)) sau.set_stat('wstat') model = PowLaw1D('powlaw1d.default') model.ref = 1e9 model.ampl = 1 model.gamma = 2 sau.set_model(model * 1e-20) sau.fit() assert_allclose(model.pars[0].val, 2.0881699, rtol=1e-3) assert_allclose(model.pars[2].val, 1.6234222, rtol=1e-3)
def test_user_model_stat_docs(): """ This test reproduces the documentation shown at: http://cxc.harvard.edu/sherpa4.4/statistics/#userstat and: http://cxc.harvard.edu/sherpa/threads/user_model/ I tried to be as faithful as possible to the original, although the examples in thedocs are not completely self-contained, so some changes were necessary. I changed the numpy reference, as it is imported as `np` here, and added a clean up of the environment before doing anything. For the model, the difference is that I am not importing the function from an external module, plus the dataset is different. Also, the stats docs do not perform a fit. """ def my_stat_func(data, model, staterror, syserror=None, weight=None): # A simple function to replicate χ2 fvec = ((data - model) / staterror)**2 stat = fvec.sum() return (stat, fvec) def my_staterr_func(data): # A simple staterror function return np.sqrt(data) def myline(pars, x): return pars[0]*x + pars[1] x = [1, 2, 3] y = [4, 5, 6.01] ui.clean() ui.load_arrays(1, x, y) ui.load_user_stat("mystat", my_stat_func, my_staterr_func) ui.set_stat(eval('mystat')) ui.load_user_model(myline, "myl") ui.add_user_pars("myl", ["m", "b"]) ui.set_model(eval('myl')) ui.fit() assert ui.get_par("myl.m").val == approx(1, abs=0.01) assert ui.get_par("myl.b").val == approx(3, abs=0.01)
def test_rsp(self): fname = self.make_path("qso.pi") ui.load_pha(fname) ui.set_stat("chi2xspecvar") ui.set_method("neldermead") ui.group_counts(10) ui.notice(0.3, 8) ui.set_model("xsphabs.abs1*xspowerlaw.p1") ui.set_model("abs1*(p1+gauss1d.g1)") g1.pos = 3. ui.freeze(g1.pos) g1.fwhm = 0.1 ui.freeze(g1.fwhm) ui.set_stat('cstat') ui.fit() ui.plot_pvalue(p1, p1 + g1, num=100) tmp = ui.get_pvalue_results() expected = [210.34566845619273, 207.66618095925094, 2.679487496941789] self.compare_results(expected, [tmp.null, tmp.alt, tmp.lr])
def test_eqwith_err(make_data_path, restore_xspec_settings): def check(a0, a1, a2): assert a0 == pytest.approx(0.16443033244310976, rel=1e-3) assert a1 == pytest.approx(0.09205564216156815, rel=1e-3) assert a2 == pytest.approx(0.23933118287470895, rel=1e-3) ui.set_method('neldermead') ui.set_stat('cstat') ui.set_xsabund('angr') ui.set_xsxsect('bcmc') ui.load_data(make_data_path('12845.pi')) ui.notice(0.5, 7) ui.set_model("xsphabs.gal*xszphabs.zabs*(powlaw1d.p1+xszgauss.g1)") ui.set_par(gal.nh, 0.08) ui.freeze(gal) ui.set_par(zabs.redshift, 0.518) ui.set_par(g1.redshift, 0.518) ui.set_par(g1.Sigma, 0.01) ui.freeze(g1.Sigma) ui.set_par(g1.LineE, min=6.0, max=7.0) ui.fit() np.random.seed(12345) result = ui.eqwidth(p1, p1 + g1, error=True, niter=100) check(result[0], result[1], result[2]) params = result[3] np.random.seed(12345) result = ui.eqwidth(p1, p1 + g1, error=True, params=params, niter=100) check(result[0], result[1], result[2]) parvals = ui.get_fit_results().parvals assert parvals[0] == pytest.approx(0.6111340686157877, rel=1.0e-3) assert parvals[1] == pytest.approx(1.6409785803466297, rel=1.0e-3) assert parvals[2] == pytest.approx(8.960926761312153e-05, rel=1.0e-3) assert parvals[3] == pytest.approx(6.620017726014523, rel=1.0e-3) assert parvals[4] == pytest.approx(1.9279114810359657e-06, rel=1.0e-3)
def test_eqwith_err(make_data_path, restore_xspec_settings): def check(a0, a1, a2): assert a0 == approx(0.16443033244310976, rel=1e-3) assert a1 == approx(0.09205564216156815, rel=1e-3) assert a2 == approx(0.23933118287470895, rel=1e-3) ui.set_method('neldermead') ui.set_stat('cstat') ui.set_xsabund('angr') ui.set_xsxsect('bcmc') ui.load_data(make_data_path('12845.pi')) ui.notice(0.5, 7) ui.set_model("xsphabs.gal*xszphabs.zabs*(powlaw1d.p1+xszgauss.g1)") ui.set_par(gal.nh, 0.08) ui.freeze(gal) ui.set_par(zabs.redshift, 0.518) ui.set_par(g1.redshift, 0.518) ui.set_par(g1.Sigma, 0.01) ui.freeze(g1.Sigma) ui.set_par(g1.LineE, min=6.0, max=7.0) ui.fit() numpy.random.seed(12345) result = ui.eqwidth(p1, p1 + g1, error=True, niter=100) check(result[0], result[1], result[2]) params = result[3] numpy.random.seed(12345) result = ui.eqwidth(p1, p1 + g1, error=True, params=params, niter=100) check(result[0], result[1], result[2]) parvals = ui.get_fit_results().parvals assert parvals[0] == approx(0.6111340686157877, rel=1.0e-3) assert parvals[1] == approx(1.6409785803466297, rel=1.0e-3) assert parvals[2] == approx(8.960926761312153e-05, rel=1.0e-3) assert parvals[3] == approx(6.620017726014523, rel=1.0e-3) assert parvals[4] == approx(1.9279114810359657e-06, rel=1.0e-3)
def test_set_analysis_wave_fabrizio(self): rmf = self.datadir + '/ciao4.3/fabrizio/Data/3c273.rmf' arf = self.datadir + '/ciao4.3/fabrizio/Data/3c273.arf' ui.set_model("fabrizio", "xspowerlaw.p1") ui.fake_pha("fabrizio", arf, rmf, 10000) model = ui.get_model("fabrizio") bare_model, _ = ui._session._get_model_status("fabrizio") y = bare_model.calc([1, 1], model.xlo, model.xhi) y_m = numpy.mean(y) ui.set_analysis("fabrizio", "wave") model2 = ui.get_model("fabrizio") bare_model2, _ = ui._session._get_model_status("fabrizio") y2 = bare_model2.calc([1, 1], model2.xlo, model2.xhi) y2_m = numpy.mean(y2) self.assertAlmostEqual(y_m, y2_m)
def test_set_analysis_wave_fabrizio(self): rmf = self.datadir + '/ciao4.3/fabrizio/Data/3c273.rmf' arf = self.datadir + '/ciao4.3/fabrizio/Data/3c273.arf' ui.set_model("fabrizio", "xspowerlaw.p1") ui.fake_pha("fabrizio", arf, rmf, 10000) model = ui.get_model("fabrizio") bare_model, _ = ui._session._get_model_status("fabrizio") y = bare_model.calc([1,1], model.xlo, model.xhi) y_m = numpy.mean(y) ui.set_analysis("fabrizio","wave") model2 = ui.get_model("fabrizio") bare_model2, _ = ui._session._get_model_status("fabrizio") y2 = bare_model2.calc([1,1], model2.xlo, model2.xhi) y2_m = numpy.mean(y2) self.assertAlmostEqual(y_m, y2_m)
def test_load_multi_arfsrmfs(make_data_path): pha_pi = make_data_path("3c273.pi") ui.load_pha(1, pha_pi) ui.load_pha(2, pha_pi) bkg_pi = make_data_path("3c273_bg.pi") ui.load_bkg(1, bkg_pi) ui.load_bkg(2, bkg_pi) arf = make_data_path("3c273.arf") ui.load_multi_arfs(1, [arf, arf], [1, 2]) ui.load_multi_arfs(2, [arf, arf], [1, 2]) rmf = make_data_path("3c273.rmf") ui.load_multi_rmfs(1, [rmf, rmf], [1, 2]) ui.load_multi_rmfs(2, [rmf, rmf], [1, 2]) ui.set_model(1, ui.xsapec.src) ui.set_model(2, ui.xsapec.src) ui.fit() parvals = ui.get_fit_results().parvals assert (parvals[0] == pytest.approx(1.03364, rel=1.0e-3)) assert (parvals[1] == pytest.approx(4.56712e-05, rel=1.03e-3))
def test_set_analysis_wave_fabrizio(self): rmf = self.make_path('3c273.rmf') arf = self.make_path('3c273.arf') ui.set_model("fabrizio", "xspowerlaw.p1") ui.fake_pha("fabrizio", arf, rmf, 10000) parvals = [1, 1] model = ui.get_model("fabrizio") bare_model, _ = ui._session._get_model_status("fabrizio") y = bare_model.calc(parvals, model.xlo, model.xhi) y_m = numpy.mean(y) ui.set_analysis("fabrizio", "wave") model2 = ui.get_model("fabrizio") bare_model2, _ = ui._session._get_model_status("fabrizio") y2 = bare_model2.calc(parvals, model2.xlo, model2.xhi) y2_m = numpy.mean(y2) self.assertAlmostEqual(y_m, y2_m)
def test_set_analysis_wave_fabrizio(clean_astro_ui, make_data_path): rmf = make_data_path('3c273.rmf') arf = make_data_path('3c273.arf') ui.set_model("fabrizio", "xspowerlaw.p1") ui.fake_pha("fabrizio", arf, rmf, 10000) parvals = [1, 1] model = ui.get_model("fabrizio") bare_model, _ = ui._session._get_model_status("fabrizio") y = bare_model.calc(parvals, model.xlo, model.xhi) y_m = numpy.mean(y) ui.set_analysis("fabrizio", "wave") model2 = ui.get_model("fabrizio") bare_model2, _ = ui._session._get_model_status("fabrizio") y2 = bare_model2.calc(parvals, model2.xlo, model2.xhi) y2_m = numpy.mean(y2) assert y2_m == pytest.approx(y_m)
def test_sherpa_fit(self, tmpdir): # this is to make sure that the written PHA files work with sherpa import sherpa.astro.ui as sau from sherpa.models import PowLaw1D # TODO: this works a little bit, but some info and warnings # from Sherpa remain. Not sure what to do, OK as-is for now. import logging logging.getLogger("sherpa").setLevel("ERROR") self.obs_list.write(tmpdir, use_sherpa=True) filename = tmpdir / "pha_obs23523.fits" sau.load_pha(str(filename)) sau.set_stat("wstat") model = PowLaw1D("powlaw1d.default") model.ref = 1e9 model.ampl = 1 model.gamma = 2 sau.set_model(model * 1e-20) sau.fit() assert_allclose(model.pars[0].val, 2.732, rtol=1e-3) assert_allclose(model.pars[2].val, 4.647, rtol=1e-3)
def do_beta_model(source, v_field, em_field): tmpdir = tempfile.mkdtemp() curdir = os.getcwd() os.chdir(tmpdir) ds = source.ds A = 3000. exp_time = 1.0e5 redshift = 0.05 nH_sim = 0.02 apec_model = TableApecModel(0.1, 11.5, 20000, thermal_broad=False) abs_model = TBabsModel(nH_sim) sphere = ds.sphere("c", (0.5, "Mpc")) kT_sim = source.kT Z_sim = source.Z thermal_model = ThermalSourceModel(apec_model, Zmet=Z_sim, prng=source.prng) photons = PhotonList.from_data_source(sphere, redshift, A, exp_time, thermal_model) D_A = photons.parameters["FiducialAngularDiameterDistance"] norm_sim = sphere.quantities.total_quantity(em_field) norm_sim *= 1.0e-14 / (4 * np.pi * D_A * D_A * (1. + redshift) * (1. + redshift)) norm_sim = float(norm_sim.in_cgs()) v1, v2 = sphere.quantities.weighted_variance(v_field, em_field) sigma_sim = float(v1.in_units("km/s")) mu_sim = -float(v2.in_units("km/s")) events = photons.project_photons("z", absorb_model=abs_model, prng=source.prng) events = ACIS_I(events, rebin=False, convolve_psf=False, prng=source.prng) events.write_spectrum("beta_model_evt.pi", clobber=True) os.system("cp %s ." % events.parameters["ARF"]) os.system("cp %s ." % events.parameters["RMF"]) load_user_model(mymodel, "tbapec") add_user_pars("tbapec", ["nH", "kT", "metallicity", "redshift", "norm"], [0.01, 4.0, 0.2, redshift, norm_sim * 0.8], parmins=[0.0, 0.1, 0.0, -20.0, 0.0], parmaxs=[10.0, 20.0, 10.0, 20.0, 1.0e9], parfrozen=[False, False, False, True, False]) load_pha("beta_model_evt.pi") set_stat("cstat") set_method("simplex") ignore(":0.5, 8.0:") set_model("tbapec") fit() set_covar_opt("sigma", 1.645) covar() res = get_covar_results() assert np.abs(res.parvals[0] - nH_sim) < res.parmaxes[0] assert np.abs(res.parvals[1] - kT_sim) < res.parmaxes[1] assert np.abs(res.parvals[2] - Z_sim) < res.parmaxes[2] assert np.abs(res.parvals[3] - norm_sim) < res.parmaxes[3] os.chdir(curdir) shutil.rmtree(tmpdir)
def test_341(): """ The original reporter of bug #341 had a special implementation that should be captured by this test. The implementation has a proxy model that takes care of updating the actual model when it is evaluated. During a recent refactoring of the Stat and Fit code (PR #287) a regression was introduced by short-circuiting the evaluation of the model. """ class ExampleModel(object): """ Class to define model """ def __init__(self, x, y): self.x = np.array(x) self.y = np.array(y) self.parvals = [1, 2] self.parnames = ("m", "b") def calc_stat(self): return float(np.sum(np.abs(self.y - self.model()))) def model(self): return self.parvals[0] * self.x + self.parvals[1] class CalcModel(object): """ Class to update model parameters """ def __init__(self, model): self.model = model def __call__(self, pars, x): self.model.parvals = pars return np.ones_like(x) class CalcStat(object): """ Class to determine fit statistic """ def __init__(self, model): self.model = model def __call__(self, _data, _model, *args, **kwargs): fit_stat = self.model.calc_stat() return fit_stat, np.ones(1) xdata = [1, 2, 3] ydata = [4, 5, 6] newmodel = ExampleModel(xdata, ydata) dummy_data = np.zeros(1) dummy_times = np.arange(1) ui.load_arrays(1, dummy_times, dummy_data) method = 'simplex' ui.set_method(method) ui.load_user_model(CalcModel(newmodel), 'simplemodel') ui.add_user_pars('simplemodel', newmodel.parnames) ui.set_model(1, 'simplemodel') calc_stat = CalcStat(newmodel) ui.load_user_stat('customstat', calc_stat, lambda x: np.ones_like(x)) ui.set_stat(eval('customstat')) ui.fit(1) assert ui.get_par("simplemodel.m").val == approx(1, abs=0.00001) assert ui.get_par("simplemodel.b").val == approx(3, abs=0.00001)
def test_vapec_beta_model(): bms = BetaModelSource() tmpdir = tempfile.mkdtemp() curdir = os.getcwd() os.chdir(tmpdir) prng = 45 ds = bms.ds A = 30000. exp_time = 1.0e4 redshift = 0.05 nH_sim = 0.02 sphere = ds.sphere("c", (0.5, "Mpc")) kT_sim = bms.kT Z_sim = bms.Z O_sim = bms.O Ca_sim = bms.Ca var_elem = {"O": ("stream", "oxygen"), "Ca": ("stream", "calcium")} thermal_model = ThermalSourceModel("apec", 0.1, 11.5, 20000, var_elem=var_elem, Zmet=("gas","metallicity"), prng=prng) photons = PhotonList.from_data_source(sphere, redshift, A, exp_time, thermal_model) D_A = photons.parameters["fid_d_a"] norm_sim = sphere.quantities.total_quantity("emission_measure") norm_sim *= 1.0e-14/(4*np.pi*D_A*D_A*(1.+redshift)*(1.+redshift)) norm_sim = float(norm_sim.in_cgs()) events = photons.project_photons("z", [30.0, 45.0], absorb_model="tbabs", nH=nH_sim, prng=prng, no_shifting=True) new_events = Lynx_Calorimeter(events, prng=prng) os.system("cp %s %s ." % (arf.filename, rmf.filename)) new_events.write_channel_spectrum("var_abund_beta_model_evt.pha", overwrite=True) load_user_model(mymodel_var, "tbapec") add_user_pars("tbapec", ["nH", "kT", "abund", "redshift", "norm", "O", "Ca"], [nH_sim, 4.0, Z_sim, redshift, norm_sim*0.8, 0.3, 0.5], parmins=[0.0, 0.1, 0.0, -20.0, 0.0, 0.0, 0.0], parmaxs=[10.0, 20.0, 10.0, 20.0, 1.0e9, 10.0, 10.0], parfrozen=[True, False, True, True, False, False, False]) load_pha("var_abund_beta_model_evt.pha") set_stat("cstat") set_method("levmar") ignore(":0.6, 8.0:") set_model("tbapec") fit() res = get_fit_results() assert np.abs(res.parvals[0]-kT_sim)/kT_sim < 0.05 assert np.abs(res.parvals[1]-norm_sim)/norm_sim < 0.05 assert np.abs(res.parvals[2]-O_sim)/O_sim < 0.05 assert np.abs(res.parvals[3]-Ca_sim)/Ca_sim < 0.15 os.chdir(curdir) shutil.rmtree(tmpdir)
def do_beta_model(source, v_field, em_field, axis="z", prng=None): tmpdir = tempfile.mkdtemp() curdir = os.getcwd() os.chdir(tmpdir) if prng is None: prng = source.prng ds = source.ds A = 30000. exp_time = 1.0e4 redshift = 0.05 nH_sim = 0.02 sphere = ds.sphere("c", (0.5, "Mpc")) kT_sim = source.kT Z_sim = source.Z thermal_model = ThermalSourceModel("apec", 0.1, 11.5, 20000, Zmet=Z_sim, prng=prng) photons = PhotonList.from_data_source(sphere, redshift, A, exp_time, thermal_model) D_A = photons.parameters["fid_d_a"] norm_sim = sphere.quantities.total_quantity(em_field) norm_sim *= 1.0e-14/(4*np.pi*D_A*D_A*(1.+redshift)*(1.+redshift)) norm_sim = float(norm_sim.in_cgs()) v1, v2 = sphere.quantities.weighted_variance(v_field, em_field) if isinstance(axis, string_types): if axis == "z": fac = 1.0 else: fac = 0.0 else: axis /= np.sqrt(np.dot(axis, axis)) fac = np.dot(axis, [0.0, 0.0, 1.0]) sigma_sim = fac*float(v1.in_units("km/s")) mu_sim = -fac*float(v2.in_units("km/s")) events = photons.project_photons(axis, [30.0, 45.0], absorb_model="tbabs", nH=nH_sim, prng=prng) events.write_simput_file("beta_model", overwrite=True) instrument_simulator("beta_model_simput.fits", "beta_model_evt.fits", exp_time, "mucal", [30.0, 45.0], overwrite=True, foreground=False, ptsrc_bkgnd=False, instr_bkgnd=False, prng=prng) write_spectrum("beta_model_evt.fits", "beta_model_evt.pi", overwrite=True) os.system("cp %s %s ." % (arf.filename, rmf.filename)) load_user_model(mymodel, "tbapec") add_user_pars("tbapec", ["nH", "kT", "metallicity", "redshift", "norm", "velocity"], [0.02, 4.0, 0.2, 0.04, norm_sim*0.8, 300.0], parmins=[0.0, 0.1, 0.0, -200.0, 0.0, 0.0], parmaxs=[10.0, 20.0, 10.0, 200.0, 1.0e9, 20000.0], parfrozen=[True, False, False, False, False, False]) load_pha("beta_model_evt.pi") set_stat("cstat") set_method("levmar") ignore(":0.6, 8.0:") set_model("tbapec") fit() res = get_fit_results() redshift_sim = (1.0+mu_sim/ckms)*(1.0+redshift) - 1.0 assert np.abs(res.parvals[0]-kT_sim)/kT_sim < 0.05 assert np.abs(res.parvals[1]-Z_sim)/Z_sim < 0.05 assert np.abs(res.parvals[2]-redshift_sim)/redshift_sim < 0.05 assert np.abs(res.parvals[3]-norm_sim) < 0.05 assert np.abs(res.parvals[4]-sigma_sim) < 30.0 os.chdir(curdir) shutil.rmtree(tmpdir)
from bb import BoxBOD, report_results # Load data ui.load_arrays(1, BoxBOD.x, BoxBOD.y, np.ones_like(BoxBOD.x)) # @todo: It is possible to give no staterror, but I'm not sure # what Sherpa does then. fr.statval is no longer the correct chi2. # Set up the model and load it as a Sherpa model def boxbod_func(pars, x): b1, b2 = pars return BoxBOD.model(x, b1, b2) ui.load_user_model(boxbod_func, "boxbod") ui.add_user_pars("boxbod", ["b1", "b2"]) bb = boxbod ui.set_model(bb) bb.b1, bb.b2 = BoxBOD.p0[0], BoxBOD.p0[1] # Perform fit ui.set_stat('chi2datavar') #ui.set_method('levmar') # ['levmar', 'moncar', 'neldermead', 'simplex'] ui.set_method_opt('xtol', 1e-10) ui.fit() # Compute best-fit parameters ui.set_covar_opt('eps', 1e-5) # @todo: Why does this parameter have no effect ui.covariance() # Compute covariance matrix (i.e. errors) #ui.conf() # Compute profile errors #ui.show_all() # Print a very nice summary of your session to less # Report results fr = ui.get_fit_results() cr = ui.get_covar_results()
dummy_data = np.zeros(100) dummy_times = np.arange(100) ui.load_arrays(1, dummy_times, dummy_data) ui.set_method(method) ui.get_method().config.update(SHERPA_CONFIGS.get(method, {})) calc_model = CalcModel() ui.load_user_model(calc_model, "axo_mod") # sets global axo_mod parnames = [] for row in range(N_ROWS): for col in range(N_COLS): parnames.append("adj_{}_{}".format(row, col)) ui.add_user_pars("axo_mod", parnames) ui.set_model(1, "axo_mod") calc_stat = CalcStat(axo_mod, M_2d, displ_x) ui.load_user_stat("axo_stat", calc_stat, lambda x: np.ones_like(x)) ui.set_stat(axo_stat) calc_model.set_calc_stat(calc_stat) # Set frozen, min, and max attributes for each axo_mod parameter for par in axo_mod.pars: par.val = 0.0 # par.frozen = par.frozen par.min = -5 par.max = 5 ui.fit(1)
def test_point_source(): tmpdir = tempfile.mkdtemp() curdir = os.getcwd() os.chdir(tmpdir) nH_sim = 0.02 norm_sim = 1.0e-4 alpha_sim = 0.95 redshift = 0.02 exp_time = (100., "ks") area = (3000., "cm**2") wcs = create_dummy_wcs() ebins = np.linspace(0.1, 11.5, 2001) emid = 0.5*(ebins[1:]+ebins[:-1]) spec = norm_sim*(emid*(1.0+redshift))**(-alpha_sim) de = np.diff(ebins)[0] abs_model = TBabsModel(nH_sim) events = EventList.create_empty_list(exp_time, area, wcs) positions = [(30.01, 45.0)] new_events = events.add_point_sources(positions, ebins, spec, prng=prng, absorb_model=abs_model) new_events = ACIS_S(new_events, prng=prng) scalex = float(np.std(new_events['xpix'])*sigma_to_fwhm*new_events.parameters["dtheta"]) scaley = float(np.std(new_events['ypix'])*sigma_to_fwhm*new_events.parameters["dtheta"]) psf_scale = ACIS_S.psf_scale assert (scalex - psf_scale)/psf_scale < 0.01 assert (scaley - psf_scale)/psf_scale < 0.01 new_events.write_spectrum("point_source_evt.pi", clobber=True) os.system("cp %s ." % new_events.parameters["ARF"]) os.system("cp %s ." % new_events.parameters["RMF"]) load_user_model(mymodel, "tplaw") add_user_pars("tplaw", ["nH", "norm", "redshift", "alpha"], [0.01, norm_sim*0.8, redshift, 0.9], parmins=[0.0, 0.0, 0.0, 0.1], parmaxs=[10.0, 1.0e9, 10.0, 10.0], parfrozen=[False, False, True, False]) load_pha("point_source_evt.pi") set_stat("cstat") set_method("simplex") ignore(":0.5, 9.0:") set_model("tplaw") fit() set_covar_opt("sigma", 1.6) covar() res = get_covar_results() assert np.abs(res.parvals[0]-nH_sim) < res.parmaxes[0] assert np.abs(res.parvals[1]-norm_sim/de) < res.parmaxes[1] assert np.abs(res.parvals[2]-alpha_sim) < res.parmaxes[2] os.chdir(curdir) shutil.rmtree(tmpdir)
import sherpa.astro.ui as ui from spec import load_data, report_results # Load data x, y, y_err = load_data() ui.load_arrays(1, x, y, y_err) # Set up the model ui.set_model(ui.powlaw1d.pl) pl.gamma, pl.ampl = 2, 1e-12 # Perform fit ui.fit() # Compute best-fit parameters ui.covar() # Compute covariance matrix (i.e. errors) # ui.conf() # Compute profile errors # ui.show_all() # Print a very nice summary of your session to less # Report results fr = ui.get_fit_results() cr = ui.get_covar_results() package = "sherpa" gamma, norm = fr.parvals chi2 = fr.statval gamma_err, norm_err = cr.parmaxes cov = cr.extra_output[1, 0] corr = cov / (norm_err * gamma_err) report_results(package, norm, norm_err, gamma, gamma_err, chi2, cov, corr)