[yt-svn] commit/yt: 5 new changesets
commits-noreply at bitbucket.org
commits-noreply at bitbucket.org
Wed Mar 9 09:40:35 PST 2016
5 new commits in yt:
https://bitbucket.org/yt_analysis/yt/commits/5c16df18466b/
Changeset: 5c16df18466b
Branch: yt
User: atmyers
Date: 2016-03-04 18:59:58+00:00
Summary: Add an example of changing the scale keyword argument to the Transfer Function Tutorial.
Affected #: 1 file
diff -r c61e9e1d9dbe9595cb9769b3df337e485a8bc598 -r 5c16df18466b8a546df46d0b880949c21758dcb9 doc/source/visualizing/TransferFunctionHelper_Tutorial.ipynb
--- a/doc/source/visualizing/TransferFunctionHelper_Tutorial.ipynb
+++ b/doc/source/visualizing/TransferFunctionHelper_Tutorial.ipynb
@@ -4,7 +4,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Here, we explain how to use TransferFunctionHelper to visualize and interpret yt volume rendering transfer functions. TransferFunctionHelper is a utility class that makes it easy to visualize he probability density functions of yt fields that you might want to volume render. This makes it easier to choose a nice transfer function that highlights interesting physical regimes.\n",
+ "Here, we explain how to use TransferFunctionHelper to visualize and interpret yt volume rendering transfer functions. Creating a custom transfer function is a process that usually involves some trial-and-error. TransferFunctionHelper is a utility class designed to help you visualize the probability density functions of yt fields that you might want to volume render. This makes it easier to choose a nice transfer function that highlights interesting physical regimes.\n",
"\n",
"First, we set up our namespace and define a convenience function to display volume renderings inline in the notebook. Using `%matplotlib inline` makes it so matplotlib plots display inline in the notebook."
]
@@ -133,8 +133,8 @@
"tfh.set_log(True)\n",
"tfh.build_transfer_function()\n",
"tfh.tf.add_layers(8, w=0.01, mi=4.0, ma=8.0, col_bounds=[4.,8.], alpha=np.logspace(-1,2,7), colormap='RdBu_r')\n",
- "tfh.tf.map_to_colormap(6.0, 8.0, colormap='Reds', scale=10.0)\n",
- "tfh.tf.map_to_colormap(-1.0, 6.0, colormap='Blues_r', scale=1.)\n",
+ "tfh.tf.map_to_colormap(6.0, 8.0, colormap='Reds')\n",
+ "tfh.tf.map_to_colormap(-1.0, 6.0, colormap='Blues_r')\n",
"\n",
"tfh.plot(profile_field='cell_mass')"
]
@@ -143,7 +143,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Finally, let's take a look at the volume rendering. First use the helper function to create a default rendering, then we override this with the transfer function we just created."
+ "Let's take a look at the volume rendering. First use the helper function to create a default rendering, then we override this with the transfer function we just created."
]
},
{
@@ -167,27 +167,75 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "We can clearly see that the hot gas is mostly associated with bound structures while the cool gas is associated with low-density voids."
+ "That looks okay, but the red gas (associated with temperatures between 1e6 and 1e8 K) is a bit hard to see in the image. To fix this, we can make that gas contribute a larger alpha value to the image by using the ``scale`` keyword argument in ``map_to_colormap``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "tfh2 = TransferFunctionHelper(ds)\n",
+ "tfh2.set_field('temperature')\n",
+ "tfh2.set_bounds()\n",
+ "tfh2.set_log(True)\n",
+ "tfh2.build_transfer_function()\n",
+ "tfh2.tf.add_layers(8, w=0.01, mi=4.0, ma=8.0, col_bounds=[4.,8.], alpha=np.logspace(-1,2,7), colormap='RdBu_r')\n",
+ "tfh2.tf.map_to_colormap(6.0, 8.0, colormap='Reds', scale=5.0)\n",
+ "tfh2.tf.map_to_colormap(-1.0, 6.0, colormap='Blues_r', scale=1.0)\n",
+ "\n",
+ "tfh2.plot(profile_field='cell_mass')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Note that the height of the red portion of the transfer function has increased by a factor of 5.0. If we use this transfer function to make the final image:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "source.set_transfer_function(tfh2.tf)\n",
+ "im3 = sc.render()\n",
+ "\n",
+ "showme(im3[:,:,:3])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The red gas is now much more prominant in the image. We can clearly see that the hot gas is mostly associated with bound structures while the cool gas is associated with low-density voids."
]
}
],
"metadata": {
"kernelspec": {
- "display_name": "Python 3",
+ "display_name": "Python 2",
"language": "python",
- "name": "python3"
+ "name": "python2"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
- "version": 3
+ "version": 2
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.5.1"
+ "pygments_lexer": "ipython2",
+ "version": "2.7.11"
}
},
"nbformat": 4,
https://bitbucket.org/yt_analysis/yt/commits/88b43f0ef048/
Changeset: 88b43f0ef048
Branch: yt
User: atmyers
Date: 2016-03-04 19:14:11+00:00
Summary: merging.
Affected #: 99 files
diff -r 5c16df18466b8a546df46d0b880949c21758dcb9 -r 88b43f0ef048557578f4a0eb26cfd85910c1550b doc/source/analyzing/fields.rst
--- a/doc/source/analyzing/fields.rst
+++ b/doc/source/analyzing/fields.rst
@@ -94,16 +94,16 @@
There is a third, borderline class of field in yt, as well. This is the
"alias" type, where a field on disk (for example, (frontend, ``Density``)) is
-aliased into an internal yt-name (for example, (``gas``, ``density``)). The
+aliased into an internal yt-name (for example, (``gas``, ``density``)). The
aliasing process allows universally-defined derived fields to take advantage of
internal names, and it also provides an easy way to address what units something
should be returned in. If an aliased field is requested (and aliased fields
will always be lowercase, with underscores separating words) it will be returned
-in CGS units (future versions will enable global defaults to be set for MKS and
-other unit systems), whereas if the frontend-specific field is requested, it
-will not undergo any unit conversions from its natural units. (This rule is
-occasionally violated for fields which are mesh-dependent, specifically particle
-masses in some cosmology codes.)
+in the units specified by the unit system of the database (see :ref:`unit_systems`
+for a guide to using the different unit systems in yt), whereas if the
+frontend-specific field is requested, it will not undergo any unit conversions
+from its natural units. (This rule is occasionally violated for fields which
+are mesh-dependent, specifically particle masses in some cosmology codes.)
.. _known-field-types:
@@ -125,7 +125,8 @@
* ``gas`` -- This is the usual default for simulation frontends for fluid
types. These fields are typically aliased to the frontend-specific mesh
fields for grid-based codes or to the deposit fields for particle-based
- codes. Default units are in CGS.
+ codes. Default units are in the unit system of the dataset (see
+ :ref:`unit_systems` for more information).
* particle type -- These are particle fields that exist on-disk as written
by individual frontends. If the frontend designates names for these particles
(i.e. particle type) those names are the field types.
@@ -240,6 +241,37 @@
print(ds.field_info["gas", "pressure"].get_units())
print(ds.field_info["gas", "pressure"].get_source())
+.. _bfields:
+
+Magnetic Fields
+---------------
+
+Magnetic fields require special handling, because their dimensions are different in
+different systems of units, in particular between the CGS and MKS (SI) systems of units.
+Superficially, it would appear that they are in the same dimensions, since the units
+of the magnetic field in the CGS and MKS system are gauss (:math:`\rm{G}`) and tesla
+(:math:`\rm{T}`), respectively, and numerically :math:`1~\rm{G} = 10^{-4}~\rm{T}`. However,
+if we examine the base units, we find that they do indeed have different dimensions:
+
+.. math::
+
+ \rm{1~G = 1~\frac{\sqrt{g}}{\sqrt{cm}\cdot{s}}} \\
+ \rm{1~T = 1~\frac{kg}{A\cdot{s^2}}}
+
+It is easier to see the difference between the dimensionality of the magnetic field in the two
+systems in terms of the definition of the magnetic pressure:
+
+.. math::
+
+ p_B = \frac{B^2}{8\pi}~\rm{(cgs)} \\
+ p_B = \frac{B^2}{2\mu_0}~\rm{(MKS)}
+
+where :math:`\mu_0 = 4\pi \times 10^{-7}~\rm{N/A^2}` is the vacuum permeability. yt automatically
+detects on a per-frontend basis what units the magnetic should be in, and allows conversion between
+different magnetic field units in the different :ref:`unit systems <unit_systems>` as well. To
+determine how to set up special magnetic field handling when designing a new frontend, check out
+:ref:`bfields-frontend`.
+
Particle Fields
---------------
diff -r 5c16df18466b8a546df46d0b880949c21758dcb9 -r 88b43f0ef048557578f4a0eb26cfd85910c1550b doc/source/analyzing/units/2)_Fields_and_unit_conversion.ipynb
--- a/doc/source/analyzing/units/2)_Fields_and_unit_conversion.ipynb
+++ b/doc/source/analyzing/units/2)_Fields_and_unit_conversion.ipynb
@@ -24,9 +24,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"import yt\n",
@@ -41,9 +39,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"print (maxval)"
@@ -52,9 +48,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"print (dens)"
@@ -63,9 +57,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"mass = dd['cell_mass']\n",
@@ -79,9 +71,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"dx = dd['dx']\n",
@@ -107,9 +97,11 @@
"* `in_units`\n",
"* `in_cgs`\n",
"* `in_mks`\n",
+ "* `in_base`\n",
"* `convert_to_units`\n",
"* `convert_to_cgs`\n",
- "* `convert_to_mks`"
+ "* `convert_to_mks`\n",
+ "* `convert_to_base`"
]
},
{
@@ -122,9 +114,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"print (dd['density'].in_units('Msun/pc**3'))"
@@ -134,35 +124,73 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "`in_cgs` and `in_mks` return a copy of the array converted CGS and MKS units, respectively:"
+ "`in_cgs` and `in_mks` return a copy of the array converted to CGS and MKS units, respectively:"
]
},
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"print (dd['pressure'])\n",
- "print ((dd['pressure']).in_cgs())\n",
- "print ((dd['pressure']).in_mks())"
+ "print (dd['pressure'].in_cgs())\n",
+ "print (dd['pressure'].in_mks())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "The next two methods do in-place conversions:"
+ "`in_cgs` and `in_mks` are just special cases of the more general `in_base`, which can convert a `YTArray` to a number of different unit systems:"
]
},
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print (dd['pressure'].in_base('imperial')) # Imperial/English base units\n",
+ "print (dd['pressure'].in_base('galactic')) # Base units of kpc, Msun, Myr\n",
+ "print (dd['pressure'].in_base('planck')) # Base units in the Planck system\n",
+ "print (dd['pressure'].in_base()) # defaults to cgs if no argument given"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "`in_base` can even take a dataset as the argument to convert the `YTArray` into the base units of the dataset:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print (dd['pressure'].in_base(ds)) # The IsolatedGalaxy dataset from above"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "yt defines a number of unit systems, and new unit systems may be added by the user, which can also be passed to `in_base`. To learn more about the unit systems, how to use them with datasets and other objects, and how to add new ones, see [Unit Systems](unit_systems.html)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The rest of the methods do in-place conversions:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
"outputs": [],
"source": [
"dens = dd['density']\n",
@@ -182,9 +210,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"print (dd['density'])\n",
@@ -206,9 +232,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"print (dd['cell_mass'])\n",
@@ -234,9 +258,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"q1 = yt.YTArray(1.0,\"C\") # coulombs\n",
@@ -249,9 +271,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"B1 = yt.YTArray(1.0,\"T\") # tesla\n",
@@ -285,9 +305,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
@@ -317,9 +335,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"print (dd['cell_mass'].ndarray_view())\n",
@@ -338,9 +354,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"density_values = dd['density'].d\n",
@@ -374,23 +388,19 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"from astropy import units as u\n",
"\n",
"x = 42.0 * u.meter\n",
- "y = yt.YTQuantity.from_astropy(x) "
+ "y = yt.YTQuantity.from_astropy(x)"
]
},
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"print (x, type(x))\n",
@@ -400,9 +410,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"a = np.random.random(size=10) * u.km/u.s\n",
@@ -412,9 +420,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"print (a, type(a))\n",
@@ -431,9 +437,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"temp = dd[\"temperature\"]\n",
@@ -443,9 +447,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"print (temp, type(temp))\n",
@@ -462,9 +464,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"from yt.utilities.physical_constants import kboltz\n",
@@ -474,9 +474,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"print (kboltz, type(kboltz))\n",
@@ -493,9 +491,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"k1 = kboltz.to_astropy()\n",
@@ -506,9 +502,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"c = yt.YTArray.from_astropy(a)\n",
@@ -526,9 +520,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"from pint import UnitRegistry\n",
@@ -540,9 +532,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"print (v, type(v))\n",
@@ -552,9 +542,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"ptemp = temp.to_pint()"
@@ -563,9 +551,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"print (temp, type(temp))\n",
@@ -582,7 +568,7 @@
"language_info": {
"codemirror_mode": {
"name": "ipython",
- "version": 3
+ "version": 3.0
},
"file_extension": ".py",
"mimetype": "text/x-python",
@@ -594,4 +580,4 @@
},
"nbformat": 4,
"nbformat_minor": 0
-}
+}
\ No newline at end of file
diff -r 5c16df18466b8a546df46d0b880949c21758dcb9 -r 88b43f0ef048557578f4a0eb26cfd85910c1550b doc/source/analyzing/units/4)_Comparing_units_from_different_datasets.ipynb
--- a/doc/source/analyzing/units/4)_Comparing_units_from_different_datasets.ipynb
+++ b/doc/source/analyzing/units/4)_Comparing_units_from_different_datasets.ipynb
@@ -4,7 +4,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Units that refer to the internal simulation coordinate system will have different CGS conversion factors in different datasets. Depending on how a unit system is implemented, this could add an element of uncertainty when we compare dimensional arrays instances produced by different unit systems. Fortunately, this is not a problem for `YTArray` since all `YTArray` unit systems are defined in terms of physical CGS units.\n",
+ "Units that refer to the internal simulation coordinate system will have different CGS conversion factors in different datasets. Depending on how a unit system is implemented, this could add an element of uncertainty when we compare dimensional array instances produced by different unit systems. Fortunately, this is not a problem for `YTArray` since all `YTArray` unit systems are defined in terms of physical CGS units.\n",
"\n",
"As an example, let's load up two enzo datasets from different redshifts in the same cosmology simulation."
]
@@ -12,9 +12,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"# A high redshift output from z ~ 8\n",
@@ -29,9 +27,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"# A low redshift output from z ~ 0\n",
@@ -51,9 +47,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"print (ds2.length_unit.in_cgs()/ds1.length_unit.in_cgs() == (1+ds1.current_redshift)/(1+ds2.current_redshift))"
@@ -69,9 +63,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"print (ds2.length_unit/ds1.length_unit)"
@@ -89,9 +81,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"import yt\n",
@@ -120,7 +110,7 @@
"language_info": {
"codemirror_mode": {
"name": "ipython",
- "version": 3
+ "version": 3.0
},
"file_extension": ".py",
"mimetype": "text/x-python",
@@ -132,4 +122,4 @@
},
"nbformat": 4,
"nbformat_minor": 0
-}
+}
\ No newline at end of file
diff -r 5c16df18466b8a546df46d0b880949c21758dcb9 -r 88b43f0ef048557578f4a0eb26cfd85910c1550b doc/source/analyzing/units/7)_Unit_Systems.ipynb
--- /dev/null
+++ b/doc/source/analyzing/units/7)_Unit_Systems.ipynb
@@ -0,0 +1,491 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "By default, the results of most calculations in yt are expressed in a \"centimeters-grams-seconds\" (CGS) set of units. This includes the values of derived fields and aliased fields.\n",
+ "\n",
+ "However, this system of units may not be the most natural for a given dataset or an entire class of datasets. For this reason, yt provides the ability to define new unit systems and use them in a way that is highly configurable by the end-user. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Unit Systems Available in yt"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Several unit systems are already supplied for use within yt. They are:\n",
+ "\n",
+ "* `\"cgs\"`: Centimeters-grams-seconds unit system, with base of `(cm, g, s, K, radian)`. Uses the Gaussian normalization for electromagnetic units. \n",
+ "* `\"mks\"`: Meters-kilograms-seconds unit system, with base of `(m, kg, s, K, radian, A)`.\n",
+ "* `\"imperial\"`: Imperial unit system, with base of `(mile, lbm, s, R, radian)`.\n",
+ "* `\"galactic\"`: \"Galactic\" unit system, with base of `(kpc, Msun, Myr, K, radian)`.\n",
+ "* `\"solar\"`: \"Solar\" unit system, with base of `(AU, Mearth, yr, K, radian)`. \n",
+ "* `\"planck\"`: Planck natural units $(\\hbar = c = G = k_B = 1)$, with base of `(l_pl, m_pl, t_pl, T_pl, radian)`. \n",
+ "* `\"geometrized\"`: Geometrized natural units $(c = G = 1)$, with base of `(l_geom, m_geom, t_geom, K, radian)`. \n",
+ "\n",
+ "We can examine these unit systems by querying them from the `unit_system_registry`. For example, we can look at the default CGS system:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "import yt\n",
+ "yt.unit_system_registry[\"cgs\"]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We can see that we have two sets of units that this system defines: \"base\" and \"other\" units. The \"base\" units are the set of units from which all other units in the system are composed of, such as centimeters, grams, and seconds. The \"other\" units are compound units which fields with specific dimensionalities are converted to, such as ergs, dynes, gauss, and electrostatic units (esu). \n",
+ "\n",
+ "We see a similar setup for the MKS system, except that in this case, there is a base unit of current, the Ampere:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "yt.unit_system_registry[\"mks\"]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We can also look at the imperial system:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "yt.unit_system_registry[\"imperial\"]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "and the \"galactic\" system as well:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "yt.unit_system_registry[\"galactic\"]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Converting `YTArrays` to the Different Unit Systems"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Choosing a Unit System When Loading a Dataset"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "When a dataset is `load`ed, a unit system may be specified. When this happens, all aliased and derived fields will be converted to the units of the given system. The default is `\"cgs\"`.\n",
+ "\n",
+ "For example, we can specify that the fields from a FLASH dataset can be expressed in MKS units:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "ds_flash = yt.load(\"GasSloshing/sloshing_nomag2_hdf5_plt_cnt_0100\", unit_system=\"mks\")\n",
+ "sp = ds_flash.sphere(\"c\", (100.,\"kpc\"))\n",
+ "print (sp[\"density\"]) # This is an alias for (\"flash\",\"dens\")\n",
+ "print (sp[\"pressure\"]) # This is an alias for (\"flash\",\"pres\")\n",
+ "print (sp[\"angular_momentum_x\"]) # This is a derived field\n",
+ "print (sp[\"kinetic_energy\"]) # This is also a derived field"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Aliased fields are converted to the requested unit system, but the on-disk fields that they correspond to remain in their original (code) units:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "print (sp[\"flash\",\"dens\"]) # This is aliased to (\"gas\", \"density\")\n",
+ "print (sp[\"flash\",\"pres\"]) # This is aliased to (\"gas\", \"pressure\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We can take an `Enzo` dataset and express it in `\"galactic\"` units:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "ds_enzo = yt.load(\"IsolatedGalaxy/galaxy0030/galaxy0030\", unit_system=\"galactic\")\n",
+ "sp = ds_enzo.sphere(\"c\", (20.,\"kpc\"))\n",
+ "print (sp[\"density\"])\n",
+ "print (sp[\"pressure\"])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We can also express all of the fields associated with a dataset in that dataset's system of \"code\" units. Though the on-disk fields are already in these units, this means that we can express even derived fields in code units as well:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "ds_chombo = yt.load(\"KelvinHelmholtz/data.0004.hdf5\", unit_system=\"code\")\n",
+ "dd = ds_chombo.all_data()\n",
+ "print (dd[\"density\"])\n",
+ "print (dd[\"kinetic_energy\"])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Defining Fields So That They Can Use the Different Unit Systems"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "If you define a new derived field for use in yt and wish to make the different unit systems available to it, you will need to specify this when calling `add_field`. Suppose I defined a new field called `\"momentum_x\"` and wanted it to have general units. I would have to set it up in this fashion, using the `unit_system` attribute of the dataset and querying it for the appropriate dimensions:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "mom_units = ds_flash.unit_system[\"velocity\"]*ds_flash.unit_system[\"density\"]\n",
+ "def _momentum_x(field, data):\n",
+ " return data[\"density\"]*data[\"velocity_x\"]\n",
+ "ds_flash.add_field((\"gas\",\"momentum_x\"), function=_momentum_x, units=mom_units)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now, the field will automatically be expressed in whatever units the dataset was called with. In this case, it was MKS:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "slc = yt.SlicePlot(ds_flash, \"z\", [\"momentum_x\"], width=(300.,\"kpc\"))\n",
+ "slc.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Note that the momentum density has been plotted with the correct MKS units of $\\mathrm{kg/(m^2\\cdot{s})}$."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "If you don't create a derived field from a dataset but instead use `yt.add_field`, and still want to use the unit system of that dataset for the units, the only option at present is to set `units=\"auto\"` in the call to `yt.add_field` and the `dimensions` keyword to the correct dimensions for the field:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "from yt.units import clight\n",
+ "\n",
+ "def _rest_energy(field, data):\n",
+ " return data[\"cell_mass\"]*clight*clight\n",
+ "yt.add_field((\"gas\",\"rest_energy\"), function=_rest_energy, units=\"auto\", dimensions=\"energy\")\n",
+ "\n",
+ "ds_flash2 = yt.load(\"GasSloshing/sloshing_nomag2_hdf5_plt_cnt_0150\", unit_system=\"galactic\")\n",
+ "\n",
+ "sp = ds_flash2.sphere(\"c\", (100.,\"kpc\"))\n",
+ "sp[\"rest_energy\"]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Obtaining Physical Constants in a Specific Unit System"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Each unit system provides the ability to obtain any physical constant in yt's physical constants database in the base units of that system via the `constants` attribute of the unit system. For example, to obtain the value of Newton's universal constant of gravitation in different base units:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "for name in [\"cgs\", \"mks\", \"imperial\", \"planck\", \"geometrized\"]:\n",
+ " unit_system = yt.unit_system_registry[name]\n",
+ " print (name, unit_system.constants.G)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Equivalently, one could import a physical constant from the main database and convert it using `in_base`:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "from yt.utilities.physical_constants import G\n",
+ "print (G.in_base(\"mks\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Defining Your Own Unit System"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "You are not limited to using the unit systems already defined by yt. A new unit system can be defined by creating a new `UnitSystem` instance. For example, to create a unit system where the default units are in millimeters, centigrams, and microseconds:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "small_unit_system = yt.UnitSystem(\"small\", \"mm\", \"cg\", \"us\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "where the required arguments are a `name` for the unit system, and the `length_unit`, `mass_unit`, and `time_unit` for the unit system, which serve as the \"base\" units to convert everything else to. Once a unit system instance is created, it is automatically added to the `unit_system_registry` so that it may be used throughout yt:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "yt.unit_system_registry[\"small\"]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Note that the base units for the dimensions of angle and temperature have been automatically set to radians and Kelvin, respectively. If desired, these can be specified using optional arguments when creating the `UnitSystem` object:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "wacky_unit_system = yt.UnitSystem(\"wacky\", \"mile\", \"kg\", \"day\", temperature_unit=\"R\", angle_unit=\"deg\")\n",
+ "wacky_unit_system"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Though it will rarely be necessary, an MKS-style system of units where a unit of current can be specified as a base unit can also be created using the `current_mks` optional argument:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "mksish_unit_system = yt.UnitSystem(\"mksish\", \"dm\", \"ug\", \"ks\", current_mks_unit=\"mA\")\n",
+ "mksish_unit_system"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Initializing a `UnitSystem` object only sets up the base units. In this case, all fields will be converted to combinations of these base units based on their dimensionality. However, you may want to specify that fields of a given dimensionality use a compound unit by default instead. For example, you might prefer that in the `\"small\"` unit system that pressures be represented in microdynes per millimeter squared. To do this, set these to be the units of the `\"pressure\"` dimension explicitly:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "small_unit_system[\"pressure\"] = \"udyne/mm**2\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We can now look at the `small_unit_system` object and see that these units are now defined for pressure in the \"Other Units\" category:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "small_unit_system"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We can do the same for a few other dimensionalities:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "small_unit_system[\"magnetic_field_cgs\"] = \"mG\"\n",
+ "small_unit_system[\"specific_energy\"] = \"cerg/ug\"\n",
+ "small_unit_system[\"velocity\"] = \"cm/s\"\n",
+ "small_unit_system"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.5.1"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff -r 5c16df18466b8a546df46d0b880949c21758dcb9 -r 88b43f0ef048557578f4a0eb26cfd85910c1550b doc/source/analyzing/units/index.rst
--- a/doc/source/analyzing/units/index.rst
+++ b/doc/source/analyzing/units/index.rst
@@ -34,6 +34,7 @@
comparing_units_from_different_datasets
units_and_plotting
unit_equivalencies
+ unit_systems
.. note::
diff -r 5c16df18466b8a546df46d0b880949c21758dcb9 -r 88b43f0ef048557578f4a0eb26cfd85910c1550b doc/source/analyzing/units/unit_systems.rst
--- /dev/null
+++ b/doc/source/analyzing/units/unit_systems.rst
@@ -0,0 +1,7 @@
+.. _unit_systems:
+
+Unit Systems
+============
+
+.. notebook:: 7)_Unit_Systems.ipynb
+:skip_exceptions:
diff -r 5c16df18466b8a546df46d0b880949c21758dcb9 -r 88b43f0ef048557578f4a0eb26cfd85910c1550b doc/source/developing/creating_derived_fields.rst
--- a/doc/source/developing/creating_derived_fields.rst
+++ b/doc/source/developing/creating_derived_fields.rst
@@ -33,7 +33,10 @@
In this example, the ``density`` field will return data with units of
``g/cm**3`` and the ``thermal_energy`` field will return data units of
``erg/g``, so the result will automatically have units of pressure,
-``erg/cm**3``.
+``erg/cm**3``. This assumes the unit system is set to the default, which is
+CGS: if a different unit system is selected, the result will be in the same
+dimensions of pressure but different units. See :ref:`unit_systems` for more
+information.
Once we've defined our function, we need to notify yt that the field is
available. The :func:`add_field` function is the means of doing this; it has a
@@ -47,7 +50,7 @@
.. code-block:: python
- yt.add_field("pressure", function=_pressure, units="dyne/cm**2")
+ yt.add_field(("gas", "pressure"), function=_pressure, units="dyne/cm**2")
We feed it the name of the field, the name of the function, and the
units. Note that the units parameter is a "raw" string, in the format that yt
@@ -59,7 +62,7 @@
as in the ``_pressure`` example above.
Field definitions return array data with units. If the field function returns
-data in a dimensionally equivalent unit (e.g. a ``dyne`` versus a ``N``), the
+data in a dimensionally equivalent unit (e.g. a ``"dyne"`` versus a ``"N"``), the
field data will be converted to the units specified in ``add_field`` before
being returned in a data object selection. If the field function returns data
with dimensions that are incompatibible with units specified in ``add_field``,
@@ -67,7 +70,7 @@
function returns data in the correct units. Often, this means applying units to
a dimensionless float or array.
-If your field definition influcdes physical constants rather than defining a
+If your field definition includes physical constants rather than defining a
constant as a float, you can import it from ``yt.utilities.physical_constants``
to get a predefined version of the constant with the correct units. If you know
the units your data is supposed to have ahead of time, you can import unit
@@ -82,7 +85,29 @@
Lastly, if you do not know the units of your field ahead of time, you can
specify ``units='auto'`` in the call to ``add_field`` for your field. This will
automatically determine the appropriate units based on the units of the data
-returned by the field function.
+returned by the field function. This is also a good way to let your derived fields
+be automatically converted to the units of the :ref:`unit system <unit_systems>` in
+your dataset.
+
+If ``units='auto'`` is set, it is also required to set the ``dimensions`` keyword
+argument so that error-checking can be done on the derived field to make sure that
+the dimensionality of the returned array and the field are the same:
+
+.. code-block:: python
+
+ import yt
+ from yt.units import dimensions
+
+ def _pressure(field, data):
+ return (data.ds.gamma - 1.0) * \
+ data["density"] * data["thermal_energy"]
+
+ yt.add_field(("gas","pressure"), function=_pressure, units="auto",
+ dimensions=dimensions.pressure)
+
+If ``dimensions`` is not set, an error will be thrown. The ``dimensions`` keyword
+can be a SymPy ``symbol`` object imported from ``yt.units.dimensions``, a compound
+dimension of these, or a string corresponding to one of these objects.
:func:`add_field` can be invoked in two other ways. The first is by the
function decorator :func:`derived_field`. The following code is equivalent to
@@ -111,10 +136,27 @@
.. code-block:: python
ds = yt.load("GasSloshing/sloshing_nomag2_hdf5_plt_cnt_0100")
- ds.add_field("pressure", function=_pressure, units="dyne/cm**2")
+ ds.add_field(("gas", "pressure"), function=_pressure, units="dyne/cm**2")
-If you find yourself using the same custom-defined fields over and over, you
-should put them in your plugins file as described in :ref:`plugin-file`.
+If you specify fields in this way, you can take advantage of the dataset's
+:ref:`unit system <unit_systems>` to define the units for you, so that
+the units will be returned in the units of that system:
+
+.. code-block:: python
+
+ ds.add_field(("gas", "pressure"), function=_pressure, units=ds.unit_system["pressure"])
+
+Since the :class:`yt.units.unit_systems.UnitSystem` object returns a :class:`yt.units.unit_object.Unit` object when
+queried, you're not limited to specifying units in terms of those already available. You can specify units for fields
+using basic arithmetic if necessary:
+
+.. code-block:: python
+
+ ds.add_field(("gas", "my_acceleration"), function=_my_acceleration,
+ units=ds.unit_system["length"]/ds.unit_system["time"]**2)
+
+If you find yourself using the same custom-defined fields over and over, you should put them in your plugins file as
+described in :ref:`plugin-file`.
A More Complicated Example
--------------------------
@@ -148,7 +190,7 @@
y_hat /= r
z_hat /= r
return xv*x_hat + yv*y_hat + zv*z_hat
- yt.add_field("my_radial_velocity",
+ yt.add_field(("gas","my_radial_velocity"),
function=_my_radial_velocity,
units="cm/s",
take_log=False,
@@ -195,8 +237,11 @@
``function``
This is a function handle that defines the field
``units``
- This is a string that describes the units. Powers must be in
- Python syntax (``**`` instead of ``^``).
+ This is a string that describes the units, or a query to a :ref:`UnitSystem <unit_systems>`
+ object, e.g. ``ds.unit_system["energy"]``. Powers must be in Python syntax (``**``
+ instead of ``^``). Alternatively, it may be set to ``"auto"`` to have the units
+ determined automatically. In this case, the ``dimensions`` keyword must be set to the
+ correct dimensions of the field.
``display_name``
This is a name used in the plots, for instance ``"Divergence of
Velocity"``. If not supplied, the ``name`` value is used.
@@ -219,6 +264,9 @@
``force_override``
(*Advanced*) Overrides the definition of an old field if a field with the
same name has already been defined.
+``dimensions``
+ Set this if ``units="auto"``. Can be either a string or a dimension object from
+ ``yt.units.dimensions``.
Debugging a Derived Field
-------------------------
@@ -236,7 +284,7 @@
.. code-block:: python
- @yt.derived_field(name = "funthings")
+ @yt.derived_field(name = ("gas","funthings"))
def funthings(field, data):
return data["sillythings"] + data["humorousthings"]**2.0
@@ -244,7 +292,7 @@
.. code-block:: python
- @yt.derived_field(name = "funthings")
+ @yt.derived_field(name = ("gas","funthings"))
def funthings(field, data):
data._debug()
return data["sillythings"] + data["humorousthings"]**2.0
diff -r 5c16df18466b8a546df46d0b880949c21758dcb9 -r 88b43f0ef048557578f4a0eb26cfd85910c1550b doc/source/developing/creating_frontend.rst
--- a/doc/source/developing/creating_frontend.rst
+++ b/doc/source/developing/creating_frontend.rst
@@ -104,6 +104,43 @@
have a display name of ``r"\rho"``. Omitting the ``"display_name"``
will result in using a capitalized version of the ``"name"``.
+.. _bfields-frontend:
+
+Creating Aliases for Magnetic Fields
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Setting up access to the magnetic fields in your dataset requires special
+handling, because in different unit systems magnetic fields have different
+dimensions (see :ref:`bfields` for an explanation). If your dataset includes
+magnetic fields, you should include them in ``known_other_fields``, but do
+not set up aliases for them--instead use the special handling function
+:meth:`~yt.fields.magnetic_fields.setup_magnetic_field_aliases`. It takes
+as arguments the ``FieldInfoContainer`` instance, the field type of the
+frontend, and the list of magnetic fields from the frontend. Here is an
+example of how this is implemented in the FLASH frontend:
+
+.. code-block:: python
+
+ class FLASHFieldInfo(FieldInfoContainer):
+ known_other_fields = (
+ ...
+ ("magx", (b_units, [], "B_x")), # Note there is no alias here
+ ("magy", (b_units, [], "B_y")),
+ ("magz", (b_units, [], "B_z")),
+ ...
+ )
+
+ def setup_fluid_fields(self):
+ from yt.fields.magnetic_field import \
+ setup_magnetic_field_aliases
+ ...
+ setup_magnetic_field_aliases(self, "flash", ["mag%s" % ax for ax in "xyz"])
+
+This function should always be imported and called from within the
+``setup_fluid_fields`` method of the ``FieldInfoContainer``. If this
+function is used, converting between magnetic fields in different
+:ref:`unit systems <unit_systems>` will be handled automatically.
+
Data Localization Structures
----------------------------
diff -r 5c16df18466b8a546df46d0b880949c21758dcb9 -r 88b43f0ef048557578f4a0eb26cfd85910c1550b doc/source/examining/Loading_Generic_Array_Data.ipynb
--- a/doc/source/examining/Loading_Generic_Array_Data.ipynb
+++ b/doc/source/examining/Loading_Generic_Array_Data.ipynb
@@ -41,9 +41,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"import yt\n",
@@ -60,9 +58,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"arr = np.random.random(size=(64,64,64))"
@@ -78,9 +74,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"data = dict(density = (arr, \"g/cm**3\"))\n",
@@ -124,9 +118,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"slc = yt.SlicePlot(ds, \"z\", [\"density\"])\n",
@@ -148,9 +140,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"posx_arr = np.random.uniform(low=-1.5, high=1.5, size=10000)\n",
@@ -177,9 +167,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"slc = yt.SlicePlot(ds, \"z\", [\"density\"])\n",
@@ -205,9 +193,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"import h5py\n",
@@ -227,9 +213,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"print (f.keys())"
@@ -245,9 +229,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"units = [\"gauss\",\"gauss\",\"gauss\", \"g/cm**3\", \"erg/cm**3\", \"K\", \n",
@@ -264,9 +246,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"data = {k:(v.value,u) for (k,v), u in zip(f.items(),units)}\n",
@@ -276,9 +256,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"ds = yt.load_uniform_grid(data, data[\"Density\"][0].shape, length_unit=250.*cm_per_kpc, bbox=bbox, nprocs=8, \n",
@@ -295,9 +273,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"prj = yt.ProjectionPlot(ds, \"z\", [\"z-velocity\",\"Temperature\",\"Bx\"], weight_field=\"Density\")\n",
@@ -323,9 +299,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"#Find the min and max of the field\n",
@@ -345,9 +319,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"tf = yt.ColorTransferFunction((mi, ma), grey_opacity=False)"
@@ -363,9 +335,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"# Choose a vector representing the viewing direction.\n",
@@ -375,7 +345,7 @@
"# Define the width of the image\n",
"W = 1.5*ds.domain_width[0]\n",
"# Define the number of pixels to render\n",
- "Npixels = 512 "
+ "Npixels = 512"
]
},
{
@@ -388,9 +358,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"cam = ds.camera(c, L, W, Npixels, tf, fields=['Temperature'],\n",
@@ -404,9 +372,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"cam.show()"
@@ -429,9 +395,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"import astropy.io.fits as pyfits\n",
@@ -448,9 +412,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"f = pyfits.open(data_dir+\"/UnigridData/velocity_field_20.fits\")\n",
@@ -467,9 +429,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"data = {}\n",
@@ -489,9 +449,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"data[\"velocity_x\"] = data.pop(\"x-velocity\")\n",
@@ -509,9 +467,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"ds = yt.load_uniform_grid(data, data[\"velocity_x\"][0].shape, length_unit=(1.0,\"Mpc\"))\n",
@@ -539,9 +495,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"grid_data = [\n",
@@ -566,9 +520,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"for g in grid_data: \n",
@@ -586,9 +538,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"grid_data[0][\"number_of_particles\"] = 0 # Set no particles in the top-level grid\n",
@@ -611,9 +561,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"ds = yt.load_amr_grids(grid_data, [32, 32, 32])"
@@ -629,9 +577,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"slc = yt.SlicePlot(ds, \"z\", [\"density\"])\n",
@@ -650,7 +596,6 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "* Units will be incorrect unless the data has already been converted to cgs.\n",
"* Particles may be difficult to integrate.\n",
"* Data must already reside in memory before loading it in to yt, whether it is generated at runtime or loaded from disk. \n",
"* Some functions may behave oddly, and parallelism will be disappointing or non-existent in most cases.\n",
@@ -668,7 +613,7 @@
"language_info": {
"codemirror_mode": {
"name": "ipython",
- "version": 3
+ "version": 3.0
},
"file_extension": ".py",
"mimetype": "text/x-python",
@@ -680,4 +625,4 @@
},
"nbformat": 4,
"nbformat_minor": 0
-}
+}
\ No newline at end of file
diff -r 5c16df18466b8a546df46d0b880949c21758dcb9 -r 88b43f0ef048557578f4a0eb26cfd85910c1550b doc/source/examining/loading_data.rst
--- a/doc/source/examining/loading_data.rst
+++ b/doc/source/examining/loading_data.rst
@@ -803,7 +803,8 @@
.. rubric:: Caveats
-* Please be careful that the units are correctly utilized; yt assumes cgs.
+* Please be careful that the units are correctly utilized; yt assumes cgs by default, but conversion to
+ other :ref:`unit systems <unit_systems>` is also possible.
.. _loading-gadget-data:
@@ -1065,7 +1066,6 @@
.. rubric:: Caveats
-* Units will be incorrect unless the data has already been converted to cgs.
* Some functions may behave oddly, and parallelism will be disappointing or
non-existent in most cases.
* No consistency checks are performed on the index
@@ -1123,7 +1123,6 @@
.. rubric:: Caveats
-* Units will be incorrect unless the data has already been converted to cgs.
* Particles may be difficult to integrate.
* Data must already reside in memory.
@@ -1176,7 +1175,6 @@
.. rubric:: Caveats
-* Units will be incorrect unless the data has already been converted to cgs.
* Integration is not implemented.
* Some functions may behave oddly or not work at all.
* Data must already reside in memory.
@@ -1230,7 +1228,6 @@
.. rubric:: Caveats
-* Units will be incorrect unless the data has already been converted to cgs.
* Integration is not implemented.
* Some functions may behave oddly or not work at all.
* Data must already reside in memory.
diff -r 5c16df18466b8a546df46d0b880949c21758dcb9 -r 88b43f0ef048557578f4a0eb26cfd85910c1550b doc/source/reference/field_list.rst
--- a/doc/source/reference/field_list.rst
+++ b/doc/source/reference/field_list.rst
@@ -3084,10 +3084,10 @@
def _vorticity_x(field, data):
f = (data[ftype, "velocity_z"][sl_center,sl_right,sl_center] -
data[ftype, "velocity_z"][sl_center,sl_left,sl_center]) \
- / (div_fac*just_one(data["index", "dy"]).in_cgs())
+ / (div_fac*just_one(data["index", "dy"]))
f -= (data[ftype, "velocity_y"][sl_center,sl_center,sl_right] -
data[ftype, "velocity_y"][sl_center,sl_center,sl_left]) \
- / (div_fac*just_one(data["index", "dz"].in_cgs()))
+ / (div_fac*just_one(data["index", "dz"]))
new_field = data.ds.arr(np.zeros_like(data[ftype, "velocity_z"],
dtype=np.float64),
f.units)
@@ -3220,7 +3220,7 @@
def _cylindrical_r(field, data):
normal = data.get_field_parameter("normal")
coords = get_periodic_rvec(data)
- return data.ds.arr(get_cyl_r(coords, normal), "code_length").in_cgs()
+ return data.ds.arr(get_cyl_r(coords, normal), "code_length").in_base(unit_system.name)
('index', 'cylindrical_theta')
@@ -3251,7 +3251,7 @@
def _cylindrical_z(field, data):
normal = data.get_field_parameter("normal")
coords = get_periodic_rvec(data)
- return data.ds.arr(get_cyl_z(coords, normal), "code_length").in_cgs()
+ return data.ds.arr(get_cyl_z(coords, normal), "code_length").in_base(unit_system.name)
('index', 'disk_angle')
@@ -3424,7 +3424,7 @@
def _spherical_r(field, data):
coords = get_periodic_rvec(data)
- return data.ds.arr(get_sph_r(coords), "code_length").in_cgs()
+ return data.ds.arr(get_sph_r(coords), "code_length").in_base(unit_system.name)
('index', 'spherical_theta')
diff -r 5c16df18466b8a546df46d0b880949c21758dcb9 -r 88b43f0ef048557578f4a0eb26cfd85910c1550b setup.py
--- a/setup.py
+++ b/setup.py
@@ -5,6 +5,7 @@
from setuptools import setup, find_packages
from setuptools.extension import Extension
from setuptools.command.build_ext import build_ext as _build_ext
+from setuptools.command.sdist import sdist as _sdist
from setuptools.command.build_py import build_py as _build_py
from setupext import \
check_for_openmp, check_for_pyembree, read_embree_location, \
@@ -327,6 +328,16 @@
import numpy
self.include_dirs.append(numpy.get_include())
+class sdist(_sdist):
+ # subclass setuptools source distribution builder to ensure cython
+ # generated C files are included in source distribution.
+ # See http://stackoverflow.com/a/18418524/1382869
+ def run(self):
+ # Make sure the compiled Cython files in the distribution are up-to-date
+ from Cython.Build import cythonize
+ cythonize(cython_extensions)
+ _sdist.run(self)
+
setup(
name="yt",
version=VERSION,
@@ -357,15 +368,17 @@
packages=find_packages(),
setup_requires=[
'numpy',
- 'cython>=0.22'
+ 'cython>=0.22',
],
install_requires=[
# 'matplotlib', # messes up nosetests will be fixed in future PRs
+ 'setuptools>=18.0',
'sympy',
'numpy',
'IPython',
+ 'cython',
],
- cmdclass={'build_ext': build_ext, 'build_py': build_py},
+ cmdclass={'sdist': sdist, 'build_ext': build_ext, 'build_py': build_py},
author="The yt project",
author_email="yt-dev at lists.spacepope.org",
url="http://yt-project.org/",
diff -r 5c16df18466b8a546df46d0b880949c21758dcb9 -r 88b43f0ef048557578f4a0eb26cfd85910c1550b yt/__init__.py
--- a/yt/__init__.py
+++ b/yt/__init__.py
@@ -175,3 +175,9 @@
# Import some helpful math utilities
from yt.utilities.math_utils import \
ortho_find, quartiles, periodic_position
+
+from yt.units.unit_systems import UnitSystem
+from yt.units.unit_object import unit_system_registry
+
+from yt.analysis_modules.list_modules import \
+ amods
diff -r 5c16df18466b8a546df46d0b880949c21758dcb9 -r 88b43f0ef048557578f4a0eb26cfd85910c1550b yt/analysis_modules/level_sets/clump_validators.py
--- a/yt/analysis_modules/level_sets/clump_validators.py
+++ b/yt/analysis_modules/level_sets/clump_validators.py
@@ -13,7 +13,8 @@
# The full license is in the file COPYING.txt, distributed with this software.
#-----------------------------------------------------------------------------
-from yt.utilities.data_point_utilities import FindBindingEnergy
+from yt.utilities.lib.misc_utilities import \
+ gravitational_binding_energy
from yt.utilities.operator_registry import \
OperatorRegistry
from yt.utilities.physical_constants import \
@@ -64,11 +65,12 @@
(bulk_velocity[2] - clump["all", "particle_velocity_z"])**2)).sum()
potential = clump.data.ds.quan(G *
- FindBindingEnergy(clump["gas", "cell_mass"].in_cgs(),
- clump["index", "x"].in_cgs(),
- clump["index", "y"].in_cgs(),
- clump["index", "z"].in_cgs(),
- truncate, (kinetic / G).in_cgs()),
+ gravitational_binding_energy(
+ clump["gas", "cell_mass"].in_cgs(),
+ clump["index", "x"].in_cgs(),
+ clump["index", "y"].in_cgs(),
+ clump["index", "z"].in_cgs(),
+ truncate, (kinetic / G).in_cgs()),
kinetic.in_cgs().units)
if truncate and potential >= kinetic:
@@ -76,7 +78,7 @@
if use_particles:
potential += clump.data.ds.quan(G *
- FindBindingEnergy(
+ gravitational_binding_energy(
clump["all", "particle_mass"].in_cgs(),
clump["all", "particle_position_x"].in_cgs(),
clump["all", "particle_position_y"].in_cgs(),
diff -r 5c16df18466b8a546df46d0b880949c21758dcb9 -r 88b43f0ef048557578f4a0eb26cfd85910c1550b yt/analysis_modules/photon_simulator/photon_models.py
--- a/yt/analysis_modules/photon_simulator/photon_models.py
+++ b/yt/analysis_modules/photon_simulator/photon_models.py
@@ -133,7 +133,7 @@
if num_cells == 0:
continue
vol = chunk["cell_volume"].in_cgs().v
- EM = (chunk["density"]/mp).v**2
+ EM = (chunk["density"]/mp).in_cgs().v**2
EM *= 0.5*(1.+self.X_H)*self.X_H*vol
if isinstance(self.Zmet, string_types):
diff -r 5c16df18466b8a546df46d0b880949c21758dcb9 -r 88b43f0ef048557578f4a0eb26cfd85910c1550b yt/data_objects/construction_data_containers.py
--- a/yt/data_objects/construction_data_containers.py
+++ b/yt/data_objects/construction_data_containers.py
@@ -426,7 +426,7 @@
# will not be necessary at all, as the final conversion will occur
# at the display layer.
if not dl.units.is_dimensionless:
- dl.convert_to_units("cm")
+ dl.convert_to_units(self.ds.unit_system["length"])
v = np.empty((chunk.ires.size, len(fields)), dtype="float64")
for i, field in enumerate(fields):
d = chunk[field] * dl
diff -r 5c16df18466b8a546df46d0b880949c21758dcb9 -r 88b43f0ef048557578f4a0eb26cfd85910c1550b yt/data_objects/data_containers.py
--- a/yt/data_objects/data_containers.py
+++ b/yt/data_objects/data_containers.py
@@ -36,6 +36,7 @@
from yt.units.yt_array import \
YTArray, \
YTQuantity
+import yt.units.dimensions as ytdims
from yt.utilities.exceptions import \
YTUnitConversionError, \
YTFieldUnitError, \
@@ -45,7 +46,8 @@
YTFieldNotParseable, \
YTFieldNotFound, \
YTFieldTypeNotFound, \
- YTDataSelectorNotImplemented
+ YTDataSelectorNotImplemented, \
+ YTDimensionalityError
from yt.utilities.lib.marching_cubes import \
march_cubes_grid, march_cubes_grid_flux
from yt.utilities.parallel_tools.parallel_analysis_interface import \
@@ -186,11 +188,11 @@
self.center = None
return
elif isinstance(center, YTArray):
- self.center = self.ds.arr(center.in_cgs())
+ self.center = self.ds.arr(center.copy())
self.center.convert_to_units('code_length')
elif isinstance(center, (list, tuple, np.ndarray)):
if isinstance(center[0], YTQuantity):
- self.center = self.ds.arr([c.in_cgs() for c in center])
+ self.center = self.ds.arr([c.copy() for c in center])
self.center.convert_to_units('code_length')
else:
self.center = self.ds.arr(center, 'code_length')
@@ -935,7 +937,7 @@
s = "%s (%s): " % (self.__class__.__name__, self.ds)
for i in self._con_args:
try:
- s += ", %s=%s" % (i, getattr(self, i).in_cgs())
+ s += ", %s=%s" % (i, getattr(self, i).in_base(unit_system=self.ds.unit_system))
except AttributeError:
s += ", %s=%s" % (i, getattr(self, i))
return s
@@ -1054,6 +1056,7 @@
"of lower dimensionality (%u vs %u)" %
(data_source._dimensionality, self._dimensionality))
self.field_parameters.update(data_source.field_parameters)
+ self.quantities = DerivedQuantityCollection(self)
@property
def selector(self):
@@ -1206,13 +1209,19 @@
# infer the units from the units of the data we get back
# from the field function and use these units for future
# field accesses
- units = str(getattr(fd, 'units', ''))
+ units = getattr(fd, 'units', '')
+ if units == '':
+ dimensions = ytdims.dimensionless
+ else:
+ dimensions = units.dimensions
+ units = str(units.get_base_equivalent(self.ds.unit_system.name))
+ if fi.dimensions != dimensions:
+ raise YTDimensionalityError(fi.dimensions, dimensions)
fi.units = units
self.field_data[field] = self.ds.arr(fd, units)
msg = ("Field %s was added without specifying units, "
"assuming units are %s")
mylog.warn(msg % (fi.name, units))
- continue
try:
fd.convert_to_units(fi.units)
except AttributeError:
@@ -1457,7 +1466,6 @@
self._set_center(center)
self.coords = None
self._grids = None
- self.quantities = DerivedQuantityCollection(self)
def cut_region(self, field_cuts, field_parameters=None):
"""
diff -r 5c16df18466b8a546df46d0b880949c21758dcb9 -r 88b43f0ef048557578f4a0eb26cfd85910c1550b yt/data_objects/static_output.py
--- a/yt/data_objects/static_output.py
+++ b/yt/data_objects/static_output.py
@@ -40,7 +40,7 @@
ParameterFileStore, \
NoParameterShelf, \
output_type_registry
-from yt.units.unit_object import Unit
+from yt.units.unit_object import Unit, unit_system_registry
from yt.units.unit_registry import UnitRegistry
from yt.fields.derived_field import \
ValidateSpatial
@@ -59,6 +59,7 @@
from yt.units.yt_array import \
YTArray, \
YTQuantity
+from yt.units.unit_systems import create_code_unit_system
from yt.data_objects.region_expression import \
RegionExpression
@@ -192,7 +193,8 @@
obj = _cached_datasets[apath]
return obj
- def __init__(self, filename, dataset_type=None, file_style=None, units_override=None):
+ def __init__(self, filename, dataset_type=None, file_style=None,
+ units_override=None, unit_system="cgs"):
"""
Base class for generating new output types. Principally consists of
a *filename* and a *dataset_type* which will be passed on to children.
@@ -235,6 +237,11 @@
self.set_units()
self._setup_coordinate_handler()
+ create_code_unit_system(self)
+ if unit_system == "code":
+ unit_system = str(self)
+ self.unit_system = unit_system_registry[unit_system]
+
# Because we need an instantiated class to check the ds's existence in
# the cache, we move that check to here from __new__. This avoids
# double-instantiation.
@@ -870,7 +877,7 @@
"""Converts an array into a :class:`yt.units.yt_array.YTArray`
The returned YTArray will be dimensionless by default, but can be
- cast to arbitray units using the ``input_units`` keyword argument.
+ cast to arbitrary units using the ``input_units`` keyword argument.
Parameters
----------
@@ -916,7 +923,7 @@
"""Converts an scalar into a :class:`yt.units.yt_array.YTQuantity`
The returned YTQuantity will be dimensionless by default, but can be
- cast to arbitray units using the ``input_units`` keyword argument.
+ cast to arbitrary units using the ``input_units`` keyword argument.
Parameters
----------
This diff is so big that we needed to truncate the remainder.
https://bitbucket.org/yt_analysis/yt/commits/ebd869f91222/
Changeset: ebd869f91222
Branch: yt
User: atmyers
Date: 2016-03-04 20:50:20+00:00
Summary: restoring the notebook metdata to python3 form
Affected #: 1 file
diff -r 88b43f0ef048557578f4a0eb26cfd85910c1550b -r ebd869f91222cf16c7505a8add9ca5aa6f2d6f1e doc/source/visualizing/TransferFunctionHelper_Tutorial.ipynb
--- a/doc/source/visualizing/TransferFunctionHelper_Tutorial.ipynb
+++ b/doc/source/visualizing/TransferFunctionHelper_Tutorial.ipynb
@@ -221,9 +221,9 @@
],
"metadata": {
"kernelspec": {
- "display_name": "Python 2",
+ "display_name": "Python 3",
"language": "python",
- "name": "python2"
+ "name": "python3"
},
"language_info": {
"codemirror_mode": {
@@ -234,8 +234,8 @@
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
- "pygments_lexer": "ipython2",
- "version": "2.7.11"
+ "pygments_lexer": "ipython3",
+ "version": "3.5.1"
}
},
"nbformat": 4,
https://bitbucket.org/yt_analysis/yt/commits/1323e272447c/
Changeset: 1323e272447c
Branch: yt
User: atmyers
Date: 2016-03-04 20:51:10+00:00
Summary: missed this one
Affected #: 1 file
diff -r ebd869f91222cf16c7505a8add9ca5aa6f2d6f1e -r 1323e272447cd962f8a57ad147950d1ee0d0a689 doc/source/visualizing/TransferFunctionHelper_Tutorial.ipynb
--- a/doc/source/visualizing/TransferFunctionHelper_Tutorial.ipynb
+++ b/doc/source/visualizing/TransferFunctionHelper_Tutorial.ipynb
@@ -228,7 +228,7 @@
"language_info": {
"codemirror_mode": {
"name": "ipython",
- "version": 2
+ "version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
https://bitbucket.org/yt_analysis/yt/commits/c74d00a0b3ce/
Changeset: c74d00a0b3ce
Branch: yt
User: ngoldbaum
Date: 2016-03-09 17:40:20+00:00
Summary: Merged in atmyers/yt (pull request #2018)
Add an example of changing the scale keyword argument to the Transfer Function Tutorial. Closes Issue #1098.
Affected #: 1 file
diff -r aef6b376c4a5cb8e3ec8a3434e29435f142ad997 -r c74d00a0b3ce8086dc90a2734061a524c6ff277e doc/source/visualizing/TransferFunctionHelper_Tutorial.ipynb
--- a/doc/source/visualizing/TransferFunctionHelper_Tutorial.ipynb
+++ b/doc/source/visualizing/TransferFunctionHelper_Tutorial.ipynb
@@ -4,7 +4,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Here, we explain how to use TransferFunctionHelper to visualize and interpret yt volume rendering transfer functions. TransferFunctionHelper is a utility class that makes it easy to visualize he probability density functions of yt fields that you might want to volume render. This makes it easier to choose a nice transfer function that highlights interesting physical regimes.\n",
+ "Here, we explain how to use TransferFunctionHelper to visualize and interpret yt volume rendering transfer functions. Creating a custom transfer function is a process that usually involves some trial-and-error. TransferFunctionHelper is a utility class designed to help you visualize the probability density functions of yt fields that you might want to volume render. This makes it easier to choose a nice transfer function that highlights interesting physical regimes.\n",
"\n",
"First, we set up our namespace and define a convenience function to display volume renderings inline in the notebook. Using `%matplotlib inline` makes it so matplotlib plots display inline in the notebook."
]
@@ -132,8 +132,8 @@
"tfh.set_log(True)\n",
"tfh.build_transfer_function()\n",
"tfh.tf.add_layers(8, w=0.01, mi=4.0, ma=8.0, col_bounds=[4.,8.], alpha=np.logspace(-1,2,7), colormap='RdBu_r')\n",
- "tfh.tf.map_to_colormap(6.0, 8.0, colormap='Reds', scale=10.0)\n",
- "tfh.tf.map_to_colormap(-1.0, 6.0, colormap='Blues_r', scale=1.)\n",
+ "tfh.tf.map_to_colormap(6.0, 8.0, colormap='Reds')\n",
+ "tfh.tf.map_to_colormap(-1.0, 6.0, colormap='Blues_r')\n",
"\n",
"tfh.plot(profile_field='cell_mass')"
]
@@ -142,7 +142,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Finally, let's take a look at the volume rendering. First use the helper function to create a default rendering, then we override this with the transfer function we just created."
+ "Let's take a look at the volume rendering. First use the helper function to create a default rendering, then we override this with the transfer function we just created."
]
},
{
@@ -166,7 +166,55 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "We can clearly see that the hot gas is mostly associated with bound structures while the cool gas is associated with low-density voids."
+ "That looks okay, but the red gas (associated with temperatures between 1e6 and 1e8 K) is a bit hard to see in the image. To fix this, we can make that gas contribute a larger alpha value to the image by using the ``scale`` keyword argument in ``map_to_colormap``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "tfh2 = TransferFunctionHelper(ds)\n",
+ "tfh2.set_field('temperature')\n",
+ "tfh2.set_bounds()\n",
+ "tfh2.set_log(True)\n",
+ "tfh2.build_transfer_function()\n",
+ "tfh2.tf.add_layers(8, w=0.01, mi=4.0, ma=8.0, col_bounds=[4.,8.], alpha=np.logspace(-1,2,7), colormap='RdBu_r')\n",
+ "tfh2.tf.map_to_colormap(6.0, 8.0, colormap='Reds', scale=5.0)\n",
+ "tfh2.tf.map_to_colormap(-1.0, 6.0, colormap='Blues_r', scale=1.0)\n",
+ "\n",
+ "tfh2.plot(profile_field='cell_mass')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Note that the height of the red portion of the transfer function has increased by a factor of 5.0. If we use this transfer function to make the final image:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "source.set_transfer_function(tfh2.tf)\n",
+ "im3 = sc.render()\n",
+ "\n",
+ "showme(im3[:,:,:3])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The red gas is now much more prominant in the image. We can clearly see that the hot gas is mostly associated with bound structures while the cool gas is associated with low-density voids."
]
}
],
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