SunPy: Python for solar physics
Upcoming SlideShare
Loading in...5

SunPy: Python for solar physics






Total Views
Views on SlideShare
Embed Views



1 Embed 294 294



Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
Post Comment
Edit your comment

SunPy: Python for solar physics SunPy: Python for solar physics Presentation Transcript

  • Steven Christe1,, Matt Earnshaw2, Keith Hughitt1, Jack Ireland1, Florian Mayer3,Albert Shih1, Alex Young11 NASA GSFC2 Imperial College London3 Vienna University of Technology Florian Mayer
  •  What is Python? Introduction to Python Scientific Python  NumPy  Matplotlib  SciPy Python in solar physics
  •  General-purpose Object-oriented (disputed) Cross-platform  Windows  Mac OS  Linux  Other Unices (FreeBSD, Solaris, etc.) High-level
  •  Internet companies  Google  Rackspace Games  Battlefield 2  Civilization 4 Graphics  Walt Disney Science  NASA  ESRI
  •  Easy Comprehensive standard library (“batteries included”) Quality does vary, though. Good support for scientific tasks Permissive open-source licenseOn the downside: Slower, but ways to speed up
  • PYTHON IDL Free open-source software  Proprietary software Without cost  License cost General purpose  Small community Good plotting  Cumbersome plotting No solar software  Solar software
  •  Implementation started 1989 by Guido van Rossum (BDFL) 2.0 appeared 2000  Garbage collection  Unicode 3.0 appeared 2008
  •  Astronomy Artificial intelligence & machine learning Bayesian Statistics Biology (including Neuroscience) Dynamical systems Economics and Econometrics Electromagnetics Electrical Engineering Geosciences Molecular modeling Signal processing Symbolic math, number theory
  •  pyFITS – read FITS files pyRAF – run IRAF tasks pywcs pyephem – compute positions of objects in space spacepy (space sciences, just released) Planned standard library AstroPy
  •  Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Readability counts. There should be one – and preferably only one – obvious way to do it. Although that way may not be obvious at first unless youre Dutch. >>> import this
  • Brief introduction into Python
  •  Infix notation operations Python 2 defaults to floor division More mathematical operations in math Complex math in cmath
  •  Integers are arbitrary size. Floats are platform doubles. decimal module for arbitrary precision decimal numbers fractions module for fractions
  • STRINGS / BYTES UNICODE "foo"  u"foo" Store bytes  Store unicode codepoints Useful for binary data  Useful for text  Behave as expected for multibyte characters
  •  [1, 2, 3, 4]  (1, u"foo") Mutable  Immutable Multiple records  Different objects describing one record
  •  if/elif/else for-loop  break  continue  else while-loop pass
  •  Default arguments are evaluated once at compile time! lambda alternative syntax for definition of trivial functions Functions are objects, too!
  •  Unordered key-value mappings Approx. O(1) lookup and storage Keys must be immutable (hashable)
  •  Unordered collection of unique objects Approx. O(1) membership test Members must be immutable (hashable)
  •  Classes Explicit self Multiple inheritance Also in IDL 8; no escaping it
  •  try / except / else raise Exceptions inherit from Exception
  • PYTHON 2.7 PYTHON 3.2 Print statement  Print function String / Unicode  Bytes / String Floor division  Float Division Relative imports  Absolute imports Lists  Views Tons of other changes
  •  Fundamental package for science in Python Multidimensional fixed-size, homogenous arrays Derived objects: e.g. matrices More efficient Less code
  •  Python list arange linspace / logspace ones / zeros / eye / diag random
  •  Absence of explicit looping  Conciseness – less bugs  Closer to mathematical notation  More pythonic. Also possible for user functions
  •  Expansion of multidimensional arrays Implicit element-by-element behavior
  •  Boolean area Integer area
  • Type Remarks Character codebyte compatible: C char bshort compatible: C short hintc compatible: C int iint_ compatible: Python int llonglong compatible: C long long q large enough to fit aintp p pointerint8 8 bitsint16 16 bitsint32 32 bitsint64 64 bits
  • Type Remarks Character codeubyte compatible: C u. char Bushort compatible: C u. short Huintc compatible: C unsigned int Iuint compatible: Python int Lulonglong compatible: C long long Q large enough to fit auintp P pointeruint8 8 bitsuint16 16 bitsuint32 32 bitsuint64 64 bits
  • Type Remarks Character codehalf esingle compatible: C float fdouble compatible: C doublefloat_ compatible: Python float dlongfloat compatible: C long float gfloat16 16 bitsfloat32 32 bitsfloat64 64 bitsfloat96 96 bits, platform?float128 128 bits, platform?
  • Type Remarks Character codecsingle F compatible: Pythoncomplex_ D complexclongfloat Gcomplex64 two 32-bit floatscomplex128 two 64-bit floats two 96-bit floats,complex192 platform? two 128-bit floats,complex256 platform?
  •  NumPy: weave.blitz (fast NumPy expressions) NumPy: weave.inline (inline C/C++) f2py (interface Fortran) Pyrex/Cython (python-like compiled language)
  •  2D plotting library Some 3D support Publication-quality figures “Make easy things easy and hard things possible” Configurable using matplotlibrc
  • import numpy as npfrom matplotlib import pyplot as pltt = np.linspace(0, 2, 200)s = np.sin(2*pi*t)plt.plot(t, s, linewidth=1.0)plt.xlabel(time (s))plt.ylabel(voltage (mV))plt.title(About as simple as it gets, folks)plt.grid(True)
  • import numpy as npfrom matplotlib import pyplot as pltdef f(t): s1 = np.cos(2*pi*t) e1 = np.exp(-t) return np.multiply(s1,e1)t1 = np.arange(0.0, 5.0, 0.1)t2 = np.arange(0.0, 5.0, 0.02)t3 = np.arange(0.0, 2.0, 0.01)plt.subplot(211)l = plot(t1, f(t1), bo, t2, f(t2), k--, markerfacecolor=green)plt.grid(True)plt.title(A tale of 2 subplots)plt.ylabel(Damped oscillation)plt.subplot(212)plt.plot(t3, np.cos(2*pi*t3), r.)plt.grid(True)plt.xlabel(time (s))plt.ylabel(Undamped)
  • import numpy as npimport matplotlib.path as mpathimport matplotlib.patches as mpatchesimport matplotlib.pyplot as pltPath = mpath.Pathfig = plt.figure()ax = fig.add_subplot(111)pathdata = [ (Path.MOVETO, (1.58, -2.57)), (Path.CURVE4, (0.35, -1.1)), (Path.CURVE4, (-1.75, 2.0)), (Path.CURVE4, (0.375, 2.0)), (Path.LINETO, (0.85, 1.15)), (Path.CURVE4, (2.2, 3.2)), (Path.CURVE4, (3, 0.05)), (Path.CURVE4, (2.0, -0.5)), (Path.CLOSEPOLY, (1.58, -2.57)), ]codes, verts = zip(*pathdata)path = mpath.Path(verts, codes)patch = mpatches.PathPatch(path, facecolor=red,edgecolor=yellow, alpha=0.5)ax.add_patch(patch)x, y = zip(*path.vertices)line, = ax.plot(x, y, go-)ax.grid()ax.set_xlim(-3,4)ax.set_ylim(-3,4)ax.set_title(spline paths)
  • from mpl_toolkits.mplot3d import Axes3Dfrom matplotlib import cmfrom matplotlib.ticker import (LinearLocator, FixedLocator,FormatStrFormatter)import matplotlib.pyplot as pltimport numpy as npfig = plt.figure()ax = fig.gca(projection=3d)X = np.arange(-5, 5, 0.25)Y = np.arange(-5, 5, 0.25)X, Y = np.meshgrid(X, Y)R = np.sqrt(X**2 + Y**2)Z = np.sin(R)surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.jet, linewidth=0, antialiased=False)ax.set_zlim3d(-1.01, 1.01)ax.w_zaxis.set_major_locator(LinearLocator(10))ax.w_zaxis.set_major_formatter(FormatStrFormatter(%.03f))fig.colorbar(surf, shrink=0.5, aspect=5)
  • import numpy as npfrom matplotlib import pyplot as pltfrom matplotlib.patches import EllipseNUM = 250ells = [ Ellipse(xy=rand(2)*10, width=np.rand(), height=np.rand(), angle=np.rand()*360) for i in xrange(NUM)]fig = plt.figure()ax = fig.add_subplot(111, aspect=equal)for e in ells: ax.add_artist(e) e.set_clip_box(ax.bbox) e.set_alpha(rand()) e.set_facecolor(rand(3))ax.set_xlim(0, 10)ax.set_ylim(0, 10)
  •  Statistics Optimization Numerical integration Linear algebra Fourier transforms Signal processing Image processing ODE solvers Special functions And more.
  •  Three phases  Glass sample – light grey  Bubbles – black  Sand grains – dark grey Determine  Fraction of the sample covered by these  Typical size of sand grains or bubbles
  • 1. Open image and examine it2. Crop away panel at bottom  Examine histogram3. Apply median filter4. Determine thresholds5. Display colored image6. Use mathematical morphology to clean the different phases7. Attribute labels to all bubbles and sand grains  Remove from the sand mask grains that are smaller than 10 pixels8. Compute the mean size of bubbles.
  •  Spatially aware maps Read FITS files  RHESSI  SDO/AIA  EIT  TRACE  LASCO standard color tables and hist equalization basic image coalignment VSO HEK
  •  Spatially aware array NumPy array Based on SolarSoft Map. MapCube
  •  Two APIs  Legacy API (tries to mimic IDL vso_search)  New API based on boolean operations
  •  Create VSO queries from HER responses WIP: Plot HER events over images
  •  Use it! File feature requests Express opinion on the mailing list / in IRC File bug reports Contribute documentation Contribute code
  •  Website: Mailing list: IRC: #sunpy on Git code repository:
  •  Email: IRC: __name__ in #sunpy on freenode XMPP:
  •  SciPy: Astronomical modules: Science modules: NumPy/IDL: Python for interactive data analysis: SciPy lecture notes: This talk: SunPy doc:
  •  Steven Christe1, Matt Earnshaw2 Keith Hughitt1 Jack Ireland1 Thanks to Florian Mayer3 Albert Shih1 Alex Young11 NASA GSFC2 Imperial College London3 Vienna University of Technology