GD1Koposov10#
- class gala.coordinates.GD1Koposov10(*args, **kwargs)[source]#
Bases:
BaseCoordinateFrame
A Heliocentric spherical coordinate system defined by the orbit of the GD1 stream, as described in Koposov et al. 2010 (see: http://arxiv.org/abs/0907.1085).
For more information about this class, see the Astropy documentation on coordinate frames in
coordinates
.- Parameters:
- representation
BaseRepresentation
orNone
A representation object or None to have no data (or use the other keywords)
- phi1
angle_like
, optional,must
be
keyword
The longitude-like angle corresponding to GD-1’s orbit.
- phi2
angle_like
, optional,must
be
keyword
The latitude-like angle corresponding to GD-1’s orbit.
- distance
Quantity
, optional,must
be
keyword
The Distance for this object along the line-of-sight.
- pm_phi1_cosphi2
Quantity
, optional,must
be
keyword
The proper motion in the longitude-like direction corresponding to the GD-1 stream’s orbit.
- pm_phi2
Quantity
, optional,must
be
keyword
The proper motion in the latitude-like direction perpendicular to the GD-1 stream’s orbit.
- radial_velocity
Quantity
, optional,must
be
keyword
The Distance for this object along the line-of-sight.
- representation
Attributes Summary
Return an instance with the data transposed.
Cache for this frame, a dict.
Shorthand for a cartesian representation of the coordinates in this object.
Shorthand for a cylindrical representation of the coordinates in this object.
The coordinate data for this object.
Default representation for differential data (e.g., velocity)
Default representation for position data
The differential used for this frame's data.
Mapping for frame-specific component names
True if this frame has
data
, False otherwise.The number of dimensions of the instance and underlying arrays.
Shorthand for the two-dimensional proper motion as a
Quantity
object with angular velocity units.Shorthand for the radial or line-of-sight velocity as a
Quantity
object.A dictionary with the information of what attribute names for this frame apply to particular representations.
The representation class used for this frame's data.
The shape of the underlying data.
The size of the object, as calculated from its shape.
Shorthand for a spherical representation of the coordinates in this object.
Shorthand for a spherical representation of the positional data and a
SphericalCosLatDifferential
for the velocity data in this object.Shorthand for retrieving the Cartesian space-motion as a
CartesianDifferential
object.Methods Summary
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.
Return a dict with the defaults for each frame attribute.
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 Documentation
- T#
Return an instance with the data transposed.
Parameters are as for
T
. All internal data are views of the data of the original.
- 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()
- 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. If this frame has no data, an
ValueError
will be raised. Usehas_data
to check if data is present on this frame 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.
This will be a subclass from
BaseDifferential
. For simultaneous setting of representation and differentials, see theset_representation_cls
method.
- frame_attributes = {}#
- frame_specific_representation_info#
Mapping for frame-specific component names
- isscalar#
- name = 'gd1koposov10'#
- ndim#
The number of dimensions of the instance and underlying arrays.
- proper_motion#
Shorthand for the two-dimensional proper motion as a
Quantity
object with angular velocity units. In the returnedQuantity
,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.
- 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.
This will be a subclass from
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 theset_representation_cls
method.
- shape#
- size#
- spherical#
Shorthand for a spherical representation of the coordinates in this object.
- sphericalcoslat#
Shorthand for a spherical representation of the positional data and a
SphericalCosLatDifferential
for the velocity data in this object.
- velocity#
Shorthand for retrieving the Cartesian space-motion as a
CartesianDifferential
object.This is equivalent to calling
self.cartesian.differentials['s']
.
Methods Documentation
- copy(*args, **kwargs)#
Return an instance containing copies of the internal data.
Parameters are as for
copy()
.
- 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.
- flatten(*args, **kwargs)#
Return a copy with the array collapsed into one dimension.
Parameters are as for
flatten()
.
- 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:
- Returns:
- representation
BaseRepresentation
orBaseDifferential
.
- representation
- get_representation_component_names(which='base')#
- get_representation_component_units(which='base')#
- 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
- other
- Returns:
- isequivbool
True if the frames are the same, False if not.
- Raises:
TypeError
If
other
isn’t aBaseCoordinateFrame
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.
- is_transformable_to(new_frame)#
Determines if this coordinate frame can be transformed to another given frame.
- Parameters:
- new_frame
BaseCoordinateFrame
subclass or instance The proposed frame to transform into.
- new_frame
- Returns:
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 ascoord
. 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.
- position_angle(other: BaseCoordinateFrame | SkyCoord) Angle #
Compute the on-sky position angle to another coordinate.
- Parameters:
- other
BaseCoordinateFrame
orSkyCoord
The other coordinate to compute the position angle to. It is treated as the “head” of the vector of the position angle.
- other
- Returns:
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
- 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
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.
- data
- Returns:
- frameobj
BaseCoordinateFrame
subclass instance A new object in this frame, with the same frame attributes as this one, but with the
data
as the coordinate data.
- frameobj
- 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 toTrue
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 setcopy
toTrue
.- Parameters:
- copybool, 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
BaseCoordinateFrame
subclass instance Replica of this object, but possibly with new frame attributes.
- frameobj
- 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:
- copybool, 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
BaseCoordinateFrame
subclass instance Replica of this object, but without data and possibly with new frame attributes.
- frameobj
- represent_as(base, s='base', in_frame_units=False)[source]#
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 theset_representation_cls
method to also set the differential.- Parameters:
- basesubclass of
BaseRepresentation
orstr
The type of representation to generate. Must be a class (not an instance), or the string name of the representation class.
- ssubclass of
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_unitsbool, keyword-only
Force the representation units to match the specified units particular to this frame
- basesubclass of
- Returns:
- 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.)>
- 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 (seereshape()
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 usingNDArrayShapeMethods
).
- 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/matchsep.
- Parameters:
- other
BaseCoordinateFrame
orSkyCoord
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 thenself.separation(other)
can be different fromother.separation(self)
. Withorigin_mismatch="warn"
(default) the transformation is always performed, but a warning is emitted if it is not a pure rotation. Iforigin_mismatch="ignore"
then the required transformation is always performed without warnings. Iforigin_mismatch="error"
then only transformations that are pure rotations are allowed.
- other
- Returns:
- sep
Angle
The on-sky separation between this and the
other
coordinate.
- sep
Notes
The separation is calculated using the Vincenty formula, which is stable at all locations, including poles and antipodes [1].
- 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/matchsep.
- Parameters:
- other
BaseCoordinateFrame
orSkyCoord
The coordinate system to get the distance to.
- other
- Returns:
- sep
Distance
The real-space distance between these two coordinates.
- sep
- 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
,BaseRepresentation
subclass, optional The name or subclass to use to represent the coordinate data.
- s
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.
- base
- 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.
- transform_to(new_frame)#
Transform this object’s coordinate data to a new frame.
- Parameters:
- new_framecoordinate-like
The frame to transform this coordinate frame into.
- Returns:
- transframecoordinate-like
A new object with the coordinate data represented in the
newframe
system.
- 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.