astro py:docs

- Index
- Modules

### Navigation

- next »
- « previous |
- Astropy v1.1.1 »
- What’s New in Astropy 1.0?

# What’s New in Astropy 1.0?

## Overview

Astropy 1.0 is a major release that adds significant new functionality since the 0.4.x series of releases.

In particular, coordinate conversions to/from Altitude/Azimuth are now supported (see Support for Alt/Az coordinates), a new package to help with data visualization has been added (see New data visualization subpackage), and a new package for common analytic functions is now also included (see New analytic functions subpackage).

The ASCII Tables (astropy.io.ascii) sub-package now includes fast C-based readers/writers for common formats, and also supports a new ASCII format that better preserves meta-data (see New ASCII features), the modeling package has been significantly improved and now supports composite models (see New modeling features), and the `Table` class can now include `SkyCoord` and `Time` objects containing arrays (see New Table features).

In addition to these major changes, Astropy 1.0 includes a large number of smaller improvements and bug fixes, which are described in the Full Changelog. By the numbers:

- 681 issues have been closed since v0.4
- 419 pull requests have been merged since v0.4
- 122 distinct people have contributed code

## About Long-term support

Astropy v1.0 is a long-term support (LTS) release. This means v1.0 will be supported with bug fixes for 2 years from its release, rather than 6 months like the non-LTS releases. More details about this, including a wider rationale for Astropy’s version numbering scheme, can be found in Astropy Proposal for Enhancement 2.

Note that different sub-packages in Astropy have different stability levels. See the Current status of sub-packages page for an overview of the status of major components. LTS can be expected for anything with green or blue (stable or mature) status on that page. For yellow (in development) subpackages, LTS may be provided, but major changes may prevent backporting of complex changes, particularly if they are connected to new features.

## Support for Alt/Az coordinates

The `coordinates` package now supports conversion to/from AltAz coordinates. This means `coordinates` can now be used for planning observations. For example:

    >>> from astropy import units as u
    >>> from astropy.time import Time
    >>> from astropy.coordinates import SkyCoord, EarthLocation, AltAz
    >>> greenwich = EarthLocation(lat=51.477*u.deg,lon=0*u.deg)
    >>> albireo = SkyCoord('19h30m43.2805s +27d57m34.8483s')
    >>> altaz = albireo.transform_to(AltAz(location=greenwich, obstime=Time('2014-6-21 0:00')))
    >>> print altaz.alt, altaz.az
    60d32m28.4576s 133d45m36.4967s

For a more detailed outline of this new functionality, see the Example: Observation Planning and the `AltAz` documentation.

To enable this functionality, `coordinates` now also contains the full IAU-sanctioned coordinate transformation stack from ICRS to AltAz. To view the full set of coordinate frames now available, see the coordinates Reference/API.

## New Galactocentric coordinate frame

Added a new, customizable `Galactocentric` coordinate frame. The other coordinate frames (e.g., `ICRS`, `Galactic`) are all Heliocentric (or barycentric). The center of this new coordinate frame is at the center of the Galaxy, with customizable parameters allowing the user to specify the distance to the Galactic center (`galcen_distance`), the ICRS position of the Galactic center (`galcen_ra`, `galcen_dec`), the height of the Sun above the Galactic midplane (`z_sun`), and a final roll angle that allows for specifying the orientation of the z axis (`roll`):

    >>> from astropy import units as u
    >>> from astropy.coordinates import SkyCoord, Galactocentric
    >>> c = SkyCoord(ra=152.718 * u.degree,
    ...              dec=-11.214 * u.degree,
    ...              distance=21.5 * u.kpc)
    >>> c.transform_to(Galactocentric)
    <SkyCoord (Galactocentric: galcen_distance=8.3 kpc, galcen_ra=266d24m18.36s, galcen_dec=-28d56m10.23s, z_sun=27.0 pc, roll=0.0 deg): (x, y, z) in kpc
        (-13.6512648452, -16.6847348677, 12.4862582821)>
    >>> c.transform_to(Galactocentric(galcen_distance=8*u.kpc, z_sun=15*u.pc))
    <SkyCoord (Galactocentric: galcen_distance=8.0 kpc, galcen_ra=266d24m18.36s, galcen_dec=-28d56m10.23s, z_sun=15.0 pc, roll=0.0 deg): (x, y, z) in kpc
        (-13.368458678, -16.6847348677, 12.466872262)>

## New data visualization subpackage

The new Data Visualization package is intended to collect functionality that can be helpful when visualizing data. At the moment, the main functionality is image normalizing (including both scaling and stretching) but this will be expanded in future. Included in the image normalization functionality is the ability to compute interval limits on data, (such as percentile limits), stretching with non-linear functions (such as square root or arcsinh functions), and the ability to use custom stretches in Matplotlib that are correctly reflected in the colorbar:

    import numpy as np
    import matplotlib.pyplot as plt

    from astropy.visualization import SqrtStretch
    from astropy.visualization.mpl_normalize import ImageNormalize

    # Generate test image
    image = np.arange(65536).reshape((256, 256))

    # Create normalizer object
    norm = ImageNormalize(vmin=0., vmax=65536, stretch=SqrtStretch())

    fig = plt.figure(figsize=(6,3))
    ax = fig.add_subplot(1,1,1)
    im = ax.imshow(image, norm=norm, origin='lower', aspect='auto')
    fig.colorbar(im)

(Source code, png, hires.png, pdf)

## New analytic functions subpackage

This subpackage provides analytic functions that are commonly used in astronomy. These already understand `Quantity`, i.e., they can handle units of input and output parameters. For instance, to calculate the blackbody flux for 10000K at 6000 Angstrom:

    >>> from astropy import units as u
    >>> from astropy.analytic_functions import blackbody_lambda, blackbody_nu
    >>> blackbody_lambda(6000 * u.AA, 10000 * u.K)
    <Quantity 15315791.836941158 erg / (Angstrom cm2 s sr)>
    >>> blackbody_nu(6000 * u.AA, 10000 * u.K)
    <Quantity 0.00018391673686797075 erg / (cm2 Hz s sr)

See Analytic Functions (astropy.analytic_functions) for more details.

In future versions of Astropy, the functions in this module might also be accessible as `Model` classes.

## New ASCII features

### Fast readers/writers for ASCII files

The `astropy.io.ascii` module now includes a significantly faster Cython/C engine for reading and writing ASCII files. This is available for the following formats: `basic`, `commented_header`, `csv`, `no_header`, `rdb`, and `tab`. On average the new engine is about 4 to 5 times faster than the corresponding pure-Python implementation, and is often comparable to the speed of the pandas ASCII file interface (read_csv and to_csv). The fast reader has parallel processing option that allows harnessing multiple cores for input parsing to achieve even greater speed gains.

By default, `read()` and `write()` will attempt to use the fast C engine when dealing with compatible formats. Certain features of the full read / write interface are not available in the fast version, in which case the pure-Python version will automatically be used.

For full details including extensive performance testing, see Fast ASCII I/O.

### Enhanced CSV format

One of the problems when storing a table in an ASCII format is preserving table meta-data such as comments, keywords and column data types, units, and descriptions. Using the newly defined Enhanced Character Separated Values format it is now possible to write a table to an ASCII-format file and read it back with no loss of information. The ECSV format has been designed to be both human-readable and compatible with most simple CSV readers.

In the example below we show writing a table that has `float32` and `bool` types. This illustrates the simple look of the format which has a few header lines (starting with `#`) in YAML format and then the data values in CSV format.

    >>> t = Table()
    >>> t['x'] = Column([1.0, 2.0], unit='m', dtype='float32')
    >>> t['y'] = Column([False, True], dtype='bool')

    >>> from astropy.extern.six.moves import StringIO
    >>> fh = StringIO()
    >>> t.write(fh, format='ascii.ecsv')
    >>> table_string = fh.getvalue()
    >>> print(table_string)
    # %ECSV 0.9
    # ---
    # columns:
    # - {name: x, unit: m, type: float32}
    # - {name: y, type: bool}
    x y
    1.0 False
    2.0 True

Without the header this table would get read back with different types (`float64` and `string` respectively) and no unit values. Instead with the automatically-detected ECSV we get:

    >>> Table.read(table_string, format='ascii')
    <Table masked=False length=2>
       x      y
       m
    float32  bool
    ------- -----
        1.0 False
        2.0  True

Note that using the ECSV reader requires the PyYAML package to be installed.

## New modeling features

New subclasses of `Model` are now a bit easier to define, requiring less boilerplate code in general. Now all that is necessary to define a new model class is an `evaluate` method that computes the model. Optionally one can define fittable parameters, a `fit_deriv`, and/or an `inverse`. The new, improved `custom_model` decorator reduces the boilerplate needed for many models even more. See Defining New Model Classes for more details.

Array broadcasting has also been improved, enabling a broader range of possibilities for the values of model parameters and inputs. Support has also been improved for Model Sets (previously referred to as parameter sets) which can be thought of like an array of models of the same class, each with different sets of parameters, which can be fitted simultaneously either to the same data, or to different data sets per model. See Instantiating and Evaluating Models for more details.

It is now possible to create compound models by combining existing models using the standard arithmetic operators such as `+` and `*`, as well as functional composition using the `|` operator. This provides a powerful and flexible new way to create more complex models without having to define any special classes or functions. For example:

    >>> from astropy.modeling.models import Gaussian1D
    >>> gaussian1 = Gaussian1D(1, 0, 0.2)
    >>> gaussian2 = Gaussian1D(2.5, 0.5, 0.1)
    >>> sum_of_gaussians = gaussian1 + gaussian2

The resulting model works like any other model, and also works with the fitting framework. See the introduction to compound models and full compound models documentation for more examples.

## New Table features

### Refactor of table infrastructure

The underlying data container for the Astropy `Table` object has been changed in Astropy v1.0. Previously, tables were stored internally as a Numpy structured array object, with column access being a memory view of the corresponding Numpy array field. Starting with this release the fundamental data container is an ordered dictionary of individual column objects and each `Column` object is the sole owner of its data.

The biggest impact to users is that operations such as adding or removing table columns is now significantly faster because there is no structured array to rebuild each time.

For details please see Table implementation change in 1.0.

### Support for ‘mixin’ columns

Version v1.0 of Astropy introduces a new concept of the “Mixin Column” in tables which allows integration of appropriate non-`Column` based class objects within a `Table` object. These mixin column objects are not converted in any way but are used natively.

The available built-in mixin column classes are `Quantity`, `SkyCoord`, and `Time`. User classes for array-like objects that support the Mixin protocol can also be used in tables as mixin columns.

Warning

While the Astropy developers are excited about this new capability and intend to improve it, the interface for using mixin columns is not stable at this point and it is not recommended for use in production code.

As an example we can create a table and add a time column:

    >>> from astropy.table import Table
    >>> from astropy.time import Time
    >>> t = Table()
    >>> t['index'] = [1, 2]
    >>> t['time'] = Time(['2001-01-02T12:34:56', '2001-02-03T00:01:02'])
    >>> print(t)
    index           time
    ----- -----------------------
        1 2001-01-02T12:34:56.000
        2 2001-02-03T00:01:02.000

The important point here is that the `time` column is a bona fide `Time` object:

    >>> t['time']
    <Time object: scale='utc' format='isot' value=['2001-01-02T12:34:56.000' '2001-02-03T00:01:02.000']>
    >>> t['time'].mjd
    array([ 51911.52425926,  51943.00071759])

For all the details, including a new `QTable` class, please see Mixin columns.

## Integration with WCSAxes

The `WCS` class can now be used as a Matplotlib projection to make plots of images with WCS coordinates overlaid, making use of the WCSAxes affiliated package behind the scenes. More information on using this functionality can be found in the WCSAxes documentation.

## Deprecation and backward-incompatible changes

Astropy is now no longer supported on Python 3.1 and 3.2. Python 3.x users should use Python 3.3 or 3.4. In addition, support for Numpy 1.5 has been dropped, and users should make sure they are using Numpy 1.6 or later.

## Full change log

To see a detailed list of all changes in version v1.0, including changes in API, please see the Full Changelog.