def _post_init(self, val, **field_args):
"""Initialize float field"""
if isinstance(val, PositionArray):
if val.cls_name != "PositionArray":
raise exceptions.InitializationError(
f"Argument 'val' cannot be of type '{val.cls_name}', must be of type 'PositionArray' or numpy/list"
)
data = val
else:
try:
system = field_args.pop("system")
except KeyError:
raise exceptions.InitializationError(
f"{self._factory.__name__}() missing 1 required positional argument: 'system'"
) from None
data = self._factory(val, system, **field_args)
# Check that unit is not given, overwrite with system units
if self._unit is not None and self._unit != data.unit():
raise exceptions.InitializationError("Parameter 'unit' should not be specified for positions")
self._unit = data.unit()
# Check that the correct number of observations are given
if len(data) != self.num_obs:
raise ValueError(f"{self.name!r} initialized with {len(data)} values, expected {self.num_obs}")
# Store the data as a PositionArray
self.data = data
def _post_init(self, val, **field_args):
"""Initialize time field"""
if isinstance(val, TimeArray):
data = val
else:
try:
scale = field_args.pop("scale")
except KeyError:
raise exceptions.InitializationError(
f"{self._factory.__name__}() missing 1 required positional argument: 'scale'"
) from None
try:
fmt = field_args.pop("fmt")
except KeyError:
raise exceptions.InitializationError(
f"{self._factory.__name__}() missing 1 required positional argument: 'fmt'"
) from None
data = self._factory(val, scale, fmt, **field_args)
# Check that unit is not given, overwrite with time scale
if self._unit is not None:
raise exceptions.InitializationError(
"Parameter 'unit' should not be specified for times")
self._unit = None
# Check that the correct number of observations are given
if len(data) != self.num_obs:
raise ValueError(
f"{self.name!r} initialized with {len(data)} values, expected {self.num_obs}"
)
# Store the data as a TimeArray
self.data = data
def _post_init(self, val, **field_args):
"""Initialize position delta field"""
if isinstance(val, PosVelDeltaArray):
data = val
else:
try:
system = field_args.pop("system")
except KeyError:
raise exceptions.InitializationError(
f"{self._factory.__name__}() missing 1 required positional argument: 'system'"
) from None
data = self._factory(val, system, **field_args)
# Check that unit is not given, overwrite with system units
if self._unit is not None and self._unit != data.unit():
raise exceptions.InitializationError(
"Parameter 'unit' should not be specified for position and velocity deltas"
)
self._unit = data.unit()
# Check that the correct number of observations are given
if len(data) != self.num_obs:
raise ValueError(
f"{self.name!r} initialized with {len(data)} values, expected {self.num_obs}"
)
# Store the data as a PosVelDeltaArray
self.data = data
def _post_init(self, val, **field_args):
"""Initialize float field"""
if field_args:
raise exceptions.InitializationError(
f"{self._factory.__name__}() received unknown argument {','.join(field_args.keys())}"
)
data = self._factory(val, dtype=bool)
# Check that the correct number of observations are given
if len(data) != self.num_obs:
raise ValueError(
f"{self.name!r} initialized with {len(data)} values, expected {self.num_obs}"
)
# We only support 1- and 2-dimensional arrays
if data.ndim < 1 or data.ndim > 2:
raise ValueError(
f"{self.name!r} initialized with {data.ndim}-dimensional data, "
"only 1- and 2-dimensional values are supported")
# Check that unit is not given
if self._unit is not None:
raise exceptions.InitializationError(
"Parameter 'unit' should not be specified for boolean arrays")
# Store the data as a regular numpy array
self.data = data
def _post_init(self, val, **field_args):
"""Initialize field"""
if field_args:
raise exceptions.InitializationError(f"Unknown input parameter {','.join(field_args.keys())}")
if isinstance(val, Collection):
data = val
else:
data = self._factory()
# Check that unit is not given
if self._unit is not None:
raise exceptions.InitializationError("Parameter 'unit' should not be specified for collections")
# Store the data as a Collection
self.data = data
def _post_init(self, val, **dir_args):
"""Initialize float field"""
if isinstance(val, DirectionArray):
data = val
else:
data = self._factory(val, **dir_args)
# Check that unit is not given, overwrite with direction units
if self._unit is not None and self._unit != data.unit():
raise exceptions.InitializationError(
"Parameter 'unit' should not be specified for directions")
self._unit = data.unit()
# Check that the correct number of observations are given
if len(data) != self.num_obs:
raise ValueError(
f"{self.name!r} initialized with {len(data)} values, expected {self.num_obs}"
)
# Check that the correct number of columns are given
if data.ndim != 2:
raise ValueError(
f"{self.name!r} initialized with {data.ndim} columns, expected 2 (ra, dec)"
)
# Store the data as a TimeArray
self.data = data
def _post_init(self, val, **field_args):
"""Initialize float field"""
if field_args:
raise exceptions.InitializationError(
f"{self._factory.__name__}() received unknown argument {','.join(field_args.keys())}"
)
if isinstance(val, np.ndarray) and val.dtype == self.dtype:
data = val
else:
data = self._factory(val, dtype=self.dtype)
# Check that the correct number of observations are given
if len(data) != self.num_obs:
raise ValueError(
f"{self.name!r} initialized with {len(data)} values, expected {self.num_obs}"
)
# We only support 1- and 2-dimensional arrays
# if data.ndim < 1 or data.ndim > 2:
# raise ValueError(
# f"{self.name!r} initialized with {data.ndim}-dimensional data, "
# "only 1- and 2-dimensional values are supported"
# )
# Handle units
if self._unit is not None:
self._unit = self._validate_unit(data, self._unit)
# Store the data as a regular numpy array
self.data = data
def _post_init(self, val, **field_args):
"""Initialize float field"""
if field_args:
raise exceptions.InitializationError(
f"{self._factory.__name__}() received unknown argument {','.join(field_args.keys())}"
)
data = self._factory(val, dtype=float)
# Check that the correct number of observations are given
if len(data) != self.num_obs:
raise ValueError(
f"{self.name!r} initialized with {len(data)} values, expected {self.num_obs}"
)
# We only support 1- and 2-dimensional arrays
if data.ndim < 1 or data.ndim > 2:
raise ValueError(
f"{self.name!r} initialized with {data.ndim}-dimensional data, "
"only 1- and 2-dimensional values are supported")
# Handle units
if self._unit is not None:
cols = 1 if data.ndim == 1 else data.shape[1]
if isinstance(self._unit, str):
self._unit = (self._unit, ) * cols
elif len(self._unit) != cols:
raise ValueError(
f"Number of units ({len(self._unit)}) must equal number of columns ({cols})"
)
# Store the data as a regular numpy array
self.data = data
def g2t_pos(gcrs: "GcrsPosition", time: "Time" = None) -> "TrsPosition":
"""Transforms input array from gcrs to trs coordinates"""
if time is None:
time = gcrs.time
if time is None:
raise mg_exceptions.InitializationError("Time is not defined")
gcrs = np.asarray(gcrs)[:, :, None]
return (rotation.gcrs2trs(time) @ gcrs)[:, :, 0]
def g2t_vel(gcrs: "GcrsVelocity", time: "Time" = None) -> "TrsVelocity":
"""Transforms input array from gcrs to trs coordinates"""
if time is None:
time = gcrs.time
if time is None:
raise mg_exceptions.InitializationError("Time is not defined")
gcrs = nputil.col(gcrs)
return _matmul(rotation.dgcrs2trs_dt(time), gcrs)
def t2g_pos(trs: "TrsPosition", time: "Time" = None) -> "GcrsPosition":
"""Transforms input array from trs to gcrs coordinates"""
if time is None:
time = trs.time
if time is None:
raise mg_exceptions.InitializationError("Time is not defined")
trs = nputil.col(trs)
return _matmul(rotation.trs2gcrs(time), trs)
def t2g_vel(trs: "TrsVelocity", time: "Time" = None) -> "GcrsVelocity":
"""Transforms input array from trs to gcrs coordinates"""
if time is None:
time = trs.time
if time is None:
raise mg_exceptions.InitializationError("Time is not defined")
trs = np.asarray(trs)[:, :, None]
return (rotation.dtrs2gcrs_dt(time) @ trs)[:, :, 0]
def delta_t2y(trs: "TrsPositionDelta",
time: "Time" = None) -> "YawPositionDelta":
"""Convert position deltas from TRS to YAW"""
if time is None:
time = trs.time
if time is None:
raise mg_exceptions.InitializationError("Time is not defined")
t2y = rotation.trs2yaw(trs.ref_pos, time)
return _matmul(t2y, trs.mat)
def delta_y2t(yaw: "YawPositionDelta",
time: "Time" = None) -> "TrsPositionDelta":
"""Convert position deltas from YAW to TRS"""
if time is None:
time = yaw.time
if time is None:
raise mg_exceptions.InitializationError("Time is not defined")
y2t = rotation.yaw2trs(yaw.ref_pos, time)
return _matmul(y2t, yaw.mat)
def delta_y2t_posvel(yaw: "YawPosVelDelta",
time: "Time" = None) -> "TrsPosVelDelta":
"""Convert position deltas from YAW to TRS"""
if time is None:
time = yaw.time
if time is None:
raise mg_exceptions.InitializationError("Time is not defined")
y2t = rotation.yaw2trs(yaw.ref_pos, time)
# TODO: verify this tranformation
yaw2trs = np.block([[y2t, np.zeros(y2t.shape)], [np.zeros(y2t.shape),
y2t]])
return _matmul(yaw2trs, yaw.mat)
def g2t_posvel(gcrs: "GcrsPosVel", time: "Time" = None) -> "TrsPosVel":
"""Transforms input array from gcrs to trs coordinates"""
if time is None:
time = gcrs.time
if time is None:
raise mg_exceptions.InitializationError("Time is not defined")
gcrs = nputil.col(gcrs)
g2t = rotation.gcrs2trs(time)
dg2t = rotation.dgcrs2trs_dt(time)
transformation = np.block([[g2t, np.zeros(g2t.shape)], [dg2t, g2t]])
return _matmul(transformation, gcrs)
def t2g_posvel(trs: "TrsPosVel", time: "Time" = None) -> "GcrsPosVel":
"""Transforms input array from trs to gcrs coordinates"""
if time is None:
time = trs.time
if time is None:
raise mg_exceptions.InitializationError("Time is not defined")
trs = nputil.col(trs)
t2g = rotation.trs2gcrs(time)
dt2g = rotation.dtrs2gcrs_dt(time)
transformation = np.block([[t2g, np.zeros(t2g.shape)], [dt2g, t2g]])
return _matmul(transformation, trs)
def delta_t2y_posvel(trs: "TrsPosVelDelta",
time: "Time" = None) -> "YawPosVelDelta":
"""Convert position deltas from TRS to YAW"""
if time is None:
time = trs.time
if time is None:
raise mg_exceptions.InitializationError("Time is not defined")
t2y = rotation.trs2yaw(trs.ref_pos, time)
# TODO: verify this tranformation
trs2yaw = np.block([[t2y, np.zeros(t2y.shape)], [np.zeros(t2y.shape),
t2y]])
return _matmul(trs2yaw, trs.mat)
def _post_init(self, val, **field_args):
"""Initialize sigma field"""
if isinstance(val, SigmaArray):
data = val
else:
try:
sigma = field_args.pop("sigma")
except KeyError:
raise exceptions.InitializationError(
f"{self._factory.__name__}() missing 1 required positional argument: 'sigma'"
) from None
if field_args:
raise exceptions.InitializationError(
f"{self._factory.__name__}() received unknown argument {','.join(field_args.keys())}"
)
data = self._factory(val, sigma)
# Check that the correct number of observations are given
if len(data) != self.num_obs:
raise ValueError(
f"{self.name!r} initialized with {len(data)} values, expected {self.num_obs}"
)
# We only support 1- and 2-dimensional arrays
if data.ndim < 1 or data.ndim > 2:
raise ValueError(
f"{self.name!r} initialized with {data.ndim}-dimensional data, "
"only 1- and 2-dimensional values are supported")
# Handle units
if self._unit is not None:
self._unit = self._validate_unit(data, self._unit)
data.set_unit(self._unit)
# Store the data as a SigmaArray
self.data = data
def g2t_posvel(gcrs: "GcrsPosVel", time: "Time" = None) -> "TrsPosVel":
"""Transforms input array from gcrs to trs coordinates"""
if time is None:
time = gcrs.time
if time is None:
raise mg_exceptions.InitializationError("Time is not defined")
gcrs = np.asarray(gcrs)[:, :, None]
g2t = rotation.gcrs2trs(time)
dg2t = rotation.dgcrs2trs_dt(time)
# Form block diagonal matrix with shape (num_obs, 6, 6)
transformation = np.block([[g2t, np.zeros(g2t.shape)],
[np.zeros(dg2t.shape), dg2t]])
return (transformation @ gcrs)[:, :, 0]
def t2g_posvel(trs: "TrsPosVel", time: "Time" = None) -> "GcrsPosVel":
"""Transforms input array from trs to gcrs coordinates"""
if time is None:
time = trs.time
if time is None:
raise mg_exceptions.InitializationError("Time is not defined")
trs = np.asarray(trs)[:, :, None]
t2g = rotation.trs2gcrs(time)
dt2g = rotation.dtrs2gcrs_dt(time)
# Form block diagonal matrix with shape (num_obs, 6, 6)
transformation = np.block([[t2g, np.zeros(t2g.shape)],
[np.zeros(dt2g.shape), dt2g]])
return (transformation @ trs)[:, :, 0]
