def __array_ufunc__(self, function, method, *inputs, **kwargs):
# TODO: it would be more logical to have this in Quantity already,
# instead of in UFUNC_HELPERS, where it cannot be overridden.
# And really it should just return NotImplemented, since possibly
# another argument might know what to do.
if function not in self._supported_ufuncs:
raise UnitTypeError(
"Cannot use ufunc '{0}' with function quantities".format(
function.__name__))
return super().__array_ufunc__(function, method, *inputs, **kwargs)
def _set_unit(self, unit):
if not isinstance(unit, self._unit_class):
# Have to take care of, e.g., (10*u.mag).view(u.Magnitude)
try:
# "or 'nonsense'" ensures `None` breaks, just in case.
unit = self._unit_class(function_unit=unit or 'nonsense')
except Exception:
raise UnitTypeError(
"{0} instances require {1} function units".format(
type(self).__name__, self._unit_class.__name__) +
", so cannot set it to '{0}'.".format(unit))
self._unit = unit
def __rtruediv__(self, other):
if self.unit.physical_unit == dimensionless_unscaled:
return self._function_view.__rdiv__(other)
raise UnitTypeError("Cannot divide function quantities which "
"are not dimensionless into anything.")
def __mul__(self, other):
if self.unit.physical_unit == dimensionless_unscaled:
return self._function_view * other
raise UnitTypeError("Cannot multiply function quantities which "
"are not dimensionless with anything.")
def check_param_values(model, **user_param):
"""Performs generic check that the requested model parameters have valid values and units for the requested
SNEWPY model.
Parameters
----------
model : snewpy.model.SupernovaModel
Model class used to perform parameter check
user_param : varies
User-requested model parameters to be tested for validity. MUST be provided as keyword arguments that match the
model `param` class member
Raises
------
ValueError
If invalid model parameters are provided based on units, allowed values, etc.
UnitTypeError
If invalid units are provided for a model parameter
See Also
--------
snewpy.models.ccsn
snewpy.models.presn
"""
model_param = model.param
# Check that the appropriate number of params are provided
if len(user_param) != len(model_param):
raise ValueError(
f"Invalid model parameters, expected {len(model_param)} "
f"but {len(user_param)} were given")
# Check that user-requested params have valid units and values
for (key, allowed_params), user_param in zip(model_param.items(),
user_param.values()):
# If both have units, check that the user param value is valid. If valid, continue. Else, error
if type(user_param) == Quantity and type(allowed_params) == Quantity:
if get_physical_type(user_param.unit) != get_physical_type(
allowed_params.unit):
raise UnitTypeError(
f"Incorrect units {user_param.unit} provided for parameter {key}, "
f"expected {allowed_params.unit}")
elif user_param.to(
allowed_params.unit).value in allowed_params.value:
continue
else:
raise ValueError(
f"Invalid value '{user_param}' provided for parameter {key}, "
f"allowed value(s): {allowed_params}")
# If one only one has units, then error
elif (type(user_param) == Quantity) ^ (type(allowed_params)
== Quantity):
# User param has units, model param is unitless
if type(user_param) == Quantity:
raise ValueError(
f"Invalid units {user_param.unit} for parameter {key} provided, expected None"
)
else:
raise ValueError(
f"Missing units for parameter {key}, expected {allowed_params.unit}"
)
# Check that unitless user param value is valid. If valid, continue. Else, Error
elif user_param in allowed_params:
continue
else:
raise ValueError(
f"Invalid value '{user_param}' provided for parameter {key}, "
f"allowed value(s): {allowed_params}")
