def test_simul_stat_fit(stat, hide_logging, reset_xspec, setup_two): data1 = setup_two['data_pi2278'] data2 = setup_two['data_pi2286'] model1 = setup_two['model_pi2278'] model2 = setup_two['model_pi2286'] data = DataSimulFit(name='data1data2', datasets=[data1, data2]) model = SimulFitModel(name='model1model2', parts=[model1, model2]) fit = Fit(data=data, model=model, stat=stat(), method=NelderMead()) result = fit.fit() _fit_simul_datavarstat_results_bench = { 'succeeded': 1, 'numpoints': 18, 'dof': 15, 'istatval': 56609.70689926489, 'statval': 126.1509268988255, 'parvals': numpy.array( [0.8417576197443695, 1.6496933246579941, 0.2383939869443424]) } compare_results(_fit_simul_datavarstat_results_bench, result)
def mwl_fit_low_level(): """Use high-level Sherpa API. Low-level = no session, classes. Example: http://python4astronomers.github.io/fitting/low-level.html """ fermi_data = FermiData().sherpa_data hess_data = IACTData().sherpa_data # spec_model = PowLaw1D('spec_model') spec_model = LogParabola('spec_model') spec_model.c1 = 0.5 spec_model.c2 = 0.2 spec_model.ampl = 5e-11 data = DataSimulFit(name='global_data', datasets=[fermi_data, hess_data]) # TODO: Figure out how to notice using the low-level API # data.notice(mins=1e-3, maxes=None, axislist=None) model = SimulFitModel(name='global_model', parts=[spec_model, spec_model]) stat = FermiStat() method = LevMar() fit = Fit(data=data, model=model, stat=stat, method=method) result = fit.fit() # IPython.embed() return Bunch(results=result, model=spec_model)
def fit(self, current): self._fit.model.thawedpars = current # nm = NelderMead() # nm.config['iquad'] = 0 # nm.config['finalsimplex'] = 1 #lm = LevMar() #lm.config['maxfev'] = 5 cv = Covariance() # Use the fit method defined before called get_draws(). This way the user # does not have to pass in the fitting method and method options. fit = Fit(self._fit.data, self._fit.model, self._fit.stat, self._fit.method, cv) fit_result = fit.fit() covar_result = fit.est_errors() sigma = np.array(covar_result.extra_output) if np.isnan(sigma).any(): raise CovarError("NaNs found in covariance matrix") # cache the fitting scales self._sigma = sigma
def test_mycash_nobkgdata_modelhasbkg(self): data = self.bkg fit = Fit(data, self.model, MyCashWithBkg(), NelderMead()) results = fit.fit() self.compare_results(self._fit_mycashnobkg_results_bench, results, tol=1.0e-3)
def setUp(self): try: from sherpa.astro.io import read_pha from sherpa.astro.xspec import XSwabs, XSpowerlaw except: return # self.startdir = os.getcwd() self.old_level = logger.getEffectiveLevel() logger.setLevel(logging.CRITICAL) pha = self.make_path("refake_0934_1_21_1e4.fak") # rmf = self.make_path("ccdid7_default.rmf") # arf = self.make_path("quiet_0934.arf") self.simarf = self.make_path("aref_sample.fits") self.pcaarf = self.make_path("aref_Cedge.fits") data = read_pha(pha) data.ignore(None, 0.3) data.ignore(7.0, None) rsp = Response1D(data) self.abs1 = XSwabs('abs1') self.p1 = XSpowerlaw('p1') model = rsp(self.abs1 * self.p1) self.fit = Fit(data, model, CStat(), NelderMead(), Covariance())
def setup(): data = Data1D('fake', _x, _y, _err) g1 = Gauss1D('g1') g1.fwhm.set(1.0, _tiny, _max, frozen=False) g1.pos.set(1.0, -_max, _max, frozen=False) g1.ampl.set(1.0, -_max, _max, frozen=False) p1 = PowLaw1D('p1') p1.gamma.set(1.0, -10, 10, frozen=False) p1.ampl.set(1.0, 0.0, _max, frozen=False) p1.ref.set(1.0, -_max, _max, frozen=True) model = p1 + g1 method = LevMar() method.config['maxfev'] = 10000 method.config['ftol'] = float(_eps) method.config['epsfcn'] = float(_eps) method.config['gtol'] = float(_eps) method.config['xtol'] = float(_eps) method.config['factor'] = float(100) fit = Fit(data, model, Chi2DataVar(), method, Covariance()) results = fit.fit() for key in ["succeeded", "numpoints", "nfev"]: assert _fit_results_bench[key] == int(getattr(results, key)) for key in ["rstat", "qval", "statval", "dof"]: # used rel and abs tol of 1e-7 with numpy allclose assert float(getattr(results, key)) == pytest.approx(_fit_results_bench[key]) for key in ["parvals"]: try: # used rel and abs tol of 1e-4 with numpy allclose assert getattr(results, key) == pytest.approx(_fit_results_bench[key]) except AssertionError: print('parvals bench: ', _fit_results_bench[key]) print('parvals fit: ', getattr(results, key)) print('results', results) raise fields = [ 'data', 'model', 'method', 'fit', 'results', 'covresults', 'dof', 'mu', 'num' ] out = namedtuple('Results', fields) out.data = data out.model = model out.method = method out.fit = fit out.results = results out.covresults = fit.est_errors() out.dof = results.dof out.mu = numpy.array(results.parvals) out.cov = numpy.array(out.covresults.extra_output) out.num = 10 return out
def _fit_sherpa(self): """Wrapper around sherpa minimizer.""" from sherpa.fit import Fit from sherpa.data import Data1DInt from sherpa.optmethods import NelderMead from .sherpa_utils import SherpaModel, SherpaStat binning = self.obs_list[0].e_reco # The sherpa data object is not usued in the fit. It is set to the # first observation for debugging purposes, see below data = self.obs_list[0].on_vector.data.data.value data = Data1DInt('Dummy data', binning[:-1].value, binning[1:].value, data) # DEBUG # from sherpa.models import PowLaw1D # from sherpa.stats import Cash # model = PowLaw1D('sherpa') # model.ref = 0.1 # fit = Fit(data, model, Cash(), NelderMead()) # NOTE: We cannot use the Levenbergr-Marquart optimizer in Sherpa # because it relies on the fvec return value of the fit statistic (we # return None). The computation of fvec is not straightforwad, not just # stats per bin. E.g. for a cash fit the sherpa stat computes it # according to cstat # see https://github.com/sherpa/sherpa/blob/master/sherpa/include/sherpa/stats.hh#L122 self._sherpa_fit = Fit(data, SherpaModel(self), SherpaStat(self), NelderMead()) fitresult = self._sherpa_fit.fit() log.debug(fitresult) self._make_fit_result(self.model.parameters)
def test_intproj(old_numpy_printing, override_plot_backend): p = plot.IntervalProjection() r = p._repr_html_() check_empty(r, 'IntervalProjection', nsummary=8) x = np.arange(5, 8, 0.5) y = np.asarray([2, 3, 4, 5, 4, 3]) dy = y / 2 d = Data1D('n n', x, y, staterror=dy) m = Const1D() fit = Fit(d, m, stat=Chi2()) fr = fit.fit() assert fr.succeeded p.prepare(min=1, max=6, nloop=10) p.calc(fit, m.c0) r = p._repr_html_() assert r is not None if plot.backend.name == 'pylab': assert '<summary>IntervalProjection</summary>' in r assert '<svg ' in r return assert '<summary>IntervalProjection (8)</summary>' in r assert '<div class="dataname">x</div><div class="dataval">[ 1. 1.555556 2.111111 2.666667 3.222222 3.777778 4.333333 4.888889\n 5.444444 6. ]</div>' in r assert '<div class="dataname">nloop</div><div class="dataval">10</div>' in r
def test_mycash_data_and_model_donothave_bkg(self): data = self.bkg fit = Fit(data, self.model, MyCashNoBkg(), NelderMead()) results = fit.fit() self.compare_results(self._fit_mycashnobkg_results_bench, results, tol=1.0e-3)
def call(self, niter, seed): pars = {} pars_index = {} index = 0 for par in self.model.pars: if par.frozen is False: name = '%s.%s' % (par.modelname, par.name) pars_index[index] = name pars[name] = [] index += 1 data = self.data y = data.y x = data.x if type(data) == Data1DAsymmetricErrs: y_l = y - data.elo y_h = y + data.ehi elif isinstance(data, (Data1D,)): y_l = data.staterror y_h = data.staterror else: msg ="{0} {1}".format(ReSampleData.__name__, type(data)) raise NotImplementedError(msg) numpy.random.seed(seed) for j in range(niter): ry = [] for i in range(len(y_l)): a = y_l[i] b = y_h[i] r = -1 while r < a or r > b: sigma = b - y[i] u = numpy.random.random_sample() if u < 0.5: sigma=y[i]-a r = numpy.random.normal(loc=y[i],scale=sigma,size=None) if u < 0.5 and r > y[i]: r = -1 if u > 0.5 and r < y[i]: r = -1 ry.append(r) # fit is performed for each simulated data point fit = Fit(Data1D('tmp', x, ry), self.model, LeastSq( ), LevMar()) fit_result = fit.fit() for index, val in enumerate(fit_result.parvals): name = pars_index[index] pars[name].append(val) result = {} for index, name in pars_index.items(): avg = numpy.average(pars[name]) std = numpy.std(pars[name]) print(name, ': avg =', avg, ', std =', std) result[name] = pars[name] return result
def test_same_cache(self): poly = Polynom1D() poly.pars[1].thaw() sdata = DataSimulFit('d1d2d3', (self.d1, self.d2, self.d3)) smodel = SimulFitModel('same', (poly, poly, poly)) sfit = Fit(sdata, smodel, method=NelderMead(), stat=Cash()) result = sfit.fit() self.compare_results(self._fit_same_poly_bench, result)
def fit(self): """Fit spectrum""" from sherpa.fit import Fit from sherpa.models import ArithmeticModel, SimulFitModel from sherpa.astro.instrument import Response1D from sherpa.data import DataSimulFit # Translate model to sherpa model if necessary if isinstance(self.model, models.SpectralModel): model = self.model.to_sherpa() else: model = self.model if not isinstance(model, ArithmeticModel): raise ValueError('Model not understood: {}'.format(model)) # Make model amplitude O(1e0) val = model.ampl.val * self.FLUX_FACTOR ** (-1) model.ampl = val if self.fit_range is not None: log.info('Restricting fit range to {}'.format(self.fit_range)) fitmin = self.fit_range[0].to('keV').value fitmax = self.fit_range[1].to('keV').value # Loop over observations pha = list() folded_model = list() nobs = len(self.obs_list) for ii in range(nobs): temp = self.obs_list[ii].to_sherpa() if self.fit_range is not None: temp.notice(fitmin, fitmax) if temp.get_background() is not None: temp.get_background().notice(fitmin, fitmax) temp.ignore_bad() if temp.get_background() is not None: temp.get_background().ignore_bad() pha.append(temp) # Forward folding resp = Response1D(pha[ii]) folded_model.append(resp(model) * self.FLUX_FACTOR) data = DataSimulFit('simul fit data', pha) fitmodel = SimulFitModel('simul fit model', folded_model) log.debug(fitmodel) fit = Fit(data, fitmodel, self.statistic) fitresult = fit.fit() log.debug(fitresult) # The model instance passed to the Fit now holds the best fit values covar = fit.est_errors() log.debug(covar) for ii in range(nobs): efilter = pha[ii].get_filter() shmodel = fitmodel.parts[ii] self.result[ii].fit = _sherpa_to_fitresult(shmodel, covar, efilter, fitresult)
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_gauss_gauss(self): g1, g2 = Gauss1D(), Gauss1D() g1.fwhm = 1.3 g1.pos = 1.5 g2.fwhm = 4. g2.pos = -2.0 sdata = DataSimulFit('d4d5', (self.d4, self.d5)) smodel = SimulFitModel('g1g2', (g1, g2)) sfit = Fit(sdata, smodel, method=LevMar(), stat=LeastSq()) result = sfit.fit() self.compare_results(self._fit_g2g2_bench, result)
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_cache(): """To make sure that the runtime fit(cache=???) works""" x = np.array([1.0, 2.0, 3.0]) model = MyCacheTestModel() par = np.array([1.1, 2.0, 3.0]) y = model.calc(par, x) data = Data1D('tmp', x, y) fit = Fit(data, model, LeastSq()) fit.fit(cache=False)
def test_wstat(self): fit = Fit(self.data, self.model, WStat(), LevMar()) results = fit.fit() # On a local linux machine I have to bump the tolerance to # 3e-4, but this isn't seen on Travis. The fit isn't # "great", so it may be that the results are sensitive to # numerical differences (e.g. as introduced with updated # compilers). # tol = 3e-4 tol = 1e-6 # TODO: investigate difference self.compare_results(self._fit_wstat_results_bench, results, tol=tol)
def test_diff_cache(self): poly1 = Polynom1D() poly2 = Polynom1D() poly3 = Polynom1D() poly1.pars[1].thaw() poly2.pars[1].thaw() poly3.pars[1].thaw() sdata = DataSimulFit('d123', (self.d1, self.d2, self.d3)) smodel = SimulFitModel('diff', (poly1, poly2, poly3)) sfit = Fit(sdata, smodel, method=NelderMead(), stat=Cash()) result = sfit.fit() self.compare_results(self._fit_diff_poly_bench, result)
def test_simul_stat_fit(self): data1 = self.data_pi2278 data2 = self.data_pi2286 model1 = self.model_mult model2 = self.model_mult data = DataSimulFit(name='data1data2', datasets=[data1, data2]) model = SimulFitModel(name='model1model2', parts=[model1, model2]) fit = Fit(data=data, model=model, stat=MyChiNoBkg(), method=NelderMead()) result = fit.fit() self.compare_results(self._fit_simul_datavarstat_results_bench, result)
def test_data2d_int_eval_model_to_fit(array_sizes_fixture): from sherpa.fit import Fit from sherpa.optmethods import LevMar from sherpa.stats import Chi2 from sherpa.models import Gauss2D x0, x1, dx, y = array_sizes_fixture data2 = Data2DInt('name', x0.flatten(), x0.flatten() + dx, x1.flatten(), x1.flatten() + dx, y.flatten(), staterror=numpy.sqrt(y).flatten()) model2 = Gauss2D() fitter = Fit(data2, model2, Chi2(), LevMar()) fitter.fit() # Failed in Sherpa 4.11.0
def test_regproj(old_numpy_printing, override_plot_backend): p = plot.RegionProjection() r = p._repr_html_() check_empty(r, 'RegionProjection', nsummary=13) x = np.arange(5, 8, 0.5) y = np.asarray([2, 3, 4, 5, 4, 3]) dy = y / 2 d = Data1D('n n', x, y, staterror=dy) m = Polynom1D() m.c1.thaw() fit = Fit(d, m, stat=Chi2()) fr = fit.fit() assert fr.succeeded p.prepare(min=(-2, -1), max=(2, 2), nloop=(10, 20)) p.calc(fit, m.c0, m.c1) r = p._repr_html_() assert r is not None if plot_backend_is("pylab"): assert "<summary>RegionProjection</summary>" in r assert "<svg " in r return assert "<summary>RegionProjection (13)</summary>" in r # Issue #1372 shows that the numbers here can depend on the platform; as # this test is not about whether the fit converged to the same solution # the tests are very basic. An alternative would be to just place # the values from the fit object into the strings, but then there is # the problem that this test currently requires old_numpy_printing, # so the results would not necessarily match. # assert '<div class="dataname">parval0</div><div class="dataval">-0.5' in r assert '<div class="dataname">parval1</div><div class="dataval">0.5' in r assert '<div class="dataname">sigma</div><div class="dataval">(1, 2, 3)</div>' in r # These values may depend on the platform so only very-limited check. # assert '<div class="dataname">y</div><div class="dataval">[ 30' in r assert '<div class="dataname">levels</div><div class="dataval">[ 3.6' in r assert '<div class="dataname">min</div><div class="dataval">[-2, -1]</div>' in r assert '<div class="dataname">max</div><div class="dataval">[2, 2]</div>' in r assert '<div class="dataname">nloop</div><div class="dataval">(10, 20)</div>' in r
def setUp(self): data = Data1D('fake', self._x, self._y, self._err) g1 = Gauss1D('g1') g1.fwhm.set(1.0, _tiny, _max, frozen=False) g1.pos.set(1.0, -_max, _max, frozen=False) g1.ampl.set(1.0, -_max, _max, frozen=False) p1 = PowLaw1D('p1') p1.gamma.set(1.0, -10, 10, frozen=False) p1.ampl.set(1.0, 0.0, _max, frozen=False) p1.ref.set(1.0, -_max, _max, frozen=True) model = p1 + g1 method = LevMar() method.config['maxfev'] = 10000 method.config['ftol'] = float(_eps) method.config['epsfcn'] = float(_eps) method.config['gtol'] = float(_eps) method.config['xtol'] = float(_eps) method.config['factor'] = float(100) self.fit = Fit(data, model, Chi2DataVar(), method, Covariance()) results = self.fit.fit() for key in ["succeeded", "numpoints", "nfev"]: assert self._fit_results_bench[key] == int(getattr(results, key)) for key in ["rstat", "qval", "statval", "dof"]: assert numpy.allclose(float(self._fit_results_bench[key]), float(getattr(results, key)), 1.e-7, 1.e-7) for key in ["parvals"]: try: assert numpy.allclose(self._fit_results_bench[key], getattr(results, key), 1.e-4, 1.e-4) except AssertionError: print('parvals bench: ', self._fit_results_bench[key]) print('parvals fit: ', getattr(results, key)) print('results', results) raise covresults = self.fit.est_errors() self.dof = results.dof self.mu = numpy.array(results.parvals) self.cov = numpy.array(covresults.extra_output) self.num = 10
def setUp(self): try: from sherpa.astro.io import read_pha from sherpa.astro.xspec import XSwabs, XSpowerlaw except: return #self.startdir = os.getcwd() self.old_level = logger.getEffectiveLevel() logger.setLevel(logging.CRITICAL) datadir = SherpaTestCase.datadir if datadir is None: return pha = os.path.join(datadir, "refake_0934_1_21_1e4.fak") rmf = os.path.join(datadir, "ccdid7_default.rmf") arf = os.path.join(datadir, "quiet_0934.arf") self.simarf = os.path.join(datadir, "aref_sample.fits") self.pcaarf = os.path.join(datadir, "aref_Cedge.fits") data = read_pha(pha) data.ignore(None,0.3) data.ignore(7.0,None) rsp = Response1D(data) self.abs1 = XSwabs('abs1') self.p1 = XSpowerlaw('p1') model = rsp(self.abs1*self.p1) self.fit = Fit(data, model, CStat(), NelderMead(), Covariance())
def _fit_sherpa(self): """Wrapper around sherpa minimizer.""" from sherpa.fit import Fit from sherpa.data import Data1DInt from sherpa.optmethods import NelderMead from .sherpa_utils import SherpaModel, SherpaStat binning = self.obs_list[0].e_reco # The sherpa data object is not usued in the fit. It is set to the # first observation for debugging purposes, see below data = self.obs_list[0].on_vector.data.data.value data = Data1DInt('Dummy data', binning[:-1].value, binning[1:].value, data) # DEBUG # from sherpa.models import PowLaw1D # from sherpa.stats import Cash # model = PowLaw1D('sherpa') # model.ref = 0.1 # fit = Fit(data, model, Cash(), NelderMead()) # NOTE: We cannot use the Levenbergr-Marquart optimizer in Sherpa # because it relies on the fvec return value of the fit statistic (we # return None). The computation of fvec is not straightforwad, not just # stats per bin. E.g. for a cash fit the sherpa stat computes it # according to cstat # see https://github.com/sherpa/sherpa/blob/master/sherpa/include/sherpa/stats.hh#L122 self._sherpa_fit = Fit(data, SherpaModel(self), SherpaStat(self), NelderMead()) fitresult = self._sherpa_fit.fit() log.debug(fitresult) self._make_fit_result()
def setup(make_data_path): from sherpa.astro.io import read_pha from sherpa.astro.xspec import XSwabs, XSpowerlaw old_level = logger.getEffectiveLevel() logger.setLevel(logging.CRITICAL) pha = make_data_path("refake_0934_1_21_1e4.fak") simarf = make_data_path("aref_sample.fits") pcaarf = make_data_path("aref_Cedge.fits") data = read_pha(pha) data.ignore(None, 0.3) data.ignore(7.0, None) rsp = Response1D(data) abs1 = XSwabs('abs1') p1 = XSpowerlaw('p1') model = rsp(abs1 * p1) abs1.nh = 0.092886 p1.phoindex = 0.994544 p1.norm = 9.26369 fit = Fit(data, model, CStat(), NelderMead(), Covariance()) yield {'simarf': simarf, 'pcaarf': pcaarf, 'niter': 10, 'fit': fit} # Reset the logger logger.setLevel(old_level)
def test_sherpa_crab_fit(): from sherpa.models import NormGauss2D, PowLaw1D, TableModel, Const2D from sherpa.stats import Chi2ConstVar from sherpa.optmethods import LevMar from sherpa.fit import Fit from ..sherpa_ import CombinedModel3D filename = gammapy_extra.filename('experiments/sherpa_cube_analysis/counts.fits.gz') # Note: The cube is stored in incorrect format counts = SkyCube.read(filename, format='fermi-counts') cube = counts.to_sherpa_data3d() # Set up exposure table model filename = gammapy_extra.filename('experiments/sherpa_cube_analysis/exposure.fits.gz') exposure_data = fits.getdata(filename) exposure = TableModel('exposure') exposure.load(None, exposure_data.ravel()) # Freeze exposure amplitude exposure.ampl.freeze() # Setup combined spatial and spectral model spatial_model = NormGauss2D('spatial-model') spectral_model = PowLaw1D('spectral-model') source_model = CombinedModel3D(spatial_model=spatial_model, spectral_model=spectral_model) # Set starting values source_model.gamma = 2.2 source_model.xpos = 83.6 source_model.ypos = 22.01 source_model.fwhm = 0.12 source_model.ampl = 0.05 model = 1E-9 * exposure * source_model # 1E-9 flux factor # Fit fit = Fit(data=cube, model=model, stat=Chi2ConstVar(), method=LevMar()) result = fit.fit() reference = [0.121556, 83.625627, 22.015564, 0.096903, 2.240989] assert_allclose(result.parvals, reference, rtol=1E-3)
def test_sherpa_crab_fit(): from sherpa.models import NormGauss2D, PowLaw1D, TableModel, Const2D from sherpa.stats import Chi2ConstVar from sherpa.optmethods import LevMar from sherpa.fit import Fit from ..sherpa_ import Data3D, CombinedModel3D filename = gammapy_extra.filename( 'experiments/sherpa_cube_analysis/counts.fits.gz') counts = SkyCube.read(filename) cube = counts.to_sherpa_data3d() # Set up exposure table model filename = gammapy_extra.filename( 'experiments/sherpa_cube_analysis/exposure.fits.gz') exposure_data = fits.getdata(filename) exposure = TableModel('exposure') exposure.load(None, exposure_data.ravel()) # Freeze exposure amplitude exposure.ampl.freeze() # Setup combined spatial and spectral model spatial_model = NormGauss2D('spatial-model') spectral_model = PowLaw1D('spectral-model') source_model = CombinedModel3D(spatial_model=spatial_model, spectral_model=spectral_model) # Set starting values source_model.gamma = 2.2 source_model.xpos = 83.6 source_model.ypos = 22.01 source_model.fwhm = 0.12 source_model.ampl = 0.05 model = 1E-9 * exposure * (source_model) # 1E-9 flux factor # Fit fit = Fit(data=cube, model=model, stat=Chi2ConstVar(), method=LevMar()) result = fit.fit() reference = (0.11925401159500593, 83.640630749333056, 22.020525848447541, 0.036353759774770608, 1.1900312815970555) assert_allclose(result.parvals, reference, rtol=1E-8)
def test_sherpa_crab_fit(): from sherpa.models import NormGauss2D, PowLaw1D, TableModel, Const2D from sherpa.stats import Chi2ConstVar from sherpa.optmethods import LevMar from sherpa.fit import Fit from ..sherpa_ import CombinedModel3D filename = gammapy_extra.filename( 'experiments/sherpa_cube_analysis/counts.fits.gz') # Note: The cube is stored in incorrect format counts = SkyCube.read(filename, format='fermi-counts') cube = counts.to_sherpa_data3d() # Set up exposure table model filename = gammapy_extra.filename( 'experiments/sherpa_cube_analysis/exposure.fits.gz') exposure_data = fits.getdata(filename) exposure = TableModel('exposure') exposure.load(None, exposure_data.ravel()) # Freeze exposure amplitude exposure.ampl.freeze() # Setup combined spatial and spectral model spatial_model = NormGauss2D('spatial-model') spectral_model = PowLaw1D('spectral-model') source_model = CombinedModel3D(spatial_model=spatial_model, spectral_model=spectral_model) # Set starting values source_model.gamma = 2.2 source_model.xpos = 83.6 source_model.ypos = 22.01 source_model.fwhm = 0.12 source_model.ampl = 0.05 model = 1E-9 * exposure * source_model # 1E-9 flux factor # Fit fit = Fit(data=cube, model=model, stat=Chi2ConstVar(), method=LevMar()) result = fit.fit() reference = [0.121556, 83.625627, 22.015564, 0.096903, 2.240989] assert_allclose(result.parvals, reference, rtol=1E-5)
def test_sherpa_crab_fit(): from sherpa.models import NormGauss2D, PowLaw1D, TableModel, Const2D from sherpa.stats import Chi2ConstVar from sherpa.optmethods import LevMar from sherpa.fit import Fit from ..sherpa_ import Data3D, CombinedModel3D filename = gammapy_extra.filename('experiments/sherpa_cube_analysis/counts.fits.gz') counts = SkyCube.read(filename) cube = counts.to_sherpa_data3d() # Set up exposure table model filename = gammapy_extra.filename('experiments/sherpa_cube_analysis/exposure.fits.gz') exposure_data = fits.getdata(filename) exposure = TableModel('exposure') exposure.load(None, exposure_data.ravel()) # Freeze exposure amplitude exposure.ampl.freeze() # Setup combined spatial and spectral model spatial_model = NormGauss2D('spatial-model') spectral_model = PowLaw1D('spectral-model') source_model = CombinedModel3D(spatial_model=spatial_model, spectral_model=spectral_model) # Set starting values source_model.gamma = 2.2 source_model.xpos = 83.6 source_model.ypos = 22.01 source_model.fwhm = 0.12 source_model.ampl = 0.05 model = 1E-9 * exposure * (source_model) # 1E-9 flux factor # Fit fit = Fit(data=cube, model=model, stat=Chi2ConstVar(), method=LevMar()) result = fit.fit() reference = (0.11925401159500593, 83.640630749333056, 22.020525848447541, 0.036353759774770608, 1.1900312815970555) assert_allclose(result.parvals, reference, rtol=1E-8)
def test_regproj(old_numpy_printing, override_plot_backend): p = plot.RegionProjection() r = p._repr_html_() check_empty(r, 'RegionProjection', nsummary=13) x = np.arange(5, 8, 0.5) y = np.asarray([2, 3, 4, 5, 4, 3]) dy = y / 2 d = Data1D('n n', x, y, staterror=dy) m = Polynom1D() m.c1.thaw() fit = Fit(d, m, stat=Chi2()) fr = fit.fit() assert fr.succeeded p.prepare(min=(-2, -1), max=(2, 2), nloop=(10, 20)) p.calc(fit, m.c0, m.c1) r = p._repr_html_() assert r is not None if plot.backend.name == 'pylab': assert '<summary>RegionProjection</summary>' in r assert '<svg ' in r return print(r) assert '<summary>RegionProjection (13)</summary>' in r assert '<div class="dataname">parval0</div><div class="dataval">-0.5315772076542427</div>' in r assert '<div class="dataname">parval1</div><div class="dataval">0.5854611101216837</div>' in r assert '<div class="dataname">sigma</div><div class="dataval">(1, 2, 3)</div>' in r assert '<div class="dataname">y</div><div class="dataval">[ 306.854444 282.795953 259.744431 237.699877 216.662291 196.631674\n' in r assert '<div class="dataname">levels</div><div class="dataval">[ 3.606863 7.491188 13.140272]</div>' in r assert '<div class="dataname">min</div><div class="dataval">[-2, -1]</div>' in r assert '<div class="dataname">max</div><div class="dataval">[2, 2]</div>' in r assert '<div class="dataname">nloop</div><div class="dataval">(10, 20)</div>' in r
def test_leastsq_stat(hide_logging, reset_xspec, setup_group): fit = Fit(setup_group['data'], setup_group['model'], LeastSq(), LevMar()) results = fit.fit() _fit_leastsq_results_bench = { 'succeeded': 1, 'numpoints': 143, 'dof': 140, 'istatval': 117067.64900554597, 'statval': 4203.173180288109, 'parvals': numpy.array([1.808142494916457, 5.461611041944977, -1.907736527635154]) } compare_results(_fit_leastsq_results_bench, results, tol=2e-4)
def test_cstat_stat(hide_logging, reset_xspec, setup): fit = Fit(setup['data'], setup['model'], CStat(), NelderMead()) results = fit.fit() _fit_cstat_results_bench = { 'succeeded': 1, 'numpoints': 460, 'dof': 457, 'istatval': 21647.62293983995, 'statval': 472.6585691450068, 'parvals': numpy.array([1.75021021282262, 5.474614304244775, -1.9985761873334102]) } compare_results(_fit_cstat_results_bench, results)
def mwl_fit_low_level_calling_fermi(): """Example how to do a Sherpa model fit, but use the Fermi ScienceTools to evaluate the likelihood for the Fermi dataset. """ spec_model = LogParabola('spec_model') spec_model.c1 = 0.5 spec_model.c2 = 0.2 spec_model.ampl = 5e-11 model = spec_model data = FermiDataShim() stat = FermiStatShim() method = LevMar() fit = Fit(data=data, model=model, stat=stat, method=method) result = fit.fit() return dict(results=result, model=spec_model)
def mwl_fit_low_level_calling_fermi(): """Example how to do a Sherpa model fit, but use the Fermi ScienceTools to evaluate the likelihood for the Fermi dataset. """ spec_model = LogParabola('spec_model') spec_model.c1 = 0.5 spec_model.c2 = 0.2 spec_model.ampl = 5e-11 model = spec_model data = FermiDataShim() stat = FermiStatShim() method = LevMar() fit = Fit(data=data, model=model, stat=stat, method=method) result = fit.fit() # IPython.embed() return Bunch(results=result, model=spec_model)
def test_wstat(hide_logging, reset_xspec, setup): fit = Fit(setup['data'], setup['model'], WStat(), LevMar()) results = fit.fit() _fit_wstat_results_bench = { 'succeeded': 1, 'numpoints': 460, 'dof': 457, 'istatval': 21647.48285025895, 'statval': 472.6585709918982, 'parvals': numpy.array([1.750204250228727, 5.47466040324842, -1.9983562007031974]) } compare_results(_fit_wstat_results_bench, results, tol=2e-4)
def setUp(self): data = Data1D('fake', self._x, self._y, self._err) g1 = Gauss1D('g1') g1.fwhm.set(1.0, _tiny, _max, frozen=False) g1.pos.set(1.0, -_max, _max, frozen=False) g1.ampl.set(1.0, -_max, _max, frozen=False) p1 = PowLaw1D('p1') p1.gamma.set(1.0, -10, 10, frozen=False) p1.ampl.set(1.0, 0.0, _max, frozen=False) p1.ref.set(1.0, -_max, _max, frozen=True) model = p1 + g1 method = LevMar() method.config['maxfev'] = 10000 method.config['ftol'] = float(_eps) method.config['epsfcn'] = float(_eps) method.config['gtol'] = float(_eps) method.config['xtol'] = float(_eps) method.config['factor'] = float(100) self.fit = Fit(data, model, Chi2DataVar(), method, Covariance()) results = self.fit.fit() for key in ["succeeded", "numpoints", "nfev"]: assert self._fit_results_bench[key] == int(getattr(results, key)) for key in ["rstat", "qval", "statval", "dof"]: assert numpy.allclose(float(self._fit_results_bench[key]), float(getattr(results, key)), 1.e-7, 1.e-7) for key in ["parvals"]: try: assert numpy.allclose(self._fit_results_bench[key], getattr(results, key), 1.e-4, 1.e-4) except AssertionError: print 'parvals bench: ', self._fit_results_bench[key] print 'parvals fit: ', getattr(results, key) print 'results', results raise covresults = self.fit.est_errors() self.dof = results.dof self.mu = numpy.array(results.parvals) self.cov = numpy.array(covresults.extra_output) self.num = 10
def setUp(self): from sherpa.astro.io import read_pha from sherpa.astro.xspec import XSwabs, XSpowerlaw # self.startdir = os.getcwd() self.old_level = logger.getEffectiveLevel() logger.setLevel(logging.CRITICAL) pha = self.make_path("refake_0934_1_21_1e4.fak") # rmf = self.make_path("ccdid7_default.rmf") # arf = self.make_path("quiet_0934.arf") self.simarf = self.make_path("aref_sample.fits") self.pcaarf = self.make_path("aref_Cedge.fits") data = read_pha(pha) data.ignore(None, 0.3) data.ignore(7.0, None) rsp = Response1D(data) self.abs1 = XSwabs('abs1') self.p1 = XSpowerlaw('p1') model = rsp(self.abs1 * self.p1) self.fit = Fit(data, model, CStat(), NelderMead(), Covariance())
def test_wstat(self): fit = Fit(self.data, self.model, WStat(), NelderMead()) results = fit.fit() self.compare_results(self._fit_wstat_results_bench, results)
def test_mychi_nobkgdata_modelhasbkg(self): data = self.bkg fit = Fit(data, self.model, MyChiWithBkg(), LevMar()) results = fit.fit() self.compare_results(self._fit_mychinobkg_results_bench, results, 1e-5)
def test_mychi_datahasbkg_modelhasnobkg(self): fit = Fit(self.data, self.model, MyChiNoBkg(), LevMar()) results = fit.fit() self.compare_results(self._fit_mychi_results_bench, results)
def test_mycash_nobkgdata_modelhasbkg(self): data = self.bkg fit = Fit(data, self.model, MyCashWithBkg(), NelderMead()) results = fit.fit() self.compare_results(self._fit_mycashnobkg_results_bench, results)
def test_mycash_datahasbkg_modelhasnobkg(self): fit = Fit(self.data, self.model, MyCashNoBkg(), NelderMead()) results = fit.fit() self.compare_results(self._fit_mycash_results_bench, results)
def test_mycash_data_and_model_donothave_bkg(self): data = self.bkg fit = Fit(data, self.model, MyCashNoBkg(), NelderMead()) results = fit.fit() self.compare_results(self._fit_mycashnobkg_results_bench, results)
class test_sim(SherpaTestCase): @unittest.skipIf(not has_fits_support(), 'need pycrates, pyfits') @unittest.skipIf(not has_package_from_list('sherpa.astro.xspec'), "required sherpa.astro.xspec module missing") def setUp(self): try: from sherpa.astro.io import read_pha from sherpa.astro.xspec import XSwabs, XSpowerlaw except: return #self.startdir = os.getcwd() self.old_level = logger.getEffectiveLevel() logger.setLevel(logging.CRITICAL) datadir = SherpaTestCase.datadir if datadir is None: return pha = os.path.join(datadir, "refake_0934_1_21_1e4.fak") rmf = os.path.join(datadir, "ccdid7_default.rmf") arf = os.path.join(datadir, "quiet_0934.arf") self.simarf = os.path.join(datadir, "aref_sample.fits") self.pcaarf = os.path.join(datadir, "aref_Cedge.fits") data = read_pha(pha) data.ignore(None,0.3) data.ignore(7.0,None) rsp = Response1D(data) self.abs1 = XSwabs('abs1') self.p1 = XSpowerlaw('p1') model = rsp(self.abs1*self.p1) self.fit = Fit(data, model, CStat(), NelderMead(), Covariance()) def tearDown(self): #os.chdir(self.startdir) if hasattr(self,'old_level'): logger.setLevel(self.old_level) @unittest.skipIf(not has_package_from_list('sherpa.astro.xspec'), "required sherpa.astro.xspec module missing") @unittest.skipIf(test_data_missing(), "required test data missing") def test_pragbayes_simarf(self): datadir = SherpaTestCase.datadir if datadir is None: return mcmc = sim.MCMC() self.abs1.nh = 0.092886 self.p1.phoindex = 0.994544 self.p1.norm = 9.26369 mcmc.set_sampler("PragBayes") mcmc.set_sampler_opt("simarf", self.simarf) mcmc.set_sampler_opt("p_M", 0.5) mcmc.set_sampler_opt("nsubiter", 7) covar_results = self.fit.est_errors() cov = covar_results.extra_output niter = 10 stats, accept, params = mcmc.get_draws(self.fit, cov, niter=niter) # try: # assert (covar_results.parmaxes < params.std(1)).all() # except AssertionError: # print 'covar: ', str(covar_results.parmaxes) # print 'param: ', str(params.std(1)) # raise @unittest.skipIf(not has_package_from_list('sherpa.astro.xspec'), "required sherpa.astro.xspec module missing") @unittest.skipIf(test_data_missing(), "required test data missing") def test_pragbayes_pcaarf(self): datadir = SherpaTestCase.datadir if datadir is None: return mcmc = sim.MCMC() self.abs1.nh = 0.092886 self.p1.phoindex = 0.994544 self.p1.norm = 9.26369 mcmc.set_sampler("pragBayes") mcmc.set_sampler_opt("simarf", self.pcaarf) mcmc.set_sampler_opt("p_M", 0.5) mcmc.set_sampler_opt("nsubiter", 5) covar_results = self.fit.est_errors() cov = covar_results.extra_output niter = 10 stats, accept, params = mcmc.get_draws(self.fit, cov, niter=niter)
def test_mycash_data_and_model_have_bkg(self): fit = Fit(self.data, self.model, MyCashWithBkg(), NelderMead()) results = fit.fit() self.compare_results(self._fit_mycash_results_bench, results)
def test_cash_stat(self): fit = Fit(self.data, self.model, Cash(), NelderMead()) results = fit.fit() self.compare_results(self._fit_mycash_results_bench, results)
def test_leastsq_stat(self): fit = Fit(self.data, self.model, LeastSq(), NelderMead()) results = fit.fit() self.compare_results(self._fit_leastsq_results_bench, results)
def test_chi2gehrels_stat(self): fit = Fit(self.data, self.model, Chi2Gehrels(), NelderMead()) results = fit.fit() self.compare_results(self._fit_chi2gehrels_results_bench, results)
def test_chi2constvar_stat(self): fit = Fit(self.data, self.model, Chi2ConstVar(), NelderMead()) results = fit.fit() self.compare_results(self._fit_chi2constvar_results_bench, results)
def test_mychi_data_and_model_donothave_bkg(self): data = self.bkg fit = Fit(data, self.model, MyChiNoBkg(), LevMar()) results = fit.fit() self.compare_results(self._fit_mychinobkg_results_bench, results, 1e-5)
def test_mychi_data_and_model_have_bkg(self): fit = Fit(self.data, self.model, MyChiWithBkg(), LevMar()) results = fit.fit() self.compare_results(self._fit_mychi_results_bench, results)
class test_sim(SherpaTestCase): @requires_fits @requires_xspec def setUp(self): from sherpa.astro.io import read_pha from sherpa.astro.xspec import XSwabs, XSpowerlaw # self.startdir = os.getcwd() self.old_level = logger.getEffectiveLevel() logger.setLevel(logging.CRITICAL) pha = self.make_path("refake_0934_1_21_1e4.fak") # rmf = self.make_path("ccdid7_default.rmf") # arf = self.make_path("quiet_0934.arf") self.simarf = self.make_path("aref_sample.fits") self.pcaarf = self.make_path("aref_Cedge.fits") data = read_pha(pha) data.ignore(None, 0.3) data.ignore(7.0, None) rsp = Response1D(data) self.abs1 = XSwabs('abs1') self.p1 = XSpowerlaw('p1') model = rsp(self.abs1 * self.p1) self.fit = Fit(data, model, CStat(), NelderMead(), Covariance()) def tearDown(self): # os.chdir(self.startdir) if hasattr(self, 'old_level'): logger.setLevel(self.old_level) @requires_xspec @requires_data def test_pragbayes_simarf(self): mcmc = sim.MCMC() self.abs1.nh = 0.092886 self.p1.phoindex = 0.994544 self.p1.norm = 9.26369 mcmc.set_sampler("PragBayes") mcmc.set_sampler_opt("simarf", self.simarf) mcmc.set_sampler_opt("p_M", 0.5) mcmc.set_sampler_opt("nsubiter", 7) covar_results = self.fit.est_errors() cov = covar_results.extra_output niter = 10 stats, accept, params = mcmc.get_draws(self.fit, cov, niter=niter) # try: # assert (covar_results.parmaxes < params.std(1)).all() # except AssertionError: # print 'covar: ', str(covar_results.parmaxes) # print 'param: ', str(params.std(1)) # raise @requires_xspec @requires_data def test_pragbayes_pcaarf(self): mcmc = sim.MCMC() self.abs1.nh = 0.092886 self.p1.phoindex = 0.994544 self.p1.norm = 9.26369 mcmc.set_sampler("pragBayes") mcmc.set_sampler_opt("simarf", self.pcaarf) mcmc.set_sampler_opt("p_M", 0.5) mcmc.set_sampler_opt("nsubiter", 5) covar_results = self.fit.est_errors() cov = covar_results.extra_output niter = 10 stats, accept, params = mcmc.get_draws(self.fit, cov, niter=niter)