plot

add_cbar(ax, cmap, norm, **kwargs)

Truncate or expand cmap such that it covers axes limit and and colorbar to axes

Source code in pyhdx/plot.py

def add_cbar(ax, cmap, norm, **kwargs):
    """Truncate or expand cmap such that it covers axes limit and and colorbar to axes"""

    N = cmap.N
    ymin, ymax = np.min(ax.get_ylim()), np.max(ax.get_ylim())
    values = np.linspace(ymin, ymax, num=N)

    norm_clip = copy(norm)
    norm_clip.clip = True
    colors = cmap(norm_clip(values))

    if isinstance(cmap, uplt.DiscreteColormap):
        listmode = "discrete"
    elif isinstance(cmap, uplt.ContinuousColormap):
        listmode = "continuous"
    else:
        listmode = "perceptual"

    cb_cmap = uplt.Colormap(colors, listmode=listmode)

    cb_norm = uplt.Norm("linear", vmin=ymin, vmax=ymax)  # todo allow log norms?
    cbar_kwargs = {**CBAR_KWARGS, **kwargs}
    reverse = np.diff(ax.get_ylim()) < 0

    cbar = ax.colorbar(cb_cmap, norm=cb_norm, reverse=reverse, **cbar_kwargs)

    return cbar

add_mse_panels(axes, fit_result, cmap=None, norm=None, panel_kwargs=None, fig=None, cbar=False, cbar_kwargs=None)

adds linear bar panels to axes showing some property (usually MSE)

Source code in pyhdx/plot.py

def add_mse_panels(
    axes,
    fit_result,
    cmap=None,
    norm=None,
    panel_kwargs=None,
    fig=None,
    cbar=False,
    cbar_kwargs=None,
):
    """adds linear bar panels to axes showing some property (usually MSE)"""

    residue_mse = fit_result.get_residue_mse()
    vmax = residue_mse.to_numpy().max()

    cmap = cmap or CMAP_NORM_DEFAULTS.cmaps["mse"]
    norm = norm or uplt.Norm("linear", vmin=0, vmax=vmax)

    collections = []
    for hdxm, ax in zip(fit_result.hdxm_set, axes):
        panel_kwargs = panel_kwargs or {}
        loc = panel_kwargs.pop("loc", "b")
        panel_kwargs = {"width": "5mm", "space": 0, **panel_kwargs}

        pn = ax.panel_axes(loc, **panel_kwargs)
        residue_values = residue_mse[hdxm.name]

        collection = single_linear_bar(
            pn,
            hdxm.coverage.r_number,
            residue_values.to_numpy().squeeze(),
            cmap=cmap,
            norm=norm,
        )
        collections.append(collection)

    if cbar:
        if fig is None:
            raise ValueError("Must pass 'fig' keyword argument to add a global colorbar")
        cbar_kwargs = cbar_kwargs or {}
        cbar_kwargs = {
            "width": CBAR_KWARGS["width"],
            "loc": "b",
            "length": 0.3,
            **cbar_kwargs,
        }

        cbar = fig.colorbar(cmap, norm=norm, **cbar_kwargs)
    else:
        cbar = None

    return collections, cbar

linear_bars(data, norm, cmap, cbar_sclf=1.0, **figure_kwargs)

Generate a linear bar plot with multiple subplots.

Parameters:

Name	Type	Description	Default
data	dict[str, dict[str, Series]]	A dictionary containing the data for each subplot. The keys are the top-level labels, and the values are dictionaries containing the data for each subplot. The data is represented as a pandas Series object.	required
norm		A normalization object to be applied to the color scale.	required
cmap		A colormap object to be used for coloring the bars.	required
cbar_sclf		A scaling factor to be applied to the color scale. Default is 1.0.	1.0
**figure_kwargs		Additional keyword arguments to be passed to the figure.	{}

Returns:

Name	Type	Description
fig		The figure object containing the plot.
axes		The axes object containing the subplots.
cbar		The colorbar object.

Source code in pyhdx/plot.py

def linear_bars(
    data: dict[str, dict[str, pd.Series]],
    norm,
    cmap,
    cbar_sclf=1.0,
    **figure_kwargs,
):
    """
    Generate a linear bar plot with multiple subplots.

    Args:
        data: A dictionary containing the data for each subplot. The keys are the top-level labels, and the values are dictionaries containing the data for each subplot. The data is represented as a pandas Series object.
        norm: A normalization object to be applied to the color scale.
        cmap: A colormap object to be used for coloring the bars.
        cbar_sclf: A scaling factor to be applied to the color scale. Default is 1.0.
        **figure_kwargs: Additional keyword arguments to be passed to the figure.

    Returns:
        fig: The figure object containing the plot.
        axes: The axes object containing the subplots.
        cbar: The colorbar object.
    """

    hspace = [elem for v in data.values() for elem in [0] * (len(v) - 1) + [None]][:-1]
    ncols = 1
    nrows = len(hspace) + 1

    figure_width = figure_kwargs.pop("width", cfg.plotting.page_width) / 25.4
    refaspect = figure_kwargs.pop("refaspect", cfg.plotting.linear_bars_aspect)
    cbar_width = figure_kwargs.pop("cbar_width", cfg.plotting.cbar_width) / 25.4

    fig, axes = uplt.subplots(
        nrows=nrows, ncols=ncols, refaspect=refaspect, width=figure_width, hspace=hspace
    )
    axes_iter = iter(axes)
    y_edges = [0, 1]
    for top_level, subdict in data.items():
        for i, (label, values) in enumerate(subdict.items()):
            ax = next(axes_iter)
            rmin, rmax = values.index.min(), values.index.max()
            r_edges = uplt.arange(rmin - 0.5, rmax + 0.5, 1)
            ax.pcolormesh(
                r_edges,
                y_edges,
                values.to_numpy().reshape(1, -1),
                cmap=cmap,
                vmin=norm.vmin,
                vmax=norm.vmax,
                levels=256,
            )
            ax.format(yticks=[])

            ax.text(
                1.02,
                0.5,
                label,
                horizontalalignment="left",
                verticalalignment="center",
                transform=ax.transAxes,
            )

            if i == 0:
                ax.format(title=top_level)

    axes.format(xlabel=r_xlabel)

    cmap_norm = copy(norm)
    cmap_norm.vmin *= cbar_sclf
    cmap_norm.vmax *= cbar_sclf

    cbar = fig.colorbar(cmap, norm=cmap_norm, loc="b", width=cbar_width)

    return fig, axes, cbar

linear_bars_figure(data, reference=None, groupby=None, field='dG', norm=None, cmap=None, **figure_kwargs)

Generate a linear bars figure based on the provided data.

Parameters:

Name	Type	Description	Default
data	DataFrame	A pandas DataFrame containing the data to be plotted.	required
reference	Optional[str]	An optional string representing the reference value for subtraction.	None
groupby	Optional[str]	An optional string representing the column to group the data by.	None
field	str	A string representing the field to be plotted. Default is "dG".	'dG'
norm		An optional normalization function.	None
cmap		An optional colormap.	None
**figure_kwargs		Additional keyword arguments to be passed to the figure.	{}

Returns:

Name	Type	Description
fig		The generated figure.
axes		The axes of the figure.
cbar		The colorbar of the figure.

Source code in pyhdx/plot.py

def linear_bars_figure(
    data: pd.DataFrame,
    reference: Optional[str] = None,
    groupby: Optional[str] = None,
    field: str = "dG",
    norm=None,
    cmap=None,
    **figure_kwargs,
):
    """
    Generate a linear bars figure based on the provided data.

    Args:
        data: A pandas DataFrame containing the data to be plotted.
        reference: An optional string representing the reference value for subtraction.
        groupby: An optional string representing the column to group the data by.
        field: A string representing the field to be plotted. Default is "dG".
        norm: An optional normalization function.
        cmap: An optional colormap.
        **figure_kwargs: Additional keyword arguments to be passed to the figure.

    Returns:
        fig: The generated figure.
        axes: The axes of the figure.
        cbar: The colorbar of the figure.
    """

    if reference is None and field == "dG":
        cmap_default, norm_default = CMAP_NORM_DEFAULTS["dG"]
        ylabel = dG_ylabel
        sclf = 1e-3
    elif reference is not None and field == "dG":
        cmap_default, norm_default = CMAP_NORM_DEFAULTS["ddG"]
        ylabel = ddG_ylabel
        sclf = 1e-3
    elif reference is None and field == "rfu":
        cmap_default, norm_default = CMAP_NORM_DEFAULTS["rfu"]
        ylabel = "RFU"
        sclf = 1.0
    elif reference is not None and field == "rfu":
        cmap_default, norm_default = CMAP_NORM_DEFAULTS["drfu"]
        ylabel = "ΔRFU"
        sclf = 1.0
    else:
        cmap_default, norm_default = None, None
        ylabel = ""
        sclf = 1.0

    cmap = cmap or cmap_default
    norm = norm or norm_default

    if cmap is None:
        raise ValueError("No valid Colormap found")
    if norm is None:
        raise ValueError("No valid Norm found")

    reduced = data.xs(level=-1, key=field, axis=1)

    if groupby:
        grp_level = reduced.columns.names.index(groupby)
        bar_level = 1 - grp_level
    else:
        grp_level, bar_level = 0, 1

    flat = reduced.columns.to_flat_index().tolist()
    series_list = [reduced[col] for col in reduced.columns]

    # nest the individual pandas series in a dict according to grp / bar level
    result = defaultdict(dict)
    for tup, series in zip(flat, series_list):
        result[tup[grp_level]][tup[bar_level]] = series

    # subract reference values if given
    if reference is not None:
        for subdict in result.values():
            ref_values = subdict.pop(reference)
            for name, values in subdict.items():
                subdict[name] = values - ref_values

    fig, axes, cbar = linear_bars(
        result,
        norm=norm,
        cmap=cmap,
        cbar_sclf=sclf,
        **figure_kwargs,
    )

    cbar.set_label(ylabel)

    return fig, axes, cbar

residue_time_scatter_figure(hdxm, field='rfu', cmap='turbo', norm=None, scatter_kwargs=None, cbar_kwargs=None, **figure_kwargs)

per-residue per-exposure values for field field by weighted averaging

Source code in pyhdx/plot.py

def residue_time_scatter_figure(
    hdxm,
    field="rfu",
    cmap="turbo",
    norm=None,
    scatter_kwargs=None,
    cbar_kwargs=None,
    **figure_kwargs,
):
    """per-residue per-exposure values for field  `field` by weighted averaging"""

    n_subplots = hdxm.Nt
    ncols = figure_kwargs.pop("ncols", min(cfg.plotting.ncols, n_subplots))
    nrows = figure_kwargs.pop("nrows", int(np.ceil(n_subplots / ncols)))
    figure_width = figure_kwargs.pop("width", cfg.plotting.page_width) / 25.4
    refaspect = figure_kwargs.pop("refaspect", cfg.plotting.residue_scatter_aspect)
    # cbar_width = figure_kwargs.pop("cbar_width", cfg.plotting.cbar_width) / 25.4

    cmap = uplt.Colormap(cmap)  # todo allow None as cmap
    norm = norm or uplt.Norm("linear", vmin=0, vmax=1)

    fig, axes = uplt.subplots(
        ncols=ncols,
        nrows=nrows,
        width=figure_width,
        refaspect=refaspect,
        sharey=4,
        **figure_kwargs,
    )
    scatter_kwargs = scatter_kwargs or {}
    axes_iter = iter(axes)
    for hdx_tp in hdxm:
        ax = next(axes_iter)
        residue_time_scatter(
            ax, hdx_tp, field=field, cmap=cmap, norm=norm, cbar=False, **scatter_kwargs
        )  # todo cbar kwargs? (check with other methods)
        ax.format(title=f"exposure: {hdx_tp.exposure:.1f}")

    for ax in axes_iter:
        ax.axis("off")

    axes.format(xlabel=r_xlabel, ylabel=field)

    cbar_kwargs = cbar_kwargs or {}
    cbars = []
    for ax in axes:
        if not ax.axison:
            continue

        cbar = add_cbar(ax, cmap, norm, **cbar_kwargs)
        cbars.append(cbar)

    return fig, axes, cbars

single_linear_bar(ax, x, z, cmap, norm, **kwargs)

makes a linear bar plot on supplied axis with values z and corresponding x values x

Source code in pyhdx/plot.py

def single_linear_bar(ax, x, z, cmap, norm, **kwargs):
    """makes a linear bar plot on supplied axis with values z and corresponding x values x"""

    if isinstance(z, pd.Series):
        z = z.to_numpy()
    elif isinstance(z, pd.DataFrame):
        assert len(z.columns) == 1, "Can only plot dataframes with 1 column"
        z = z.to_numpy().squeeze()

    img = np.expand_dims(z, 0)

    collection = ax.pcolormesh(
        uplt.edges(x),
        np.array([0, 1]),
        img,
        cmap=cmap,
        vmin=norm.vmin,
        vmax=norm.vmax,
        levels=256,
        **kwargs,
    )
    ax.format(yticks=[])

    return collection