poliastro.frames.ecliptic
¶
Module Contents¶
Classes¶
This system has its X axis towards the Sun and its Z axis perpendicular to |
Attributes¶
- poliastro.frames.ecliptic.GeocentricMeanEcliptic¶
- poliastro.frames.ecliptic.HeliocentricEclipticJ2000¶
- class poliastro.frames.ecliptic.GeocentricSolarEcliptic(*args, copy=True, representation_type=None, differential_type=None, **kwargs)¶
Bases:
astropy.coordinates.BaseEclipticFrame
This system has its X axis towards the Sun and its Z axis perpendicular to the plane of the Earth’s orbit around the Sun (positive North). This system is fixed with respect to the Earth-Sun line. It is convenient for specifying magnetospheric boundaries. It has also been widely adopted as the system for representing vector quantities in space physics databases.
- 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 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 has_data¶
True if this frame has data, False otherwise.
- property shape¶
The shape of the underlying data.
- property size¶
The size of the object, as calculated from its shape.
- property isscalar¶
- 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.
- property representation_info¶
A dictionary with the information of what attribute names for this frame apply to particular representations.
- property cartesian¶
Shorthand for a cartesian representation of the coordinates in this object.
- property cylindrical¶
Shorthand for a cylindrical representation of the coordinates in this object.
- 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.
- property velocity¶
Shorthand for retrieving the Cartesian space-motion as a ~astropy.coordinates.CartesianDifferential object.
This is equivalent to calling
self.cartesian.differentials['s']
.
- 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.
- property ndim¶
The number of dimensions of the instance and underlying arrays.
- 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.
- obstime¶
- default_representation¶
- default_differential¶
- frame_specific_representation_info¶
- frame_attributes¶
- representation_type¶
- representation_component_names¶
- representation_component_units¶
- classmethod __init_subclass__(**kwargs)¶
- __len__()¶
- __bool__()¶
Any instance should evaluate to True, except when it is empty.
- classmethod get_frame_attr_defaults()¶
Return a dict with the defaults for each frame attribute
- classmethod get_frame_attr_names()¶
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.
- 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.
- get_representation_component_names(which='base')¶
- get_representation_component_units(which='base')¶
- 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 setcopy
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
- 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
- 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 theset_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.)>
- transform_to(new_frame)¶
Transform this object’s coordinate data to a new frame.
- Parameters
new_frame (coordinate-like or ~astropy.coordinates.BaseCoordinateFrame subclass instance) – The frame to transform this coordinate frame into. The frame class option is deprecated.
- 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.
- 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’ ifnew_frame
is the same system as this object but no transformation is defined.- Return type
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.
- 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_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
- Raises
TypeError – If
other
isn’t a ~astropy.coordinates.BaseCoordinateFrame or subclass.
- __repr__()¶
Return repr(self).
- __setitem__(item, value)¶
- __dir__()¶
Override the builtin dir behavior to include representation names.
TODO: dynamic representation transforms (i.e. include cylindrical et al.).
- __getattr__(attr)¶
Allow access to attributes on the representation and differential as found via
self.get_representation_component_names
.TODO: We should handle dynamic representation transforms here (e.g., .cylindrical) instead of defining properties as below.
- __setattr__(attr, value)¶
Implement setattr(self, name, value).
- __eq__(value)¶
Equality operator for frame.
This implements strict equality and requires that the frames are equivalent and that the representation data are exactly equal.
- __ne__(value)¶
Return self!=value.
- separation(other)¶
Computes on-sky separation between this coordinate and another.
Note
If the
other
coordinate object is in a different frame, it is first transformed to the frame of this object. This can lead to unintuitive behavior if not accounted for. Particularly of note is thatself.separation(other)
andother.separation(self)
may not give the same answer in this case.- Parameters
other (~astropy.coordinates.BaseCoordinateFrame) – The coordinate to get the separation to.
- 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.
- separation_3d(other)¶
Computes three dimensional separation between this coordinate and another.
- Parameters
other (~astropy.coordinates.BaseCoordinateFrame) – 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.
- __getitem__(item)¶
- __iter__()¶
- __array_function__(function, types, args, kwargs)¶
Wrap numpy functions that make sense.
- copy(*args, **kwargs)¶
Return an instance containing copies of the internal data.
Parameters are as for
copy()
.
- 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
).
- 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.
- flatten(*args, **kwargs)¶
Return a copy with the array collapsed into one dimension.
Parameters are as for
flatten()
.
- 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.
- 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.
- 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.