[yt-svn] commit/yt-doc: 5 new changesets

Bitbucket commits-noreply at bitbucket.org
Wed Jan 30 19:31:04 PST 2013


5 new commits in yt-doc:

https://bitbucket.org/yt_analysis/yt-doc/commits/0ca083913bb4/
changeset:   0ca083913bb4
user:        sskory
date:        2013-01-25 01:16:22
summary:     More on the cheat sheet.
affected #:  1 file

diff -r 41a29eb8260e344259abc2061d94897b6868269f -r 0ca083913bb4da97df34ce3d2ed4f64c4922a9c0 cheatsheet.tex
--- a/cheatsheet.tex
+++ b/cheatsheet.tex
@@ -37,7 +37,7 @@
 % if using A4 paper. (This probably isn't strictly necessary.)
 % If using another size paper, use default 1cm margins.
 \ifthenelse{\lengthtest { \paperwidth = 11in}}
-	{ \geometry{top=.5in,left=.5in,right=.5in,bottom=.5in} }
+	{ \geometry{top=.5in,left=.5in,right=.5in,bottom=0.85in} }
 	{\ifthenelse{ \lengthtest{ \paperwidth = 297mm}}
 		{\geometry{top=1cm,left=1cm,right=1cm,bottom=1cm} }
 		{\geometry{top=1cm,left=1cm,right=1cm,bottom=1cm} }
@@ -102,9 +102,15 @@
 Need help? Start here \url{http://yt-project.org/doc/help/} and then
 try the IRC chat room \url{http://yt-project.org/irc.html},
 or the mailing list \url{http://lists.spacepope.org/listinfo.cgi/yt-users-spacepope.org}.
-
+{\bf Installing yt:} The easiest way to install yt is to use the installation script
+found on the yt homepage or the docs linked above.
 
 \subsection{Command Line yt}
+yt, and its convenience functions, are launched from a command line prompt.
+Many commands have flags to control behavior.
+Commands can be followed by
+{\bf {-}{-}help} (e.g. {\bf yt render {-}{-}help}) for detailed help for that command
+including a list of the available flags.
 \begin{tabular}{@{}lp{3.5cm}@{}}
 \texttt{iyt} & Load yt and IPython. \\
 \texttt{yt load} {\it dataset}    & Load a single dataset.  \\
@@ -113,7 +119,7 @@
 \texttt{yt update} & Update yt to most recent version.\\
 \texttt{yt instinfo} & yt installation information. \\
 \texttt{yt notebook} & Run the IPython notebook server. \\
-\texttt{yt serve} (\it{dataset})  &  Run yt-specific web GUI.\\
+\texttt{yt serve} (\it{dataset})  &  Run yt-specific web GUI ({\it dataset} is optional).\\
 \texttt{yt upload\_image} \it{image.png}  & Upload PNG image to imgur.com. \\
 \texttt{yt upload\_notebook} \it{notebook.nb} & Upload IPython notebook to hub.yt-project.org.\\
 \texttt{yt plot} \it{dataset} & Create a set of images.\\
@@ -137,13 +143,10 @@
  session. 
 \end{tabular}
 
-Many commands have flags to control behavior.
-Commands can be followed by
-{\bf {-}{-}help} (e.g. {\bf yt render {-}{-}help}) for detailed help for that command
-including a list of the available flags.
-({\it Parentheticals}) above are optional.
-
 \subsection{yt Imports}
+In order to use yt, Python must load the relevant yt modules into memory.
+The import commands are entered in the Python/IPython shell or
+used as part of a script.
 \newlength{\MyLen}
 \settowidth{\MyLen}{\texttt{letterpaper}/\texttt{a4paper} \ }
 %\begin{tabular}{@{}p{\the\MyLen}%
@@ -153,26 +156,22 @@
 \texttt{from yt.mods import \textasteriskcentered}  \textemdash\ 
 Load base yt  modules. \\
 \texttt{from yt.config import ytcfg}  \textemdash\ 
-Used to set yt configuration options.  \textemdash\ 
- If used, must be called before importing other modules.\\
+Used to set yt configuration options.
+ If used, must be called before importing any other module.\\
 \texttt{from yt.analysis\_modules.api import \textasteriskcentered}   \textemdash\ 
 Load all yt analysis modules. \\
 \texttt{from yt.analysis\_modules.\emph{halo\_finding}.api import \textasteriskcentered}  \textemdash\ 
-Load halo finding modules. Other modules, listed below, 
+Load halo finding modules. Other modules
 are loaded in a similar way by swapping the 
 {\em emphasized} text.
-\texttt{absorption\_spectrum}, \texttt{coordinate\_transformation}, 
-\texttt{cosmological\_observation}, \texttt{halo\_mass\_function}, 
-\texttt{halo\_merger\_tree}, \texttt{halo\_profiler}, \texttt{level\_sets}, 
-\texttt{hierarchy\_subset}, \texttt{radial\_column\_density}, 
-\texttt{spectral\_integrator}, \texttt{star\_analysis}, \texttt{sunrise\_export}, 
-\texttt{two\_point\_functions}
+See the \textbf{Analysis Modules} section for a listing and short descriptions of each.
 \end{tabular}
-The import commands are entered in the Python shell or
-used as part of a script.
 
 \subsection{Numpy Arrays}
-% More examples are probably needed especially, but this is a start.
+Simulation data in yt is returned in Numpy arrays. The Numpy package provides a wealth of built-in
+functions that operate on Numpy arrays. Here is a very brief list of some useful ones.
+Please see \url{http://docs.scipy.org/doc/numpy/reference/} for the full
+numpy documentation.
 \settowidth{\MyLen}{\texttt{multicol} }
 \begin{tabular}{@{}p{8cm}}
 
@@ -181,17 +180,19 @@
 min value of \texttt{a}.\\
 \texttt{v = a[}{\it index}\texttt{]} \textemdash\ Select a single value from \texttt{a} at location {\it index}.\\
 \texttt{b = a[}{\it i:j}\texttt{]} \textemdash\ Select the slice of values from \texttt{a} between
-locations {\it i} to {\it j-1} saved to a new numpy array \texttt{b} with length {\it j-i}. \\
-
+locations {\it i} to {\it j-1} saved to a new Numpy array \texttt{b} with length {\it j-i}. \\
+\texttt{sel = (a > const)}  \textemdash\ Create a new boolean Numpy array \texttt{sel}, of the same shape as \texttt{a},
+that marks which values of \texttt{a > const}. Other operators work as well.\\
+\texttt{b = a[sel]} \textemdash\ Create a new Numpy array \texttt{b} made up of elements from \texttt{a} that correspond to elements of \texttt{sel}
+that are {\it True}.\\
+\texttt{a.dump({\it filename.dat})} \textemdash\ Save \texttt{a} to the binary file {\it filename.dat}.\\
+\texttt{a = load({\it filename.dat})} \textemdash\ Load the contents of {\it filename.dat} into \texttt{a}.
 \end{tabular}
 
-Please see \url{http://docs.scipy.org/doc/numpy/reference/} for the full
-numpy documentation.
-
 \subsection{IPython Tips}
 \settowidth{\MyLen}{\texttt{multicol} }
 These tips work if IPython has been loaded, typically either by invoking
-\texttt{iyt} or \texttt{yt load} on the command line or using the IPython notebook (\texttt{yt notebook}).
+\texttt{iyt} or \texttt{yt load} on the command line, or using the IPython notebook (\texttt{yt notebook}).
 \begin{tabular}{@{}p{8cm}}
 \texttt{Tab complete} \textemdash\ IPython will attempt to auto-complete a
 variable or function name when the \texttt{Tab} key is pressed, e.g. {\it HaloFi}\textendash\texttt{Tab} would auto-complete
@@ -199,6 +200,7 @@
 would give you a list of random functions (note the trailing period before hitting \texttt{Tab}).\\
 \texttt{?, ??} \textemdash\ Appending one or two question marks at the end of any object gives you
 detailed information about it, e.g. {\it variable\_name}?.\\
+Below a few IPython ``magics'' are listed, which are IPython-specific shortcut commands.\\
 \texttt{\%paste} \textemdash\ Paste content from the system clipboard into the IPython shell.\\
 \texttt{\%hist} \textemdash\ Print recent command history.\\
 \texttt{\%quickref} \textemdash\ Print IPython quick reference.\\
@@ -212,11 +214,14 @@
 IPython documentation.
 
 \subsection{Load and Access Data}
+The first step in using yt is to reference a simulation snapshot.
+After that, simulation data is generally accessed in yt using {\it Data Containers} which are Python objects
+that define a region of simulation space from which data should be selected.
 \settowidth{\MyLen}{\texttt{multicol} }
 %\begin{tabular}{@{}p{\the\MyLen}%
 %               @{}p{\linewidth-\the\MyLen}@{}}
 \begin{tabular}{@{}p{8cm}}
-\texttt{pf = load(}{\it dataset}\texttt{)} \textemdash\   Load a single snapshot.\\
+\texttt{pf = load(}{\it dataset}\texttt{)} \textemdash\   Reference a single snapshot.\\
 \texttt{dd = pf.h.all\_data()} \textemdash\ Select the entire volume.\\
 \texttt{a = dd[}{\it field\_name}\texttt{]} \textemdash\ Saves the contents of {\it field} into the
 numpy array \texttt{a}. Similarly for other data containers.\\
@@ -246,6 +251,9 @@
  {\it [sp, ``NOT'', (di, ``OR'', re)]} gives a volume defined
  by {\it sp} minus the patches covered by {\it di} and {\it re}.\\
  
+\texttt{pf.h.save\_object(sp, {\it "sp\_for\_later"})} \textemdash\ Save an object (\texttt{sp}) for later use.\\
+\texttt{sp = pf.h.load\_object({\it "sp\_for\_later"})} \textemdash\ Recover a saved object.\\
+
 \end{tabular}
 
 
@@ -265,6 +273,53 @@
 \end{tabular}
 
 
+
+\subsection{The $\sim$/.yt/ Directory}
+\settowidth{\MyLen}{\texttt{multicol} }
+yt will automatically check for configuration files in a special directory (\texttt{\$HOME/.yt/}) in the user's home directory.
+
+%\begin{tabular}{@{}p{\the\MyLen}%
+%               @{}p{\linewidth-\the\MyLen}@{}}
+\begin{tabular}{@{}p{8cm}}
+The \texttt{config} file \textemdash\ Settings that control runtime behavior. \\
+The \texttt{my\_plugins.py} file \textemdash\ Add functions, derived fields, constants, or other commonly-used Python code to yt.
+\end{tabular}
+
+
+
+\subsection{Analysis Modules}
+\settowidth{\MyLen}{\texttt{multicol}}
+The import name for each module is listed at the end of each description (see \textbf{yt Imports}).
+%\begin{tabular}{@{}p{\the\MyLen}%
+%               @{}p{\linewidth-\the\MyLen}@{}}
+\begin{tabular}{@{}p{8cm}}
+\texttt{Absorption Spectrum} \textemdash\ (\texttt{absorption\_spectrum}). \\
+\texttt{Clump Finder} \textemdash\ Find clumps defined by density thresholds (\texttt{level\_sets}). \\
+\texttt{Coordinate Transformation} \textemdash\ (\texttt{coordinate\_transformation}). \\
+\texttt{Halo Finding} \textemdash\ Locate halos of dark matter particles (\texttt{halo\_finding}). \\
+\texttt{Halo Mass Function} \textemdash\ Find halo mass functions from data and from theory (\texttt{halo\_mass\_function}). \\
+\texttt{Halo Profiling} \textemdash\ Profile and project multiple halos (\texttt{halo\_profiler}). \\
+\texttt{Halo Merger Tree} \textemdash\ Create a database of halo mergers (\texttt{halo\_merger\_tree}). \\
+\texttt{Light Cone Generator} \textemdash\ \\
+\texttt{Light Ray Generator} \textemdash\ \\
+\texttt{Radial Column Density} \textemdash\ Calculate column densities around a point (\texttt{radial\_column\_density}). \\
+\texttt{Rockstar Halo Finding} \textemdash\ Locate halos of dark matter using the Rockstar halo finder (\texttt{halo\_finding.rockstar}). \\
+\texttt{Star Particle Analysis} \textemdash\ Analyze star formation history and assemble spectra (\texttt{star\_analysis}). \\
+\texttt{Sunrise Exporter} \textemdash\ Export data to the sunrise visualization format (\texttt{sunrise\_export}). \\
+\texttt{Two Point Functions} \textemdash\ Two point correlations (\texttt{two\_point\_functions}). \\
+
+\end{tabular}
+
+\subsection{Parallel Analysis}
+\settowidth{\MyLen}{\texttt{multicol}}
+Nearly all of yt is parallelized using MPI and in most cases it can provide a meaningful
+speed-up of analysis tasks.
+The {\it mpi4py} package must be installed for parallelism in yt
+({\it pip install mpi4py} on the command line).
+
+
+\end{tabular}
+
 %\rule{0.3\linewidth}{0.25pt}
 %\scriptsize
 


https://bitbucket.org/yt_analysis/yt-doc/commits/139c85566a20/
changeset:   139c85566a20
user:        sskory
date:        2013-01-25 01:16:43
summary:     Merge.
affected #:  4 files

diff -r 0ca083913bb4da97df34ce3d2ed4f64c4922a9c0 -r 139c85566a20bdb18af99ccd325ea3d8d4ec0447 source/advanced/installing.rst
--- a/source/advanced/installing.rst
+++ b/source/advanced/installing.rst
@@ -184,6 +184,18 @@
 a bug, and we would love to hear about it so we can fix it.  Please inform us 
 through the bugsubmit utility or through the yt-users mailing list.
 
+Updating yt's Dependencies
+--------------------------
+
+If you used the install script to originally install yt, updating the various 
+libraries and modules yt depends on can be done by running:
+
+.. code-block:: bash
+
+   $ yt update --all
+
+For custom installs, you will need to update the dependencies by hand.
+
 Switching Between Branches in yt
 ================================
 

diff -r 0ca083913bb4da97df34ce3d2ed4f64c4922a9c0 -r 139c85566a20bdb18af99ccd325ea3d8d4ec0447 source/cookbook/rendering_with_box_and_grids.py
--- /dev/null
+++ b/source/cookbook/rendering_with_box_and_grids.py
@@ -0,0 +1,57 @@
+from yt.mods import *
+
+# Load the dataset.
+pf = load("Enzo_64/DD0043/data0043")
+
+# Create a data container (like a sphere or region) that
+# represents the entire domain.
+dd = pf.h.all_data()
+
+# Get the minimum and maximum densities.
+mi, ma = dd.quantities["Extrema"]("Density")[0]
+
+# Create a transfer function to map field values to colors.
+# We bump up our minimum to cut out some of the background fluid
+tf = ColorTransferFunction((na.log10(mi)+2.0, na.log10(ma)))
+
+# Add three guassians, evenly spaced between the min and
+# max specified above with widths of 0.02 and using the
+# gist_stern colormap.
+tf.add_layers(3, w=0.02, colormap="gist_stern")
+
+# Choose a center for the render.
+c = [0.5, 0.5, 0.5]
+
+# Choose a vector representing the viewing direction.
+L = [0.5, 0.2, 0.7]
+
+# Set the width of the image.
+# Decreasing or increasing this value
+# results in a zoom in or out.
+W = 1.0
+
+# The number of pixels along one side of the image.
+# The final image will have Npixel^2 pixels.
+Npixels = 512
+
+# Create a camera object.
+# This object creates the images and
+# can be moved and rotated.
+cam = pf.h.camera(c, L, W, Npixels, tf)
+
+# Create a snapshot.
+# The return value of this function could also be accepted, modified (or saved
+# for later manipulation) and then put written out using write_bitmap.
+# clip_ratio applies a maximum to the function, which is set to that value
+# times the .std() of the array.
+im = cam.snapshot("%s_volume_rendered.png" % pf, clip_ratio=8.0)
+
+# Add the domain edges, with an alpha blending of 0.3:
+cam.draw_domain(im, alpha=0.3)
+write_bitmap('%s_vr_domain.png' % pf)
+
+# Add the grids, colored by the grid level with the algae colormap
+cam.draw_grids(im, alpha=0.3, cmap='algae')
+write_bitmap('%s_vr_grids.png' % pf)
+
+

diff -r 0ca083913bb4da97df34ce3d2ed4f64c4922a9c0 -r 139c85566a20bdb18af99ccd325ea3d8d4ec0447 source/interacting/command-line.rst
--- a/source/interacting/command-line.rst
+++ b/source/interacting/command-line.rst
@@ -192,7 +192,8 @@
 ++++++
 
 This subcommand updates the yt installation to the most recent version for
-your repository (e.g. stable, 2.0, development, etc.).  See 
+your repository (e.g. stable, 2.0, development, etc.).  Adding the ``--all`` 
+flag will update the dependencies as well. See 
 :ref:`automated-update` for more details.
 
 .. _upload-image:

diff -r 0ca083913bb4da97df34ce3d2ed4f64c4922a9c0 -r 139c85566a20bdb18af99ccd325ea3d8d4ec0447 source/visualizing/volume_rendering.rst
--- a/source/visualizing/volume_rendering.rst
+++ b/source/visualizing/volume_rendering.rst
@@ -77,9 +77,15 @@
     im = cam.snapshot('test_rendering.png',clip_ratio=6.0)
     
     # Take a snapshot, saving the image to file fn.
-    cam.snapshot(fn)
+    im = cam.snapshot(fn)
     
+    # To add the domain box to the image:
+    cam.draw_domain(im)
+    write_bitmap(im, 'test_rendering_with_domain.png')
 
+    # To add the grid outlines to the image:
+    cam.draw_grids(im)
+    write_bitmap(im, 'test_rendering_with_grids.png')
 Method
 ------
 


https://bitbucket.org/yt_analysis/yt-doc/commits/4f70020a3311/
changeset:   4f70020a3311
user:        sskory
date:        2013-01-30 21:18:26
summary:     More in the cheat sheet.
affected #:  1 file

diff -r 139c85566a20bdb18af99ccd325ea3d8d4ec0447 -r 4f70020a33115f5f4bb30793e7d6b1dac527e888 cheatsheet.tex
--- a/cheatsheet.tex
+++ b/cheatsheet.tex
@@ -117,6 +117,7 @@
 \texttt{yt help} & Print yt help information. \\
 \texttt{yt stats} \it{dataset}  & Print stats of a dataset. \\
 \texttt{yt update} & Update yt to most recent version.\\
+\texttt{yt update --all} & Update yt and dependencies to most recent version. \\
 \texttt{yt instinfo} & yt installation information. \\
 \texttt{yt notebook} & Run the IPython notebook server. \\
 \texttt{yt serve} (\it{dataset})  &  Run yt-specific web GUI ({\it dataset} is optional).\\
@@ -312,12 +313,52 @@
 
 \subsection{Parallel Analysis}
 \settowidth{\MyLen}{\texttt{multicol}}
-Nearly all of yt is parallelized using MPI and in most cases it can provide a meaningful
-speed-up of analysis tasks.
-The {\it mpi4py} package must be installed for parallelism in yt
-({\it pip install mpi4py} on the command line).
+Nearly all of yt is parallelized using MPI.
+The {\it mpi4py} package must be installed for parallelism in yt.
+To install {\it pip install mpi4py} on the command line usually works.
+Execute python in parallel similar to this:\\
+{\it mpirun -n 12 python script.py --parallel}\\
+This command may differ for each system on which you use yt;
+please consult the system documentation for details on how to run parallel applications.
+\begin{tabular}{@{}p{8cm}}
+\texttt{from yt.pmods import *} \textemdash\ Load yt faster when in parallel.
+This replaces the usual \texttt{from yt.mods import *}.\\
+\texttt{parallel\_objects()} \textemdash\ A way to parallelize analysis over objects
+(such as halos or clumps).\\
 
+\end{tabular}
 
+\subsection{Pre-Installed Versions}
+\settowidth{\MyLen}{\texttt{multicol}}
+yt is pre-installed on several supercomputer systems.
+\begin{tabular}{@{}p{8cm}}
+\textbf{NICS Kraken} \textemdash\ {\it module load yt} \\
+\end{tabular}
+
+\subsection{Mercurial}
+\settowidth{\MyLen}{\texttt{multicol}}
+Please see \url{http://mercurial.selenic.com/} for the full Mercurial documentation.
+\begin{tabular}{@{}p{8cm}}
+\texttt{hg clone https://bitbucket.org/yt\_analysis/yt} \textemdash\ Clone a copy of yt. \\
+\texttt{hg status} \textemdash\ Files changed in working directory.\\
+\texttt{hg diff} \textemdash\ Print diff of all changed files in working directory. \\
+\texttt{hg diff -r{\it RevX} -r{\it RevY}} \textemdash\ Print diff of all changes between revision {\it RevX} and {\it RevY}.\\
+\texttt{hg log} \textemdash\ History of changes.\\
+\texttt{hg cat -r{\it RevX file}} \textemdash\ Print the contents of {\it file} from revision {\it RevX}.\\
+\texttt{hg heads} \textemdash\ Print all the current heads. \\
+\texttt{hg revert -r{\it RevX file}} \textemdash\ Revert {\it file} to revision {\it RevX}. On-disk changed version is
+moved to {\it file.orig}. \\
+\texttt{hg commit} \textemdash\ Commit changes to repository. \\
+\texttt{hg push} \textemdash\ Push changes to default remote repository. \\
+\texttt{hg pull} \textemdash\ Pull changes from default remote repository. \\
+\texttt{hg serve} \textemdash\ Launch a webserver on the local machine to examine the repository in a web browser. \\
+\end{tabular}
+
+\subsection{FAQ}
+\settowidth{\MyLen}{\texttt{multicol}}
+\begin{tabular}{@{}p{8cm}}
+\texttt{pf.field\_info[`field'].take\_log = False} \textemdash\ When plotting \texttt{field}, do not take log.
+Must enter \texttt{pf.h} before this command. \\
 \end{tabular}
 
 %\rule{0.3\linewidth}{0.25pt}
@@ -325,6 +366,6 @@
 
 % Can put some final stuff here like copyright etc...
 
+\end{multicols}
 
-\end{multicols}
 \end{document}
\ No newline at end of file


https://bitbucket.org/yt_analysis/yt-doc/commits/d8cfe267683c/
changeset:   d8cfe267683c
user:        sskory
date:        2013-01-30 21:18:47
summary:     Merge.
affected #:  14 files

diff -r 4f70020a33115f5f4bb30793e7d6b1dac527e888 -r d8cfe267683cfd821e435c97dfa453c8825e7f03 .hgtags
--- a/.hgtags
+++ b/.hgtags
@@ -1,2 +1,5 @@
+ae96e6783ef6fe12b9d9ffd2c370b26b5de183b1 2.2
+67134a1d1c3fde038544147b0bc5f0319dd806eb 2.3
 ae96e6783ef6fe12b9d9ffd2c370b26b5de183b1 2.2-build1
 67134a1d1c3fde038544147b0bc5f0319dd806eb 2.3-build1
+1cc371e712eefa92fb2c6871475c05870eed840f 2.4

diff -r 4f70020a33115f5f4bb30793e7d6b1dac527e888 -r d8cfe267683cfd821e435c97dfa453c8825e7f03 source/conf.py
--- a/source/conf.py
+++ b/source/conf.py
@@ -53,9 +53,9 @@
 # built documents.
 #
 # The short X.Y version.
-version = '2.4'
+version = '2.5'
 # The full version, including alpha/beta/rc tags.
-release = '2.4'
+release = '2.5dev'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.

diff -r 4f70020a33115f5f4bb30793e7d6b1dac527e888 -r d8cfe267683cfd821e435c97dfa453c8825e7f03 source/configuration.rst
--- a/source/configuration.rst
+++ b/source/configuration.rst
@@ -92,12 +92,18 @@
   log files?
 * ``maximumstoredpfs`` (default: ``'500'``): How many parameter files should be
   tracked between sessions?
+* ``notebook_password`` (default: empty): If set, this will be fed to the
+  IPython notebook created by ``yt notebook``.  Note that this should be an
+  sha512 hash, not a plaintext password.  Starting ``yt notebook`` with no
+  setting will provide instructions for setting this.
 * ``onlydeserialize`` (default: ``'False'``): If true, only pull from .yt files,
   never add to them.
 * ``parameterfilestore`` (default: ``'parameter_files.csv'``): The name of the file
   in ``$HOME/.yt/`` in which parameter files will be tracked.
 * ``pluginfilename``  (default ``'my_plugins.py'``) The name of our plugin file.
 * ``serialize`` (default: ``'True'``): Are we allowed to write to the ``.yt`` file?
+* ``sketchfab_api_key`` (default: empty): API key for http://sketchfab.com/ for
+  uploading AMRSurface objects.
 * ``storeparameterfiles`` (default: ``'False'``): Should we track parameter files
   between sessions?
 * ``suppressStreamLogging`` (default: ``'False'``): If true, execution mode will be

diff -r 4f70020a33115f5f4bb30793e7d6b1dac527e888 -r d8cfe267683cfd821e435c97dfa453c8825e7f03 source/cookbook/complex_plots.rst
--- a/source/cookbook/complex_plots.rst
+++ b/source/cookbook/complex_plots.rst
@@ -147,3 +147,28 @@
 volume rendering.
 
 .. yt_cookbook:: amrkdtree_downsampling.py
+
+Plotting Streamlines
+~~~~~~~~~~~~~~~~~~~~
+
+This recipe demonstrates how to display streamlines in a simulation.  (Note:
+streamlines can also be queried for values!)
+
+.. yt_cookbook:: streamlines.py
+
+Plotting Isocontours
+~~~~~~~~~~~~~~~~~~~~
+
+This recipe demonstrates how to extract an isocontour and then plot it in
+matplotlib, coloring the surface by a second quantity.
+
+.. yt_cookbook:: surface_plot.py
+
+Plotting Isocontours and Streamlines
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+This recipe plots both isocontours and streamlines simultaneously.  Note that
+this will not include any blending, so streamlines that are occluded by the
+surface will still be visible.
+
+.. yt_cookbook:: streamlines_isocontour.py

diff -r 4f70020a33115f5f4bb30793e7d6b1dac527e888 -r d8cfe267683cfd821e435c97dfa453c8825e7f03 source/cookbook/streamlines.py
--- /dev/null
+++ b/source/cookbook/streamlines.py
@@ -0,0 +1,22 @@
+from yt.mods import *
+from yt.visualization.api import Streamlines
+
+pf = load("IsolatedGalaxy/galaxy0030/galaxy0030")
+c = np.array([0.5]*3)
+N = 100
+scale = 1.0
+pos_dx = np.random.random((N,3))*scale-scale/2.
+pos = c+pos_dx
+
+streamlines = Streamlines(pf,pos,'x-velocity', 'y-velocity', 'z-velocity', length=1.0) 
+streamlines.integrate_through_volume()
+
+import matplotlib.pylab as pl
+from mpl_toolkits.mplot3d import Axes3D
+fig=pl.figure() 
+ax = Axes3D(fig)
+for stream in streamlines.streamlines:
+    stream = stream[np.all(stream != 0.0, axis=1)]
+    ax.plot3D(stream[:,0], stream[:,1], stream[:,2], alpha=0.1)
+pl.savefig('streamlines.png')
+

diff -r 4f70020a33115f5f4bb30793e7d6b1dac527e888 -r d8cfe267683cfd821e435c97dfa453c8825e7f03 source/cookbook/streamlines_isocontour.py
--- /dev/null
+++ b/source/cookbook/streamlines_isocontour.py
@@ -0,0 +1,35 @@
+from yt.mods import *
+from yt.visualization.api import Streamlines
+
+pf = load("IsolatedGalaxy/galaxy0030/galaxy0030")
+c = np.array([0.5]*3)
+N = 30
+scale = 15.0/pf['kpc']
+pos_dx = np.random.random((N,3))*scale-scale/2.
+pos = c+pos_dx
+
+streamlines = Streamlines(pf,pos,'x-velocity', 'y-velocity', 'z-velocity', length=1.0) 
+streamlines.integrate_through_volume()
+
+import matplotlib.pylab as pl
+from mpl_toolkits.mplot3d import Axes3D
+from mpl_toolkits.mplot3d.art3d import Poly3DCollection
+fig=pl.figure() 
+ax = Axes3D(fig)
+for stream in streamlines.streamlines:
+    stream = stream[np.all(stream != 0.0, axis=1)]
+    ax.plot3D(stream[:,0], stream[:,1], stream[:,2], alpha=0.1)
+
+
+sphere = pf.h.sphere("max", (1.0, "mpc"))
+surface = pf.h.surface(sphere, "Density", 1e-24)
+colors = apply_colormap(np.log10(surface["Temperature"]), cmap_name="hot")
+
+p3dc = Poly3DCollection(surface.triangles, linewidth=0.0)
+colors = colors[0,:,:]/255.
+colors[:,3] = 0.3
+p3dc.set_facecolors(colors)
+ax.add_collection(p3dc)
+
+pl.savefig('streamlines_isocontour.png')
+

diff -r 4f70020a33115f5f4bb30793e7d6b1dac527e888 -r d8cfe267683cfd821e435c97dfa453c8825e7f03 source/cookbook/surface_plot.py
--- /dev/null
+++ b/source/cookbook/surface_plot.py
@@ -0,0 +1,20 @@
+from mpl_toolkits.mplot3d import Axes3D
+from mpl_toolkits.mplot3d.art3d import Poly3DCollection
+import matplotlib.pyplot as plt
+from yt.mods import *
+
+pf = load("IsolatedGalaxy/galaxy0030/galaxy0030")
+sphere = pf.h.sphere("max", (1.0, "mpc"))
+surface = pf.h.surface(sphere, "Density", 1e-25)
+colors = apply_colormap(np.log10(surface["Temperature"]), cmap_name="hot")
+
+fig = plt.figure()
+ax = fig.gca(projection='3d')
+p3dc = Poly3DCollection(surface.triangles, linewidth=0.0)
+
+p3dc.set_facecolors(colors[0,:,:]/255.)
+ax.add_collection(p3dc)
+ax.auto_scale_xyz(surface.vertices[0,:], surface.vertices[1,:], surface.vertices[2,:])
+ax.set_aspect(1.0)
+
+plt.savefig("%s_Surface.png" % pf)

diff -r 4f70020a33115f5f4bb30793e7d6b1dac527e888 -r d8cfe267683cfd821e435c97dfa453c8825e7f03 source/index.rst
--- a/source/index.rst
+++ b/source/index.rst
@@ -2,27 +2,31 @@
 ===========
 
 yt is a community-developed analysis and visualization toolkit for
-astrophysical simulation data.  yt provides full support for the `Enzo
-<http://enzo.googlecode.com/>`_, Orion, `Nyx
-<https://ccse.lbl.gov/Research/NYX/index.html>`_, and `FLASH codes
-<http://flash.uchicago.edu/website/home/>`_, with preliminary support for
-`RAMSES
-<http://irfu.cea.fr/Phocea/Vie_des_labos/Ast/ast_sstechnique.php?id_ast=904>`_,
-ART, and Maestro.
-It runs both interactively and
+astrophysical simulation data.  yt runs both interactively and
 non-interactively, and has been designed to support as many operations as
-possible in parallel. For more detailed information, see our `ApJS paper
-<http://adsabs.harvard.edu/abs/2011ApJS..192....9T>`_.
+possible in parallel. 
 
-To install ``yt``, see :ref:`orientation` or :ref:`installing-yt`.  To see
-what's new since the last version, check out :ref:`changelog`.
+yt provides full support for several simulation codes in the current release:
+
+ * `Enzo <http://enzo-project.org/>`_ Orion, 
+ * Orion
+ * `Nyx <https://ccse.lbl.gov/Research/NYX/index.html>`_
+ * `FLASH <http://flash.uchicago.edu/website/home/>`_
+ * Piernik
+
+We also provide limited support for Castro, NMSU-ART, and Maestro.  A limited
+amount of RAMSES IO is provided, but full support  for RAMSES will not be
+completed until the 3.0 release of yt.
 
 If you use ``yt`` in a paper, you are highly encouraged to submit the
 repository containing the scripts you used to analyze and visualize your data
-to the `yt Hub <http://hub.yt-project.org/>`_, and we ask that you consider citing
-our `method paper <http://adsabs.harvard.edu/abs/2011ApJS..192....9T>`_, as
-well.  If you are looking to use ``yt``, then check out the `yt Hub <http://hub.yt-project.org/>`_ for ideas of how other people used ``yt`` to generate worthwhile analysis.  We encourage you to explore the source code and even consider
-:ref:`contributing <contributing-code>` your enhancements and scripts.
+to the `yt Hub <http://hub.yt-project.org/>`_, and we ask that you consider
+citing our `method paper <http://adsabs.harvard.edu/abs/2011ApJS..192....9T>`_,
+as well.  If you are looking to use ``yt``, then check out the `yt Hub
+<http://hub.yt-project.org/>`_ for ideas of how other people used ``yt`` to
+generate worthwhile analysis.  We encourage you to explore the source code and
+even consider :ref:`contributing <contributing-code>` your enhancements and
+scripts.
 
 For more information, please visit `our homepage <http://yt-project.org/>`_
 and for help, please see :ref:`asking-for-help`.

diff -r 4f70020a33115f5f4bb30793e7d6b1dac527e888 -r d8cfe267683cfd821e435c97dfa453c8825e7f03 source/interacting/ipython_notebook.rst
--- a/source/interacting/ipython_notebook.rst
+++ b/source/interacting/ipython_notebook.rst
@@ -12,7 +12,7 @@
 
 A sample notebook, demonstrating some of the functionality of both yt 2.4 and
 the IPython notebook (as exposed through yt) can be found at
-http://yt-project.org/files/yt24demo.ipynb .
+http://yt-project.org/files/yt24.ipynb .
 
 There are two main things that yt exposes to the IPython notebook: displaying
 PlotWindow objects and displaying Volume Renderings.  Both of these are exposed

diff -r 4f70020a33115f5f4bb30793e7d6b1dac527e888 -r d8cfe267683cfd821e435c97dfa453c8825e7f03 source/visualizing/image_panner.rst
--- a/source/visualizing/image_panner.rst
+++ /dev/null
@@ -1,248 +0,0 @@
-.. _image-panner:
-
-The AMR Image Panner
-====================
-.. versionadded:: 1.7
-
-The mechanism for creating images from reduced 2D AMR data in yt is to feed
-that data through a pixelization routine, which takes a flattened array of
-pixel locations, widths and values and returns a 2D buffer of data suitable for
-plotting as an image.  This enables us to pan and zoom virtually at will, with
-no extra cost from re-projecting the simulation.
-
-Typically, this is all hidden from the user: the plot interface mostly just
-lets you describe your plot, rather than describe moving around inside the
-plot.  But, with the image panning extension, you have more freedom: tools can
-be built on top of the pixelization routine, so that updated buffers as the
-user moves around in a given dataset can be used for things like image plotting
-and display.
-
-The image panning object is utilized as a frontend to the data; it provides
-actions to pan and zoom an imaginary porthole on the data.  When the bounds are
-updated, the image is re-created that corresponds to those bounds and an
-optional callback is called.  The image panner object should be viewed more as
-a component in a larger system, rather than anything that's particularly useful
-on its own.  However, in the yt code there are already a few plugins that
-utilize the image panner to do some interesting things.
-
-An image panner is uniquely defined by:
-
- * Source: this is the AMR2D Data that provides the data to be pixelized.  As
-   of right now, this can only be slices or projections.
- * Size: this is the size of the buffer to pixelize.
- * Field: this is the field to pixelize, from the source.
-
-"Callbacks" can be provided as well.  The idea behind a callback is that every
-time either the image buffer or the image viewport is changed the callbacks are
-called with the new information, so that any dependent routines can then be
-called.  This way, routines that rely on images or viewport information are
-called only when necessary.
-
-When the image panning extension is imported, most of the image panner classes
-and subclasses are registered to hang off the hierarchy object, as all other
-data objects do.  This module is documented in :ref:`image-panner-api`.
-
-Now, for some examples!
-
-Interactive Motion and Image Saving
------------------------------------
-
-This is the simplest example, where a callback is provided that saves an image
-every time the pixelized image is updated.  The components of this are provided
-in the distribution, so only a minimal set of code is necessary.  Here's a
-fiducial example, assuming that we just want to save out every time we change
-the image:
-
-.. code-block:: python
-
-   import yt.extensions.image_panner
-   from yt.mods import *
-   
-   pf = load("RD0005-mine/RedshiftOutput0005")
-   proj = pf.h.proj(0, "Density", "Density")
-   
-   saver = yt.extensions.image_panner.ImageSaver(0)
-   ip = pf.h.image_panner(proj, (512, 512), "Density", callback = saver)
-
-At this point, the *ip* object is set up, and it can accept commands.  Every
-time a zoom or pan command is issued, it will re-save a file in the current
-working directory called ``wimage_000.png`` (the 000 comes from feeding the
-ImagerSaver "0" during instantiation.)  So, for instance, we start out by
-initiating our first save:
-
-.. code-block:: python
-
-   ip.zoom(1.0)
-
-This sets the scale nicely, and we have this image saved out:
-
-.. image:: _images/ip_saver_0.png
-   :width: 256
-
-This is the full domain.  We can now zoom in:
-
-.. code-block:: python
-
-   ip.zoom(3.0)
-
-and we re-load our ``wimage_000.png`` file:
-
-.. image:: _images/ip_saver_1.png
-   :width: 256
-
-But now we see a little halo in the lower right.  So, we can pan over there.
-There are two ways to pan -- either by absolute values or by values specified
-relative to the current viewport size.  We'll use the latter, and it looks to
-me to be about 25% of the viewport to get over to that halo.
-
-.. code-block:: python
-
-   ip.pan_rel( (0.25, 0.25) )
-
-And reloading our image, we see:
-
-.. image:: _images/ip_saver_2.png
-   :width: 256
-
-We've successfully centered!
-
-Windowed Rendering
-------------------
-
-Another possibility is that you'd like to have multiple pixelized tiles
-rendered out, but you only want to have one controller process.  This is more
-useful when the rendering processes occur in separate processes, but the
-sequential generation of tiles is abstracted in this interface.
-
-Note that here, unlike above, we supply a different number to each instance of
-the ImageSaver.  This lets us generating multiple tiles at a time.
-
-.. code-block:: python
-
-   import yt.extensions.image_panner as image_panner
-   from yt.mods import *
-   
-   pf = load("RD0005-mine/RedshiftOutput0005")
-   proj = pf.h.proj(0, "Density", "Density")
-   
-   ws = []
-   
-   saver = yt.extensions.image_panner.ImageSaver(0)
-   ws.append(pf.h.windowed_image_panner(proj, (1024, 1024), (512, 512),
-             (0, 0), "Density", callback = saver))
-   
-   saver = yt.extensions.image_panner.ImageSaver(1)
-   ws.append(pf.h.windowed_image_panner(proj, (1024, 1024), (512, 512),
-             (512, 0), "Density", callback = saver))
-   
-   saver = yt.extensions.image_panner.ImageSaver(2)
-   ws.append(pf.h.windowed_image_panner(proj, (1024, 1024), (512, 512),
-             (0, 512), "Density", callback = saver))
-   
-   saver = yt.extensions.image_panner.ImageSaver(3)
-   ws.append(pf.h.windowed_image_panner(proj, (1024, 1024), (512, 512),
-             (512, 512), "Density", callback = saver))
-   
-   mwvmp = image_panner.MultipleWindowVariableMeshPanner(ws)
-
-The creation of windowed image panners is slightly different than standard
-image panners: each one is explicitly told how big the final image is, and
-how big their portion is, and the index at which they should start.  Finally,
-this list is supplied to an instance of a controller object.
-
-When the following code is executed:
-
-.. code-block:: python
-
-   mwvmp.zoom(1.0)
-
-four new 512x512 images will be output covering each of the individual regions
-"owned" by each windowed panner.  The final image can be constructed by
-stitching these sub-images together.  Why is this useful?  Well, we can also
-dispatch the rendering jobs to remote nodes!
-   
-Remote Windowed Rendering
--------------------------
-
-In the section `interactive-parallel`, the process of launching an
-IPython-based controller and engines system is described.  That discussion
-won't be repeated here too extensively, but if you simply launch several
-``ipengine`` instances and an ``ipcontroller`` -- either locally or remotely --
-you can utilize a parallel version of the windowed renderer.
-
-.. warning::
-   Note that by default ``ipcontroller`` opens up ports!  It is recommended
-   that you supply the argument ``--engine-ip=127.0.0.1`` to ensure only local
-   connections are allowed.  SSH tunnelling can then be used to connect to the
-   controller.
-
-Note that you can also supply callbacks to the remote nodes -- this is the
-basis of a future enhancement, where this interface will be used to drive a
-tiled display wall, and each render node will supply a large pixelized image to
-corresponding its own tile, to be displayed at full resolution.
-
-The interface here is similar to the windowed rendering above, but it will
-attempt to dispatch to engines running on the IPython MultiEngineClient
-interface instead of creating objects locally.
-
-.. code-block:: python
-
-   import yt.extensions.image_panner
-   from yt.mods import *
-   
-   pf = load("/Users/matthewturk/Research/data/RD0005-mine/RedshiftOutput0005")
-   proj = pf.h.proj(0, "Density", "Density")
-   
-   rvmp = pf.h.remote_image_panner(proj)
-   
-   rvmp.add_window( (1024, 1024), (512, 512), (0, 0), "Density")
-   rvmp.add_window( (1024, 1024), (512, 512), (512, 0), "Density")
-   rvmp.add_window( (1024, 1024), (512, 512), (0, 512), "Density")
-   rvmp.add_window( (1024, 1024), (512, 512), (512, 512), "Density")
-   
-   rvmp.zoom(1.0)
-
-The implicit callback supplied to the remote objects is a saver, with the tile
-ID as the image name: so all of these will save out ``wimage_XXX.png`` files,
-where ``XXX`` is the tile ID of that window.
-
-Native Map Interface
---------------------
-
-If you have `Chaco <http://code.enthought.com/chaco/>`_ installed, either by
-itself or as part of the full Enthought Tool Suite, you can use a pan and zoom
-interface like Google Maps to explore your data.
-
-The script to initiate this is relatively simple and very similar to what
-is used above:
-
-.. code-block:: python
-
-   import yt.extensions.image_panner
-   from yt.mods import *
-   
-   pf = load("RD0005-mine/RedshiftOutput0005")
-   proj = pf.h.proj(0, "Density", "Density")
-   
-   ip = pf.h.image_panner(proj, (512, 512), "Density")
-   from yt.extensions.image_panner.pan_and_scan_widget \
-       import VariableMeshPannerView
-   vmpv = VariableMeshPannerView(panner = ip)
-   vmpv.configure_traits()
-
-Here's a screencast of me using it to explore a big dataset.
-
-.. raw:: html
-
-   <div id="v7570">
-   <a href="http://www.macromedia.com/go/getflashplayer">Get the Flash Player</a> to see this video.
-   </div>
-   <script type="text/javascript" src="https://media.dreamhost.com/mp4/swfobject.js"></script>
-   <script type="text/javascript">
-   var swf = new SWFObject("https://media.dreamhost.com/mp4/player.swf", "mpl", "201", "211", 8);
-   swf.addParam("allowfullscreen", "true");
-   swf.addParam("allowscriptaccess", "always");
-   swf.addVariable("file", "http://yt-project.org/files/20100328_chaco_ui_conv.flv");
-   swf.addVariable("image", "http://yt-project.org/files/20100328_chaco_ui_conv.jpeg");
-   swf.write("v7570");
-   </script>

diff -r 4f70020a33115f5f4bb30793e7d6b1dac527e888 -r d8cfe267683cfd821e435c97dfa453c8825e7f03 source/visualizing/index.rst
--- a/source/visualizing/index.rst
+++ b/source/visualizing/index.rst
@@ -8,6 +8,5 @@
    callbacks
    manual_plotting
    volume_rendering
-   image_panner
    streamlines
 

diff -r 4f70020a33115f5f4bb30793e7d6b1dac527e888 -r d8cfe267683cfd821e435c97dfa453c8825e7f03 source/visualizing/plots.rst
--- a/source/visualizing/plots.rst
+++ b/source/visualizing/plots.rst
@@ -12,11 +12,10 @@
 many example scripts in :ref:`cookbook`.
 
 There are currently two plotting interfaces available in ``yt``. The
-:class:`~yt.visualization.plot_window.PlotWindow` interface is useful
-for taking a quick look at simulation outputs.  The ``PlotCollection``
-interface is best for in-depth analysis of a simulation, allowing a
-collection of plots to be set up, rendered, and saved simultaneously.
-Below we will summarize how to use both plotting interfaces.
+:class:`~yt.visualization.plot_window.PlotWindow` interface is useful for
+taking a quick look at simulation outputs.  The ``PlotCollection`` interface
+was previously used to generate all types of plots, but is now primarily left
+as a mechanism for easily generating profile and phase plots.
 
 .. _simple-inspection:
 
@@ -24,10 +23,10 @@
 ----------------------
 
 If you need to take a quick look at a single simulation output, ``yt``
-provides the ``PlotWindow`` interface for quickly generating annotated
-2D visualizations of simulation data.  You can create a ``PlotWindow``
-plot by supplying a parameter file, a list of fields to plot, and a
-plot center to create a :class:`~yt.visualization.plot_window.SlicePlot`,
+provides the ``PlotWindow`` interface for generating annotated 2D
+visualizations of simulation data.  You can create a ``PlotWindow`` plot by
+supplying a parameter file, a list of fields to plot, and a plot center to
+create a :class:`~yt.visualization.plot_window.SlicePlot`,
 :class:`~yt.visualization.plot_window.ProjectionPlot`, or
 :class:`~yt.visualization.plot_window.OffAxisSlicePlot`.
 
@@ -55,13 +54,13 @@
 
    from yt.mods import *
    pf = load("RedshiftOutput0005")
-   slc = SlicePlot(pf,2,'Density',[0.2,0.3,0.8],(20,'kpc'))
+   slc = SlicePlot(pf, 'z', 'Density',[0.2,0.3,0.8],(20,'kpc'))
    slc.save()
 
 The above example will display an annotated plot of a slice of the
 Density field in a 20 kpc square window centered on the coordinate
 (0.2,0.3) in the x-y plane.  The axis to slice along is keyed to the
-number 2, corresponding to the z-axis.  Finally, the image is saved to
+letter 'z', corresponding to the z-axis.  Finally, the image is saved to
 a png file.
 
 Conceptually, you can think of the SlicePlot as an adjustable window
@@ -71,7 +70,7 @@
 
    from yt.mods import *
    pf = load("RedshiftOutput0005")
-   slc = SlicePlot(pf,2,'Pressure')
+   slc = SlicePlot(pf, 'z','Pressure')
    slc.save()
    slc.zoom(10)
    slc.save('zoom')
@@ -92,7 +91,7 @@
 
    from yt.mods import *
    pf = load("RedshiftOutput0005")
-   slc = SlicePlot(pf,0,'VorticitySquared',width=(10,'au'),center='max')
+   slc = SlicePlot(pf, 'x', 'VorticitySquared',width=(10,'au'),center='max')
    slc.annotate_grids()
    slc.save()
 
@@ -176,15 +175,12 @@
 :class:`~yt.visualization.plot_collection.PlotCollection` is
 instantiated with a given parameter file and (optionally) a center.
 
-At this point we can add various plots to our plot collection.  For starters,
-we'll take a look at creating images.  Images can be created from data in a
-variety of ways.  For the most part, it's easier to think of the image as an
-"operator" that acts on a dataset, retrieving and then processing that data
-before it is returned as an image.  Things like the number of pixels, the
-colormap, the (simulation-space) bounds of the image and other
-*visualization*-specific attributes are set after the data is handled and
-processed.  This leads to much more rapid iteration of image properties than
-would normally be possible.
+.. warning:: The plot collection has largely been supplanted by the PlotWindow
+             and nowadays is only useful for profiles and phase plots!
+
+At this point we can add various plots to our plot collection.  We will only
+look at profiles and phase plots, as image-type plots are best handled by
+the plot window described above.
 
 .. note:: Whenever a plot is added to a plot collection, that plot object is
           appended to the list ``plots`` on the PlotCollection, where it can be
@@ -207,129 +203,6 @@
 include that set of values, the most dense point would have been found
 and used.
 
-.. _how-to-make-slices:
-
-Slices
-~~~~~~
-
-Slices are axially-aligned images of data selected at a fixed point on an axis;
-these are the fastest type of two-dimensional image, as only the correct
-coordinate data is read from disk and then plotted.  To add one to a
-:class:`~yt.visualization.plot_collection.PlotCollection` you would use the
-method :meth:`~yt.visualization.plot_collection.PlotCollection.add_slice`,
-supplying it the field to slice and the axis along which you want the slice to
-be taken.
-
-For instance, to take a single slice along the 0th (x) axis:
-
-.. code-block:: python
-
-   pc.add_slice("Density", 0)
-
-This creates a slice through the x-axis located at the center of the plot
-collection.  It's initially filled with the "Density" values (but that can be
-changed with
-:meth:`~yt.visualization.plot_collection.PlotCollection.switch_field`) and is
-set to the width of the full domain.  Below, in
-:ref:`how-to-control-image-plots`, we talk about how to change the viewport.
-
-.. _how-to-make-projections:
-
-Projections
-~~~~~~~~~~~
-
-Projections are closer in style to profiles than slices.  They can exist either
-as a summation of the data along every possible ray through the simulation, or
-an average value along every possible ray.  If a *weight_field* is provided,
-then the data returned is an average; typically you will want to weight with
-``Density``.  If you do not supply a *weight_field* then the returned data is a
-column sum.  These fields are stored in between invocations -- this allows for
-speedier access to a relatively slow process.
-
-To create a projection, you would use the method
-:meth:`~yt.visualization.plot_collection.PlotCollection.add_slice`.  For
-instance, to project Density along the 1st (y) axis:
-
-.. code-block:: python
-
-   pc.add_projection("Density", 1)
-
-Because we have supplied no *weight_field*, we are given back an integration of
-the "Density" along the axis.  Density is expressed in grams per cubic
-centimeter, so an integration would return density in grams per square
-centimeter.  If we wanted the average Temperature, weighted by Density (a
-common task) we would instead call the method like this:
-
-.. code-block:: python
-
-   pc.add_projection("Temperature", 1, "Density")
-
-Because we're taking an average, we are given back a Temperature, not an
-integration of Temperature.  Below, in :ref:`how-to-control-image-plots`, we
-talk about how to change the viewport.
-
-.. _how-to-make-oblique-slices:
-
-Oblique Slices
-~~~~~~~~~~~~~~
-
-Oblique slices, also called "cutting planes", are slices that are not axially
-aligned, but instead aligned with a given normal vector.  These can be used for
-face-on images of disks and other objects, as well as a rotational slices.
-They work just like slices in other ways, but they tend to be a bit slower.
-
-You can add an oblique slice to a plot collection using :meth:`~yt.visualization.plot_collection.PlotCollection.add_cutting_plane`,
-which accepts as its arguments the field and the normal vector to the desired
-plane.  If we wanted to cut through the simulation with a normal vector of
-[0.4, 0.1, 0.9] we would call the method with these arguments:
-
-.. code-block:: python
-
-   pc.add_cutting_plane("Density", [0.4, 0.1, 0.9])
-
-Note that we can use any vector here, which means we could (for instance)
-calculate the angular momentum vector of some region and supply that.  Below,
-in :ref:`how-to-control-image-plots`, we talk about how to change the viewport.
-
-.. _how-to-control-image-plots:
-
-Controlling Image Plots
-~~~~~~~~~~~~~~~~~~~~~~~
-
-Slices, projections and oblique slices can all be modified in a number of ways.
-The most important of these is setting the viewport.  This can be done using
-the method :meth:`~yt.visualization.plot_collection.PlotCollection.set_width`.
-This method accepts both a value and a unit.  For instance:
-
-.. code-block:: python
-
-   pc.set_width(100, 'au')
-
-would set the viewport of *all* the attached plots to be 100 AU.  Note that
-this means you can add multiple plots -- a projection, a slice, or even 
-slices of different quantities -- and set the viewport for all of them with a
-single command.
-
-In the case of profiles, it is also useful to be able to manually select the axes range. By default, ``yt`` will automatically select a plot axes range suitable for the data being displayed, but if you wish to override this (for instance, to ensure a time sequence of plots remain on the same scale), you can use:
-
-.. code-block:: python
-
-   p = pc.add_profile_object(my_galaxy, ["Density", "Temperature"])
-   p.set_xlim(1e-25, 1e-20)
-   p.set_ylim(1e3, 1e8)
-
-For images, the colorbar can be adjusted similarly to the above with :meth:`~yt.visualization.plot_collection.PlotCollection.set_zlim`. Labels can be set with :meth:`~yt.visualization.plot_collection.PlotCollection.set_label`
-and color maps can be changed with
-:meth:`~yt.visualization.plot_collection.PlotCollection.set_cmap`.  There are
-several other modifications that can be made, as discussed in the documentation
-for :class:`~yt.visualization.plot_collection.PlotCollection`.
-
-In addition, and as discussed in :ref:`callbacks`, a number of modifications
-can be made to a plot.  This includes velocity vectors, contours, particle
-plotting, and so on.
-
-
-
 .. _how-to-make-1d-profiles:
 
 1D Profiles
@@ -438,10 +311,30 @@
 Interactive Plotting
 ~~~~~~~~~~~~~~~~~~~~
 
-Thanks to the pylab interface in Matplotlib, we have an interactive plot
-collection available for usage within ``IPython``.  Instead of
-:class:`~yt.visualization.plot_collection.PlotCollection`, use
-:class:`~yt.visualization.plot_collection.PlotCollectionInteractive` -- this
-will generate automatically updating GUI windows with the plots inside them.
-You will need to use an appropriate :ref:`Matplotlib Backend <mpl-shell>` such
-as ``TkAgg`` or ``MacAgg``, however.
+The best way to interactively plot data is through the IPython notebook.  Many
+detailed tutorials on using the IPython notebook can be found at
+http://ipython.org/presentation.html , but the simplest way to use it is to
+type:
+
+.. code-block:: bash
+
+   yt notebook
+
+at the command line.  This will prompt you for a password (so that if you're on
+a shared user machine no one else can pretend to be you!) and then spawn an
+IPython notebook you can connect to.  You need to additionally change the
+import statement you use:
+
+.. code-block:: python
+
+   from yt.imods import *
+
+This will set up a number of helper functions and enable interactive plotting.
+Now when you create a plot window you can call ``.show()`` to see it inline:
+
+.. code-block:: python
+
+   p = ProjectionPlot(pf, "x", "Density")
+   p.show()
+
+The image will appear inline.

diff -r 4f70020a33115f5f4bb30793e7d6b1dac527e888 -r d8cfe267683cfd821e435c97dfa453c8825e7f03 source/welcome/derived_fields.rst
--- a/source/welcome/derived_fields.rst
+++ b/source/welcome/derived_fields.rst
@@ -1,23 +1,21 @@
 Derived Fields and Derived Quantities
 -------------------------------------
 
-While the heart of ``yt`` is the large set of basic code, physical,
-reduced, and plot objects already developed, in a metaphorical sense,
-its 'soul' is the fact that any of the objects can be used as starting
-points for creating fields and quantities of your own devices. Derived
-quantities and derived fields are the physical objects ``yt`` creates
-from the ``primitive`` variables the AMR code stores. These may or may
-not be the so-called primitive variables of fluid dynamics (density,
-velocity, energy): they are whatever your AMR code writes to
-disk. 
+While the primary attraction of ``yt`` is the large set of basic code,
+physical, reduced, and plot objects already developed, at its core is the fact
+that any of the objects can be used as starting points for creating fields and
+quantities of your own devices. Derived quantities and derived fields are the
+physical objects ``yt`` creates from the "primitive" variables the simulation
+code stores. These may or may not be the so-called primitive variables of fluid
+dynamics (density, velocity, energy): they are whatever your simulation code
+writes to disk. 
 
-Derived quantities are those data products derived from these
-variables such that the total amount of returned data is *less* than
-the number of cells. Derived fields, on the other hand, return a field
-with *equal* numbers of cells and the same geometry as the primitive
-variables from which it was derived. For example, ``yt`` could compute
-the gravitational potential at every point in space reconstructed from
-the density field.
+Derived quantities are those data products derived from these variables such
+that the total amount of returned data is *less* than the number of cells.
+Derived fields, on the other hand, return a field with *equal* numbers of cells
+and the same geometry as the primitive variables from which it was derived. For
+example, ``yt`` could compute the gravitational potential at every point in
+space reconstructed from the density field.
 
 ``yt`` already includes a large number of both derived fields and quantities,
 but its real power is that it is easy to create your own. See

diff -r 4f70020a33115f5f4bb30793e7d6b1dac527e888 -r d8cfe267683cfd821e435c97dfa453c8825e7f03 source/welcome/index.rst
--- a/source/welcome/index.rst
+++ b/source/welcome/index.rst
@@ -1,7 +1,10 @@
 Welcome to yt
 =============
 
-While not necessary to get the guts of yt up and running, this section provides a primer on the functionality, motivation, and philosophy of yt, which will prove fruitful when trying to understand why and how to activate different features in yt later on.
+While not necessary to get the guts of yt up and running, this section provides
+a primer on the functionality, motivation, and philosophy of yt, which will
+prove fruitful when trying to understand why and how to activate different
+features in yt later on.
 
 .. toctree::
    :maxdepth: 2


https://bitbucket.org/yt_analysis/yt-doc/commits/54e5330b2613/
changeset:   54e5330b2613
user:        sskory
date:        2013-01-30 21:22:33
summary:     Adding pmods to parallel_computation.rst.
affected #:  1 file
Diff not available.

Repository URL: https://bitbucket.org/yt_analysis/yt-doc/

--

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