# Coordinates

### From AstroBaki

### [edit] Short Topical Videos

### [edit] References

- Euler Angles (Wikipedia)
- Classical Mechanics (Goldstein), see section 4.4 (pg. 150), starting with Euler angles

## Contents |

# SPHERICAL/ASTRONOMICAL COORDINATE TRANSFORMATION

Carl Heiles

In our never-ending attempt to make your life easier, we present you with the quickest of quick summaries of spherical coordinate transformation with matrix techniques. For example, you might need to point the telescope at some particular position in the Galaxy. In other words, you need to convert from Galactic coordinates to altitude and azimuth. This involves three separate coordinate transformations: Galactic longitude and latitude to equatorial right ascension and declination []; to hour angle and declination []; to azimuth and altitude []. Or maybe you need to go all or partway in the the other direction, i.e. [] or maybe just [].

These are conversions among four spherical coordinate systems. Such conversions involve all those complicated combinations of trig functions (sigh). You can write down all these trig functions for the various possible transformation—twelve possibilities in all if you include going both directions.

But there is a much easier, more elegant, and more politically correct way: 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.

There are two big advantages with this method. First, you can apply several transformations in succession by multiplying the rotation matrices in succession, so you break the process down into single transformations, each with its own rotation matrix. Second, it’s easy to go “backwards”—you just use the inverse of the matrix.

The method is *general* and can be applied to *any* coordinate transformation. Spherical coordinates are characterized by two angles. One “goes around the *z*-axis”—it is like longitude on the earth. The other “goes up and down” and is like latitude on the earth. These angles are “longitude-like” and “latitude-like”, and we’ll denote them by *l**o**n**g* and *l**a**t*. Thus, for Galactic coordinates, is the “longitude-like” *l**o**n**g* and *b* is the “latitude-like” *l**a**t*; for equatorial coordinates, it’s α (or *h**a*) and δ; for terrestrial coordinates, it’s *a**z* and *a**l**t*.

One more thing before we get into details. Our discussion is oriented towards astronomy, but the method works for any type of spherical coordinate transformation. There is an excellent, short discussion of the general situation in Goldstein’s *Classical Mechanics*, §4.4.

## 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: SPECIFICS FOR OUR PROBLEM

OK, what are these rotation matrices? We’ll do you a big favor and tell you.

### 2.1 (RA, DEC) to (HA, DEC)—any epoch.

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.

This is from Green’s *Spherical Astronomy*, chapter 14.6, problem 14.6 (answers in back of book). We should’ve made you derive this, but we’re softies. You *really should* at least *glance* at Green’s chapter 2.7, which defines Galactic coordinates. 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 A CRUCIAL PRELIMINARY: 2-D arrays

In a computer, a multidimensional data set can be indexed in two ways, the *column-major* and *row-major* formats. IDL and Fortran use the row-major format; C and Python use column-major. Suppose you have a matrix called *A*. In IDL’s row-major format, when you type [*print, A*] IDL prints

which is different from what you are used to seeing in standard matrix notation (and Python and C) which is the column-major format

Thank goodness we are using Python! Why does IDL do this nonstandard thing? It’s because it’s more straightforward for image processing, in which traditionally the images are scanned row-by-row (as in a TV set) instead of column-by-column. And IDL’s origins are image processing, not matrix math.

### 3.2 Try the following 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 .