[yt-svn] commit/yt: 4 new changesets
commits-noreply at bitbucket.org
commits-noreply at bitbucket.org
Thu Jul 24 10:28:54 PDT 2014
4 new commits in yt:
https://bitbucket.org/yt_analysis/yt/commits/8a3510414a12/
Changeset: 8a3510414a12
Branch: yt-3.0
User: mzingale
Date: 2014-07-24 16:53:25
Summary: add a new recipe with annotated volume rendering
Affected #: 2 files
diff -r 58f37beaba3c763150dc4b1a83debafc5e8f63c8 -r 8a3510414a12eaf31249f043e524ef98e091ae50 doc/source/cookbook/complex_plots.rst
--- a/doc/source/cookbook/complex_plots.rst
+++ b/doc/source/cookbook/complex_plots.rst
@@ -194,6 +194,15 @@
.. yt_cookbook:: rendering_with_box_and_grids.py
+Volume Rendering with Annotation
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+This recipe demonstrates how to write the simulation time, show an
+axis triad indicating the direction of the coordinate system, and show
+the transfer function on a volume rendering.
+
+.. yt_cookbook:: vol-annotated.py
+
Plotting Streamlines
~~~~~~~~~~~~~~~~~~~~
diff -r 58f37beaba3c763150dc4b1a83debafc5e8f63c8 -r 8a3510414a12eaf31249f043e524ef98e091ae50 doc/source/cookbook/vol-annotated.py
--- /dev/null
+++ b/doc/source/cookbook/vol-annotated.py
@@ -0,0 +1,74 @@
+#!/usr/bin/env python
+
+import pylab
+
+from yt.mods import *
+import yt.visualization.volume_rendering.api as vr
+
+ds = load("maestro_subCh_plt00248")
+
+dd = ds.h.all_data()
+
+# field in the dataset we will visualize
+field = ('boxlib', 'radial_velocity')
+
+# the values we wish to highlight in the rendering. We'll put a Gaussian
+# centered on these with width sigma
+vals = [-1.e7, -5.e6, -2.5e6, 2.5e6, 5.e6, 1.e7]
+sigma = 2.e5
+
+mi, ma = min(vals), max(vals)
+
+# Instantiate the ColorTransferfunction.
+tf = vr.ColorTransferFunction((mi, ma))
+
+for v in vals:
+ tf.sample_colormap(v, sigma**2, colormap="coolwarm")
+
+
+# volume rendering requires periodic boundaries. This dataset has
+# solid walls. We need to hack it for now (this will be fixed in
+# a later yt)
+ds.periodicity = (True, True, True)
+
+
+# Set up the camera parameters: center, looking direction, width, resolution
+c = np.array([0.0, 0.0, 0.0])
+L = np.array([1.0, 1.0, 1.2])
+W = 1.5*ds.domain_width
+N = 720
+
+# +z is "up" for our dataset
+north=[0.0,0.0,1.0]
+
+# Create a camera object
+cam = vr.Camera(c, L, W, N, transfer_function=tf, ds=ds,
+ no_ghost=False, north_vector=north,
+ fields = [field], log_fields = [False])
+
+im = cam.snapshot()
+
+# add an axes triad
+cam.draw_coordinate_vectors(im)
+
+# add the domain box to the image
+nim = cam.draw_domain(im)
+
+# increase the contrast -- for some reason, the enhance default
+# to save_annotated doesn't do the trick
+max_val = im[:,:,:3].std() * 4.0
+nim[:,:,:3] /= max_val
+
+# we want to write the simulation time on the figure, so create a
+# figure and annotate it
+f = pylab.figure()
+
+pylab.text(0.2, 0.85, "{:.3g} s".format(float(ds.current_time.d)),
+ transform=f.transFigure, color="white")
+
+# tell the camera to use our figure
+cam._render_figure = f
+
+# save annotated -- this added the transfer function values,
+# and the clear_fig=False ensures it writes onto our existing figure.
+cam.save_annotated("vol_annotated.png", nim, dpi=145, clear_fig=False)
https://bitbucket.org/yt_analysis/yt/commits/7f1ce77e7254/
Changeset: 7f1ce77e7254
Branch: yt-3.0
User: mzingale
Date: 2014-07-24 17:08:02
Summary: remove .h
Affected #: 1 file
diff -r 8a3510414a12eaf31249f043e524ef98e091ae50 -r 7f1ce77e725411505608ea2f0770a15f733316df doc/source/cookbook/vol-annotated.py
--- a/doc/source/cookbook/vol-annotated.py
+++ b/doc/source/cookbook/vol-annotated.py
@@ -7,7 +7,7 @@
ds = load("maestro_subCh_plt00248")
-dd = ds.h.all_data()
+dd = ds.all_data()
# field in the dataset we will visualize
field = ('boxlib', 'radial_velocity')
https://bitbucket.org/yt_analysis/yt/commits/04c7e205efec/
Changeset: 04c7e205efec
Branch: yt-3.0
User: mzingale
Date: 2014-07-24 19:07:21
Summary: don't import *, just import yt
Affected #: 1 file
diff -r 7f1ce77e725411505608ea2f0770a15f733316df -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 doc/source/cookbook/vol-annotated.py
--- a/doc/source/cookbook/vol-annotated.py
+++ b/doc/source/cookbook/vol-annotated.py
@@ -1,11 +1,12 @@
#!/usr/bin/env python
+import numpy as np
import pylab
-from yt.mods import *
+import yt
import yt.visualization.volume_rendering.api as vr
-ds = load("maestro_subCh_plt00248")
+ds = yt.load("maestro_subCh_plt00248")
dd = ds.all_data()
https://bitbucket.org/yt_analysis/yt/commits/6dfe7fd6f909/
Changeset: 6dfe7fd6f909
Branch: yt-3.0
User: mzingale
Date: 2014-07-24 19:09:22
Summary: merge
Affected #: 28 files
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 doc/source/analyzing/analysis_modules/radial_column_density.rst
--- a/doc/source/analyzing/analysis_modules/radial_column_density.rst
+++ b/doc/source/analyzing/analysis_modules/radial_column_density.rst
@@ -5,6 +5,14 @@
.. sectionauthor:: Stephen Skory <s at skory.us>
.. versionadded:: 2.3
+.. note::
+
+ As of :code:`yt-3.0`, the radial column density analysis module is not
+ currently functional. This functionality is still available in
+ :code:`yt-2.x`. If you would like to use these features in :code:`yt-3.x`,
+ help is needed to port them over. Contact the yt-users mailing list if you
+ are interested in doing this.
+
This module allows the calculation of column densities around a point over a
field such as ``NumberDensity`` or ``Density``.
This uses :ref:`healpix_volume_rendering` to interpolate column densities
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 doc/source/analyzing/analysis_modules/radmc3d_export.rst
--- a/doc/source/analyzing/analysis_modules/radmc3d_export.rst
+++ b/doc/source/analyzing/analysis_modules/radmc3d_export.rst
@@ -6,6 +6,14 @@
.. sectionauthor:: Andrew Myers <atmyers2 at gmail.com>
.. versionadded:: 2.6
+.. note::
+
+ As of :code:`yt-3.0`, the radial column density analysis module is not
+ currently functional. This functionality is still available in
+ :code:`yt-2.x`. If you would like to use these features in :code:`yt-3.x`,
+ help is needed to port them over. Contact the yt-users mailing list if you
+ are interested in doing this.
+
`RADMC-3D
<http://www.ita.uni-heidelberg.de/~dullemond/software/radmc-3d/>`_ is a three-dimensional Monte-Carlo radiative transfer code
that is capable of handling both line and continuum emission. The :class:`~yt.analysis_modules.radmc3d_export.RadMC3DInterface.RadMC3DWriter`
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 doc/source/analyzing/analysis_modules/star_analysis.rst
--- a/doc/source/analyzing/analysis_modules/star_analysis.rst
+++ b/doc/source/analyzing/analysis_modules/star_analysis.rst
@@ -5,6 +5,14 @@
.. sectionauthor:: Stephen Skory <sskory at physics.ucsd.edu>
.. versionadded:: 1.6
+.. note::
+
+ As of :code:`yt-3.0`, the star particle analysis module is not currently
+ functional. This functionality is still available in :code:`yt-2.x`. If
+ you would like to use these features in :code:`yt-3.x`, help is needed to
+ port them over. Contact the yt-users mailing list if you are interested in
+ doing this.
+
This document describes tools in yt for analyzing star particles.
The Star Formation Rate tool bins stars by time to produce star formation
statistics over several metrics.
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 doc/source/analyzing/analysis_modules/sunrise_export.rst
--- a/doc/source/analyzing/analysis_modules/sunrise_export.rst
+++ b/doc/source/analyzing/analysis_modules/sunrise_export.rst
@@ -6,6 +6,13 @@
.. sectionauthor:: Christopher Moody <cemoody at ucsc.edu>
.. versionadded:: 1.8
+.. note::
+
+ As of :code:`yt-3.0`, the sunrise exporter is not currently functional.
+ This functionality is still available in :code:`yt-2.x`. If you would like
+ to use these features in :code:`yt-3.x`, help is needed to port them over.
+ Contact the yt-users mailing list if you are interested in doing this.
+
The yt-Sunrise exporter essentially takes grid cell data and translates it into a binary octree format, attaches star particles, and saves the output to a FITS file Sunrise can read. For every cell, the gas mass, metals mass (a fraction of which is later assumed to be in the form of dust), and the temperature are saved. Star particles are defined entirely by their mass, position, metallicity, and a 'radius.' This guide outlines the steps to exporting the data, troubleshoots common problems, and reviews recommended sanity checks.
Simple Export
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 doc/source/analyzing/analysis_modules/two_point_functions.rst
--- a/doc/source/analyzing/analysis_modules/two_point_functions.rst
+++ b/doc/source/analyzing/analysis_modules/two_point_functions.rst
@@ -5,6 +5,14 @@
.. sectionauthor:: Stephen Skory <sskory at physics.ucsd.edu>
.. versionadded:: 1.7
+.. note::
+
+ As of :code:`yt-3.0`, the two point function analysis module is not
+ currently functional. This functionality is still available in
+ :code:`yt-2.x`. If you would like to use these features in :code:`yt-3.x`,
+ help is needed to port them over. Contact the yt-users mailing list if you
+ are interested in doing this.
+
The Two Point Functions framework (TPF) is capable of running several
multi-dimensional two point functions simultaneously on a dataset using
memory and workload parallelism.
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 doc/source/analyzing/fields.rst
--- a/doc/source/analyzing/fields.rst
+++ b/doc/source/analyzing/fields.rst
@@ -1,19 +1,22 @@
Particle Fields
-====================================
+===============
+
Naturally, particle fields contain properties of particles rather than
grid cells. Many of these fields have corresponding grid fields that
can be populated by "depositing" the particle values onto a yt grid.
General Particle Fields
-------------------------------------
+-----------------------
+
Every particle will contain both a ``particle_position`` and ``particle_velocity``
that tracks the position and velocity (respectively) in code units.
SPH Fields
-------------------------------------
+----------
+
For gas particles from SPH simulations, each particle will typically carry
-a field for the smoothing length `h`, which is roughly equivalent to
-`(m/\rho)^{1/3}`, where `m` and `rho` are the particle mass and density
+a field for the smoothing length ``h``, which is roughly equivalent to
+``(m/\rho)^{1/3}``, where ``m`` and ``rho`` are the particle mass and density
respectively. This can be useful for doing neighbour finding.
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 doc/source/analyzing/parallel_computation.rst
--- a/doc/source/analyzing/parallel_computation.rst
+++ b/doc/source/analyzing/parallel_computation.rst
@@ -84,6 +84,7 @@
import yt
yt.enable_parallelism()
+
ds = yt.load("RD0035/RedshiftOutput0035")
v, c = ds.find_max("density")
print v, c
@@ -125,6 +126,8 @@
.. code-block:: python
import yt
+ yt.enable_parallelism()
+
ds = yt.load("RD0035/RedshiftOutput0035")
v, c = ds.find_max("density")
p = yt.ProjectionPlot(ds, "x", "density")
@@ -143,6 +146,7 @@
.. code-block:: python
import yt
+ yt.enable_parallelism()
def print_and_save_plot(v, c, plot, print=True):
if print:
@@ -216,6 +220,7 @@
# As always...
import yt
+ yt.enable_parallelism()
import glob
@@ -314,6 +319,8 @@
.. code-block:: python
import yt
+ yt.enable_parallelism()
+
ts = yt.DatasetSeries("DD*/output_*", parallel = 4)
for ds in ts.piter():
@@ -478,6 +485,8 @@
import yt
import time
+ yt.enable_parallelism()
+
ds = yt.load("DD0152")
t0 = time.time()
bigstuff, hugestuff = StuffFinder(ds)
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 doc/source/analyzing/units/index.rst
--- a/doc/source/analyzing/units/index.rst
+++ b/doc/source/analyzing/units/index.rst
@@ -12,9 +12,9 @@
and execute the documentation interactively, you need to download the repository
and start the IPython notebook.
-If you installed `yt` using the install script, you will need to navigate to
-:code:`$YT_DEST/src/yt-hg/doc/source/units`, then start an IPython notebook
-server:
+You will then need to navigate to :code:`$YT_HG/doc/source/units` (where $YT_HG
+is the location of a clone of the yt mercurial repository), and then start an
+IPython notebook server:
.. code:: bash
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 doc/source/cookbook/index.rst
--- a/doc/source/cookbook/index.rst
+++ b/doc/source/cookbook/index.rst
@@ -44,3 +44,4 @@
../analyzing/analysis_modules/sunyaev_zeldovich
fits_radio_cubes
fits_xray_images
+ tipsy_notebook
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 doc/source/cookbook/tipsy_and_yt.ipynb
--- /dev/null
+++ b/doc/source/cookbook/tipsy_and_yt.ipynb
@@ -0,0 +1,196 @@
+{
+ "metadata": {
+ "name": "",
+ "signature": "sha256:2ae8b1599fa35495fa1bb8deb1c67094e3529e70093b30e20354122cd9403d9d"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "Using yt to view and analyze Tipsy outputs from Gasoline"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Loading Files"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Alright, let's start with some basics. Before we do anything, we will need to load a snapshot. You can do this using the ```load``` convenience function. yt will autodetect that you have a tipsy snapshot, and automatically set itself up appropriately."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import yt"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We will be looking at a fairly low resolution dataset. In the next cell, the `ds` object has an atribute called `n_ref` that tells the oct-tree how many particles to refine on. The default is 64, but we'll get prettier plots (at the expense of a deeper tree) with 8. Just passing the argument `n_ref=8` to load does this for us."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ ">This dataset is available for download at http://yt-project.org/data/TipsyGalaxy.tar.gz (10 MB)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "ds = yt.load('TipsyGalaxy/galaxy.00300', n_ref=8)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We now have a `TipsyDataset` object called `ds`. Let's see what fields it has."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "ds.field_list"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "`yt` also defines so-called \"derived\" fields. These fields are functions of the on-disk fields that live in the `field_list`. There is a `derived_field_list` attribute attached to the `Dataset` object - let's take look at the derived fields in this dataset:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "ds.derived_field_list"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "All of the field in the `field_list` are arrays containing the values for the associated particles. These haven't been smoothed or gridded in any way. We can grab the array-data for these particles using `ds.all_data()`. For example, let's take a look at a temperature-colored scatterplot of the gas particles in this output."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "%matplotlib inline\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "dd = ds.all_data()\n",
+ "xcoord = dd['Gas','Coordinates'][:,0].v\n",
+ "ycoord = dd['Gas','Coordinates'][:,1].v\n",
+ "logT = np.log10(dd['Gas','Temperature'])\n",
+ "plt.scatter(xcoord, ycoord, c=logT, s=2*logT, marker='o', edgecolor='none', vmin=2, vmax=6)\n",
+ "plt.xlim(-20,20)\n",
+ "plt.ylim(-20,20)\n",
+ "cb = plt.colorbar()\n",
+ "cb.set_label('$\\log_{10}$ Temperature')\n",
+ "plt.gcf().set_size_inches(15,10)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": []
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Making Smoothed Images"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "`yt` will automatically generate smoothed versions of these fields that you can use to plot. Let's make a temperature slice and a density projection."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "yt.SlicePlot(ds, 'z', ('gas','density'), width=(40, 'kpc'), center='m')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "yt.ProjectionPlot(ds, 'z', ('gas','density'), width=(40, 'kpc'), center='m')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Not only are the values in the tipsy snapshot read and automatically smoothed, the auxiliary files that have physical significance are also smoothed. Let's look at a slice of Iron mass fraction."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "yt.SlicePlot(ds, 'z', ('gas', 'FeMassFrac'), width=(40, 'kpc'), center='m')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": []
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 doc/source/cookbook/tipsy_notebook.rst
--- /dev/null
+++ b/doc/source/cookbook/tipsy_notebook.rst
@@ -0,0 +1,7 @@
+.. _tipsy-notebook:
+
+Using yt to view and analyze Tipsy outputs from Gasoline
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+.. notebook:: tipsy_and_yt.ipynb
+
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 doc/source/developing/building_the_docs.rst
--- a/doc/source/developing/building_the_docs.rst
+++ b/doc/source/developing/building_the_docs.rst
@@ -55,11 +55,11 @@
.. code-block:: bash
- cd $YT_DEST/src/yt-hg/doc
+ cd $YT_HG/doc
make html
This will produce an html version of the documentation locally in the
-``$YT_DEST/src/yt-hg/doc/build/html`` directory. You can now go there and open
+``$YT_HG/doc/build/html`` directory. You can now go there and open
up ``index.html`` or whatever file you wish in your web browser.
Building the docs (full)
@@ -116,7 +116,7 @@
.. code-block:: bash
- cd $YT_DEST/src/yt-hg/doc
+ cd $YT_HG/doc
make html
If all of the dependencies are installed and all of the test data is in the
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 doc/source/developing/developing.rst
--- a/doc/source/developing/developing.rst
+++ b/doc/source/developing/developing.rst
@@ -165,10 +165,15 @@
Only one of these two options is needed.
-If you plan to develop yt on Windows, we recommend using the `MinGW <http://www.mingw.org/>`_ gcc
-compiler that can be installed using the `Anaconda Python
-Distribution <https://store.continuum.io/cshop/anaconda/>`_. Also, the syntax for the
-setup command is slightly different; you must type:
+.. _windows-developing:
+
+Developing yt on Windows
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+If you plan to develop yt on Windows, we recommend using the `MinGW
+<http://www.mingw.org/>`_ gcc compiler that can be installed using the `Anaconda
+Python Distribution <https://store.continuum.io/cshop/anaconda/>`_. Also, the
+syntax for the setup command is slightly different; you must type:
.. code-block:: bash
@@ -185,17 +190,24 @@
Making and Sharing Changes
++++++++++++++++++++++++++
-The simplest way to submit changes to yt is to commit changes in your
-``$YT_DEST/src/yt-hg`` directory, fork the repository on BitBucket, push the
-changesets to your fork, and then issue a pull request.
+The simplest way to submit changes to yt is to do the following:
+
+ * Build yt from the mercurial repository
+ * Navigate to the root of the yt repository
+ * Make some changes and commit them
+ * Fork the `yt repository on BitBucket <https://bitbucket.org/yt_analysis/yt>`_
+ * Push the changesets to your fork
+ * Issue a pull request.
Here's a more detailed flowchart of how to submit changes.
#. If you have used the installation script, the source code for yt can be
- found in ``$YT_DEST/src/yt-hg``. (Below, in :ref:`reading-source`,
- we describe how to find items of interest.) Edit the source file you are
- interested in and test your changes. (See :ref:`testing` for more
- information.)
+ found in ``$YT_DEST/src/yt-hg``. Alternatively see
+ :ref:`source-installation` for instructions on how to build yt from the
+ mercurial repository. (Below, in :ref:`reading-source`, we describe how to
+ find items of interest.)
+ #. Edit the source file you are interested in and
+ test your changes. (See :ref:`testing` for more information.)
#. Fork yt on BitBucket. (This step only has to be done once.) You can do
this at: https://bitbucket.org/yt_analysis/yt/fork . Call this repository
``yt``.
@@ -207,7 +219,7 @@
these changes as well.
#. Push your changes to your new fork using the command::
- hg push https://bitbucket.org/YourUsername/yt/
+ hg push -r . https://bitbucket.org/YourUsername/yt/
If you end up doing considerable development, you can set an alias in the
file ``.hg/hgrc`` to point to this path.
@@ -244,9 +256,9 @@
include a recipe in the cookbook section, or it could simply be adding a note
in the relevant docs text somewhere.
-The documentation exists in the main mercurial code repository for yt in the
-``doc`` directory (i.e. ``$YT_DEST/src/yt-hg/doc/source`` on systems installed
-using the installer script). It is organized hierarchically into the main
+The documentation exists in the main mercurial code repository for yt in the
+``doc`` directory (i.e. ``$YT_HG/doc/source`` where ``$YT_HG`` is the path of
+the yt mercurial repository). It is organized hierarchically into the main
categories of:
* Visualizing
@@ -345,16 +357,6 @@
yt``), then you must "activate" it using the following commands from within the
repository directory.
-In order to do this for the first time with a new repository, you have to
-copy some config files over from your yt installation directory (where yt
-was initially installed from the install_script.sh). Try this:
-
-.. code-block:: bash
-
- $ cp $YT_DEST/src/yt-hg/*.cfg <REPOSITORY_NAME>
-
-and then every time you want to "activate" a different repository of yt.
-
.. code-block:: bash
$ cd <REPOSITORY_NAME>
@@ -367,11 +369,16 @@
How To Read The Source Code
---------------------------
-If you just want to *look* at the source code, you already have it on your
-computer. Go to the directory where you ran the install_script.sh, then
-go to ``$YT_DEST/src/yt-hg`` . In this directory are a number of
-subdirectories with different components of the code, although most of them
-are in the yt subdirectory. Feel free to explore here.
+If you just want to *look* at the source code, you may already have it on your
+computer. If you build yt using the install script, the source is available at
+``$YT_DEST/src/yt-hg``. See :ref:`source-installation` for more details about
+to obtain the yt source code if you did not build yt using the install
+script.
+
+The root directory of the yt mercurial repository contains a number of
+subdirectories with different components of the code. Most of the yt source
+code is contained in the ``yt`` subdirectory. This directory its self contains
+the following subdirectories:
``frontends``
This is where interfaces to codes are created. Within each subdirectory of
@@ -380,10 +387,19 @@
* ``data_structures.py``, where subclasses of AMRGridPatch, Dataset
and AMRHierarchy are defined.
* ``io.py``, where a subclass of IOHandler is defined.
+ * ``fields.py``, where fields we expect to find in datasets are defined
* ``misc.py``, where any miscellaneous functions or classes are defined.
* ``definitions.py``, where any definitions specific to the frontend are
defined. (i.e., header formats, etc.)
+ ``fields``
+ This is where all of the derived fields that ship with yt are defined.
+
+ ``geometry``
+ This is where geometric helpler routines are defined. Handlers
+ for grid and oct data, as well as helpers for coordinate transformations
+ can be found here.
+
``visualization``
This is where all visualization modules are stored. This includes plot
collections, the volume rendering interface, and pixelization frontends.
@@ -409,6 +425,10 @@
All broadly useful code that doesn't clearly fit in one of the other
categories goes here.
+ ``extern``
+ Bundled external modules (i.e. code that was not written by one of
+ the yt authors but that yt depends on) lives here.
+
If you're looking for a specific file or function in the yt source code, use
the unix find command:
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 doc/source/developing/intro.rst
--- a/doc/source/developing/intro.rst
+++ b/doc/source/developing/intro.rst
@@ -66,11 +66,11 @@
typo or grammatical fixes, adding a FAQ, or increasing coverage of
functionality, it would be very helpful if you wanted to help out.
-The easiest way to help out is to fork the main yt repository (where
-the documentation lives in the ``$YT_DEST/src/yt-hg/doc`` directory,
-and then make your changes in your own fork. When you are done, issue a pull
-request through the website for your new fork, and we can comment back and
-forth and eventually accept your changes.
+The easiest way to help out is to fork the main yt repository (where the
+documentation lives in the ``doc`` directory in the root of the yt mercurial
+repository) and then make your changes in your own fork. When you are done,
+issue a pull request through the website for your new fork, and we can comment
+back and forth and eventually accept your changes.
One of the more interesting ways we are attempting to do lately is to add
screencasts to the documentation -- these are recordings of people executing
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 doc/source/developing/testing.rst
--- a/doc/source/developing/testing.rst
+++ b/doc/source/developing/testing.rst
@@ -59,11 +59,13 @@
$ cd $YT_HG
$ nosetests
+where ``$YT_HG`` is the path to the root of the yt mercurial repository.
+
If you want to specify a specific unit test to run (and not run the entire
suite), you can do so by specifying the path of the test relative to the
-``$YT_DEST/src/yt-hg/yt`` directory -- note that you strip off one ``yt`` more
-than you normally would! For example, if you want to run the
-plot_window tests, you'd run:
+``$YT_HG/yt`` directory -- note that you strip off one ``yt`` more than you
+normally would! For example, if you want to run the plot_window tests, you'd
+run:
.. code-block:: bash
@@ -172,7 +174,7 @@
$ nosetests --with-answer-testing
In either case, the current gold standard results will be downloaded from the
-amazon cloud and compared to what is generated locally. The results from a
+rackspace cloud and compared to what is generated locally. The results from a
nose testing session are pretty straightforward to understand, the results for
each test are printed directly to STDOUT. If a test passes, nose prints a
period, F if a test fails, and E if the test encounters an exception or errors
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 doc/source/examining/generic_particle_data.rst
--- /dev/null
+++ b/doc/source/examining/generic_particle_data.rst
@@ -0,0 +1,6 @@
+.. _genertic-particle-data:
+
+Loading Generic Particle Data
+-----------------------------
+
+.. notebook:: Loading_Generic_Particle_Data.ipynb
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 doc/source/examining/loading_data.rst
--- a/doc/source/examining/loading_data.rst
+++ b/doc/source/examining/loading_data.rst
@@ -391,10 +391,7 @@
These will be used set the units, if they are specified.
-Using yt to view and analyze Tipsy outputs from Gasoline
-++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-.. notebook:: tipsy_and_yt.ipynb
+See :ref:`tipsy-notebook` for more details.
.. _loading-artio-data:
@@ -839,7 +836,8 @@
Generic Array Data
------------------
-See :ref:`loading-numpy-array` for more detail.
+See :ref:`loading-numpy-array` and
+:ref:`~yt.frontends.stream.data_structures.load_uniform_grid` for more detail.
Even if your data is not strictly related to fields commonly used in
astrophysical codes or your code is not supported yet, you can still feed it to
@@ -892,7 +890,8 @@
Generic AMR Data
----------------
-See :ref:`loading-numpy-array` for more detail.
+See :ref:`loading-numpy-array` and
+:ref:`~yt.frontends.sph.data_structures.load_amr_grids` for more detail.
It is possible to create native ``yt`` dataset from Python's dictionary
that describes set of rectangular patches of data of possibly varying
@@ -944,21 +943,72 @@
Generic Particle Data
---------------------
-.. notebook:: Loading_Generic_Particle_Data.ipynb
+See :ref:`generic-particle-data` and
+:ref:`~yt.frontends.stream.data_structures.load_particles` for more detail.
+
+You can also load generic particle data using the same ``stream`` functionality
+discussed above to load in-memory grid data. For example, if your particle
+positions and masses are stored in ``positions`` and ``massess``, a
+vertically-stacked array of particle x,y, and z positions, and a 1D array of
+particle masses respectively, you would load them like this:
+
+.. code-block:: python
+
+ import yt
+
+ data = dict(particle_position=positions, particle_mass=masses)
+ ds = yt.load_particles(data)
+
+You can also load data using 1D x, y, and z position arrays:
+
+.. code-block:: python
+
+ import yt
+
+ data = dict(particle_position_x=posx,
+ particle_position_y=posy,
+ particle_position_z=posz,
+ particle_mass=masses)
+ ds = yt.load_particles(data)
+
+The ``load_particles`` function also accepts the following keyword parameters:
+
+ ``length_unit``
+ The units used for particle positions.
+
+ ``mass_unit``
+ The units of the particle masses.
+
+ ``time_unit``
+ The units used to represent times. This is optional and is only used if
+ your data contains a ``creation_time`` field or a ``particle_velocity`` field.
+
+ ``velocity_unit``
+ The units used to represent velocities. This is optional and is only used
+ if you supply a velocity field. If this is not supplied, it is inferred from
+ the length and time units.
+
+ ``bbox``
+ The bounding box for the particle positions.
.. _loading_sph_data:
SPH Particle Data
-----------------
-For all of the SPH frontends, yt uses a cython-based SPH to created deposit
-mesh fields from individual particle fields. This uses a standard M4 smoothing
-kernel and the ``SmoothingLength`` field to calculate SPH sums, filling in the
-mesh fields. This gives you the ability to both track individual particles
-(useful for tasks like following contiguous clouds of gas that would be require
-a clump finder in grid data) as well as doing standard grid-based analysis.
-The ``SmoothingLength`` variable is also useful for determining which particles
+
+For all of the SPH frontends, yt uses cython-based SPH smoothing onto an
+in-memory octree to create deposited mesh fields from individual SPH particle
+fields.
+
+This uses a standard M4 smoothing kernel and the ``smoothing_length``
+field to calculate SPH sums, filling in the mesh fields. This gives you the
+ability to both track individual particles (useful for tasks like following
+contiguous clouds of gas that would be require a clump finder in grid data) as
+well as doing standard grid-based analysis (i.e. slices, projections, and profiles).
+
+The ``smoothing_length`` variable is also useful for determining which particles
can interact with each other, since particles more distant than twice the
smoothing length do not typically see each other in SPH simulations. By
-changing the value of the ``SmoothingLength`` and then re-depositing particles
+changing the value of the ``smoothing_length`` and then re-depositing particles
onto the grid, you can also effectively mimic what your data would look like at
lower resolution.
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 doc/source/examining/tipsy_and_yt.ipynb
--- a/doc/source/examining/tipsy_and_yt.ipynb
+++ /dev/null
@@ -1,196 +0,0 @@
-{
- "metadata": {
- "name": "",
- "signature": "sha256:2ae8b1599fa35495fa1bb8deb1c67094e3529e70093b30e20354122cd9403d9d"
- },
- "nbformat": 3,
- "nbformat_minor": 0,
- "worksheets": [
- {
- "cells": [
- {
- "cell_type": "heading",
- "level": 1,
- "metadata": {},
- "source": [
- "Using yt to view and analyze Tipsy outputs from Gasoline"
- ]
- },
- {
- "cell_type": "heading",
- "level": 2,
- "metadata": {},
- "source": [
- "Loading Files"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Alright, let's start with some basics. Before we do anything, we will need to load a snapshot. You can do this using the ```load``` convenience function. yt will autodetect that you have a tipsy snapshot, and automatically set itself up appropriately."
- ]
- },
- {
- "cell_type": "code",
- "collapsed": false,
- "input": [
- "import yt"
- ],
- "language": "python",
- "metadata": {},
- "outputs": []
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "We will be looking at a fairly low resolution dataset. In the next cell, the `ds` object has an atribute called `n_ref` that tells the oct-tree how many particles to refine on. The default is 64, but we'll get prettier plots (at the expense of a deeper tree) with 8. Just passing the argument `n_ref=8` to load does this for us."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- ">This dataset is available for download at http://yt-project.org/data/TipsyGalaxy.tar.gz (10 MB)."
- ]
- },
- {
- "cell_type": "code",
- "collapsed": false,
- "input": [
- "ds = yt.load('TipsyGalaxy/galaxy.00300', n_ref=8)"
- ],
- "language": "python",
- "metadata": {},
- "outputs": []
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "We now have a `TipsyDataset` object called `ds`. Let's see what fields it has."
- ]
- },
- {
- "cell_type": "code",
- "collapsed": false,
- "input": [
- "ds.field_list"
- ],
- "language": "python",
- "metadata": {},
- "outputs": []
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "`yt` also defines so-called \"derived\" fields. These fields are functions of the on-disk fields that live in the `field_list`. There is a `derived_field_list` attribute attached to the `Dataset` object - let's take look at the derived fields in this dataset:"
- ]
- },
- {
- "cell_type": "code",
- "collapsed": false,
- "input": [
- "ds.derived_field_list"
- ],
- "language": "python",
- "metadata": {},
- "outputs": []
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "All of the field in the `field_list` are arrays containing the values for the associated particles. These haven't been smoothed or gridded in any way. We can grab the array-data for these particles using `ds.all_data()`. For example, let's take a look at a temperature-colored scatterplot of the gas particles in this output."
- ]
- },
- {
- "cell_type": "code",
- "collapsed": false,
- "input": [
- "%matplotlib inline\n",
- "import matplotlib.pyplot as plt\n",
- "import numpy as np"
- ],
- "language": "python",
- "metadata": {},
- "outputs": []
- },
- {
- "cell_type": "code",
- "collapsed": false,
- "input": [
- "dd = ds.all_data()\n",
- "xcoord = dd['Gas','Coordinates'][:,0].v\n",
- "ycoord = dd['Gas','Coordinates'][:,1].v\n",
- "logT = np.log10(dd['Gas','Temperature'])\n",
- "plt.scatter(xcoord, ycoord, c=logT, s=2*logT, marker='o', edgecolor='none', vmin=2, vmax=6)\n",
- "plt.xlim(-20,20)\n",
- "plt.ylim(-20,20)\n",
- "cb = plt.colorbar()\n",
- "cb.set_label('$\\log_{10}$ Temperature')\n",
- "plt.gcf().set_size_inches(15,10)"
- ],
- "language": "python",
- "metadata": {},
- "outputs": []
- },
- {
- "cell_type": "heading",
- "level": 2,
- "metadata": {},
- "source": [
- "Making Smoothed Images"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "`yt` will automatically generate smoothed versions of these fields that you can use to plot. Let's make a temperature slice and a density projection."
- ]
- },
- {
- "cell_type": "code",
- "collapsed": false,
- "input": [
- "yt.SlicePlot(ds, 'z', ('gas','density'), width=(40, 'kpc'), center='m')"
- ],
- "language": "python",
- "metadata": {},
- "outputs": []
- },
- {
- "cell_type": "code",
- "collapsed": false,
- "input": [
- "yt.ProjectionPlot(ds, 'z', ('gas','density'), width=(40, 'kpc'), center='m')"
- ],
- "language": "python",
- "metadata": {},
- "outputs": []
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Not only are the values in the tipsy snapshot read and automatically smoothed, the auxiliary files that have physical significance are also smoothed. Let's look at a slice of Iron mass fraction."
- ]
- },
- {
- "cell_type": "code",
- "collapsed": false,
- "input": [
- "yt.SlicePlot(ds, 'z', ('gas', 'FeMassFrac'), width=(40, 'kpc'), center='m')"
- ],
- "language": "python",
- "metadata": {},
- "outputs": []
- }
- ],
- "metadata": {}
- }
- ]
-}
\ No newline at end of file
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 doc/source/help/index.rst
--- a/doc/source/help/index.rst
+++ b/doc/source/help/index.rst
@@ -88,31 +88,40 @@
-----------------------
We've done our best to make the source clean, and it is easily searchable from
-your computer. Go inside your yt install directory by going to the
-``$YT_DEST/src/yt-hg/yt`` directory where all the code lives. You can then search
-for the class, function, or keyword which is giving you problems with
-``grep -r *``, which will recursively search throughout the code base. (For a
-much faster and cleaner experience, we recommend ``grin`` instead of
-``grep -r *``. To install ``grin`` with python, just type ``pip install
-grin``.)
+your computer.
-So let's say that pesky ``SlicePlot`` is giving you problems still, and you
-want to look at the source to figure out what is going on.
+If you have not done so already (see :ref:`source-installation`), clone a copy of the yt mercurial repository and make it the 'active' installation by doing
+
+.. code-block::bash
+
+ python setup.py develop
+
+in the root directory of the yt mercurial repository.
+
+.. note::
+
+ This has already been done for you if you installed using the bash install
+ script. Building yt from source will not work if you do not have a C compiler
+ installed.
+
+Once inside the yt mercurial repository, you can then search for the class,
+function, or keyword which is giving you problems with ``grep -r *``, which will
+recursively search throughout the code base. (For a much faster and cleaner
+experience, we recommend ``grin`` instead of ``grep -r *``. To install ``grin``
+with python, just type ``pip install grin``.)
+
+So let's say that ``SlicePlot`` is giving you problems still, and you want to
+look at the source to figure out what is going on.
.. code-block:: bash
- $ cd $YT_DEST/src/yt-hg/yt
+ $ cd $YT-HG/yt
$ grep -r SlicePlot * (or $ grin SlicePlot)
-
- data_objects/analyzer_objects.py:class SlicePlotDataset(AnalysisTask):
- data_objects/analyzer_objects.py: from yt.visualization.api import SlicePlot
- data_objects/analyzer_objects.py: self.SlicePlot = SlicePlot
- data_objects/analyzer_objects.py: slc = self.SlicePlot(ds, self.axis, self.field, center = self.center)
- ...
-You can now followup on this and open up the files that have references to
-``SlicePlot`` (particularly the one that definese SlicePlot) and inspect their
-contents for problems or clarification.
+This will print a number of locations in the yt source tree where ``SlicePlot``
+is mentioned. You can now followup on this and open up the files that have
+references to ``SlicePlot`` (particularly the one that defines SlicePlot) and
+inspect their contents for problems or clarification.
.. _isolate_and_document:
@@ -128,7 +137,6 @@
* Put your script, errors, and outputs online:
* ``$ yt pastebin script.py`` - pastes script.py online
- * ``$ python script.py --paste`` - pastes errors online
* ``$ yt upload_image image.png`` - pastes image online
* Identify which version of the code you’re using.
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 doc/source/installing.rst
--- a/doc/source/installing.rst
+++ b/doc/source/installing.rst
@@ -8,39 +8,190 @@
Getting yt
----------
-yt is a Python package (with some components written in C), using NumPy as a
-computation engine, Matplotlib for some visualization tasks and Mercurial for
-version control. Because installation of all of these interlocking parts can
-be time-consuming, yt provides an installation script which downloads and builds
-a fully-isolated Python + NumPy + Matplotlib + HDF5 + Mercurial installation.
-yt supports Linux and OSX deployment, with the possibility of deployment on
-other Unix-like systems (XSEDE resources, clusters, etc.).
+In this document we describe several methods for installing yt. The method that
+will work best for you depends on your precise situation:
-Since the install is fully-isolated, if you get tired of having yt on your
-system, you can just delete its directory, and yt and all of its dependencies
-will be removed from your system (no scattered files remaining throughout
-your system).
+* If you already have a scientific python software stack installed on your
+ computer and are comfortable installing python packages,
+ :ref:`source-installation` will probably be the best choice. If you have set
+ up python using a source-based package manager like `Homebrew
+ <http://brew.sh>`_ or `MacPorts <http://www.macports.org/>`_ this choice will
+ let you install yt using the python installed by the package manager. Similarly
+ for python environments set up via linux package managers so long as you
+ have the the necessary compilers installed (e.g. the ``build-essentials``
+ package on debian and ubuntu).
+
+* If you use the `Anaconda <https://store.continuum.io/cshop/anaconda/>`_ python
+ distribution see :ref:`anaconda-installation` for details on how to install
+ yt using the ``conda`` package manager. Source-based installation from the
+ mercurial repository or via ``pip`` should also work under Anaconda. Note that
+ this is currently the only supported installation mechanism on Windows.
+
+* If you do not have root access on your computer, are not comfortable managing
+ python packages, or are working on a supercomputer or cluster computer, you
+ will probably want to use the bash installation script. This builds python,
+ numpy, matplotlib, and yt from source to set up an isolated scientific python
+ environment inside of a single folder in your home directory. See
+ :ref:`install-script` for more details.
+
+.. _source-installation:
+
+Installing yt Using pip or from Source
+++++++++++++++++++++++++++++++++++++++
+
+To install yt from source, you must make sure you have yt's dependencies
+installed on your system. These include: a C compiler, ``HDF5``, ``python``,
+``Cython``, ``NumPy``, ``matplotlib``, ``sympy``, and ``h5py``. From here, you
+can use ``pip`` (which comes with ``Python``) to install the latest stable
+version of yt:
+
+.. code-block:: bash
+
+ $ pip install yt
+
+The source code for yt may be found at the Bitbucket project site and can also
+be utilized for installation. If you prefer to install the development version
+of yt instead of the latest stable release, you will need ``mercurial`` to clone
+the official repo:
+
+.. code-block:: bash
+
+ hg clone https://bitbucket.org/yt_analysis/yt
+ cd yt
+ hg update yt
+ python setup.py install --user
+
+This will install yt into ``$HOME/.local/lib64/python2.7/site-packages``.
+Please refer to ``setuptools`` documentation for the additional options.
+
+If you will be modifying yt, you can also make the clone of the yt mercurial
+repository the "active" installed copy:
+
+..code-block:: bash
+
+ hg clone https://bitbucket.org/yt_analysis/yt
+ cd yt
+ hg update yt
+ python setup.py develop
+
+If you choose this installation method, you do not need to run any activation
+script since this will install yt into your global python environment.
+
+Keeping yt Updated via Mercurial
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+If you want to maintain your yt installation via updates straight from the
+Bitbucket repository or if you want to do some development on your own, we
+suggest you check out some of the :ref:`development docs <contributing-code>`,
+especially the sections on :ref:`Mercurial <mercurial-with-yt>` and
+:ref:`building yt from source <building-yt>`.
+
+You can also make use of the following command to keep yt up to date from the
+command line:
+
+.. code-block:: bash
+
+ yt update
+
+This will detect that you have installed yt from the mercurial repository, pull
+any changes from bitbucket, and then recompile yt if necessary.
+
+.. _anaconda-installation:
+
+Installing yt Using Anaconda
+++++++++++++++++++++++++++++
+
+Perhaps the quickest way to get yt up and running is to install it using the
+`Anaconda Python Distribution <https://store.continuum.io/cshop/anaconda/>`_,
+which will provide you with a easy-to-use environment for installing Python
+packages.
+
+If you do not want to install the full anaconda python distribution, you can
+install a bare-bones Python installation using miniconda. To install miniconda,
+visit http://repo.continuum.io/miniconda/ and download a recent version of the
+``Miniconda-x.y.z`` script (corresponding to Python 2.7) for your platform and
+system architecture. Next, run the script, e.g.:
+
+.. code-block:: bash
+
+ bash Miniconda-3.3.0-Linux-x86_64.sh
+
+Make sure that the Anaconda ``bin`` directory is in your path, and then issue:
+
+.. code-block:: bash
+
+ conda install yt
+
+which will install yt along with all of its dependencies.
+
+Recipes to build conda packages for yt are available at
+https://github.com/conda/conda-recipes. To build the yt conda recipe, first
+clone the conda-recipes repository
+
+.. code-block:: bash
+
+ git clone https://github.com/conda/conda-recipes
+
+Then navigate to the repository root and invoke `conda build`:
+
+.. code-block:: bash
+
+ cd conda-recipes
+ conda build ./yt/
+
+Note that building a yt conda package requires a C compiler.
+
+.. _windows-installation:
+
+Installing yt on Windows
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+Installation on Microsoft Windows is only supported for Windows XP Service Pack
+3 and higher (both 32-bit and 64-bit) using Anaconda, see
+:ref:`anaconda-installation`. Also see :ref:`windows-developing` for details on
+how to build yt from source in Windows.
+
+.. _install-script:
+
+All-in-one installation script
+++++++++++++++++++++++++++++++
+
+Because installation of all of the interlocking parts necessary to install yt
+itself can be time-consuming, yt provides an all-in-one installation script
+which downloads and builds a fully-isolated Python + NumPy + Matplotlib + HDF5 +
+Mercurial installation. Since the install script compiles yt's dependencies from
+source, you must have C, C++, and optionally Fortran compilers installed.
+
+The install script supports UNIX-like systems, including Linux, OS X, and most
+supercomputer and cluster environments. It is particularly suited for deployment
+in environments where users do not have root access and can only install
+software into their home directory.
+
+Since the install is fully-isolated in a single directory, if you get tired of
+having yt on your system, you can just delete the directory and yt and all of
+its dependencies will be removed from your system (no scattered files remaining
+throughout your system).
+
+Running the install script
+^^^^^^^^^^^^^^^^^^^^^^^^^^
To get the installation script, download it from:
.. code-block:: bash
- http://hg.yt-project.org/yt/raw/stable/doc/install_script.sh
+ wget http://hg.yt-project.org/yt/raw/stable/doc/install_script.sh
.. _installing-yt:
-Installing yt
--------------
-
-By default, the bash script will install an array of items, but there are
-additional packages that can be downloaded and installed (e.g. SciPy, enzo,
-etc.). The script has all of these options at the top of the file. You should
-be able to open it and edit it without any knowledge of bash syntax.
-To execute it, run:
+By default, the bash install script will install an array of items, but there
+are additional packages that can be downloaded and installed (e.g. SciPy, enzo,
+etc.). The script has all of these options at the top of the file. You should be
+able to open it and edit it without any knowledge of bash syntax. To execute
+it, run:
.. code-block:: bash
- $ bash install_script.sh
+ bash install_script.sh
Because the installer is downloading and building a variety of packages from
source, this will likely take a while (e.g. 20 minutes), but you will get
@@ -48,7 +199,7 @@
If you receive errors during this process, the installer will provide you
with a large amount of information to assist in debugging your problems. The
-file ``yt_install.log`` will contain all of the ``STDOUT`` and ``STDERR`` from
+file ``yt_install.log`` will contain all of the ``stdout`` and ``stderr`` from
the entire installation process, so it is usually quite cumbersome. By looking
at the last few hundred lines (i.e. ``tail -500 yt_install.log``), you can
potentially figure out what went wrong. If you have problems, though, do not
@@ -57,7 +208,7 @@
.. _activating-yt:
Activating Your Installation
-----------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Once the installation has completed, there will be instructions on how to set up
your shell environment to use yt by executing the activate script. You must
@@ -67,13 +218,13 @@
.. code-block:: bash
- $ source <yt installation directory>/bin/activate
+ source <yt installation directory>/bin/activate
If you use csh or tcsh as your shell, activate that version of the script:
.. code-block:: bash
- $ source <yt installation directory>/bin/activate.csh
+ source <yt installation directory>/bin/activate.csh
If you don't like executing outside scripts on your computer, you can set
the shell variables manually. ``YT_DEST`` needs to point to the root of the
@@ -82,6 +233,38 @@
will also need to set ``LD_LIBRARY_PATH`` and ``PYTHONPATH`` to contain
``$YT_DEST/lib`` and ``$YT_DEST/python2.7/site-packages``, respectively.
+.. _updating-yt:
+
+Updating yt and its dependencies
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+With many active developers, code development sometimes occurs at a furious
+pace in yt. To make sure you're using the latest version of the code, run
+this command at a command-line:
+
+.. code-block:: bash
+
+ yt update
+
+Additionally, if you want to make sure you have the latest dependencies
+associated with yt and update the codebase simultaneously, type this:
+
+.. code-block:: bash
+
+ yt update --all
+
+.. _removing-yt:
+
+Removing yt and its dependencies
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Because yt and its dependencies are installed in an isolated directory when
+you use the script installer, you can easily remove yt and all of its
+dependencies cleanly. Simply remove the install directory and its
+subdirectories and you're done. If you *really* had problems with the
+code, this is a last defense for solving: remove and then fully
+:ref:`re-install <installing-yt>` from the install script again.
+
.. _testing-installation:
Testing Your Installation
@@ -92,7 +275,7 @@
.. code-block:: bash
- $ yt --help
+ yt --help
If this works, you should get a list of the various command-line options for
yt, which means you have successfully installed yt. Congratulations!
@@ -102,112 +285,3 @@
figure it out.
If you like, this might be a good time :ref:`to run the test suite <testing>`.
-
-.. _updating-yt:
-
-Updating yt and its dependencies
---------------------------------
-
-With many active developers, code development sometimes occurs at a furious
-pace in yt. To make sure you're using the latest version of the code, run
-this command at a command-line:
-
-.. code-block:: bash
-
- $ yt update
-
-Additionally, if you want to make sure you have the latest dependencies
-associated with yt and update the codebase simultaneously, type this:
-
-.. code-block:: bash
-
- $ yt update --all
-
-.. _removing-yt:
-
-Removing yt and its dependencies
---------------------------------
-
-Because yt and its dependencies are installed in an isolated directory when
-you use the script installer, you can easily remove yt and all of its
-dependencies cleanly. Simply remove the install directory and its
-subdirectories and you're done. If you *really* had problems with the
-code, this is a last defense for solving: remove and then fully
-:ref:`re-install <installing-yt>` from the install script again.
-
-.. _alternative-installation:
-
-Alternative Installation Methods
---------------------------------
-
-.. _pip-installation:
-
-Installing yt Using pip or from Source
-++++++++++++++++++++++++++++++++++++++
-
-If you want to forego the use of the install script, you need to make sure you
-have yt's dependencies installed on your system. These include: a C compiler,
-``HDF5``, ``python``, ``cython``, ``NumPy``, ``matplotlib``, and ``h5py``. From here,
-you can use ``pip`` (which comes with ``Python``) to install yt as:
-
-.. code-block:: bash
-
- $ pip install yt
-
-The source code for yt may be found at the Bitbucket project site and can also be
-utilized for installation. If you prefer to use it instead of relying on external
-tools, you will need ``mercurial`` to clone the official repo:
-
-.. code-block:: bash
-
- $ hg clone https://bitbucket.org/yt_analysis/yt
- $ cd yt
- $ hg update yt
- $ python setup.py install --user
-
-It will install yt into ``$HOME/.local/lib64/python2.7/site-packages``.
-Please refer to ``setuptools`` documentation for the additional options.
-
-If you choose this installation method, you do not need to run the activation
-script as it is unnecessary.
-
-.. _anaconda-installation:
-
-Installing yt Using Anaconda
-++++++++++++++++++++++++++++
-
-Perhaps the quickest way to get yt up and running is to install it using the `Anaconda Python
-Distribution <https://store.continuum.io/cshop/anaconda/>`_, which will provide you with a
-easy-to-use environment for installing Python packages. To install a bare-bones Python
-installation with yt, first visit http://repo.continuum.io/miniconda/ and download a recent
-version of the ``Miniconda-x.y.z`` script (corresponding to Python 2.7) for your platform and
-system architecture. Next, run the script, e.g.:
-
-.. code-block:: bash
-
- $ bash Miniconda-3.3.0-Linux-x86_64.sh
-
-Make sure that the Anaconda ``bin`` directory is in your path, and then issue:
-
-.. code-block:: bash
-
- $ conda install yt
-
-which will install yt along with all of its dependencies.
-
-.. _windows-installation:
-
-Installing yt on Windows
-++++++++++++++++++++++++
-
-Installation on Microsoft Windows is only supported for Windows XP Service Pack 3 and
-higher (both 32-bit and 64-bit) using Anaconda.
-
-Keeping yt Updated via Mercurial
-++++++++++++++++++++++++++++++++
-
-If you want to maintain your yt installation via updates straight from the Bitbucket repository,
-or if you want to do some development on your own, we suggest you check out some of the
-:ref:`development docs <contributing-code>`, especially the sections on :ref:`Mercurial
-<mercurial-with-yt>` and :ref:`building yt from source <building-yt>`.
-
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 doc/source/reference/api/api.rst
--- a/doc/source/reference/api/api.rst
+++ b/doc/source/reference/api/api.rst
@@ -1,3 +1,5 @@
+.. _api-reference:
+
API Reference
=============
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 doc/source/reference/faq/index.rst
--- a/doc/source/reference/faq/index.rst
+++ b/doc/source/reference/faq/index.rst
@@ -196,33 +196,10 @@
.. code-block:: bash
- cd $YT_DEST/src/yt-hg
+ cd $YT_HG
python setup.py develop
-
-Unresolved Installation Problem on OSX 10.6
--------------------------------------------
-When installing on some instances of OSX 10.6, a few users have noted a failure
-when yt tries to build with OpenMP support:
-
- Symbol not found: _GOMP_barrier
- Referenced from: <YT_DEST>/src/yt-hg/yt/utilities/lib/grid_traversal.so
-
- Expected in: dynamic lookup
-
-To resolve this, please make a symbolic link:
-
-.. code-block:: bash
-
- $ ln -s /usr/local/lib/x86_64 <YT_DEST>/lib64
-
-where ``<YT_DEST>`` is replaced by the path to the root of the directory
-containing the yt install, which will usually be ``yt-<arch>``. After doing so,
-you should be able to cd to <YT_DEST>/src/yt-hg and run:
-
-.. code-block:: bash
-
- $ python setup.py install
+where ``$YT_HG`` is the path to the yt mercurial repository.
.. _plugin-file:
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 doc/source/yt3differences.rst
--- a/doc/source/yt3differences.rst
+++ b/doc/source/yt3differences.rst
@@ -21,29 +21,42 @@
Here's a quick reference for how to update your code to work with yt-3.0.
- * Importing yt is now as simple as ``import yt``. The docs have been
- extensively updated to reflect this new style. ``from yt.mods import *``
- still works, but we are discouraging its use going forward.
+ * We have reworked yt's import system so that most commonly-used yt functions
+ and classes live in the top-level ``yt`` namespace. That means you can now
+ import yt with ``import yt``, load a dataset with ``ds = yt.load``
+ and create a plot with ``yt.SlicePlot``. See :ref:`api-reference` for a full
+ API listing.
+ * Fields and metadata for data objects and datasets now have units. The unit
+ system keeps you from making weird things like ``ergs`` + ``g`` and can
+ handle things like ``g`` + ``kg`` or ``kg*m/s**2 == Newton``. See
+ :ref:`units` for more information.
+ * Previously, yt would use "Enzo-isms" for field names. We now very
+ specifically define fields as lowercase with underscores. For instance,
+ what used to be ``VelocityMagnitude`` would now be ``velocity_magnitude``.
+ Axis names are now at the *end* of field names, not the beginning.
+ ``x-velocity`` is now ``velocity_x``.
* Fields can be accessed by a name, but are named internally as ``(fluid_type,
fluid_name)``.
- * Fields on-disk will be in code units, and will be named ``(code_name,
+ * Mesh fields on-disk will be in code units, and will be named ``(code_name,
FieldName)``.
- * Previously, yt would use "Enzo-isms" for field names. We now very
- specifically define fields as lowercase with underscores. For instance,
- what used to be ``VelocityMagnitude`` would now be ``velocity_magnitude``.
- * Particles are either named by their type or default to the type ``io``.
- * Axis names are now at the *end* of field names, not the beginning.
- ``x-velocity`` is now ``velocity_x``.
- * Any derived quantities that *always* returned lists (like ``Extrema``,
- which would return a list even if you only ask for one field) now only
- return a single tuple if you only ask for one field.
- * Units can be tricky, and they try to keep you from making weird things like
- ``ergs`` + ``g``. See :ref:`units` for more information.
+ * Particle fields on-disk will also be in code units, and will be named
+ ``(particle_type, FieldName)``. If there is only one particle type in the
+ output file, the particle type for all particles will be ``io``.
* Previously, yt would capture command line arguments when being imported.
This no longer happens. As a side effect, it is no longer necessary to
specify ``--parallel`` at the command line when running a parallel
computation. Use ``yt.enable_parallelism()`` instead. See
:ref:`parallel-computation` for more detail.
+ * Any derived quantities that *always* returned lists (like ``Extrema``,
+ which would return a list even if you only ask for one field) now only
+ returns a single result if you only ask for one field. Results for particle
+ and mesh fields will be returned separately.
+ * Derived quantities can now be accessed via a function that hangs off of the
+ ``quantities`` atribute of data objects. Instead of
+ ``dd.quantities['TotalMass']``, you can now use
+ ``dd.quantities.total_mass()`` to do the same thing. All derived quantities
+ can be accessed via a function that hangs off of the `quantities` attribute
+ of data objects.
Cool New Things
---------------
@@ -92,9 +105,10 @@
Units
+++++
-yt now has units. This is one of the bigger features, and in essence it means
-that you can convert units between anything. See :ref:`units` for more
-information.
+yt now has a unit system. This is one of the bigger features, and in essence it means
+that you can convert units between anything. In practice, it makes it much
+easier to define fields and convert data between different unit systems. See
+:ref:`units` for more information.
Non-Cartesian Coordinates
+++++++++++++++++++++++++
@@ -119,10 +133,11 @@
my_object["gas", "density"]
-will return the gas field density. This extends to particle types as well. By
-default you do *not* need to use the field "type" key, but in case of ambiguity
-it will utilize the default value in its place. This should therefore be
-identical to::
+will return the gas field density. In this example "gas" is the field type and
+"density" is the field name. Field types are a bit like a namespace. This
+system extends to particle types as well. By default you do *not* need to use
+the field "type" key, but in case of ambiguity it will utilize the default value
+in its place. This should therefore be identical to::
my_object["density"]
@@ -133,20 +148,6 @@
along with it units. This means that if you want to manipulate fields, you
have to modify them in a unitful way.
-Field Info
-++++++++++
-
-In the past, the object ``ds`` (or ``ds``) had a ``field_info`` object which
-was a dictionary leading to derived field definitions. At the present time,
-because of the field naming changes (i.e., access-by-tuple) it is better to
-utilize the function ``_get_field_info`` than to directly access the
-``field_info`` dictionary. For example::
-
- finfo = ds._get_field_info("gas", "density")
-
-This function respects the special "field type" ``unknown`` and will search all
-field types for the field name.
-
Parameter Files are Now Datasets
++++++++++++++++++++++++++++++++
@@ -154,6 +155,29 @@
(i.e., ``ds``) with the term "dataset." Future revisions will change most of
the ``ds`` atrributes of objects into ``ds`` or ``dataset`` attributes.
+Hierarchy is Now Index
+++++++++++++++++++++++
+
+The hierarchy object (``pf.h``) is now referred to as an index (``ds.index``).
+It is no longer necessary to directly refer to the ``index`` as often, since
+data objects are now attached to the to the ``dataset`` object. Before, you
+would say ``ph.f.sphere()``, now you can say ``ds.sphere()``.
+
+Field Info
+++++++++++
+
+In previous versions of yt, the ``dataset`` object (what we used to call a
+parameter file) had a ``field_info`` attribute which was a dictionary leading to
+derived field definitions. At the present time, because of the field naming
+changes (i.e., access-by-tuple) it is better to utilize the function
+``_get_field_info`` than to directly access the ``field_info`` dictionary. For
+example::
+
+ finfo = ds._get_field_info("gas", "density")
+
+This function respects the special "field type" ``unknown`` and will search all
+field types for the field name.
+
Projection Argument Order
+++++++++++++++++++++++++
@@ -173,7 +197,8 @@
Nearly all internal objects have been renamed. Typically this means either
removing ``AMR`` from the prefix or replacing it with ``YT``. All names of
objects remain the same for the purposes of selecting data and creating them;
-i.e., you will not need to change ``ds.sphere`` to something else.
+i.e., ``sphere`` objects are still called ``sphere`` - you can access create one
+via ``ds.sphere``.
Boolean Regions
+++++++++++++++
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 yt/frontends/stream/data_structures.py
--- a/yt/frontends/stream/data_structures.py
+++ b/yt/frontends/stream/data_structures.py
@@ -498,7 +498,7 @@
for field in data:
if isinstance(field, tuple):
new_field = field
- elif len(data[field].shape) == 1:
+ elif len(data[field].shape) in (1, 2):
new_field = ("io", field)
elif len(data[field].shape) == 3:
new_field = ("gas", field)
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 yt/frontends/stream/fields.py
--- a/yt/frontends/stream/fields.py
+++ b/yt/frontends/stream/fields.py
@@ -68,6 +68,7 @@
("particle_mass", ("code_mass", [], None)),
("smoothing_length", ("code_length", [], None)),
("density", ("code_mass/code_length**3", [], None)),
+ ("creation_time", ("code_time", [], None)),
)
def setup_fluid_fields(self):
diff -r 04c7e205efeca4a032a9fbf33484ba4293499ae2 -r 6dfe7fd6f90947fe787e2fbfa572d75639370e45 yt/frontends/stream/io.py
--- a/yt/frontends/stream/io.py
+++ b/yt/frontends/stream/io.py
@@ -167,9 +167,11 @@
# self.fields[g.id][fname] is the pattern here
morton = []
for ptype in self.ds.particle_types_raw:
- pos = np.column_stack(self.fields[data_file.filename][
- (ptype, "particle_position_%s" % ax)]
- for ax in 'xyz')
+ try:
+ pos = np.column_stack(self.fields[data_file.filename][
+ (ptype, "particle_position_%s" % ax)] for ax in 'xyz')
+ except KeyError:
+ pos = self.fields[data_file.filename][ptype, "particle_position"]
if np.any(pos.min(axis=0) < data_file.ds.domain_left_edge) or \
np.any(pos.max(axis=0) > data_file.ds.domain_right_edge):
raise YTDomainOverflow(pos.min(axis=0), pos.max(axis=0),
@@ -186,7 +188,10 @@
pcount = {}
for ptype in self.ds.particle_types_raw:
d = self.fields[data_file.filename]
- pcount[ptype] = d[ptype, "particle_position_x"].size
+ try:
+ pcount[ptype] = d[ptype, "particle_position_x"].size
+ except KeyError:
+ pcount[ptype] = d[ptype, "particle_position"].shape[0]
return pcount
def _identify_fields(self, data_file):
Repository URL: https://bitbucket.org/yt_analysis/yt/
--
This is a commit notification from bitbucket.org. You are receiving
this because you have the service enabled, addressing the recipient of
this email.
More information about the yt-svn
mailing list