rta_reconstruction.utils.coordinates.TelescopeFrame

class rta_reconstruction.utils.coordinates.TelescopeFrame(*args, **kwargs)

Bases: BaseCoordinateFrame

Telescope coordinate frame.

A Frame using a UnitSphericalRepresentation. This is basically the same as a HorizonCoordinate, but the origin is at the telescope’s pointing direction.

This is used to specify coordinates in the field of view of a telescope that is independent of the optical properties of the telescope.

fov_lon is aligned with azimuth and fov_lat is aligned with altitude of the horizontal coordinate frame as implemented in astropy.coordinates.AltAz.

This is what astropy calls a SkyOffsetCoordinate.

telescope_pointing

Coordinate of the telescope pointing in AltAz

Type:

SkyCoord[AltAz]

obstime

Observation time

Type:

Tiem

location

Location of the telescope

Type:

EarthLocation

__init__(*args, **kwargs)

Methods

__init__(*args, **kwargs)
copy(*args, **kwargs)	Return an instance containing copies of the internal data.
diagonal(*args, **kwargs)	Return an instance with the specified diagonals.
flatten(*args, **kwargs)	Return a copy with the array collapsed into one dimension.
get_frame_attr_defaults()	Return a dict with the defaults for each frame attribute.
get_frame_attr_names()
get_representation_cls([which])	The class used for part of this frame's data.
get_representation_component_names([which])
get_representation_component_units([which])
is_equivalent_frame(other)	Checks if this object is the same frame as the other object.
is_frame_attr_default(attrnm)	Determine whether or not a frame attribute has its value because it's the default value, or because this frame was created with that value explicitly requested.
is_transformable_to(new_frame)	Determines if this coordinate frame can be transformed to another given frame.
position_angle(other)	Compute the on-sky position angle to another coordinate.
ravel(*args, **kwargs)	Return an instance with the array collapsed into one dimension.
realize_frame(data, **kwargs)	Generates a new frame with new data from another frame (which may or may not have data).
replicate([copy])	Return a replica of the frame, optionally with new frame attributes.
replicate_without_data([copy])	Return a replica without data, optionally with new frame attributes.
represent_as(base[, s, in_frame_units])	Generate and return a new representation of this frame's data as a Representation object.
reshape(*args, **kwargs)	Returns an instance containing the same data with a new shape.
separation(other, *[, origin_mismatch])	Computes on-sky separation between this coordinate and another.
separation_3d(other)	Computes three dimensional separation between this coordinate and another.
set_representation_cls([base, s])	Set representation and/or differential class for this frame's data.
squeeze(*args, **kwargs)	Return an instance with single-dimensional shape entries removed.
swapaxes(*args, **kwargs)	Return an instance with the given axes interchanged.
take(indices[, axis, out, mode])	Return a new instance formed from the elements at the given indices.
transform_to(new_frame)	Transform this object's coordinate data to a new frame.
transpose(*args, **kwargs)	Return an instance with the data transposed.

Attributes

T	Return an instance with the data transposed.
cache	Cache for this frame, a dict.
cartesian	Shorthand for a cartesian representation of the coordinates in this object.
cylindrical	Shorthand for a cylindrical representation of the coordinates in this object.
data	The coordinate data for this object.
default_differential	Default representation for differential data (e.g., velocity)
default_representation	Default representation for position data
differential_type	The differential used for this frame's data.
frame_attributes
frame_specific_representation_info	Mapping for frame-specific component names
has_data	True if this frame has data, False otherwise.
isscalar
location	A frame attribute
name
ndim	The number of dimensions of the instance and underlying arrays.
obstime	A frame attribute
proper_motion	Shorthand for the two-dimensional proper motion as a ~astropy.units.Quantity object with angular velocity units.
radial_velocity	Shorthand for the radial or line-of-sight velocity as a ~astropy.units.Quantity object.
representation_component_names
representation_component_units
representation_info	A dictionary with the information of what attribute names for this frame apply to particular representations.
representation_type	The representation class used for this frame's data.
shape	The shape of the underlying data.
size	The size of the object, as calculated from its shape.
spherical	Shorthand for a spherical representation of the coordinates in this object.
sphericalcoslat	Shorthand for a spherical representation of the positional data and a ~astropy.coordinates.SphericalCosLatDifferential for the velocity data in this object.
telescope_pointing	A frame attribute
velocity	Shorthand for retrieving the Cartesian space-motion as a ~astropy.coordinates.CartesianDifferential object.

property T

Return an instance with the data transposed.

Parameters are as for T. All internal data are views of the data of the original.

property cache

Cache for this frame, a dict.

It stores anything that should be computed from the coordinate data (not from the frame attributes). This can be used in functions to store anything that might be expensive to compute but might be re-used by some other function. E.g.:

if 'user_data' in myframe.cache:
    data = myframe.cache['user_data']
else:
    myframe.cache['user_data'] = data = expensive_func(myframe.lat)

If in-place modifications are made to the frame data, the cache should be cleared:

myframe.cache.clear()

property cartesian

Shorthand for a cartesian representation of the coordinates in this object.

copy(*args, **kwargs)

Return an instance containing copies of the internal data.

Parameters are as for copy().

property cylindrical

Shorthand for a cylindrical representation of the coordinates in this object.

property data

The coordinate data for this object. If this frame has no data, an ValueError will be raised. Use has_data to check if data is present on this frame object.

property default_differential

Default representation for differential data (e.g., velocity)

property default_representation

Default representation for position data

diagonal(*args, **kwargs)

Return an instance with the specified diagonals.

Parameters are as for diagonal(). All internal data are views of the data of the original.

property differential_type

The differential used for this frame’s data.

This will be a subclass from ~astropy.coordinates.BaseDifferential. For simultaneous setting of representation and differentials, see the set_representation_cls method.

flatten(*args, **kwargs)

Return a copy with the array collapsed into one dimension.

Parameters are as for flatten().

property frame_specific_representation_info

Mapping for frame-specific component names

classmethod get_frame_attr_defaults()

Return a dict with the defaults for each frame attribute.

classmethod get_frame_attr_names()

Deprecated since version 5.2: The get_frame_attr_names() method is deprecated and may be removed in a future version. Use get_frame_attr_defaults() to obtain a dict of frame attribute names and default values. The fastest way to obtain the names is frame_attributes.keys()

Return a dict with the defaults for each frame attribute.

get_representation_cls(which='base')

The class used for part of this frame’s data.

Parameters:

which ((‘base’, ‘s’, None)) – The class of which part to return. ‘base’ means the class used to represent the coordinates; ‘s’ the first derivative to time, i.e., the class representing the proper motion and/or radial velocity. If None, return a dict with both.

Returns:

representation

Return type:

~astropy.coordinates.BaseRepresentation or ~astropy.coordinates.BaseDifferential.

property has_data

True if this frame has data, False otherwise.

is_equivalent_frame(other)

Checks if this object is the same frame as the other object.

To be the same frame, two objects must be the same frame class and have the same frame attributes. Note that it does not matter what, if any, data either object has.

Parameters:

other (BaseCoordinateFrame) – the other frame to check

Returns:

isequiv – True if the frames are the same, False if not.

Return type:

bool

Raises:

TypeError – If other isn’t a ~astropy.coordinates.BaseCoordinateFrame or subclass.

is_frame_attr_default(attrnm)

Determine whether or not a frame attribute has its value because it’s the default value, or because this frame was created with that value explicitly requested.

Parameters:

attrnm (str) – The name of the attribute to check.

Returns:

isdefault – True if the attribute attrnm has its value by default, False if it was specified at creation of this frame.

Return type:

bool

is_transformable_to(new_frame)

Determines if this coordinate frame can be transformed to another given frame.

Parameters:

new_frame (~astropy.coordinates.BaseCoordinateFrame subclass or instance) – The proposed frame to transform into.

Returns:

transformable – True if this can be transformed to new_frame, False if not, or the string ‘same’ if new_frame is the same system as this object but no transformation is defined.

Return type:

bool or str

Notes

A return value of ‘same’ means the transformation will work, but it will just give back a copy of this object. The intended usage is:

if coord.is_transformable_to(some_unknown_frame):
    coord2 = coord.transform_to(some_unknown_frame)

This will work even if some_unknown_frame turns out to be the same frame class as coord. This is intended for cases where the frame is the same regardless of the frame attributes (e.g. ICRS), but be aware that it might also indicate that someone forgot to define the transformation between two objects of the same frame class but with different attributes.

location

A frame attribute

No default value

property ndim

The number of dimensions of the instance and underlying arrays.

obstime

A frame attribute

No default value

position_angle(other: BaseCoordinateFrame | SkyCoord) → Angle

Compute the on-sky position angle to another coordinate.

Parameters:

other (~astropy.coordinates.BaseCoordinateFrame or ~astropy.coordinates.SkyCoord) – The other coordinate to compute the position angle to. It is treated as the “head” of the vector of the position angle.

Returns:

The (positive) position angle of the vector pointing from self to other, measured East from North. If either self or other contain arrays, this will be an array following the appropriate numpy broadcasting rules.

Return type:

~astropy.coordinates.Angle

Examples

>>> from astropy import units as u
>>> from astropy.coordinates import ICRS, SkyCoord
>>> c1 = SkyCoord(0*u.deg, 0*u.deg)
>>> c2 = ICRS(1*u.deg, 0*u.deg)
>>> c1.position_angle(c2).degree
90.0
>>> c2.position_angle(c1).degree
270.0
>>> c3 = SkyCoord(1*u.deg, 1*u.deg)
>>> c1.position_angle(c3).degree  
44.995636455344844

property proper_motion

Shorthand for the two-dimensional proper motion as a ~astropy.units.Quantity object with angular velocity units. In the returned ~astropy.units.Quantity, axis=0 is the longitude/latitude dimension so that .proper_motion[0] is the longitudinal proper motion and .proper_motion[1] is latitudinal. The longitudinal proper motion already includes the cos(latitude) term.

property radial_velocity

Shorthand for the radial or line-of-sight velocity as a ~astropy.units.Quantity object.

ravel(*args, **kwargs)

Return an instance with the array collapsed into one dimension.

Parameters are as for ravel(). Note that it is not always possible to unravel an array without copying the data. If you want an error to be raise if the data is copied, you should should assign shape (-1,) to the shape attribute.

realize_frame(data, **kwargs)

Generates a new frame with new data from another frame (which may or may not have data). Roughly speaking, the converse of replicate_without_data.

Parameters:

• data (~astropy.coordinates.BaseRepresentation) – The representation to use as the data for the new frame.

• **kwargs – Any additional keywords are treated as frame attributes to be set on the new frame object. In particular, representation_type can be specified.

Returns:

frameobj – A new object in this frame, with the same frame attributes as this one, but with the data as the coordinate data.

Return type:

~astropy.coordinates.BaseCoordinateFrame subclass instance

replicate(copy=False, **kwargs)

Return a replica of the frame, optionally with new frame attributes.

The replica is a new frame object that has the same data as this frame object and with frame attributes overridden if they are provided as extra keyword arguments to this method. If copy is set to True then a copy of the internal arrays will be made. Otherwise the replica will use a reference to the original arrays when possible to save memory. The internal arrays are normally not changeable by the user so in most cases it should not be necessary to set copy to True.

Parameters:

• copy (bool, optional) – If True, the resulting object is a copy of the data. When False, references are used where possible. This rule also applies to the frame attributes.

• **kwargs – Any additional keywords are treated as frame attributes to be set on the new frame object.

Returns:

frameobj – Replica of this object, but possibly with new frame attributes.

Return type:

~astropy.coordinates.BaseCoordinateFrame subclass instance

replicate_without_data(copy=False, **kwargs)

Return a replica without data, optionally with new frame attributes.

The replica is a new frame object without data but with the same frame attributes as this object, except where overridden by extra keyword arguments to this method. The copy keyword determines if the frame attributes are truly copied vs being references (which saves memory for cases where frame attributes are large).

This method is essentially the converse of realize_frame.

Parameters:

• copy (bool, optional) – If True, the resulting object has copies of the frame attributes. When False, references are used where possible.

• **kwargs – Any additional keywords are treated as frame attributes to be set on the new frame object.

Returns:

frameobj – Replica of this object, but without data and possibly with new frame attributes.

Return type:

~astropy.coordinates.BaseCoordinateFrame subclass instance

represent_as(base, s='base', in_frame_units=False)

Generate and return a new representation of this frame’s data as a Representation object.

Note: In order to make an in-place change of the representation of a Frame or SkyCoord object, set the representation attribute of that object to the desired new representation, or use the set_representation_cls method to also set the differential.

Parameters:

• base (subclass of BaseRepresentation or string) – The type of representation to generate. Must be a class (not an instance), or the string name of the representation class.

• s (subclass of ~astropy.coordinates.BaseDifferential, str, optional) – Class in which any velocities should be represented. Must be a class (not an instance), or the string name of the differential class. If equal to ‘base’ (default), inferred from the base class. If None, all velocity information is dropped.

• in_frame_units (bool, keyword-only) – Force the representation units to match the specified units particular to this frame

Returns:

newrep – A new representation object of this frame’s data.

Return type:

BaseRepresentation-derived object

Raises:

AttributeError – If this object had no data

Examples

>>> from astropy import units as u
>>> from astropy.coordinates import SkyCoord, CartesianRepresentation
>>> coord = SkyCoord(0*u.deg, 0*u.deg)
>>> coord.represent_as(CartesianRepresentation)  
<CartesianRepresentation (x, y, z) [dimensionless]
        (1., 0., 0.)>

>>> coord.representation_type = CartesianRepresentation
>>> coord  
<SkyCoord (ICRS): (x, y, z) [dimensionless]
    (1., 0., 0.)>

property representation_info

A dictionary with the information of what attribute names for this frame apply to particular representations.

property representation_type

The representation class used for this frame’s data.

This will be a subclass from ~astropy.coordinates.BaseRepresentation. Can also be set using the string name of the representation. If you wish to set an explicit differential class (rather than have it be inferred), use the set_representation_cls method.

reshape(*args, **kwargs)

Returns an instance containing the same data with a new shape.

Parameters are as for reshape(). Note that it is not always possible to change the shape of an array without copying the data (see reshape() documentation). If you want an error to be raise if the data is copied, you should assign the new shape to the shape attribute (note: this may not be implemented for all classes using NDArrayShapeMethods).

separation(other: BaseCoordinateFrame | SkyCoord, *, origin_mismatch: Literal['ignore', 'warn', 'error'] = 'warn') → Angle

Computes on-sky separation between this coordinate and another.

For more on how to use this (and related) functionality, see the examples in astropy-coordinates-separations-matching.

Parameters:

• other (~astropy.coordinates.BaseCoordinateFrame or ~astropy.coordinates.SkyCoord) – The coordinate to get the separation to.

• origin_mismatch ({"warn", "ignore", "error"}, keyword-only) – If the other coordinates are in a different frame then they will have to be transformed, and if the transformation is not a pure rotation then self.separation(other) can be different from other.separation(self). With origin_mismatch="warn" (default) the transformation is always performed, but a warning is emitted if it is not a pure rotation. If origin_mismatch="ignore" then the required transformation is always performed without warnings. If origin_mismatch="error" then only transformations that are pure rotations are allowed.

Returns:

sep – The on-sky separation between this and the other coordinate.

Return type:

~astropy.coordinates.Angle

Notes

The separation is calculated using the Vincenty formula, which is stable at all locations, including poles and antipodes [1].

[1]

https://en.wikipedia.org/wiki/Great-circle_distance

separation_3d(other)

Computes three dimensional separation between this coordinate and another.

For more on how to use this (and related) functionality, see the examples in astropy-coordinates-separations-matching.

Parameters:

other (~astropy.coordinates.BaseCoordinateFrame or ~astropy.coordinates.SkyCoord) – The coordinate system to get the distance to.

Returns:

sep – The real-space distance between these two coordinates.

Return type:

~astropy.coordinates.Distance

Raises:

ValueError – If this or the other coordinate do not have distances.

set_representation_cls(base=None, s='base')

Set representation and/or differential class for this frame’s data.

Parameters:

• base (str, ~astropy.coordinates.BaseRepresentation subclass, optional) – The name or subclass to use to represent the coordinate data.

• s (~astropy.coordinates.BaseDifferential subclass, optional) – The differential subclass to use to represent any velocities, such as proper motion and radial velocity. If equal to ‘base’, which is the default, it will be inferred from the representation. If None, the representation will drop any differentials.

property shape

The shape of the underlying data.

property size

The size of the object, as calculated from its shape.

property spherical

Shorthand for a spherical representation of the coordinates in this object.

property sphericalcoslat

Shorthand for a spherical representation of the positional data and a ~astropy.coordinates.SphericalCosLatDifferential for the velocity data in this object.

squeeze(*args, **kwargs)

Return an instance with single-dimensional shape entries removed.

Parameters are as for squeeze(). All internal data are views of the data of the original.

swapaxes(*args, **kwargs)

Return an instance with the given axes interchanged.

Parameters are as for swapaxes(): axis1, axis2. All internal data are views of the data of the original.

take(indices, axis=None, out=None, mode='raise')

Return a new instance formed from the elements at the given indices.

Parameters are as for take(), except that, obviously, no output array can be given.

telescope_pointing

A frame attribute

No default value

transform_to(new_frame)

Transform this object’s coordinate data to a new frame.

Parameters:

new_frame (coordinate-like) – The frame to transform this coordinate frame into.

Returns:

transframe – A new object with the coordinate data represented in the newframe system.

Return type:

coordinate-like

Raises:

ValueError – If there is no possible transformation route.

transpose(*args, **kwargs)

Return an instance with the data transposed.

Parameters are as for transpose(). All internal data are views of the data of the original.

property velocity

Shorthand for retrieving the Cartesian space-motion as a ~astropy.coordinates.CartesianDifferential object.

This is equivalent to calling self.cartesian.differentials['s'].