def __init__(self, r_s=None, alpha=None, rho_s=1 * u.Unit("GeV / cm3")):
alpha = self.DEFAULT_ALPHA if alpha is None else alpha
r_s = self.DEFAULT_SCALE_RADIUS if r_s is None else r_s
self.parameters = Parameters([
Parameter("r_s", u.Quantity(r_s)),
Parameter("alpha", u.Quantity(alpha)),
Parameter("rho_s", u.Quantity(rho_s)),
])
def __init__(self, lon_0, lat_0, frame="galactic"):
self.frame = frame
self.lon_0 = Parameter("lon_0",
Longitude(lon_0).wrap_at("180d"),
min=-180,
max=180)
self.lat_0 = Parameter("lat_0", Latitude(lat_0), min=-90, max=90)
super().__init__([self.lon_0, self.lat_0])
def __init__(self, lon_0, lat_0, radius, width, frame="galactic"):
self.frame = frame
self.lon_0 = Parameter("lon_0",
Longitude(lon_0).wrap_at("180d"),
min=-180,
max=180)
self.lat_0 = Parameter("lat_0", Latitude(lat_0), min=-90, max=90)
self.radius = Parameter("radius", Angle(radius))
self.width = Parameter("width", Angle(width))
super().__init__([self.lon_0, self.lat_0, self.radius, self.width])
def __init__(self, lon_0, lat_0, r_0, edge="0.01 deg", frame="galactic"):
self.frame = frame
self.lon_0 = Parameter("lon_0",
Longitude(lon_0).wrap_at("180d"),
min=-180,
max=180)
self.lat_0 = Parameter("lat_0", Latitude(lat_0), min=-90, max=90)
self.r_0 = Parameter("r_0", Angle(r_0))
self.edge = Parameter("edge", Angle(edge), min=0.01, frozen=True)
super().__init__([self.lon_0, self.lat_0, self.r_0, self.edge])
def __init__(self,
amplitude=1E-12 * u.Unit('cm-2 s-1 TeV-1'),
reference=10 * u.TeV,
alpha=2,
beta=1):
self.parameters = Parameters([
Parameter('amplitude', amplitude),
Parameter('reference', reference, frozen=True),
Parameter('alpha', alpha),
Parameter('beta', beta)
])
def test_parameter_quantity():
par = Parameter("spam", 42, "deg", 10)
quantity = par.quantity
assert quantity.unit == "deg"
assert quantity.value == 420
par.quantity = "70 deg"
assert_allclose(par.factor, 7)
assert par.scale == 10
assert par.unit == "deg"
def test_parameter_scale():
# Basic check how scale is used for value, min, max
par = Parameter("spam", 42, "deg", 10, 400, 500)
assert par.value == 420
assert par.min == 400
assert_allclose(par.factor_min, 40)
assert par.max == 500
assert_allclose(par.factor_max, 50)
par.value = 70
assert par.scale == 10
assert_allclose(par.factor, 7)
def __init__(
self,
amplitude=1e-12 * u.Unit("cm-2 s-1 TeV-1"),
reference=10 * u.TeV,
alpha=2,
beta=1,
):
self.parameters = Parameters([
Parameter("amplitude", amplitude),
Parameter("reference", reference, frozen=True),
Parameter("alpha", alpha),
Parameter("beta", beta),
])
def __init__(
self,
map,
norm=1,
meta=None,
interp_kwargs=None,
name="diffuse",
filename=None,
obs_id="Global",
):
self.name = name
axis = map.geom.get_axis_by_name("energy")
if axis.node_type != "center":
raise ValueError('Need a map with energy axis node_type="center"')
self.map = map
self.norm = Parameter("norm", norm)
self.meta = {} if meta is None else meta
self.filename = filename
self.obs_id = obs_id
interp_kwargs = {} if interp_kwargs is None else interp_kwargs
interp_kwargs.setdefault("interp", "linear")
interp_kwargs.setdefault("fill_value", 0)
self._interp_kwargs = interp_kwargs
super().__init__([self.norm])
def __init__(self):
self.parameters = Parameters(
[
Parameter("amplitude", 3e-12, unit="cm-2 s-1 TeV-1"),
Parameter("reference", 1, unit="TeV", frozen=True),
Parameter("alpha", 2.4, min=1, max=5),
Parameter("beta", 0.2, min=0.001, max=1),
Parameter("z_fermi", 0),
Parameter("z_magic", 0),
Parameter("z_veritas", 0),
Parameter("z_fact", 0),
Parameter("z_hess", 0),
]
)
def __init__(self, mass, channel, scale=1, jfactor=1, z=0, k=2):
self.scale = Parameter("scale", scale)
self.k = k
self.z = z
self.mass = mass
self.channel = channel
self.jfactor = jfactor
self.primary_flux = PrimaryFlux(mass, channel=self.channel).table_model
super().__init__([self.scale])
def __init__(self,
lon_0,
lat_0,
sigma_semi_major,
e,
phi,
frame="galactic"):
self.frame = frame
self.lon_0 = Parameter("lon_0",
Longitude(lon_0).wrap_at("180d"),
min=-180,
max=180)
self.lat_0 = Parameter("lat_0", Latitude(lat_0), min=-90, max=90)
self.sigma_semi_major = Parameter("sigma_semi_major",
Angle(sigma_semi_major))
self.e = Parameter("e", e, min=0, max=1)
self.phi = Parameter("phi", Angle(phi))
super().__init__(
[self.lon_0, self.lat_0, self.sigma_semi_major, self.e, self.phi])
def test_parameter_init():
par = Parameter("spam", 42, "deg")
assert par.name == "spam"
assert par.factor == 42
assert isinstance(par.factor, float)
assert par.scale == 1
assert isinstance(par.scale, float)
assert par.value == 42
assert isinstance(par.value, float)
assert par.unit == "deg"
assert par.min is np.nan
assert par.max is np.nan
assert par.frozen is False
par = Parameter("spam", "42 deg")
assert par.factor == 42
assert par.scale == 1
assert par.unit == "deg"
with pytest.raises(TypeError):
Parameter(1, 2)
def __init__(self,
lon_0,
lat_0,
semi_major,
e,
phi,
edge="0.01 deg",
frame="galactic"):
try:
from astropy.coordinates.angle_utilities import offset_by
self._offset_by = offset_by
except ImportError:
raise ImportError("The SkyEllipse model requires astropy>=3.1")
self.frame = frame
self.lon_0 = Parameter("lon_0",
Longitude(lon_0).wrap_at("180d"),
min=-180,
max=180)
self.lat_0 = Parameter("lat_0", Latitude(lat_0), min=-90, max=90)
self.semi_major = Parameter("semi_major", Angle(semi_major))
self.e = Parameter("e", e, min=0, max=1)
self.phi = Parameter("phi", Angle(phi))
self.edge = Parameter("edge", Angle(edge), frozen=True, min=0.01)
super().__init__([
self.lon_0, self.lat_0, self.semi_major, self.e, self.phi,
self.edge
])
def __init__(
self,
background,
norm=1,
tilt=0,
reference="1 TeV",
name="background",
filename=None,
obs_id=None,
):
axis = background.geom.get_axis_by_name("energy")
if axis.node_type != "edges":
raise ValueError(
'Need an integrated map, energy axis node_type="edges"')
self.map = background
self.norm = Parameter("norm", norm, unit="", min=0)
self.tilt = Parameter("tilt", tilt, unit="", frozen=True)
self.reference = Parameter("reference", reference, frozen=True)
self.name = name
self.filename = filename
self.obs_id = obs_id
super().__init__([self.norm, self.tilt, self.reference])
def test_parameters_getitem(pars):
assert pars[1].name == "ham"
assert pars["ham"].name == "ham"
assert pars[pars[1]].name == "ham"
with pytest.raises(TypeError):
pars[42.3]
with pytest.raises(IndexError):
pars[3]
with pytest.raises(IndexError):
pars["lamb"]
with pytest.raises(ValueError):
pars[Parameter("bam!", 99)]
def __init__(self,
map,
norm=1,
meta=None,
normalize=True,
interp_kwargs=None,
filename=None):
if (map.data < 0).any():
log.warning("Diffuse map has negative values. Check and fix this!")
self.map = map
if normalize:
self.normalize()
self.norm = Parameter("norm", norm)
self.meta = dict() if meta is None else meta
interp_kwargs = {} if interp_kwargs is None else interp_kwargs
interp_kwargs.setdefault("interp", "linear")
interp_kwargs.setdefault("fill_value", 0)
self._interp_kwargs = interp_kwargs
self.filename = filename
super().__init__([self.norm])
def __init__(self, value=1):
self.value = Parameter("value", value)
super().__init__([self.value])
def pars():
x = Parameter("x", 2.1)
y = Parameter("y", 3.1, scale=1e5)
z = Parameter("z", 4.1, scale=1e-5)
return Parameters([x, y, z])
def __init__(self, r_s=None, rho_s=1 * u.Unit("GeV / cm3")):
r_s = self.DEFAULT_SCALE_RADIUS if r_s is None else r_s
self.parameters = Parameters([
Parameter("r_s", u.Quantity(r_s)),
Parameter("rho_s", u.Quantity(rho_s))
])
def test_parameter_repr():
par = Parameter("spam", 42, "deg")
assert repr(par).startswith("Parameter(name=")
def __init__(self):
self.parameters = Parameters(
[Parameter("x", 2),
Parameter("y", 3e2),
Parameter("z", 4e-2)])
def test_parameter_to_dict():
par = Parameter("spam", 42, "deg")
d = par.to_dict()
assert isinstance(d["unit"], str)
def test_parameter_autoscale(method, value, factor, scale):
par = Parameter("", value)
par.autoscale()
assert_allclose(par.factor, factor)
assert_allclose(par.scale, scale)
assert isinstance(par.scale, float)
def pars():
return Parameters(
[Parameter("spam", 42, "deg"),
Parameter("ham", 99, "TeV")])
def test_parameters_autoscale():
pars = Parameters([Parameter("", 20)])
pars.autoscale()
assert_allclose(pars[0].factor, 2)
assert_allclose(pars[0].scale, 10)
def __init__(self):
self.parameters = Parameters(
[Parameter("x", 2),
Parameter("y", 3e2),
Parameter("z", 4e-2)])
self.data_shape = (1, )
