Exemple #1
0
def test_remove_auxiliary_variable():

    p1 = Parameter('test_parameter',
                   1.0,
                   min_value=-5.0,
                   max_value=5.0,
                   delta=0.2,
                   desc='test',
                   free=False,
                   unit='MeV')

    x = Parameter('aux_variable', 1.0)

    # ax + b

    law = Line()
    law.a = 2.0
    law.b = 1.0

    p1.add_auxiliary_variable(x, law)

    assert p1.value == 3.0

    x.value = 4.0

    assert p1.value == 6.0

    p1.remove_auxiliary_variable()

    assert p1.has_auxiliary_variable() == False

    p1.value = -1.0

    assert p1.value == -1.0
def test_remove_auxiliary_variable():

    p1 = Parameter('test_parameter', 1.0, min_value=-5.0, max_value=5.0, delta=0.2, desc='test', free=False, unit='MeV')

    x = Parameter('aux_variable', 1.0)

    # ax + b

    law = Line()
    law.a = 1.0
    law.b = 2.0

    p1.add_auxiliary_variable(x, law)

    assert p1.value == 3.0

    x.value = 4.0

    assert p1.value == 6.0

    p1.remove_auxiliary_variable()

    assert p1.has_auxiliary_variable() == False

    p1.value = -1.0

    assert p1.value == -1.0
def test_set_auxiliary_variable():

    p1 = Parameter('test_parameter', 1.0, min_value=-5.0, max_value=5.0, delta=0.2, desc='test', free=False, unit='MeV')

    x = Parameter('aux_variable', 1.0)

    # ax + b

    law = Line()
    law.a = 1.0
    law.b = 2.0

    p1.add_auxiliary_variable(x, law)

    assert p1.has_auxiliary_variable() == True

    assert p1.value == 3.0

    x.value = 4.0

    assert p1.value == 6.0

    # Check that assigning to the parameter doesn't produce any effect
    p1.value = -1.0

    assert p1.value == 6.0
Exemple #4
0
def test_links_and_pickle():

    import pickle

    p_orig = Parameter('test_parameter',
                       1.0,
                       min_value=-5.0,
                       max_value=5.0,
                       delta=0.2,
                       desc='test',
                       free=False,
                       unit=u.MeV,
                       prior=Uniform_prior())

    # Test the linkinking and pickle

    # Add a link
    x = Parameter('aux_variable', 1.0)

    # ax + b

    law = Line()
    law.a = 2.0
    law.b = 1.0

    p_orig.add_auxiliary_variable(x, law)

    # Now pickle and unpickle

    d = pickle.dumps(p_orig)

    p = pickle.loads(d)

    assert p.has_auxiliary_variable() == True

    assert p.value == 3.0

    assert p.free == False

    p.auxiliary_variable[0].value = 4.0

    assert p.value == 6.0

    # Check that assigning to the parameter doesn't produce any effect
    p.value = -1.0

    assert p.value == 6.0
Exemple #5
0
def test_set_auxiliary_variable():

    p1 = Parameter('test_parameter',
                   1.0,
                   min_value=-5.0,
                   max_value=5.0,
                   delta=0.2,
                   desc='test',
                   free=False,
                   unit='MeV')

    x = Parameter('aux_variable', 1.0)

    # ax + b

    law = Line()
    law.a = 2.0
    law.b = 1.0

    p1.add_auxiliary_variable(x, law)

    assert p1.has_auxiliary_variable() == True

    assert p1.value == 3.0

    assert p1.free == False

    x.value = 4.0

    assert p1.value == 6.0

    # Check that assigning to the parameter doesn't produce any effect
    p1.value = -1.0

    assert p1.value == 6.0

    # Now check errors reporting
    with pytest.raises(AttributeError):

        p1.add_auxiliary_variable(1.0, law)

    # Now add it twice to verify that it overwrites it
    p1.add_auxiliary_variable(x, law)
    p1.add_auxiliary_variable(x, law)

    p1.display()
def test_pickling_unpickling():

    # 1d function
    po = Powerlaw()

    po.K = 5.35

    new_po = pickle.loads(pickle.dumps(po))

    assert new_po.K.value == po.K.value

    # 2d function
    gs = Gaussian_on_sphere()

    _ = pickle.loads(pickle.dumps(gs))

    # 3d function
    c = Continuous_injection_diffusion()

    _ = pickle.loads(pickle.dumps(c))

    # composite function
    po2 = Powerlaw()
    li = Line()
    composite = po2 * li + po2 - li + 2 * po2 / li  # type: Function1D

    # Change some parameter
    composite.K_1 = 3.2
    composite.a_2 = 1.56

    dump = pickle.dumps(composite)

    new_composite = pickle.loads(dump)

    assert new_composite.K_1.value == composite.K_1.value
    assert new_composite.a_2.value == composite.a_2.value
Exemple #7
0
def test_time_domain_integration():

    po = Powerlaw()

    default_powerlaw = Powerlaw()

    src = PointSource("test", ra=0.0, dec=0.0, spectral_shape=po)

    m = Model(src)  # type: model.Model

    # Add time independent variable
    time = IndependentVariable("time", 0.0, u.s)

    m.add_independent_variable(time)

    # Now link one of the parameters with a simple line law
    line = Line()

    line.a = 0.0

    m.link(po.index, time, line)

    # Test the display just to make sure it doesn't crash
    m.display()

    # Now test the average with the integral

    energies = np.linspace(1, 10, 10)

    results = m.get_point_source_fluxes(0, energies,
                                        tag=(time, 0, 10))  # type: np.ndarray

    assert np.all(results == 1.0)

    # Now test the linking of the normalization, first with a constant then with a line with a certain
    # angular coefficient

    m.unlink(po.index)

    po.index.value = default_powerlaw.index.value

    line2 = Line()

    line2.a = 0.0
    line2.b = 1.0

    m.link(po.K, time, line2)

    time.value = 1.0

    results = m.get_point_source_fluxes(0, energies, tag=(time, 0, 10))

    assert np.allclose(results, default_powerlaw(energies))

    # Now make something actually happen
    line2.a = 1.0
    line2.b = 1.0

    results = m.get_point_source_fluxes(0, energies,
                                        tag=(time, 0, 10))  # type: np.ndarray

    # Compare with analytical result
    def F(x):
        return line2.a.value / 2.0 * x**2 + line2.b.value * x

    effective_norm = (F(10) - F(0)) / 10.0

    expected_results = default_powerlaw(
        energies) * effective_norm  # type: np.ndarray

    assert np.allclose(expected_results, results)
def test_function_composition():

    Test_function = get_a_function_class()

    line = Test_function()
    powerlaw = Powerlaw()

    composite = powerlaw + line

    composite.set_units(u.keV, 1.0 / (u.keV * u.cm**2 * u.s))

    for x in ([1, 2, 3,
               4], [1, 2, 3, 4] * u.keV, 1.0, np.array([1.0, 2.0, 3.0, 4.0])):

        assert np.all(composite(x) == line(x) + powerlaw(x))

    # Test -
    po = Powerlaw()
    li = Line()
    composite = po - li

    assert composite(1.0) == (po(1.0) - li(1.0))

    # test *
    composite = po * li

    assert composite(2.25) == po(2.25) * li(2.25)

    # test /
    composite = po / li

    assert composite(2.25) == po(2.25) / li(2.25)

    # test .of
    composite = po.of(li)

    assert composite(2.25) == po(li(2.25))

    # test power
    composite = po**li

    assert composite(2.25) == po(2.25)**li(2.25)

    # test negation
    neg_po = -po

    assert neg_po(2.25) == -po(2.25)

    # test abs
    new_li = Line()
    new_li.b = -10.0

    abs_new_li = abs(new_li)

    assert new_li(1.0) < 0
    assert abs_new_li(1.0) == abs(new_li(1.0))

    # test rpower
    composite = 2.0**new_li

    assert composite(2.25) == 2.0**(new_li(2.25))

    # test multiplication by a number
    composite = 2.0 * po

    assert composite(2.25) == 2.0 * po(2.25)

    # Number divided by
    composite = 1.0 / li

    assert composite(2.25) == 1.0 / li(2.25)

    # Composite of composite
    composite = po * li + po - li + 2 * po / li

    assert composite(2.25) == po(2.25) * li(2.25) + po(2.25) - li(
        2.25) + 2 * po(2.25) / li(2.25)

    print(composite)