[yt-svn] commit/yt: 6 new changesets
commits-noreply at bitbucket.org
commits-noreply at bitbucket.org
Wed Oct 22 08:45:50 PDT 2014
6 new commits in yt:
https://bitbucket.org/yt_analysis/yt/commits/2300c7b133f7/
Changeset: 2300c7b133f7
Branch: yt
User: ngoldbaum
Date: 2014-10-16 19:10:48+00:00
Summary: Adding a field plugin for fields defined in my_plugins.py. Closes #899.
These fields *should* be able to raise errors without causing the whole script
to fail. It needs to be this way because fields defined in my_plugins may only
make sense for certain datasets, yet the my_plugins.py file shouldn't need to be
edited for each dataset. The solution is to create a special field plugin that
only contains fields defined in the my_plugins.py file.
Affected #: 3 files
diff -r 39285f3a563b2d3575f6e3f4c756f4e541bd5871 -r 2300c7b133f7120b961dd02a72682df22cbb80d8 yt/fields/api.py
--- a/yt/fields/api.py
+++ b/yt/fields/api.py
@@ -26,6 +26,11 @@
from . import particle_fields
#from . import species_fields
from . import vector_operations
+from . import local_fields
+from . import my_plugin_fields
+
+from .local_fields import add_field, derived_field
+
from .derived_field import \
DerivedField, \
@@ -38,6 +43,3 @@
FieldDetector
from .field_info_container import \
FieldInfoContainer
-
-from . import local_fields
-from .local_fields import add_field, derived_field
diff -r 39285f3a563b2d3575f6e3f4c756f4e541bd5871 -r 2300c7b133f7120b961dd02a72682df22cbb80d8 yt/fields/my_plugin_fields.py
--- /dev/null
+++ b/yt/fields/my_plugin_fields.py
@@ -0,0 +1,31 @@
+"""
+This is a container for storing fields defined in the my_plugins.py file.
+
+
+
+"""
+
+#-----------------------------------------------------------------------------
+# Copyright (c) 2013, yt Development Team.
+#
+# Distributed under the terms of the Modified BSD License.
+#
+# The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+import numpy as np
+
+from .field_plugin_registry import \
+ register_field_plugin
+
+from .field_info_container import \
+ FieldInfoContainer
+
+# Empty FieldInfoContainer
+my_plugins_fields = FieldInfoContainer(None, [], None)
+
+ at register_field_plugin
+def setup_my_plugins_fields(registry, ftype="gas", slice_info=None):
+ # fields end up inside this container when added via add_field in
+ # my_plugins.py. See yt.funcs.enable_plugins to see how this is set up.
+ registry.update(my_plugins_fields)
diff -r 39285f3a563b2d3575f6e3f4c756f4e541bd5871 -r 2300c7b133f7120b961dd02a72682df22cbb80d8 yt/funcs.py
--- a/yt/funcs.py
+++ b/yt/funcs.py
@@ -14,7 +14,6 @@
#-----------------------------------------------------------------------------
import time, types, signal, inspect, traceback, sys, pdb, os, re
-import time, types, signal, inspect, traceback, sys, pdb, os, re
import contextlib
import warnings, struct, subprocess
import numpy as np
@@ -748,9 +747,10 @@
SyntaxWarning, stacklevel=2)
return cls(*args, **kwargs)
return _func
-
+
def enable_plugins():
import yt
+ from yt.fields.my_plugin_fields import my_plugins_fields
from yt.config import ytcfg
my_plugin_name = ytcfg.get("yt","pluginfilename")
# We assume that it is with respect to the $HOME/.yt directory
@@ -760,6 +760,8 @@
_fn = os.path.expanduser("~/.yt/%s" % my_plugin_name)
if os.path.isfile(_fn):
mylog.info("Loading plugins from %s", _fn)
+ execdict = yt.__dict__
+ execdict['add_field'] = my_plugins_fields.add_field
execfile(_fn, yt.__dict__)
def fix_unitary(u):
https://bitbucket.org/yt_analysis/yt/commits/e91a257e91ee/
Changeset: e91a257e91ee
Branch: yt
User: ngoldbaum
Date: 2014-10-16 19:15:17+00:00
Summary: Fixing a logic error in the previous commit.
Affected #: 1 file
diff -r 2300c7b133f7120b961dd02a72682df22cbb80d8 -r e91a257e91ee9022a81bb2533141a666290e5381 yt/funcs.py
--- a/yt/funcs.py
+++ b/yt/funcs.py
@@ -762,7 +762,7 @@
mylog.info("Loading plugins from %s", _fn)
execdict = yt.__dict__
execdict['add_field'] = my_plugins_fields.add_field
- execfile(_fn, yt.__dict__)
+ execfile(_fn, execdict)
def fix_unitary(u):
if u == '1':
https://bitbucket.org/yt_analysis/yt/commits/224070a2beb1/
Changeset: 224070a2beb1
Branch: yt
User: ngoldbaum
Date: 2014-10-16 19:16:39+00:00
Summary: Copy the dict, avoiding stomping on the main yt.__init__ dict.
Affected #: 1 file
diff -r e91a257e91ee9022a81bb2533141a666290e5381 -r 224070a2beb194afaa8bd26c3116ca4d7dac75d3 yt/funcs.py
--- a/yt/funcs.py
+++ b/yt/funcs.py
@@ -760,7 +760,7 @@
_fn = os.path.expanduser("~/.yt/%s" % my_plugin_name)
if os.path.isfile(_fn):
mylog.info("Loading plugins from %s", _fn)
- execdict = yt.__dict__
+ execdict = yt.__dict__.copy()
execdict['add_field'] = my_plugins_fields.add_field
execfile(_fn, execdict)
https://bitbucket.org/yt_analysis/yt/commits/f0b3173ad21c/
Changeset: f0b3173ad21c
Branch: yt
User: ngoldbaum
Date: 2014-10-21 23:21:36+00:00
Summary: Updating the docs page describing my_plugins.py
Affected #: 1 file
diff -r 224070a2beb194afaa8bd26c3116ca4d7dac75d3 -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 doc/source/reference/faq/index.rst
--- a/doc/source/reference/faq/index.rst
+++ b/doc/source/reference/faq/index.rst
@@ -214,26 +214,37 @@
The plugin file is a means of modifying the available fields, quantities, data
objects and so on without modifying the source code of yt. The plugin file
-will be executed if it is detected, and it must be:
+will be executed if it is detected. It must be located in a ``.yt`` folder
+in your home directory and be named ``my_plugins.py``:
.. code-block:: bash
$HOME/.yt/my_plugins.py
-The code in this file can thus add fields, add derived quantities, add
+The code in this file can add fields, define functions, define
datatypes, and on and on. It is executed at the bottom of ``yt.mods``, and so
-it is provided with the entire namespace available in the module ``yt.mods`` --
-which is the primary entry point to yt, and which contains most of the
-functionality of yt. For example, if I created a plugin file containing:
+it is provided with the entire namespace available in the module ``yt.mods``.
+For example, if I created a plugin file containing:
.. code-block:: python
def _myfunc(field, data):
return np.random.random(data["density"].shape)
- add_field("SomeQuantity", function=_myfunc)
+ add_field("some_quantity", function=_myfunc, units='')
-then all of my data objects would have access to the field "SomeQuantity"
-despite its lack of use.
+then all of my data objects would have access to the field "some_quantity".
+Note that the units must be specified as a string, see
+:ref:`data_selection_and_fields` for more details on units and derived fields.
+
+.. note::
+
+ Since the ``my_plugins.py`` is parsed inside of ``yt.mods``, you must import
+ yt using ``yt.mods`` to use the plugins file. If you import using
+ ``import yt``, the plugins file will not be parsed. You can tell that your
+ plugins file is being parsed by watching for a logging message when you
+ import yt. Note that both the ``yt load`` and ``iyt`` command line entry
+ points invoke ``from yt.mods import *``, so the ``my_plugins.py`` file
+ will be parsed if you enter yt that way.
You can also define other convenience functions in your plugin file. For
instance, you could define some variables or functions, and even import common
https://bitbucket.org/yt_analysis/yt/commits/0b5116194f20/
Changeset: 0b5116194f20
Branch: yt
User: ngoldbaum
Date: 2014-10-21 23:22:03+00:00
Summary: Merging with mainline.
Affected #: 24 files
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a doc/source/analyzing/analysis_modules/halo_transition.rst
--- a/doc/source/analyzing/analysis_modules/halo_transition.rst
+++ b/doc/source/analyzing/analysis_modules/halo_transition.rst
@@ -52,7 +52,7 @@
data_ds = yt.load('Enzo_64/RD0006/RedshiftOutput0006')
hc = HaloCatalog(data_ds=data_ds, finder_method='hop')
hc.create()
- ad = hc.all_data()
+ ad = hc.halos_ds.all_data()
masses = ad['particle_mass'][:]
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a doc/source/cookbook/gadget_notebook.rst
--- /dev/null
+++ b/doc/source/cookbook/gadget_notebook.rst
@@ -0,0 +1,7 @@
+.. _gadget-notebook:
+
+Using yt to view and analyze Gadget outputs
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+.. notebook:: yt_gadget_analysis.ipynb
+
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a doc/source/cookbook/tipsy_and_yt.ipynb
--- a/doc/source/cookbook/tipsy_and_yt.ipynb
+++ b/doc/source/cookbook/tipsy_and_yt.ipynb
@@ -1,7 +1,16 @@
{
"metadata": {
+ "kernelspec": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 2
+ },
+ "display_name": "IPython (Python 2)",
+ "language": "python",
+ "name": "python2"
+ },
"name": "",
- "signature": "sha256:2ae8b1599fa35495fa1bb8deb1c67094e3529e70093b30e20354122cd9403d9d"
+ "signature": "sha256:1f6e5cf50123ad75676f035a2a36cd60f4987832462907b9cb78cb25548d8afd"
},
"nbformat": 3,
"nbformat_minor": 0,
@@ -10,14 +19,6 @@
"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": [
@@ -193,4 +194,4 @@
"metadata": {}
}
]
-}
+}
\ No newline at end of file
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a doc/source/cookbook/yt_gadget_analysis.ipynb
--- /dev/null
+++ b/doc/source/cookbook/yt_gadget_analysis.ipynb
@@ -0,0 +1,263 @@
+{
+ "metadata": {
+ "kernelspec": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 2
+ },
+ "display_name": "IPython (Python 2)",
+ "language": "python",
+ "name": "python2"
+ },
+ "name": "",
+ "signature": "sha256:42e2b7cc4c70a501432f24bc0d62d0723605d50196399148dd365d28387dd55d"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Loading the data"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "First we set up our imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import yt\n",
+ "import numpy as np\n",
+ "import yt.units as units\n",
+ "import pylab"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "First we load the data set, specifying both the unit length/mass/velocity, as well as the size of the bounding box (which should encapsulate all the particles in the data set)\n",
+ "\n",
+ "At the end, we flatten the data into \"ad\" in case we want access to the raw simulation data"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ ">This dataset is available for download at http://yt-project.org/data/GadgetDiskGalaxy.tar.gz (430 MB)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "fname = 'GadgetDiskGalaxy/snapshot_200.hdf5'\n",
+ "\n",
+ "unit_base = {'UnitLength_in_cm' : 3.08568e+21,\n",
+ " 'UnitMass_in_g' : 1.989e+43,\n",
+ " 'UnitVelocity_in_cm_per_s' : 100000}\n",
+ "\n",
+ "bbox_lim = 1e5 #kpc\n",
+ "\n",
+ "bbox = [[-bbox_lim,bbox_lim],\n",
+ " [-bbox_lim,bbox_lim],\n",
+ " [-bbox_lim,bbox_lim]]\n",
+ " \n",
+ "ds = yt.load(fname,unit_base=unit_base,bounding_box=bbox)\n",
+ "ds.index\n",
+ "ad= ds.all_data()"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let's make a projection plot to look at the entire volume"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "px = yt.ProjectionPlot(ds, 'x', ('gas', 'density'))\n",
+ "px.show()"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let's print some quantities about the domain, as well as the physical properties of the simulation\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "print 'left edge: ',ds.domain_left_edge\n",
+ "print 'right edge: ',ds.domain_right_edge\n",
+ "print 'center: ',ds.domain_center"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We can also see the fields that are available to query in the dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "sorted(ds.field_list)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let's create a data object that represents the full simulation domain, and find the total mass in gas and dark matter particles contained in it:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "ad = ds.all_data()\n",
+ "\n",
+ "# total_mass returns a list, representing the total gas and dark matter + stellar mass, respectively\n",
+ "print [tm.in_units('Msun') for tm in ad.quantities.total_mass()]"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now let's say we want to zoom in on the box (since clearly the bounding we chose initially is much larger than the volume containing the gas particles!), and center on wherever the highest gas density peak is. First, let's find this peak:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "density = ad[(\"PartType0\",\"density\")]\n",
+ "wdens = np.where(density == np.max(density))\n",
+ "coordinates = ad[(\"PartType0\",\"Coordinates\")]\n",
+ "center = coordinates[wdens][0]\n",
+ "print 'center = ',center"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Set up the box to zoom into"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "new_box_size = ds.quan(250,'code_length')\n",
+ "\n",
+ "left_edge = center - new_box_size/2\n",
+ "right_edge = center + new_box_size/2\n",
+ "\n",
+ "print new_box_size.in_units('Mpc')\n",
+ "print left_edge.in_units('Mpc')\n",
+ "print right_edge.in_units('Mpc')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "ad2= ds.region(center=center, left_edge=left_edge, right_edge=right_edge)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Using this new data object, let's confirm that we're only looking at a subset of the domain by first calculating thte total mass in gas and particles contained in the subvolume:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "print [tm.in_units('Msun') for tm in ad.quantities.total_mass()]"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "And then by visualizing what the new zoomed region looks like"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "px = yt.ProjectionPlot(ds, 'x', ('gas', 'density'), center=center, width=new_box_size)\n",
+ "px.show()"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Cool - there's a disk galaxy there!"
+ ]
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a doc/source/developing/creating_frontend.rst
--- a/doc/source/developing/creating_frontend.rst
+++ b/doc/source/developing/creating_frontend.rst
@@ -7,14 +7,14 @@
have a question about making a custom derived quantity, please
contact the mailing list.
-yt is designed to support analysis and visualization of data from multiple
-different simulation codes, although it has so far been most successfully
-applied to Adaptive Mesh Refinement (AMR) data. For a list of codes and the
-level of support they enjoy, see :ref:`code-support`.
+yt is designed to support analysis and visualization of data from
+multiple different simulation codes. For a list of codes and the level
+of support they enjoy, see :ref:`code-support`.
-We'd like to support a broad range of codes, both AMR-based and otherwise. To
-add support for a new code, a few things need to be put into place. These
-necessary structures can be classified into a couple categories:
+We'd like to support a broad range of codes, both Adaptive Mesh
+Refinement (AMR)-based and otherwise. To add support for a new code, a
+few things need to be put into place. These necessary structures can
+be classified into a couple categories:
* Data meaning: This is the set of parameters that convert the data into
physically relevant units; things like spatial and mass conversions, time
@@ -33,73 +33,147 @@
If you are interested in adding a new code, be sure to drop us a line on
`yt-dev <http://lists.spacepope.org/listinfo.cgi/yt-dev-spacepope.org>`_!
-To get started, make a new directory in ``yt/frontends`` with the name of your
-code -- you can start by copying into it the contents of the ``stream``
-directory, which is a pretty empty format. You'll then have to create a subclass
-of ``Dataset``. This subclass will need to handle conversion between the
-different physical units and the code units; for the most part, the examples of
-``OrionDataset`` and ``EnzoDataset`` should be followed, but
-``ChomboDataset``, as a slightly newer addition, can also be used as an
-instructive example -- be sure to add an ``_is_valid`` classmethod that will
-verify if a filename is valid for that output type, as that is how "load" works.
+To get started, make a new directory in ``yt/frontends`` with the name
+of your code. Copying the contents of the ``yt/frontends/_skeleton``
+directory will add a lot of boilerplate for the required classes and
+methods that are needed. In particular, you'll have to create a
+subclass of ``Dataset`` in the data_structures.py file. This subclass
+will need to handle conversion between the different physical units
+and the code units (typically in the ``_set_code_unit_attributes()``
+method), read in metadata describing the overall data on disk (via the
+``_parse_parameter_file()`` method), and provide a ``classmethod``
+called ``_is_valid()`` that lets the ``yt.load`` method help identify an
+input file as belonging to *this* particular ``Dataset`` subclass.
+For the most part, the examples of
+``yt.frontends.boxlib.data_structures.OrionDataset`` and
+``yt.frontends.enzo.data_structures.EnzoDataset`` should be followed,
+but ``yt.frontends.chombo.data_structures.ChomboDataset``, as a
+slightly newer addition, can also be used as an instructive example.
-A new set of fields must be added in the file ``fields.py`` in that directory.
-For the most part this means subclassing ``CodeFieldInfoContainer`` and adding
-the necessary fields specific to that code. Here is the Chombo field container:
+A new set of fields must be added in the file ``fields.py`` in your
+new directory. For the most part this means subclassing
+``FieldInfoContainer`` and adding the necessary fields specific to
+your code. Here is a snippet from the base BoxLib field container:
.. code-block:: python
- from UniversalFields import *
- class ChomboFieldContainer(CodeFieldInfoContainer):
- _shared_state = {}
- _field_list = {}
- ChomboFieldInfo = ChomboFieldContainer()
- add_chombo_field = ChomboFieldInfo.add_field
+ from yt.fields.field_info_container import FieldInfoContainer
+ class BoxlibFieldInfo(FieldInfoContainer):
+ known_other_fields = (
+ ("density", (rho_units, ["density"], None)),
+ ("eden", (eden_units, ["energy_density"], None)),
+ ("xmom", (mom_units, ["momentum_x"], None)),
+ ("ymom", (mom_units, ["momentum_y"], None)),
+ ("zmom", (mom_units, ["momentum_z"], None)),
+ ("temperature", ("K", ["temperature"], None)),
+ ("Temp", ("K", ["temperature"], None)),
+ ("x_velocity", ("cm/s", ["velocity_x"], None)),
+ ("y_velocity", ("cm/s", ["velocity_y"], None)),
+ ("z_velocity", ("cm/s", ["velocity_z"], None)),
+ ("xvel", ("cm/s", ["velocity_x"], None)),
+ ("yvel", ("cm/s", ["velocity_y"], None)),
+ ("zvel", ("cm/s", ["velocity_z"], None)),
+ )
-The field container is a shared state object, which is why we explicitly set
-``_shared_state`` equal to a mutable.
+ known_particle_fields = (
+ ("particle_mass", ("code_mass", [], None)),
+ ("particle_position_x", ("code_length", [], None)),
+ ("particle_position_y", ("code_length", [], None)),
+ ("particle_position_z", ("code_length", [], None)),
+ ("particle_momentum_x", (mom_units, [], None)),
+ ("particle_momentum_y", (mom_units, [], None)),
+ ("particle_momentum_z", (mom_units, [], None)),
+ ("particle_angmomen_x", ("code_length**2/code_time", [], None)),
+ ("particle_angmomen_y", ("code_length**2/code_time", [], None)),
+ ("particle_angmomen_z", ("code_length**2/code_time", [], None)),
+ ("particle_id", ("", ["particle_index"], None)),
+ ("particle_mdot", ("code_mass/code_time", [], None)),
+ )
+
+The tuples, ``known_other_fields`` and ``known_particle_fields``
+contain entries, which are tuples of the form ``("name", ("units",
+["fields", "to", "alias"], "display_name"))``. ``"name"`` is the name
+of a field stored on-disk in the dataset. ``"units"`` corresponds to
+the units of that field. The list ``["fields", "to", "alias"]``
+allows you to specify additional aliases to this particular field; for
+example, if your on-disk field for the x-direction velocity were
+``"x-direction-velocity"``, maybe you'd prefer to alias to the more
+terse name of ``"xvel"``. ``"display_name"`` is an optional parameter
+that can be used to specify how you want the field to be displayed on
+a plot; this can be LaTeX code, for example the density field could
+have a display name of ``r"\rho"``. Omitting the ``"display_name"``
+will result in using a capitalized version of the ``"name"``.
Data Localization Structures
----------------------------
-As of right now, the "grid patch" mechanism is going to remain in yt, however in
-the future that may change. As such, some other output formats -- like Gadget --
-may be shoe-horned in, slightly.
+These functions and classes let yt know about how the arrangement of
+data on disk corresponds to the physical arrangement of data within
+the simulation. yt has grid datastructures for handling both
+patch-based and octree-based AMR codes. The terms 'patch-based'
+and 'octree-based' are used somewhat loosely here. For example,
+traditionally, the FLASH code used the paramesh AMR library, which is
+based on a tree structure, but the FLASH frontend in yt utilizes yt's
+patch-based datastructures. It is up to the frontend developer to
+determine which yt datastructures best match the datastructures of
+their simulation code.
-Hierarchy
-^^^^^^^^^
+Both approaches -- patch-based and octree-based -- have a concept of a
+*Hierarchy* or *Index* (used somewhat interchangeably in the code) of
+datastructures and something that describes the elements that make up
+the Hierarchy or Index. For patch-based codes, the Index is a
+collection of ``AMRGridPatch`` objects that describe a block of zones.
+For octree-based codes, the Index contains datastructures that hold
+information about the individual octs, namely an ``OctreeContainer``.
-To set up data localization, an ``AMRHierarchy`` subclass must be added in the
-file ``data_structures.py``. The index object must override the following
-methods:
+Hierarchy or Index
+^^^^^^^^^^^^^^^^^^
- * ``_detect_fields``: ``self.field_list`` must be populated as a list of
- strings corresponding to "native" fields in the data files.
- * ``_setup_classes``: it's probably safe to crib this from one of the other
- ``AMRHierarchy`` subclasses.
- * ``_count_grids``: this must set self.num_grids to be the total number of
- grids in the simulation.
- * ``_parse_index``: this must fill in ``grid_left_edge``,
+To set up data localization, a ``GridIndex`` subclass for patch-based
+codes or an ``OctreeIndex`` subclass for octree-based codes must be
+added in the file ``data_structures.py``. Examples of these different
+types of ``Index`` can be found in, for example, the
+``yt.frontends.chombo.data_structures.ChomboHierarchy`` for patch-based
+codes and ``yt.frontends.ramses.data_structures.RAMSESIndex`` for
+octree-based codes.
+
+For the most part, the ``GridIndex`` subclass must override (at a
+minimum) the following methods:
+
+ * ``_detect_output_fields()``: ``self.field_list`` must be populated as a list
+ of strings corresponding to "native" fields in the data files.
+ * ``_count_grids()``: this must set ``self.num_grids`` to be the total number
+ of grids (equivalently ``AMRGridPatch``'es) in the simulation.
+ * ``_parse_index()``: this must fill in ``grid_left_edge``,
``grid_right_edge``, ``grid_particle_count``, ``grid_dimensions`` and
- ``grid_levels`` with the appropriate information. Additionally, ``grids``
- must be an array of grid objects that already know their IDs.
- * ``_populate_grid_objects``: this initializes the grids by calling
- ``_prepare_grid`` and ``_setup_dx`` on all of them. Additionally, it should
- set up ``Children`` and ``Parent`` lists on each grid object.
- * ``_setup_unknown_fields``: If a field is in the data file that yt doesn't
- already know, this is where you make a guess at it.
- * ``_setup_derived_fields``: ``self.derived_field_list`` needs to be made a
- list of strings that correspond to all derived fields valid for this
- index.
+ ``grid_levels`` with the appropriate information. Each of these variables
+ is an array, with an entry for each of the ``self.num_grids`` grids.
+ Additionally, ``grids`` must be an array of ``AMRGridPatch`` objects that
+ already know their IDs.
+ * ``_populate_grid_objects()``: this initializes the grids by calling
+ ``_prepare_grid()`` and ``_setup_dx()`` on all of them. Additionally, it
+ should set up ``Children`` and ``Parent`` lists on each grid object.
-For the most part, the ``ChomboHierarchy`` should be the first place to look for
-hints on how to do this; ``EnzoHierarchy`` is also instructive.
+The ``OctreeIndex`` has somewhat analogous methods, but often with
+different names; both ``OctreeIndex`` and ``GridIndex`` are subclasses
+of the ``Index`` class. In particular, for the ``OctreeIndex``, the
+method ``_initialize_oct_handler()`` setups up much of the oct
+metadata that is analogous to the grid metadata created in the
+``GridIndex`` methods ``_count_grids()``, ``_parse_index()``, and
+``_populate_grid_objects()``.
Grids
^^^^^
-A new grid object, subclassing ``AMRGridPatch``, will also have to be added.
-This should go in ``data_structures.py``. For the most part, this may be all
+.. note:: This section only applies to the approach using yt's patch-based
+ datastructures. For the octree-based approach, one does not create
+ a grid object, but rather an ``OctreeSubset``, which has methods
+ for filling out portions of the octree structure. Again, see the
+ code in ``yt.frontends.ramses.data_structures`` for an example of
+ the octree approach.
+
+A new grid object, subclassing ``AMRGridPatch``, will also have to be added in
+``data_structures.py``. For the most part, this may be all
that is needed:
.. code-block:: python
@@ -115,32 +189,46 @@
self.Level = level
-Even the most complex grid object, ``OrionGrid``, is still relatively simple.
+Even one of the more complex grid objects,
+``yt.frontends.boxlib.BoxlibGrid``, is still relatively simple.
Data Reading Functions
----------------------
-In ``io.py``, there are a number of IO handlers that handle the mechanisms by
-which data is read off disk. To implement a new data reader, you must subclass
-``BaseIOHandler`` and override the following methods:
+In ``io.py``, there are a number of IO handlers that handle the
+mechanisms by which data is read off disk. To implement a new data
+reader, you must subclass ``BaseIOHandler``. The various frontend IO
+handlers are stored in an IO registry - essentially a dictionary that
+uses the name of the frontend as a key, and the specific IO handler as
+a value. It is important, therefore, to set the ``dataset_type``
+attribute of your subclass, which is what is used as the key in the IO
+registry. For example:
- * ``_read_field_names``: this routine accepts a grid object and must return all
- the fields in the data file affiliated with that grid. It is used at the
- initialization of the ``AMRHierarchy`` but likely not later.
- * ``modify``: This accepts a field from a data file and returns it ready to be
- used by yt. This is used in Enzo data for preloading.
- * ``_read_data_set``: This accepts a grid object and a field name and must
- return that field, ready to be used by yt as a NumPy array. Note that this
- presupposes that any actions done in ``modify`` (above) have been executed.
- * ``_read_data_slice``: This accepts a grid object, a field name, an axis and
- an (integer) coordinate, and it must return a slice through the array at that
- value.
- * ``preload``: (optional) This accepts a list of grids and a list of datasets
- and it populates ``self.queue`` (a dict keyed by grid id) with dicts of
- datasets.
- * ``_read_exception``: (property) This is a tuple of exceptions that can be
- raised by the data reading to indicate a field does not exist in the file.
+.. code-block:: python
+ class IOHandlerBoxlib(BaseIOHandler):
+ _dataset_type = "boxlib_native"
+ ...
+
+At a minimum, one should also override the following methods
+
+* ``_read_fluid_selection()``: this receives a collection of data "chunks", a
+ selector describing which "chunks" you are concerned with, a list of fields,
+ and the size of the data to read. It should create and return a dictionary
+ whose keys are the fields, and whose values are numpy arrays containing the
+ data. The data should actually be read via the ``_read_chunk_data()``
+ method.
+* ``_read_chunk_data()``: this method receives a "chunk" of data along with a
+ list of fields we want to read. It loops over all the grid objects within
+ the "chunk" of data and reads from disk the specific fields, returning a
+ dictionary whose keys are the fields and whose values are numpy arrays of
+ the data.
+
+If your dataset has particle information, you'll want to override the
+``_read_particle_coords()`` and ``read_particle_fields()`` methods as
+well. Each code is going to read data from disk in a different
+fashion, but the ``yt.frontends.boxlib.io.IOHandlerBoxlib`` is a
+decent place to start.
And that just about covers it. Please feel free to email
`yt-users <http://lists.spacepope.org/listinfo.cgi/yt-users-spacepope.org>`_ or
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a doc/source/examining/loading_data.rst
--- a/doc/source/examining/loading_data.rst
+++ b/doc/source/examining/loading_data.rst
@@ -983,6 +983,8 @@
onto the grid, you can also effectively mimic what your data would look like at
lower resolution.
+See :ref:`gadget-notebook` for an example.
+
.. _loading-tipsy-data:
Tipsy Data
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a doc/source/visualizing/plots.rst
--- a/doc/source/visualizing/plots.rst
+++ b/doc/source/visualizing/plots.rst
@@ -469,6 +469,21 @@
slc.set_log('density', False)
slc.save()
+Specifically, a field containing both positive and negative values can be plotted
+with symlog scale, by seting the boolean to be ``True`` and providing an extra
+parameter ``linthresh``. In the region around zero (when the log scale approaches
+to infinity), the linear scale will be applied to the region ``(-linthresh, linthresh)``
+and stretched relative to the logarithmic range. You can also plot a positive field
+under symlog scale with the linear range of ``(0, linthresh)``.
+
+.. python-script::
+
+ import yt
+ ds = yt.load("IsolatedGalaxy/galaxy0030/galaxy0030")
+ slc = yt.SlicePlot(ds, 'z', 'x-velocity', width=(30,'kpc'))
+ slc.set_log('x-velocity', True, linthresh=1.e1)
+ slc.save()
+
Lastly, the :meth:`~yt.visualization.plot_window.AxisAlignedSlicePlot.set_zlim`
function makes it possible to set a custom colormap range.
@@ -531,6 +546,26 @@
slc.set_buff_size(1600)
slc.save()
+Turning off minorticks
+~~~~~~~~~~~~~~~~~~~~~~
+
+By default minorticks for the x and y axes are turned on.
+The minorticks may be removed using the
+:meth:`~yt.visualization.plot_window.AxisAlignedSlicePlot.set_minorticks`
+function, which either accepts a specific field name including the 'all' alias
+and the desired state for the plot as 'on' or 'off'. There is also an analogous
+:meth:`~yt.visualization.plot_window.AxisAlignedSlicePlot.set_cbar_minorticks`
+function for the colorbar axis.
+
+.. python-script::
+
+ import yt
+ ds = yt.load("IsolatedGalaxy/galaxy0030/galaxy0030")
+ slc = yt.SlicePlot(ds, 'z', 'density', width=(10,'kpc'))
+ slc.set_minorticks('all', 'off')
+ slc.set_cbar_minorticks('all', 'off')
+ slc.save()
+
.. _matplotlib-customization:
Further customization via matplotlib
@@ -743,7 +778,7 @@
Adjusting the plot units does not require recreating the histogram, so adjusting
units will always be inexpensive, requiring only an in-place unit conversion.
-In the following example we create a a plot of the average density in solar
+In the following example we create a plot of the average density in solar
masses per cubic parsec as a function of radius in kiloparsecs.
.. python-script::
@@ -892,7 +927,7 @@
``fractional`` keyword to ``True``. When set to ``True``, the value in each bin
is divided by the sum total from all bins. These can be turned into cumulative
distribution functions (CDFs) by setting the ``accumulation`` keyword to
-``True``. This will make is so that the value in any bin N is the cumulative
+``True``. This will make it so that the value in any bin N is the cumulative
sum of all bins from 0 to N. The direction of the summation can be reversed by
setting ``accumulation`` to ``-True``. For ``PhasePlot``, the accumulation can
be set independently for each axis by setting ``accumulation`` to a list of
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a yt/analysis_modules/cosmological_observation/light_cone/light_cone.py
--- a/yt/analysis_modules/cosmological_observation/light_cone/light_cone.py
+++ b/yt/analysis_modules/cosmological_observation/light_cone/light_cone.py
@@ -186,13 +186,13 @@
# Simple error check to make sure more than 100% of box depth
# is never required.
if self.light_cone_solution[q]["box_depth_fraction"] > 1.0:
- mylog.debug(("Warning: box fraction required to go from " +
+ mylog.error(("Warning: box fraction required to go from " +
"z = %f to %f is %f") %
(self.light_cone_solution[q]["redshift"], z_next,
self.light_cone_solution[q]["box_depth_fraction"]))
- mylog.debug(("Full box delta z is %f, but it is %f to the " +
+ mylog.error(("Full box delta z is %f, but it is %f to the " +
"next data dump.") %
- (self.light_cone_solution[q]["deltazMax"],
+ (self.light_cone_solution[q]["dz_max"],
self.light_cone_solution[q]["redshift"]-z_next))
# Get projection axis and center.
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a yt/analysis_modules/cosmological_observation/light_ray/light_ray.py
--- a/yt/analysis_modules/cosmological_observation/light_ray/light_ray.py
+++ b/yt/analysis_modules/cosmological_observation/light_ray/light_ray.py
@@ -169,7 +169,7 @@
(self.light_ray_solution[q]['redshift'], z_next,
self.light_ray_solution[q]['traversal_box_fraction']))
mylog.error("Full box delta z is %f, but it is %f to the next data dump." %
- (self.light_ray_solution[q]['deltazMax'],
+ (self.light_ray_solution[q]['dz_max'],
self.light_ray_solution[q]['redshift']-z_next))
# Get dataset axis and center.
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a yt/data_objects/data_containers.py
--- a/yt/data_objects/data_containers.py
+++ b/yt/data_objects/data_containers.py
@@ -807,6 +807,8 @@
self.fields = [k for k in self.field_data if k not in skip]
if fields is not None:
self.fields = ensure_list(fields) + self.fields
+ if len(self.fields) == 0:
+ raise ValueError("No fields found to plot in get_pw")
(bounds, center, display_center) = \
get_window_parameters(axis, center, width, self.ds)
pw = PWViewerMPL(self, bounds, fields=self.fields, origin=origin,
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a yt/data_objects/selection_data_containers.py
--- a/yt/data_objects/selection_data_containers.py
+++ b/yt/data_objects/selection_data_containers.py
@@ -542,7 +542,7 @@
"""
_type_name = "data_collection"
_con_args = ("_obj_list",)
- def __init__(self, center, obj_list, ds = None, field_parameters = None):
+ def __init__(self, obj_list, ds=None, field_parameters=None, center=None):
YTSelectionContainer3D.__init__(self, center, ds, field_parameters)
self._obj_ids = np.array([o.id - o._id_offset for o in obj_list],
dtype="int64")
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a yt/data_objects/tests/test_data_collection.py
--- a/yt/data_objects/tests/test_data_collection.py
+++ b/yt/data_objects/tests/test_data_collection.py
@@ -8,7 +8,7 @@
# We decompose in different ways
for nprocs in [1, 2, 4, 8]:
ds = fake_random_ds(16, nprocs = nprocs)
- coll = ds.data_collection(ds.domain_center, ds.index.grids)
+ coll = ds.data_collection(ds.index.grids)
crho = coll["density"].sum(dtype="float64").to_ndarray()
grho = np.sum([g["density"].sum(dtype="float64") for g in ds.index.grids],
dtype="float64")
@@ -16,7 +16,7 @@
yield assert_equal, coll.size, ds.domain_dimensions.prod()
for gi in range(ds.index.num_grids):
grids = ds.index.grids[:gi+1]
- coll = ds.data_collection(ds.domain_center, grids)
+ coll = ds.data_collection(grids)
crho = coll["density"].sum(dtype="float64")
grho = np.sum([g["density"].sum(dtype="float64") for g in grids],
dtype="float64")
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a yt/frontends/_skeleton/api.py
--- a/yt/frontends/_skeleton/api.py
+++ b/yt/frontends/_skeleton/api.py
@@ -19,8 +19,7 @@
SkeletonDataset
from .fields import \
- SkeletonFieldInfo, \
- add_skeleton_field
+ SkeletonFieldInfo
from .io import \
IOHandlerSkeleton
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a yt/frontends/_skeleton/data_structures.py
--- a/yt/frontends/_skeleton/data_structures.py
+++ b/yt/frontends/_skeleton/data_structures.py
@@ -13,18 +13,13 @@
# The full license is in the file COPYING.txt, distributed with this software.
#-----------------------------------------------------------------------------
-import numpy as np
-
-from yt.data_objects.grid_patch import \
- AMRGridPatch
from yt.data_objects.grid_patch import \
AMRGridPatch
from yt.geometry.grid_geometry_handler import \
GridIndex
from yt.data_objects.static_output import \
Dataset
-from yt.utilities.lib.misc_utilities import \
- get_box_grids_level
+from .fields import SkeletonFieldInfo
class SkeletonGrid(AMRGridPatch):
_id_offset = 0
@@ -41,20 +36,15 @@
def __repr__(self):
return "SkeletonGrid_%04i (%s)" % (self.id, self.ActiveDimensions)
-class SkeletonHierarchy(AMRHierarchy):
-
+class SkeletonHierarchy(GridIndex):
grid = SkeletonGrid
def __init__(self, ds, dataset_type='skeleton'):
self.dataset_type = dataset_type
- self.dataset = weakref.proxy(ds)
# for now, the index file is the dataset!
self.index_filename = self.dataset.parameter_filename
self.directory = os.path.dirname(self.index_filename)
- AMRHierarchy.__init__(self, ds, dataset_type)
-
- def _initialize_data_storage(self):
- pass
+ GridIndex.__init__(self, ds, dataset_type)
def _detect_output_fields(self):
# This needs to set a self.field_list that contains all the available,
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a yt/frontends/_skeleton/io.py
--- a/yt/frontends/_skeleton/io.py
+++ b/yt/frontends/_skeleton/io.py
@@ -13,9 +13,6 @@
# The full license is in the file COPYING.txt, distributed with this software.
#-----------------------------------------------------------------------------
-import numpy as np
-import h5py
-
from yt.utilities.io_handler import \
BaseIOHandler
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a yt/frontends/chombo/data_structures.py
--- a/yt/frontends/chombo/data_structures.py
+++ b/yt/frontends/chombo/data_structures.py
@@ -113,7 +113,8 @@
self.directory = ds.fullpath
self._handle = ds._handle
- self.float_type = self._handle['Chombo_global'].attrs['testReal'].dtype.name
+ tr = self._handle['Chombo_global'].attrs.get("testReal", "float32")
+
self._levels = [key for key in self._handle.keys() if key.startswith('level')]
GridIndex.__init__(self, ds, dataset_type)
@@ -161,7 +162,13 @@
def _count_grids(self):
self.num_grids = 0
for lev in self._levels:
- self.num_grids += self._handle[lev]['Processors'].len()
+ d = self._handle[lev]
+ if 'Processors' in d:
+ self.num_grids += d['Processors'].len()
+ elif 'boxes' in d:
+ self.num_grids += d['boxes'].len()
+ else:
+ raise RuntimeError("Uknown file specification")
def _parse_index(self):
f = self._handle # shortcut
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a yt/frontends/chombo/io.py
--- a/yt/frontends/chombo/io.py
+++ b/yt/frontends/chombo/io.py
@@ -25,6 +25,7 @@
_dataset_type = "chombo_hdf5"
_offset_string = 'data:offsets=0'
_data_string = 'data:datatype=0'
+ _offsets = None
def __init__(self, ds, *args, **kwargs):
BaseIOHandler.__init__(self, ds, *args, **kwargs)
@@ -32,6 +33,29 @@
self._handle = ds._handle
self.dim = self._handle['Chombo_global/'].attrs['SpaceDim']
self._read_ghost_info()
+ if self._offset_string not in self._handle['level_0']:
+ self._calculate_offsets()
+
+ def _calculate_offsets(self):
+ def box_size(corners):
+ size = 1
+ for idim in range(self.dim):
+ size *= (corners[idim+self.dim] - corners[idim] + 1)
+ return size
+
+ self._offsets = {}
+ num_comp = self._handle.attrs['num_components']
+ level = 0
+ while 1:
+ lname = 'level_%i' % level
+ if lname not in self._handle: break
+ boxes = self._handle['level_0']['boxes'].value
+ box_sizes = np.array([box_size(box) for box in boxes])
+
+ offsets = np.cumsum(box_sizes*num_comp, dtype='int64')
+ offsets -= offsets[0]
+ self._offsets[level] = offsets
+ level += 1
def _read_ghost_info(self):
try:
@@ -41,7 +65,7 @@
self.ghost = np.array(self.ghost)
except KeyError:
# assume zero ghosts if outputGhosts not present
- self.ghost = np.zeros(self.dim)
+ self.ghost = np.zeros(self.dim, 'int64')
_field_dict = None
@property
@@ -80,7 +104,10 @@
shape = grid.ActiveDimensions + 2*self.ghost
boxsize = shape.prod()
- grid_offset = lev[self._offset_string][grid._level_id]
+ if self._offsets is not None:
+ grid_offset = self._offsets[grid.Level][grid._level_id]
+ else:
+ grid_offset = lev[self._offset_string][grid._level_id]
start = grid_offset+self.field_dict[field]*boxsize
stop = start + boxsize
data = lev[self._data_string][start:stop]
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a yt/frontends/stream/data_structures.py
--- a/yt/frontends/stream/data_structures.py
+++ b/yt/frontends/stream/data_structures.py
@@ -473,7 +473,8 @@
field_units[k] = v.units
new_data[k] = v.copy().d
data = new_data
- elif all([(len(val) == 2) for val in data.values()]):
+ elif all([((not isinstance(val, np.ndarray)) and (len(val) == 2))
+ for val in data.values()]):
new_data, field_units = {}, {}
for field in data:
try:
@@ -700,7 +701,7 @@
field_units=None, bbox=None, sim_time=0.0, length_unit=None,
mass_unit=None, time_unit=None, velocity_unit=None,
magnetic_unit=None, periodicity=(True, True, True),
- geometry = "cartesian"):
+ geometry = "cartesian", refine_by=2):
r"""Load a set of grids of data into yt as a
:class:`~yt.frontends.stream.data_structures.StreamHandler`.
This should allow a sequence of grids of varying resolution of data to be
@@ -750,6 +751,8 @@
each axis
geometry : string
"cartesian", "cylindrical" or "polar"
+ refine_by : integer
+ Specifies the refinement ratio between levels. Defaults to 2.
Examples
--------
@@ -771,7 +774,7 @@
... g["density"] = np.random.random(g["dimensions"]) * 2**g["level"]
...
>>> units = dict(density='g/cm**3')
- >>> ds = load_amr_grids(grid_data, [8, 8, 8], field_units=units,
+ >>> ds = load_amr_grids(grid_data, [32, 32, 32], field_units=units,
... length_unit=1.0)
"""
@@ -848,7 +851,7 @@
handler.name = "AMRGridData"
handler.domain_left_edge = domain_left_edge
handler.domain_right_edge = domain_right_edge
- handler.refine_by = 2
+ handler.refine_by = refine_by
handler.dimensionality = 3
handler.domain_dimensions = domain_dimensions
handler.simulation_time = sim_time
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a yt/frontends/stream/tests/test_stream_amrgrids.py
--- a/yt/frontends/stream/tests/test_stream_amrgrids.py
+++ b/yt/frontends/stream/tests/test_stream_amrgrids.py
@@ -26,3 +26,25 @@
p = ProjectionPlot(spf, 'x', ["density"], center='c', origin='native')
return p
yield assert_raises, YTIntDomainOverflow, make_proj
+
+def test_refine_by():
+ grid_data = []
+ ref_by = 4
+ lo = 0.0
+ hi = 1.0
+ fine_grid_width = (hi - lo) / ref_by
+ for level in range(2):
+ grid_dict = {}
+
+ grid_dict['left_edge'] = [0.0 + 0.5*fine_grid_width*level]*3
+ grid_dict['right_edge'] = [1.0 - 0.5*fine_grid_width*level]*3
+ grid_dict['dimensions'] = [8, 8, 8]
+ grid_dict['level'] = level
+
+ grid_dict['density'] = np.ones((8,8,8))
+
+ grid_data.append(grid_dict)
+
+ domain_dimensions = np.array([8, 8, 8])
+
+ spf = load_amr_grids(grid_data, domain_dimensions, refine_by=ref_by)
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a yt/geometry/selection_routines.pyx
--- a/yt/geometry/selection_routines.pyx
+++ b/yt/geometry/selection_routines.pyx
@@ -727,9 +727,14 @@
if dobj.left_edge[i] < dobj.ds.domain_left_edge[i] or \
dobj.right_edge[i] > dobj.ds.domain_right_edge[i]:
raise RuntimeError(
- "Error: bad Region in non-periodic domain along dimension %s. "
- "Region left edge = %s, Region right edge = %s"
- "Dataset left edge = %s, Dataset right edge = %s" % \
+ "Error: yt attempted to read outside the boundaries of "
+ "a non-periodic domain along dimension %s.\n"
+ "Region left edge = %s, Region right edge = %s\n"
+ "Dataset left edge = %s, Dataset right edge = %s\n\n"
+ "This commonly happens when trying to compute ghost cells "
+ "up to the domain boundary. Two possible solutions are to "
+ "load a smaller region that does not border the edge or "
+ "override the periodicity for this dataset." % \
(i, dobj.left_edge[i], dobj.right_edge[i],
dobj.ds.domain_left_edge[i], dobj.ds.domain_right_edge[i])
)
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a yt/visualization/base_plot_types.py
--- a/yt/visualization/base_plot_types.py
+++ b/yt/visualization/base_plot_types.py
@@ -109,12 +109,16 @@
cax.set_position(caxrect)
self.cax = cax
- def _init_image(self, data, cbnorm, cmap, extent, aspect):
+ def _init_image(self, data, cbnorm, cblinthresh, cmap, extent, aspect):
"""Store output of imshow in image variable"""
if (cbnorm == 'log10'):
norm = matplotlib.colors.LogNorm()
elif (cbnorm == 'linear'):
norm = matplotlib.colors.Normalize()
+ elif (cbnorm == 'symlog'):
+ if cblinthresh is None:
+ cblinthresh = (data.max()-data.min())/10.
+ norm = matplotlib.colors.SymLogNorm(cblinthresh,vmin=data.min(), vmax=data.max())
extent = [float(e) for e in extent]
if isinstance(cmap, tuple):
if has_brewer:
@@ -126,7 +130,16 @@
self.image = self.axes.imshow(data.to_ndarray(), origin='lower',
extent=extent, norm=norm, vmin=self.zmin,
aspect=aspect, vmax=self.zmax, cmap=cmap)
- self.cb = self.figure.colorbar(self.image, self.cax)
+ if (cbnorm == 'symlog'):
+ formatter = matplotlib.ticker.LogFormatterMathtext()
+ self.cb = self.figure.colorbar(self.image, self.cax, format=formatter)
+ yticks = list(-10**np.arange(np.floor(np.log10(-data.min())),\
+ np.rint(np.log10(cblinthresh))-1, -1)) + [0] + \
+ list(10**np.arange(np.rint(np.log10(cblinthresh)),\
+ np.ceil(np.log10(data.max()))+1))
+ self.cb.set_ticks(yticks)
+ else:
+ self.cb = self.figure.colorbar(self.image, self.cax)
def _repr_png_(self):
canvas = FigureCanvasAgg(self.figure)
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a yt/visualization/plot_container.py
--- a/yt/visualization/plot_container.py
+++ b/yt/visualization/plot_container.py
@@ -80,6 +80,53 @@
return args[0]
return newfunc
+def get_log_minorticks(vmin, vmax):
+ """calculate positions of linear minorticks on a log colorbar
+
+ Parameters
+ ----------
+ vmin : float
+ the minimum value in the colorbar
+ vmax : float
+ the maximum value in the colorbar
+
+ """
+ expA = np.floor(np.log10(vmin))
+ expB = np.floor(np.log10(vmax))
+ cofA = np.ceil(vmin/10**expA)
+ cofB = np.floor(vmax/10**expB)
+ lmticks = []
+ while cofA*10**expA <= cofB*10**expB:
+ if expA < expB:
+ lmticks = np.hstack( (lmticks, np.linspace(cofA, 9, 10-cofA)*10**expA) )
+ cofA = 1
+ expA += 1
+ else:
+ lmticks = np.hstack( (lmticks, np.linspace(cofA, cofB, cofB-cofA+1)*10**expA) )
+ expA += 1
+ return np.array(lmticks)
+
+def get_symlog_minorticks(linthresh, vmin, vmax):
+ """calculate positions of linear minorticks on a symmetric log colorbar
+
+ Parameters
+ ----------
+ linthresh: float
+ the threshold for the linear region
+ vmin : float
+ the minimum value in the colorbar
+ vmax : float
+ the maximum value in the colorbar
+
+ """
+ if vmin >= 0 or vmax <= 0:
+ raise RuntimeError(
+ '''attempting to set minorticks for
+ a symlog plot with one-sided data:
+ got vmin = %s, vmax = %s''' % (vmin, vmax))
+ return np.hstack( (-get_log_minorticks(linthresh,-vmin)[::-1], 0,
+ get_log_minorticks(linthresh, vmax)) )
+
field_transforms = {}
@@ -102,6 +149,7 @@
log_transform = FieldTransform('log10', np.log10, LogLocator())
linear_transform = FieldTransform('linear', lambda x: x, LinearLocator())
+symlog_transform = FieldTransform('symlog', None, LogLocator())
class PlotDictionary(defaultdict):
def __getitem__(self, item):
@@ -143,11 +191,13 @@
self._font_color = None
self._xlabel = None
self._ylabel = None
+ self._minorticks = {}
+ self._cbar_minorticks = {}
self._colorbar_label = PlotDictionary(
self.data_source, lambda: None)
@invalidate_plot
- def set_log(self, field, log):
+ def set_log(self, field, log, linthresh=None):
"""set a field to log or linear.
Parameters
@@ -156,6 +206,8 @@
the field to set a transform
log : boolean
Log on/off.
+ linthresh : float (must be positive)
+ linthresh will be enabled for symlog scale only when log is true
"""
if field == 'all':
@@ -164,7 +216,13 @@
fields = [field]
for field in self.data_source._determine_fields(fields):
if log:
- self._field_transform[field] = log_transform
+ if linthresh is not None:
+ if not linthresh > 0.:
+ raise ValueError('\"linthresh\" must be positive')
+ self._field_transform[field] = symlog_transform
+ self._field_transform[field].func = linthresh
+ else:
+ self._field_transform[field] = log_transform
else:
self._field_transform[field] = linear_transform
return self
@@ -271,6 +329,58 @@
self.plots[field].zmax = myzmax
return self
+ @invalidate_plot
+ def set_minorticks(self, field, state):
+ """turn minor ticks on or off in the current plot
+
+ Displaying minor ticks reduces performance; turn them off
+ using set_minorticks('all', 'off') if drawing speed is a problem.
+
+ Parameters
+ ----------
+ field : string
+ the field to remove minorticks
+ state : string
+ the state indicating 'on' or 'off'
+
+ """
+ if field == 'all':
+ fields = self.plots.keys()
+ else:
+ fields = [field]
+ for field in self.data_source._determine_fields(fields):
+ if state == 'on':
+ self._minorticks[field] = True
+ else:
+ self._minorticks[field] = False
+ return self
+
+ @invalidate_plot
+ def set_cbar_minorticks(self, field, state):
+ """turn colorbar minor ticks on or off in the current plot
+
+ Displaying minor ticks reduces performance; turn them off
+ using set_cbar_minorticks('all', 'off') if drawing speed is a problem.
+
+ Parameters
+ ----------
+ field : string
+ the field to remove colorbar minorticks
+ state : string
+ the state indicating 'on' or 'off'
+
+ """
+ if field == 'all':
+ fields = self.plots.keys()
+ else:
+ fields = [field]
+ for field in self.data_source._determine_fields(fields):
+ if state == 'on':
+ self._cbar_minorticks[field] = True
+ else:
+ self._cbar_minorticks[field] = False
+ return self
+
def setup_callbacks(self):
# Left blank to be overriden in subclasses
pass
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a yt/visualization/plot_window.py
--- a/yt/visualization/plot_window.py
+++ b/yt/visualization/plot_window.py
@@ -33,7 +33,9 @@
from .plot_modifications import get_smallest_appropriate_unit, \
callback_registry
from .plot_container import \
- ImagePlotContainer, log_transform, linear_transform, \
+ ImagePlotContainer, \
+ log_transform, linear_transform, symlog_transform, \
+ get_log_minorticks, get_symlog_minorticks, \
invalidate_data, invalidate_plot, apply_callback
from yt.data_objects.time_series import \
@@ -711,9 +713,9 @@
zlim = (None, None)
image = self.frb[f]
-
if self._field_transform[f] == log_transform:
msg = None
+ use_symlog = False
if zlim != (None, None):
pass
elif np.nanmax(image) == np.nanmin(image):
@@ -724,10 +726,21 @@
"values. Max = %f." % (f, np.nanmax(image))
elif not np.any(np.isfinite(image)):
msg = "Plot image for field %s is filled with NaNs." % (f,)
+ elif np.nanmax(image) > 0. and np.nanmin(image) < 0:
+ msg = "Plot image for field %s has both positive "\
+ "and negative values. Min = %f, Max = %f."\
+ % (f, np.nanmin(image), np.nanmax(image))
+ use_symlog = True
if msg is not None:
mylog.warning(msg)
- mylog.warning("Switching to linear colorbar scaling.")
- self._field_transform[f] = linear_transform
+ if use_symlog:
+ mylog.warning("Switching to symlog colorbar scaling "\
+ "unless linear scaling is specified later")
+ self._field_transform[f] = symlog_transform
+ self._field_transform[f].func = None
+ else:
+ mylog.warning("Switching to linear colorbar scaling.")
+ self._field_transform[f] = linear_transform
fp = self._font_properties
@@ -746,6 +759,7 @@
self.plots[f] = WindowPlotMPL(
image, self._field_transform[f].name,
+ self._field_transform[f].func,
self._colormaps[f], extent, zlim,
self.figure_size, fp.get_size(),
self.aspect, fig, axes, cax)
@@ -860,6 +874,32 @@
self.plots[f].cb.ax.axes.yaxis.get_offset_text()]):
label.set_fontproperties(fp)
+ # x-y axes minorticks
+ if f not in self._minorticks:
+ self._minorticks[f] = True
+ if self._minorticks[f] is True:
+ self.plots[f].axes.minorticks_on()
+ else:
+ self.plots[f].axes.minorticks_off()
+
+ # colorbar minorticks
+ if f not in self._cbar_minorticks:
+ self._cbar_minorticks[f] = True
+ if self._cbar_minorticks[f] is True:
+ if self._field_transform[f] == linear_transform:
+ self.plots[f].cax.minorticks_on()
+ else:
+ vmin = np.float64( self.plots[f].cb.norm.vmin )
+ vmax = np.float64( self.plots[f].cb.norm.vmax )
+ if self._field_transform[f] == log_transform:
+ mticks = self.plots[f].image.norm( get_log_minorticks(vmin, vmax) )
+ else: # symlog_transform
+ flinthresh = 10**np.floor( np.log10( self.plots[f].cb.norm.linthresh ) )
+ mticks = self.plots[f].image.norm( get_symlog_minorticks(flinthresh, vmin, vmax) )
+ self.plots[f].cax.yaxis.set_ticks(mticks, minor=True)
+ else:
+ self.plots[f].cax.minorticks_off()
+
self.run_callbacks(f)
if draw_axes is False:
@@ -1643,7 +1683,7 @@
class WindowPlotMPL(ImagePlotMPL):
"""A container for a single PlotWindow matplotlib figure and axes"""
- def __init__(self, data, cbname, cmap, extent, zlim, figure_size, fontsize,
+ def __init__(self, data, cbname, cblinthresh, cmap, extent, zlim, figure_size, fontsize,
unit_aspect, figure, axes, cax):
self._draw_colorbar = True
self._draw_axes = True
@@ -1669,7 +1709,7 @@
super(WindowPlotMPL, self).__init__(
size, axrect, caxrect, zlim, figure, axes, cax)
- self._init_image(data, cbname, cmap, extent, unit_aspect)
+ self._init_image(data, cbname, cblinthresh, cmap, extent, unit_aspect)
self.image.axes.ticklabel_format(scilimits=(-2, 3))
if cbname == 'linear':
diff -r f0b3173ad21c5e4616d39cdb67c21dba97ff11e8 -r 0b5116194f20c04adb094da2897add271298b37a yt/visualization/profile_plotter.py
--- a/yt/visualization/profile_plotter.py
+++ b/yt/visualization/profile_plotter.py
@@ -29,7 +29,7 @@
from .base_plot_types import ImagePlotMPL
from .plot_container import \
ImagePlotContainer, \
- log_transform, linear_transform
+ log_transform, linear_transform, get_log_minorticks
from yt.data_objects.profiles import \
create_profile
from yt.utilities.exceptions import \
@@ -848,6 +848,29 @@
label.set_fontproperties(fp)
if self._font_color is not None:
label.set_color(self._font_color)
+
+ # x-y axes minorticks
+ if f not in self._minorticks:
+ self._minorticks[f] = True
+ if self._minorticks[f] is True:
+ self.plots[f].axes.minorticks_on()
+ else:
+ self.plots[f].axes.minorticks_off()
+
+ # colorbar minorticks
+ if f not in self._cbar_minorticks:
+ self._cbar_minorticks[f] = True
+ if self._cbar_minorticks[f] is True:
+ if self._field_transform[f] == linear_transform:
+ self.plots[f].cax.minorticks_on()
+ else:
+ vmin = np.float64( self.plots[f].cb.norm.vmin )
+ vmax = np.float64( self.plots[f].cb.norm.vmax )
+ mticks = self.plots[f].image.norm( get_log_minorticks(vmin, vmax) )
+ self.plots[f].cax.yaxis.set_ticks(mticks, minor=True)
+ else:
+ self.plots[f].cax.minorticks_off()
+
self._plot_valid = True
@classmethod
https://bitbucket.org/yt_analysis/yt/commits/d3691b7a4346/
Changeset: d3691b7a4346
Branch: yt
User: jzuhone
Date: 2014-10-22 15:45:41+00:00
Summary: Merged in ngoldbaum/yt (pull request #1262)
Adding a field plugin for fields defined in my_plugins.py. Closes #899.
Affected #: 4 files
diff -r 4ac89a8373911095eab03cbd009ca1bbf10c940e -r d3691b7a43464dbf63a11dc7f064c7d68e479416 doc/source/reference/faq/index.rst
--- a/doc/source/reference/faq/index.rst
+++ b/doc/source/reference/faq/index.rst
@@ -214,26 +214,37 @@
The plugin file is a means of modifying the available fields, quantities, data
objects and so on without modifying the source code of yt. The plugin file
-will be executed if it is detected, and it must be:
+will be executed if it is detected. It must be located in a ``.yt`` folder
+in your home directory and be named ``my_plugins.py``:
.. code-block:: bash
$HOME/.yt/my_plugins.py
-The code in this file can thus add fields, add derived quantities, add
+The code in this file can add fields, define functions, define
datatypes, and on and on. It is executed at the bottom of ``yt.mods``, and so
-it is provided with the entire namespace available in the module ``yt.mods`` --
-which is the primary entry point to yt, and which contains most of the
-functionality of yt. For example, if I created a plugin file containing:
+it is provided with the entire namespace available in the module ``yt.mods``.
+For example, if I created a plugin file containing:
.. code-block:: python
def _myfunc(field, data):
return np.random.random(data["density"].shape)
- add_field("SomeQuantity", function=_myfunc)
+ add_field("some_quantity", function=_myfunc, units='')
-then all of my data objects would have access to the field "SomeQuantity"
-despite its lack of use.
+then all of my data objects would have access to the field "some_quantity".
+Note that the units must be specified as a string, see
+:ref:`data_selection_and_fields` for more details on units and derived fields.
+
+.. note::
+
+ Since the ``my_plugins.py`` is parsed inside of ``yt.mods``, you must import
+ yt using ``yt.mods`` to use the plugins file. If you import using
+ ``import yt``, the plugins file will not be parsed. You can tell that your
+ plugins file is being parsed by watching for a logging message when you
+ import yt. Note that both the ``yt load`` and ``iyt`` command line entry
+ points invoke ``from yt.mods import *``, so the ``my_plugins.py`` file
+ will be parsed if you enter yt that way.
You can also define other convenience functions in your plugin file. For
instance, you could define some variables or functions, and even import common
diff -r 4ac89a8373911095eab03cbd009ca1bbf10c940e -r d3691b7a43464dbf63a11dc7f064c7d68e479416 yt/fields/api.py
--- a/yt/fields/api.py
+++ b/yt/fields/api.py
@@ -26,6 +26,11 @@
from . import particle_fields
#from . import species_fields
from . import vector_operations
+from . import local_fields
+from . import my_plugin_fields
+
+from .local_fields import add_field, derived_field
+
from .derived_field import \
DerivedField, \
@@ -38,6 +43,3 @@
FieldDetector
from .field_info_container import \
FieldInfoContainer
-
-from . import local_fields
-from .local_fields import add_field, derived_field
diff -r 4ac89a8373911095eab03cbd009ca1bbf10c940e -r d3691b7a43464dbf63a11dc7f064c7d68e479416 yt/fields/my_plugin_fields.py
--- /dev/null
+++ b/yt/fields/my_plugin_fields.py
@@ -0,0 +1,31 @@
+"""
+This is a container for storing fields defined in the my_plugins.py file.
+
+
+
+"""
+
+#-----------------------------------------------------------------------------
+# Copyright (c) 2013, yt Development Team.
+#
+# Distributed under the terms of the Modified BSD License.
+#
+# The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+import numpy as np
+
+from .field_plugin_registry import \
+ register_field_plugin
+
+from .field_info_container import \
+ FieldInfoContainer
+
+# Empty FieldInfoContainer
+my_plugins_fields = FieldInfoContainer(None, [], None)
+
+ at register_field_plugin
+def setup_my_plugins_fields(registry, ftype="gas", slice_info=None):
+ # fields end up inside this container when added via add_field in
+ # my_plugins.py. See yt.funcs.enable_plugins to see how this is set up.
+ registry.update(my_plugins_fields)
diff -r 4ac89a8373911095eab03cbd009ca1bbf10c940e -r d3691b7a43464dbf63a11dc7f064c7d68e479416 yt/funcs.py
--- a/yt/funcs.py
+++ b/yt/funcs.py
@@ -14,7 +14,6 @@
#-----------------------------------------------------------------------------
import time, types, signal, inspect, traceback, sys, pdb, os, re
-import time, types, signal, inspect, traceback, sys, pdb, os, re
import contextlib
import warnings, struct, subprocess
import numpy as np
@@ -748,9 +747,10 @@
SyntaxWarning, stacklevel=2)
return cls(*args, **kwargs)
return _func
-
+
def enable_plugins():
import yt
+ from yt.fields.my_plugin_fields import my_plugins_fields
from yt.config import ytcfg
my_plugin_name = ytcfg.get("yt","pluginfilename")
# We assume that it is with respect to the $HOME/.yt directory
@@ -760,7 +760,9 @@
_fn = os.path.expanduser("~/.yt/%s" % my_plugin_name)
if os.path.isfile(_fn):
mylog.info("Loading plugins from %s", _fn)
- execfile(_fn, yt.__dict__)
+ execdict = yt.__dict__.copy()
+ execdict['add_field'] = my_plugins_fields.add_field
+ execfile(_fn, execdict)
def fix_unitary(u):
if u == '1':
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