├── .gitignore ├── 01 - Preparing To Dive Into Astropy.ipynb ├── 02 - FITS Files.ipynb ├── 03 - World Coordinate Systems.ipynb ├── 04 - Data Modeling.ipynb ├── 05 - Cosmology.ipynb ├── README.md └── data ├── example.fits └── example2.fits /.gitignore: -------------------------------------------------------------------------------- 1 | *.pyc 2 | .ipynb_checkpoints/ 3 | *.swp 4 | myFile*.fits 5 | -------------------------------------------------------------------------------- /01 - Preparing To Dive Into Astropy.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Preparing to Dive Into Astropy\n", 8 | "\n", 9 | "__Author: Kaustubh Vaghmare__" 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "## What is Astropy?\n", 17 | "\n", 18 | "Astropy is a third party Python module designed to be like a swiss army knife for common programming needs of Astronomers. Since it is a third party package, it needs to be installed.\n", 19 | "\n", 20 | "If you are using the full Anaconda distribution of Python, it is already available. If you are using an alternate distribution, you can install it by either saying,\n", 21 | "\n", 22 | " pip install astropy\n", 23 | " \n", 24 | "or\n", 25 | "\n", 26 | " conda install astropy" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "metadata": {}, 32 | "source": [ 33 | "## Some Features of Astropy\n", 34 | "\n", 35 | "Astropy has several features present in it. Let us summarize some of them.\n", 36 | "\n", 37 | "- Support for typical I/O operations - FITS files, tables, VO etc.\n", 38 | "- Support for basic quantities, astronomical coordinates.\n", 39 | "- Statistics and Modeling\n", 40 | "- Cosmological Calculations\n", 41 | "- Other utilities." 42 | ] 43 | }, 44 | { 45 | "cell_type": "markdown", 46 | "metadata": {}, 47 | "source": [ 48 | "## Astropy Affiliated Packages\n", 49 | "\n", 50 | "Astropy is both the Python module as well as the community. And within the community, there exist a lot of other independently made packages. However, these packages strive to be consistent with the overall organizational theme of Astropy. These packages are called the Astropy Affiliated packages.\n", 51 | "\n", 52 | "Some of the packages include:\n", 53 | "\n", 54 | "- ccdproc (for CCD data processing)\n", 55 | "- photutils (for performing photometry using a variety of source detection and photometry algorithms)\n", 56 | "- specutils (for spectroscopic analyses)\n", 57 | "- astroquery (for querying commonly used astronomical data archives)\n", 58 | "- and many many more.\n", 59 | "\n", 60 | "For a full list of all packages, please visit: https://www.astropy.org/affiliated/index.html" 61 | ] 62 | }, 63 | { 64 | "cell_type": "markdown", 65 | "metadata": {}, 66 | "source": [ 67 | "## Some Useful Links\n", 68 | "\n", 69 | "Truth be told, there is very little to 'learn' per se when it comes to Astropy. There are some basic concepts for complete newcomers to Astronomy but beyond that, it is all about navigating the documentation and finding which sub-mobule of Astropy and which corresponding function best solves the problem you are trying to solve.\n", 70 | "\n", 71 | "To that effect, here are some useful links to make note of.\n", 72 | "\n", 73 | "- The full user documentation (https://docs.astropy.org/en/stable/)\n", 74 | "- A collection of tutorials for a variety of tasks. (http://learn.astropy.org/tutorials.html)\n", 75 | "- A compilation of example code snippets. (https://docs.astropy.org/en/stable/generated/examples/index.html)" 76 | ] 77 | }, 78 | { 79 | "cell_type": "markdown", 80 | "metadata": {}, 81 | "source": [ 82 | "## Minimal Python Know How\n", 83 | "\n", 84 | "To successfully use Astropy it is very important to be aware of basic Python programming concepts. This includes\n", 85 | "\n", 86 | "- all the basic Python syntax (if, for, while etc.)\n", 87 | "- basic input and output\n", 88 | "- the data structures (lists, dictionaries etc.)\n", 89 | "- Some basic concepts of Object Oriented Programming.\n", 90 | "- Basic error catching (try / except)\n", 91 | "\n", 92 | "Behind the scenes, a lot of the astropy routines use other packages and the data structures provided by these packages. It is thus important for one to know\n", 93 | "\n", 94 | "- Numpy arrays\n", 95 | "- Pandas dataframes\n", 96 | "- Plotting librares (matplotlib basics, optionally seaborn)" 97 | ] 98 | }, 99 | { 100 | "cell_type": "markdown", 101 | "metadata": {}, 102 | "source": [ 103 | "## Object Oriented Programming Basics\n", 104 | "\n", 105 | "Consider some objects - for eg. a Ferrari, a Lamborghini, a McLarenF1 etc.\n", 106 | "\n", 107 | "All these objects are unique.\n", 108 | "\n", 109 | "- They have a different color.\n", 110 | "- A different build.\n", 111 | "- A different engine power.\n", 112 | "- etc.\n", 113 | "\n", 114 | "But also, these objects have commonalities.\n", 115 | "\n", 116 | "- They all exhibit properties such as color, build, engine power etc.\n", 117 | "- They provide common functions such as 'changing a gear', 'pressing the accelerator', 'braking' and more.\n", 118 | "\n", 119 | "In computer programming, we often come across problems or codes whre it is needed that we work with objects which are unique in their own way but share common behavior. An effective way to write code where problems can be expressed an object interactions with this kind of behavior is Object Oriented Programming.\n", 120 | "\n", 121 | "__Enter the \"Class\"__\n", 122 | "\n", 123 | "A class describes\n", 124 | "\n", 125 | "- the common properties that objects of the given class possess\n", 126 | "- the methods or functions that can be performed on these objects.\n", 127 | "\n", 128 | "Once a class is in place, we can create many objects of that class. What will change from object to object, are its individual properties and what will remain common across the objects is some of the features coded in the class.\n", 129 | "\n", 130 | "__And You Have Been using OOP All Along!__\n", 131 | "\n", 132 | "Yes! For example. consider the following simple code." 133 | ] 134 | }, 135 | { 136 | "cell_type": "code", 137 | "execution_count": 1, 138 | "metadata": {}, 139 | "outputs": [], 140 | "source": [ 141 | "s1 = \"Hello\"\n", 142 | "s2 = \"World\"" 143 | ] 144 | }, 145 | { 146 | "cell_type": "code", 147 | "execution_count": 2, 148 | "metadata": {}, 149 | "outputs": [ 150 | { 151 | "data": { 152 | "text/plain": [ 153 | "'HELLO'" 154 | ] 155 | }, 156 | "execution_count": 2, 157 | "metadata": {}, 158 | "output_type": "execute_result" 159 | } 160 | ], 161 | "source": [ 162 | "s1.upper()" 163 | ] 164 | }, 165 | { 166 | "cell_type": "code", 167 | "execution_count": 3, 168 | "metadata": {}, 169 | "outputs": [ 170 | { 171 | "data": { 172 | "text/plain": [ 173 | "'WORLD'" 174 | ] 175 | }, 176 | "execution_count": 3, 177 | "metadata": {}, 178 | "output_type": "execute_result" 179 | } 180 | ], 181 | "source": [ 182 | "s2.upper()" 183 | ] 184 | }, 185 | { 186 | "cell_type": "code", 187 | "execution_count": 4, 188 | "metadata": {}, 189 | "outputs": [ 190 | { 191 | "data": { 192 | "text/plain": [ 193 | "'o'" 194 | ] 195 | }, 196 | "execution_count": 4, 197 | "metadata": {}, 198 | "output_type": "execute_result" 199 | } 200 | ], 201 | "source": [ 202 | "s1[-1]" 203 | ] 204 | }, 205 | { 206 | "cell_type": "code", 207 | "execution_count": 5, 208 | "metadata": {}, 209 | "outputs": [ 210 | { 211 | "data": { 212 | "text/plain": [ 213 | "'d'" 214 | ] 215 | }, 216 | "execution_count": 5, 217 | "metadata": {}, 218 | "output_type": "execute_result" 219 | } 220 | ], 221 | "source": [ 222 | "s2[-1]" 223 | ] 224 | }, 225 | { 226 | "cell_type": "markdown", 227 | "metadata": {}, 228 | "source": [ 229 | "Let's look at another series of statements." 230 | ] 231 | }, 232 | { 233 | "cell_type": "code", 234 | "execution_count": 6, 235 | "metadata": {}, 236 | "outputs": [], 237 | "source": [ 238 | "d1 = {'a': 1, 'b': 2}\n", 239 | "d2 = {'c': True, 'd': [1,2,3]}" 240 | ] 241 | }, 242 | { 243 | "cell_type": "code", 244 | "execution_count": 7, 245 | "metadata": {}, 246 | "outputs": [ 247 | { 248 | "data": { 249 | "text/plain": [ 250 | "dict_keys(['a', 'b'])" 251 | ] 252 | }, 253 | "execution_count": 7, 254 | "metadata": {}, 255 | "output_type": "execute_result" 256 | } 257 | ], 258 | "source": [ 259 | "d1.keys()" 260 | ] 261 | }, 262 | { 263 | "cell_type": "code", 264 | "execution_count": 8, 265 | "metadata": {}, 266 | "outputs": [ 267 | { 268 | "data": { 269 | "text/plain": [ 270 | "dict_keys(['c', 'd'])" 271 | ] 272 | }, 273 | "execution_count": 8, 274 | "metadata": {}, 275 | "output_type": "execute_result" 276 | } 277 | ], 278 | "source": [ 279 | "d2.keys()" 280 | ] 281 | }, 282 | { 283 | "cell_type": "code", 284 | "execution_count": 9, 285 | "metadata": {}, 286 | "outputs": [ 287 | { 288 | "data": { 289 | "text/plain": [ 290 | "1" 291 | ] 292 | }, 293 | "execution_count": 9, 294 | "metadata": {}, 295 | "output_type": "execute_result" 296 | } 297 | ], 298 | "source": [ 299 | "d1['a']" 300 | ] 301 | }, 302 | { 303 | "cell_type": "code", 304 | "execution_count": 10, 305 | "metadata": {}, 306 | "outputs": [ 307 | { 308 | "data": { 309 | "text/plain": [ 310 | "True" 311 | ] 312 | }, 313 | "execution_count": 10, 314 | "metadata": {}, 315 | "output_type": "execute_result" 316 | } 317 | ], 318 | "source": [ 319 | "d2['c']" 320 | ] 321 | }, 322 | { 323 | "cell_type": "markdown", 324 | "metadata": {}, 325 | "source": [ 326 | "Can you connect this with OOP?\n", 327 | "\n", 328 | "When we created the two strings 's1' and 's2', what we were actually doing is creating two objects of class 'String'.\n", 329 | "\n", 330 | "- Each string was unique, it was a different collection and order of characters.\n", 331 | "- But yet they had common behavior - you could `.upper()` on them, you could access their elements using `[-1]` syntax and so on.\n", 332 | "\n", 333 | "Same is the case with dictionaries. 'd1' and 'd2' are completely unique dictionaries but they exhibit a common behavior and structure.\n", 334 | "\n", 335 | "The behavior for String objects is defined in something known as the 'String' class and the behavior for the dictionaries is defined in a 'Dictionary' class.\n", 336 | "\n", 337 | "__But why all this?__\n", 338 | "\n", 339 | "Because creating objects of different kinds is a common pattern in many Astropy utilities. The way an object is created is something like this." 340 | ] 341 | }, 342 | { 343 | "cell_type": "code", 344 | "execution_count": 12, 345 | "metadata": {}, 346 | "outputs": [], 347 | "source": [ 348 | "d1 = dict()\n", 349 | "d1['a'] = 'Hello'\n", 350 | "d1['b'] = True" 351 | ] 352 | }, 353 | { 354 | "cell_type": "markdown", 355 | "metadata": {}, 356 | "source": [ 357 | "Here we use `dict()` to get a dictionary object and then changed the properties of the dictionary elements. This is call 'instantiation'.\n", 358 | "\n", 359 | "The general syntax is\n", 360 | "\n", 361 | " obj = Class(prop1, prop2...)\n", 362 | " \n", 363 | "where prop1, prop2 etc. can can optional or compulsory depending on how the class is designed.\n", 364 | "\n", 365 | "When we want to make a FITS file, for example, we will create an object of a corresponding class. When we want to create a search routine, we define the properties of how it should conducts its search for celestial objects and create it from a search routine class. When we want to define a new quantity, we use the Quantity class and supply necessary properties, when we want to work with Cosmological models, we define an object of some Cosmology class and so on.\n", 366 | "\n", 367 | "It is for this reason, it is worthwhile for us to remind ourselves these basics of Class and Object concepts in Python." 368 | ] 369 | } 370 | ], 371 | "metadata": { 372 | "kernelspec": { 373 | "display_name": "Python 3", 374 | "language": "python", 375 | "name": "python3" 376 | }, 377 | "language_info": { 378 | "codemirror_mode": { 379 | "name": "ipython", 380 | "version": 3 381 | }, 382 | "file_extension": ".py", 383 | "mimetype": "text/x-python", 384 | "name": "python", 385 | "nbconvert_exporter": "python", 386 | "pygments_lexer": "ipython3", 387 | "version": "3.8.3" 388 | } 389 | }, 390 | "nbformat": 4, 391 | "nbformat_minor": 4 392 | } 393 | -------------------------------------------------------------------------------- /03 - World Coordinate Systems.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# World Coordinate Systems in Astropy\n", 8 | "\n", 9 | "__Author: Kaustubh Vaghmare__" 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "If you open an image is ds9 or any other image viewer, you will notice that as the mouse pointer moves across various regions in the image, a part of the window will reflect the current coordinates in some coordinate system. This is possible because the image header contains a whole bunch of keywords which can be used to compute the coordinates as a function of the pixel coordinates.\n", 17 | "\n", 18 | "What one needs is the coordinate for one pixel and then variation in coordinates for every pixel of movement. But if the image is very large, the curvature of the sky can become important. Then additional information to account for second order effects will need to be recorded\n", 19 | "\n", 20 | "Let's see how a good fraction of all this is handled using Astropy.\n", 21 | "\n", 22 | "Simple steps:\n", 23 | "\n", 24 | " Get hold of the header.\n", 25 | " Pass it to a WCS object constructor.\n", 26 | " And use this object for coordinate conversions.\n" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 4, 32 | "metadata": {}, 33 | "outputs": [ 34 | { 35 | "name": "stdout", 36 | "output_type": "stream", 37 | "text": [ 38 | "WCS Keywords\n", 39 | "\n", 40 | "Number of WCS axes: 2\n", 41 | "CTYPE : 'RA---TAN' 'DEC--TAN' \n", 42 | "CRVAL : 205.4864335 47.26686298333333 \n", 43 | "CRPIX : -3929.556588388735 377.0604456526553 \n", 44 | "PC1_1 PC1_2 : 0.02528041441746252 2.266833305288208e-05 \n", 45 | "PC2_1 PC2_2 : -1.983416356621748e-05 0.02528846844193638 \n", 46 | "CDELT : -0.01868178756738699 0.01868178756738699 \n", 47 | "NAXIS : 777 777\n" 48 | ] 49 | } 50 | ], 51 | "source": [ 52 | "from astropy.io import fits\n", 53 | "import astropy.wcs as wcs\n", 54 | "\n", 55 | "hdulist = fits.open('data/example2.fits')\n", 56 | "w = wcs.WCS(hdulist[0].header)\n", 57 | "print(w)" 58 | ] 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": 5, 63 | "metadata": {}, 64 | "outputs": [ 65 | { 66 | "data": { 67 | "text/plain": [ 68 | "[array(202.69037279), array(47.10039636)]" 69 | ] 70 | }, 71 | "execution_count": 5, 72 | "metadata": {}, 73 | "output_type": "execute_result" 74 | } 75 | ], 76 | "source": [ 77 | "# Convert pixels to coordinates.\n", 78 | "w.wcs_pix2world(100, 100, 1)" 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": 6, 84 | "metadata": {}, 85 | "outputs": [ 86 | { 87 | "data": { 88 | "text/plain": [ 89 | "[array([202.69037279, 202.68677899]), array([47.10039636, 47.10266995])]" 90 | ] 91 | }, 92 | "execution_count": 6, 93 | "metadata": {}, 94 | "output_type": "execute_result" 95 | } 96 | ], 97 | "source": [ 98 | "w.wcs_pix2world([100, 105], [100, 105], 1)" 99 | ] 100 | }, 101 | { 102 | "cell_type": "code", 103 | "execution_count": 7, 104 | "metadata": {}, 105 | "outputs": [ 106 | { 107 | "data": { 108 | "text/plain": [ 109 | "[array(100.56778084), array(99.1810579)]" 110 | ] 111 | }, 112 | "execution_count": 7, 113 | "metadata": {}, 114 | "output_type": "execute_result" 115 | } 116 | ], 117 | "source": [ 118 | "w.wcs_world2pix(202.69, 47.1, 1)" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": 8, 124 | "metadata": {}, 125 | "outputs": [ 126 | { 127 | "data": { 128 | "text/plain": [ 129 | "array([[202.76146626, 47.05535561],\n", 130 | " [202.74206475, 47.42164629],\n", 131 | " [202.2009436 , 47.40718098],\n", 132 | " [202.22406523, 47.04102483]])" 133 | ] 134 | }, 135 | "execution_count": 8, 136 | "metadata": {}, 137 | "output_type": "execute_result" 138 | } 139 | ], 140 | "source": [ 141 | "w.calc_footprint()" 142 | ] 143 | }, 144 | { 145 | "cell_type": "markdown", 146 | "metadata": {}, 147 | "source": [ 148 | "## Some convenience functions\n", 149 | "\n", 150 | "There are some utilities provided for your convenience which make coordinate to pixel and vice versa calculations much simple." 151 | ] 152 | }, 153 | { 154 | "cell_type": "code", 155 | "execution_count": 9, 156 | "metadata": {}, 157 | "outputs": [ 158 | { 159 | "data": { 160 | "text/plain": [ 161 | "" 163 | ] 164 | }, 165 | "execution_count": 9, 166 | "metadata": {}, 167 | "output_type": "execute_result" 168 | } 169 | ], 170 | "source": [ 171 | "output = wcs.utils.pixel_to_skycoord(100, 100, w)\n", 172 | "output" 173 | ] 174 | }, 175 | { 176 | "cell_type": "markdown", 177 | "metadata": {}, 178 | "source": [ 179 | "Remember: This is capable of ignoring higher dimensions in WCS in radio data, for example.\n", 180 | "\n", 181 | "The output here is a special object known as a sky coordinate object. This can be created by saying,\n", 182 | "\n", 183 | " from astropy.coordinates import SkyCoord\n", 184 | " c = SkyCoord(10, 20, unit='deg')\n", 185 | "\n" 186 | ] 187 | }, 188 | { 189 | "cell_type": "code", 190 | "execution_count": 11, 191 | "metadata": {}, 192 | "outputs": [ 193 | { 194 | "name": "stdout", 195 | "output_type": "stream", 196 | "text": [ 197 | "\n" 199 | ] 200 | } 201 | ], 202 | "source": [ 203 | "import astropy\n", 204 | "\n", 205 | "new = output.transform_to(astropy.coordinates.Galactic)\n", 206 | "print(new)" 207 | ] 208 | }, 209 | { 210 | "cell_type": "code", 211 | "execution_count": 12, 212 | "metadata": {}, 213 | "outputs": [ 214 | { 215 | "name": "stdout", 216 | "output_type": "stream", 217 | "text": [ 218 | "0d28m50.1524s\n" 219 | ] 220 | } 221 | ], 222 | "source": [ 223 | "from astropy.coordinates import SkyCoord\n", 224 | "\n", 225 | "distance = output.separation(SkyCoord(202, 47, unit='deg'))\n", 226 | "print(distance)" 227 | ] 228 | }, 229 | { 230 | "cell_type": "code", 231 | "execution_count": 13, 232 | "metadata": {}, 233 | "outputs": [ 234 | { 235 | "name": "stdout", 236 | "output_type": "stream", 237 | "text": [ 238 | "202d41m22.7546s 47d06m03.0639s\n" 239 | ] 240 | } 241 | ], 242 | "source": [ 243 | "print(output.ra, output.dec)" 244 | ] 245 | } 246 | ], 247 | "metadata": { 248 | "kernelspec": { 249 | "display_name": "Python 3", 250 | "language": "python", 251 | "name": "python3" 252 | }, 253 | "language_info": { 254 | "codemirror_mode": { 255 | "name": "ipython", 256 | "version": 3 257 | }, 258 | "file_extension": ".py", 259 | "mimetype": "text/x-python", 260 | "name": "python", 261 | "nbconvert_exporter": "python", 262 | "pygments_lexer": "ipython3", 263 | "version": "3.8.3" 264 | } 265 | }, 266 | "nbformat": 4, 267 | "nbformat_minor": 4 268 | } 269 | -------------------------------------------------------------------------------- /04 - Data Modeling.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Data Modeling with Astropy\n", 8 | "\n", 9 | "__Author: Kaustubh Vaghmare__" 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "\"modeling\" is a library in Python designed to give you\n", 17 | "\n", 18 | "- Access to commonly used models.\n", 19 | "- As well as fit them to various data.\n", 20 | "\n", 21 | "Let's see how to use this module." 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": {}, 27 | "source": [ 28 | "First off, we will use the models prebuilt into this module to generate some data." 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": 1, 34 | "metadata": {}, 35 | "outputs": [ 36 | { 37 | "data": { 38 | "text/plain": [ 39 | "" 40 | ] 41 | }, 42 | "execution_count": 1, 43 | "metadata": {}, 44 | "output_type": "execute_result" 45 | }, 46 | { 47 | "data": { 48 | "image/png": "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\n", 49 | "text/plain": [ 50 | "
" 51 | ] 52 | }, 53 | "metadata": { 54 | "needs_background": "light" 55 | }, 56 | "output_type": "display_data" 57 | } 58 | ], 59 | "source": [ 60 | "from astropy.modeling import models\n", 61 | "import numpy as np\n", 62 | "import matplotlib.pyplot as plt\n", 63 | "%matplotlib inline\n", 64 | "\n", 65 | "x = np.linspace(9, 14, 100)\n", 66 | "gauss_example1 = models.Gaussian1D(amplitude=1.0, mean=12, stddev=0.5)\n", 67 | "gauss_example2 = models.Gaussian1D(amplitude=2.0, mean=13.5, stddev=0.2)\n", 68 | "gauss_total = gauss_example1 + gauss_example2\n", 69 | "y = gauss_total(x)\n", 70 | "\n", 71 | "plt.scatter(x,y)" 72 | ] 73 | }, 74 | { 75 | "cell_type": "code", 76 | "execution_count": 2, 77 | "metadata": {}, 78 | "outputs": [ 79 | { 80 | "data": { 81 | "text/plain": [ 82 | "" 83 | ] 84 | }, 85 | "execution_count": 2, 86 | "metadata": {}, 87 | "output_type": "execute_result" 88 | }, 89 | { 90 | "data": { 91 | "image/png": "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\n", 92 | "text/plain": [ 93 | "
" 94 | ] 95 | }, 96 | "metadata": { 97 | "needs_background": "light" 98 | }, 99 | "output_type": "display_data" 100 | } 101 | ], 102 | "source": [ 103 | "import numpy.random as nr\n", 104 | "\n", 105 | "y_noise = nr.normal(0, 0.1, len(x))\n", 106 | "y_obs = 12 + 0.01*x**2 + y + y_noise\n", 107 | "plt.scatter(x, y_obs)" 108 | ] 109 | }, 110 | { 111 | "cell_type": "markdown", 112 | "metadata": {}, 113 | "source": [ 114 | "We saw how trivial it is to use a model and actually evaluate it over a range. But a more useful thing we need to do with models is to fit some data. Now, pretend that x and y_obs are two arrays that contain our observed data. We can start by plotting the same." 115 | ] 116 | }, 117 | { 118 | "cell_type": "code", 119 | "execution_count": 3, 120 | "metadata": {}, 121 | "outputs": [ 122 | { 123 | "data": { 124 | "text/plain": [ 125 | "" 126 | ] 127 | }, 128 | "execution_count": 3, 129 | "metadata": {}, 130 | "output_type": "execute_result" 131 | }, 132 | { 133 | "data": { 134 | "image/png": "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\n", 135 | "text/plain": [ 136 | "
" 137 | ] 138 | }, 139 | "metadata": { 140 | "needs_background": "light" 141 | }, 142 | "output_type": "display_data" 143 | } 144 | ], 145 | "source": [ 146 | "plt.scatter(x, y_obs)" 147 | ] 148 | }, 149 | { 150 | "cell_type": "markdown", 151 | "metadata": {}, 152 | "source": [ 153 | "Once we have a plot, our next step is to choose a model. What model shall fit the data well? Let us assume that these are spectral features with some known wavelengths. So, we may assume that each feature is a Gaussian. To minimize number if independent parameters, we may also consider that the difference in the wavelengths is a constant. Such a constraint obviously comes from our prior knowledge of the physical system that generated the spectrum.\n", 154 | "\n", 155 | "Next, these emission features clearly are not on their own - they are stop a continuum. Assuming that the continuum is not varying at a fast rate wrt wavelengths (X-axis), we can further assume that a quadratic polynomial suffices in accounting for this.\n", 156 | "\n", 157 | "So, our model is a second order polynomial plus two Gaussians, with different means but separated by a known amount.\n" 158 | ] 159 | }, 160 | { 161 | "cell_type": "code", 162 | "execution_count": 20, 163 | "metadata": {}, 164 | "outputs": [], 165 | "source": [ 166 | "# So, let us construct our model.\n", 167 | "model = models.Gaussian1D(amplitude=1.0, mean=12.1, stddev=0.5) +\\\n", 168 | " models.Gaussian1D(amplitude=1.0, mean=13.6, stddev=0.4) +\\\n", 169 | " models.Polynomial1D(degree=2)" 170 | ] 171 | }, 172 | { 173 | "cell_type": "code", 174 | "execution_count": 21, 175 | "metadata": {}, 176 | "outputs": [ 177 | { 178 | "name": "stdout", 179 | "output_type": "stream", 180 | "text": [ 181 | "('amplitude_0', 'mean_0', 'stddev_0', 'amplitude_1', 'mean_1', 'stddev_1', 'c0_2', 'c1_2', 'c2_2')\n" 182 | ] 183 | } 184 | ], 185 | "source": [ 186 | "print(model.param_names)" 187 | ] 188 | }, 189 | { 190 | "cell_type": "code", 191 | "execution_count": 22, 192 | "metadata": {}, 193 | "outputs": [], 194 | "source": [ 195 | "# Our model is not complete. We must supply our constraint.\n", 196 | "def constraint_mean(model):\n", 197 | " mean_0 = model.mean_1 - 1.5\n", 198 | " return mean_0\n", 199 | "\n", 200 | "model.mean_0.tied = constraint_mean" 201 | ] 202 | }, 203 | { 204 | "cell_type": "markdown", 205 | "metadata": {}, 206 | "source": [ 207 | "The model is ready. We have the data. What we finally need is a fitting algorithm. Let us choose the Marquardt Levenberg method." 208 | ] 209 | }, 210 | { 211 | "cell_type": "code", 212 | "execution_count": 23, 213 | "metadata": {}, 214 | "outputs": [], 215 | "source": [ 216 | "from astropy.modeling import fitting\n", 217 | "fitter = fitting.LevMarLSQFitter()\n", 218 | "\n", 219 | "model_fit = fitter(model, x, y_obs)" 220 | ] 221 | }, 222 | { 223 | "cell_type": "code", 224 | "execution_count": 24, 225 | "metadata": {}, 226 | "outputs": [ 227 | { 228 | "data": { 229 | "text/plain": [ 230 | "array([ 0.90358336, 12.00138921, 0.45139846, 2.06095233, 13.50138921,\n", 231 | " 0.21485245, 8.6082357 , 0.60795781, -0.01652507])" 232 | ] 233 | }, 234 | "execution_count": 24, 235 | "metadata": {}, 236 | "output_type": "execute_result" 237 | } 238 | ], 239 | "source": [ 240 | "model_fit.parameters" 241 | ] 242 | }, 243 | { 244 | "cell_type": "code", 245 | "execution_count": 25, 246 | "metadata": {}, 247 | "outputs": [ 248 | { 249 | "data": { 250 | "text/plain": [ 251 | "('amplitude_0',\n", 252 | " 'mean_0',\n", 253 | " 'stddev_0',\n", 254 | " 'amplitude_1',\n", 255 | " 'mean_1',\n", 256 | " 'stddev_1',\n", 257 | " 'c0_2',\n", 258 | " 'c1_2',\n", 259 | " 'c2_2')" 260 | ] 261 | }, 262 | "execution_count": 25, 263 | "metadata": {}, 264 | "output_type": "execute_result" 265 | } 266 | ], 267 | "source": [ 268 | "model_fit.param_names" 269 | ] 270 | }, 271 | { 272 | "cell_type": "code", 273 | "execution_count": 26, 274 | "metadata": {}, 275 | "outputs": [ 276 | { 277 | "data": { 278 | "text/plain": [ 279 | "{'amplitude_0': 0.9035833596742572,\n", 280 | " 'mean_0': 12.001389206019292,\n", 281 | " 'stddev_0': 0.4513984646646848,\n", 282 | " 'amplitude_1': 2.0609523268230263,\n", 283 | " 'mean_1': 13.501389206019292,\n", 284 | " 'stddev_1': 0.2148524505642017,\n", 285 | " 'c0_2': 8.608235703085297,\n", 286 | " 'c1_2': 0.6079578146586134,\n", 287 | " 'c2_2': -0.016525065299963112}" 288 | ] 289 | }, 290 | "execution_count": 26, 291 | "metadata": {}, 292 | "output_type": "execute_result" 293 | } 294 | ], 295 | "source": [ 296 | "dict(zip(model_fit.param_names, model_fit.parameters))" 297 | ] 298 | }, 299 | { 300 | "cell_type": "code", 301 | "execution_count": 27, 302 | "metadata": {}, 303 | "outputs": [ 304 | { 305 | "data": { 306 | "text/plain": [ 307 | "[]" 308 | ] 309 | }, 310 | "execution_count": 27, 311 | "metadata": {}, 312 | "output_type": "execute_result" 313 | }, 314 | { 315 | "data": { 316 | "image/png": "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\n", 317 | "text/plain": [ 318 | "
" 319 | ] 320 | }, 321 | "metadata": { 322 | "needs_background": "light" 323 | }, 324 | "output_type": "display_data" 325 | } 326 | ], 327 | "source": [ 328 | "plt.scatter(x, y_obs, color='black', alpha=0.3)\n", 329 | "plt.plot(x, model_fit(x), color='red')" 330 | ] 331 | } 332 | ], 333 | "metadata": { 334 | "kernelspec": { 335 | "display_name": "Python 3", 336 | "language": "python", 337 | "name": "python3" 338 | }, 339 | "language_info": { 340 | "codemirror_mode": { 341 | "name": "ipython", 342 | "version": 3 343 | }, 344 | "file_extension": ".py", 345 | "mimetype": "text/x-python", 346 | "name": "python", 347 | "nbconvert_exporter": "python", 348 | "pygments_lexer": "ipython3", 349 | "version": "3.8.3" 350 | } 351 | }, 352 | "nbformat": 4, 353 | "nbformat_minor": 4 354 | } 355 | -------------------------------------------------------------------------------- /05 - Cosmology.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Cosmology Calculations with Astropy\n", 8 | "\n", 9 | "__Author: Kaustubh Vaghmare__" 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "You no longer need to open a web browser to access a cosmology calculator. You can do all this in Python using astropy's cosmology module. Let's see a quick demo." 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 1, 22 | "metadata": {}, 23 | "outputs": [ 24 | { 25 | "name": "stdout", 26 | "output_type": "stream", 27 | "text": [ 28 | "['Planck18_arXiv_v2', 'Planck15', 'Planck13', 'WMAP9', 'WMAP7', 'WMAP5']\n" 29 | ] 30 | } 31 | ], 32 | "source": [ 33 | "from astropy import cosmology\n", 34 | "print(cosmology.parameters.available)" 35 | ] 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": 2, 40 | "metadata": {}, 41 | "outputs": [ 42 | { 43 | "name": "stdout", 44 | "output_type": "stream", 45 | "text": [ 46 | "159.1650142340452 km / (Mpc s)\n", 47 | "0.03373807940563316\n", 48 | "1.7653419274468524e-28 g / cm3\n", 49 | "2728.2255 K\n", 50 | "1770.5128493113732 Mpc\n", 51 | "0.03168529715449053 arcsec / kpc\n", 52 | "0.2\n" 53 | ] 54 | } 55 | ], 56 | "source": [ 57 | "# Let us choose a model out of one of the above...\n", 58 | "from astropy.cosmology import Planck15\n", 59 | "\n", 60 | "print(Planck15.H(1.5)) # what is the Hubble parameter at redshift 1.5?\n", 61 | "print(Planck15.Ode(3)) # density parameter for dark energy at redshift z=3 (in units of critical density)\n", 62 | "print(Planck15.critical_density(3))\n", 63 | "print(Planck15.Tcmb(1000))\n", 64 | "print(Planck15.angular_diameter_distance(2))\n", 65 | "print(Planck15.arcsec_per_kpc_comoving(3))\n", 66 | "print(Planck15.scale_factor(4))" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 10, 72 | "metadata": {}, 73 | "outputs": [ 74 | { 75 | "name": "stdout", 76 | "output_type": "stream", 77 | "text": [ 78 | "H\n", 79 | "H0\n", 80 | "Neff\n", 81 | "Ob\n", 82 | "Ob0\n", 83 | "Ode\n", 84 | "Ode0\n", 85 | "Odm\n", 86 | "Odm0\n", 87 | "Ogamma\n", 88 | "Ogamma0\n", 89 | "Ok\n", 90 | "Ok0\n", 91 | "Om\n", 92 | "Om0\n", 93 | "Onu\n", 94 | "Onu0\n", 95 | "Tcmb\n", 96 | "Tcmb0\n", 97 | "Tnu\n", 98 | "Tnu0\n", 99 | "abs_distance_integrand\n", 100 | "absorption_distance\n", 101 | "age\n", 102 | "angular_diameter_distance\n", 103 | "angular_diameter_distance_z1z2\n", 104 | "arcsec_per_kpc_comoving\n", 105 | "arcsec_per_kpc_proper\n", 106 | "clone\n", 107 | "comoving_distance\n", 108 | "comoving_transverse_distance\n", 109 | "comoving_volume\n", 110 | "critical_density\n", 111 | "critical_density0\n", 112 | "de_density_scale\n", 113 | "differential_comoving_volume\n", 114 | "distmod\n", 115 | "efunc\n", 116 | "h\n", 117 | "has_massive_nu\n", 118 | "hubble_distance\n", 119 | "hubble_time\n", 120 | "inv_efunc\n", 121 | "kpc_comoving_per_arcmin\n", 122 | "kpc_proper_per_arcmin\n", 123 | "lookback_distance\n", 124 | "lookback_time\n", 125 | "lookback_time_integrand\n", 126 | "luminosity_distance\n", 127 | "m_nu\n", 128 | "name\n", 129 | "nu_relative_density\n", 130 | "scale_factor\n", 131 | "w\n" 132 | ] 133 | } 134 | ], 135 | "source": [ 136 | "print(\"\\n\".join([i for i in dir(Planck15) if not i[0] == \"_\"]))" 137 | ] 138 | } 139 | ], 140 | "metadata": { 141 | "kernelspec": { 142 | "display_name": "Python 3", 143 | "language": "python", 144 | "name": "python3" 145 | }, 146 | "language_info": { 147 | "codemirror_mode": { 148 | "name": "ipython", 149 | "version": 3 150 | }, 151 | "file_extension": ".py", 152 | "mimetype": "text/x-python", 153 | "name": "python", 154 | "nbconvert_exporter": "python", 155 | "pygments_lexer": "ipython3", 156 | "version": "3.8.3" 157 | } 158 | }, 159 | "nbformat": 4, 160 | "nbformat_minor": 4 161 | } 162 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # The Astropy Tutorial 2 | ## by Kaustubh Vaghmare 3 | 4 | This repository contains the notebook(s) used by me for teaching the fundamentals of Astropy. It contains 5 | 6 | - Jupyter notebooks with code and theory 7 | - And also the data needed to go through some of the code examples. 8 | 9 | ## What you need? 10 | 11 | You can either choose to work with a vanilla Python environment or with the Anaconda distribution. 12 | 13 | If you are working with a full Anaconda distribution, Astropy package should already be installed. You can confirm this by running a Python shell and executing the following commands. 14 | 15 | >>> import astropy 16 | >>> print(astropy.__version__) 17 | 4.0.1.post1 18 | 19 | And if you are working with a non-Conda environment, you can install it with ease. As a good practice, we always start with a Virtual environment dedicated to our specific project or work session. For creating the Virtual Environment, choose a directory. 20 | 21 | python3 -m venv astropy_venv 22 | source astropy_venv/bin/activate 23 | 24 | And then install the packages by saying, 25 | 26 | pip install astropy 27 | 28 | It is a good option to install some other packages as well which we will need that are not exactly needed for Astropy to work bu t we will need them. 29 | 30 | pip install scipy pandas matplotlib seaborn jupyter jupyterlab 31 | 32 | ## Starting Off 33 | 34 | Ensure whatever environment you are working in, is activated and then start Jupyter Lab. 35 | 36 | jupyter lab 37 | -------------------------------------------------------------------------------- /data/example.fits: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vkaustubh/astropy-tutorial/3cac8391225af02c510b67caecd57364f39b449f/data/example.fits -------------------------------------------------------------------------------- /data/example2.fits: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vkaustubh/astropy-tutorial/3cac8391225af02c510b67caecd57364f39b449f/data/example2.fits --------------------------------------------------------------------------------