This presentaion is available at the following URL as slides and a notebook at the following URLs:
http://yt-project.org/McMaster_yt_demo/yt_tutorial.slides.html
http://yt-project.org/McMaster_yt_demo/yt_tutorial.ipynb
The data I use in this presentation are available at the following URL:
yt is a framework for working with the ouputs of simulation codes¶
visualization¶
- slices
- projections
- volume rendering
- phase diagrams
analysis¶
- data selection and derived quantities
- low-level data inspection
- halo finding and cataloging
- profiling (how does a quantity vary with radius? density?)
yt supports many production astrophysical simulation codes¶
- SPH
- Patch AMR
- Octree AMR
- Unstructured Mesh
Developed by a global team of astrophysics researchers to solve their real-world problems.¶
| Tom Abel | Andrew Cunningham | Cameron Hummels | Michael Kuhlen | Desika Narayanan | Hsi-Yu Schive | Ting-Wai To |
| Gabriel Altay | Bili Dong | Suoqing Ji | Meagan Lang | Kaylea Nelson | Anthony Scopatz | Joseph Tomlinson |
| Kenza Arraki | Nicholas Earl | Allyson Julian | Eve Lee | Brian O'Shea | Noel Scudder | Stephanie Tonnesen |
| Kirk Barrow | Hilary Egan | Anni Järvenpää | Doris Lee | J.S. Oishi | Sam Skillman | Matthew Turk |
| Ricarda Beckmann | Rasmi Elasmar | Christian Karch | Sam Leitner | JC Passy | Stephen Skory | Casey W. Stark |
| Elliott Biondo | Daniel Fenn | Max Katz | Stuart Levy | John Regan | Aaron Smith | Miguel de Val-Borro |
| Alex Bogert | John Forbes | BW Keller | Yuan Li | Mark Richardson | Britton Smith | Rick Wagner |
| Robert Bradshaw | Sam Geen | Ji-hoon Kim | Joshua Moloney | Sherwood Richers | Geoffrey So | Mike Warren |
| Yi-Hao Chen | Adam Ginsburg | Steffen Klemer | Christopher Moody | Thomas Robitaille | Antoine Strugarek | Andrew Wetzel |
| Pengfei Chen | Nathan Goldbaum | Fabian Koller | Stuart Mumford | Anna Rosen | Elizabeth Tasker | John Wise |
| David Collins | Eric Hallman | Kacper Kowalik | Andrew Myers | Chuck Rozhon | Benjamin Thompson | Michael Zingale |
| Brian Crosby | David Hannasch | Mark Krumholz | Jill Naiman | Douglas Rudd | Robert Thompson | John ZuHone |
In [1]:
from IPython.display import IFrame
IFrame('http://yt-project.org/docs/dev/reference/code_support.html', width=960, height=600)
Out[1]:
Sample datasets loadable by yt¶
In [2]:
IFrame('http://yt-project.org/data', width=700, height=500)
Out[2]:
What is yt?¶
(slides adapted from Britton Smith's PyAstro 16 talk)
Data on disk has no inherent physical meaning¶
yt lets you think about the data using a physically motivated interface¶
yt lets you think about the data using a physically motivated interface¶
In [3]:
import yt
ds = yt.load('GalaxyClusterMerger/fiducial_1to3_b0.273d_hdf5_plt_cnt_0175')
Allowing you to forget about what your data looks like as a file format¶
And select only the data you want to select¶
In [4]:
import yt.units as u
sp = ds.sphere(ds.domain_center, 2*u.Mpc)
yt natively deals with multiresolution data¶
Data from each selected cell is returned as a flat, 1D array, with unit metadata attached¶
In [5]:
print(sp['density'])
Data objects can be queried for many fields¶
In [6]:
print(sp['temperature'])
Data objects can be queried for many fields¶
In [7]:
from pprint import pprint
# fields that are defined in the on-disk data file
pprint(ds.field_list)
Data objects can be queried for many fields¶
In [8]:
# fields that yt can calculate given the fields in ds.field_list
# (only showing gas fields to fit on one screen)
pprint([f for f in ds.derived_field_list if f[0]=='gas'])
Spatial information is not lost¶
In [9]:
sp['x']
Out[9]:
In [10]:
sp['x'].to('kpc')
Out[10]:
Spatial information is not lost¶
In [11]:
import numpy as np
np.unique(sp['dx']).to('kpc')
Out[11]:
Data objects return fields as unit-aware numpy arrays¶
In [12]:
from yt.units import kboltz, mh
pressure = sp['density']*sp['temperature']*kboltz/(0.6*mh)
pressure.in_units('Pa')
Out[12]:
In [13]:
pressure.in_units('dyne/cm**2')
Out[13]:
yt has very flexible handling for units and unit conversions¶
In [14]:
rho = sp['density']
print (rho.to('g/cm**3'))
print ()
print (rho.to('Msun/kpc**3'))
print ()
print (rho.to('code_mass/code_length**3'))
In [15]:
rho + 200*u.Msun/u.kpc**3
Out[15]:
Derived quantities turn fields into single values¶
In [16]:
sp['cell_mass']
Out[16]:
Derived quantities turn fields into single values¶
In [17]:
sp.quantities.total_quantity('cell_mass')
Out[17]:
In [18]:
sp.quantities.angular_momentum_vector()
Out[18]:
In [19]:
IFrame("http://yt-project.org/docs/dev/analyzing/objects.html#available-derived-quantities", width=700, height=600)
Out[19]:
Create new fields by defining a python function¶
In [20]:
def my_entropy(field, data):
return (kboltz * data['temperature'] / data['number_density']**(2/3))
ds.add_field('entropy', function=my_entropy, units="keV*cm**2")
In [21]:
sp['entropy']
Out[21]:
Data Containers¶
In [22]:
ad = ds.all_data()
box = ds.box(ds.domain_left_edge + 500*u.kpc, ds.domain_right_edge - 500*u.kpc)
sp = ds.sphere(ds.domain_center, 500*u.kpc)
disk = ds.disk(ds.domain_center, [0, 0, 1], 500*u.kpc, 100*u.kpc)
ray = ds.ray(ds.domain_left_edge, ds.domain_right_edge)
In [23]:
IFrame("http://yt-project.org/doc/analyzing/objects.html#available-objects", width=700, height=600)
Out[23]:
Particle fields¶
In [24]:
ds = yt.load('FIRE_M12i_ref11/snapshot_600.hdf5')
print(type(ds))
In [25]:
ds.field_list
Out[25]:
In [26]:
ad = ds.all_data()
gas_ppos = ad['PartType0', 'particle_position']
gas_mass = ad['PartType0', 'particle_mass']
dm_ppos = ad['PartType1', 'particle_position']
dm_mass = ad['PartType1', 'particle_mass']
print(gas_ppos, '\n')
print(gas_mass)
In [27]:
print(gas_ppos.shape, gas_mass.shape, '\n')
print(dm_ppos.shape, dm_ppos.shape, '\n')
pprint(ds.particle_type_counts)
Particle unions¶
In [28]:
print(ds.particle_unions)
union = ds.particle_unions['all']
print(union.sub_types)
In [29]:
all_ppos = ad['all', 'particle_position']
print(all_ppos.shape)
In [30]:
from yt.data_objects.particle_unions import \
ParticleUnion
u = ParticleUnion("star", ["PartType2", "PartType4"])
ds.add_particle_union(u)
ad['star', 'particle_mass']
Out[30]:
Particle filters¶
In [31]:
from yt.data_objects.particle_filters import add_particle_filter
def young_star(pfilter, data):
filter = data.ds.current_time - data[pfilter.filtered_type, "creation_time"]
filter.convert_to_units('Myr')
return filter < 10
add_particle_filter("young_stars", function=young_star, filtered_type='io',
requires=["creation_time"])
In [32]:
ds = yt.load('DD0600/DD0600')
ds.add_particle_filter('young_stars')
ad = ds.all_data()
print(ad['io', 'particle_mass'].shape)
print(ad['young_stars', 'particle_mass'].shape)
This uses ParticlePlot, a new feature in yt 3.3
In [33]:
from yt import ParticlePlot
p = ParticlePlot(ds,
('young_stars', 'particle_position_x'),
('young_stars', 'particle_position_y'),
('young_stars', 'particle_mass'),
width=(10, 'kpc'))
p.set_unit(('young_stars', 'particle_mass'), 'Msun')
Out[33]:
What can we do using this language of fields and data objects?¶
Visualization and analysis¶
- SlicePlot, ProjectionPlot, ProfilePlot, PhasePlot
- ParticlePlot, ParticlePhasePlot
- Slices, projections, profiles, covering grids, and fixed resolution buffers
Halo analysis¶
- Support for FOF, HOP, and Rockstar halo finders
- Halo catalogs
Volume rendering¶
- Pretty pictures!
- Software volume renderer and OpenGL interactive volume rendering
SlicePlot¶
In [34]:
from yt import SlicePlot
ds = yt.load('DD0600/DD0600')
SlicePlot(ds, 2, ('gas', 'density'))
Out[34]:
In [35]:
slc = SlicePlot(ds, 2, 'density', width=(15, 'kpc'), center='m')
slc.show()
In [36]:
slc.set_origin('native')
Out[36]:
In [37]:
slc.set_cmap('density', 'magma')
Out[37]:
Plot callbacks¶
In [38]:
slc.annotate_grids()
Out[38]:
In [39]:
slc.save('my_amazing_plot.eps')
Out[39]:
In [40]:
slc.save('my_amazing_plot.png')
Out[40]:
In [41]:
from yt import ProjectionPlot
prj = ProjectionPlot(ds, 2, 'density')
In [42]:
prj
Out[42]:
In [43]:
prj.zoom(20)
Out[43]:
In [44]:
prj.zoom(3)
Out[44]:
In [45]:
dd = ds.sphere(ds.domain_center, (30, 'kpc'))
prj = ProjectionPlot(ds, 2, 'density', data_source=dd, width=(80, 'kpc'))
prj.set_zlim('density', 1e-4, 1e0)
Out[45]:
In [46]:
ProjectionPlot(ds, 2, 'density', max_level=5, width=(80, 'kpc'))
Out[46]:
In [47]:
ProjectionPlot(ds, 2, 'temperature', weight_field='density', width=(15, 'kpc'))
Out[47]:
In [48]:
ProjectionPlot(ds, 2, 'density', width=(15, 'kpc'), method='mip')
Out[48]:
In [49]:
import numexpr as ne
from yt.units import G
from numpy import pi
def _total_dynamical_time(field, data):
dens = data['density']
dmd = data['dark_matter_density']
dens.convert_to_cgs()
dmd.convert_to_cgs()
tdyn = ne.evaluate("sqrt(3*pi/(32*G*(dens + dmd)))")
tdyn = tdyn*yt.units.s
return tdyn
def _sfr(field, data):
dens = data['density']
tdyn = data['total_dynamical_time']
Mu = np.float64(data.ds.parameters['Mu'])
dens.convert_to_cgs()
tdyn.convert_to_cgs()
sfr = ne.evaluate("where(dens*Mu/mh > 50, 0.01*dens/tdyn, 0)")
sfr = sfr*(yt.units.g/yt.units.cm**3/yt.units.s)
return sfr
ds.add_field('total_dynamical_time', _total_dynamical_time, units='s')
ds.add_field('sfr_density', _sfr, units='g/cm**3/s')
In [50]:
prj = yt.ProjectionPlot(ds, 2, 'sfr_density', width=(10, 'kpc'))
prj.set_unit('sfr_density', 'Msun/kpc**2/yr')
prj.set_zlim('sfr_density', 1e-1, 3e1)
Out[50]:
PhasePlot and ProfilePlot¶
In [51]:
from yt import PhasePlot
PhasePlot(ds.all_data(), 'density', 'temperature', 'cell_mass',
weight_field=None, fractional=True)
Out[51]:
Analysis¶
- Profiles
- covering grids
- Many more that I don't have time to talk about in detail
Profiles¶
Profiles can create a 1D, 2D, or 3D histogram of a field versus a set of other fields.
We already saw a 2D histogram above when we made a PhasePlot of density, temperature, and cell mass
We can use profiles to calculate the average value or total of a field vs another field.
In [52]:
from yt import create_profile
sph = ds.sphere(ds.domain_center, (15, 'kpc'))
profile = create_profile(sph, ('radius'), ('sfr_density'), logs={'radius': False})
In [53]:
%matplotlib inline
from matplotlib import pyplot as plt
plt.plot(profile.x.to('kpc'), profile['sfr_density'].to('Msun/kpc**3/yr'))
plt.xlabel('Radius (kpc)')
plt.ylabel(r'$\Sigma_{\rm{SFR}}\ (M_\odot kpc^{-3} yr^{-1}))$')
Out[53]:
Covering grids¶
Covering grids are a uniform resolution 3D representation of a yt dataset. Very useful for analysis tools that expect a uniform resolution grid, or for simplifying analysis to avoid thinking about AMR.
In [54]:
ds = yt.load('output_00080/info_00080.txt')
SlicePlot(ds, 2, 'density', center=[0.5, 0.5, 0.75])
Out[54]:
In [55]:
# create covering grid of density at AMR level 0
cgrid = ds.covering_grid(0, left_edge=[0, 0, 0], dims=[64, 64, 64])
density_field = cgrid["density"]
print (density_field.shape)
plt.imshow(np.log10(density_field[:,:,48].v), interpolation='none')
plt.show()
Analysis Modules¶
In [57]:
IFrame("http://yt-project.org/docs/dev/analyzing/analysis_modules/index.html", width=700, height=600)
Out[57]:
Spinoffs¶
In [59]:
IFrame("http://caesar.readthedocs.io/en/latest/", width=700, height=600)
Out[59]:
In [60]:
IFrame("http://trident-project.org/", width=700, height=600)
Out[60]:
Coming soon¶
- Improved Scalability for Particle Codes
- First-class support for unstructured meshes
- Improved volume rendering interface
- Support for more kinds of synthetic observations
Community¶
- 20,304 changesets since 2007 by 108 unique contributors
- 350 subscribers to users mailing list, 120 subscribers to developer mailing list
- Funding for aspects of yt development comes from the NSF, NASA and the Gordon and Betty Moore Foundation
In [61]:
IFrame("https://www.openhub.net/p/yt_amr", width=700, height=600)
Out[61]:
Getting involved and asking for help¶
Documentation: http://yt-project.org/doc
Users mailing list: http://lists.spacepope.org/listinfo.cgi/yt-users-spacepope.org
Developer mailing list: http://lists.spacepope.org/listinfo.cgi/yt-dev-spacepope.org
Developer guide: http://yt-project.org/docs/dev/developing/index.html
Slack Channel: https://yt-project.slack.com
IRC Channel: http://yt-project.org/irc.html (or #yt on freenode with your favorite IRC client)