[yt-svn] commit/yt: 6 new changesets
commits-noreply at bitbucket.org
commits-noreply at bitbucket.org
Wed Jun 15 11:09:54 PDT 2016
6 new commits in yt:
https://bitbucket.org/yt_analysis/yt/commits/2c89ad39dd1c/
Changeset: 2c89ad39dd1c
Branch: yt
User: brittonsmith
Date: 2016-04-27 13:39:00+00:00
Summary: Add brute force method for finding particles contained within a collection of cells so we can query particle fields from clumps.
Affected #: 3 files
diff -r 77db965d0a537a9884d6db3c5ad7595dc3070ba0 -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 yt/analysis_modules/level_sets/clump_handling.py
--- a/yt/analysis_modules/level_sets/clump_handling.py
+++ b/yt/analysis_modules/level_sets/clump_handling.py
@@ -57,6 +57,9 @@
self.min_val = self.data[field].min()
self.max_val = self.data[field].max()
+ if parent is not None:
+ self.data.parent = self.parent.data
+
# List containing characteristics about clumps that are to be written
# out by the write routines.
if clump_info is None:
diff -r 77db965d0a537a9884d6db3c5ad7595dc3070ba0 -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 yt/data_objects/selection_data_containers.py
--- a/yt/data_objects/selection_data_containers.py
+++ b/yt/data_objects/selection_data_containers.py
@@ -24,12 +24,13 @@
iterable, \
validate_width_tuple, \
fix_length
+from yt.geometry.selection_routines import \
+ points_in_cells
from yt.units.yt_array import \
YTArray
from yt.utilities.exceptions import \
YTSphereTooSmall, \
YTIllDefinedCutRegion, \
- YTMixedCutRegion, \
YTEllipsoidOrdering
from yt.utilities.minimal_representation import \
MinimalSliceData
@@ -793,8 +794,10 @@
for field in fields:
f = self.base_object[field]
if f.shape != ind.shape:
- raise YTMixedCutRegion(self.conditionals, field)
- self.field_data[field] = self.base_object[field][ind]
+ parent = getattr(self, "parent", self.base_object)
+ self.field_data[field] = parent[field][self._part_ind]
+ else:
+ self.field_data[field] = self.base_object[field][ind]
@property
def blocks(self):
@@ -809,18 +812,35 @@
if not np.any(m): continue
yield obj, m
+ _cell_mask = None
@property
def _cond_ind(self):
- ind = None
- obj = self.base_object
- with obj._field_parameter_state(self.field_parameters):
- for cond in self.conditionals:
- res = eval(cond)
- if ind is None: ind = res
- if ind.shape != res.shape:
- raise YTIllDefinedCutRegion(self.conditionals)
- np.logical_and(res, ind, ind)
- return ind
+ if self._cell_mask is None:
+ ind = None
+ obj = self.base_object
+ with obj._field_parameter_state(self.field_parameters):
+ for cond in self.conditionals:
+ res = eval(cond)
+ if ind is None: ind = res
+ if ind.shape != res.shape:
+ raise YTIllDefinedCutRegion(self.conditionals)
+ np.logical_and(res, ind, ind)
+ self._cell_mask = ind
+ return self._cell_mask
+
+ _particle_mask = None
+ @property
+ def _part_ind(self):
+ if self._particle_mask is None:
+ parent = getattr(self, "parent", self.base_object)
+ mask = points_in_cells(
+ self["x"], self["y"], self["z"],
+ self["dx"], self["dy"], self["dz"],
+ parent["particle_position_x"].to("code_length"),
+ parent["particle_position_y"].to("code_length"),
+ parent["particle_position_z"].to("code_length"))
+ self._particle_mask = mask
+ return self._particle_mask
@property
def icoords(self):
diff -r 77db965d0a537a9884d6db3c5ad7595dc3070ba0 -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 yt/geometry/selection_routines.pyx
--- a/yt/geometry/selection_routines.pyx
+++ b/yt/geometry/selection_routines.pyx
@@ -2046,3 +2046,42 @@
return ("halo_particles", self.halo_id)
halo_particles_selector = HaloParticlesSelector
+
+ at cython.cdivision(True)
+ at cython.boundscheck(False)
+ at cython.wraparound(False)
+def points_in_cells(
+ np.float64_t[:] cx,
+ np.float64_t[:] cy,
+ np.float64_t[:] cz,
+ np.float64_t[:] dx,
+ np.float64_t[:] dy,
+ np.float64_t[:] dz,
+ np.float64_t[:] px,
+ np.float64_t[:] py,
+ np.float64_t[:] pz):
+ # Take a list of cells and particles and calculate which particles
+ # are enclosed within one of the cells. This is used for querying
+ # particle fields on clump/contour objects.
+ # We use brute force since the cells are a relatively unordered collection.
+
+ cdef int p, c, n_p, n_c
+
+ n_p = px.size
+ n_c = cx.size
+ mask = np.ones(n_p, dtype="bool")
+
+ for p in range(n_p):
+ for c in range(n_c):
+ if fabs(px[p] - cx[c]) > 0.5 * dx[c]:
+ mask[p] = False
+ continue
+ if fabs(py[p] - cy[c]) > 0.5 * dy[c]:
+ mask[p] = False
+ continue
+ if fabs(pz[p] - cz[c]) > 0.5 * dz[c]:
+ mask[p] = False
+ continue
+ if mask[p]: break
+
+ return mask
https://bitbucket.org/yt_analysis/yt/commits/aa006bf5e5f9/
Changeset: aa006bf5e5f9
Branch: yt
User: brittonsmith
Date: 2016-06-13 19:05:59+00:00
Summary: Merging.
Affected #: 168 files
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 .hgchurn
--- a/.hgchurn
+++ b/.hgchurn
@@ -1,6 +1,6 @@
stephenskory at yahoo.com = s at skory.us
"Stephen Skory stephenskory at yahoo.com" = s at skory.us
-yuan at astro.columbia.edu = bear0980 at gmail.com
+bear0980 at gmail.com = yuan at astro.columbia.edu
juxtaposicion at gmail.com = cemoody at ucsc.edu
chummels at gmail.com = chummels at astro.columbia.edu
jwise at astro.princeton.edu = jwise at physics.gatech.edu
@@ -19,7 +19,6 @@
sername=kayleanelson = kaylea.nelson at yale.edu
kayleanelson = kaylea.nelson at yale.edu
jcforbes at ucsc.edu = jforbes at ucolick.org
-ngoldbau at ucsc.edu = goldbaum at ucolick.org
biondo at wisc.edu = Biondo at wisc.edu
samgeen at googlemail.com = samgeen at gmail.com
fbogert = fbogert at ucsc.edu
@@ -39,4 +38,12 @@
jnaiman at ucolick.org = jnaiman
migueld.deval = miguel at archlinux.net
slevy at ncsa.illinois.edu = salevy at illinois.edu
-malzraa at gmail.com = kellerbw at mcmaster.ca
\ No newline at end of file
+malzraa at gmail.com = kellerbw at mcmaster.ca
+None = convert-repo
+dfenn = df11c at my.fsu.edu
+langmm = langmm.astro at gmail.com
+jmt354 = jmtomlinson95 at gmail.com
+desika = dnarayan at haverford.edu
+Ben Thompson = bthompson2090 at gmail.com
+goldbaum at ucolick.org = ngoldbau at illinois.edu
+ngoldbau at ucsc.edu = ngoldbau at illinois.edu
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 .hgignore
--- a/.hgignore
+++ b/.hgignore
@@ -45,9 +45,11 @@
yt/utilities/lib/mesh_intersection.cpp
yt/utilities/lib/mesh_samplers.cpp
yt/utilities/lib/mesh_traversal.cpp
+yt/utilities/lib/mesh_triangulation.c
yt/utilities/lib/mesh_utilities.c
yt/utilities/lib/misc_utilities.c
yt/utilities/lib/particle_mesh_operations.c
+yt/utilities/lib/primitives.c
yt/utilities/lib/origami.c
yt/utilities/lib/particle_mesh_operations.c
yt/utilities/lib/pixelization_routines.c
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 CONTRIBUTING.rst
--- a/CONTRIBUTING.rst
+++ b/CONTRIBUTING.rst
@@ -651,7 +651,7 @@
.. _multiple-PRs:
Working with Multiple BitBucket Pull Requests
-+++++++++++++++++++++++++++++++++++++++++++++
+---------------------------------------------
Once you become active developing for yt, you may be working on
various aspects of the code or bugfixes at the same time. Currently,
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 CREDITS
--- a/CREDITS
+++ b/CREDITS
@@ -10,6 +10,7 @@
Alex Bogert (fbogert at ucsc.edu)
André-Patrick Bubel (code at andre-bubel.de)
Pengfei Chen (madcpf at gmail.com)
+ Yi-Hao Chen (yihaochentw at gmail.com)
David Collins (dcollins4096 at gmail.com)
Brian Crosby (crosby.bd at gmail.com)
Andrew Cunningham (ajcunn at gmail.com)
@@ -25,10 +26,12 @@
William Gray (graywilliamj at gmail.com)
Markus Haider (markus.haider at uibk.ac.at)
Eric Hallman (hallman13 at gmail.com)
+ David Hannasch (David.A.Hannasch at gmail.com)
Cameron Hummels (chummels at gmail.com)
Anni Järvenpää (anni.jarvenpaa at gmail.com)
Allyson Julian (astrohckr at gmail.com)
Christian Karch (chiffre at posteo.de)
+ Maximilian Katz (maximilian.katz at stonybrook.edu)
Ben W. Keller (kellerbw at mcmaster.ca)
Ji-hoon Kim (me at jihoonkim.org)
Steffen Klemer (sklemer at phys.uni-goettingen.de)
@@ -60,6 +63,7 @@
Anna Rosen (rosen at ucolick.org)
Chuck Rozhon (rozhon2 at illinois.edu)
Douglas Rudd (drudd at uchicago.edu)
+ Hsi-Yu Schive (hyschive at gmail.com)
Anthony Scopatz (scopatz at gmail.com)
Noel Scudder (noel.scudder at stonybrook.edu)
Pat Shriwise (shriwise at wisc.edu)
@@ -75,6 +79,7 @@
Elizabeth Tasker (tasker at astro1.sci.hokudai.ac.jp)
Benjamin Thompson (bthompson2090 at gmail.com)
Robert Thompson (rthompsonj at gmail.com)
+ Joseph Tomlinson (jmtomlinson95 at gmail.com)
Stephanie Tonnesen (stonnes at gmail.com)
Matthew Turk (matthewturk at gmail.com)
Rich Wagner (rwagner at physics.ucsd.edu)
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 appveyor.yml
--- /dev/null
+++ b/appveyor.yml
@@ -0,0 +1,38 @@
+# AppVeyor.com is a Continuous Integration service to build and run tests under
+# Windows
+
+environment:
+
+ global:
+ PYTHON: "C:\\Miniconda-x64"
+
+ matrix:
+
+ - PYTHON_VERSION: "2.7"
+
+ - PYTHON_VERSION: "3.5"
+
+
+platform:
+ -x64
+
+install:
+ - "SET PATH=%PYTHON%;%PYTHON%\\Scripts;%PATH%"
+
+ # Install the build and runtime dependencies of the project.
+ # Create a conda environment
+ - "conda create -q --yes -n test python=%PYTHON_VERSION%"
+ - "activate test"
+
+ # Check that we have the expected version of Python
+ - "python --version"
+
+ # Install specified version of numpy and dependencies
+ - "conda install -q --yes numpy nose setuptools ipython Cython sympy h5py matplotlib"
+ - "python setup.py develop"
+
+# Not a .NET project
+build: false
+
+test_script:
+ - "nosetests -e test_all_fields ."
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 doc/source/analyzing/analysis_modules/photon_simulator.rst
--- a/doc/source/analyzing/analysis_modules/photon_simulator.rst
+++ b/doc/source/analyzing/analysis_modules/photon_simulator.rst
@@ -478,7 +478,8 @@
import yt
import numpy as np
- from yt.utilities.physical_constants import cm_per_kpc, K_per_keV, mp
+ from yt.utilities.physical_ratios import cm_per_kpc, K_per_keV
+ from yt.units import mp
from yt.utilities.cosmology import Cosmology
from yt.analysis_modules.photon_simulator.api import *
import aplpy
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 doc/source/analyzing/analysis_modules/xray_emission_fields.rst
--- a/doc/source/analyzing/analysis_modules/xray_emission_fields.rst
+++ b/doc/source/analyzing/analysis_modules/xray_emission_fields.rst
@@ -32,7 +32,7 @@
from yt.analysis_modules.spectral_integrator.api import \
add_xray_emissivity_field
- xray_fields = add_xray_emissivity_field(0.5, 7.0)
+ xray_fields = add_xray_emissivity_field(ds, 0.5, 7.0)
Additional keyword arguments are:
@@ -49,7 +49,8 @@
* **constant_metallicity** (*float*): If specified, assume a constant
metallicity for the emission from metals. The *with_metals* keyword
- must be set to False to use this. Default: None.
+ must be set to False to use this. It should be given in unit of solar metallicity.
+ Default: None.
The resulting fields can be used like all normal fields. The function will return the names of
the created fields in a Python list.
@@ -60,7 +61,7 @@
from yt.analysis_modules.spectral_integrator.api import \
add_xray_emissivity_field
- xray_fields = add_xray_emissivity_field(0.5, 7.0, filename="apec_emissivity.h5")
+ xray_fields = add_xray_emissivity_field(ds, 0.5, 7.0, filename="apec_emissivity.h5")
ds = yt.load("enzo_tiny_cosmology/DD0046/DD0046")
plot = yt.SlicePlot(ds, 'x', 'xray_luminosity_0.5_7.0_keV')
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 doc/source/analyzing/fields.rst
--- a/doc/source/analyzing/fields.rst
+++ b/doc/source/analyzing/fields.rst
@@ -14,14 +14,126 @@
out of favor, as these discrete fields can be any type of sparsely populated
data.
+What are fields?
+----------------
+
+Fields in yt are denoted by a two-element tuple, of the form ``(field_type,
+field_name)``. The first element, the "field type" is a category for a
+field. Possible field types used in yt include *gas* (for fluid mesh fields
+defined on a mesh) or *io* (for fields defined at particle locations). Field
+types can also correspond to distinct particle of fluid types in a single
+simulation. For example, a plasma physics simulation using the Particle in Cell
+method might have particle types corresponding to *electrons* and *ions*. See
+:ref:`known-field-types` below for more info about field types in yt.
+
+The second element of field tuples, the "field name", denotes the specific field
+to select, given the field type. Possible field names include *density*,
+*velocity_x* or *pressure* --- these three fields are examples of field names
+that might be used for a fluid defined on a mesh. Examples of particle fields
+include *particle_mass*, *particle_position*, or *particle_velocity_x*. In
+general, particle field names are prefixed by "particle\_", which makes it easy
+to distinguish between a particle field or a mesh field when no field type is
+provided.
+
+What fields are available?
+--------------------------
+
+We provide a full list of fields that yt recognizes by default at
+:ref:`field-list`. If you want to create additional custom derived fields,
+see :ref:`creating-derived-fields`.
+
+Every dataset has an attribute, ``ds.fields``. This attribute possesses
+attributes itself, each of which is a "field type," and each field type has as
+its attributes the fields themselves. When one of these is printed, it returns
+information about the field and things like units and so on. You can use this
+for tab-completing as well as easier access to information.
+
+As an example, you might browse the available fields like so:
+
+.. code-block:: python
+
+ print(dir(ds.fields))
+ print(dir(ds.fields.gas))
+ print(ds.fields.gas.density)
+
+On an Enzo dataset, the result from the final command would look something like
+this:::
+
+ Alias Field for "('enzo', 'Density')" (gas, density): (units: g/cm**3)
+
+You can use this to easily explore available fields, particularly through
+tab-completion in Jupyter/IPython.
+
+For a more programmatic method of accessing fields, you can utilize the
+``ds.field_list``, ``ds.derived_field_list`` and some accessor methods to gain
+information about fields. The full list of fields available for a dataset can
+be found as the attribute ``field_list`` for native, on-disk fields and
+``derived_field_list`` for derived fields (``derived_field_list`` is a superset
+of ``field_list``). You can view these lists by examining a dataset like this:
+
+.. code-block:: python
+
+ ds = yt.load("my_data")
+ print(ds.field_list)
+ print(ds.derived_field_list)
+
+By using the ``field_info()`` class, one can access information about a given
+field, like its default units or the source code for it.
+
+.. code-block:: python
+
+ ds = yt.load("my_data")
+ ds.index
+ print(ds.field_info["gas", "pressure"].get_units())
+ print(ds.field_info["gas", "pressure"].get_source())
+
+Using fields to access data
+---------------------------
+
+The primary *use* of fields in yt is to access data from a dataset. For example,
+if I want to use a data object (see :ref:`Data-objects` for more detail about
+data objects) to access the ``('gas', 'density')`` field, one can do any of the
+following:
+
+.. code-block:: python
+
+ ad = ds.all_data()
+
+ # just a field name
+ density = ad['density']
+
+ # field tuple with no parentheses
+ density = ad['gas', 'density']
+
+ # full field tuple
+ density = ad[('gas', 'density')]
+
+ # through the ds.fields object
+ density = ad[ds.fields.gas.density]
+
+The first data access example is the simplest. In that example, the field type
+is inferred from the name of the field. The next two examples use the field type
+explicitly, this might be necessary if there is more than one field type with a
+"density" field defined in the same dataset. The third example is slightly more
+verbose but is syntactically identical to the second example due to the way
+indexing works in the Python language.
+
+The final example uses the ``ds.fields`` object described above. This way of
+accessing fields lends itself to interactive use, especially if you make heavy
+use of IPython's tab completion features. Any of these ways of denoting the
+``('gas', 'density')`` field can be used when supplying a field name to a yt
+data object, analysis routines, or plotting and visualization function.
+
+Accessing Fields without a Field Type
+-------------------------------------
+
In previous versions of yt, there was a single mechanism of accessing fields on
-a data container -- by their name, which was mandated to be a single string,
-and which often varied between different code frontends. yt 3.0 allows
-for datasets containing multiple different types of fluid fields, mesh fields,
-particles (with overlapping or disjoint lists of fields). To enable accessing
-these fields in a meaningful, simple way, the mechanism for accessing them has
-changed to take an optional *field type* in addition to the *field name* of
-the form ('*field type*', '*field name*').
+a data container -- by their name, which was mandated to be a single string, and
+which often varied between different code frontends. yt 3.0 allows for datasets
+containing multiple different types of fluid fields, mesh fields, particles
+(with overlapping or disjoint lists of fields). However, to preserve backward
+compatibility and make interactive use simpler, yt will still accept field names
+given as a string and will try to infer the field type given a field name.
As an example, we may be in a situation where have multiple types of particles
which possess the ``particle_position`` field. In the case where a data
@@ -30,9 +142,9 @@
.. code-block:: python
- print(ad["humans", "particle_position"])
- print(ad["dogs", "particle_position"])
- print(ad["dinosaurs", "particle_position"])
+ print(ad["dark_matter", "particle_position"])
+ print(ad["stars", "particle_position"])
+ print(ad["black_holes", "particle_position"])
Each of these three fields may have different sizes. In order to enable
falling back on asking only for a field by the name, yt will use the most
@@ -45,7 +157,8 @@
print(ad["particle_velocity"])
-it would select ``dinosaurs`` as the field type.
+it would select ``black_holes`` as the field type, since the last field accessed
+used that field type.
The same operations work for fluid and mesh fields. As an example, in some
cosmology simulations, we may want to examine the mass of particles in a region
@@ -189,58 +302,6 @@
* Species fields, such as for chemistry species (yt can recognize the entire
periodic table in field names and construct ionization fields as need be)
-What fields are available?
---------------------------
-
-We provide a full list of fields that yt recognizes by default at
-:ref:`field-list`. If you want to create additional custom derived fields,
-see :ref:`creating-derived-fields`.
-
-Every dataset has an attribute, ``ds.fields``. This attribute possesses
-attributes itself, each of which is a "field type," and each field type has as
-its attributes the fields themselves. When one of these is printed, it returns
-information about the field and things like units and so on. You can use this
-for tab-completing as well as easier access to information.
-
-As an example, you might browse the available fields like so:
-
-.. code-block:: python
-
- print(dir(ds.fields))
- print(dir(ds.fields.gas))
- print(ds.fields.gas.density)
-
-On an Enzo dataset, the result from the final command would look something like
-this:::
-
- Alias Field for "('enzo', 'Density')" (gas, density): (units: g/cm**3)
-
-You can use this to easily explore available fields, particularly through
-tab-completion in Jupyter/IPython.
-
-For a more programmatic method of accessing fields, you can utilize the
-``ds.field_list``, ``ds.derived_field_list`` and some accessor methods to gain
-information about fields. The full list of fields available for a dataset can
-be found as the attribute ``field_list`` for native, on-disk fields and
-``derived_field_list`` for derived fields (``derived_field_list`` is a superset
-of ``field_list``). You can view these lists by examining a dataset like this:
-
-.. code-block:: python
-
- ds = yt.load("my_data")
- print(ds.field_list)
- print(ds.derived_field_list)
-
-By using the ``field_info()`` class, one can access information about a given
-field, like its default units or the source code for it.
-
-.. code-block:: python
-
- ds = yt.load("my_data")
- ds.index
- print(ds.field_info["gas", "pressure"].get_units())
- print(ds.field_info["gas", "pressure"].get_source())
-
.. _bfields:
Magnetic Fields
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 doc/source/analyzing/units/1)_Symbolic_Units.ipynb
--- a/doc/source/analyzing/units/1)_Symbolic_Units.ipynb
+++ b/doc/source/analyzing/units/1)_Symbolic_Units.ipynb
@@ -155,7 +155,7 @@
"outputs": [],
"source": [
"from yt.units.yt_array import YTQuantity\n",
- "from yt.utilities.physical_constants import kboltz\n",
+ "from yt.units import kboltz\n",
"from numpy.random import random\n",
"import numpy as np\n",
"\n",
@@ -446,7 +446,7 @@
},
"outputs": [],
"source": [
- "from yt.utilities.physical_constants import G, kboltz\n",
+ "from yt.units import G, kboltz\n",
"\n",
"print (\"Newton's constant: \", G)\n",
"print (\"Newton's constant in MKS: \", G.in_mks(), \"\\n\")\n",
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 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
@@ -467,7 +467,7 @@
"metadata": {},
"outputs": [],
"source": [
- "from yt.utilities.physical_constants import kboltz\n",
+ "from yt.units import kboltz\n",
"kb = kboltz.to_astropy()"
]
},
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 doc/source/analyzing/units/6)_Unit_Equivalencies.ipynb
--- a/doc/source/analyzing/units/6)_Unit_Equivalencies.ipynb
+++ b/doc/source/analyzing/units/6)_Unit_Equivalencies.ipynb
@@ -41,7 +41,7 @@
"print (dd[\"temperature\"].to_equivalent(\"eV\", \"thermal\"))\n",
"\n",
"# Rest energy of the proton\n",
- "from yt.utilities.physical_constants import mp\n",
+ "from yt.units import mp\n",
"E_p = mp.to_equivalent(\"GeV\", \"mass_energy\")\n",
"print (E_p)"
]
@@ -61,7 +61,7 @@
},
"outputs": [],
"source": [
- "from yt.utilities.physical_constants import clight\n",
+ "from yt.units import clight\n",
"v = 0.1*clight\n",
"g = v.to_equivalent(\"dimensionless\", \"lorentz\")\n",
"print (g)\n",
@@ -166,7 +166,7 @@
},
"outputs": [],
"source": [
- "from yt.utilities.physical_constants import qp # the elementary charge in esu\n",
+ "from yt.units import qp # the elementary charge in esu\n",
"qp_SI = qp.to_equivalent(\"C\",\"SI\") # convert to Coulombs\n",
"print (qp)\n",
"print (qp_SI)"
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 doc/source/analyzing/units/7)_Unit_Systems.ipynb
--- a/doc/source/analyzing/units/7)_Unit_Systems.ipynb
+++ b/doc/source/analyzing/units/7)_Unit_Systems.ipynb
@@ -324,7 +324,7 @@
},
"outputs": [],
"source": [
- "from yt.utilities.physical_constants import G\n",
+ "from yt.units import G\n",
"print (G.in_base(\"mks\"))"
]
},
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 doc/source/cookbook/single_dataset_light_ray.py
--- a/doc/source/cookbook/single_dataset_light_ray.py
+++ b/doc/source/cookbook/single_dataset_light_ray.py
@@ -3,8 +3,8 @@
from yt.analysis_modules.cosmological_observation.api import \
LightRay
-fn = "IsolatedGalaxy/galaxy0030/galaxy0030"
-lr = LightRay(fn)
+ds = yt.load("IsolatedGalaxy/galaxy0030/galaxy0030")
+lr = LightRay(ds)
# With a single dataset, a start_position and
# end_position or trajectory must be given.
@@ -17,7 +17,6 @@
# Optionally, we can now overplot this ray on a projection of the source
# dataset
-ds = yt.load(fn)
p = yt.ProjectionPlot(ds, 'z', 'density')
p.annotate_ray(lr)
p.save()
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 doc/source/cookbook/tests/test_cookbook.py
--- a/doc/source/cookbook/tests/test_cookbook.py
+++ b/doc/source/cookbook/tests/test_cookbook.py
@@ -15,6 +15,26 @@
import subprocess
+def run_with_capture(*args, **kwargs):
+ sp = subprocess.Popen(*args,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ **kwargs)
+ out, err = sp.communicate()
+ if out:
+ sys.stdout.write(out.decode("UTF-8"))
+ if err:
+ sys.stderr.write(err.decode("UTF-8"))
+
+ if sp.returncode != 0:
+ retstderr = " ".join(args[0])
+ retstderr += "\n\nTHIS IS THE REAL CAUSE OF THE FAILURE:\n"
+ retstderr += err.decode("UTF-8") + "\n"
+ raise subprocess.CalledProcessError(sp.returncode, retstderr)
+
+ return sp.returncode
+
+
PARALLEL_TEST = {"rockstar_nest.py": "3"}
BLACKLIST = ["opengl_ipython.py", "opengl_vr.py"]
@@ -37,10 +57,16 @@
def check_recipe(cmd):
'''Run single recipe'''
- try:
- subprocess.check_call(cmd)
- result = True
- except subprocess.CalledProcessError as e:
- print(("Stdout output:\n", e.output))
- result = False
- assert result
+ proc = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE)
+ out, err = proc.communicate()
+ if out:
+ sys.stdout.write(out.decode("utf8"))
+ if err:
+ sys.stderr.write(err.decode("utf8"))
+
+ if proc.returncode != 0:
+ retstderr = " ".join(cmd)
+ retstderr += "\n\nTHIS IS THE REAL CAUSE OF THE FAILURE:\n"
+ retstderr += err.decode("UTF-8") + "\n"
+ raise subprocess.CalledProcessError(proc.returncode, retstderr)
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 doc/source/cookbook/various_lens.py
--- a/doc/source/cookbook/various_lens.py
+++ b/doc/source/cookbook/various_lens.py
@@ -85,6 +85,7 @@
cam = sc.add_camera(ds, lens_type='spherical')
# Set the size ratio of the final projection to be 2:1, since spherical lens
# will generate the final image with length of 2*pi and height of pi.
+# Recommended resolution for YouTube 360-degree videos is [3840, 2160]
cam.resolution = [500, 250]
# Standing at (x=0.4, y=0.5, z=0.5), we look in all the radial directions
# from this point in spherical coordinate.
@@ -99,9 +100,11 @@
# Stereo-spherical lens
cam = sc.add_camera(ds, lens_type='stereo-spherical')
-# Set the size ratio of the final projection to be 4:1, since spherical-perspective lens
-# will generate the final image with both left-eye and right-eye ones jointed together.
-cam.resolution = [1000, 250]
+# Set the size ratio of the final projection to be 1:1, since spherical-perspective lens
+# will generate the final image with both left-eye and right-eye ones jointed together,
+# with left-eye image on top and right-eye image on bottom.
+# Recommended resolution for YouTube virtual reality videos is [3840, 2160]
+cam.resolution = [500, 500]
cam.position = ds.arr([0.4, 0.5, 0.5], 'code_length')
cam.switch_orientation(normal_vector=normal_vector,
north_vector=north_vector)
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 doc/source/developing/creating_derived_fields.rst
--- a/doc/source/developing/creating_derived_fields.rst
+++ b/doc/source/developing/creating_derived_fields.rst
@@ -71,9 +71,9 @@
a dimensionless float or array.
If your field definition includes physical constants rather than defining a
-constant as a float, you can import it from ``yt.utilities.physical_constants``
+constant as a float, you can import it from ``yt.units``
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
+the units your data is supposed to have ahead of time, you can also import unit
symbols like ``g`` or ``cm`` from the ``yt.units`` namespace and multiply the
return value of your field function by the appropriate combination of unit
symbols for your field's units. You can also convert floats or NumPy arrays into
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 doc/source/developing/creating_frontend.rst
--- a/doc/source/developing/creating_frontend.rst
+++ b/doc/source/developing/creating_frontend.rst
@@ -34,7 +34,8 @@
`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. Copying the contents of the ``yt/frontends/_skeleton``
+of your code and add the name into ``yt/frontends/api.py``.
+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
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 doc/source/developing/testing.rst
--- a/doc/source/developing/testing.rst
+++ b/doc/source/developing/testing.rst
@@ -95,17 +95,17 @@
To create new unit tests:
#. Create a new ``tests/`` directory next to the file containing the
- functionality you want to test. Be sure to add this new directory as a
- subpackage in the setup.py script located in the directory you're adding a
- new ``tests/`` folder to. This ensures that the tests will be deployed in
- yt source and binary distributions.
+ functionality you want to test and add an empty ``__init__.py`` file to
+ it.
#. Inside that directory, create a new python file prefixed with ``test_`` and
including the name of the functionality.
#. Inside that file, create one or more routines prefixed with ``test_`` that
- accept no arguments. These should ``yield`` a tuple of the form
- ``function``, ``argument_one``, ``argument_two``, etc. For example
- ``yield assert_equal, 1.0, 1.0`` would be captured by nose as a test that
- asserts that 1.0 is equal to 1.0.
+ accept no arguments. The test function should do some work that tests some
+ functionality and should also verify that the results are correct using
+ assert statements or functions.
+# Tests can ``yield`` a tuple of the form ``function``, ``argument_one``,
+ ``argument_two``, etc. For example ``yield assert_equal, 1.0, 1.0`` would be
+ captured by nose as a test that asserts that 1.0 is equal to 1.0.
#. Use ``fake_random_ds`` to test on datasets, and be sure to test for
several combinations of ``nproc``, so that domain decomposition can be
tested as well.
@@ -245,6 +245,12 @@
* ``IsothermalCollapse/snap_505.hdf5``
* ``GadgetDiskGalaxy/snapshot_200.hdf5``
+GAMER
+~~~~~~
+
+* ``InteractingJets/jet_000002``
+* ``WaveDarkMatter/psiDM_000020``
+
Halo Catalog
~~~~~~~~~~~~
@@ -464,9 +470,9 @@
test.prefix = "my_unique_name"
# this ensures a nice test name in nose's output
- test_my_ds.__description__ = test.description
+ test_my_ds.__name__ = test.description
- yield test_my_ds
+ yield test
Another good example of an image comparison test is the
``PlotWindowAttributeTest`` defined in the answer testing framework and used in
@@ -532,7 +538,13 @@
local_pw_000:
-would regenerate answers for OWLS frontend.
+would regenerate answers for OWLS frontend.
+
+When adding tests to an existing set of answers (like ``local_owls_000`` or ``local_varia_000``),
+it is considered best practice to first submit a pull request adding the tests WITHOUT incrementing
+the version number. Then, allow the tests to run (resulting in "no old answer" errors for the missing
+answers). If no other failures are present, you can then increment the version number to regenerate
+the answers. This way, we can avoid accidently covering up test breakages.
Adding New Answer Tests
~~~~~~~~~~~~~~~~~~~~~~~
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 doc/source/examining/loading_data.rst
--- a/doc/source/examining/loading_data.rst
+++ b/doc/source/examining/loading_data.rst
@@ -775,32 +775,38 @@
----------
FLASH HDF5 data is *mostly* supported and cared for by John ZuHone. To load a
-FLASH dataset, you can use the ``yt.load`` command and provide it the file name of a plot file or checkpoint file, but particle
-files are not currently directly loadable by themselves, due to the fact that
-they typically lack grid information. For instance, if you were in a directory
-with the following files:
+FLASH dataset, you can use the ``yt.load`` command and provide it the file name of
+a plot file, checkpoint file, or particle file. Particle files require special handling
+depending on the situation, the main issue being that they typically lack grid information.
+The first case is when you have a plotfile and a particle file that you would like to
+load together. In the simplest case, this occurs automatically. For instance, if you
+were in a directory with the following files:
.. code-block:: none
- cosmoSim_coolhdf5_chk_0026
+ radio_halo_1kpc_hdf5_plt_cnt_0100 # plotfile
+ radio_halo_1kpc_hdf5_part_0100 # particle file
-You would feed it the filename ``cosmoSim_coolhdf5_chk_0026``:
+where the plotfile and the particle file were created at the same time (therefore having
+particle data consistent with the grid structure of the former). Notice also that the
+prefix ``"radio_halo_1kpc_"`` and the file number ``100`` are the same. In this special case,
+the particle file will be loaded automatically when ``yt.load`` is called on the plotfile.
+This also works when loading a number of files in a time series.
-.. code-block:: python
-
- import yt
- ds = yt.load("cosmoSim_coolhdf5_chk_0026")
-
-If you have a FLASH particle file that was created at the same time as
-a plotfile or checkpoint file (therefore having particle data
-consistent with the grid structure of the latter), its data may be loaded with the
-``particle_filename`` optional argument:
+If the two files do not have the same prefix and number, but they nevertheless have the same
+grid structure and are at the same simulation time, the particle data may be loaded with the
+``particle_filename`` optional argument to ``yt.load``:
.. code-block:: python
import yt
ds = yt.load("radio_halo_1kpc_hdf5_plt_cnt_0100", particle_filename="radio_halo_1kpc_hdf5_part_0100")
+However, if you don't have a corresponding plotfile for a particle file, but would still
+like to load the particle data, you can still call ``yt.load`` on the file. However, the
+grid information will not be available, and the particle data will be loaded in a fashion
+similar to SPH data.
+
.. rubric:: Caveats
* Please be careful that the units are correctly utilized; yt assumes cgs by default, but conversion to
@@ -1021,6 +1027,34 @@
yt will utilize length, mass and time to set up all other units.
+GAMER Data
+----------
+
+GAMER HDF5 data is supported and cared for by Hsi-Yu Schive. You can load the data like this:
+
+.. code-block:: python
+
+ import yt
+ ds = yt.load("InteractingJets/jet_000002")
+
+Currently GAMER does not assume any unit for non-cosmological simulations. To specify the units for yt,
+you need to supply conversions for length, time, and mass to ``load`` using the ``units_override`` functionality:
+
+.. code-block:: python
+
+ import yt
+ code_units = { "length_unit":(1.0,"kpc"),
+ "time_unit" :(3.08567758096e+13,"s"),
+ "mass_unit" :(1.4690033e+36,"g") }
+ ds = yt.load("InteractingJets/jet_000002", units_override=code_units)
+
+This means that the yt fields, e.g., ``("gas","density")``, will be in cgs units, but the GAMER fields,
+e.g., ``("gamer","Dens")``, will be in code units.
+
+.. rubric:: Caveats
+
+* GAMER data in raw binary format (i.e., OPT__OUTPUT_TOTAL = C-binary) is not supported.
+
.. _loading-amr-data:
Generic AMR Data
@@ -1285,6 +1319,29 @@
``bbox``
The bounding box for the particle positions.
+.. _loading-gizmo-data:
+
+Gizmo Data
+----------
+
+Gizmo datasets, including FIRE outputs, can be loaded into yt in the usual
+manner. Like other SPH data formats, yt loads Gizmo data as particle fields
+and then uses smoothing kernels to deposit those fields to an underlying
+grid structure as spatial fields as described in :ref:`loading-gadget-data`.
+To load Gizmo datasets using the standard HDF5 output format::
+
+ import yt
+ ds = yt.load("snapshot_600.hdf5")
+
+Because the Gizmo output format is similar to the Gadget format, yt
+may load Gizmo datasets as Gadget depending on the circumstances, but this
+should not pose a problem in most situations. FIRE outputs will be loaded
+accordingly due to the number of metallicity fields found (11 or 17).
+
+For Gizmo outputs written as raw binary outputs, you may have to specify
+a bounding box, field specification, and units as are done for standard
+Gadget outputs. See :ref:`loading-gadget-data` for more information.
+
.. _loading-pyne-data:
Halo Catalog Data
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 doc/source/examining/low_level_inspection.rst
--- a/doc/source/examining/low_level_inspection.rst
+++ b/doc/source/examining/low_level_inspection.rst
@@ -232,3 +232,28 @@
whatever interface they wish for displaying and saving their image data.
You can use the :class:`~yt.visualization.fixed_resolution.FixedResolutionBuffer`
to accomplish this as described in :ref:`fixed-resolution-buffers`.
+
+High-level Information about Particles
+--------------------------------------
+
+There are a number of high-level helpers attached to ``Dataset`` objects to find
+out information about the particles in an output file. First, one can check if
+there are any particles in a dataset at all by examining
+``ds.particles_exist``. This will be ``True`` for datasets the include particles
+and ``False`` otherwise.
+
+One can also see which particle types are available in a dataset. Particle types
+that are available in the dataset's on-disk output are known as "raw" particle
+types, and they will appear in ``ds.particle_types_raw``. Particle types that
+are dynamically defined via a particle filter of a particle union will also
+appear in the ``ds.particle_types`` list. If the simulation only has one
+particle type on-disk, its name will by ``'io'``. If there is more than one
+particle type, the names of the particle types will be inferred from the output
+file. For example, Gadget HDF5 files have particle type names like ``PartType0``
+and ``PartType1``, while Enzo data, which usually only has one particle type,
+will only have a particle named ``io``.
+
+Finally, one can see the number of each particle type by inspecting
+``ds.particle_type_counts``. This will be a dictionary mappying the names of
+particle types in ``ds.particle_types_raw`` to the number of each particle type
+in a simulation output.
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 doc/source/installing.rst
--- a/doc/source/installing.rst
+++ b/doc/source/installing.rst
@@ -18,26 +18,27 @@
* If you do not have root access on your computer, are not comfortable managing
python packages, or are working on a supercomputer or cluster computer, you
- will probably want to use the bash all-in-one installation script. This builds
- Python, NumPy, Matplotlib, and yt from source to set up an isolated scientific
- python environment inside of a single folder in your home directory. See
- :ref:`install-script` for more details.
+ will probably want to use the bash all-in-one installation script. This
+ creates a python environment using the `miniconda python
+ distrubtion <http://conda.pydata.org/miniconda.html>`_ and the
+ `conda <http://conda.pydata.org/docs/>`_ package manager inside of a single
+ folder in your home directory. See :ref:`install-script` for more details.
* If you use the `Anaconda <https://store.continuum.io/cshop/anaconda/>`_ python
- distribution see :ref:`anaconda-installation` for details on how to install
- yt using the ``conda`` package manager. Source-based installation from the
- mercurial repository or via ``pip`` should also work under Anaconda. Note that
- this is currently the only supported installation mechanism on Windows.
+ distribution and already have ``conda`` installed, see
+ :ref:`anaconda-installation` for details on how to install yt using the
+ ``conda`` package manager. Note that this is currently the only supported
+ installation mechanism on Windows.
-* If you already have a scientific python software stack installed on your
- computer and are comfortable installing python packages,
+* If you want to build a development version of yt or are comfortable with
+ compilers and know your way around python packaging,
:ref:`source-installation` will probably be the best choice. If you have set
up python using a source-based package manager like `Homebrew
<http://brew.sh>`_ or `MacPorts <http://www.macports.org/>`_ this choice will
- let you install yt using the python installed by the package manager. Similarly
- for python environments set up via Linux package managers so long as you
- have the necessary compilers installed (e.g. the ``build-essentials``
- package on Debian and Ubuntu).
+ let you install yt using the python installed by the package
+ manager. Similarly, this will also work for python environments set up via
+ Linux package managers so long as you have the necessary compilers installed
+ (e.g. the ``build-essentials`` package on Debian and Ubuntu).
.. note::
See `Parallel Computation
@@ -53,19 +54,21 @@
Before you install yt, you must decide which branch (i.e. version) of the code
you prefer to use:
-* ``yt`` -- The most up-to-date *development* version with the most current features but sometimes unstable (yt-3.x)
-* ``stable`` -- The latest stable release of yt-3.x
-* ``yt-2.x`` -- The latest stable release of yt-2.x
+* ``yt`` -- The most up-to-date *development* version with the most current
+ features but sometimes unstable (the development version of the next ``yt-3.x``
+ release).
+* ``stable`` -- The latest stable release of ``yt-3.x``.
+* ``yt-2.x`` -- The last stable release of ``yt-2.x``.
-If this is your first time using the code, we recommend using ``stable``,
-unless you specifically need some piece of brand-new functionality only
-available in ``yt`` or need to run an old script developed for ``yt-2.x``.
-There were major API and functionality changes made in yt after version 2.7
-in moving to version 3.0. For a detailed description of the changes
-between versions 2.x (e.g. branch ``yt-2.x``) and 3.x (e.g. branches ``yt`` and
-``stable``) see :ref:`yt3differences`. Lastly, don't feel like you're locked
-into one branch when you install yt, because you can easily change the active
-branch by following the instructions in :ref:`switching-between-yt-versions`.
+If this is your first time using the code, we recommend using ``stable``, unless
+you specifically need some piece of brand-new functionality only available in
+``yt`` or need to run an old script developed for ``yt-2.x``. There were major
+API and functionality changes made in yt for version 3.0. For a detailed
+description of the changes between versions 2.x (e.g. branch ``yt-2.x``) and 3.x
+(e.g. branches ``yt`` and ``stable``) see :ref:`yt3differences`. Lastly, don't
+feel like you're locked into one branch when you install yt, because you can
+easily change the active branch by following the instructions in
+:ref:`switching-between-yt-versions`.
.. _install-script:
@@ -74,9 +77,8 @@
Because installation of all of the interlocking parts necessary to install yt
itself can be time-consuming, yt provides an all-in-one installation script
-which downloads and builds a fully-isolated Python + NumPy + Matplotlib + HDF5 +
-Mercurial installation. Since the install script compiles yt's dependencies from
-source, you must have C, C++, and optionally Fortran compilers installed.
+which downloads and builds a fully-isolated installation of Python that includes
+NumPy, Matplotlib, H5py, Mercurial, and yt.
The install script supports UNIX-like systems, including Linux, OS X, and most
supercomputer and cluster environments. It is particularly suited for deployment
@@ -94,30 +96,62 @@
^^^^^^^^^^^^^^^^^^^^^^^^^^
To get the installation script for the ``stable`` branch of the code,
-download it from:
+download it using the following command:
.. code-block:: bash
- wget http://bitbucket.org/yt_analysis/yt/raw/stable/doc/install_script.sh
+ $ wget http://bitbucket.org/yt_analysis/yt/raw/stable/doc/install_script.sh
-If you wish to install a different version of yt (see
-:ref:`above <branches-of-yt>`), replace ``stable`` with the appropriate
-branch name (e.g. ``yt``, ``yt-2.x``) in the path above to get the correct
-install script.
-
-By default, the bash install script will install an array of items, but there
-are additional packages that can be downloaded and installed (e.g. SciPy, enzo,
-etc.). The script has all of these options at the top of the file. You should be
-able to open it and edit it without any knowledge of bash syntax. To execute
-it, run:
+If you do not have ``wget``, the following should also work:
.. code-block:: bash
- bash install_script.sh
+ $ curl -OL http://bitbucket.org/yt_analysis/yt/raw/stable/doc/install_script.sh
+
+If you wish to install a different version of yt (see :ref:`branches-of-yt`),
+replace ``stable`` with the appropriate branch name (e.g. ``yt``, ``yt-2.x``) in
+the path above to get the correct install script.
+
+By default, the bash install script will create a python environment based on
+the `miniconda python distrubtion <http://conda.pydata.org/miniconda.html>`_,
+and will install yt's dependencies using the `conda
+<http://conda.pydata.org/docs/>`_ package manager. To avoid needing a
+compilation environment to run the install script, yt itself will also be
+installed using `conda`.
+
+If you would like to customize your yt installation, you can edit the values of
+several variables that are defined at the top of the script.
+
+If you would like to build yt from source, you will need to edit the install
+script and set ``INST_YT_SOURCE=1`` near the top. This will clone a copy of the
+yt mercurial repository and build yt form source. The default is
+``INST_YT_SOURCE=0``, which installs yt from a binary conda package.
+
+The install script can also build python and all yt dependencies from source. To
+switch to this mode, set ``INST_CONDA=0`` at the top of the install script. If
+you choose this mode, you must also set ``INST_YT_SOURCE=1``.
+
+In addition, you can tell the install script to download and install some
+additional packages --- currently these include
+`PyX <http://pyx.sourceforge.net/>`_, the `Rockstar halo
+finder <http://arxiv.org/abs/1110.4372>`_, `SciPy <https://www.scipy.org/>`_,
+`Astropy <http://www.astropy.org/>`_, and the necessary dependencies for
+:ref:`unstructured mesh rendering <unstructured_mesh_rendering>`. The script has
+all of the options for installing optional packages near the top of the
+file. You should be able to open it and edit it without any knowledge of bash
+syntax. For example, to install scipy, change ``INST_SCIPY=0`` to
+``INST_SCIPY=1``.
+
+To execute the install script, run:
+
+.. code-block:: bash
+
+ $ bash install_script.sh
Because the installer is downloading and building a variety of packages from
-source, this will likely take a while (e.g. 20 minutes), but you will get
-updates of its status at the command line throughout.
+source, this will likely take a few minutes, especially if you have a slow
+internet connection or have ``INST_CONDA=0`` set. You will get updates of its
+status at the command prompt throughout.
If you receive errors during this process, the installer will provide you
with a large amount of information to assist in debugging your problems. The
@@ -127,26 +161,63 @@
potentially figure out what went wrong. If you have problems, though, do not
hesitate to :ref:`contact us <asking-for-help>` for assistance.
+If the install script errors out with a message about being unable to import the
+python SSL bindings, this means that the Python built by the install script was
+unable to link against the OpenSSL library. This likely means that you installed
+with ``INST_CONDA=0`` on a recent version of OSX, or on a cluster that has a
+very out of date installation of OpenSSL. In both of these cases you will either
+need to install OpenSSL yourself from the system package manager or consider
+using ``INST_CONDA=1``, since conda-based installs can install the conda package
+for OpenSSL.
+
.. _activating-yt:
Activating Your Installation
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Once the installation has completed, there will be instructions on how to set up
-your shell environment to use yt by executing the activate script. You must
-run this script in order to have yt properly recognized by your system. You can
-either add it to your login script, or you must execute it in each shell session
-prior to working with yt.
+your shell environment to use yt.
+
+Activating Conda-based installs (``INST_CONDA=1``)
+""""""""""""""""""""""""""""""""""""""""""""""""""
+
+For conda-based installs, you will need to ensure that the installation's
+``yt-conda/bin`` directory is prepended to your ``PATH`` environment variable.
+
+For Bash-style shells, you can use the following command in a terminal session
+to temporarily activate the yt installation:
.. code-block:: bash
- source <yt installation directory>/bin/activate
+ $ export PATH=/path/to/yt-conda/bin:$PATH
+
+and on csh-style shells:
+
+.. code-block:: csh
+
+ $ setenv PATH /path/to/yt-conda/bin:$PATH
+
+If you would like to permanently activate yt, you can also update the init file
+appropriate for your shell and OS (e.g. .bashrc, .bash_profile, .cshrc, .zshrc)
+to include the same command.
+
+Activating source-based installs (``INST_CONDA=0``)
+"""""""""""""""""""""""""""""""""""""""""""""""""""
+
+For this installation method, you must run an ``activate`` script to activate
+the yt environment in a terminal session. You must run this script in order to
+have yt properly recognized by your system. You can either add it to your login
+script, or you must execute it in each shell session prior to working with yt.
+
+.. code-block:: bash
+
+ $ source <yt installation directory>/bin/activate
If you use csh or tcsh as your shell, activate that version of the script:
.. code-block:: bash
- source <yt installation directory>/bin/activate.csh
+ $ source <yt installation directory>/bin/activate.csh
If you don't like executing outside scripts on your computer, you can set
the shell variables manually. ``YT_DEST`` needs to point to the root of the
@@ -166,14 +237,21 @@
.. code-block:: bash
- yt update
+ $ yt update
-Additionally, if you want to make sure you have the latest dependencies
-associated with yt and update the codebase simultaneously, type this:
+Additionally, if you ran the install script with ``INST_CONDA=0`` and want to
+make sure you have the latest dependencies associated with yt and update the
+codebase simultaneously, type this:
.. code-block:: bash
- yt update --all
+ $ yt update --all
+
+If you ran the install script with ``INST_CONDA=1`` and want to update your dependencies, run:
+
+.. code-block:: bash
+
+ $ conda update --all
.. _removing-yt:
@@ -192,35 +270,26 @@
Installing yt Using Anaconda
++++++++++++++++++++++++++++
-Perhaps the quickest way to get yt up and running is to install it using the
-`Anaconda Python Distribution <https://store.continuum.io/cshop/anaconda/>`_,
-which will provide you with a easy-to-use environment for installing Python
-packages.
-
-If you do not want to install the full anaconda python distribution, you can
-install a bare-bones Python installation using miniconda. To install miniconda,
-visit http://repo.continuum.io/miniconda/ and download ``Miniconda-latest-...``
-script for your platform and system architecture. Next, run the script, e.g.:
-
-.. code-block:: bash
-
- bash Miniconda-latest-Linux-x86_64.sh
-
For both the Anaconda and Miniconda installations, make sure that the Anaconda
``bin`` directory is in your path, and then issue:
.. code-block:: bash
- conda install yt
+ $ conda install yt
which will install stable branch of yt along with all of its dependencies.
+.. _nightly-conda-builds:
+
+Nightly Conda Builds
+^^^^^^^^^^^^^^^^^^^^
+
If you would like to install latest development version of yt, you can download
it from our custom anaconda channel:
.. code-block:: bash
- conda install -c http://use.yt/with_conda/ yt
+ $ conda install -c http://use.yt/with_conda/ yt
New packages for development branch are built after every pull request is
merged. In order to make sure you are running latest version, it's recommended
@@ -228,28 +297,26 @@
.. code-block:: bash
- conda update -c http://use.yt/with_conda/ yt
+ $ conda update -c http://use.yt/with_conda/ yt
Location of our channel can be added to ``.condarc`` to avoid retyping it during
each *conda* invocation. Please refer to `Conda Manual
<http://conda.pydata.org/docs/config.html#channel-locations-channels>`_ for
detailed instructions.
+.. _conda-source-build:
-Obtaining Source Code
-^^^^^^^^^^^^^^^^^^^^^
+Building yt from Source For Conda-based Installs
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-There are two ways to get the yt source code when using an Anaconda
-installation.
-
-Option 1:
-
-Ensure that you have all build dependencies installed in your current
+First, ensure that you have all build dependencies installed in your current
conda environment:
.. code-block:: bash
- conda install cython mercurial sympy ipython h5py matplotlib
+ $ conda install cython mercurial sympy ipython matplotlib
+
+In addition, you will need a C compiler installed.
.. note::
@@ -260,87 +327,124 @@
.. code-block:: bash
- export CONDA_DIR=$(python -c 'import sys; print(sys.executable.split("/bin/python")[0])')
- conda create -y -n py27 python=2.7 mercurial
- ln -s ${CONDA_DIR}/envs/py27/bin/hg ${CONDA_DIR}/bin
+ $ export CONDA_DIR=$(python -c 'import sys; print(sys.executable.split("/bin/python")[0])')
+ $ conda create -y -n py27 python=2.7 mercurial
+ $ ln -s ${CONDA_DIR}/envs/py27/bin/hg ${CONDA_DIR}/bin
Clone the yt repository with:
.. code-block:: bash
- hg clone https://bitbucket.org/yt_analysis/yt
+ $ hg clone https://bitbucket.org/yt_analysis/yt
Once inside the yt directory, update to the appropriate branch and
-run ``setup.py``. For example, the following commands will allow you
+run ``setup.py develop``. For example, the following commands will allow you
to see the tip of the development branch.
.. code-block:: bash
- hg up yt
- python setup.py develop
+ $ hg pull
+ $ hg update yt
+ $ python setup.py develop
This will make sure you are running a version of yt corresponding to the
most up-to-date source code.
-Option 2:
+.. _rockstar-conda:
-Recipes to build conda packages for yt are available at
-https://github.com/conda/conda-recipes. To build the yt conda recipe, first
-clone the conda-recipes repository
+Rockstar Halo Finder for Conda-based installations
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The easiest way to set rockstar up in a conda-based python envrionment is to run
+the install script with both ``INST_CONDA=1`` and ``INST_ROCKSTAR=1``.
+
+If you want to do this manually, you will need to follow these
+instructions. First, clone Matt Turk's fork of rockstar and compile it:
.. code-block:: bash
- git clone https://github.com/conda/conda-recipes
+ $ hg clone https://bitbucket.org/MatthewTurk/rockstar
+ $ cd rockstar
+ $ make lib
-Then navigate to the repository root and invoke ``conda build``:
+Next, copy `librockstar.so` into the `lib` folder of your anaconda installation:
.. code-block:: bash
- cd conda-recipes
- conda build ./yt/
+ $ cp librockstar.so /path/to/anaconda/lib
-Note that building a yt conda package requires a C compiler.
+Finally, you will need to recompile yt to enable the rockstar interface. Clone a
+copy of the yt mercurial repository (see :ref:`conda-source-build`), or navigate
+to a clone that you have already made, and do the following:
+
+.. code-block:: bash
+
+ $ cd /path/to/yt-hg
+ $ ./clean.sh
+ $ echo /path/to/rockstar > rockstar.cfg
+ $ python setup.py develop
+
+Here ``/path/to/yt-hg`` is the path to your clone of the yt mercurial repository
+and ``/path/to/rockstar`` is the path to your clone of Matt Turk's fork of
+rockstar.
+
+Finally, to actually use rockstar, you will need to ensure the folder containing
+`librockstar.so` is in your LD_LIBRARY_PATH:
+
+.. code-block:: bash
+
+ $ export LD_LIBRARY_PATH=/path/to/anaconda/lib
+
+You should now be able to enter a python session and import the rockstar
+interface:
+
+.. code-block:: python
+
+ >>> from yt.analysis_modules.halo_finding.rockstar import rockstar_interface
+
+If this python import fails, then you have not installed rockstar and yt's
+rockstar interface correctly.
.. _windows-installation:
Installing yt on Windows
^^^^^^^^^^^^^^^^^^^^^^^^
-Installation on 64-bit Microsoft Windows platforms is supported using Anaconda (see
-:ref:`anaconda-installation`). Also see :ref:`windows-developing` for details on how to build yt
-from source in Windows.
+Installation on 64-bit Microsoft Windows platforms is supported using Anaconda
+(see :ref:`anaconda-installation`). Also see :ref:`windows-developing` for
+details on how to build yt from source in Windows.
.. _source-installation:
-Installing yt Using pip or from Source
-++++++++++++++++++++++++++++++++++++++
+Installing yt Using ``pip`` or From Source
+++++++++++++++++++++++++++++++++++++++++++
+
+.. note::
+
+ If you wish to install yt from source in a conda-based installation of yt,
+ see :ref:`conda-source-build`.
To install yt from source, you must make sure you have yt's dependencies
-installed on your system.
+installed on your system. Right now, the dependencies to build yt from
+source include:
-If you use a Linux OS, use your distro's package manager to install these yt
-dependencies on your system:
+- ``mercurial``
+- A C compiler such as ``gcc`` or ``clang``
+- ``Python 2.7``, ``Python 3.4``, or ``Python 3.5``
-- ``HDF5``
-- ``zeromq``
-- ``sqlite``
-- ``mercurial``
-
-Then install the required Python packages with ``pip``:
+In addition, building yt from source requires several python packages
+which can be installed with ``pip``:
.. code-block:: bash
- $ pip install numpy matplotlib cython h5py nose sympy
+ $ pip install numpy matplotlib cython sympy
-If you're using IPython notebooks, you can install its dependencies
-with ``pip`` as well:
+You may also want to install some of yt's optional dependencies, including
+``jupyter``, ``h5py`` (which in turn depends on the HDF5 library), ``scipy``, or
+``astropy``,
-.. code-block:: bash
-
- $ pip install ipython[notebook]
-
-From here, you can use ``pip`` (which comes with ``Python``) to install the latest
-stable version of yt:
+From here, you can use ``pip`` (which comes with ``Python``) to install the
+latest stable version of yt:
.. code-block:: bash
@@ -353,46 +457,30 @@
.. code-block:: bash
- hg clone https://bitbucket.org/yt_analysis/yt
- cd yt
- hg update yt
- python setup.py install --user --prefix=
+ $ hg clone https://bitbucket.org/yt_analysis/yt
+ $ cd yt
+ $ hg update yt
+ $ python setup.py install --user --prefix=
.. note::
- If you maintain your own user-level python installation separate from the OS-level python
- installation, you can leave off ``--user --prefix=``, although you might need
- ``sudo`` depending on where python is installed. See `This StackOverflow
- discussion
+ If you maintain your own user-level python installation separate from the
+ OS-level python installation, you can leave off ``--user --prefix=``, although
+ you might need ``sudo`` depending on where python is installed. See `This
+ StackOverflow discussion
<http://stackoverflow.com/questions/4495120/combine-user-with-prefix-error-with-setup-py-install>`_
if you are curious why ``--prefix=`` is neccessary on some systems.
-.. note::
-
- yt requires version 18.0 or higher of ``setuptools``. If you see
- error messages about this package, you may need to update it. For
- example, with pip via
-
- .. code-block:: bash
-
- pip install --upgrade setuptools
-
- or your preferred method. If you have ``distribute`` installed, you
- may also see error messages for it if it's out of date. You can
- update with pip via
-
- .. code-block:: bash
-
- pip install --upgrade distribute
-
- or via your preferred method.
-
-
This will install yt into a folder in your home directory
(``$HOME/.local/lib64/python2.7/site-packages`` on Linux,
``$HOME/Library/Python/2.7/lib/python/site-packages/`` on OSX) Please refer to
the ``setuptools`` documentation for the additional options.
+If you are unable to locate the ``yt`` executable (i.e. ``yt version`` failes),
+then you likely need to add the ``$HOME/.local/bin`` (or the equivalent on your
+OS) to your PATH. Some linux distributions do not include this directory in the
+default search path.
+
If you choose this installation method, you do not need to run any activation
script since this will install yt into your global python environment.
@@ -401,15 +489,35 @@
.. code-block:: bash
- hg clone https://bitbucket.org/yt_analysis/yt
- cd yt
- hg update yt
- python setup.py develop --user --prefix=
+ $ hg clone https://bitbucket.org/yt_analysis/yt
+ $ cd yt
+ $ hg update yt
+ $ python setup.py develop --user --prefix=
As above, you can leave off ``--user --prefix=`` if you want to install yt into the default
package install path. If you do not have write access for this location, you
might need to use ``sudo``.
+Build errors with ``setuptools`` or ``distribute``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Building yt requires version 18.0 or higher of ``setuptools``. If you see error
+messages about this package, you may need to update it. For example, with pip
+via
+
+.. code-block:: bash
+
+ $ pip install --upgrade setuptools
+
+or your preferred method. If you have ``distribute`` installed, you may also see
+error messages for it if it's out of date. You can update with pip via
+
+.. code-block:: bash
+
+ $ pip install --upgrade distribute
+
+or via your preferred method.
+
Keeping yt Updated via Mercurial
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -424,7 +532,7 @@
.. code-block:: bash
- yt update
+ $ yt update
This will detect that you have installed yt from the mercurial repository, pull
any changes from Bitbucket, and then recompile yt if necessary.
@@ -439,7 +547,7 @@
.. code-block:: bash
- yt --help
+ $ yt --help
If this works, you should get a list of the various command-line options for
yt, which means you have successfully installed yt. Congratulations!
@@ -453,21 +561,57 @@
.. _switching-between-yt-versions:
-Switching versions of yt: yt-2.x, yt-3.x, stable, and dev
----------------------------------------------------------
+Switching versions of yt: ``yt-2.x``, ``stable``, and ``yt`` branches
+---------------------------------------------------------------------
-With the release of version 3.0 of yt, development of the legacy yt 2.x series
-has been relegated to bugfixes. That said, we will continue supporting the 2.x
-series for the foreseeable future. This makes it easy to use scripts written
-for older versions of yt without substantially updating them to support the
-new field naming or unit systems in yt version 3.
+Here we explain how to switch between different development branches of yt.
-Currently, the yt-2.x codebase is contained in a named branch in the yt
-mercurial repository. Thus, depending on the method you used to install
-yt, there are different instructions for switching versions.
+If You Installed yt Using the Bash Install Script
++++++++++++++++++++++++++++++++++++++++++++++++++
-If You Installed yt Using the Installer Script
-++++++++++++++++++++++++++++++++++++++++++++++
+The instructions for how to switch between branches depend on whether you ran
+the install script with ``INST_YT_SOURCE=0`` (the default) or
+``INST_YT_SOURCE=1``. You can determine which option you used by inspecting the
+output:
+
+.. code-block:: bash
+
+ $ yt version
+
+If the output from this command looks like:
+
+.. code-block:: none
+
+ The current version and changeset for the code is:
+
+ ---
+ Version = 3.2.3
+ ---
+
+i.e. it does not refer to a specific changeset hash, then you originally chose
+``INST_YT_SOURCE=0``.
+
+On the other hand, if the output from ``yt version`` looks like:
+
+.. code-block:: none
+
+ The current version and changeset for the code is:
+
+ ---
+ Version = 3.3-dev
+ Changeset = d8eec89b2c86 (yt) tip
+ ---
+
+i.e. it refers to a specific changeset in the yt mercurial repository, then
+you installed using ``INST_YT_SOURCE=1``.
+
+Conda-based installs (``INST_YT_SOURCE=0``)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+In this case you can either install one of the nightly conda builds (see :ref:`nightly-conda-builds`), or you can follow the instructions above to build yt from source under conda (see :ref:`conda-source-build`).
+
+Source-based installs (``INST_YT_SOURCE=1``)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
You already have the mercurial repository, so you simply need to switch
which version you're using. Navigate to the root of the yt mercurial
@@ -476,9 +620,9 @@
.. code-block:: bash
- cd yt-<machine>/src/yt-hg
- hg update <desired-version>
- python setup.py develop
+ $ cd yt-<machine>/src/yt-hg
+ $ hg update <desired-version>
+ $ python setup.py develop
Valid versions to jump to are described in :ref:`branches-of-yt`.
@@ -494,8 +638,8 @@
.. code-block:: bash
- pip uninstall yt
- hg clone https://bitbucket.org/yt_analysis/yt
+ $ pip uninstall yt
+ $ hg clone https://bitbucket.org/yt_analysis/yt
Now, to switch between versions, you need to navigate to the root of
the mercurial yt repository. Use mercurial to
@@ -503,9 +647,9 @@
.. code-block:: bash
- cd yt
- hg update <desired-version>
- python setup.py install --user --prefix=
+ $ cd yt
+ $ hg update <desired-version>
+ $ python setup.py install --user --prefix=
Valid versions to jump to are described in :ref:`branches-of-yt`).
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 doc/source/quickstart/2)_Data_Inspection.ipynb
--- a/doc/source/quickstart/2)_Data_Inspection.ipynb
+++ b/doc/source/quickstart/2)_Data_Inspection.ipynb
@@ -154,6 +154,35 @@
"cell_type": "markdown",
"metadata": {},
"source": [
+ "Finally, we can get basic information about the particle types and number of particles in a simulation:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "print (ds.particle_types)\n",
+ "print (ds.particle_types_raw)\n",
+ "print (ds.particle_type_counts)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "For this dataset, we see that there are two particle types defined, (`io` and `all`), but that only one of these particle types in in `ds.particle_types_raw`. The `ds.particle_types` list contains *all* particle types in the simulation, including ones that are dynamically defined like particle unions. The `ds.particle_types_raw` list includes only particle types that are in the output file we loaded the dataset from.\n",
+ "\n",
+ "We can also see that there are a bit more than 1.1 million particles in this simulation. Only particle types in `ds.particle_types_raw` will appear in the `ds.particle_type_counts` dictionary."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
"# Mesh Structure\n",
"\n",
"If you're using a simulation type that has grids (for instance, here we're using an Enzo simulation) you can examine the structure of the mesh. For the most part, you probably won't have to use this unless you're debugging a simulation or examining in detail what is going on."
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 doc/source/reference/code_support.rst
--- a/doc/source/reference/code_support.rst
+++ b/doc/source/reference/code_support.rst
@@ -28,14 +28,18 @@
+-----------------------+------------+-----------+------------+-------+----------+----------+------------+----------+
| Enzo | Y | Y | Y | Y | Y | Y | Y | Full |
+-----------------------+------------+-----------+------------+-------+----------+----------+------------+----------+
+| FITS | Y | N/A | Y | Y | Y | Y | Y | Full |
++-----------------------+------------+-----------+------------+-------+----------+----------+------------+----------+
| FLASH | Y | Y | Y | Y | Y | Y | Y | Full |
+-----------------------+------------+-----------+------------+-------+----------+----------+------------+----------+
-| FITS | Y | N/A | Y | Y | Y | Y | Y | Full |
-+-----------------------+------------+-----------+------------+-------+----------+----------+------------+----------+
| Gadget | Y | Y | Y | Y | Y [#f2]_ | Y | Y | Full |
+-----------------------+------------+-----------+------------+-------+----------+----------+------------+----------+
+| GAMER | Y | N | Y | Y | Y | Y | Y | Full |
++-----------------------+------------+-----------+------------+-------+----------+----------+------------+----------+
| Gasoline | Y | Y | Y | Y | Y [#f2]_ | Y | Y | Full |
+-----------------------+------------+-----------+------------+-------+----------+----------+------------+----------+
+| Gizmo | Y | Y | Y | Y | Y [#f2]_ | Y | Y | Full |
++-----------------------+------------+-----------+------------+-------+----------+----------+------------+----------+
| Grid Data Format (GDF)| Y | N/A | Y | Y | Y | Y | Y | Full |
+-----------------------+------------+-----------+------------+-------+----------+----------+------------+----------+
| Maestro | Y [#f1]_ | N | Y | Y | Y | Y | N | Partial |
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 doc/source/visualizing/callbacks.rst
--- a/doc/source/visualizing/callbacks.rst
+++ b/doc/source/visualizing/callbacks.rst
@@ -692,6 +692,28 @@
s.annotate_triangle_facets(points, plot_args={"colors": 'black'})
s.save()
+.. _annotate-mesh-lines:
+
+Annotate Mesh Lines Callback
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. function:: annotate_mesh_lines(plot_args=None)
+
+ (This is a proxy for
+ :class:`~yt.visualization.plot_modifications.MeshLinesCallback`.)
+
+ This draws the mesh line boundaries over a plot using a Matplotlib
+ line collection. This callback is only useful for unstructured or
+ semi-structured mesh datasets.
+
+.. python-script::
+
+ import yt
+ ds = yt.load('MOOSE_sample_data/out.e')
+ sl = yt.SlicePlot(ds, 2, ('connect1', 'nodal_aux'))
+ sl.annotate_mesh_lines(plot_args={'color':'black'})
+ sl.save()
+
.. _annotate-ray:
Overplot the Path of a Ray
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 doc/source/visualizing/plots.rst
--- a/doc/source/visualizing/plots.rst
+++ b/doc/source/visualizing/plots.rst
@@ -406,16 +406,14 @@
import yt
ds = yt.load('MOOSE_sample_data/out.e-s010')
sl = yt.SlicePlot(ds, 'z', ('connect1', 'diffused'))
- sl.annotate_mesh_lines(thresh=0.1)
+ sl.annotate_mesh_lines(plot_args={'color':'black'})
sl.zoom(0.75)
sl.save()
-This annotation is performed by marking the pixels where the mapped coordinate is close
-to the element boundary. What counts as 'close' (in the mapped coordinate system) is
-determined by the ``thresh`` parameter, which can be varied to make the lines thicker or
-thinner.
+The ``plot_args`` parameter is a dictionary of keyword arguments that will be passed
+to matplotlib. It can be used to control the mesh line color, thickness, etc...
-The above example all involve 8-node hexahedral mesh elements. Here is another example from
+The above examples all involve 8-node hexahedral mesh elements. Here is another example from
a dataset that uses 6-node wedge elements:
.. python-script::
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 doc/source/visualizing/sketchfab.rst
--- a/doc/source/visualizing/sketchfab.rst
+++ b/doc/source/visualizing/sketchfab.rst
@@ -55,7 +55,7 @@
.. code-block:: python
import yt
- ds = yt.load("/data/workshop2012/IsolatedGalaxy/galaxy0030/galaxy0030")
+ ds = yt.load("IsolatedGalaxy/galaxy0030/galaxy0030")
sphere = ds.sphere("max", (1.0, "Mpc"))
surface = ds.surface(sphere, "density", 1e-27)
@@ -113,24 +113,23 @@
.. code-block:: python
- import yt
- ds = yt.load("redshift0058")
- dd = ds.sphere("max", (200, "kpc"))
- rho = 5e-27
+ import yt
+ from yt.units import kpc
+ ds = yt.load("IsolatedGalaxy/galaxy0030/galaxy0030")
+ dd = ds.sphere(ds.domain_center, (500, "kpc"))
+ rho = 1e-28
- bounds = [(dd.center[i] - 100.0/ds['kpc'],
- dd.center[i] + 100.0/ds['kpc']) for i in range(3)]
+ bounds = [[dd.center[i] - 250*kpc, dd.center[i] + 250*kpc] for i in range(3)]
- surf = ds.surface(dd, "density", rho)
+ surf = ds.surface(dd, "density", rho)
- upload_id = surf.export_sketchfab(
- title = "RD0058 - 5e-27",
- description = "Extraction of Density (colored by Temperature) at 5e-27 " \
- + "g/cc from a galaxy formation simulation by Ryan Joung."
- color_field = "temperature",
- color_map = "hot",
- color_log = True,
- bounds = bounds
+ upload_id = surf.export_sketchfab(
+ title="galaxy0030 - 1e-28",
+ description="Extraction of Density (colored by temperature) at 1e-28 g/cc",
+ color_field="temperature",
+ color_map="hot",
+ color_log=True,
+ bounds=bounds
)
and yt will extract a surface, convert to a format that Sketchfab.com
@@ -141,15 +140,13 @@
.. raw:: html
- <iframe frameborder="0" height="480" width="854" allowFullScreen
- webkitallowfullscreen="true" mozallowfullscreen="true"
- src="http://skfb.ly/l4jh2edcba?autostart=0&transparent=0&autospin=0&controls=1&watermark=1"></iframe>
+ <iframe width="640" height="480" src="https://sketchfab.com/models/ff59dacd55824110ad5bcc292371a514/embed" frameborder="0" allowfullscreen mozallowfullscreen="true" webkitallowfullscreen="true" onmousewheel=""></iframe>
As a note, Sketchfab has a maximum model size of 50MB for the free account.
-50MB is pretty hefty, though, so it shouldn't be a problem for most needs.
-We're working on a way to optionally upload links to the Sketchfab models on
-the `yt Hub <https://hub.yt-project.org/>`_, but for now, if you want to share
-a cool model we'd love to see it!
+50MB is pretty hefty, though, so it shouldn't be a problem for most
+needs. Additionally, if you have an eligible e-mail address associated with a
+school or university, you can request a free professional account, which allows
+models up to 200MB. See https://sketchfab.com/education for details.
OBJ and MTL Files
-----------------
@@ -167,7 +164,7 @@
import yt
- ds = yt.load("/data/workshop2012/IsolatedGalaxy/galaxy0030/galaxy0030")
+ ds = yt.load("IsolatedGalaxy/galaxy0030/galaxy0030")
rho = [2e-27, 1e-27]
trans = [1.0, 0.5]
filename = './surfaces'
@@ -239,7 +236,7 @@
import yt
- ds = yt.load("/data/workshop2012/IsolatedGalaxy/galaxy0030/galaxy0030")
+ ds = yt.load("IsolatedGalaxy/galaxy0030/galaxy0030")
rho = [2e-27, 1e-27]
trans = [1.0, 0.5]
filename = './surfaces'
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 doc/source/visualizing/volume_rendering.rst
--- a/doc/source/visualizing/volume_rendering.rst
+++ b/doc/source/visualizing/volume_rendering.rst
@@ -31,8 +31,8 @@
as grid or continent lines, and then to render a production-quality
visualization. By changing the "lens" used, a single camera path can output
images suitable for planetarium domes, immersive and head tracking systems
-(such as the Oculus Rift or recent "spherical" movie viewers such as the
-mobile YouTube app), as well as standard screens.
+(such as the Oculus Rift or recent 360-degree/virtual reality movie viewers
+such as the mobile YouTube app), as well as standard screens.
.. image:: _images/scene_diagram.svg
:width: 50%
@@ -327,13 +327,19 @@
The :class:`~yt.visualization.volume_rendering.lens.SphericalLens` produces
a cylindrical-spherical projection. Movies rendered in this way can be
-displayed in head-tracking devices (e.g. Oculus Rift) or in YouTube 360 view
-(for more information see `the YouTube help
-<https://support.google.com/youtube/answer/6178631?hl=en>`, but it's a
-simple matter of running a script on an encoded movie file.)
+displayed as YouTube 360-degree videos (for more information see
+`the YouTube help: Upload 360-degree videos
+<https://support.google.com/youtube/answer/6178631?hl=en>`_).
:class:`~yt.visualization.volume_rendering.lens.StereoSphericalLens`
is identical to :class:`~yt.visualization.volume_rendering.lens.SphericalLens`
-but it produces two images from nearby camera positions for use in 3D viewing.
+but it produces two images from nearby camera positions for virtual reality
+movies, which can be displayed in head-tracking devices (e.g. Oculus Rift)
+or in mobile YouTube app with Google Cardboard (for more information
+see `the YouTube help: Upload virtual reality videos
+<https://support.google.com/youtube/answer/6316263?hl=en>`_).
+`This virtual reality video
+<https://youtu.be/ZYWY53X7UQE>`_ on YouTube is an example produced with
+:class:`~yt.visualization.volume_rendering.lens.StereoSphericalLens`.
.. _annotated-vr-example:
diff -r 2c89ad39dd1c37473d72d9fd3e02656290e256e0 -r aa006bf5e5f92076e72f38130551978e675b4bc8 setup.cfg
--- a/setup.cfg
+++ b/setup.cfg
@@ -10,10 +10,10 @@
[flake8]
# we exclude:
-# api.py and __init__.py files to avoid spurious unused import errors
-# _mpl_imports.py for the same reason
+# api.py, mods.py, _mpl_imports.py, and __init__.py files to avoid spurious
+# unused import errors
# autogenerated __config__.py files
# vendored libraries
-exclude = */api.py,*/__init__.py,*/__config__.py,yt/visualization/_mpl_imports.py,yt/utilities/lodgeit.py,yt/utilities/poster/*,yt/extern/*,yt/mods.py
+exclude = */api.py,*/__init__.py,*/__config__.py,yt/visualization/_mpl_imports.py,yt/utilities/lodgeit.py,yt/utilities/lru_cache.py,yt/utilities/poster/*,yt/extern/*,yt/mods.py
max-line-length=999
ignore = E111,E121,E122,E123,E124,E125,E126,E127,E128,E129,E131,E201,E202,E211,E221,E222,E227,E228,E241,E301,E203,E225,E226,E231,E251,E261,E262,E265,E266,E302,E303,E402,E502,E701,E703,E731,W291,W292,W293,W391,W503
\ No newline at end of file
This diff is so big that we needed to truncate the remainder.
https://bitbucket.org/yt_analysis/yt/commits/7fb568976ac9/
Changeset: 7fb568976ac9
Branch: yt
User: brittonsmith
Date: 2016-06-13 19:01:53+00:00
Summary: Reverting cache of cell mask.
Affected #: 1 file
diff -r aa006bf5e5f92076e72f38130551978e675b4bc8 -r 7fb568976ac9c87d152aac25aaa6eb99c5b8d0ae yt/data_objects/selection_data_containers.py
--- a/yt/data_objects/selection_data_containers.py
+++ b/yt/data_objects/selection_data_containers.py
@@ -812,21 +812,18 @@
if not np.any(m): continue
yield obj, m
- _cell_mask = None
@property
def _cond_ind(self):
- if self._cell_mask is None:
- ind = None
- obj = self.base_object
- with obj._field_parameter_state(self.field_parameters):
- for cond in self.conditionals:
- res = eval(cond)
- if ind is None: ind = res
- if ind.shape != res.shape:
- raise YTIllDefinedCutRegion(self.conditionals)
- np.logical_and(res, ind, ind)
- self._cell_mask = ind
- return self._cell_mask
+ ind = None
+ obj = self.base_object
+ with obj._field_parameter_state(self.field_parameters):
+ for cond in self.conditionals:
+ res = eval(cond)
+ if ind is None: ind = res
+ if ind.shape != res.shape:
+ raise YTIllDefinedCutRegion(self.conditionals)
+ np.logical_and(res, ind, ind)
+ return ind
_particle_mask = None
@property
https://bitbucket.org/yt_analysis/yt/commits/bfbce27e09d9/
Changeset: bfbce27e09d9
Branch: yt
User: brittonsmith
Date: 2016-06-13 21:26:22+00:00
Summary: Ensuring consistent units.
Affected #: 1 file
diff -r 7fb568976ac9c87d152aac25aaa6eb99c5b8d0ae -r bfbce27e09d9146a79587785402ae4e023197388 yt/data_objects/selection_data_containers.py
--- a/yt/data_objects/selection_data_containers.py
+++ b/yt/data_objects/selection_data_containers.py
@@ -830,12 +830,14 @@
def _part_ind(self):
if self._particle_mask is None:
parent = getattr(self, "parent", self.base_object)
+ units = "code_length"
mask = points_in_cells(
- self["x"], self["y"], self["z"],
- self["dx"], self["dy"], self["dz"],
- parent["particle_position_x"].to("code_length"),
- parent["particle_position_y"].to("code_length"),
- parent["particle_position_z"].to("code_length"))
+ self["x"].to(units), self["y"].to(units),
+ self["z"].to(units), self["dx"].to(units),
+ self["dy"].to(units), self["dz"].to(units),
+ parent["particle_position_x"].to(units),
+ parent["particle_position_y"].to(units),
+ parent["particle_position_z"].to(units))
self._particle_mask = mask
return self._particle_mask
https://bitbucket.org/yt_analysis/yt/commits/a3f0b14e3d7a/
Changeset: a3f0b14e3d7a
Branch: yt
User: brittonsmith
Date: 2016-06-14 16:25:46+00:00
Summary: Adding clump finder tests.
Affected #: 2 files
diff -r bfbce27e09d9146a79587785402ae4e023197388 -r a3f0b14e3d7a10324b61c241aacf756579bb4530 yt/analysis_modules/level_sets/tests/test_clump_finding.py
--- /dev/null
+++ b/yt/analysis_modules/level_sets/tests/test_clump_finding.py
@@ -0,0 +1,74 @@
+"""
+Clump finder tests
+
+
+
+
+"""
+
+#-----------------------------------------------------------------------------
+# Copyright (c) 2016, 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 yt.analysis_modules.level_sets.api import \
+ Clump, \
+ find_clumps, \
+ get_lowest_clumps
+from yt.frontends.stream.api import \
+ load_uniform_grid
+from yt.testing import \
+ assert_array_equal, \
+ assert_equal
+
+def test_clump_finding():
+ n_c = 8
+ n_p = 1
+ dims = (n_c, n_c, n_c)
+
+ density = np.ones(dims)
+ high_rho = 10.
+ # add a couple disconnected density enhancements
+ density[2, 2, 2] = high_rho
+ density[6, 6, 6] = high_rho
+
+ # put a particle at the center of one of them
+ dx = 1. / n_c
+ px = 2.5 * dx * np.ones(n_p)
+
+ data = {"density": density,
+ "particle_mass": np.ones(n_p),
+ "particle_position_x": px,
+ "particle_position_y": px,
+ "particle_position_z": px,
+ "number_of_particles": n_p}
+
+ ds = load_uniform_grid(data, dims)
+
+ ad = ds.all_data()
+ master_clump = Clump(ad, ("gas", "density"))
+ master_clump.add_validator("min_cells", 1)
+
+ find_clumps(master_clump, 0.5, 2. * high_rho, 10.)
+
+ # there should be two children
+ assert_equal(len(master_clump.children), 2)
+
+ leaf_clumps = get_lowest_clumps(master_clump)
+ # two leaf clumps
+ assert_equal(len(leaf_clumps), 2)
+
+
+ # check some clump fields
+ assert_equal(master_clump.children[0]["density"][0].size, 1)
+ assert_equal(master_clump.children[0]["density"][0], ad["density"].max())
+ assert_equal(master_clump.children[0]["particle_mass"].size, 1)
+ assert_array_equal(master_clump.children[0]["particle_mass"], ad["particle_mass"])
+ assert_equal(master_clump.children[1]["density"][0].size, 1)
+ assert_equal(master_clump.children[1]["density"][0], ad["density"].max())
+ assert_equal(master_clump.children[1]["particle_mass"].size, 0)
https://bitbucket.org/yt_analysis/yt/commits/b4f9e4c9baed/
Changeset: b4f9e4c9baed
Branch: yt
User: ngoldbaum
Date: 2016-06-15 18:09:43+00:00
Summary: Merged in brittonsmith/yt (pull request #2148)
Enabling particle fields for clump objects
Affected #: 5 files
diff -r e0b1c973fefe530286e6589ef119dce4e4fe09e4 -r b4f9e4c9baeda6a9c9dd92bd026ca8dc86fc8afe yt/analysis_modules/level_sets/clump_handling.py
--- a/yt/analysis_modules/level_sets/clump_handling.py
+++ b/yt/analysis_modules/level_sets/clump_handling.py
@@ -57,6 +57,9 @@
self.min_val = self.data[field].min()
self.max_val = self.data[field].max()
+ if parent is not None:
+ self.data.parent = self.parent.data
+
# List containing characteristics about clumps that are to be written
# out by the write routines.
if clump_info is None:
diff -r e0b1c973fefe530286e6589ef119dce4e4fe09e4 -r b4f9e4c9baeda6a9c9dd92bd026ca8dc86fc8afe yt/analysis_modules/level_sets/tests/test_clump_finding.py
--- /dev/null
+++ b/yt/analysis_modules/level_sets/tests/test_clump_finding.py
@@ -0,0 +1,74 @@
+"""
+Clump finder tests
+
+
+
+
+"""
+
+#-----------------------------------------------------------------------------
+# Copyright (c) 2016, 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 yt.analysis_modules.level_sets.api import \
+ Clump, \
+ find_clumps, \
+ get_lowest_clumps
+from yt.frontends.stream.api import \
+ load_uniform_grid
+from yt.testing import \
+ assert_array_equal, \
+ assert_equal
+
+def test_clump_finding():
+ n_c = 8
+ n_p = 1
+ dims = (n_c, n_c, n_c)
+
+ density = np.ones(dims)
+ high_rho = 10.
+ # add a couple disconnected density enhancements
+ density[2, 2, 2] = high_rho
+ density[6, 6, 6] = high_rho
+
+ # put a particle at the center of one of them
+ dx = 1. / n_c
+ px = 2.5 * dx * np.ones(n_p)
+
+ data = {"density": density,
+ "particle_mass": np.ones(n_p),
+ "particle_position_x": px,
+ "particle_position_y": px,
+ "particle_position_z": px,
+ "number_of_particles": n_p}
+
+ ds = load_uniform_grid(data, dims)
+
+ ad = ds.all_data()
+ master_clump = Clump(ad, ("gas", "density"))
+ master_clump.add_validator("min_cells", 1)
+
+ find_clumps(master_clump, 0.5, 2. * high_rho, 10.)
+
+ # there should be two children
+ assert_equal(len(master_clump.children), 2)
+
+ leaf_clumps = get_lowest_clumps(master_clump)
+ # two leaf clumps
+ assert_equal(len(leaf_clumps), 2)
+
+
+ # check some clump fields
+ assert_equal(master_clump.children[0]["density"][0].size, 1)
+ assert_equal(master_clump.children[0]["density"][0], ad["density"].max())
+ assert_equal(master_clump.children[0]["particle_mass"].size, 1)
+ assert_array_equal(master_clump.children[0]["particle_mass"], ad["particle_mass"])
+ assert_equal(master_clump.children[1]["density"][0].size, 1)
+ assert_equal(master_clump.children[1]["density"][0], ad["density"].max())
+ assert_equal(master_clump.children[1]["particle_mass"].size, 0)
diff -r e0b1c973fefe530286e6589ef119dce4e4fe09e4 -r b4f9e4c9baeda6a9c9dd92bd026ca8dc86fc8afe yt/data_objects/selection_data_containers.py
--- a/yt/data_objects/selection_data_containers.py
+++ b/yt/data_objects/selection_data_containers.py
@@ -24,12 +24,13 @@
iterable, \
validate_width_tuple, \
fix_length
+from yt.geometry.selection_routines import \
+ points_in_cells
from yt.units.yt_array import \
YTArray
from yt.utilities.exceptions import \
YTSphereTooSmall, \
YTIllDefinedCutRegion, \
- YTMixedCutRegion, \
YTEllipsoidOrdering
from yt.utilities.minimal_representation import \
MinimalSliceData
@@ -793,8 +794,10 @@
for field in fields:
f = self.base_object[field]
if f.shape != ind.shape:
- raise YTMixedCutRegion(self.conditionals, field)
- self.field_data[field] = self.base_object[field][ind]
+ parent = getattr(self, "parent", self.base_object)
+ self.field_data[field] = parent[field][self._part_ind]
+ else:
+ self.field_data[field] = self.base_object[field][ind]
@property
def blocks(self):
@@ -822,6 +825,22 @@
np.logical_and(res, ind, ind)
return ind
+ _particle_mask = None
+ @property
+ def _part_ind(self):
+ if self._particle_mask is None:
+ parent = getattr(self, "parent", self.base_object)
+ units = "code_length"
+ mask = points_in_cells(
+ self["x"].to(units), self["y"].to(units),
+ self["z"].to(units), self["dx"].to(units),
+ self["dy"].to(units), self["dz"].to(units),
+ parent["particle_position_x"].to(units),
+ parent["particle_position_y"].to(units),
+ parent["particle_position_z"].to(units))
+ self._particle_mask = mask
+ return self._particle_mask
+
@property
def icoords(self):
return self.base_object.icoords[self._cond_ind,:]
diff -r e0b1c973fefe530286e6589ef119dce4e4fe09e4 -r b4f9e4c9baeda6a9c9dd92bd026ca8dc86fc8afe yt/geometry/selection_routines.pyx
--- a/yt/geometry/selection_routines.pyx
+++ b/yt/geometry/selection_routines.pyx
@@ -2046,3 +2046,42 @@
return ("halo_particles", self.halo_id)
halo_particles_selector = HaloParticlesSelector
+
+ at cython.cdivision(True)
+ at cython.boundscheck(False)
+ at cython.wraparound(False)
+def points_in_cells(
+ np.float64_t[:] cx,
+ np.float64_t[:] cy,
+ np.float64_t[:] cz,
+ np.float64_t[:] dx,
+ np.float64_t[:] dy,
+ np.float64_t[:] dz,
+ np.float64_t[:] px,
+ np.float64_t[:] py,
+ np.float64_t[:] pz):
+ # Take a list of cells and particles and calculate which particles
+ # are enclosed within one of the cells. This is used for querying
+ # particle fields on clump/contour objects.
+ # We use brute force since the cells are a relatively unordered collection.
+
+ cdef int p, c, n_p, n_c
+
+ n_p = px.size
+ n_c = cx.size
+ mask = np.ones(n_p, dtype="bool")
+
+ for p in range(n_p):
+ for c in range(n_c):
+ if fabs(px[p] - cx[c]) > 0.5 * dx[c]:
+ mask[p] = False
+ continue
+ if fabs(py[p] - cy[c]) > 0.5 * dy[c]:
+ mask[p] = False
+ continue
+ if fabs(pz[p] - cz[c]) > 0.5 * dz[c]:
+ mask[p] = False
+ continue
+ if mask[p]: break
+
+ return mask
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