# Coordinates

### From AstroBaki

### [edit] Short Topical Videos

### [edit] References

- Spherical/Astronomical Coordinate Transformation
- Euler Angles (Wikipedia)
- Classical Mechanics (Goldstein), see section 4.4 (pg. 150), starting with Euler angles

## Contents |

# Spherical or Astronomical Coordinate Transformation

Converting from Galactic coordinates to altitude and azimuth involves three separate coordinate transformations: Galactic longitude and latitude to equatorial right ascension and declination [(*l*, *b*) (α, δ)]; to hour angle and declination [(α, δ) (*h**a*, δ)]; to azimuth and altitude [(*h**a*, δ) (*a**z*, *a**l**t*)].

It is possible (and recommended) to implement these coordinate transformations using *rotation matrices*. In this method, you generate a vector in the original coordinate system; convert the vector to another coordinate system by rotating the coordinates using matrix multiplication; and convert the vector to the angles of the new coordinate system. The method is *general* and can be applied to *any* coordinate transformation.

## 1 Rotation Matrices: The Method

To restate the problem: we start with (*l**o**n**g*, *l**a**t*) in one coordinate system and want to convert to (, ) in some other coordinate system. Here’s the prescription:

*Step 1.* First, convert the angles to rectangular coordinates. One would usually call these (*x*, *y*, *z*); here, to emphasize the vector/matrix flavor, we call them (*x*_{0}, *x*_{1}, *x*_{2}) and denote the 3-element vector . To accomplish this conversion in Python:

x = numpy.array([0.,0,0]) x[0] = numpy.cos(lat) * numpy.cos(long) x[1] = numpy.cos(lat) * numpy.sin(long) x[2] = nump.sin(lat)

*Step 2.* Apply the rotation matrix *R* (we’ll discuss its definitions below):

In Python, we’ll use numpy arrays to represent and , and you do matrix multiplication with numpy.dot:

xp = numpy.dot(R, x)

*Step 3.* Convert the primed rectangular coordinates to the new set of spherical coordinates :

To do these in Python, where we’ll write **longp, latp**:

longp = numpy.arctan2(xp[1], xp[0]) latp = numpy.arcsin(xp[2])

That’s it! If you want to “go backwards”, you just apply the matrix multiplications using the inverse matrices. For rotation matrices, the inverse is always equal to the transpose(!)If you don’t believe this, check on the *R*’s below in §2!—symbolically for the matrix *R*, *R*^{ − 1} = *R*^{T}. So to go from the primed system to the unprimed, you switch the primed and unprimed in equation (2) and use the inverse rotation matrix

and in Python

iR = numpy.linalg.inv(R) x = numpy.dot(iR, xp)

## 2 Rotation Matrices: Specific for our Problem

### 2.1 (Ra, Dec) to (Ha, Dec)

Converting from keeps the declination the same and uses the relationship *h**a* = *L**S**T* − α. It is easiest to think of this in two steps, so we express

First, we rotate around the equatorial pole by an angle equal to the Local Sidereal Time (*L**S**T*), which does :

Next, the *h**a* and α go in opposite directions, which is equivalent to converting from the original left-handed to a right-handed coordinate system, so the second step is just to perform this reversal:

The full rotation matrix is the matrix product . *Note the order!* Applying at the *beginning* in the matrix product means that it operates *last* on the vector , which is what we want. So we have as the product

### 2.2 (Ha,Dec) to (Azimuth, Altitude)

Because (*h**a*,δ) are Earth-based coordinates, this conversion depends only on your terrestrial latitude φ:

### 2.3 Equatorial to Galactic

In truth, the precession of the equatorial coordinate system makes this matrix a function of time: the equatorial coordinates move around the sky, but the Galactic ones do not. Precession amounts to nearly an arcminute per year! In principle, you should derive the matrix for the current epoch. In practice, you may not need such high accuracy. Better than the 1950 version are the numbers for epoch 2000, which are in Green’s equation (14.55); epoch 2000 is lots closer to the present than is epoch 1950:

### 2.4 Precession—converting equatorial between epochs.

We won’t need these for the lab course, but we give you the info for the sake of completeness. Generating the rotation matrix for precession is a bit tedious and we won’t give the explicit formulae here. They are in Green’s book. The elements of the matrix are in equation (9.31). These elements contain angles, which depend on time as in equation (9.23) if you are converting from epoch 2000 to some other epoch. Precession isn’t all there is; for precision exceeding ˜10 you also need to account for nutation of the Earth, which has a random component and is not completely predictable. For the complete story, see Green’s chapter 9 and *The Astronomical Almanac 1998*, pages B39-B43—for interested parties only!

## 3 Doing all this in Python

Obviously, all this stuff is simple in Python/Numpy, which deals easily with matrices. Before beginning, though, a cautionary note about 2-D arrays on computers:

### 3.1 Examples in Python

Test , going both forwards and backwards. For an observatory at latitude , transforms to . Hour angle is usually given in hours using sexagesimal notation: *h**a* = 21^{h}40^{m}12^{s}.) See the PyEphem module for functions that go back and forth between decimal and sexagesimal notations.

Test by making up your own example, using the fact that *h**a* = *L**S**T* − α.

Test for the Crab Nebula. The Crab has 1950 equatorial coordinates and Galactic coordinates .

Finally, put them all together and make sure that works, too. For *all* of these, make sure you know how to go backwards! For example, suppose you want to convert . You need to first apply and then . So the full rotation matrix in this case is

Again, *note the order!* Applying at the *beginning* in the matrix product means that it operates *last* on the vector .