Tutorial_13/Space_Time_Coordinates.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Coordinates and Time\n",
    "The concept of coordinates and time is hopefully not alien (get it?) to you; however, astronomy being the precise field that it is, there are several time and coordinate systems in use, with slight variations between them, which may be important depending on your type of study (if you are studying the timing of the pulses of a pulsar for example, vs. the proper motion of stars in the sky)\n",
    "\n",
    "As we approach the end of the planned series of tutorials, we once again state our main goal: to make you self-sufficient in using Python. Keeping that in mind, we have put in significantly less material than previous tutorials, since we expect you to keep referring to the AstroPy documentation. (also note, AstroPy has several functions and classes, which reflect the many uses that astronomers find for different quantities. So it is practically impossible to cover all of that in one tutorial). So this will only get you started in your AstroPy quest; find out more about the equations and coordinate and time systems used here, and their implementations in AstroPy.!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To begin with let us look at Time. Before you get started on this section, please go through the following webpages to get acquainted with the terms we will use in today's tutorial: [this](http://www.astronomy.ohio-state.edu/~pogge/Ast350/timesys.html), then [this](http://spiff.rit.edu/classes/phys301/lectures/time/time.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from astropy.time import Time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can easily access the time formats available. See also : [AstroPy Documentation](https://docs.astropy.org/en/stable/time/#time-format). \n",
    "These are essentially just the various ways in which we can write the date and time. \n",
    "\n",
    "For example, let us use the date and time 11:27:07 PM on 15th September 2018.\n",
    "\n",
    "We would write this in 'iso' as 2018-09-15 23:27:07 <br>\n",
    "'isot' just replaces the space between the date and time with a 'T': 2018-09-15T23:27:07 <br>\n",
    "However, the dates are also dependent on the type of calendar used. If you use the Julian calendar, or the Gregorian calendar makes a difference in your date representations. This problem is compounded if say, there was a period in time when several countries shifted to the Gregorian calendar, while others were yet to do so. \n",
    "\n",
    "mjd, and jd are more convenient representations, as these are literally counting the days since some specified date. Julian Days are the number of days (can be fractional to account for time) since noon, Jan 1, 4713 BC (note that this date is as per what you would get if you extended the Julian calendar backwards, and not the Gregorian calendar in use today). Due to its large size, see below, a modified version called Modified Julian Days (yes, very creative) is used where the reference is Midnight Nov 17, 1858. Because MJD is defined from midnight, the integer part changes at noon (in UTC, see below for scales), which makes it convenient for astronomers.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Time.FORMATS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If the format is clear, then you don't have to specify it\n",
    "example_time = Time(\"2018-09-15 23:27:07\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"ISO: {example_time}\")\n",
    "print(f\"ISOT: {example_time.isot}\")\n",
    "print(f\"Julian Day (JD): {example_time.jd}\")\n",
    "print(f\"MJD: {example_time.mjd}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can easily find the time between two given date-times. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "time1 = Time(\"2018-09-15 23:27:07\", scale='utc')\n",
    "time2 = Time(\"2020-01-17 18:04:23\", scale='utc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "delta_time = time2-time1\n",
    "delta_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"Time elapsed in seconds is {delta_time.sec}\")\n",
    "print(f\"Time elapsed in days is {delta_time.jd}\")\n",
    "print(f\"Time elapsed is {delta_time.datetime}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we move on to something you might have noticed in the TimeDelta object: scale. \n",
    "\n",
    "Scale is essentially telling us how time passes. We know the value of a second to high precision, however the effects of the Earth's rotation mean that there are leap seconds between the actual time measured with the atomic clock (this is called International Atomic Time (or 'tai')) and the time taking the rotation into account (UTC, and other local times). \n",
    "\n",
    "This is reflected the `scale` argument. The [AstroPy Documentation](https://docs.astropy.org/en/stable/time/#time-scale) gives more details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Time.SCALES"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use UTC for now. However, time differences are always measured in a time scale which does not have Earth's rotation messing it up. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "time_array = np.array([time1, time2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(time_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Time comparisons are supported\n",
    "time_array.max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many more functionalities of the `time` module, but for general use, this should suffice. Moving on to the other 3 indices, i.e. Coordinates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Coordinates\n",
    "3 coordinates are required to specify position. If we use a spherical coordinate system, these will be the distance to the point (or object), and two other angles (similar to the co-latitude and longitude used on Earth, for example). In an equivalent Cartesian System, we only need to know the direction of Z-axis and X-axis and the coordinate system is specified (this correponds to latitude of 90° and longitude of 0° respectively). Then we can play around with angles all we want. \n",
    "\n",
    "We will not consider distance for 3 reasons: Distance measurements deserve another (maybe two) tutorial, it is difficult and it is not necessary to observe the sky."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we start, just as earlier, please have a look at this [link](https://dept.astro.lsa.umich.edu/resources/ugactivities/Labs/coords/) for some insight into these coordinate systems before proceeding. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Horizontal Coordinates\n",
    "This is the natural coordinate system we would think of while observing the sky. The Z-axis is directly overhead, and X-axis points to the North. However by convention, the \"longitude\" called Azimuth is measured N-E-S-W-N. The other coordinate (\"latitude\") is called Altitude and is quite literally the altitude of the object (as an angle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Equatorial Coordinates\n",
    "This is essentially the coordinate system we want to use while stating the position of the object as it accounts for Earth's rotation. Here, the Z-axis is the Earth's North Pole (rotation axis), and X-axis is defined as the point of intersection of the Earth's Equator and its orbital plane (called the Ecliptic). \n",
    "\n",
    "The \"longitude\" called Right Ascension (RA) is directly correlated with time, so it is usually written in HMS (if not decimal degrees). \"Latitude\" is called Declination. (to convert from decimal degrees to hours, divide by 15, i.e. 360 degrees is equal to 24 hours)\n",
    "\n",
    "There are problems however; the Earth's rotation axis changes direction gradually. This leads to a need for specifying when the coordinate system has to be defined. For most modern observations, this is called J2000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import astropy.units as u\n",
    "from astropy.coordinates import SkyCoord"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can define a coordinate as required: (for a more complete list, check out... you guessed it, the [AstroPy Documentation](https://docs.astropy.org/en/stable/coordinates/#getting-started))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coordinate1 = SkyCoord(ra = '12h34m10s', dec = '+19d10m29s')\n",
    "coordinate2 = SkyCoord(ra = 245.88, dec = -19.24, unit='deg')\n",
    "coordinate3 = SkyCoord(ra = 182.3*u.deg, dec = 54.89*u.deg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An earlier tutorial (on Functions) asked you to calculate the distance between galaxies. This would have made it significantly easier to do so. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Separation in angles between coordinates. \n",
    "coordinate1.separation(coordinate2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also get the coordinates of an astronomical object using its name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "whirlpool_coordinates = SkyCoord.from_name(\"M51\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A slightly more complicated example here would be converting between the Equatorial and Horizontal systems; note that this is an example in the AstroPy Documentation. You are encouraged to look it up in preparation for..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Your Assignment...\n",
    "...should you choose to accept it, will be the following:\n",
    "1. Make a scatter plot of the position of the Sun in Horizontal Coordinates throughout the year. You may use the Ephemeris of the Sun from this [link](http://astropixels.com/ephemeris/sun/sun2019.html) (Geocentric Ephemeris for the Sun, Moon and Planets Courtesy of Fred Espenak, www.Astropixels.com). <br>\n",
    "The resulting plot is called an Analemma. Change up the position on Earth (latitude) and do the same calculation. How does changing latitude change the Analemma?\n",
    "2. Choose an object (any that you want) and plot its altitude throughout the night (local night; you will have to add 5 hours 30 minutes to UTC). \n",
    "\n",
    "Use the following coordinates for calculation in part 2:\n",
    "Indian Astronomical Observatory (Hanle, Ladakh)\n",
    "Coordinates: 32.7908° N, 79.0002° E\n",
    "Height above Sea Level: 4500 m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use this opportunity to see if a target you like can be observed from Hanle, which is where the GROWTH-India Telescope is set up. If your target is above 30 degrees in altitude for a significant time period (at least an hour or so), then it is likely we can observe it.\n",
    "\n",
    "You can submit your proposals [here](https://docs.google.com/forms/d/1JEFMmV4YSLcARtiSe_KrZaS8PiNKp7ThSJ9kDZsTqGw/edit) for any targets you want to observe!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}