pytecplot 1.5.2__py3-none-any.whl

tecplot/plot/streamtrace.py

@@ -0,0 +1,1949 @@
+from builtins import int
+
+import collections
+import ctypes
+
+from ..tecutil import _tecutil
+from ..constant import *
+from ..exception import *
+from ..tecutil import Index, IndexSet, color_spec, lock, sv
+from .. import session, tecutil, version
+from . import symbol
+
+
+class StreamtraceStyle(session.Style):
+    def __init__(self, streamtrace, *sv_args):
+        self.streamtrace = streamtrace
+        kw = dict(uniqueid=streamtrace.plot.frame.uid)
+        super().__init__(streamtrace._sv, *sv_args, **kw)
+
+
+class StreamtraceTiming(StreamtraceStyle):
+    """Timed markers for streamlines.
+
+    Use `StreamtraceTiming` to control timed markers for streamlines, and timed
+    dashes for all types of streamtraces. Stream markers are drawn at time
+    locations along streamlines. The spacing between stream markers is
+    proportional to the magnitude of the local vector field:
+
+    .. code-block:: python
+        :emphasize-lines: 22-24
+
+        import tecplot
+        from tecplot.constant import *
+        import os
+
+        examples_dir = tecplot.session.tecplot_examples_directory()
+        datafile = os.path.join(examples_dir, 'SimpleData', 'VortexShedding.plt')
+        dataset = tecplot.data.load_tecplot(datafile)
+
+        frame = tecplot.active_frame()
+        frame.plot_type = tecplot.constant.PlotType.Cartesian2D
+
+        plot = frame.plot()
+        plot.vector.u_variable = dataset.variable('U(M/S)')
+        plot.vector.v_variable = dataset.variable('V(M/S)')
+        plot.show_streamtraces = True
+        plot.show_shade = True
+        plot.fieldmap(0).shade.color = Color.LightBlue
+
+
+        streamtraces = plot.streamtraces
+        streamtraces.show_markers = True
+        timing = streamtraces.timing
+        timing.anchor = 0
+        timing.delta = 0.0001
+
+        streamtraces.marker_size = 1.5
+        streamtraces.marker_symbol().shape =GeomShape.RTri
+        streamtraces.marker_color = Color.Mahogany
+
+        streamtraces.add_rake(start_position=(-0.003, 0.005),
+                              end_position=(-0.003, -0.005),
+                              stream_type=Streamtrace.TwoDLine,
+                              num_seed_points=10)
+
+
+        plot.axes.y_axis.min = -0.02
+        plot.axes.y_axis.max = 0.02
+        plot.axes.x_axis.min = -0.008
+        plot.axes.x_axis.max = 0.04
+
+        tecplot.export.save_png('streamtrace_timing.png', 600, supersample=3)
+
+    .. figure:: /_static/images/streamtrace_timing.png
+        :width: 300px
+        :figwidth: 300px
+
+    """
+
+    def __init__(self, streamtrace):
+        super().__init__(streamtrace, sv.STREAMTIMING)
+
+    @lock()
+    def reset_delta(self):
+        """Reset the time delta for dashed streamtraces.
+
+
+        The delta time is reset such that a stream dash in the vicinity of
+        the maximum vector magnitude will have a length approximately equal
+        to 10 percent of the frame width.
+
+        Raises:
+            `TecplotSystemError`: Streamtraces time delta could not be reset.
+
+        Example usage::
+
+            >>> plot.streamtraces.timing.reset_delta()
+        """
+        with self.streamtrace.plot.frame.activated():
+            if not _tecutil.StreamtraceResetDelta():
+                raise TecplotSystemError()
+
+    @property
+    def _show_dashes(self):
+        return self._get_style(bool, sv.SHOWDASHES)
+
+    @_show_dashes.setter
+    def _show_dashes(self, value):
+        self._set_style(bool(value), sv.SHOWDASHES)
+
+    @property
+    def _show_markers(self):
+        return self._get_style(bool, sv.SHOWMARKERS)
+
+    @_show_markers.setter
+    def _show_markers(self, value):
+        self._set_style(bool(value), sv.SHOWMARKERS)
+
+    @property
+    def _marker_color(self):
+        return color_spec(self._get_style(Color, sv.MARKCOLOR),
+                          self.streamtrace.plot)
+
+    @_marker_color.setter
+    def _marker_color(self, value):
+        self._set_style(color_spec(value), sv.MARKCOLOR)
+
+    @property
+    def _marker_size(self):
+        return self._get_style(float, sv.MARKSIZE)
+
+    @_marker_size.setter
+    def _marker_size(self, value):
+        self._set_style(float(value), sv.MARKSIZE)
+
+    @property
+    def _dash_skip(self):
+        return self._get_style(int, sv.DASHSKIP)
+
+    @_dash_skip.setter
+    def _dash_skip(self, value):
+        self._set_style(int(value), sv.DASHSKIP)
+
+    @property
+    def _marker_symbol_type(self):
+        return symbol.Symbol(self, sv.MARKSYMBOL)._symbol_type
+
+    @_marker_symbol_type.setter
+    def _marker_symbol_type(self, value):
+        symbol.Symbol(self, sv.MARKSYMBOL)._symbol_type = value
+
+    def _marker_symbol(self, symbol_type=None):
+        _dispatch = {
+            SymbolType.Text: symbol.TextSymbol,
+            SymbolType.Geometry: symbol.GeometrySymbol}
+        return _dispatch[symbol_type or self._marker_symbol_type](
+            self, sv.MARKSYMBOL)
+
+    @property
+    def start(self):
+        """`float`: Time at which the first marker should be drawn.
+
+        A start time of zero means that the first marker is drawn at the
+        starting point. A start time of 2.5 means that the first stream
+        marker is drawn 2.5 time units downstream of the starting point.
+
+        Example usage::
+
+            >>> plot.streamtraces.timing.start = 2.5
+        """
+        return self._get_style(float, sv.TIMESTART)
+
+    @start.setter
+    def start(self, value):
+        self._set_style(float(value), sv.TIMESTART)
+
+    @property
+    def end(self):
+        """`float`: Time after which no stream markers are drawn.
+
+        Example usage::
+
+            >>> plot.streamtraces.timing.end = 3.0
+        """
+        return self._get_style(float, sv.TIMEEND)
+
+    @end.setter
+    def end(self, value):
+        self._set_style(float(value), sv.TIMEEND)
+
+    @property
+    def anchor(self):
+        """`float`: Time that a dash is guaranteed to start.
+
+        A dash is guaranteed to start at `anchor`, provided the start
+        and end time surround the dash.
+
+        Example usage::
+
+            >>> plot.streamtraces.timing.anchor = 1.1
+        """
+        return self._get_style(float, sv.TIMEANCHOR)
+
+    @anchor.setter
+    def anchor(self, value):
+        self._set_style(float(value), sv.TIMEANCHOR)
+
+    @property
+    def delta(self):
+        """`float`: Time between stream markers.
+
+        `delta` is the time interval that measures the time between
+        stream markers. The actual distance between markers is the product
+        of this number and the local `Vector` magnitude.
+
+        Call `StreamtraceTiming.reset_delta()` to reset this to the default.
+
+        Example usage::
+
+            >>> plot.streamtraces.timing.delta = 0.1
+        """
+        return self._get_style(float, sv.TIMEDELTA)
+
+    @delta.setter
+    def delta(self, value):
+        self._set_style(float(value), sv.TIMEDELTA)
+
+
+class StreamtraceTerminationLine(StreamtraceStyle):
+    """Streamtraces termination line attributes.
+
+    A streamtrace termination line is a polyline that terminates any
+    streamtraces that cross it. The termination line is useful for stopping
+    streamtraces before they spiral or stall.
+
+    .. note::
+        Before setting any `StreamtraceTerminationLine` properties, you must
+        `add a termination line <set_termination_line>`.
+
+    Streamtraces are terminated whenever any of the following occur:
+
+        * The maximum number of integration steps is reached.
+        * Any point where a streamtrace passes outside the available data.
+        * The streamtrace reaches a point where the velocity magnitude is zero.
+
+    .. code-block:: python
+        :emphasize-lines: 19-29
+
+        import tecplot
+        from tecplot.constant import *
+        import os
+
+        examples_dir = tecplot.session.tecplot_examples_directory()
+        datafile = os.path.join(examples_dir, 'SimpleData', 'VortexShedding.plt')
+        dataset = tecplot.data.load_tecplot(datafile)
+
+        frame = tecplot.active_frame()
+        frame.plot_type = tecplot.constant.PlotType.Cartesian2D
+
+        plot = frame.plot()
+        plot.vector.u_variable = dataset.variable('U(M/S)')
+        plot.vector.v_variable = dataset.variable('V(M/S)')
+        plot.show_streamtraces = True
+        plot.show_shade = True
+        plot.fieldmap(0).shade.color = Color.LightBlue
+
+        streamtraces = plot.streamtraces
+        streamtraces.set_termination_line([(0.03, 0.005),
+                                           (0.03, -0.005), ])
+
+        term_line = streamtraces.termination_line
+        term_line.active = True
+        term_line.show = True
+        term_line.color = Color.Red
+        term_line.line_pattern = LinePattern.Dashed
+        term_line.pattern_length = .5
+        term_line.line_thickness = .5
+
+        streamtraces.add_rake(start_position=(-0.003, 0.005),
+                              end_position=(-0.003, -0.005),
+                              stream_type=Streamtrace.TwoDLine,
+                              num_seed_points=10)
+
+        plot.axes.y_axis.min = -0.02
+        plot.axes.y_axis.max = 0.02
+        plot.axes.x_axis.min = -0.01
+        plot.axes.x_axis.max = 0.04
+
+        tecplot.export.save_png('streamtrace_term_line.png', 600, supersample=3)
+
+    .. figure:: /_static/images/streamtrace_term_line.png
+        :width: 300px
+        :figwidth: 300px
+    """
+
+    def __init__(self, streamtrace):
+        super().__init__(streamtrace, sv.TERMLINE)
+
+    @property
+    def active(self):
+        """`bool`: Activate/disable the streamtrace termination line.
+
+        Set to `True` to activate the termination line and terminate any
+        streamtraces that cross it. Set to `False` and redraw the plot
+        with unterminated streamtraces.
+
+        .. note::
+            To display the termination line itself, set `show` to `True`.
+
+        Example usage::
+
+            >>> plot.streamtraces.termination_line.active = True
+        """
+        return self._get_style(bool, sv.ISACTIVE)
+
+    @active.setter
+    def active(self, value):
+        self._set_style(bool(value), sv.ISACTIVE)
+
+    @property
+    def is_active(self):
+        tecutil.api_moved('StreamtraceTerminationLine.is_active',
+                          'StreamtraceTerminationLine.active',
+                          '0.13', '2018 R2')
+
+    @is_active.setter
+    def is_active(self, value):
+        tecutil.api_moved('StreamtraceTerminationLine.is_active',
+                          'StreamtraceTerminationLine.active',
+                          '0.13', '2018 R2')
+
+    @property
+    def show(self):
+        """`bool`: Display the termination line.
+
+        Set to `True` to display the termination line. Set to `False` and
+        redraw the plot to display terminated streamlines (if `active` is
+        set to `True`), but not the termination line itself.
+
+        .. note::
+            To display terminated streamtraces, `active` must be set to
+            `True`.
+
+        Example usage::
+
+            >>> plot.streamtraces.termination_line.show = True
+        """
+        return self._get_style(bool, sv.SHOW)
+
+    @show.setter
+    def show(self, value):
+        self._set_style(bool(value), sv.SHOW)
+
+    @property
+    def color(self):
+        """`Color`: Color of the termination line.
+
+        Example usage::
+
+            >>> plot.streamtraces.termination_line.color = Color.Red
+        """
+        return self._get_style(Color, sv.COLOR)
+
+    @color.setter
+    def color(self, value):
+        self._set_style(Color(value), sv.COLOR)
+
+    @property
+    def line_pattern(self):
+        """`LinePattern`: Pattern of the terminating line.
+
+        Example usage::
+
+            >>> plot.streamtraces.termination_line.line_pattern = LinePattern.Dotted
+        """
+        return self._get_style(LinePattern, sv.LINEPATTERN)
+
+    @line_pattern.setter
+    def line_pattern(self, value):
+        self._set_style(LinePattern(value), sv.LINEPATTERN)
+
+    @property
+    def pattern_length(self):
+        """`float`: Length of the pattern as a percentage of frame height.
+
+        Example usage::
+
+            >>> plot.streamtraces.termination_line.pattern_length = 2
+        """
+        return self._get_style(float, sv.PATTERNLENGTH)
+
+    @pattern_length.setter
+    def pattern_length(self, value):
+        self._set_style(float(value), sv.PATTERNLENGTH)
+
+    @property
+    def line_thickness(self):
+        """`float`: Thickness of the termination line as a percentage of frame height.
+
+        Example usage::
+
+            >>> plot.streamtraces.termination_line.line_thickness = 0.1
+        """
+        return self._get_style(float, sv.LINETHICKNESS)
+
+    @line_thickness.setter
+    def line_thickness(self, value):
+        self._set_style(float(value), sv.LINETHICKNESS)
+
+
+class StreamtraceRodRibbonMesh(StreamtraceStyle):
+    """Streamtraces rod/ribbon mesh attributes.
+
+    .. note::
+        To set the mesh color or line thickness, see `Streamtraces.color`
+        and `Streamtraces.line_thickness`.
+
+    .. code-block:: python
+        :emphasize-lines: 25-28
+
+        import os
+        import tecplot
+        from tecplot.constant import *
+
+        examples_dir = tecplot.session.tecplot_examples_directory()
+        datafile = os.path.join(examples_dir, 'SimpleData', 'DownDraft.plt')
+        dataset = tecplot.data.load_tecplot(datafile)
+
+        frame = tecplot.active_frame()
+        frame.plot_type = tecplot.constant.PlotType.Cartesian3D
+
+        plot = frame.plot()
+        plot.fieldmap(0).surfaces.surfaces_to_plot = SurfacesToPlot.BoundaryFaces
+        plot.show_mesh = False
+        plot.show_shade = False
+        plot.show_edge = True
+
+        plot.vector.u_variable_index = 4
+        plot.vector.v_variable_index = 5
+        plot.vector.w_variable_index = 6
+        plot.show_streamtraces = True
+
+        ribbon = plot.streamtraces.rod_ribbon
+        ribbon.width = .008
+        ribbon.mesh.show = True
+        ribbon.mesh.line_thickness = 0.2
+        #Ribbon mesh color inherited from streamtrace color
+        plot.streamtraces.color = Color.AquaGreen
+
+        plot.streamtraces.add_rake(
+            start_position=(0, 0.22, 0),
+            end_position=(0, 0.22, 0.1),
+            stream_type=Streamtrace.VolumeRibbon)
+
+        plot.view.width = 0.644
+        plot.view.alpha = 66.4
+        plot.view.theta = -122.4
+        plot.view.psi   = 124.5
+        plot.view.position = (5.3, 3.56, -4.3)
+
+        tecplot.export.save_png('streamtrace_ribbon_mesh.png', 600, supersample=3)
+
+    .. figure:: /_static/images/streamtrace_ribbon_mesh.png
+        :width: 300px
+        :figwidth: 300px
+
+    """
+    def __init__(self, robribbon):
+        super().__init__(robribbon, sv.MESH)
+        self.streamtrace = robribbon.streamtrace
+
+    @property
+    def show(self):
+        """`bool`: Display mesh.
+
+        .. note::
+
+            The mesh color for streamtraces is determined by the line color.
+
+        Example usage::
+
+            >>> plot.streamtraces.rod_ribbon.mesh.show = True
+        """
+        return self._get_style(bool, sv.SHOW)
+
+    @show.setter
+    def show(self, value):
+        self._set_style(bool(value), sv.SHOW)
+
+    @property
+    def line_thickness(self):
+        """`float`: Get/Set streamtrace rod/ribbon mesh line thickness as a
+        percentage of frame height.
+
+        Typical values are **.02, .1, .4, .8, 1.5**
+
+        Example usage::
+
+            >>> plot.streamtraces.rod_ribbon.mesh.line_thickness = 0.2
+        """
+        return self.streamtrace._get_style(float, sv.LINETHICKNESS)
+
+    @line_thickness.setter
+    def line_thickness(self, value):
+        self.streamtrace._set_style(float(value), sv.LINETHICKNESS)
+
+
+class StreamtraceRodRibbonContour(StreamtraceStyle):
+    """Contour flooding display for streamtrace rod/ribbons.
+
+    .. code-block:: python
+        :emphasize-lines: 15-16,28-29
+
+        import os
+        import numpy as np
+        import tecplot
+        from tecplot.constant import *
+
+        examples_dir = tecplot.session.tecplot_examples_directory()
+        datafile = os.path.join(examples_dir, 'SimpleData', 'DownDraft.plt')
+        dataset = tecplot.data.load_tecplot(datafile)
+
+        frame = tecplot.active_frame()
+        frame.plot_type = tecplot.constant.PlotType.Cartesian3D
+
+        plot = frame.plot()
+        plot.fieldmap(0).surfaces.surfaces_to_plot = SurfacesToPlot.BoundaryFaces
+        plot.contour(0).variable = dataset.variable(3)
+        plot.contour(0).levels.reset_levels(np.linspace(1.15,1.25,11))
+        plot.show_mesh = False
+        plot.show_shade = False
+        plot.show_edge = True
+
+        plot.vector.u_variable_index = 4
+        plot.vector.v_variable_index = 5
+        plot.vector.w_variable_index = 6
+        plot.show_streamtraces = True
+
+        rod = plot.streamtraces.rod_ribbon
+        rod.width = .008
+        rod.contour.show = True
+        rod.contour.use_lighting_effect = True
+
+        plot.streamtraces.add_rake(
+            start_position=(0, 0.22, 0),
+            end_position=(0, 0.22, 0.1),
+            stream_type=Streamtrace.VolumeRod)
+
+        plot.view.width = 0.644
+        plot.view.alpha = 66.4
+        plot.view.theta = -122.4
+        plot.view.psi   = 124.5
+        plot.view.position = (5.3, 3.56, -4.3)
+
+        tecplot.export.save_png('streamtrace_rod_contour.png', 600, supersample=3)
+
+    .. figure:: /_static/images/streamtrace_rod_contour.png
+        :width: 300px
+        :figwidth: 300px
+    """
+
+    def __init__(self, streamtrace):
+        super().__init__(streamtrace, sv.CONTOUR)
+
+    @property
+    def use_lighting_effect(self):
+        """`bool`: Enable lighting effect for streamtrace rod/ribbons.
+
+        .. note::
+            Setting `StreamtraceRodRibbonContour.use_lighting_effect` will also set
+            the same value for `StreamtraceRodRibbonShade.use_lighting_effect`,
+            and vice-versa.
+
+        The lighting effect is set with `StreamtraceRodRibbonEffects.lighting_effect`, and may
+        be one of `LightingEffect.Gouraud` or `LightingEffect.Paneled`.
+
+        Example usage::
+
+            >>> ribbon = plot.streamtraces.rod_ribbon
+            >>> contour = ribbon.contour
+            >>> contour.use_lighting_effect = True
+            >>> ribbon.effects.lighting_effect = LightingEffect.Paneled
+        """
+        return self._get_style(bool, sv.USELIGHTINGEFFECT)
+
+    @use_lighting_effect.setter
+    def use_lighting_effect(self, value):
+        self._set_style(bool(value), sv.USELIGHTINGEFFECT)
+
+    @property
+    def show(self):
+        """`bool`: Enable or disable contour flooding display.
+
+        Example usage::
+
+            >>> plot.streamtraces.rod_ribbon.contour.show = True
+        """
+        return self._get_style(bool, sv.SHOW)
+
+    @show.setter
+    def show(self, value):
+        self._set_style(bool(value), sv.SHOW)
+
+    @property
+    def flood_contour_group_index(self):
+        """`Index` (zero-based index): The `Index` of the `ContourGroup` to use for flooding.
+
+        This property sets and gets, by `Index`, the `ContourGroup` used for
+        flooding. Changing style on this `ContourGroup` will affect all
+        fieldmaps on the same `Frame <layout.Frame>` that use it.
+
+        Example usage::
+
+            >>> contour = plot.streamtraces.rod_ribbon.contour
+            >>> contour.flood_contour_group_index = 0  # First contour group
+        """
+        return self._get_style(Index, sv.FLOODCOLORING)
+
+    @flood_contour_group_index.setter
+    def flood_contour_group_index(self, index):
+        self._set_style(Index(index), sv.FLOODCOLORING)
+
+    @property
+    def flood_contour_group(self):
+        """`ContourGroup`: Contour group to use for flooding.
+
+        This property sets and gets the ContourGroup used for flooding.
+        Changing style on this `ContourGroup` will affect all fieldmaps on
+        the same `Frame <layout.Frame>` that use it.
+
+        Example usage::
+
+            >>> group = plot.contour(1)
+            >>> contour = plot.streamtraces.rod_ribbon.contour
+            >>> contour.flood_contour_group = group
+        """
+        return self.streamtrace.plot.contour(self.flood_contour_group_index)
+
+    @flood_contour_group.setter
+    def flood_contour_group(self, flood_contour_group):
+        self.flood_contour_group_index = flood_contour_group.index
+
+
+class StreamtraceRodRibbonShade(StreamtraceStyle):
+    """Color and lighting display for rod/ribbons.
+
+    .. code-block:: python
+        :emphasize-lines: 25-29
+
+        import os
+        import tecplot
+        from tecplot.constant import *
+
+        examples_dir = tecplot.session.tecplot_examples_directory()
+        datafile = os.path.join(examples_dir, 'SimpleData', 'DuctFlow.plt')
+        dataset = tecplot.data.load_tecplot(datafile)
+
+        frame = tecplot.active_frame()
+        frame.plot_type = tecplot.constant.PlotType.Cartesian3D
+
+        plot = frame.plot()
+        plot.show_mesh = False
+        plot.show_shade = False
+        plot.show_edge = True
+        plot.fieldmap(0).edge.edge_type = EdgeType.Creases
+
+        plot.vector.u_variable_index = 3
+        plot.vector.v_variable_index = 4
+        plot.vector.w_variable_index = 5
+
+        plot.show_streamtraces = True
+        plot.streamtraces.show_paths = True
+
+        ribbon = plot.streamtraces.rod_ribbon
+        ribbon.shade.show = True
+        ribbon.shade.color = Color.Blue
+        ribbon.shade.use_lighting_effect = True
+        ribbon.width = .03
+
+
+        plot.streamtraces.add_rake(start_position=(1.5, 0, .45),
+                                   end_position=(1.5, 1, 0),
+                                   stream_type=Streamtrace.VolumeRibbon)
+
+        tecplot.export.save_png('streamtrace_ribbon_shade.png', 600, supersample=3)
+
+    .. figure:: /_static/images/streamtrace_ribbon_shade.png
+        :width: 300px
+        :figwidth: 300px
+    """
+    def __init__(self, streamtrace):
+        super().__init__(streamtrace, sv.SHADE)
+
+    @property
+    def show(self):
+        """`bool`: Show shade attributes.
+
+        Example usage::
+
+            >>> plot.streamtraces.rod_ribbon.shade.show = True
+        """
+        return self._get_style(bool, sv.SHOW)
+
+    @show.setter
+    def show(self, value):
+        self._set_style(bool(value), sv.SHOW)
+
+    @property
+    def color(self):
+        """`Color`: Shade color.
+
+        `Color.MultiColor` and `Color.RGBColor` coloring are not available.
+        Use flooded contours for multi-color or RGB flooding.
+
+        Example usage::
+
+            >>> plot.streamtraces.rod_ribbon.shade.show = True
+            >>> plot.streamtraces.rod_ribbon.shade.color = Color.Blue
+        """
+        return self._get_style(Color, sv.COLOR)
+
+    @color.setter
+    def color(self, value):
+        self._set_style(Color(value), sv.COLOR)
+
+    @property
+    def use_lighting_effect(self):
+        """`bool`: Use lighting effect.
+
+        When set to `True`, the lighting effect may be selected with the
+        `SliceEffects.lighting_effect` attribute.
+
+        .. note::
+            Setting `SliceShade.use_lighting_effect` will also set
+            the same value for `SliceContour.use_lighting_effect`,
+            and vice-versa.
+
+        Example usage::
+
+            >>> plot.streamtraces.rod_ribbon.shade.use_lighting_effect = True
+            >>> plot.streamtraces.rod_ribbon.effects.lighting_effect = LightingEffect.Paneled
+        """
+        return self._get_style(bool, sv.USELIGHTINGEFFECT)
+
+    @use_lighting_effect.setter
+    def use_lighting_effect(self, value):
+        self._set_style(bool(value), sv.USELIGHTINGEFFECT)
+
+
+class StreamtraceRodRibbonEffects(StreamtraceStyle):
+    """Controls how lighting and translucency interacts with streamtrace rods and ribbons.
+
+    .. code-block:: python
+        :emphasize-lines: 28-29
+
+        import os
+        import tecplot
+        from tecplot.constant import *
+
+        examples_dir = tecplot.session.tecplot_examples_directory()
+        datafile = os.path.join(examples_dir, 'SimpleData', 'DuctFlow.plt')
+        dataset = tecplot.data.load_tecplot(datafile)
+
+        frame = tecplot.active_frame()
+        frame.plot_type = tecplot.constant.PlotType.Cartesian3D
+
+        plot = frame.plot()
+        plot.show_mesh = False
+        plot.show_shade = False
+        plot.show_edge = True
+        plot.fieldmap(0).edge.edge_type = EdgeType.Creases
+
+        plot.show_mesh = False
+        plot.show_shade = False
+
+        plot.vector.u_variable_index = 3
+        plot.vector.v_variable_index = 4
+        plot.vector.w_variable_index = 5
+        plot.show_streamtraces = True
+        plot.streamtraces.rod_ribbon.width = .03
+        plot.streamtraces.rod_ribbon.shade.color = Color.Green
+
+        plot.streamtraces.rod_ribbon.effects.use_translucency = True
+        plot.streamtraces.rod_ribbon.effects.surface_translucency = 80
+
+        plot.streamtraces.add_rake(start_position=(1.5, 0, .45),
+                                       end_position=(1.5, 1, 0),
+                                       stream_type=Streamtrace.VolumeRibbon)
+
+        tecplot.export.save_png('streamtrace_ribbon_effects.png', 600, supersample=3)
+
+    .. figure:: /_static/images/streamtrace_ribbon_effects.png
+        :width: 300px
+        :figwidth: 300px
+    """
+
+    def __init__(self, streamtrace):
+        super().__init__(streamtrace, sv.EFFECTS)
+
+    @property
+    def lighting_effect(self):
+        """`LightingEffect`: Get/set the lighting algorithm used when lighting
+           streamtrace rods and ribbons.
+
+        Ribbon lighting effects must be enabled by setting
+        `StreamtraceRodRibbonShade.use_lighting_effect` to `True` when
+        setting this value.
+
+        Note that setting `StreamtraceRodRibbonShade.use_lighting_effect` will also set
+        this value for `ribbon contours <StreamtraceRodRibbonContour>`.
+
+        There are two types of lighting effects: Paneled and Gouraud:
+
+            * `Paneled`: Within each cell, the color assigned to each area by
+                shading or contour flooding is tinted by a shade constant
+                across the cell. This shade is based on the orientation
+                of the cell relative to your 3D light source.
+            * `Gouraud`: This offers smoother, more continuous shading than
+                Paneled shading, but it also results in slower plotting
+                and larger print files. `Gouraud` shading is not continuous
+                across zone boundaries unless face neighbors are specified
+                in the data. `Gouraud` shading is not available for finite
+                element volume `Zone <data_access>` when blanking is active.
+                The zone's lighting effect reverts to `Paneled`
+                shading in this case.
+
+        Example usage::
+
+            >>> plot.streamtraces.rod_ribbon.shade.use_lighting_effect = True
+            >>> plot.streamtraces.rod_ribbon.effects.lighting_effect = LightingEffect.Paneled
+        """
+        return self._get_style(LightingEffect, sv.LIGHTINGEFFECT)
+
+    @lighting_effect.setter
+    def lighting_effect(self, value):
+        self._set_style(LightingEffect(value), sv.LIGHTINGEFFECT)
+
+    @property
+    def surface_translucency(self):
+        """`int`: Surface translucency of the streamtraces ribbon.
+
+        Surface translucency must be enabled by setting
+        `StreamtraceRodRibbonEffects.use_translucency` = `True`
+        when setting this value.
+
+        Valid translucency values range from one (opaque) to 99 (translucent).
+
+        Example usage::
+
+            >>> plot.streamtraces.rod_ribbon.effects.use_translucency = True
+            >>> plot.streamtraces.rod_ribbon.effects.surface_translucency = 20
+        """
+        return self._get_style(int, sv.SURFACETRANSLUCENCY)
+
+    @surface_translucency.setter
+    def surface_translucency(self, value):
+        self._set_style(int(value), sv.SURFACETRANSLUCENCY)
+
+    @property
+    def use_translucency(self):
+        """`bool`: Enable surface translucency.
+
+        The surface translucency value can be changed by setting
+        `StreamtraceRodRibbonEffects.surface_translucency`.
+
+        Example usage::
+
+            >>> plot.streamtraces.rod_ribbon.effects.use_translucency = True
+            >>> plot.streamtraces.rod_ribbon.effects.surface_translucency = 20
+        """
+        return self._get_style(bool, sv.USETRANSLUCENCY)
+
+    @use_translucency.setter
+    def use_translucency(self, value):
+        self._set_style(bool(value), sv.USETRANSLUCENCY)
+
+
+class StreamtraceRodRibbon(StreamtraceStyle):
+    """Get/Set streamtrace rod/ribbon attributes.
+
+    The `StreamtraceRodRibbon` class allows you to query and set attributes
+    of streamtrace rod/ribbon types:
+
+    * `Streamtrace.SurfaceRibbon`
+    * `Streamtrace.VolumeRibbon`
+    * `Streamtrace.VolumeRod`
+
+    In addition to attributes common to all rod/ribbon
+    streamtrace types such as `width <StreamtraceRodRibbon.width>`,
+    some attributes are further divided into subcategories:
+
+    * `Rod/ribbon mesh <StreamtraceRodRibbonMesh>`
+    * `Rod/ribbon contour <StreamtraceRodRibbonContour>`
+    * `Rod/ribbon shade <StreamtraceRodRibbonShade>`
+    * `Rod/ribbon effects <StreamtraceRodRibbonEffects>`
+
+    .. note::
+        To change the color of streamtrace rods/ribbons, set
+        `StreamtraceRodRibbonShade.color`.
+
+    .. code-block:: python
+        :emphasize-lines: 25-35
+
+        import os
+        import tecplot
+        from tecplot.constant import *
+
+        examples_dir = tecplot.session.tecplot_examples_directory()
+        datafile = os.path.join(examples_dir, 'SimpleData', 'DuctFlow.plt')
+        dataset = tecplot.data.load_tecplot(datafile)
+
+        frame = tecplot.active_frame()
+        frame.plot_type = tecplot.constant.PlotType.Cartesian3D
+
+        plot = frame.plot()
+        plot.show_mesh = False
+        plot.show_shade = False
+        plot.show_edge = True
+        plot.fieldmap(0).edge.edge_type = EdgeType.Creases
+        plot.contour(0).variable = dataset.variable(3)
+        plot.contour(0).levels.reset_to_nice()
+
+        plot.vector.u_variable_index = 3
+        plot.vector.v_variable_index = 4
+        plot.vector.w_variable_index = 5
+
+        plot.show_streamtraces = True
+        plot.streamtraces.rod_ribbon.width = .03
+        plot.streamtraces.rod_ribbon.contour.show = True
+
+        plot.streamtraces.add_rake(start_position=(1.5, 0.1, .4),
+                                   end_position=(1.5, .9, 0.1),
+                                   stream_type=Streamtrace.VolumeRibbon,
+                                   num_seed_points=3)
+        plot.streamtraces.add_rake(start_position=(1.5, 0.1, 0.1),
+                                   end_position=(1.5, .9, .4),
+                                   stream_type=Streamtrace.VolumeRod,
+                                   num_seed_points=4)
+
+        tecplot.export.save_png('streamtrace_ribbon.png', 600, supersample=3)
+
+    .. figure:: /_static/images/streamtrace_ribbon.png
+        :width: 300px
+        :figwidth: 300px
+
+    """
+    def __init__(self, streamtrace):
+        super().__init__(streamtrace, sv.RODRIBBON)
+        self.plot = streamtrace.plot
+
+    @property
+    def mesh(self):
+        """`StreamtraceRodRibbonMesh`: Streamtraces rod/ribbon mesh attributes.
+
+        Example usage::
+
+            >>> plot.streamtraces.rod_ribbon.mesh.show = True
+        """
+        return StreamtraceRodRibbonMesh(self)
+
+    @property
+    def contour(self):
+        """`StreamtraceRodRibbonContour`: Streamtraces rod/ribbon contour attributes.
+
+        Example usage::
+
+            >>> plot.streamtraces.rod_ribbon.contour.show = True
+        """
+        return StreamtraceRodRibbonContour(self)
+
+    @property
+    def shade(self):
+        """`StreamtraceRodRibbonShade`: Streamtraces rod/ribbon color and lighting attributes.
+
+        Example usage::
+
+            >>> plot.streamtraces.rod_ribbon.shade.color = Color.Magenta
+        """
+        return StreamtraceRodRibbonShade(self)
+
+    @property
+    def effects(self):
+        """`StreamtraceRodRibbonEffects`: Streamtraces rod/ribbon effects.
+
+        Example usage::
+
+            >>> plot.streamtraces.rod_ribbon.effects.use_translucency = True
+        """
+        return StreamtraceRodRibbonEffects(self)
+
+    @property
+    def width(self):
+        """`float`: Rod/ribbon width in grid units.
+
+        Example usage::
+
+            >>> plot.streamtraces.rod_ribbon.width = 0.01
+        """
+        return self._get_style(float, sv.WIDTH)
+
+    @width.setter
+    def width(self, value):
+        self._set_style(float(value), sv.WIDTH)
+
+    @property
+    def num_rod_points(self):
+        """`int`, valid range 3-100: Number of rod points.
+
+        Volume rods have a polygonal cross-section; this parameter tells
+        |Tecplot 360| what that cross-section should be.
+        (Three is an equilateral triangle, four is a square,
+        five is a regular pentagon, and so on.) If you want two sets
+        of volume rods with different cross-sections, you must create one
+        set and then extract the set as a zone, then configure a new
+        set of streamtraces with the second cross-section.
+
+        Example usage::
+
+            >>> plot.streamtraces.rod_ribbon.num_rod_points = 10
+        """
+        return self._get_style(int, sv.NUMRODPOINTS)
+
+    @num_rod_points.setter
+    def num_rod_points(self, value):
+        self._set_style(int(value), sv.NUMRODPOINTS)
+
+
+class Streamtraces(session.Style):
+    """Streamtrace attributes for the plot.
+
+    A streamtrace is the path traced by a massless particle placed at an
+    arbitrary location in a steady-state vector field.
+    Streamtraces may be used to illustrate the nature of the vector
+    field flow in a particular region of the `Plot`.
+
+    Note:
+        Because streamtraces are dependent upon a vector field, you must
+        define vector components before creating streamtraces.
+        However, it is not necessary to activate the Vector zone layer to
+        use streamtraces.
+
+    .. code-block:: python
+        :emphasize-lines: 22-29
+
+        import os
+        import tecplot
+        from tecplot.constant import *
+
+        examples_dir = tecplot.session.tecplot_examples_directory()
+        datafile = os.path.join(examples_dir, 'SimpleData', 'Eddy.plt')
+        dataset = tecplot.data.load_tecplot(datafile)
+
+        frame = tecplot.active_frame()
+        frame.plot_type = tecplot.constant.PlotType.Cartesian3D
+
+        plot = frame.plot()
+        plot.fieldmap(0).surfaces.surfaces_to_plot = SurfacesToPlot.BoundaryFaces
+        plot.show_mesh = True
+        plot.show_shade = False
+
+        plot.vector.u_variable_index = 4
+        plot.vector.v_variable_index = 5
+        plot.vector.w_variable_index = 6
+        plot.show_streamtraces = True
+
+        streamtraces = plot.streamtraces
+        streamtraces.color = Color.Blue
+
+        streamtraces.show_arrows = True
+        streamtraces.arrowhead_size = 2
+        streamtraces.step_size = .25
+        streamtraces.line_thickness = .2
+        streamtraces.max_steps = 100
+
+        streamtraces.add_rake(start_position=(45.49, 15.32, 59.1),
+                              end_position=(48.89, 53.2, 47.6),
+                              stream_type=Streamtrace.SurfaceLine,
+                              num_seed_points=4)
+
+
+        tecplot.export.save_png('streamtrace_example.png', 600, supersample=3)
+
+    .. figure:: /_static/images/streamtrace_example.png
+        :width: 300px
+        :figwidth: 300px
+    """
+    def __init__(self, plot):
+        super().__init__(sv.STREAMATTRIBUTES, uniqueid=plot.frame.uid)
+        self.plot = plot
+
+    @tecutil.lock()
+    def extract(self, concatenate=False, assign_strand_ids=True):
+        """Create new zones from streamtraces
+
+        Extracts the current streamtraces defined in this class to the
+        `Dataset <data.Dataset>` as one or more zones.
+
+        Parameters:
+            concatenate (`bool`, optional): Concatenate streamtraces into a
+                single zone for each format (Surface Line, Volume Line, Volume
+                Ribbon, Volume Rod).
+            assign_strand_ids (`bool`, optional): Automatically assign strand
+                ID's to the created zones. This option is ignored if
+                *concatenate* if `True`. (default: `True`)
+
+        Returns:
+            A `generator
+            <https://docs.python.org/3/reference/expressions.html#generator-expressions>`_
+            of the extracted zones.
+
+        Example usage::
+
+            >>> slice_zone = plot.streamtraces.extract()
+        """
+        dataset = self.plot.frame.dataset
+        nzones = dataset.num_zones
+        with self.plot.frame.activated():
+            with tecutil.ArgList() as arglist:
+                arglist[sv.CONCATENATE] = bool(concatenate)
+                arglist[sv.AUTOSTRANDTRANSIENTDATA] = bool(assign_strand_ids)
+                if not _tecutil.ExtractStreamtracesX(arglist):
+                    raise TecplotSystemError()
+        return (dataset.zone(i) for i in range(nzones, dataset.num_zones))
+
+    @property
+    def rod_ribbon(self):
+        """`StreamtraceRodRibbon`: Streamtrace rod/ribbon attributes.
+
+        Example usage::
+
+            >>> streamtraces.rod_ribbon.mesh.show = True
+        """
+        return StreamtraceRodRibbon(self)
+
+    @property
+    def timing(self):
+        """`StreamtraceTiming`: Streamtraces timing attributes.
+
+        Example usage::
+
+            >>> timing = plot.streamtraces.timing
+            >>> timing.start = 0.01
+        """
+        return StreamtraceTiming(self)
+
+    @property
+    def termination_line(self):
+        """`StreamtraceTerminationLine`: Streamtraces termination line attributes.
+
+        A streamtrace termination line is a polyline that terminates any
+        streamtraces that cross it. The termination line is useful for stopping
+        streamtraces before they spiral or stall.
+
+        Example usage::
+
+            >>> term_line = plot.streamtraces.termination_line
+            >>> term_line.show = True
+        """
+        return StreamtraceTerminationLine(self)
+
+    @property
+    def show_dashes(self):
+        """`bool`: Display streamtrace dashes.
+
+        The lengths of the dashes and the spaces between the dashes are
+        controlled by the value of `StreamtraceTiming.delta`. Set the
+        `Streamtraces.dash_skip` attribute to control the number of
+        time deltas used for the "off" sections of the streamtraces.
+
+        Example usage::
+
+            >>> plot.streamtraces.show_dashes = True
+        """
+        return self.timing._show_dashes
+
+    @show_dashes.setter
+    def show_dashes(self, value):
+        self.timing._show_dashes = value
+
+    @property
+    def show_markers(self):
+        """`bool`: Display streamtrace markers.
+
+        Stream markers are only available for surface and volume
+        type streamlines.
+
+        You may also specify the `size <Streamtraces.marker_size>`,
+        `color <Streamtraces.marker_color>`, and
+        `shape <Streamtraces.marker_symbol>` of the markers.
+
+        Example usage::
+
+            >>> plot.streamtraces.show_markers = True
+
+        """
+        return self.timing._show_markers
+
+    @show_markers.setter
+    def show_markers(self, value):
+        self.timing._show_markers = value
+
+    @property
+    def marker_color(self):
+        """`Color` or `ContourGroup`: `Color` of the streamline markers.
+
+        Streamtrace markers can be a solid color or be colored by a
+        `ContourGroup` as obtained through the ``plot.contour`` property.
+
+        Example usage::
+
+            >>> plot.streamtraces.marker_color = Color.Blue
+        """
+
+        return self.timing._marker_color
+
+    @marker_color.setter
+    def marker_color(self, value):
+        self.timing._marker_color = value
+
+    @property
+    def marker_size(self):
+        """`float`: Size of streamline markers.
+
+         Example usage::
+
+            >>> plot.streamtraces.marker_size = 1.1
+         """
+        return self.timing._marker_size
+
+    @marker_size.setter
+    def marker_size(self, value):
+        self.timing._marker_size = value
+
+    @property
+    def dash_skip(self):
+        """`int`: Number of time deltas used for the "off" sections of the streamlines.
+
+        .. note::
+            The ``dash_skip`` value must be greater than 0.
+
+        Example usage::
+
+            >>> plot.streamtraces.dash_skip = 2
+        """
+
+        return int(self.timing._dash_skip)
+
+    @dash_skip.setter
+    def dash_skip(self, value):
+        self.timing._dash_skip = value
+
+    @property
+    def marker_symbol_type(self):
+        """`SymbolType`: The `SymbolType` to use for stream markers.
+
+        This sets the active symbol type for streamtrace markers.
+        Use `Streamtraces.marker_symbol` to access the symbol::
+
+            >>> from tecplot.constant import SymbolType
+            >>> streamtrace = plot.streamtraces
+            >>> streamtraces.marker_symbol_type = SymbolType.Text
+            >>> symbol = streamtraces.marker_symbol(SymbolType.Text)
+            >>> symbol.text = 'a'
+        """
+        return self.timing._marker_symbol_type
+
+    @marker_symbol_type.setter
+    def marker_symbol_type(self, value):
+        self.timing._marker_symbol_type = value
+
+    def marker_symbol(self, symbol_type=None):
+        """Returns a streamline symbol style object.
+
+        Parameters:
+            symbol_type (`SymbolType`, optional): The type of symbol to return.
+                By default, this will return the active marker symbol type
+                which is obtained from `Streamtraces.marker_symbol_type`.
+
+
+        Returns: `TextSymbol` or `GeometrySymbol`, depending on `marker_symbol_type`
+
+        Example usage::
+
+            >>> from tecplot.constant import SymbolType
+            >>> streamtrace = plot.streamtraces
+            >>> streamtraces.marker_symbol_type = SymbolType.Text
+            >>> symbol = streamtraces.marker_symbol(SymbolType.Text)
+            >>> symbol.text = 'a'
+        """
+        return self.timing._marker_symbol(symbol_type)
+
+    @property
+    def show_arrows(self):
+        """`bool`: Display arrowheads along all streamlines.
+
+        Example usage::
+
+            >>> plot.streamtraces.show_arrows = True
+        """
+        return self._get_style(bool, sv.ADDARROWS)
+
+    @show_arrows.setter
+    def show_arrows(self, value):
+        self._set_style(bool(value), sv.ADDARROWS)
+
+    @property
+    def arrowhead_size(self):
+        """`float`: Arrowhead size as a percentage of frame height.
+
+        Recommend values are one of 1, 3, 5, 8, or 12.
+
+        Example usage::
+
+            >>> plot.streamtraces.show_arrows = True
+            >>> plot.streamtraces.arrowhead_size = 1.0
+        """
+        return self._get_style(float, sv.ARROWHEADSIZE)
+
+    @arrowhead_size.setter
+    def arrowhead_size(self, value):
+        self._set_style(float(value), sv.ARROWHEADSIZE)
+
+    @property
+    def arrowhead_spacing(self):
+        """`float`: Distance between arrowheads in terms of Y-frame units.
+
+        For example, a value of 10 will space arrowheads approximately
+        ten percent of the frame height apart from each other along each
+        streamline.
+
+        Example usage::
+
+            >>> plot.streamtraces.show_arrows = True
+            >>> plot.streamtraces.arrowhead_spacing = 10
+        """
+        return self._get_style(float, sv.ARROWHEADSPACING)
+
+    @arrowhead_spacing.setter
+    def arrowhead_spacing(self, value):
+        self._set_style(float(value), sv.ARROWHEADSPACING)
+
+    @property
+    def step_size(self):
+        """`float`: Maximum fraction of the distance across a cell that a streamtrace
+        moves in one step.
+
+        The step size is the maximum fraction of the distance across a cell
+        that a streamtrace moves in one step. A streamtrace adjusts its
+        step size between `step_size` and `min_step_size`, depending
+        on local curvature of the streamtrace.
+
+        A typical value (and the default) is **0.25**, which results in
+        four integration steps through each cell or element.
+        The value for Step Size affects the accuracy of the integration.
+
+        .. warning::
+            Setting step size too small can result in round-off errors,
+            while setting it too large can result in truncation
+            errors and missed cells.
+
+        Example usage::
+
+            >>> plot.streamtraces.step_size = .25
+        """
+        return self._get_style(float, sv.CELLFRACTION)
+
+    @step_size.setter
+    def step_size(self, value):
+        self._set_style(float(value), sv.CELLFRACTION)
+
+    @property
+    def color(self):
+        """`Color` or `ContourGroup`: Color of streamtraces line (not rods or ribbons).
+
+        Streamtraces can be a solid color or be colored by a
+        `ContourGroup` as obtained through the ``plot.contour`` property.
+
+        Example usage::
+
+            >>> plot.streamtraces.color = Color.Red
+        """
+        return color_spec(self._get_style(Color, sv.COLOR),
+                          self.plot)
+
+    @color.setter
+    def color(self, value):
+        self._set_style(color_spec(value), sv.COLOR)
+
+    @property
+    def line_thickness(self):
+        """`float`: Streamtrace line thickness.
+
+        Line thickness as a percentage of the frame height for 2D lines,
+        or a percentage of the median axis length for 3D surface lines and
+        volume lines.
+
+        Suggested values are .02, .1, .4, .8, 1.5
+
+        Example usage::
+
+            >>> plot.streamtraces.line_thickness = 1.1
+        """
+        return self._get_style(float, sv.LINETHICKNESS)
+
+    @line_thickness.setter
+    def line_thickness(self, value):
+        self._set_style(float(value), sv.LINETHICKNESS)
+
+    @property
+    def max_steps(self):
+        """`int`: Maximum number of steps before the streamtrace is terminated.
+
+        `max_steps` prevents streamtraces from spinning forever in a vortex,
+        or from wandering into a region where the vector components are very
+        small, very random, or both.
+
+        If a small `step_size` is selected, the `max_steps`
+        should be a large value.
+
+        Example usage::
+
+            >>> plot.streamtraces.max_steps = 5000
+        """
+        return self._get_style(int, sv.MAXSTEPS)
+
+    @max_steps.setter
+    def max_steps(self, value):
+        self._set_style(int(value), sv.MAXSTEPS)
+
+    @property
+    def min_step_size(self):
+        """`float`: Smallest step size to use as a percentage of cell distance.
+
+        A typical minimum step size value is 0.00001, which is the default.
+
+        .. Warning::
+            Setting this too small results in integration problems. Setting
+            this greater than or equal to the `step_size` results in a constant
+            step size.
+
+        Example usage::
+
+            >>> plot.streamtraces.min_step_size = .0002
+        """
+        return self._get_style(float, sv.MINCELLFRACTION)
+
+    @min_step_size.setter
+    def min_step_size(self, value):
+        self._set_style(float(value), sv.MINCELLFRACTION)
+
+    @property
+    def obey_source_zone_blanking(self):
+        """`bool`: Obey source zone blanking.
+
+        When `True`, streamtraces are generated for non-blanked regions only.
+        When `False`, streamtraces are generated for both blanked and
+        unblanked regions.
+
+        Example usage::
+
+            >>> plot.streamtraces.obey_source_zone_blanking = True
+        """
+        return self._get_style(bool, sv.OBEYSOURCEZONEBLANKING)
+
+    @obey_source_zone_blanking.setter
+    def obey_source_zone_blanking(self, value):
+        self._set_style(bool(value), sv.OBEYSOURCEZONEBLANKING)
+
+    @property
+    def show_paths(self):
+        """`bool`: Draw streamtrace paths (lines, ribbons, or rods).
+
+        A streamtrace path may be a line, ribbon or rod.
+
+        Example usage::
+
+            >>> plot.streamtraces.show_paths = True
+
+        See also `Streamtraces.show_markers`
+        """
+        return self._get_style(bool, sv.SHOWPATHS)
+
+    @show_paths.setter
+    def show_paths(self, value):
+        self._set_style(bool(value), sv.SHOWPATHS)
+
+    def add_on_zone_surface(self, stream_type, zones=None, num_seed_points=10,
+                            direction=StreamDir.Both):
+        """Add streamtraces to one or more zones in a plot.
+
+        The plot type must be either `Cartesian2D` or `Cartesian3D`.
+
+        .. note:: For volume zones the streamtraces are propagated from the
+            surfaces of the volume.
+
+        Parameters:
+            stream_type: (`Streamtrace`): Type of streamtraces to add.
+
+            zones (`set` of `integers <int>`, optional):
+                Set of `Zones <data_access>` on which to add streamtraces. If
+                `None`, then streamtraces will be added to the currently
+                active zones.
+
+            num_seed_points: (`int`, optional):
+                Number of seed points for distributing along a rake or on
+                defined surfaces.
+
+            direction: (`StreamDir`, optional): Direction of propagation
+                of the streamtraces being added.
+
+        .. code-block:: python
+
+            import os
+
+            import tecplot
+            from tecplot.constant import *
+
+            examples_dir = tecplot.session.tecplot_examples_directory()
+            datafile = os.path.join(examples_dir, 'OneraM6wing', 'OneraM6_SU2_RANS.plt')
+            dataset = tecplot.data.load_tecplot(datafile)
+
+            frame = tecplot.active_frame()
+            frame.plot_type = tecplot.constant.PlotType.Cartesian3D
+
+            plot = frame.plot()
+
+            plot.vector.u_variable_index = 4
+            plot.vector.v_variable_index = 5
+            plot.vector.w_variable_index = 6
+            plot.show_streamtraces = True
+
+            plot.streamtraces.add_on_zone_surface(
+                        # To add streamtraces to the currently active zones,
+                        # pass zones=None
+                        zones=[1],  # Add streamtraces on 2nd zone only
+                        stream_type=Streamtrace.SurfaceLine,
+                        num_seed_points=200)
+
+            tecplot.export.save_png('streamtrace_add_on_zone_surface.png', 600, supersample=3)
+
+        .. figure:: /_static/images/streamtrace_add_on_zone_surface.png
+            :width: 300px
+            :figwidth: 300px
+
+        """
+        if zones is None:
+            self._add(stream_type=stream_type,
+                      distribution_region=
+                      DistributionRegion.SurfacesOfActiveZones,
+                      stream_direction=direction,
+                      num_points=num_seed_points)
+        else:
+            with IndexSet(zones) as zone_set:
+                self._add(stream_type=stream_type,
+                          distribution_region=
+                          DistributionRegion.SurfacesOfSuppliedZones,
+                          stream_direction=direction,
+                          num_points=num_seed_points, zones=zone_set)
+
+    def add_rake(self, start_position, end_position, stream_type,
+                 num_seed_points=10, direction=StreamDir.Both):
+        """Add a rake of streamtraces to the plot of the current frame.
+
+        The plot type must be either `Cartesian2D` or `Cartesian3D`.
+
+        Parameters:
+            start_position: (2- or 3- `tuple` of `floats <float>`):
+                Pass a 2-`tuple` of `float` for a
+                `Cartesian2DFieldPlot`, or a 3-`tuple` of `float` for a
+                `Cartesian3DFieldPlot`.
+
+            end_position: (2- or 3- `tuple` of `floats <float>`):
+                Pass a 2-`tuple` of `float` for a
+                `Cartesian2DFieldPlot`, or a 3-`tuple` of `float` for a
+                `Cartesian3DFieldPlot`.
+
+            stream_type: (`Streamtrace`): Type of streamtraces to add.
+
+            num_seed_points: (`int`, optional):
+                Number of seed points for distributing along a rake or on
+                defined surfaces.
+
+            direction: (`StreamDir`, optional): Direction of propagation
+                of the streamtraces being added.
+
+        .. code-block:: python
+            :emphasize-lines: 24-26
+
+            import os
+
+            import tecplot
+            from tecplot.constant import *
+
+            examples_dir = tecplot.session.tecplot_examples_directory()
+            datafile = os.path.join(examples_dir, 'SimpleData', 'Eddy.plt')
+            dataset = tecplot.data.load_tecplot(datafile)
+
+            frame = tecplot.active_frame()
+            frame.plot_type = tecplot.constant.PlotType.Cartesian3D
+
+            plot = frame.plot()
+            plot.fieldmap(0).surfaces.surfaces_to_plot = SurfacesToPlot.BoundaryFaces
+            plot.show_mesh = True
+            plot.show_shade = False
+
+            plot.vector.u_variable_index = 4
+            plot.vector.v_variable_index = 5
+            plot.vector.w_variable_index = 6
+            plot.show_streamtraces = True
+
+            streamtraces = plot.streamtraces
+            streamtraces.add_rake(start_position=[.5, .5, .5],
+                                  end_position=[20, 20, 20],
+                                  stream_type=Streamtrace.VolumeLine)
+
+            tecplot.export.save_png('streamtrace_add_rake.png', 600, supersample=3)
+
+        .. figure:: /_static/images/streamtrace_add_rake.png
+            :width: 300px
+            :figwidth: 300px
+
+        """
+
+        self._add(stream_type, DistributionRegion.Rake, direction,
+                  num_seed_points, start_position, end_position)
+
+    def add(self, seed_point, stream_type, direction=StreamDir.Both):
+        """Add a single streamtrace to the plot of the current frame.
+
+        The plot type must be either `Cartesian2D` or `Cartesian3D`.
+
+        Parameters:
+            seed_point: (2- or 3- `tuple` of `floats <float>`):
+                Pass a 2-`tuple` of `float` for a
+                `Cartesian2DFieldPlot`, or a 3-`tuple` of `float` for a
+                `Cartesian3DFieldPlot`.
+
+            stream_type: (`Streamtrace`): Type of streamtraces to add.
+
+            direction: (`StreamDir`, optional): Direction of propagation
+                of the streamtraces being added.
+
+        .. note::
+            *stream_type* is automatically set to `Streamtrace.SurfaceLine`
+            if the plot type is `Cartesian2DFieldPlot`. The only stream
+            type available for 2D plots is `Streamtrace.SurfaceLine`.
+
+        .. code-block:: python
+            :emphasize-lines: 41
+
+            import os
+            import tecplot
+            from tecplot.constant import *
+            import numpy as np
+
+            examples_dir = tecplot.session.tecplot_examples_directory()
+            datafile = os.path.join(examples_dir, 'SimpleData', 'DuctFlow.plt')
+            dataset = tecplot.data.load_tecplot(datafile)
+
+            frame = tecplot.active_frame()
+            frame.plot_type = tecplot.constant.PlotType.Cartesian3D
+
+            plot = frame.plot()
+            plot.contour(0).variable = dataset.variable('P(N/m2)')
+            plot.contour(0).levels.reset_to_nice()
+            plot.contour(0).legend.show = False
+
+            plot.vector.u_variable = dataset.variable('U(M/S)')
+            plot.vector.v_variable = dataset.variable('V(M/S)')
+            plot.vector.w_variable = dataset.variable('W(M/S)')
+
+            # Goal: create a grid of 12 stream trace ribbons
+            x_slice_location = .79
+            y_start = .077
+            y_end = .914
+            z_start = .052
+            z_end = .415
+
+            num_left_right_slices = 4  # Must be >= 2
+            num_top_bottom_slices = 3  # Must be >= 2
+
+            plot.show_streamtraces = True
+            streamtraces = plot.streamtraces
+            streamtraces.show_paths = True
+
+            rod = streamtraces.rod_ribbon
+            rod.width = .03
+            rod.contour.show = True
+
+            for y in np.linspace(y_start, y_end, num=num_left_right_slices):
+                for z in np.linspace(z_start, z_end, num=num_top_bottom_slices):
+                    streamtraces.add([x_slice_location,y,z], Streamtrace.VolumeRibbon)
+
+            tecplot.export.save_png('streamtrace_add_xyz.png', 600, supersample=3)
+
+        .. figure:: /_static/images/streamtrace_add_xyz.png
+            :width: 300px
+            :figwidth: 300px
+        """
+        self._add(stream_type=stream_type,
+                  distribution_region=DistributionRegion.Point,
+                  stream_direction=direction,
+                  start_position=seed_point,
+                  end_position=seed_point if stream_type in (
+                     Streamtrace.SurfaceRibbon, Streamtrace.VolumeRibbon,
+                     Streamtrace.VolumeRod) else None)
+
+    @lock()
+    def _add(self, stream_type, distribution_region, stream_direction,
+             num_points=None,
+             start_position=None,
+             end_position=None,
+             zones=None):
+
+        def _assign_position(arg_list, point_ordinal, value):
+            try:
+                if __debug__:
+                    frame = self.plot.frame
+                    if frame.plot_type == PlotType.Cartesian2D and (
+                                len(value) != 2):
+                        raise TecplotTypeError(
+                                '[x,y] position for streamtrace '
+                                'requires 2D plot type.')
+                    elif frame.plot_type == PlotType.Cartesian3D and (
+                                len(value) != 3):
+                        raise TecplotTypeError(
+                                '[x,y] position for streamtrace '
+                                'requires 2D plot type.')
+
+                arg_list['X' + point_ordinal], arg_list['Y' + point_ordinal] = (
+                    float(value[0]), float(value[1]))
+                if len(value) == 3:
+                    arg_list['Z' + point_ordinal] = float(value[2])
+            except TypeError:
+                raise TecplotTypeError('streamtrace position must be a '
+                                       '2- or 3- tuple of floats.')
+
+        with tecutil.ArgList() as arglist:
+            arglist[sv.STREAMTYPE] = stream_type
+            arglist[sv.DISTRIBUTIONREGION] = distribution_region
+            arglist[sv.STREAMDIRECTION] = stream_direction
+            if zones is not None:
+                arglist[sv.ZONESET] = zones
+
+            if num_points is not None:
+                arglist[sv.NUMPTS] = int(num_points)
+            if start_position is not None:
+                _assign_position(arglist, '1', start_position)
+            if end_position is not None:
+                _assign_position(arglist, '2', end_position)
+
+            with self.plot.frame.activated():
+                if not _tecutil.StreamtraceAddX(arglist):
+                    raise TecplotSystemError()
+
+    @lock()
+    def delete_all(self):
+        """Delete all streamtraces for the current plot type.
+
+        2D and 3D streamtraces are independent of each other.
+
+        If the plot type is `Cartesian2D`, all 2D streamtraces are deleted.
+        If the plot type is `Cartesian3D`, all 3D streamtraces are deleted.
+
+        Raises:
+            `TecplotSystemError`: The streamtraces could not be deleted.
+
+        Example usage::
+
+            >>> plot.streamtraces.delete_all()
+        """
+
+        with self.plot.frame.activated():
+            if not _tecutil.StreamtraceDeleteAll():
+                raise TecplotSystemError()
+
+    @lock()
+    def delete_range(self, range_start, range_end):
+        """Delete a range of streamtraces.
+
+        Parameters:
+            range_start: (`int`): 0-based start streamtrace number to delete.
+
+            range_end: (`int`): 0-based end streamtrace number to delete.
+
+        Raises:
+            `TecplotSystemError`: The streamtraces in the range could not be deleted.
+
+        Example usage::
+
+            >>> # Delete the first 100 streamtraces
+            >>> plot.streamtraces.delete_range(0, 99)
+        """
+
+        with self.plot.frame.activated():
+            if not _tecutil.StreamtraceDeleteRange(range_start + 1, range_end + 1):
+                raise TecplotSystemError()
+
+    @lock()
+    def set_termination_line(self, line_points):
+        """Set the position of the termination line for streamtraces.
+
+        Parameters:
+            line_points: (array of `float` `tuple`) Points of the termination line.
+
+        Raises:
+            `TecplotSystemError`: Termination line could not be set.
+
+        Example usage::
+
+            >>> # Multi-segment line between points (0,0)-(5,8)-(3,6)
+            >>> line_points = [(0, 0), (5, 8), (3,6)]
+            >>> plot.streamtraces.set_termination_line(line_points)
+        """
+
+        num_points = len(line_points)
+
+        #
+        # __mul__() is used below because the alternative:
+        #  (c_double * num_points)(*P[0]... causes a lint warning in PyCharm
+        #
+        x_points = (ctypes.c_double.__mul__(num_points)
+                    )(*[P[0] for P in line_points])
+        y_points = (ctypes.c_double.__mul__(num_points)
+                    )(*[P[1] for P in line_points])
+
+        with self.plot.frame.activated():
+            if not _tecutil.StreamtraceSetTermLine(
+                    len(line_points),
+                    x_points,
+                    y_points):
+                raise TecplotSystemError()
+
+    @property
+    def count(self):
+        """Query the number of active streamtraces for the current plot type.
+
+        Returns:
+            `int`
+
+        .. note:: This property is read-only.
+
+        >>> num_active_streamtraces = plot.streamtraces.count
+
+        """
+        with self.plot.frame.activated():
+            return _tecutil.StreamtraceGetCount()
+
+    def position(self, stream_number):
+        """Query the starting position of a streamtrace.
+
+        Parameters:
+            stream_number: (`int`): 0-based stream number to query.
+
+        Returns:
+            `tuple` of `floats <float>`
+
+        Get the position of streamtrace number 3::
+
+            >>> position = plot.streamtraces.position(2) # Note: 0-based
+            >>> position.x  # == position[0]
+            0.1
+            >>> position.y  # == position[1]
+            0.2
+            >>> position.z  # == position[2]
+            0.3
+        """
+        with self.plot.frame.activated():
+            position = _tecutil.StreamtraceGetPos(stream_number + 1)
+            return tecutil.XYZ(*position)
+
+    def streamtrace_type(self, stream_number):
+        """Query the type of a streamtrace by streamtrace number.
+
+        Parameters:
+            stream_number: (`int`): 0-based stream number to query.
+
+        Returns:
+            `Streamtrace`
+
+        Get the type of streamtrace 3. Note 0-based stream number::
+
+            >>> streamtrace_type = plot.streamtraces.streamtrace_type(2)
+            >>> streamtrace_type
+            <Streamtrace.VolumeLine: 2>
+        """
+        with self.plot.frame.activated():
+            return Streamtrace(_tecutil.StreamtraceGetType(stream_number+1))
+
+    @property
+    def has_terminating_line(self):
+        """Determine if the streamtraces have the terminating line.
+
+        .. note:: This property is read-only.
+
+        Returns:
+            `bool`. `True` if the streamtraces have the terminating
+            line, `False` otherwise.
+
+        Example usage::
+
+            >>> has_terminating_line = plot.streamtraces.has_terminating_line
+
+        """
+        with self.plot.frame.activated():
+            with lock():
+                return _tecutil.StreamtraceHasTermLine()
+
+    @property
+    def active(self):
+        """`bool`: Determine if there are active streamtraces.
+
+        .. note:: This property is read-only.
+
+        Returns:
+            `bool`. `True` if there are active streamtraces
+            in the current plot type.
+
+        Example usage::
+
+            >>> streamtraces_are_active = plot.streamtraces.active
+        """
+        with self.plot.frame.activated():
+            return _tecutil.QueryStreamtracesAreActive()
+
+    @property
+    def are_active(self):
+        tecutil.api_moved('Streamtraces.are_active', 'Streamtraces.active',
+                          '0.13', '2018 R2')
+
+    @property
+    def use_slice_clipping(self):
+        """`bool`: Clip isosurface by any intersecting slices.
+
+        Example usage::
+
+            >>> from tecplot.constant import ClipPlane
+            >>> slice = plot.slice(0)
+            >>> slice.clip = ClipPlane.AbovePrimarySlice
+            >>> plot.fieldmap(0).effects.clip_planes = slice
+            >>> plot.streamtraces.use_slice_clipping = True
+
+        .. seealso:: `SliceGroup.clip`
+        """
+        return self._get_style(bool, sv.OBEYCLIPPLANES)
+
+    @use_slice_clipping.setter
+    def use_slice_clipping(self, value):
+        self._set_style(bool(value), sv.OBEYCLIPPLANES)