def test_rmf1d_matrix_arf_no_pha_call(): "Can we call an RMF () with ARF (no PHA)" # NOTE: there is no check that the grids are compatible # so this is probably not that useful a test # rdata = create_non_delta_rmf() elo = rdata.e_min ehi = rdata.e_max adata = create_arf(elo, ehi) rmf = RMF1D(rdata, arf=adata) mdl = Const1D('flat') mdl.c0 = 2.3 wrapped = rmf(mdl) # It seems like the wrapper should match the following: # assert isinstance(wrapped, RSPModelNoPHA) # but at the time the test was written (June 2017) it # does not. # assert isinstance(wrapped, RMFModelNoPHA) wmdl = wrapped.model assert wmdl == mdl
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_arf1d_no_pha_no_exposure_call(exposure): "Can we call an ARF (no PHA)" egrid = np.arange(0.1, 0.6, 0.1) specresp = np.asarray([1.1, 1.2, 1.3, 1.4]) adata = create_arf(egrid[:-1], egrid[1:], specresp, exposure=exposure) arf = ARF1D(adata) mdl = Const1D('flat') mdl.c0 = 2.3 wrapped = arf(mdl) assert isinstance(wrapped, ARFModelNoPHA) wmdl = wrapped.model if exposure is None: assert wmdl == mdl else: # It looks like equality is not well defined for the model # classes, since the following assertion fails # assert wmdl == (exposure * mdl) # so manually check # assert isinstance(wmdl, BinaryOpModel) assert wmdl.op == np.multiply assert wmdl.rhs == mdl assert isinstance(wmdl.lhs, ArithmeticConstantModel) assert wmdl.lhs.val == pytest.approx(exposure)
def test_psf1d_combined_v2(): """See test_psf1d_step_v2""" smdl = StepLo1D() smdl.xcut = 100 smdl.ampl = 10 cmdl = Const1D() cmdl.c0 = -500 imdl = smdl + cmdl gsmooth = Gauss1D() psf = PSFModel('psf', gsmooth) x = np.arange(0, 200, 0.5) d = Data1D('fake', x, x * 0) psf.fold(d) smoothed = psf(imdl) y = smoothed(x) # So the output is not easy to describe analytically, hence # we just check parts of it. # assert y[(x >= 19.5) & (x <= 100)] == pytest.approx([-490] * 162, abs=1e-4) assert y[x >= 119] == pytest.approx([-500] * 162, abs=1e-4) # check that the x <= 19 values are in ascending order y1 = y[x <= 19] assert (y1[1:] > y1[:-1]).all()
def test_binop_arithmeticxxx(model, mtype): """Can we create and combine Arithmetic*Model objects?""" m1 = Const1D() m1.c0 = 2 mleft = model + m1 assert isinstance(mleft, BinaryOpModel) assert mleft.op == numpy.add assert len(mleft.parts) == 2 assert isinstance(mleft.parts[0], mtype) assert isinstance(mleft.parts[1], Const1D) mright = m1 + model assert isinstance(mright, BinaryOpModel) assert mright.op == numpy.add assert len(mright.parts) == 2 assert isinstance(mright.parts[0], Const1D) assert isinstance(mright.parts[1], mtype) x = numpy.linspace(0.1, 0.5, 5) if mtype == ArithmeticConstantModel: y1 = 25 * numpy.ones(5) else: y1 = model(x) + 2 y2 = mleft(x) y3 = mright(x) assert y2 == pytest.approx(y1) assert y3 == pytest.approx(y1)
def test_arfmodelpha_call(ignore): """What happens calling an arf with a pha? The ignore value indicates what channel to ignore (0 means nothing is ignored). The aim is to check edge effects, and as there are only a few channels, it was decided to test all channels. """ # Note: the exposure is set in the PHA and ARF, but should not be # used when evaluating the model; it's value has been # set to a value that the test will fail it it is. # exposure = 200.1 estep = 0.01 egrid = np.arange(0.01, 0.06, estep) svals = [1.1, 1.2, 1.3, 1.4] specresp = np.asarray(svals) adata = create_arf(egrid[:-1], egrid[1:], specresp, exposure=exposure) constant = 2.3 mdl = Const1D('flat') mdl.c0 = constant channels = np.arange(1, 5, dtype=np.int16) counts = np.asarray([10, 5, 12, 7], dtype=np.int16) pha = DataPHA('test-pha', channel=channels, counts=counts, exposure=exposure) pha.set_arf(adata) # force energy units (only needed if ignore is set) pha.set_analysis('energy') if ignore is not None: de = estep * 0.9 e0 = egrid[ignore] pha.notice(lo=e0, hi=e0 + de, ignore=True) # The assert are intended to help people reading this # code rather than being a useful check that the code # is working. mask = [True, True, True, True] mask[ignore] = False assert (pha.mask == mask).all() wrapped = ARFModelPHA(adata, pha, mdl) # The model is evaluated on the ARF grid, not whatever # is sent in. It is also integrated across the bins, # which is why there is a multiplication by the # grid width (for this constant model). # # Note that the filter doesn't change the grid. # de = egrid[1:] - egrid[:-1] expected = constant * np.asarray(svals) * de out = wrapped([4, 5]) assert_allclose(out, expected)
def test_chisquare(): """Is the chi square correct? This uses the data-variance calculation. """ dset = setup_basic_dataset() dset.ignore_bad() cpt1 = Const1D() cpt2 = StepHi1D() cpt1.c0 = 20 cpt2.ampl = 20 cpt2.xcut = 6.5 mdl = cpt1 + cpt2 # Since the model does not contain a *PHA instrument model # it will not include the area-scaling, so the data and # errors should not be scaled. # scale = False counts = expected_basic_counts(scale=scale)[1:] errors = expected_basic_chisquare_errors(scale=scale) mvals = mdl(dset.channel[1:]) expected = (counts - mvals)**2 / (errors**2) expected = expected.sum() stat = Chi2DataVar() sval = stat.calc_stat(dset, mdl) assert sval[0] == pytest.approx(expected)
def test_sourceplot_channels(caplog, make_basic_datapha): """Although we ask for channels we get energy units""" data = make_basic_datapha data.units = "channel" # use a model that is "okay" to use with keV bins # m1 = Const1D('bgnd') m2 = Gauss1D('abs1') src = 100 * m1 * (1 - m2) * 10000 m1.c0 = 0.01 m2.pos = 5.0 m2.fwhm = 4.0 m2.ampl = 0.1 sp = SourcePlot() with caplog.at_level(logging.INFO, logger='sherpa'): sp.prepare(data, src) assert len(caplog.records) == 1 lname, lvl, msg = caplog.record_tuples[0] assert lname == 'sherpa.astro.plot' assert lvl == logging.WARN assert msg == 'Channel space is unappropriate for the PHA unfolded source model,\nusing energy.' check_sourceplot_energy(sp)
def test_modelphahistogram_prepare_wavelength(make_data_path): """Check we can use wavelength setting""" from sherpa.astro.io import read_pha # could fake a dataset but it's easier to use one infile = make_data_path('3c273.pi') pha = read_pha(infile) pha.name = 'my-name.pi' pha.set_analysis('wave') pha.notice(3, 5) mdl = Const1D() # not bothered too much about the model (e.g. setting a response) # plot = aplot.ModelPHAHistogram() plot.prepare(pha, mdl) assert plot.xlabel == 'Wavelength (Angstrom)' assert plot.ylabel == 'Counts/sec/Angstrom' assert plot.title == 'Model' # data is inverted assert plot.xlo[0] > plot.xlo[-1] assert plot.xlo[0] > plot.xhi[0] assert np.all(plot.y > 0) assert plot.y.size == 9
def test_sourceplot_wavelength_counts(caplog): """test_sourceplot_wavelength but when rate=False is chosen""" bins = np.arange(0.1, 10.1, 0.1) data = DataPHA('', np.arange(10), np.ones(10), bin_lo=bins[:-1].copy(), bin_hi=bins[1:].copy()) data.units = "wave" data.rate = False # use a model that is "okay" to use with keV bins # m1 = Const1D('bgnd') m2 = Gauss1D('abs1') src = 100 * m1 * (1 - m2) * 10000 m1.c0 = 0.01 m2.pos = 5.0 m2.fwhm = 4.0 m2.ampl = 0.1 sp = SourcePlot() with caplog.at_level(logging.INFO, logger='sherpa'): sp.prepare(data, src) assert len(caplog.records) == 0 check_sourceplot_wavelength(sp)
def test_sourceplot_facn(factor, caplog, make_basic_datapha): """Change plot factor for test_sourceplot""" data = make_basic_datapha data.units = "energy" data.plot_fac = factor assert data.rate # use a model that is "okay" to use with keV bins # m1 = Const1D('bgnd') m2 = Gauss1D('abs1') src = 100 * m1 * (1 - m2) * 10000 m1.c0 = 0.01 m2.pos = 5.0 m2.fwhm = 4.0 m2.ampl = 0.1 sp = SourcePlot() with caplog.at_level(logging.INFO, logger='sherpa'): sp.prepare(data, src) assert len(caplog.records) == 0 check_sourceplot_energy(sp, factor=factor)
def test_sourceplot_wavelength_facn(factor, caplog): """Change plot factor for test_sourceplot_wavelength""" bins = np.arange(0.1, 10.1, 0.1) data = DataPHA('', np.arange(10), np.ones(10), bin_lo=bins[:-1].copy(), bin_hi=bins[1:].copy()) data.units = "wavelength" data.plot_fac = factor assert data.rate m1 = Const1D('bgnd') m2 = Gauss1D('abs1') src = 100 * m1 * (1 - m2) * 10000 m1.c0 = 0.01 m2.pos = 5.0 m2.fwhm = 4.0 m2.ampl = 0.1 sp = SourcePlot() with caplog.at_level(logging.INFO, logger='sherpa'): sp.prepare(data, src) assert len(caplog.records) == 0 check_sourceplot_wavelength(sp, factor=factor)
def test_sourceplot_wavelength(caplog): """Check we get wavelength units""" bins = np.arange(0.1, 10.1, 0.1) data = DataPHA('', np.arange(10), np.ones(10), bin_lo=bins[:-1].copy(), bin_hi=bins[1:].copy()) data.units = "wave" # Note that the model evaluation in done in Angstroms # m1 = Const1D('bgnd') m2 = Gauss1D('abs1') src = 100 * m1 * (1 - m2) * 10000 m1.c0 = 0.01 m2.pos = 5.0 m2.fwhm = 4.0 m2.ampl = 0.1 sp = SourcePlot() with caplog.at_level(logging.INFO, logger='sherpa'): sp.prepare(data, src) assert len(caplog.records) == 0 check_sourceplot_wavelength(sp)
def test_sourceplot(caplog): bins = np.arange(0.1, 10.1, 0.1) data = DataPHA('', np.arange(10), np.ones(10), bin_lo=bins[:-1].copy(), bin_hi=bins[1:].copy()) data.units = "energy" assert data.rate assert data.plot_fac == 0 # use a model that is "okay" to use with keV bins # m1 = Const1D('bgnd') m2 = Gauss1D('abs1') src = 100 * m1 * (1 - m2) * 10000 m1.c0 = 0.01 m2.pos = 5.0 m2.fwhm = 4.0 m2.ampl = 0.1 sp = SourcePlot() with caplog.at_level(logging.INFO, logger='sherpa'): sp.prepare(data, src) assert len(caplog.records) == 0 check_sourceplot_energy(sp)
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_sourceplot_prepare_wavelength(make_data_path): """Check we can use wavelength setting""" from sherpa.astro.io import read_pha # could fake a dataset but it's easier to use one infile = make_data_path('3c273.pi') pha = read_pha(infile) pha.name = 'my-name.pi' pha.set_analysis('wave') pha.notice(3, 5) mdl = Const1D() # not bothered too much about the model (e.g. setting a response) # plot = aplot.SourcePlot() plot.prepare(pha, mdl) assert plot.xlabel == 'Wavelength (Angstrom)' assert plot.ylabel.startswith('f(lambda) Photons/sec/cm') assert plot.ylabel.find('^2') != -1 assert plot.ylabel.endswith('/Angstrom ') assert plot.title == 'Source Model of my-name.pi' # data is inverted assert plot.xlo[0] > plot.xlo[-1] assert plot.xlo[0] > plot.xhi[0] assert np.all(plot.y > 0) assert plot.y.size == 1090
def test_rspmodelnopha_delta_call(): "What happens calling an RMF (delta)+ARF with no pha?" exposure = 200.1 egrid = np.arange(0.01, 0.06, 0.01) elo = egrid[:-1] ehi = egrid[1:] specresp = np.asarray([1.2, 0.0, 0.5, 4.3]) rdata = create_delta_rmf(elo, ehi) adata = create_arf(elo, ehi, specresp, exposure=exposure) constant = 2.3 mdl = Const1D('flat') mdl.c0 = constant wrapped = RSPModelNoPHA(adata, rdata, mdl) # The model is evaluated on the RMF grid, not whatever # is sent in. It is also integrated across the bins, # which is why there is a multiplication by the # grid width (for this constant model). # de = egrid[1:] - egrid[:-1] expected = constant * specresp * de out = wrapped([4, 5]) assert_allclose(out, expected)
def test_orderplot_check_range(): """Are the x/y values as expected? Note that this is not a proper test as the dataset only contains a single response. However, the code is not clear as what is meant to happen with multiple responses so do not spend too much time on this test here. """ oplot = OrderPlot() pha = example_pha_data() model = Const1D('example-mdl') oplot.prepare(pha, model, orders=[2]) assert len(oplot.xlo) == 1 assert len(oplot.xhi) == 1 assert len(oplot.y) == 1 assert oplot.xlo[0] == pytest.approx(np.arange(1, 11)) assert oplot.xhi[0] == pytest.approx(np.arange(2, 12)) # constant model / exposure time yexp = np.ones(10) / 1201 assert oplot.y[0] == pytest.approx(yexp)
def test_regrid1d_wrapping_str(): """Check the str output of a wrapped model. Since this includes the name field, it subsumes test_regrid1d_wrapping_name but leave that test alone as it is an explicit check. """ # This is basically checking that __str__ comes from # the CompositeModel and that everything is set up # correctly. # internal_model = Const1D('con') internal_model.c0 = 2 internal_model.c0.freeze() imodel_name = internal_model.name rmdl = ModelDomainRegridder1D(name='test') mdl = rmdl.apply_to(internal_model) expected_name = 'test({})'.format(imodel_name) # need to strip off the first line and replace it with # the new model name expected_params = "\n".join(str(internal_model).split('\n')[1:]) expected_str = expected_name + "\n" + expected_params assert str(mdl) == expected_str
def test_show_model(): """Can we show the model?""" m = ShowableModel() n = Const1D() n.c0 = 2 # add a test of parameter linking m.norm = 10 + n.c0 toks = str(m).split('\n') assert len(toks) == 6 assert toks[0] == 'thetestmodel' assert toks[1].strip().split() == [ 'Param', 'Type', 'Value', 'Min', 'Max', 'Units' ] assert toks[2].strip().split() == [ '-----', '----', '-----', '---', '---', '-----' ] assert toks[3].strip().split() == [ 'thetestmodel.P1', 'thawed', '1', '0', '10' ] assert toks[4].strip().split() == [ 'thetestmodel.accent', 'frozen', '2', '0', '10' ] assert toks[5].strip().split() == [ 'thetestmodel.norm', 'linked', '12', 'expr:', '(10', '+', 'const1d.c0)' ] # Should hidden parameters be capable of being thawed? assert m.notseen.val == 10 assert m.notseen.min == 5 assert m.notseen.max == 15 assert not m.notseen.frozen
def test_psf1d_combined(): """This is based on sherpa.models.tests.test_regrid_unit.test_regrid1_works_with_convolution_style but I wanted to make sure we have an explicit check of the underlying code. """ smdl = StepLo1D() smdl.xcut = 12.5 smdl.ampl = 10 cmdl = Const1D() cmdl.c0 = -500 imdl = smdl + cmdl gsmooth = Gauss1D() gsmooth.fwhm = 3 psf = PSFModel('psf', gsmooth) x = np.arange(5, 23, 3) d = Data1D('fake', x, x * 0) psf.fold(d) smoothed = psf(imdl) y = smoothed(x) assert y == pytest.approx([-490, -490, -490, -500, -500, -500], rel=7e-3)
def test_arfmodelnopha_call(): "What happens calling an arf with no pha?" # Note: the exposure is set in the ARF, but should not be # used when evaluating the model; it's value has been # set to a value that the test will fail it it is. # egrid = np.arange(0.01, 0.06, 0.01) svals = [1.1, 1.2, 1.3, 1.4] specresp = np.asarray(svals) adata = create_arf(egrid[:-1], egrid[1:], specresp, exposure=200.1) constant = 2.3 mdl = Const1D('flat') mdl.c0 = constant wrapped = ARFModelNoPHA(adata, mdl) # The model is evaluated on the ARF grid, not whatever # is sent in. It is also integrated across the bins, # which is why there is a multiplication by the # grid width (for this constant model). # de = egrid[1:] - egrid[:-1] expected = constant * np.asarray(svals) * de out = wrapped([4, 5]) assert_allclose(out, expected)
def test_fit(override_plot_backend): p = plot.FitPlot() r = p._repr_html_() assert r is None # note: always None x = np.arange(5, 8, 0.5) y = np.ones(x.size) d = Data1D('n n', x, y) m = Const1D() dplot = plot.DataPlot() dplot.prepare(d) mplot = plot.ModelPlot() mplot.prepare(d, m) p.prepare(dplot, mplot) r = p._repr_html_() # different to previous checks assert r is not None if plot.backend.name == 'pylab': assert '<summary>FitPlot</summary>' in r assert '<svg ' in r return assert '<summary>DataPlot (' in r assert '<summary>ModelPlot (' in r assert '<div class="dataval">n n</div>' in r assert '<div class="dataval">Model</div>' in r
def test_rspmodelpha_delta_call(ignore): """What happens calling a rsp with a pha (RMF is a delta fn)? The ignore value gives the channel to ignore (counting from 0). """ exposure = 200.1 estep = 0.025 egrid = np.arange(0.1, 0.8, estep) elo = egrid[:-1] ehi = egrid[1:] specresp = 2.4 * np.ones(elo.size, dtype=np.float32) specresp[2:5] = 0.0 specresp[16:19] = 3.2 adata = create_arf(elo, ehi, specresp, exposure=exposure) rdata = create_delta_rmf(elo, ehi, e_min=elo, e_max=ehi) nchans = elo.size constant = 2.3 mdl = Const1D('flat') mdl.c0 = constant 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_rmf(rdata) # force energy units (only needed if ignore is set) pha.set_analysis('energy') if ignore is not None: de = estep * 0.9 e0 = egrid[ignore] pha.notice(lo=e0, hi=e0 + de, ignore=True) # The assert are intended to help people reading this # code rather than being a useful check that the code # is working. mask = [True] * nchans mask[ignore] = False assert (pha.mask == mask).all() wrapped = RSPModelPHA(adata, rdata, pha, mdl) # The model is evaluated on the RMF grid, not whatever # is sent in. It is also integrated across the bins, # which is why there is a multiplication by the # grid width (for this constant model). # # Note that the filter doesn't change the grid. # de = egrid[1:] - egrid[:-1] expected = constant * specresp * de out = wrapped([4, 5]) assert_allclose(out, expected)
def test_cache_status_multiple(caplog): """Check cache_status for a multi-component model. Unlike test_cache_syayus_single we also have evaluated the model so we can check that the cache status has changed. """ # The model expression includes an ArithmeticConstant model (the # term 2) which does not have a cache and so is ignored by # cache_status. # p = Polynom1D() b = Box1D() c = Const1D() mdl = c * (2 * p + b) # One model is not cached b._use_caching = False mdl([0.1, 0.2, 0.3]) mdl([0.1, 0.2, 0.3]) mdl([0.1, 0.2, 0.3, 0.4]) with caplog.at_level(logging.INFO, logger='sherpa'): mdl.cache_status() assert len(caplog.records) == 3 tokens = [] for lname, lvl, msg in caplog.record_tuples: assert lname == 'sherpa.models.model' assert lvl == logging.INFO toks = msg.split() assert len(toks) == 9 assert toks[1] == 'size:' assert toks[2] == '1' assert toks[3] == 'hits:' assert toks[5] == 'misses:' assert toks[7] == 'check:' assert toks[8] == '3' tokens.append(toks) toks = tokens[0] assert toks[0] == 'const1d' assert toks[4] == '1' assert toks[6] == '2' toks = tokens[1] assert toks[0] == 'polynom1d' assert toks[4] == '1' assert toks[6] == '2' toks = tokens[2] assert toks[0] == 'box1d' assert toks[4] == '0' assert toks[6] == '0'
def test_rsp_no_arf_matrix_call(analysis, phaexp): """Check out Response1D with matrix but no ARF analysis is the analysis setting arfexp determines whether the arf has an exposure time phaexp determines whether the PHA has an exposure time """ if phaexp: pha_exposure = 220.9 else: pha_exposure = None if phaexp: exposure = pha_exposure mdl_label = '({} * flat)'.format(exposure) else: exposure = 1.0 mdl_label = 'flat' rdata = create_non_delta_rmf() constant = 2.3 mdl = Const1D('flat') mdl.c0 = constant # Turn off integration on this model, so that it is not integrated # across the bin width. # mdl.integrate = False nchans = rdata.e_min.size channels = np.arange(1, nchans + 1, dtype=np.int16) counts = np.ones(nchans, dtype=np.int16) pha = DataPHA('test-pha', channel=channels, counts=counts, exposure=pha_exposure) pha.set_rmf(rdata) rsp = Response1D(pha) wrapped = rsp(mdl) assert isinstance(wrapped, ArithmeticModel) expname = 'apply_rmf({})'.format(mdl_label) assert wrapped.name == expname modvals = exposure * constant * np.ones(rdata.energ_lo.size) matrix = get_non_delta_matrix() expected = np.matmul(modvals, matrix) pha.set_analysis(analysis) out = wrapped([4, 5]) assert_allclose(out, expected)
def test_sourceplot(): bins = np.arange(0.1, 10.1, 0.1) data = DataPHA('', np.arange(10), np.ones(10), bin_lo=bins[:-1].copy(), bin_hi=bins[1:].copy()) data.units = "energy" # use a model that is "okay" to use with keV bins # m1 = Const1D('bgnd') m2 = Gauss1D('abs1') src = 100 * m1 * (1 - m2) * 10000 m1.c0 = 0.01 m2.pos = 5.0 m2.fwhm = 4.0 m2.ampl = 0.1 sp = SourcePlot() sp.prepare(data, src) # add in several asserts to check that something has been # added to the object # assert sp.xlabel == 'Energy (keV)' # the following depends on the backend # assert sp.ylabel == 'f(E) Photons/sec/cm$^2$/keV' assert sp.title == 'Source Model of ' assert sp.xlo == pytest.approx(bins[:-1]) assert sp.xhi == pytest.approx(bins[1:]) # The check of the values is just to check that things are going # as expected, so the model values have been adjusted so that # an "integer" check can be used with enough precision to make # sure that the model is being evaluated correctly, but without # a very-high-precision check # yexp = np.asarray([9998, 9997, 9997, 9997, 9996, 9996, 9995, 9994, 9994, 9993, 9992, 9991, 9990, 9988, 9987, 9985, 9983, 9982, 9980, 9977, 9975, 9973, 9970, 9967, 9964, 9961, 9958, 9955, 9951, 9948, 9944, 9941, 9937, 9934, 9930, 9927, 9923, 9920, 9917, 9914, 9911, 9909, 9907, 9905, 9903, 9902, 9901, 9900, 9900, 9900, 9900, 9901, 9902, 9903, 9905, 9907, 9909, 9911, 9914, 9917, 9920, 9923, 9927, 9930, 9934, 9937, 9941, 9944, 9948, 9951, 9955, 9958, 9961, 9964, 9967, 9970, 9973, 9975, 9977, 9980, 9982, 9983, 9985, 9987, 9988, 9990, 9991, 9992, 9993, 9994, 9994, 9995, 9996, 9996, 9997, 9997, 9997, 9998, 9998]) assert (sp.y.astype(np.int) == yexp).all()
def test_regrid1d_wrapping_create_composite_instance(): # This test depends on what we want the regridded model to look like, which is # somewhat arbitrary cmdl = Const1D() gmdl = Gauss1D() imdl = cmdl + gmdl rmdl = ModelDomainRegridder1D() mdl = rmdl.apply_to(imdl) assert isinstance(mdl, CompositeModel) assert len(mdl.parts) == 1 assert mdl.parts[0] is imdl
def test_functionmodel_check(): """ArithmeticFunctionModel errors out with invalid input""" with pytest.raises(ModelErr) as exc: ArithmeticFunctionModel(Const1D()) assert str(exc.value) == 'ArithmeticFunctionModel instance cannot be created from another model' with pytest.raises(ModelErr) as exc: ArithmeticFunctionModel(23) assert str(exc.value) == 'attempted to create ArithmeticFunctionModel from non-callable object of type int'
def test_model_linked(): """Check linking of models""" m = Gauss1D('g1') c = Const1D('c1') m.fwhm = 8 * c.c0 r = m._repr_html_() assert r is not None assert '<tr><th class="model-odd" scope="rowgroup" rowspan=3>g1</th><td>fwhm</td><td>linked</td><td>8.0</td><td colspan=2>⇐ 8 * c1.c0</td><td></td></tr>' in r assert '<tr><td>pos</td><td><input disabled type="checkbox" checked></input></td><td>0.0</td><td>-MAX</td><td>MAX</td><td></td></tr>' in r assert '<tr><td>ampl</td><td><input disabled type="checkbox" checked></input></td><td>1.0</td><td>-MAX</td><td>MAX</td><td></td></tr>' in r
def calc(self, *args, **kwargs): self._calc_store.append((args, kwargs)) return Const1D.calc(self, *args, **kwargs)
def __init__(self, name='myconst1d'): self._calc_store = [] Const1D.__init__(self, name)