# Units and Coordinates in sunpy¶

This section of the guide will talk about representing physical units and physical coordinates in sunpy. sunpy makes use of Astropy for both these tasks.

## Units in sunpy¶

All functions in sunpy that accept or return numbers associated with physcial quantities accept and return `Quantity` objects. These objects represent a number (or an array of numbers) and a unit. This means sunpy is always explicit about the units associated with a value. Quantities and units are powerful tools for keeping track of variables with a physical meaning and make it straightforward to convert the same physical quantity into different units.

In this section of the guide we will give a quick introduction to `astropy.units` and then demostrate how to use units with sunpy.

To use units we must first import them from Astropy. To save on typing we usually import units as `u`:

```>>> import astropy.units as u
```

Once we have imported units we can create a quantity by multiplying a number by a unit:

```>>> length = 10 * u.meter
>>> length
<Quantity 10. m>
```

A `Quantity` has both a `.unit` and a `.value` attribute:

```>>> length.value
10.0

>>> length.unit
Unit("m")
```

These `Quantity` objects can also be converted to other units, or unit systems:

```>>> length.to(u.km)
<Quantity 0.01 km>

>>> length.cgs
<Quantity 1000. cm>
```

Probably most usefully, `Quantity` objects will propagate units through arithmetic operations when appropriate:

```>>> distance_start = 10 * u.mm
>>> distance_end = 23 * u.km
>>> length = distance_end - distance_start
>>> length
<Quantity 22.99999 km>

>>> time = 15 * u.minute
>>> speed = length / time
>>> speed
<Quantity 1.53333267 km / min>
```

However, operations which do not make physical sense for the units specified will cause an error:

```>>> length + time
Traceback (most recent call last):
...
astropy.units.core.UnitConversionError: Can only apply 'add' function to quantities with compatible dimensions
```

## Quantities as function arguments¶

An extremely useful addition to the base functionality of Quanitities is the `@u.quantity_input` decorator. This allows you to specify required units for function arguments to ensure that the calculation within that function always make physical sense. For instance, if we defined a function to calculate speed as above, we might want the distance and time as inputs:

```>>> def speed(length, time):
...     return length / time
```

However, this requires that length and time both have the appropriate units. We therefore want to use `quantity_input` to enforce this, here we use function annotations to specify the units.

```>>> @u.quantity_input
... def speed(length: u.m, time: u.s):
...     return length / time
```

Now, when this function is called, if the units of length and time are not convertible to the units specified, an error will be raised stating that the units are incorrect or missing:

```>>> speed(1*u.m, 10*u.m)
Traceback (most recent call last):
...
astropy.units.core.UnitsError: Argument 'time' to function 'speed' must be in units convertible to 's'.

>>> speed(1*u.m, 10)
...
Traceback (most recent call last):
...
TypeError: Argument 'time' to function 'speed' has no 'unit' attribute. ... pass in an astropy Quantity instead.
```

Note that the units of the inputs do not have to be exactly the same as those in the function definition, as long as they can be converted to those units. So for instance, passing in a time in minutes still works even though we specified `time: u.s`:

```>>> speed(1*u.m, 1*u.minute)
<Quantity 1. m / min>
```

This may still not be quite as we want it, since we wanted the input time in seconds but the output is in m/min. We can correct this by defining the function with an additional annotation:

```>>> @u.quantity_input
... def speed(length: u.m, time: u.s) -> u.m/u.s:
...     return length / time
```

This will force the output of the function to be converted to m/s before returning, so that you will always have the same units on the output from this function:

```>>> speed(1*u.m, 1*u.minute)
<Quantity 0.01666667 m / s>
```

## Physical Coordinates in sunpy¶

In much the same way as `units` are used for representing physical quantities, sunpy uses `astropy.coordinates` to represent points in physical space. This applies to both points in 3D space and projected coordinates in images.

The astropy coordinates module is primarily used through the `SkyCoord` class:

```>>> from astropy.coordinates import SkyCoord
```

To enable the use of the solar physics specific frames defined in sunpy we also need to import them:

```>>> from sunpy.coordinates import frames
```

A SkyCoord object to represent a point on the Sun can then be created:

```>>> c = SkyCoord(70*u.deg, -30*u.deg, obstime="2017-08-01",
...              frame=frames.HeliographicStonyhurst)
>>> c
<SkyCoord (HeliographicStonyhurst: obstime=2017-08-01T00:00:00.000, rsun=695700.0 km): (lon, lat) in deg
(70., -30.)>
```

This `SkyCoord` object can then be transformed to any other coordinate frame defined either in Astropy or sunpy, for example:

```>>> c.transform_to(frames.Helioprojective(observer="earth"))
<SkyCoord (Helioprojective: obstime=2017-08-01T00:00:00.000, rsun=695700.0 km, observer=<HeliographicStonyhurst Coordinate for 'earth'>): (Tx, Ty, distance) in (arcsec, arcsec, km)
(769.96270814, -498.89715922, 1.51668773e+08)>
```

It is also possible to convert three dimensional positions to astrophysical frames defined in Astropy, for example `ICRS`.

```>>> c.transform_to('icrs')
<SkyCoord (ICRS): (ra, dec, distance) in (deg, deg, km)
(49.84856512, 0.05394699, 1417743.94689472)>
```

### Observer Location¶

Both `Helioprojective` and `Heliocentric` frames are defined based on the position of the observer. Therefore to transform either of these frames to a different frame the location of the observer must be known. The observer can be specified for a coordinate object using the `observer` argument to `SkyCoord`. For sunpy to calculate the location of Earth or another solar-system body, it must know the time for which the coordinate is valid; this is specified with the `obstime` argument.

Using the observer location it is possible to convert a coordinate as seen by one observer to a coordinate seen by another:

```>>> hpc1 = SkyCoord(0*u.arcsec, 0*u.arcsec, observer="earth",
...                 obstime="2017-07-26",
...                 frame=frames.Helioprojective)

>>> hpc1.transform_to(frames.Helioprojective(observer="venus",
...                                          obstime="2017-07-26"))
<SkyCoord (Helioprojective: obstime=2017-07-26T00:00:00.000, rsun=695700.0 km, observer=<HeliographicStonyhurst Coordinate for 'venus'>): (Tx, Ty, distance) in (arcsec, arcsec, AU)
(-1285.47497992, 106.20918654, 0.72405937)>
```

### Using Coordinates with sunpy Map¶

sunpy Map uses coordinates to specify locations on the image, and to plot overlays on plots of maps. When a Map is created, a coordinate frame is constructed from the header information. This can be accessed using `.coordinate_frame`:

```>>> import sunpy.map
>>> from sunpy.data.sample import AIA_171_IMAGE
>>> m = sunpy.map.Map(AIA_171_IMAGE)
>>> m.coordinate_frame
<Helioprojective Frame (obstime=2011-06-07T06:33:02.770, rsun=696000.0 km, observer=<HeliographicStonyhurst Coordinate (obstime=2011-06-07T06:33:02.770, rsun=696000.0 km): (lon, lat, radius) in (deg, deg, m)
(-0.00406308, 0.04787238, 1.51846026e+11)>)>
```

This can be used when creating a `SkyCoord` object to set the coordinate system to that image:

```>>> from astropy.coordinates import SkyCoord
>>> import astropy.units as u
>>> c = SkyCoord(100 * u.arcsec, 10*u.arcsec, frame=m.coordinate_frame)
>>> c
<SkyCoord (Helioprojective: obstime=2011-06-07T06:33:02.770, rsun=696000.0 km, observer=<HeliographicStonyhurst Coordinate (obstime=2011-06-07T06:33:02.770, rsun=696000.0 km): (lon, lat, radius) in (deg, deg, m)
(-0.00406308, 0.04787238, 1.51846026e+11)>): (Tx, Ty) in arcsec
(100., 10.)>
```

The `SkyCoord` object can be converted to a PixelPair object using `world_to_pixel`:

```>>> pixel_obj = m.world_to_pixel(c)
>>> pixel_obj
PixelPair(x=<Quantity 551.7680511 pix>, y=<Quantity 515.18266871 pix>)
```

This `SkyCoord` object could also be used to plot a point on top of the map:

```>>> import matplotlib.pyplot as plt
>>> ax = plt.subplot(projection=m)
>>> m.plot()
<matplotlib.image.AxesImage object at ...>
>>> _ = ax.plot_coord(c, 'o')
```

For more information on coordinates see Coordinates (sunpy.coordinates) section of the API Reference.