flowtracks 1.8.1.dev8__tar.gz → 1.8.1.dev12__tar.gz

flowtracks-1.8.1.dev12/CONTRIBUTING.md

@@ -0,0 +1,74 @@
+# Contributing to postptv (flowtracks)
+
+## Setup
+
+```bash
+git clone https://github.com/OpenPTV/postptv.git
+cd postptv
+uv sync --group dev
+uv run pytest
+```
+
+## Module map
+
+| Module | What it does |
+|--------|-------------|
+| `flowtracks/io.py` | Read/write trajectories (HDF5, Zarr, NPZ) |
+| `flowtracks/scene.py` | HDF5 scene backend (PyTables) |
+| `flowtracks/zarr_scene.py` | Zarr scene backend (duck-typed) |
+| `flowtracks/trajectory.py` | Trajectory data model (ParticleSet, Trajectory) |
+| `flowtracks/eulerian.py` | Lagrangian→Eulerian binning, phase/ensemble averaging, derived fields |
+| `flowtracks/phase_average.py` | Phase averaging as pure Dataset→Dataset functions |
+| `flowtracks/phase_average_xr.py` | YAML-recipe phase averaging |
+| `flowtracks/post_analysis_xr.py` | YAML-recipe post-analysis (binning + averaging + derived) |
+| `flowtracks/pipeline.py` | Thin per-stage wrappers (ptv_is→Lagrangian→Eulerian) |
+| `flowtracks/combine.py` | Multi-run combination (per-run or pooled) |
+| `flowtracks/stitching.py` | Reconnect broken trajectory segments |
+| `flowtracks/smoothing.py` | Trajectory smoothing (Savitzky-Golay) |
+| `flowtracks/repair.py` | Trajectory repair (cut, attach, join) |
+| `flowtracks/writers.py` | ParaView export (VTK, VTI, VTR, VTP, PVD) |
+| `flowtracks/vortex.py` | Vortex identification (Q-criterion, lambda2) |
+| `flowtracks/interpolation.py` | RBF/IDW interpolation onto grids |
+| `flowtracks/phasing.py` | Phase bin assignment (shared with openptv-cloud) |
+| `flowtracks/analysis.py` | Trajectory-level statistics |
+| `flowtracks/flux.py` | Flux calculations |
+| `flowtracks/graphics.py` | Visualization helpers |
+| `flowtracks/nhist.py` | Normalized histograms |
+| `flowtracks/pairs.py` | Trajectory pairing |
+| `flowtracks/merge.py` | Merge trajectories |
+| `flowtracks/clean.py` | Data cleaning |
+| `flowtracks/provenance.py` | Run provenance tracking |
+| `flowtracks/format_docstrings.py` | Docstring formatting |
+
+## Key concepts
+
+- **Trajectory**: A sequence of particle positions/velocities over time, identified by `trajid`
+- **Scene**: A reader backend (HDF5 or Zarr) providing `collect(["pos", "velocity", "time"])`
+- **Eulerian grid**: Regular (x,y,z,phase) grid of mean velocities from binning particles
+- **Phase**: Position in a periodic cycle (0..N-1), assigned by `ti = ((time - base) % cycletime) // zaman`
+- **Ensemble**: Multiple runs stacked on a `set` dimension, averaged with count weighting
+- **Pooled**: All samples from all runs collected together before binning
+
+## Architecture
+
+```
+io.py / scene.py / zarr_scene.py  →  read trajectories
+         ↓
+stitching.py / repair.py / smoothing.py  →  clean trajectories
+         ↓
+eulerian.py  →  bin to Eulerian grid (per run or pooled)
+         ↓
+phase_average.py  →  phase/ensemble averaging
+         ↓
+derived_fields()  →  MKE, TKE, VSS, etc.
+         ↓
+writers.py  →  VTK/ParaView export
+```
+
+## Tests
+
+```bash
+uv run pytest                          # all tests
+uv run pytest tests/test_eulerian_grid.py  # specific
+uv run pytest --benchmark-only         # benchmarks
+```

flowtracks-1.8.1.dev12/GLOSSARY.md

@@ -0,0 +1,33 @@
+# Glossary
+
+| Term | Definition |
+|------|-----------|
+| **Trajectory** | A sequence of particle positions/velocities over time, identified by `trajid` |
+| **Particle** | A single tracked point in one frame |
+| **Frame** | One time step (image) in the sequence |
+| **Scene** | A reader backend (HDF5 `Scene` or Zarr `ZarrScene`) providing particle data |
+| **Eulerian grid** | Regular (x, y, z, phase) grid of mean velocities from binning particles |
+| **Phase** | Position in a periodic cycle (0..N-1), assigned by `ti = ((time - base) % cycletime) // zaman` |
+| **Cycle** | One complete period of a periodic flow (e.g., one heartbeat) |
+| **Bin** | A single voxel in the Eulerian grid (x, y, z, phase) |
+| **Ensemble** | Multiple runs stacked on a `set` dimension, averaged with count weighting |
+| **Pooled** | All samples from all runs collected together before binning |
+| **Chunk** | A temporal window of frames tracked independently (parallel tracking) |
+| **Shard** | A distributed chunk (one Cloud Run task) |
+| **Seam** | Boundary between two chunks where trajectories are stitched |
+| **Overlap** | Frames shared between adjacent chunks for context (default 4) |
+| **Stitch** | Merging chunk linkages into one trajectory set |
+| **Post-process** | Trajectory repair (cut, attach, join) + velocity computation + smoothing |
+| **Repair** | `flowtracks.repair.repair_trajectories`: cut bad links, attach singles, join gaps |
+| **Smoothing** | Savitzky-Golay filter applied to trajectory positions |
+| **Valid voxel** | Voxel with sample count ≥ `min_count` |
+| **par_ave2** | Sample count per voxel per phase |
+| **zaman** | Phase bin width in frames (`deltat * 2 + 1`) |
+| **fin** | Number of phase bins (`ceil(cycletime / zaman)`) |
+| **cycletime** | Frames per cycle (e.g., 4286 for 5000 fps, 70 bpm) |
+| **deltat** | Half-width of phase bin in frames |
+| **base_time** | Frame number where cycle counting starts |
+| **min_count** | Minimum samples per voxel to be considered valid |
+| **fill_value** | Value written to invalid voxels (default NaN) |
+| **VEL_VARS** | Velocity variable names: `u_ins_mean`, `v_ins_mean`, `w_ins_mean` |
+| **CF_ATTRS** | Climate and Forecast metadata attributes for Zarr/NetCDF |

{flowtracks-1.8.1.dev8 → flowtracks-1.8.1.dev12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowtracks
-Version: 1.8.1.dev8
+Version: 1.8.1.dev12
 Summary: Library for handling 3D PTV trajectory databases and Lagrangian/Eulerian turbulence post-processing.
 Author-email: Yosef Meller <yosefm@gmail.com>
 License-Expression: GPL-3.0-only AND BSD-3-Clause

{flowtracks-1.8.1.dev8 → flowtracks-1.8.1.dev12}/flowtracks/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.8.1.dev8'
-__version_tuple__ = version_tuple = (1, 8, 1, 'dev8')
+__version__ = version = '1.8.1.dev12'
+__version_tuple__ = version_tuple = (1, 8, 1, 'dev12')
 
-__commit_id__ = commit_id = 'g989f99b4c'
+__commit_id__ = commit_id = 'ga15f667b2'

{flowtracks-1.8.1.dev8 → flowtracks-1.8.1.dev12}/flowtracks/writers.py

@@ -158,19 +158,19 @@ def _is_uniform(coord: np.ndarray, rtol: float = 1e-6) -> bool:
 
 
 def _clean(values: np.ndarray) -> np.ndarray:
-    """Zero out +-Inf (which overflow the float32 VTK cast) but PRESERVE NaN.
+    """Convert +-Inf to NaN (preserving NaN) for VTK export.
 
-    NaN marks voxels with insufficient samples (counts < min_count); exporting
-    0.0 instead would make empty voxels masquerade as zero-velocity regions.
-    The ``valid`` and ``par_ave2`` fields carry the per-voxel validity and
-    sample counts so downstream tools (ParaView thresholding, etc.) can mask
-    accordingly.
+    Inf would overflow the float32 VTK cast and is not a meaningful value;
+    NaN marks both insufficient-sample voxels and any non-finite result so
+    downstream tools (ParaView thresholding, etc.) can mask them. The
+    ``valid`` and ``par_ave2`` fields carry the per-voxel validity and sample
+    counts.
     """
     values = np.asarray(values)
     if np.issubdtype(values.dtype, np.floating):
         out = values.copy()
-        out[np.isposinf(out)] = 0.0
-        out[np.isneginf(out)] = 0.0
+        out[np.isposinf(out)] = np.nan
+        out[np.isneginf(out)] = np.nan
         return out
     return values
 

{flowtracks-1.8.1.dev8 → flowtracks-1.8.1.dev12}/flowtracks.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowtracks
-Version: 1.8.1.dev8
+Version: 1.8.1.dev12
 Summary: Library for handling 3D PTV trajectory databases and Lagrangian/Eulerian turbulence post-processing.
 Author-email: Yosef Meller <yosefm@gmail.com>
 License-Expression: GPL-3.0-only AND BSD-3-Clause

{flowtracks-1.8.1.dev8 → flowtracks-1.8.1.dev12}/flowtracks.egg-info/SOURCES.txt

@@ -1,5 +1,7 @@
 .gitignore
 CLAUDE.md
+CONTRIBUTING.md
+GLOSSARY.md
 LICENSE.txt
 README.md
 RELEASE.md
@@ -455,7 +457,6 @@ data/tracers.zarr/trajectories/vel/c/2/0
 data/tracers.zarr/trajectories/vel/c/2/1
 data/tracers.zarr/trajectories/vel/c/3/0
 data/tracers.zarr/trajectories/vel/c/3/1
-doc/an_scene.rst
 doc/analysis.rst
 doc/clean.rst
 doc/conf.py
@@ -719,14 +720,12 @@ examples/visualize_marimo.py
 examples/visualize_results.py
 flowtracks/__init__.py
 flowtracks/_version.py
-flowtracks/an_scene.py
 flowtracks/analysis.py
 flowtracks/clean.py
 flowtracks/combine.py
 flowtracks/eulerian.py
 flowtracks/flux.py
 flowtracks/format_docstrings.py
-flowtracks/future_idea_xarray_dask_zarr.py
 flowtracks/graphics.py
 flowtracks/interpolation.py
 flowtracks/io.py
@@ -794,6 +793,7 @@ tests/test_stitching.py
 tests/test_streamlined_zarr_paraview.py
 tests/test_turbulent_statistics.py
 tests/test_vortex_and_wall_shear.py
+tests/test_vtk_export_nan.py
 tests/test_writers.py
 tests/test_zarr_io.py
 tests/test_zarr_pipeline_end_to_end.py

{flowtracks-1.8.1.dev8 → flowtracks-1.8.1.dev12}/flowtracks.egg-info/scm_file_list.json

@@ -4,6 +4,8 @@
     ".github/workflows/python-publish.yml",
     ".gitignore",
     "CLAUDE.md",
+    "CONTRIBUTING.md",
+    "GLOSSARY.md",
     "LICENSE.txt",
     "LICENSES/BSD-3-Clause.txt",
     "LICENSES/GPL-3.0-only.txt",
@@ -453,7 +455,6 @@
     "data/tracers/ptv_is.10200",
     "doc/_static/hdf5_scene_analysis.html",
     "doc/_static/repeated_interpolation.html",
-    "doc/an_scene.rst",
     "doc/analysis.rst",
     "doc/clean.rst",
     "doc/conf.py",
@@ -714,14 +715,12 @@
     "examples/visualize_marimo.py",
     "examples/visualize_results.py",
     "flowtracks/__init__.py",
-    "flowtracks/an_scene.py",
     "flowtracks/analysis.py",
     "flowtracks/clean.py",
     "flowtracks/combine.py",
     "flowtracks/eulerian.py",
     "flowtracks/flux.py",
     "flowtracks/format_docstrings.py",
-    "flowtracks/future_idea_xarray_dask_zarr.py",
     "flowtracks/graphics.py",
     "flowtracks/interpolation.py",
     "flowtracks/io.py",
@@ -787,6 +786,7 @@
     "tests/test_streamlined_zarr_paraview.py",
     "tests/test_turbulent_statistics.py",
     "tests/test_vortex_and_wall_shear.py",
+    "tests/test_vtk_export_nan.py",
     "tests/test_writers.py",
     "tests/test_zarr_io.py",
     "tests/test_zarr_pipeline_end_to_end.py",

{flowtracks-1.8.1.dev8 → flowtracks-1.8.1.dev12}/flowtracks.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
   "tag": "1.8.0",
-  "distance": 8,
-  "node": "g989f99b4cf7c0f880608ed4c3bb2f5ddf36a4d79",
+  "distance": 12,
+  "node": "ga15f667b26d089ae9ce7c51378387a6c200eca3e",
   "dirty": false,
   "branch": "master",
   "node_date": "2026-11-14"

flowtracks-1.8.1.dev12/tests/test_vtk_export_nan.py

@@ -0,0 +1,160 @@
+"""Tests for VTK export: NaN/Inf preservation and valid/invalid cell counts.
+
+Verifies that flowtracks.writers.write_eulerian_series:
+- Preserves NaN for voxels with insufficient samples (does not zero them)
+- Converts Inf to NaN (does not zero or overflow)
+- Correctly exports the ``valid`` field (True/False per voxel)
+- Correctly exports ``par_ave2`` (sample counts, including sub-threshold)
+- Exports all non-finite voxels as NaN in velocity fields
+"""
+
+import numpy as np
+import pytest
+import xarray as xr
+
+pytest.importorskip("pyvista")
+
+from flowtracks.writers import _clean, write_eulerian_series
+
+
+class TestCleanFunction:
+    """Unit tests for _clean helper."""
+
+    def test_nan_preserved(self):
+        arr = np.array([1.0, np.nan, 3.0])
+        out = _clean(arr)
+        assert np.isnan(out[1])
+        assert out[0] == 1.0 and out[2] == 3.0
+
+    def test_posinf_to_nan(self):
+        arr = np.array([1.0, np.inf, 3.0])
+        out = _clean(arr)
+        assert np.isnan(out[1])
+        assert out[0] == 1.0 and out[2] == 3.0
+
+    def test_neginf_to_nan(self):
+        arr = np.array([1.0, -np.inf, 3.0])
+        out = _clean(arr)
+        assert np.isnan(out[1])
+        assert out[0] == 1.0 and out[2] == 3.0
+
+    def test_finite_unchanged(self):
+        arr = np.array([1.0, 2.0, 3.0])
+        out = _clean(arr)
+        np.testing.assert_array_equal(out, arr)
+
+    def test_non_float_passthrough(self):
+        arr = np.array([1, 2, 3], dtype=np.int64)
+        out = _clean(arr)
+        np.testing.assert_array_equal(out, arr)
+        assert out.dtype == arr.dtype
+
+    def test_bool_passthrough(self):
+        arr = np.array([True, False, True])
+        out = _clean(arr)
+        np.testing.assert_array_equal(out, arr)
+        assert out.dtype == arr.dtype
+
+    def test_mixed_nonfinite(self):
+        arr = np.array([1.0, np.nan, np.inf, -np.inf, 5.0])
+        out = _clean(arr)
+        assert out[0] == 1.0
+        assert np.isnan(out[1]) and np.isnan(out[2]) and np.isnan(out[3])
+        assert out[4] == 5.0
+
+
+def _make_dataset_with_invalid_voxels():
+    """Dataset with one voxel below min_count (NaN velocity, count=2, valid=False)."""
+    x = np.array([0.0, 1.0])
+    y = np.array([0.0, 1.0])
+    z = np.array([0.0, 1.0])
+    phase = np.array([0])
+
+    u = np.ones((2, 2, 2, 1)) * 1.0
+    u[0, 0, 0, 0] = np.nan  # insufficient samples
+    v = np.ones((2, 2, 2, 1)) * 2.0
+    w = np.ones((2, 2, 2, 1)) * 3.0
+    # par_ave2: actual counts (1 for invalid voxel, 5 for valid)
+    counts = np.array([[[[1], [5]], [[5], [5]]], [[[5], [5]], [[5], [5]]]])
+    valid = counts >= 4
+
+    return xr.Dataset(
+        {
+            "u_ins_mean": (("x", "y", "z", "phase"), u),
+            "v_ins_mean": (("x", "y", "z", "phase"), v),
+            "w_ins_mean": (("x", "y", "z", "phase"), w),
+            "par_ave2": (("x", "y", "z", "phase"), counts),
+            "valid": (("x", "y", "z", "phase"), valid),
+        },
+        coords={"x": x, "y": y, "z": z, "phase": phase},
+    ), counts, valid
+
+
+class TestVtkExportNanPreservation:
+    """Integration tests for VTK export NaN/Inf and valid/invalid handling."""
+
+    def test_nan_preserved_in_velocity(self, tmp_path):
+        ds, counts, valid = _make_dataset_with_invalid_voxels()
+        write_eulerian_series(ds, tmp_path, prefix="test")
+        import pyvista as pv
+
+        grid = pv.read(str(tmp_path / "test_0000.vti"))
+        vel = grid.point_data["velocity"]
+        nan_count = np.isnan(vel).any(axis=1).sum()
+        assert nan_count == 1, f"Expected 1 NaN voxel, got {nan_count}"
+
+    def test_valid_field_exported(self, tmp_path):
+        ds, counts, valid = _make_dataset_with_invalid_voxels()
+        write_eulerian_series(ds, tmp_path, prefix="test")
+        import pyvista as pv
+
+        grid = pv.read(str(tmp_path / "test_0000.vti"))
+        exported_valid = grid.point_data["valid"]
+        assert exported_valid.dtype == bool or exported_valid.dtype == np.bool_
+        assert not exported_valid[0], "Invalid voxel should be False"
+        assert exported_valid[1:].all(), "Valid voxels should be True"
+
+    def test_par_ave2_counts_exported(self, tmp_path):
+        ds, counts, valid = _make_dataset_with_invalid_voxels()
+        write_eulerian_series(ds, tmp_path, prefix="test")
+        import pyvista as pv
+
+        grid = pv.read(str(tmp_path / "test_0000.vti"))
+        exported_counts = grid.point_data["par_ave2"]
+        # Invalid voxel should show actual count (1), not 0
+        assert exported_counts[0] == 1, f"Expected count 1 for invalid voxel, got {exported_counts[0]}"
+        assert exported_counts[1] == 5, f"Expected count 5 for valid voxel, got {exported_counts[1]}"
+
+    def test_inf_converted_to_nan(self, tmp_path):
+        x = np.array([0.0, 1.0])
+        y = np.array([0.0, 1.0])
+        z = np.array([0.0, 1.0])
+        phase = np.array([0])
+
+        u = np.array([[[[np.inf], [1.0]], [[2.0], [3.0]]], [[[4.0], [5.0]], [[6.0], [7.0]]]])
+        v = np.ones((2, 2, 2, 1)) * 2.0
+        w = np.ones((2, 2, 2, 1)) * 3.0
+
+        ds = xr.Dataset(
+            {"u_ins_mean": (("x", "y", "z", "phase"), u),
+             "v_ins_mean": (("x", "y", "z", "phase"), v),
+             "w_ins_mean": (("x", "y", "z", "phase"), w)},
+            coords={"x": x, "y": y, "z": z, "phase": phase},
+        )
+        write_eulerian_series(ds, tmp_path, prefix="test")
+        import pyvista as pv
+
+        grid = pv.read(str(tmp_path / "test_0000.vti"))
+        vel = grid.point_data["velocity"]
+        assert np.isnan(vel[0, 0]), "Inf should be converted to NaN"
+
+    def test_all_fields_present(self, tmp_path):
+        ds, counts, valid = _make_dataset_with_invalid_voxels()
+        write_eulerian_series(ds, tmp_path, prefix="test")
+        import pyvista as pv
+
+        grid = pv.read(str(tmp_path / "test_0000.vti"))
+        assert "velocity" in grid.point_data
+        assert "par_ave2" in grid.point_data
+        assert "valid" in grid.point_data
+        # VEL_VARS are combined into "velocity", not written separately

flowtracks-1.8.1.dev8/doc/an_scene.rst

@@ -1,6 +0,0 @@
-
-Handling of Analysis Results
-============================
-
-.. automodule:: flowtracks.an_scene
-   :members:

flowtracks-1.8.1.dev8/flowtracks/an_scene.py

@@ -1,211 +0,0 @@
-# SPDX-License-Identifier: GPL-3.0-only
-# SPDX-FileCopyrightText: Yosef Meller, Alex Liberzon
-# -*- coding: utf-8 -*-
-
-import numpy as np
-
-try:
-    import tables
-except ImportError:  # optional legacy dependency; zarr paths do not need it
-    tables = None
-
-from .scene import gen_query_string, read_dual_scene
-from .trajectory import Trajectory
-
-
-class AnalysedScene(object):
-    """
-    A class for accessing data and analyses of a scene analysed and saved in
-    the format used by flowtracks.analysis.analyse().
-    """
-
-    def __init__(self, analysis_file):
-        """
-        Initializes the objects according to config and data-source metadata
-        saved in the analysis file.
-
-        Arguments:
-        analysis_file - path to the HDF file containing analysis results.
-        """
-        if tables is None:
-            raise ImportError(
-                "PyTables ('tables') is required for the legacy AnalysedScene. "
-                "The project now uses Zarr; install the 'legacy-io' extra "
-                "only if you need the old format."
-            )
-        self._file = tables.open_file(analysis_file, "r")
-        self._table = self._file.get_node('/analysis')
-
-        config = self._table.attrs['config']
-        self._scene = read_dual_scene(config)
-
-        # Cache data on user-visible columsn:
-        filt = ('trajid', 'time')
-        self._keys = []
-        self._shapes = []
-        desc = self._table.coldescrs
-        for name in self._table.colnames:
-            if name in filt:
-                continue
-            self._keys.append(name)
-            shape = desc[name].shape
-            self._shapes.append(1 if len(shape) == 0 else shape[0])
-
-    def __del__(self):
-        self._file.close()
-
-    def keys(self):
-        """
-        Return names that may be used to access data in any of the data sources
-        available, whether analyses or inertial particles.
-        """
-        return list(self._scene.get_particles().keys()) + self._keys
-
-    def shapes(self):
-        """
-        Return the number of components per item of each key in the order
-        returned by :meth:`keys`.
-        """
-        return self._scene.get_particles().shapes() + self._shapes
-
-    def _iter_frame_arrays(self, cond=None):
-        """
-        Private. Breaks the file down to its frames, and makes arrays of
-        them, iteratively. Also allows filtering the frames.
-
-        Arguments:
-        cond - an optional PyTables condition string to AND into the single
-            read performed over the whole frame range.
-        """
-        first, last = self._scene.get_range()
-        read_cond = "(time >= %d) & (time < %d)" % (first, last)
-        if cond is not None:
-            read_cond = "(%s) & (%s)" % (read_cond, cond)
-
-        arr = self._table.read_where(read_cond)
-        order = np.argsort(arr['time'], kind='stable')
-        arr = arr[order]
-        bounds = np.flatnonzero(np.diff(arr['time'])) + 1
-        groups = np.split(arr, bounds)
-        by_time = {int(g['time'][0]): g for g in groups}
-        empty = arr[0:0]
-
-        for t in range(first, last):
-            yield t, by_time.get(t, empty)
-
-    def collect(self, keys, where=None):
-        """
-        Get values of a given key, either some of them or the ones
-        corresponding to a selection given by 'where'
-
-        Arguments:
-        keys - a list of keys to take from the data
-        where - a dictionary of derived-results keys, with a tuple
-            (min,max,invert) as values. If ``invert`` is false, the search
-            range is between min and max. Otherwise it is anywhere except that.
-
-        Returns:
-        a list of arrays, in the order of ``keys``.
-        """
-        # Divide the where condition into the trajectory conditions and
-        # analysis conditions.
-        part_cond = None
-        an_cond = None
-
-        pkeys = set(self._scene.get_particles().keys())
-        if where is not None:
-            pc_add = []
-            an_cond_add = []
-
-            for key, rng in where.items():
-                cond_string = gen_query_string(key, rng)
-                if key in pkeys:
-                    pc_add.append(cond_string)
-                else:
-                    an_cond_add.append(cond_string)
-
-            if len(pc_add) != 0:
-                part_cond = ' & '.join(pc_add)
-            if len(an_cond_add) != 0:
-                an_cond = ' & '.join(an_cond_add)
-
-        # Iterate over dual frame, each from the right source using the
-        # divided conditions.
-        res = dict((k, []) for k in keys)
-
-        dframe_it = zip(
-            self._scene.get_particles()._iter_frame_arrays(part_cond),
-            self._iter_frame_arrays(an_cond))
-
-        for tr_frm, an_frm in dframe_it:
-            # Cross reference matching rows.
-            tp, p_arr = tr_frm
-            ta, a_arr = an_frm
-
-            p_trids = p_arr['trajid']
-            a_trids = a_arr['trajid']
-            trajids = np.intersect1d(p_trids, a_trids, assume_unique=True)
-
-            # select only those from the two frames:
-            in_p = np.isin(p_trids, trajids, assume_unique=True)
-            in_a = np.isin(a_trids, trajids, assume_unique=True)
-
-            if len(in_p) > 0:
-                p_arr = p_arr[in_p]
-            if len(a_arr) > 0:
-                a_arr = a_arr[in_a]
-
-            # For each dual frame, add the columns of specified keys to the list
-            # of that key's results
-            for k in keys:
-                if k in pkeys:
-                    res[k].append(p_arr[k])
-                else:
-                    res[k].append(a_arr[k])
-
-        # stack and return.
-        return [np.concatenate(res[k], axis=0) for k in keys]
-
-    def trajectory_by_id(self, trid):
-        """
-        Retrieves an inertial trajectory with the respective analysis.
-        See ``iter_trajectories`` for the full documentation.
-
-        Arguments:
-        trid - trajectory ID to fetch.
-
-        Returns:
-        a Trajectory object with analysis keys added.
-        """
-        traj = self._scene.get_particles().trajectory_by_id(trid)
-
-        # Trim last point of trajectory to match analysis:
-        kwds = dict((k, v[:-1]) for k, v in traj.as_dict().items())
-        kwds['trajid'] = trid
-
-        # Fetch by foreign key from analysis:
-        query_string = '(trajid == trid)'
-        arr = self._table.read_where(query_string)
-
-        # Update into the Trajectory object:
-        for field in arr.dtype.fields:
-            if field not in ['trajid', 'time']:
-                kwds[field] = arr[field]
-
-        return Trajectory(**kwds)
-
-    def iter_trajectories(self):
-        """
-        Iterator over inertial trajectories. Since the analysis is structured
-        around the inertial particles of the internal DualScene, it is possible
-        to iterate those trajectories, adding the corresponding fields of
-        analysis to the same object. Generates a Trajectory object for each
-        inertial particle trajectory in the particles file (in no particular
-        order, but the same order every time on the same PyTables version) and
-        yields it.
-
-        Note: since analysis works on segments, it truncates the last point of
-        each trajectory.
-        """
-        for trid in self._scene.get_particles().trajectory_ids():
-            yield self.trajectory_by_id(trid)