def test_input_output_with_external_parameters():
mg = ModelGetter()
m = mg.model
# Create an external parameter
fake_parameter = Parameter("external_parameter",
1.0,
min_value=-1.0,
max_value=1.0,
free=True)
# Link as equal (default)
m.add_external_parameter(fake_parameter)
# Save model
temp_file = "__test.yml"
m.save(temp_file, overwrite=True)
# Now reload it again
m_reloaded = load_model(temp_file)
os.remove(temp_file)
# Check that all sources have been recovered
assert m_reloaded.sources.keys() == m.sources.keys()
# Check that the external parameter have been recovered
assert 'external_parameter' in m_reloaded
# Remove external parameter
m.remove_external_parameter("external_parameter")
# Add a prior to the external parameter
fake_parameter.prior = Uniform_prior()
fake_parameter.value = -0.1
m.add_external_parameter(fake_parameter)
# Save model
temp_file = "__test.yml"
m.save(temp_file, overwrite=True)
# Now reload it again
m_reloaded = load_model(temp_file)
os.remove(temp_file)
# Check that all sources have been recovered
assert m_reloaded.sources.keys() == m.sources.keys()
# Check that the external parameter have been recovered
assert 'external_parameter' in m_reloaded
assert m.external_parameter.value == m_reloaded.external_parameter.value
def test_in_unit_of():
p = Parameter('test_parameter', 1.0, min_value=-5.0, max_value=5.0,
delta=0.2, desc='test', free=False, unit='MeV')
assert p.in_unit_of(u.keV) == 1000.0
assert p.in_unit_of(u.keV, as_quantity=True).to("MeV").value == 1.0
def test_constructor_complete():
p = 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(),
is_normalization=True,
)
assert p.min_value == -5.0
assert p.max_value == 5.0
assert p.value == 1.0
assert p.delta == 0.2
assert p.name == 'test_parameter'
assert p.description == 'test'
assert p.fix == True
assert p.free == False
assert p.has_prior() == True
assert p.unit == u.MeV
assert p.is_normalization
p.display()
def test_constructor_with_delta():
p = Parameter('test_parameter', 1.0, delta=0.3)
assert p.delta == 0.3
p.display()
def test_constructor_with_units():
p = Parameter('test_parameter', 1.0, unit=u.keV)
assert p.unit == u.keV
p.display()
def test_constructor_with_boundaries():
p = Parameter('test_parameter', 1.0, min_value=-5, max_value=5)
assert p.min_value == -5
assert p.max_value == 5
p.display()
def test_set_within_bounds_no_units():
p = Parameter('test_parameter', 1.0, min_value=-2.0, max_value=2.0)
p.value = 1.5
assert p.value == 1.5
p.display()
def test_set_delta_nounits():
p = Parameter('test_parameter', 1.0)
p.delta = 0.5
assert p.delta == 0.5
p.display()
def test_set_no_units():
p = Parameter('test_parameter', 1.0)
p.value = 25.4
assert p.value == 25.4
p.display()
def test_set_within_bounds_units():
p = Parameter('test_parameter',1.0 * u.keV, min_value = -2.0 * u.MeV, max_value = 2.0 * u.MeV, unit=u.keV)
p.value = 1.2 * u.MeV
assert p.value == 1200.0
p.display()
def test_set_delta_units():
p = Parameter('test_parameter', 1.0, unit='GeV')
p.delta = 500 * u.MeV
assert p.delta == 0.5
p.display()
def test_set_bounds_nounits():
p = Parameter('test_parameter', 1.0)
p.bounds = (-2.0, 2.0)
assert p.min_value == -2.0
assert p.max_value == 2.0
p.display()
def test_set_remove_minimum():
p1 = Parameter('test_parameter', 1.0, min_value=-5.0, max_value=5.0, delta=0.2, desc='test', free=False, unit='MeV')
p1.remove_minimum()
assert p1.min_value == None
p1.value = -1000.0
assert p1.value == -1000.0
def test_set_bounds_units():
p = Parameter('test_parameter', 1.0 * u.keV)
p.bounds = (-2.0 * u.MeV, 2.0 * u.eV)
assert p.min_value == -2000
assert p.max_value == 2e-3
p.display()
def test_set_units():
p = Parameter('test_parameter', 1.0, unit=u.keV)
p.value = 3.0 * u.MeV
assert p.value == 3000.0
with pytest.raises(u.UnitConversionError):
p.value = 3.0 * u.cm
with pytest.raises(CannotConvertValueToNewUnits):
p.unit = u.cm
with pytest.raises(CannotConvertValueToNewUnits):
p.unit = u.dimensionless_unscaled
p.unit = u.MeV
assert p.unit == u.MeV
p.display()
def test_external_parameters():
mg = ModelGetter()
m = mg.model
n_free_before_external = len(m.free_parameters)
# Create parameter
fake_parameter = Parameter("external_parameter",1.0, min_value=-1.0, max_value=1.0, free=True)
# Link as equal (default)
m.add_external_parameter(fake_parameter)
assert len(m.free_parameters) - 1 == n_free_before_external
# Try to display it just to make sure it works
m.display()
# Now test that we can remove it
m.remove_external_parameter("external_parameter")
assert len(m.free_parameters) == n_free_before_external
# Now test that adding it twice will not fail, but will issue a warning
m.add_external_parameter(fake_parameter)
with pytest.warns(RuntimeWarning):
m.add_external_parameter(fake_parameter)
def test_as_quantity():
p = Parameter('test_parameter', 1.0, min_value=-5.0, max_value=5.0,
delta=0.2, desc='test', free=False, unit='MeV')
assert isinstance(p.as_quantity, u.Quantity)
assert p.as_quantity.to("keV").value == 1000.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
def test_pickle():
from astromodels.core.cpickle_compatibility_layer import cPickle
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())
# Add a callback
working_callback = Callback()
p_orig.add_callback(working_callback)
# Now pickle and unpickle
d = cPickle.dumps(p_orig)
p = cPickle.loads(d)
# Check that everything is fine
assert p.min_value == -5.0
assert p.max_value == 5.0
assert p.value == 1.0
assert p.delta == 0.2
assert p.name == 'test_parameter'
assert p.description == 'test'
assert p.fix == True
assert p.free == False
assert p.has_prior() == True
assert p.unit == u.MeV
# Test the callback
p.value = 2.0
callback = p.get_callbacks()[0]
assert callback._control_value == p.value
def test_conflicting_units_in_initial_value_and_unit_keyword():
p = Parameter('test_parameter', 1.0 * u.keV, desc='Description', unit=u.MeV)
assert p.min_value is None
assert p.max_value is None
assert p.value == 1.0e-3
assert isinstance(p.delta, float)
assert p.name == 'test_parameter'
assert p.description == 'Description'
assert p.fix == False
assert p.free == True
assert p.has_prior() == False
assert p.prior is None
assert p.unit == u.MeV
p.display()
def test_default_constructor_units():
p = Parameter('test_parameter', 1.0 * u.keV, desc='Description')
assert p.min_value is None
assert p.max_value is None
assert p.value == 1.0
assert isinstance(p.delta, float)
assert p.name == 'test_parameter'
assert p.description == 'Description'
assert p.fix == False
assert p.free == True
assert p.has_prior() == False
assert p.prior is None
assert p.unit == u.keV
p.display()
def test_callback():
p1 = Parameter('test_parameter',
1.0,
min_value=-5.0,
max_value=5.0,
delta=0.2,
desc='test',
free=False,
unit='MeV')
class Callback(object):
def __init__(self):
self._control_value = None
def __call__(self, p):
assert p == p1
self._control_value = p1.value
working_callback = Callback()
p1.add_callback(working_callback)
# Test the callback
p1.value = 2.0
assert working_callback._control_value == p1.value
def not_working_callback():
# Wrong calling sequence
pass
p1.add_callback(not_working_callback)
with pytest.raises(NotCallableOrErrorInCall):
p1.value = 2.0
p1.empty_callbacks()
assert len(p1._callbacks) == 0
def test_default_constructor():
p = Parameter('test_parameter', 1.0, desc='Description')
assert p.min_value is None
assert p.max_value is None
assert p.value == 1.0
assert isinstance(p.delta, float)
assert p.name == 'test_parameter'
assert p.description == 'Description'
assert p.fix == False
assert p.free == True
assert p.has_prior() == False
assert p.prior is None
assert p.unit == u.dimensionless_unscaled
# Test that we cannot call a parameter with a name with spaces in it
with pytest.raises(AssertionError):
_ = Parameter('test parameter 2', 1.0)
# Test some failures cases
with pytest.raises(ValueError):
_ = Parameter('test', 'pippo')
with pytest.raises(ValueError):
_ = Parameter('test', 1.0, min_value='a')
with pytest.raises(ValueError):
_ = Parameter('test', 1.0, max_value='b')
with pytest.raises(TypeError):
_ = Parameter('test', 1.0, delta='b')
p.display()
def test_duplicate():
p1 = Parameter('test_parameter', 1.0, min_value=-5.0, max_value=5.0, delta=0.2, desc='test', free=False, unit='MeV')
p2 = p1.duplicate()
assert p1.to_dict() == p2.to_dict()
p1.display()
p2.display()
def test_clone_model():
mg = ModelGetter()
m1 = mg.model
m2 = clone_model(m1)
for source in m2.sources:
assert source in m1.sources
# Test that changing the parameter in one model does not changes the other
list(m2.free_parameters.values())[0].value = old_div(
list(m2.free_parameters.values())[0].value, 2.0
)
assert (
list(m2.free_parameters.values())[0].value
!= list(m1.free_parameters.values())[0].value
)
# test cloning model with linked external parameters
mg = ModelGetter()
m1 = mg.model
# Create parameter
fake_parameter = Parameter(
"external_parameter", 1.0, min_value=-1.0, max_value=1.0, free=True
)
# Link as equal (default)
m1.add_external_parameter(fake_parameter)
m1.link(m1.one.spectrum.main.Powerlaw.K, fake_parameter)
_ = clone_model(m1)
mg = ModelGetter()
m1 = mg.model
# Link as equal (default)
m1.add_external_parameter(fake_parameter)
m1.link(fake_parameter, m1.one.spectrum.main.Powerlaw.K)
_ = clone_model(m1)
def test_add_and_remove_independent_variable():
mg = ModelGetter()
m = mg.model
# Create an independent variable
independent_variable = IndependentVariable("time", 1.0, u.s)
# Try to add it
m.add_independent_variable(independent_variable)
# Try to remove it
m.remove_independent_variable("time")
with pytest.raises(AssertionError):
m.add_independent_variable(Parameter("time", 1.0))
# Try to add it twice, which shouldn't fail
m.add_independent_variable(independent_variable)
m.add_independent_variable(independent_variable)
# Try to display it just to make sure it works
m.display()
# Now try to use it
link_law = Powerlaw()
link_law.K.value = 1.0
link_law.index.value = -1.0
n_free_before_link = len(m.free_parameters)
m.link(m.one.spectrum.main.Powerlaw.K, independent_variable, link_law)
# The power law adds two parameters, but the link removes one, so
assert len(m.free_parameters) - 1 == n_free_before_link
# Now see if it works
for t in np.linspace(0, 10, 100):
independent_variable.value = t
assert m.one.spectrum.main.Powerlaw.K.value == link_law(t)
def test_set_bounds_nounits():
p = Parameter('test_parameter', 1.0)
p.bounds = (-2.0 ,2.0)
assert p.min_value == -2.0
assert p.max_value == 2.0
p.display()
with pytest.warns(RuntimeWarning):
p.value = 1.0
p.min_value = 2.0
def test_set_outside_bounds_units():
p = Parameter('test_parameter', 1.0 * u.keV, min_value = -2.0 * u.MeV, max_value = 2.0 * u.MeV, unit=u.keV)
with pytest.raises(SettingOutOfBounds):
p.value = -10.0 * u.MeV
with pytest.raises(SettingOutOfBounds):
p.value = 10.0 * u.MeV
p.display()
def test_set_outside_bounds_no_units():
p = Parameter('test_parameter', 1.0, min_value=-2.0, max_value=2.0)
with pytest.raises(SettingOutOfBounds):
p.value = -10.0
with pytest.raises(SettingOutOfBounds):
p.value = 10.0
p.display()
def test_remove_prior():
p1 = Parameter('test_parameter', 1.0, min_value=-5.0, max_value=5.0,
delta=0.2, desc='test', free=False, unit='MeV')
my_prior = Uniform_prior()
p1.prior = my_prior
assert p1.has_prior()==True
# Now remove it
p1.prior = None
assert p1.has_prior()==False
