Bokeh

pytao.plotting.bokeh

Classes

pytao.plotting.bokeh.BokehAppCreator

BokehAppCreator(manager, graphs, share_x=None, include_variables=False, grid=None, width=None, height=None, include_layout=False, graph_sizing_mode=None, layout_height=None, xlim=None, ylim=None, ix_uni=None)

A composite Bokeh application creator made up of 1 or more graphs.

This can be used to: * Generate a static HTML page without Python widgets * Generate a Notebook (or standalone) application with Python widgets

Interactive widgets will use the Tao object to adjust variables during callbacks resulting from user interaction.

Source code in pytao/plotting/bokeh.py

def __init__(
    self,
    manager: BokehGraphManager | NotebookGraphManager,
    graphs: list[AnyGraph],
    share_x: bool | None = None,
    include_variables: bool = False,
    grid: tuple[int, int] | None = None,
    width: int | None = None,
    height: int | None = None,
    include_layout: bool = False,
    graph_sizing_mode: SizingModeType | None = None,
    layout_height: int | None = None,
    xlim: OptionalLimit | Sequence[OptionalLimit] = None,
    ylim: OptionalLimit | Sequence[OptionalLimit] = None,
    ix_uni: int | None = None,
) -> None:
    if not len(graphs):
        raise ValueError("BokehAppCreator requires 1 or more graph")

    if any(isinstance(graph, LatticeLayoutGraph) for graph in graphs):
        include_layout = False
    elif not any(graph.is_s_plot for graph in graphs):
        include_layout = False

    if not grid:
        grid = (len(graphs), 1)

    if include_layout:
        grid = (grid[0] + 1, grid[1])

    if include_variables:
        variables = Variable.from_tao_all(manager.tao)
    else:
        variables = []

    self.manager = manager
    self.graphs = graphs
    self.share_x = share_x
    self.variables = variables
    self.grid = grid
    self.width = width
    self.height = height
    self.graph_sizing_mode = graph_sizing_mode
    self.include_layout = include_layout
    self.layout_height = layout_height
    self.ix_uni = ix_uni
    self.xlim = fix_grid_limits(xlim, num_graphs=len(graphs))
    self.ylim = fix_grid_limits(ylim, num_graphs=len(graphs))

Methods:

pytao.plotting.bokeh.BokehAppCreator.create_state

create_state()

Create an independent application state based on the graph data.

Source code in pytao/plotting/bokeh.py

def create_state(self) -> BokehAppState:
    """Create an independent application state based on the graph data."""
    pairs, layout_pairs = self._create_figures()
    grid = self._grid_figures(pairs, layout_pairs)
    return BokehAppState(
        pairs=pairs,
        layout_pairs=layout_pairs,
        grid=grid,
    )

pytao.plotting.bokeh.BokehGraphManager

BokehGraphManager(tao)

Bases: GraphManager

Bokeh backend graph manager - for non-Jupyter contexts.

Source code in pytao/plotting/plot.py

def __init__(self, tao: Tao) -> None:
    self.tao = tao
    self.regions = {}
    self._to_place = {}

Methods:

pytao.plotting.bokeh.BokehGraphManager.plot

plot(template, *, region_name=None, include_layout=True, sizing_mode=None, width=None, height=None, layout_height=None, share_x=None, xlim=None, ylim=None, save=None, curves=None, settings=None, ix_uni=None)

Plot a graph with Bokeh.

Parameters:

Name	Type	Description	Default
template	str	Graph template name.	required
region_name	str	Graph region name.	None
include_layout	bool	Include a layout plot at the bottom, if not already placed and if appropriate (i.e., another plot uses longitudinal coordinates on the x-axis).	True
sizing_mode	Optional[SizingModeType]	Set the sizing mode for all graphs. Default is configured on a per-graph basis, typically "inherit".	None
width	int	Width of each plot.	None
height	int	Height of each plot.	None
layout_height	int	Height of the layout plot.	None
share_x	bool or None	Share x-axes where sensible (None) or force sharing x-axes (True) for all plots.	None
xlim	(float, float)	X axis limits.	None
ylim	(float, float)	Y axis limits.	None
curves	Dict[int, TaoCurveSettings]	Dictionary of curve index to curve settings. These settings will be applied to the placed graph prior to plotting.	None
settings	TaoGraphSettings	Graph customization settings.	None
save	str or bool	Save the plot to a static HTML file with the given name. If True, saves to a filename based on the plot title.	None
ix_uni	int	Plot data from this universe.	None

Returns:

Type	Description
list of graphs
BokehAppCreator

Source code in pytao/plotting/bokeh.py

def plot(
    self,
    template: str,
    *,
    region_name: str | None = None,
    include_layout: bool = True,
    sizing_mode: SizingModeType | None = None,
    width: int | None = None,
    height: int | None = None,
    layout_height: int | None = None,
    share_x: bool | None = None,
    xlim: tuple[float, float] | None = None,
    ylim: tuple[float, float] | None = None,
    save: bool | str | pathlib.Path | None = None,
    curves: dict[int, TaoCurveSettings] | None = None,
    settings: TaoGraphSettings | None = None,
    ix_uni: int | None = None,
) -> tuple[list[AnyGraph], BokehAppCreator]:
    """
    Plot a graph with Bokeh.

    Parameters
    ----------
    template : str
        Graph template name.
    region_name : str, optional
        Graph region name.
    include_layout : bool
        Include a layout plot at the bottom, if not already placed and if
        appropriate (i.e., another plot uses longitudinal coordinates on
        the x-axis).
    sizing_mode : Optional[SizingModeType]
        Set the sizing mode for all graphs.  Default is configured on a
        per-graph basis, typically "inherit".
    width : int, optional
        Width of each plot.
    height : int, optional
        Height of each plot.
    layout_height : int, optional
        Height of the layout plot.
    share_x : bool or None, default=None
        Share x-axes where sensible (`None`) or force sharing x-axes (True)
        for all plots.
    xlim : (float, float), optional
        X axis limits.
    ylim : (float, float), optional
        Y axis limits.
    curves : Dict[int, TaoCurveSettings], optional
        Dictionary of curve index to curve settings. These settings will be
        applied to the placed graph prior to plotting.
    settings : TaoGraphSettings, optional
        Graph customization settings.
    save : str or bool, optional
        Save the plot to a static HTML file with the given name.
        If `True`, saves to a filename based on the plot title.
    ix_uni : int, optional
        Plot data from this universe.

    Returns
    -------
    list of graphs

    BokehAppCreator
    """
    graphs = self.prepare_graphs_by_name(
        template_name=template,
        region_name=region_name,
        curves=curves,
        settings=settings,
        xlim=xlim,
        ylim=ylim,
        ix_uni=ix_uni,
    )

    if not graphs:
        raise UnsupportedGraphError(f"No supported plots from this template: {template}")

    app = BokehAppCreator(
        manager=self,
        graphs=graphs,
        share_x=share_x,
        include_variables=False,
        grid=None,
        width=width or _Defaults.width,
        height=height or _Defaults.height,
        layout_height=layout_height or _Defaults.layout_height,
        include_layout=include_layout,
        graph_sizing_mode=sizing_mode,
        xlim=[xlim],
        ylim=[ylim],
        ix_uni=ix_uni,
    )

    if save:
        if save is True:
            save = ""
        filename = app.save(save)
        logger.info(f"Saving plot to {filename!r}")

    return graphs, app

pytao.plotting.bokeh.BokehGraphManager.plot_ele_methods

plot_ele_methods(data, *, columns=None, show_names=True, show_csr_ds_step=None, include_layout=True, lane_height=0.8, width=None, height=None, layout_height=None, save=None)

Plot element method settings as categorical lanes along the beamline.

Each method (e.g., tracking_method) becomes a horizontal lane, with each element drawn as a block spanning its longitudinal extent, colored by the method value.

Parameters:

Name	Type	Description	Default
data	ElementMethodsPlotData	Per-element method data, gathered via ElementMethodsPlotData.from_tao.	required
columns	sequence of str	Method columns to plot, in order. Defaults to all categorical columns with data for the selected elements.	None
show_names	bool	Label method transitions with the element names before and after the transition point.	True
show_csr_ds_step	bool	Add a subplot of csr_ds_step vs s. The default (None) shows it only when CSR is active for at least one selected element.	None
include_layout	bool	Include a lattice layout plot at the bottom.	True
lane_height	float	Height of each lane's blocks, where lanes are spaced 1.0 apart.	0.8
width	int	Width of each plot in pixels.	None
height	int	Height of the lane plot in pixels. Defaults to scaling with the number of lanes.	None
layout_height	int	Height of the layout plot in pixels.	None
save	Path or str	Save the plot to the given filename.	None

Returns:

Type	Description
ElementMethodsPlotData
column

Source code in pytao/plotting/bokeh.py

def plot_ele_methods(
    self,
    data: ElementMethodsPlotData,
    *,
    columns: Sequence[str] | None = None,
    show_names: bool = True,
    show_csr_ds_step: bool | None = None,
    include_layout: bool = True,
    lane_height: float = 0.8,
    width: int | None = None,
    height: int | None = None,
    layout_height: int | None = None,
    save: bool | str | pathlib.Path | None = None,
):
    """
    Plot element method settings as categorical lanes along the beamline.

    Each method (e.g., `tracking_method`) becomes a horizontal lane, with
    each element drawn as a block spanning its longitudinal extent, colored
    by the method value.

    Parameters
    ----------
    data : ElementMethodsPlotData
        Per-element method data, gathered via
        `ElementMethodsPlotData.from_tao`.
    columns : sequence of str, optional
        Method columns to plot, in order.  Defaults to all categorical
        columns with data for the selected elements.
    show_names : bool, default=True
        Label method transitions with the element names before and after
        the transition point.
    show_csr_ds_step : bool, optional
        Add a subplot of `csr_ds_step` vs s.  The default (`None`) shows
        it only when CSR is active for at least one selected element.
    include_layout : bool, default=True
        Include a lattice layout plot at the bottom.
    lane_height : float, default=0.8
        Height of each lane's blocks, where lanes are spaced 1.0 apart.
    width : int, optional
        Width of each plot in pixels.
    height : int, optional
        Height of the lane plot in pixels.  Defaults to scaling with the
        number of lanes.
    layout_height : int, optional
        Height of the layout plot in pixels.
    save : pathlib.Path or str, optional
        Save the plot to the given filename.

    Returns
    -------
    ElementMethodsPlotData
    bokeh.layouts.column
    """
    columns = data.validate_columns(columns)

    if show_csr_ds_step is None:
        show_csr_ds_step = data.csr_on

    lanes_fig = figure(
        tools=_Defaults.tools,
        toolbar_location="above",
        x_range=bokeh.models.Range1d(min(data.s_start), max(data.s_end)),
    )
    lane_renderers = _draw_method_lanes(data, columns, lanes_fig, lane_height)
    if show_names:
        _draw_method_transition_names(data, columns, lanes_fig)
    _draw_method_legend(lanes_fig, lane_renderers)
    lanes_fig.frame_height = height or max(150, 32 * len(columns))

    figs = [lanes_fig]
    if show_csr_ds_step:
        csr_fig = figure(tools=lanes_fig.tools, toolbar_location=None)
        _draw_csr_ds_step(data, csr_fig)
        csr_fig.frame_height = 120
        figs.append(csr_fig)

    if include_layout:
        layout_fig = BokehLatticeLayoutGraph(
            self, self.lattice_layout_graph
        ).create_figure(toolbar_location=None)
        layout_fig.frame_height = layout_height or _Defaults.layout_height
        figs.append(layout_fig)

    min_border_left = max(80, 8 * max(len(col) for col in columns) + 24)
    for fig in figs:
        fig.frame_width = width or _Defaults.width
        fig.min_border_left = min_border_left

    share_x_axes(figs)
    figs[-1].xaxis.axis_label = "s (m)"

    ui = bokeh.layouts.column(
        [
            lanes_fig,
            _method_settings_caption(data, margin_left=min_border_left),
            *figs[1:],
        ]
    )

    if save:
        if save is True:
            save = "ele_methods.html"
        filename = save_plot(ui, filename=save)
        logger.info(f"Saving plot to {filename!r}")

    return data, ui

pytao.plotting.bokeh.BokehGraphManager.plot_field

plot_field(ele_id, *, colormap=None, radius=0.015, num_points=100, x_scale=1.0, width=None, height=None, save=None)

Plot field information for a given element.

Parameters:

Name	Type	Description	Default
ele_id	str	Element ID.	required
colormap	str	Colormap for the plot. Matplotlib defaults to "PRGn_r", and bokeh defaults to "".	None
radius	float	Radius.	0.015
num_points	int	Number of data points.	100
width	int		None
height	int		None
save	Path or str	Save the plot to the given filename.	None

Returns:

Type	Description
ElementField
figure

Source code in pytao/plotting/bokeh.py

def plot_field(
    self,
    ele_id: str,
    *,
    colormap: str | None = None,
    radius: float = 0.015,
    num_points: int = 100,
    x_scale: float = 1.0,
    width: int | None = None,
    height: int | None = None,
    save: bool | str | pathlib.Path | None = None,
):
    """
    Plot field information for a given element.

    Parameters
    ----------
    ele_id : str
        Element ID.
    colormap : str, optional
        Colormap for the plot.
        Matplotlib defaults to "PRGn_r", and bokeh defaults to "".
    radius : float, default=0.015
        Radius.
    num_points : int, default=100
        Number of data points.
    width : int, optional
    height : int, optional
    save : pathlib.Path or str, optional
        Save the plot to the given filename.

    Returns
    -------
    ElementField

    figure
    """
    field = ElementField.from_tao(self.tao, ele_id, num_points=num_points, radius=radius)
    fig = figure(title=f"Field of {ele_id}")

    palette = colormap or _Defaults.palette

    source = _fields_to_data_source([field], x_scale=x_scale)
    cmap = bokeh.models.LinearColorMapper(
        palette=palette or _Defaults.palette,
        low=np.min(source.data["by"]),
        high=np.max(source.data["by"]),
    )

    fig.image(
        image="by",
        x="x",
        y=-1,
        dw="dw",
        dh="dh",
        color_mapper=cmap,
        source=source,
        name="field_images",
    )
    color_bar = bokeh.models.ColorBar(color_mapper=cmap, location=(0, 0))
    fig.add_layout(color_bar, "right")

    fig.frame_width = width or _Defaults.width
    fig.frame_height = height or _Defaults.height

    if save:
        if save is True:
            save = f"{ele_id}_field"
        filename = save_plot(fig, filename=save)
        logger.info(f"Saving plot to {filename!r}")

    return field, fig

pytao.plotting.bokeh.BokehGraphManager.plot_grid

plot_grid(templates, grid, *, include_layout=False, share_x=None, width=None, height=None, figsize=None, layout_height=None, xlim=None, ylim=None, curves=None, settings=None, save=None, ix_uni=None)

Plot graphs on a grid with Bokeh.

Parameters:

Name	Type	Description	Default
templates	list of str	Graph template names.	required
grid	(nrows, ncols)	Grid the provided graphs into this many rows and columns.	required
include_layout	bool	Include a layout plot at the bottom of each column.	False
share_x	bool or None	Share x-axes where sensible (None) or force sharing x-axes (True) for all plots.	None
figsize	(int, int)	Figure size. Alternative to specifying width and height separately. This takes precedence over width and height.	None
width	int	Width of the whole plot.	None
height	int	Height of the whole plot.	None
layout_height	int	Height of the layout plot.	None
xlim	list of (float, float)	X axis limits for each graph.	None
ylim	list of (float, float)	Y axis limits for each graph.	None
curves	list of Dict[int, TaoCurveSettings]	One dictionary per graph, with each dictionary mapping the curve index to curve settings. These settings will be applied to the placed graphs prior to plotting.	None
settings	list of TaoGraphSettings	Graph customization settings, per graph.	None
save	Path or str	Save the plot to the given filename.	None
ix_uni	int	Plot data from this universe for every graph in the grid.	None

Returns:

Type	Description
list of graphs
BokehAppCreator

Source code in pytao/plotting/bokeh.py

def plot_grid(
    self,
    templates: list[str],
    grid: tuple[int, int],
    *,
    include_layout: bool = False,
    share_x: bool | None = None,
    width: int | None = None,
    height: int | None = None,
    figsize: tuple[int, int] | None = None,
    layout_height: int | None = None,
    xlim: OptionalLimit | Sequence[OptionalLimit] = None,
    ylim: OptionalLimit | Sequence[OptionalLimit] = None,
    curves: list[CurveIndexToCurve] | None = None,
    settings: list[TaoGraphSettings] | None = None,
    save: bool | str | pathlib.Path | None = None,
    ix_uni: int | None = None,
):
    """
    Plot graphs on a grid with Bokeh.

    Parameters
    ----------
    templates : list of str
        Graph template names.
    grid : (nrows, ncols), optional
        Grid the provided graphs into this many rows and columns.
    include_layout : bool, default=False
        Include a layout plot at the bottom of each column.
    share_x : bool or None, default=None
        Share x-axes where sensible (`None`) or force sharing x-axes (True)
        for all plots.
    figsize : (int, int), optional
        Figure size. Alternative to specifying `width` and `height`
        separately.  This takes precedence over `width` and `height`.
    width : int, optional
        Width of the whole plot.
    height : int, optional
        Height of the whole plot.
    layout_height : int, optional
        Height of the layout plot.
    xlim : list of (float, float), optional
        X axis limits for each graph.
    ylim : list of (float, float), optional
        Y axis limits for each graph.
    curves : list of Dict[int, TaoCurveSettings], optional
        One dictionary per graph, with each dictionary mapping the curve
        index to curve settings. These settings will be applied to the
        placed graphs prior to plotting.
    settings : list of TaoGraphSettings, optional
        Graph customization settings, per graph.
    save : pathlib.Path or str, optional
        Save the plot to the given filename.
    ix_uni : int, optional
        Plot data from this universe for every graph in the grid.

    Returns
    -------
    list of graphs

    BokehAppCreator
    """
    graphs = self.prepare_grid_by_names(
        template_names=templates,
        curves=curves,
        settings=settings,
        xlim=xlim,
        ylim=ylim,
        ix_uni=ix_uni,
    )

    if figsize is not None:
        width, height = figsize

    app = BokehAppCreator(
        manager=self,
        graphs=graphs,
        share_x=share_x,
        include_variables=False,
        grid=grid,
        width=width or _Defaults.width,
        height=height or _Defaults.stacked_height,
        layout_height=layout_height or _Defaults.layout_height,
        include_layout=include_layout,
        xlim=xlim,
        ylim=ylim,
        ix_uni=ix_uni,
    )

    if save:
        if save is True:
            save = ""
        filename = app.save(save)
        logger.info(f"Saving plot to {filename!r}")
    return graphs, app

pytao.plotting.bokeh.BokehGraphManager.to_bokeh_graph

to_bokeh_graph(graph)

Create a Bokeh graph instance from the backend-agnostic AnyGraph version.

For example, BasicGraph becomes BokehBasicGraph.

Parameters:

Name	Type	Description	Default
graph	AnyGraph		required

Returns:

Type	Description
AnyBokehGraph

Source code in pytao/plotting/bokeh.py

def to_bokeh_graph(self, graph: AnyGraph) -> AnyBokehGraph:
    """
    Create a Bokeh graph instance from the backend-agnostic AnyGraph version.

    For example, `BasicGraph` becomes `BokehBasicGraph`.

    Parameters
    ----------
    graph : AnyGraph

    Returns
    -------
    AnyBokehGraph
    """
    if isinstance(graph, BasicGraph):
        return BokehBasicGraph(self, graph)
    elif isinstance(graph, LatticeLayoutGraph):
        return BokehLatticeLayoutGraph(self, graph)
    elif isinstance(graph, FloorPlanGraph):
        return BokehFloorPlanGraph(self, graph)
    raise NotImplementedError(type(graph).__name__)

pytao.plotting.bokeh.NotebookGraphManager

NotebookGraphManager(tao)

Bases: BokehGraphManager

Jupyter notebook Bokeh backend graph manager.

Source code in pytao/plotting/plot.py

def __init__(self, tao: Tao) -> None:
    self.tao = tao
    self.regions = {}
    self._to_place = {}

Methods:

pytao.plotting.bokeh.NotebookGraphManager.plot

plot(template, *, region_name=None, include_layout=True, sizing_mode=None, width=None, height=None, layout_height=None, share_x=None, vars=False, xlim=None, ylim=None, notebook_handle=False, save=None, curves=None, settings=None, ix_uni=None)

Plot a graph with Bokeh.

Parameters:

Name	Type	Description	Default
template	str	Graph template name.	required
region_name	str	Graph region name.	None
include_layout	bool	Include a layout plot at the bottom, if not already placed and if appropriate (i.e., another plot uses longitudinal coordinates on the x-axis).	True
sizing_mode	Optional[SizingModeType]	Set the sizing mode for all graphs. Default is configured on a per-graph basis, typically "inherit".	None
width	int	Width of each plot.	None
height	int	Height of each plot.	None
layout_height	int	Height of the layout plot.	None
share_x	bool or None	Share x-axes where sensible (None) or force sharing x-axes (True) for all plots.	None
vars	bool	Show Tao variables as adjustable widgets, like "single mode".	False
xlim	(float, float)	X axis limits.	None
ylim	(float, float)	Y axis limits.	None
curves	Dict[int, TaoCurveSettings]	Dictionary of curve index to curve settings. These settings will be applied to the placed graph prior to plotting.	None
settings	TaoGraphSettings	Graph customization settings.	None
save	str or bool	Save the plot to a static HTML file with the given name. If True, saves to a filename based on the plot title.	None
ix_uni	int	Plot data from this universe.	None

Returns:

Type	Description
BokehAppCreator

Source code in pytao/plotting/bokeh.py

def plot(
    self,
    template: str,
    *,
    region_name: str | None = None,
    include_layout: bool = True,
    sizing_mode: SizingModeType | None = None,
    width: int | None = None,
    height: int | None = None,
    layout_height: int | None = None,
    share_x: bool | None = None,
    vars: bool = False,
    xlim: Limit | None = None,
    ylim: Limit | None = None,
    notebook_handle: bool = False,
    save: bool | str | pathlib.Path | None = None,
    curves: dict[int, TaoCurveSettings] | None = None,
    settings: TaoGraphSettings | None = None,
    ix_uni: int | None = None,
) -> tuple[list[AnyGraph], BokehAppCreator]:
    """
    Plot a graph with Bokeh.

    Parameters
    ----------
    template : str
        Graph template name.
    region_name : str, optional
        Graph region name.
    include_layout : bool
        Include a layout plot at the bottom, if not already placed and if
        appropriate (i.e., another plot uses longitudinal coordinates on
        the x-axis).
    sizing_mode : Optional[SizingModeType]
        Set the sizing mode for all graphs.  Default is configured on a
        per-graph basis, typically "inherit".
    width : int, optional
        Width of each plot.
    height : int, optional
        Height of each plot.
    layout_height : int, optional
        Height of the layout plot.
    share_x : bool or None, default=None
        Share x-axes where sensible (`None`) or force sharing x-axes (True)
        for all plots.
    vars : bool, default=False
        Show Tao variables as adjustable widgets, like "single mode".
    xlim : (float, float), optional
        X axis limits.
    ylim : (float, float), optional
        Y axis limits.
    curves : Dict[int, TaoCurveSettings], optional
        Dictionary of curve index to curve settings. These settings will be
        applied to the placed graph prior to plotting.
    settings : TaoGraphSettings, optional
        Graph customization settings.
    save : str or bool, optional
        Save the plot to a static HTML file with the given name.
        If `True`, saves to a filename based on the plot title.
    ix_uni : int, optional
        Plot data from this universe.

    Returns
    -------
    BokehAppCreator
    """
    graphs, app = super().plot(
        region_name=region_name,
        template=template,
        include_layout=include_layout,
        sizing_mode=sizing_mode,
        width=width,
        height=height,
        layout_height=layout_height,
        xlim=xlim,
        ylim=ylim,
        curves=curves,
        settings=settings,
        share_x=share_x,
        ix_uni=ix_uni,
        save=save,
    )

    if vars:
        app.variables = Variable.from_tao_all(self.tao)

    bokeh.plotting.show(
        app.create_full_app(),
        notebook_handle=notebook_handle,
    )
    return graphs, app

pytao.plotting.bokeh.NotebookGraphManager.plot_field

plot_field(ele_id, *, colormap=None, radius=0.015, num_points=100, width=None, height=None, x_scale=1.0, save=None)

Plot field information for a given element.

Parameters:

Name	Type	Description	Default
ele_id	str	Element ID.	required
colormap	str	Colormap for the plot. Matplotlib defaults to "PRGn_r", and bokeh defaults to "".	None
radius	float	Radius.	0.015
num_points	int	Number of data points.	100
width	int		None
height	int		None
save	Path or str	Save the plot to the given filename.	None

Source code in pytao/plotting/bokeh.py

def plot_field(
    self,
    ele_id: str,
    *,
    colormap: str | None = None,
    radius: float = 0.015,
    num_points: int = 100,
    width: int | None = None,
    height: int | None = None,
    x_scale: float = 1.0,
    save: bool | str | pathlib.Path | None = None,
):
    """
    Plot field information for a given element.

    Parameters
    ----------
    ele_id : str
        Element ID.
    colormap : str, optional
        Colormap for the plot.
        Matplotlib defaults to "PRGn_r", and bokeh defaults to "".
    radius : float, default=0.015
        Radius.
    num_points : int, default=100
        Number of data points.
    width : int, optional
    height : int, optional
    save : pathlib.Path or str, optional
        Save the plot to the given filename.
    """
    field, fig = super().plot_field(
        ele_id,
        colormap=colormap,
        radius=radius,
        num_points=num_points,
        width=width,
        height=height,
        save=save,
        x_scale=x_scale,
    )
    bokeh.plotting.show(fig, notebook_handle=True)

    return field, fig

pytao.plotting.bokeh.NotebookGraphManager.plot_grid

plot_grid(templates, grid, *, curves=None, settings=None, include_layout=False, share_x=None, vars=False, figsize=None, layout_height=None, xlim=None, ylim=None, width=None, height=None, save=None, ix_uni=None)

Plot graphs on a grid with Bokeh.

Parameters:

Name	Type	Description	Default
templates	list of str	Graph template names.	required
grid	(nrows, ncols)	Grid the provided graphs into this many rows and columns.	required
include_layout	bool	Include a layout plot at the bottom of each column.	False
share_x	bool or None	Share x-axes where sensible (None) or force sharing x-axes (True) for all plots.	None
vars	bool	Show Tao variables as adjustable widgets, like "single mode".	False
figsize	(int, int)	Figure size. Alternative to specifying width and height separately. This takes precedence over width and height.	None
width	int	Width of the whole plot.	None
height	int	Height of the whole plot.	None
layout_height	int	Height of the layout plot.	None
xlim	list of (float, float)	X axis limits for each graph.	None
ylim	list of (float, float)	Y axis limits for each graph.	None
curves	list of Dict[int, TaoCurveSettings]	One dictionary per graph, with each dictionary mapping the curve index to curve settings. These settings will be applied to the placed graphs prior to plotting.	None
settings	list of TaoGraphSettings	Graph customization settings, per graph.	None
save	Path or str	Save the plot to the given filename.	None
ix_uni	int	Plot data from this universe for every graph in the grid.	None

Returns:

Type	Description
list of graphs
BokehAppCreator

Source code in pytao/plotting/bokeh.py

def plot_grid(
    self,
    templates: list[str],
    grid: tuple[int, int],
    *,
    curves: list[CurveIndexToCurve] | None = None,
    settings: list[TaoGraphSettings] | None = None,
    include_layout: bool = False,
    share_x: bool | None = None,
    vars: bool = False,
    figsize: tuple[int, int] | None = None,
    layout_height: int | None = None,
    xlim: OptionalLimit | Sequence[OptionalLimit] = None,
    ylim: OptionalLimit | Sequence[OptionalLimit] = None,
    width: int | None = None,
    height: int | None = None,
    save: bool | str | pathlib.Path | None = None,
    ix_uni: int | None = None,
):
    """
    Plot graphs on a grid with Bokeh.

    Parameters
    ----------
    templates : list of str
        Graph template names.
    grid : (nrows, ncols), optional
        Grid the provided graphs into this many rows and columns.
    include_layout : bool, default=False
        Include a layout plot at the bottom of each column.
    share_x : bool or None, default=None
        Share x-axes where sensible (`None`) or force sharing x-axes (True)
        for all plots.
    vars : bool, default=False
        Show Tao variables as adjustable widgets, like "single mode".
    figsize : (int, int), optional
        Figure size. Alternative to specifying `width` and `height`
        separately.  This takes precedence over `width` and `height`.
    width : int, optional
        Width of the whole plot.
    height : int, optional
        Height of the whole plot.
    layout_height : int, optional
        Height of the layout plot.
    xlim : list of (float, float), optional
        X axis limits for each graph.
    ylim : list of (float, float), optional
        Y axis limits for each graph.
    curves : list of Dict[int, TaoCurveSettings], optional
        One dictionary per graph, with each dictionary mapping the curve
        index to curve settings. These settings will be applied to the
        placed graphs prior to plotting.
    settings : list of TaoGraphSettings, optional
        Graph customization settings, per graph.
    save : pathlib.Path or str, optional
        Save the plot to the given filename.
    ix_uni : int, optional
        Plot data from this universe for every graph in the grid.

    Returns
    -------
    list of graphs

    BokehAppCreator
    """
    graphs, app = super().plot_grid(
        templates=templates,
        grid=grid,
        curves=curves,
        settings=settings,
        include_layout=include_layout,
        share_x=share_x,
        figsize=figsize,
        width=width,
        height=height,
        xlim=xlim,
        ylim=ylim,
        layout_height=layout_height,
        save=save,
        ix_uni=ix_uni,
    )
    if vars:
        app.variables = Variable.from_tao_all(self.tao)
    bokeh.plotting.show(app.create_full_app())
    return graphs, app

Functions:

pytao.plotting.bokeh.floor_plan_figure

floor_plan_figure(elements, *, tools=None, toolbar_location='above', title='', x_axis_label='', y_axis_label='', sizing_mode='inherit', width=None, height=None, line_width_scale=None, annotate_elements=None)

Create a figure of floor plan elements, as Tao draws a floor_plan graph.

Parameters:

Name	Type	Description	Default
elements	sequence of FloorPlanElement		required
tools	str	Bokeh tools string. Defaults to the floor plan tools setting.	None
toolbar_location	str		"above"
title	str		""
x_axis_label	str		""
y_axis_label	str		""
sizing_mode	SizingModeType		"inherit"
width	int		None
height	int		None
line_width_scale	float		None
annotate_elements	bool	Draw element name labels. Defaults to the floor plan annotation setting.	None

Returns:

Type	Description
figure

Source code in pytao/plotting/bokeh.py

def floor_plan_figure(
    elements: Sequence[FloorPlanElement],
    *,
    tools: str | None = None,
    toolbar_location: str = "above",
    title: str = "",
    x_axis_label: str = "",
    y_axis_label: str = "",
    sizing_mode: SizingModeType = "inherit",
    width: int | None = None,
    height: int | None = None,
    line_width_scale: float | None = None,
    annotate_elements: bool | None = None,
) -> figure:
    """
    Create a figure of floor plan elements, as Tao draws a `floor_plan` graph.

    Parameters
    ----------
    elements : sequence of FloorPlanElement
    tools : str, optional
        Bokeh tools string.  Defaults to the floor plan tools setting.
    toolbar_location : str, default="above"
    title : str, default=""
    x_axis_label, y_axis_label : str, default=""
    sizing_mode : SizingModeType, default="inherit"
    width, height : int, optional
    line_width_scale : float, optional
    annotate_elements : bool, optional
        Draw element name labels.  Defaults to the floor plan annotation setting.

    Returns
    -------
    bokeh.plotting.figure
    """
    if tools is None:
        tools = _Defaults.floor_plan_tools
    if line_width_scale is None:
        line_width_scale = _Defaults.floor_line_width_scale
    if annotate_elements is None:
        annotate_elements = _Defaults.floor_plan_annotate_elements

    add_named_hover_tool = isinstance(tools, str) and "hover" in tools.split(",")
    if add_named_hover_tool:
        tools = ",".join(tool for tool in tools.split(",") if tool != "hover")

    fig = figure(
        title=pgplot.mathjax_string(title),
        x_axis_label=pgplot.mathjax_string(x_axis_label),
        y_axis_label=pgplot.mathjax_string(y_axis_label),
        toolbar_location=toolbar_location,
        tools=tools,
        sizing_mode=sizing_mode,
        width=width,
        height=height,
        # This is vitally important for glyphs to render properly.
        # Compare how a circle centered at (0, 0) with a radius 1
        # looks with/without this setting
        match_aspect=True,
    )

    box_zoom = get_tool_from_figure(fig, bokeh.models.BoxZoomTool)
    if box_zoom is not None:
        box_zoom.match_aspect = True

    _draw_floor_plan_shapes(fig, list(elements), line_width_scale=line_width_scale)

    if add_named_hover_tool:
        hover = bokeh.models.HoverTool(
            renderers=get_hoverable_renderers(fig),
            tooltips=[("name", "@name")],
        )
        fig.add_tools(hover)

    if annotate_elements:
        _draw_annotations(
            fig,
            {elem.name: elem.annotations for elem in elements},
            font_size=_Defaults.floor_plan_font_size,
            skip_labels=False,
        )
    return fig

pytao.plotting.bokeh.lat_layout_figure

lat_layout_figure(elements, *, tools=None, toolbar_location='above', title='', x_axis_label='', sizing_mode='inherit', aspect_ratio=None, width=None, height=None, line_width_scale=None)

Create a figure of lattice layout elements, as Tao draws a lat_layout graph.

Parameters:

Name	Type	Description	Default
elements	sequence of LatticeLayoutElement		required
tools	str	Bokeh tools string. Defaults to the lattice layout tools setting.	None
toolbar_location	str		"above"
title	str		""
x_axis_label	str		""
sizing_mode	SizingModeType		"inherit"
aspect_ratio	float	Width / height.	None
width	int		None
height	int		None
line_width_scale	float		None

Returns:

Type	Description
figure

Source code in pytao/plotting/bokeh.py

def lat_layout_figure(
    elements: Sequence[LatticeLayoutElement],
    *,
    tools: str | None = None,
    toolbar_location: LocationType = "above",
    title: str = "",
    x_axis_label: str = "",
    sizing_mode: SizingModeType = "inherit",
    aspect_ratio: float | None = None,
    width: int | None = None,
    height: int | None = None,
    line_width_scale: float | None = None,
) -> figure:
    """
    Create a figure of lattice layout elements, as Tao draws a `lat_layout` graph.

    Parameters
    ----------
    elements : sequence of LatticeLayoutElement
    tools : str, optional
        Bokeh tools string.  Defaults to the lattice layout tools setting.
    toolbar_location : str, default="above"
    title : str, default=""
    x_axis_label : str, default=""
    sizing_mode : SizingModeType, default="inherit"
    aspect_ratio : float, optional
        Width / height.
    width, height : int, optional
    line_width_scale : float, optional

    Returns
    -------
    bokeh.plotting.figure
    """
    if tools is None:
        tools = _Defaults.lattice_layout_tools
    if line_width_scale is None:
        line_width_scale = _Defaults.line_width_scale

    add_named_hover_tool = isinstance(tools, str) and "hover" in tools.split(",")
    if add_named_hover_tool:
        tools = ",".join(tool for tool in tools.split(",") if tool != "hover")

    fig = figure(
        title=pgplot.mathjax_string(title),
        x_axis_label=pgplot.mathjax_string(x_axis_label),
        toolbar_location=toolbar_location,
        tools=tools,
        aspect_ratio=aspect_ratio,
        sizing_mode=sizing_mode,
        width=width,
        height=height,
    )

    box_zoom = get_tool_from_figure(fig, bokeh.models.BoxZoomTool)
    if box_zoom is not None:
        box_zoom.match_aspect = False

    fig.xaxis.ticker = bokeh.models.FixedTicker(
        ticks=[elem.info["ele_s_start"] for elem in elements],
        minor_ticks=[elem.info["ele_s_end"] for elem in elements],
    )
    fig.xaxis.major_label_overrides = {
        elem.info["ele_s_start"]: elem.info["label_name"] for elem in elements
    }
    fig.xaxis.major_label_orientation = math.pi / 4
    fig.yaxis.ticker = []
    fig.yaxis.visible = False

    _draw_layout_elems(
        fig, list(elements), skip_labels=True, line_width_scale=line_width_scale
    )

    if add_named_hover_tool:
        hover = bokeh.models.HoverTool(
            renderers=get_hoverable_renderers(fig),
            tooltips=[
                ("name", "@name"),
                ("s start (m)", "@s_start"),
                ("s end (m)", "@s_end"),
            ],
            mode="vline",
        )
        fig.add_tools(hover)

    fig.renderers.append(
        bokeh.models.Span(location=0, dimension="width", line_color="black", line_width=1)
    )
    return fig

pytao.plotting.bokeh.set_defaults

set_defaults(width=None, height=None, stacked_height=None, layout_height=None, palette=None, show_bokeh_logo=None, tools=None, grid_toolbar_location=None, lattice_layout_tools=None, floor_plan_tools=None, floor_plan_annotate_elements=None, layout_font_size=None, floor_plan_font_size=None, limit_scale_factor=None, max_data_points=None, variables_per_row=None, show_sliders=None, line_width_scale=None, floor_line_width_scale=None, resources=None)

Change defaults used for Bokeh plots.

Parameters:

Name	Type	Description	Default
width	int	Plot default width.	None
height	int	Plot default height.	None
stacked_height	int	Stacked plot default height (plot_grid)	None
layout_height	int	Layout plot height.	None
palette	str	Palette for plot_field.	None
show_bokeh_logo	bool	Show Bokeh logo on each plot.	None
tools	str	Bokeh tools to use.	"pan,wheel_zoom,box_zoom,reset,hover,crosshair"
grid_toolbar_location	str	Toolbar location for gridded plots.	"right"
lattice_layout_tools	str	Bokeh tools to use specifically for lattice layouts.	None
floor_plan_tools	str	Bokeh tools to use specifically for floor plan layouts.	None
layout_font_size	str	Font size to use in lattice layouts.	None
floor_plan_font_size	str	Font size to use in floor plan layouts.	None
limit_scale_factor	float	View limits from Tao are scaled by this factor. This can be used to ensure that all data is visible despite drawing method differences.	1.01
max_data_points	int	Maximum number of data points to show in the slider.	None
variables_per_row	int	Variables to list per row when in single mode (i.e., vars=True).	2
show_sliders	bool	Show sliders alongside the spinners in single mode.	True
line_width_scale	float	Plot line width scaling factor applied to Tao's line width.	1.0
floor_line_width_scale	float	Floor plan line width scaling factor applied to Tao's line width.	0.5
resources	'cdn' or 'inline'	When saving Bokeh plots to HTML, make the file fully standalone ("inline") by saving everything necessary to load the page in the file, or retrieve shared scripts and resources from online ("cdn") when the page is opened.	None

Source code in pytao/plotting/bokeh.py

def set_defaults(
    width: int | None = None,
    height: int | None = None,
    stacked_height: int | None = None,
    layout_height: int | None = None,
    palette: str | None = None,
    show_bokeh_logo: bool | None = None,
    tools: str | None = None,
    grid_toolbar_location: str | None = None,
    lattice_layout_tools: str | None = None,
    floor_plan_tools: str | None = None,
    floor_plan_annotate_elements: bool | None = None,
    layout_font_size: str | None = None,
    floor_plan_font_size: str | None = None,
    limit_scale_factor: float | None = None,
    max_data_points: int | None = None,
    variables_per_row: int | None = None,
    show_sliders: bool | None = None,
    line_width_scale: float | None = None,
    floor_line_width_scale: float | None = None,
    resources: Literal["inline", "cdn"] | None = None,
):
    """
    Change defaults used for Bokeh plots.

    Parameters
    ----------
    width : int, optional
        Plot default width.
    height : int, optional
        Plot default height.
    stacked_height : int, optional
        Stacked plot default height (`plot_grid`)
    layout_height : int, optional
        Layout plot height.
    palette : str, optional
        Palette for `plot_field`.
    show_bokeh_logo : bool, optional
        Show Bokeh logo on each plot.
    tools : str, default="pan,wheel_zoom,box_zoom,reset,hover,crosshair"
        Bokeh tools to use.
    grid_toolbar_location : str, default="right"
        Toolbar location for gridded plots.
    lattice_layout_tools : str, optional
        Bokeh tools to use specifically for lattice layouts.
    floor_plan_tools : str, optional
        Bokeh tools to use specifically for floor plan layouts.
    layout_font_size : str, optional
        Font size to use in lattice layouts.
    floor_plan_font_size : str, optional
        Font size to use in floor plan layouts.
    limit_scale_factor : float, default=1.01
        View limits from Tao are scaled by this factor.  This can be used to
        ensure that all data is visible despite drawing method differences.
    max_data_points : int, optional
        Maximum number of data points to show in the slider.
    variables_per_row : int, default=2
        Variables to list per row when in single mode (i.e., `vars=True`).
    show_sliders : bool, default=True
        Show sliders alongside the spinners in single mode.
    line_width_scale : float, default=1.0
        Plot line width scaling factor applied to Tao's line width.
    floor_line_width_scale : float, default=0.5
        Floor plan line width scaling factor applied to Tao's line width.
    resources : "cdn" or "inline", optional
        When saving Bokeh plots to HTML, make the file fully standalone
        ("inline") by saving everything necessary to load the page in the file,
        or retrieve shared scripts and resources from online ("cdn") when
        the page is opened.
    """

    if width is not None:
        _Defaults.width = int(width)
    if height is not None:
        _Defaults.height = int(height)
    if stacked_height is not None:
        _Defaults.stacked_height = int(stacked_height)
    if layout_height is not None:
        _Defaults.layout_height = int(layout_height)
    if palette is not None:
        _Defaults.palette = palette
    if show_bokeh_logo is not None:
        _Defaults.show_bokeh_logo = bool(show_bokeh_logo)
    if tools is not None:
        _Defaults.tools = tools
    if grid_toolbar_location is not None:
        _Defaults.grid_toolbar_location = grid_toolbar_location
    if lattice_layout_tools is not None:
        _Defaults.lattice_layout_tools = lattice_layout_tools
    if floor_plan_tools is not None:
        _Defaults.floor_plan_tools = floor_plan_tools
    if floor_plan_annotate_elements is not None:
        _Defaults.floor_plan_annotate_elements = floor_plan_annotate_elements
    if layout_font_size is not None:
        _Defaults.layout_font_size = layout_font_size
    if floor_plan_font_size is not None:
        _Defaults.floor_plan_font_size = floor_plan_font_size
    if limit_scale_factor is not None:
        _Defaults.limit_scale_factor = float(limit_scale_factor)
    if max_data_points is not None:
        _Defaults.max_data_points = int(max_data_points)
    if variables_per_row is not None:
        _Defaults.variables_per_row = int(variables_per_row)
    if show_sliders is not None:
        _Defaults.show_sliders = bool(show_sliders)
    if line_width_scale is not None:
        _Defaults.line_width_scale = float(line_width_scale)
    if floor_line_width_scale is not None:
        _Defaults.floor_line_width_scale = float(floor_line_width_scale)
    if resources is not None:
        if resources not in ("cdn", "inline"):
            raise ValueError(f"Unexpected value for 'resources': {resources}")
        _Defaults.resources = resources
    return {
        key: value
        for key, value in vars(_Defaults).items()
        if not key.startswith("_") and key not in {"get_size_for_class"}
    }