GenericRepresentation¶
- class interpolated_coordinates.utils.generic_representation.GenericRepresentation(*args, differentials=None, **kwargs)[source]¶
Bases:
BaseRepresentation
,GenericRepresentationOrDifferential
Generic representation of a point in a 3D coordinate system.
- Parameters:
- q1, q2, q3
Quantity
or subclass The components of the 3D points. The names are the keys and the subclasses the values of the
attr_classes
attribute.- differentials
dict
,BaseDifferential
, optional Any differential classes that should be associated with this representation. The input must either be a single
BaseDifferential
subclass instance, or a dictionary with keys set to a string representation of the SI unit with which the differential (derivative) is taken. For example, for a velocity differential on a positional representation, the key would be's'
for seconds, indicating that the derivative is a time derivative.- copybool, optional
If
True
(default), arrays will be copied. IfFalse
, arrays will be references, though possibly broadcast to ensure matching shapes.
- q1, q2, q3
Notes
All representation classes should subclass this base representation class, and define an
attr_classes
attribute, anOrderedDict
which maps component names to the class that creates them. They must also define ato_cartesian
method and afrom_cartesian
class method. By default, transformations are done via the cartesian system, but classes that want to define a smarter transformation path can overload therepresent_as
method. If one wants to use an associated differential class, one should also defineunit_vectors
andscale_factors
methods (see those methods for details).Attributes Summary
Return an instance with the data transposed.
A tuple with the in-order names of the coordinate components.
A dictionary of differential class instances.
The number of dimensions of the instance and underlying arrays.
The 'q1' component of the points(s).
The 'q2' component of the points(s).
The 'q3' component of the points(s).
The shape of the instance and underlying arrays.
The size of the object, as calculated from its shape.
Methods Summary
copy
(*args, **kwargs)Return an instance containing copies of the internal data.
cross
(other)Vector cross product of two representations.
diagonal
(*args, **kwargs)Return an instance with the specified diagonals.
dot
(other)Dot product of two representations.
flatten
(*args, **kwargs)Return a copy with the array collapsed into one dimension.
from_cartesian
(other)Create a representation of this class from a supplied Cartesian one.
from_representation
(representation)Create a new instance of this representation from another one.
get_name
()Name of the representation or differential.
mean
(*args, **kwargs)Vector mean.
norm
()Vector norm.
ravel
(*args, **kwargs)Return an instance with the array collapsed into one dimension.
represent_as
(other_class[, differential_class])Convert coordinates to another representation.
reshape
(*args, **kwargs)Returns an instance containing the same data with a new shape.
Scale factors for each component's direction.
squeeze
(*args, **kwargs)Return an instance with single-dimensional shape entries removed.
sum
(*args, **kwargs)Vector sum.
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.
Convert the representation to its Cartesian form.
transform
(matrix)Transform coordinates using a 3x3 matrix in a Cartesian basis.
transpose
(*args, **kwargs)Return an instance with the data transposed.
Cartesian unit vectors in the direction of each component.
with_differentials
(differentials)Create a new representation with the same positions as this representation, but with these new differentials.
Return a copy of the representation without attached differentials.
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.
- attr_classes: ClassVar[dict[str, type]] = {'q1': <class 'astropy.units.quantity.Quantity'>, 'q2': <class 'astropy.units.quantity.Quantity'>, 'q3': <class 'astropy.units.quantity.Quantity'>}¶
- components¶
A tuple with the in-order names of the coordinate components.
- differentials¶
A dictionary of differential class instances.
The keys of this dictionary must be a string representation of the SI unit with which the differential (derivative) is taken. For example, for a velocity differential on a positional representation, the key would be
's'
for seconds, indicating that the derivative is a time derivative.
- info¶
- isscalar¶
- ndim¶
The number of dimensions of the instance and underlying arrays.
- q1¶
The ‘q1’ component of the points(s).
- q2¶
The ‘q2’ component of the points(s).
- q3¶
The ‘q3’ component of the points(s).
- shape¶
The shape of the instance and underlying arrays.
Like
shape
, can be set to a new shape by assigning a tuple. Note that if different instances share some but not all underlying data, setting the shape of one instance can make the other instance unusable. Hence, it is strongly recommended to get new, reshaped instances with thereshape
method.- Raises:
ValueError
If the new shape has the wrong total number of elements.
AttributeError
If the shape of any of the components cannot be changed without the arrays being copied. For these cases, use the
reshape
method (which copies any arrays that cannot be reshaped in-place).
- size¶
The size of the object, as calculated from its shape.
Methods Documentation
- copy(*args, **kwargs)¶
Return an instance containing copies of the internal data.
Parameters are as for
copy()
.
- cross(other)¶
Vector cross product of two representations.
The calculation is done by converting both
self
andother
toCartesianRepresentation
, and converting the result back to the type of representation ofself
.- Parameters:
- other
BaseRepresentation
subclass instance The representation to take the cross product with.
- other
- Returns:
- cross_product
BaseRepresentation
subclass instance With vectors perpendicular to both
self
andother
, in the same type of representation asself
.
- cross_product
- 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.
- dot(other)¶
Dot product of two representations.
The calculation is done by converting both
self
andother
toCartesianRepresentation
.Note that any associated differentials will be dropped during this operation.
- Parameters:
- other
BaseRepresentation
The representation to take the dot product with.
- other
- Returns:
- dot_product
Quantity
The sum of the product of the x, y, and z components of the cartesian representations of
self
andother
.
- dot_product
- flatten(*args, **kwargs)¶
Return a copy with the array collapsed into one dimension.
Parameters are as for
flatten()
.
- abstract classmethod from_cartesian(other)¶
Create a representation of this class from a supplied Cartesian one.
- Parameters:
- other
CartesianRepresentation
The representation to turn into this class
- other
- Returns:
- representation
BaseRepresentation
subclass instance A new representation of this class’s type.
- representation
- classmethod from_representation(representation)¶
Create a new instance of this representation from another one.
- Parameters:
- representation
BaseRepresentation
instance The presentation that should be converted to this class.
- representation
- classmethod get_name()¶
Name of the representation or differential.
In lower case, with any trailing ‘representation’ or ‘differential’ removed. (E.g., ‘spherical’ for
SphericalRepresentation
orSphericalDifferential
.)
- mean(*args, **kwargs)¶
Vector mean.
Averaging is done by converting the representation to cartesian, and taking the mean of the x, y, and z components. The result is converted back to the same representation as the input.
Refer to
mean
for full documentation of the arguments, noting thataxis
is the entry in theshape
of the representation, and that theout
argument cannot be used.- Returns:
- mean
BaseRepresentation
subclass instance Vector mean, in the same representation as that of the input.
- mean
- norm()¶
Vector norm.
The norm is the standard Frobenius norm, i.e., the square root of the sum of the squares of all components with non-angular units.
Note that any associated differentials will be dropped during this operation.
- Returns:
- norm
astropy.units.Quantity
Vector norm, with the same shape as the representation.
- norm
- 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.
- represent_as(other_class, differential_class=None)¶
Convert coordinates to another representation.
If the instance is of the requested class, it is returned unmodified. By default, conversion is done via Cartesian coordinates. Also note that orientation information at the origin is not preserved by conversions through Cartesian coordinates. See the docstring for
to_cartesian()
for an example.- Parameters:
- other_class
BaseRepresentation
subclass The type of representation to turn the coordinates into.
- differential_class
dict
ofBaseDifferential
, optional Classes in which the differentials should be represented. Can be a single class if only a single differential is attached, otherwise it should be a
dict
keyed by the same keys as the differentials.
- other_class
- 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
).
- scale_factors()¶
Scale factors for each component’s direction.
Given unit vectors \(\hat{e}_c\) and scale factors \(f_c\), a change in one component of \(\delta c\) corresponds to a change in representation of \(\delta c \times f_c \times \hat{e}_c\).
- 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.
- sum(*args, **kwargs)¶
Vector sum.
Adding is done by converting the representation to cartesian, and summing the x, y, and z components. The result is converted back to the same representation as the input.
Refer to
sum
for full documentation of the arguments, noting thataxis
is the entry in theshape
of the representation, and that theout
argument cannot be used.- Returns:
- sum
BaseRepresentation
subclass instance Vector sum, in the same representation as that of the input.
- sum
- 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.
- abstract to_cartesian()¶
Convert the representation to its Cartesian form.
Note that any differentials get dropped. Also note that orientation information at the origin is not preserved by conversions through Cartesian coordinates. For example, transforming an angular position defined at distance=0 through cartesian coordinates and back will lose the original angular coordinates:
>>> import astropy.units as u >>> import astropy.coordinates as coord >>> rep = coord.SphericalRepresentation( ... lon=15*u.deg, ... lat=-11*u.deg, ... distance=0*u.pc) >>> rep.to_cartesian().represent_as(coord.SphericalRepresentation) <SphericalRepresentation (lon, lat, distance) in (rad, rad, pc) (0., 0., 0.)>
- Returns:
- cartrepr
CartesianRepresentation
The representation in Cartesian form.
- cartrepr
- transform(matrix)¶
Transform coordinates using a 3x3 matrix in a Cartesian basis.
This returns a new representation and does not modify the original one. Any differentials attached to this representation will also be transformed.
- Parameters:
- matrix(3,3) array_like
A 3x3 (or stack thereof) matrix, such as a rotation matrix.
- 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.
- unit_vectors()¶
Cartesian unit vectors in the direction of each component.
Given unit vectors \(\hat{e}_c\) and scale factors \(f_c\), a change in one component of \(\delta c\) corresponds to a change in representation of \(\delta c \times f_c \times \hat{e}_c\).
- Returns:
- unit_vectors
dict
ofCartesianRepresentation
The keys are the component names.
- unit_vectors
- with_differentials(differentials)¶
Create a new representation with the same positions as this representation, but with these new differentials.
Differential keys that already exist in this object’s differential dict are overwritten.
- Parameters:
- differentialssequence of
BaseDifferential
subclass instance The differentials for the new representation to have.
- differentialssequence of
- Returns:
BaseRepresentation
subclass instanceA copy of this representation, but with the
differentials
as its differentials.
- without_differentials()¶
Return a copy of the representation without attached differentials.
- Returns:
BaseRepresentation
subclass instanceA shallow copy of this representation, without any differentials. If no differentials were present, no copy is made.