Units in Python

The Astropy package includes a powerful framework that allows users to attach units to scalars and arrays, and manipulate/combine these, keeping track of the units.

Astropy has a lot of built-in units. A complete list can be found here.


In [ ]:
import numpy as np

from astropy.table import QTable

from astropy import units as u
from astropy import constants as const

from astropy.units import imperial
imperial.enable()

Note: because we imported the units package as u, you cannot use u as a variable name.

You can use the units by themselves:


In [ ]:
u.m    # The unit of meters

In [ ]:
u.s    # The unit of seconds

In [ ]:
u.m / u.s    # combine them into a composite unit

For any unit you can find all of the built-in units that are equivalent:


In [ ]:
u.m.find_equivalent_units()

The units package is much more useful when you combine it with scalars or arrays to create Quantities


In [ ]:
time_1 = 0.25 * u.s

time_1

In [ ]:
position = np.arange(1,6,1) * u.m    # np.arange(x,y,z) - create an array of numbers between x and y in steps z

position

In [ ]:
velocity = position / time_1

velocity

You can access the number and unit part of the Quantity separately:


In [ ]:
velocity.value

In [ ]:
velocity.unit

At example problem: How long would it take to go 100 km at velocities in velocity?


In [ ]:
distance = 100 * u.km

time_2 = distance / velocity

time_2

Notice that the units are a bit strange. We can simplify this using .decompose()


In [ ]:
time_2.decompose()

Unit conversion is really easy!


In [ ]:
time_2.to(u.h)

In [ ]:
velocity.to(u.cm / u.h)

In [ ]:
velocity.to(imperial.mi / u.h)

In [ ]:
velocity.si                     # quick conversion to SI units

In [ ]:
velocity.cgs                    # quick conversion to CGS units

In [ ]:
density = 3000 * (u.kg / u.m**3)     # From last week's homework

density.to(u.kg / u.km**3)

Units make math with Time easy!


In [ ]:
u.s.find_equivalent_units()

In [ ]:
time_3 = 29 * u.day + 7 * u.h + 56 * u.min + 12 * u.s
time_4 = 2 * u.fortnight + 1.33 * u.day

In [ ]:
time_3 - time_4

In [ ]:
(time_3 - time_4).to(u.min)

You can define your own units


In [ ]:
ringo = u.def_unit('Ringos', 3.712 * imperial.yd)

In [ ]:
position.to(ringo)

In [ ]:
velocity.to(ringo / u.s)

Dimentionless Units


In [ ]:
dimless_y = (1 * u.m) / (1 * u.km)

dimless_y

In [ ]:
dimless_y.unit

In [ ]:
dimless_y.decompose()   # returns the scale of the dimentionless quanity

Some math functions only make sense with dimentionless quanities


In [ ]:
np.log(2 * u.m)

In [ ]:
np.log((2 * u.km) / (1 * u.m))

In [ ]:
np.log10((2 * u.km) / (1 * u.m))

Or they expect the correct type of unit!


In [ ]:
np.sin(2 * u.m)

In [ ]:
np.sin(2 * u.deg)

Using units can save you headaches.

  • All of the trig functions expect all angles to be in radians.
  • If you forget this, it can lead to problems that are hard to debug

In [ ]:
np.sin(90)               # not really what I expected

In [ ]:
np.sin(90 * u.deg)       # better

Tables and units

Astropy tables are constructed to use units


In [ ]:
planet_table = QTable.read('Planets.csv', format='ascii.csv')

In [ ]:
planet_table[0:3]

In [ ]:
planet_table['a'].unit = u.AU
planet_table[0:3]

In [ ]:
planet_table['a'].to(u.km)

In [ ]:
planet_table['a'].to(u.km)[2]

Constants

The Astropy package also includes a whole bunch of built-in constants to make your life easier.

A complete list of the built-in constants can be found here.


In [ ]:
const.G

In [ ]:
const.M_sun

An Example: The velocity of an object in circular orbit around the Sun is

$$ v=\sqrt{GM_{\odot}\over d} $$

In [ ]:
distance = planet_table['a'][0:3]  # Mercury, Venus, Earth

In [ ]:
orbit_v = np.sqrt(const.G * const.M_sun / distance)

orbit_v

In [ ]:
orbit_v.decompose()

In [ ]:
orbit_v.to(u.km/u.s)

In [ ]:
orbit_v.to(ringo/u.ms)

Functions and Units - (Last week's homework)


In [ ]:
def find_diameter(H,A):
    result = (1329 / np.sqrt(A)) * (10 ** (-0.2 * H))
    return result * u.km

In [ ]:
H = 3.34
A = 0.09

asteroid_diameter = find_diameter(H,A)
asteroid_diameter

In [ ]:
def find_mass(D):
    p = 3000 * (u.kg / u.m**3)
    result = p * (1/6) * np.pi * D**3
    return result

In [ ]:
asteroid_mass = find_mass(asteroid_diameter)
asteroid_mass

In [ ]:
asteroid_mass.decompose()

In [ ]:
moon_mass = u.def_unit('Lunar\ Masses', 7.34767309e22 * u.kg)

In [ ]:
asteroid_mass.to(moon_mass)

In [ ]: