diff --git a/CHANGELOG.md b/CHANGELOG.md index b858753c2..4a42d8796 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -69,6 +69,7 @@ This major release comes with significant overhauls of some core components of C - `BPM` elements now support misalignments (see #533) (@roussel-ryan, @jank324) - Speed up tracking by replacing some PyTorch operations with faster alternatives (see #538, #558, #555, #556, #563, #561) (@jank324, @Hespe) - New `CombinedCorrector` element that combines the functionality of `HorizontalCorrector` and `VerticalCorrector` (see #589) (@jank324, @amylizzle) +- Add mean and uncertainty plotting functionalities to `ParticleBeam` plotting over vectorised beams (see #584) (@jp-ga, @jank324) ### 🐛 Bug fixes diff --git a/cheetah/particles/particle_beam.py b/cheetah/particles/particle_beam.py index 8073f1b55..321e0d67e 100644 --- a/cheetah/particles/particle_beam.py +++ b/cheetah/particles/particle_beam.py @@ -12,6 +12,8 @@ from cheetah.particles.beam import Beam from cheetah.particles.species import Species from cheetah.utils import ( + distribution_histogram_and_confidence_1d, + distribution_histogram_and_confidence_2d, elementwise_linspace, format_axis_with_prefixed_unit, match_distribution_moments, @@ -1284,46 +1286,65 @@ def plot_1d_distribution( bins: int = 100, bin_range: tuple[float] | None = None, smoothing: float = 0.0, + errorbar: tuple[str, int | float] | str = ("pi", 95), plot_kws: dict | None = None, + fill_between_kws: dict | None = None, ax: plt.Axes | None = None, ) -> plt.Axes: """ - Plot a 1D histogram of the given dimension of the particle distribution. + Plot a 1-dimensional histogram of the given phase-space dimension. :param dimension: Name of the dimension to plot. Should be one of `('x', 'px', 'y', 'py', 'tau', 'p')`. - :param bins: Number of bins to use for the histogram. - :param bin_range: Range of the bins to use for the histogram. + :param bins: Number of histogram bins. + :param bin_range: Tuple (min, max) specifying the histogram range, or `None` to + infer from the data. :param smoothing: Standard deviation of the Gaussian kernel used to smooth the histogram. - :param plot_kws: Additional keyword arguments to be passed to `plot` function of - matplotlib used to plot the histogram data. - :param ax: Matplotlib axes object to use for plotting. - :return: Matplotlib axes object with the plot. + :param errorbar: Method to compute uncertainty bands over vectorised beams. + Pass either a method string or a tuple `(method, level)`. Available methods + are "sd", "se" and "pi". + :param plot_kws: Additional keyword arguments forwarded to + `matplotlib.axes.Axes.plot`. + :param fill_between_kws: Additional keyword arguments forwarded to + `matplotlib.axes.Axes.fill_between`. + :param ax: Matplotlib axes object to use for plotting. If `None` a new axes is + created. + :return: Matplotlib axes containing the plotted histogram. """ if ax is None: _, ax = plt.subplots() - x_array = getattr(self, dimension).cpu().detach().numpy() - histogram, edges = np.histogram(x_array, bins=bins, range=bin_range) - centers = (edges[:-1] + edges[1:]) / 2 + bin_centers, histogram, lower_bound, upper_bound = ( + distribution_histogram_and_confidence_1d( + a=getattr(self, dimension), + bins=bins, + bin_range=bin_range, + errorbar=errorbar, + ) + ) - if smoothing: - histogram = gaussian_filter(histogram, smoothing) + if upper_bound is not None and lower_bound is not None: + smoothed_lower_bound = gaussian_filter(lower_bound, smoothing) + smoothed_upper_bound = gaussian_filter(upper_bound, smoothing) + ax.fill_between( + bin_centers, + smoothed_lower_bound, + smoothed_upper_bound, + **({"color": "C1", "alpha": 0.5} | (fill_between_kws or {})), + ) - ax.plot( - centers, - histogram / histogram.max(), - **{"color": "black"} | (plot_kws or {}), - ) - ax.set_xlabel(f"{self.PRETTY_DIMENSION_LABELS[dimension]}") + smoothed_histogram = gaussian_filter(histogram, smoothing) + ax.plot(bin_centers, smoothed_histogram, **({"color": "C0"} | (plot_kws or {}))) # Handle units - if dimension in ("x", "y", "tau"): - base_unit = "m" + ax.set_xlabel(f"{self.PRETTY_DIMENSION_LABELS[dimension]}") if dimension in ("x", "y", "tau"): - format_axis_with_prefixed_unit(ax.xaxis, base_unit, centers) + base_unit = "m" + format_axis_with_prefixed_unit( + ax.xaxis, base_unit, bin_centers.numpy() + ) # Take `.numpy()` because `np.max` somehow acts up on `torch.Tensor`s return ax @@ -1332,81 +1353,111 @@ def plot_2d_distribution( x_dimension: Literal["x", "px", "y", "py", "tau", "p"], y_dimension: Literal["x", "px", "y", "py", "tau", "p"], style: Literal["histogram", "contour"] = "histogram", - bins: int = 100, - bin_ranges: tuple[tuple[float]] | None = None, - histogram_smoothing: float = 0.0, - contour_smoothing: float = 3.0, + bins: tuple[int, int] = (100, 100), + bin_ranges: tuple[tuple[float, float], tuple[float, float]] | None = None, + errorbar: tuple[str, int | float] | str = ("pi", 95), + smoothing: float = 0.0, pcolormesh_kws: dict | None = None, - contour_kws: dict | None = None, + distribution_contour_kws: dict | None = None, + confidence_contour_kws: dict | None = None, ax: plt.Axes | None = None, ) -> plt.Axes: """ - Plot a 2D histogram of the given dimensions of the particle distribution. - - :param x_dimension: Name of the x dimension to plot. Should be one of - `('x', 'px', 'y', 'py', 'tau', 'p')`. - :param y_dimension: Name of the y dimension to plot. Should be one of - `('x', 'px', 'y', 'py', 'tau', 'p')`. - :param style: Style of the plot. Should be one of `('histogram', 'contour')`. - :param bins: Number of bins to use for the histogram in both dimensions. - :param bin_ranges: Ranges of the bins to use for the histogram in each - dimension. - :param smoothing: Standard deviation of the Gaussian kernel used to smooth the - histogram. - :param pcolormesh_kws: Additional keyword arguments to be passed to `pcolormesh` - function of matplotlib used to plot the histogram data. - :param contour_kws: Additional keyword arguments to be passed to `contour` - function of matplotlib used to plot the histogram data. - :param ax: Matplotlib axes object to use for plotting. - :return: Matplotlib axes object with the plot. + Plot a 2-dimensional projection of the particle distribution for two phase-space + dimensions. + + :param x_dimension: Name of the dimension plotted on the x-axis. Should be one + of `('x', 'px', 'y', 'py', 'tau', 'p')`. + :param y_dimension: Name of the dimension plotted on the y-axis. Should be one + of `('x', 'px', 'y', 'py', 'tau', 'p')`. + :param style: Visualisation style, either 'histogram' (coloured 2-dimensional + histogram) or 'contour' (normalised contour levels with greyscale + `pcolormesh`). + :param bins: Tuple (nx, ny) specifying the number of histogram bins for x and y. + :param bin_ranges: Tuple ((x_min, x_max), (y_min, y_max)) specifying the + histogram ranges for x and y, or `None` to infer from the data. + :param errorbar: Method to compute uncertainty bands over vectorised beams. Pass + either a method string or a tuple `(method, level)`. Available methods are + "sd", "se" and "pi". + :param smoothing: Standard deviation of the Gaussian kernel applied to smooth + the histogram. + :param pcolormesh_kws: Additional keyword arguments forwarded to + `matplotlib.pcolormesh`. + :param distribution_contour_kws: Additional keyword arguments forwarded to + `matplotlib.contour` when drawing distribution contours. + :param confidence_contour_kws: Additional keyword arguments forwarded to + `matplotlib.contour` when drawing confidence contours. + :param ax: Matplotlib axes object to use for plotting. If `None` a new axes is + created. + :return: Matplotlib axes containing the plotted histogram. """ if ax is None: _, ax = plt.subplots() - histogram, x_edges, y_edges = np.histogram2d( - getattr(self, x_dimension).cpu().detach().numpy(), - getattr(self, y_dimension).cpu().detach().numpy(), - bins=bins, - range=bin_ranges, + bin_centers_x, bin_centers_y, mean_histogram, lower_bound, upper_bound = ( + distribution_histogram_and_confidence_2d( + x=getattr(self, x_dimension), + y=getattr(self, y_dimension), + bins=bins, + bin_ranges=bin_ranges, + errorbar=errorbar, + ) ) - x_centers = (x_edges[:-1] + x_edges[1:]) / 2 - y_centers = (y_edges[:-1] + y_edges[1:]) / 2 # Post-process and plot - smoothed_histogram = gaussian_filter(histogram, histogram_smoothing) - clipped_histogram = np.where(smoothed_histogram > 1, smoothed_histogram, np.nan) + smoothed_histogram = gaussian_filter(mean_histogram, smoothing) + if style == "histogram": ax.pcolormesh( - x_edges, - y_edges, - clipped_histogram.T / smoothed_histogram.max(), - **{"cmap": "rainbow"} | (pcolormesh_kws or {}), + bin_centers_x, + bin_centers_y, + smoothed_histogram.mT, + **({"cmap": "rainbow"} | (pcolormesh_kws or {})), ) elif style == "contour": - contour_histogram = gaussian_filter(histogram, contour_smoothing) - - ax.contour( - x_centers, - y_centers, - contour_histogram.T / contour_histogram.max(), - **{"levels": 3} | (contour_kws or {}), + contour_set_of_mean = ax.contour( + bin_centers_x, + bin_centers_y, + smoothed_histogram.mT, + **({"levels": 3} | (distribution_contour_kws or {})), ) + if lower_bound is not None and upper_bound is not None: + smoothed_lower_bound = gaussian_filter(lower_bound, smoothing) + smoothed_upper_bound = gaussian_filter(upper_bound, smoothing) + + ax.contour( + bin_centers_x, + bin_centers_y, + smoothed_lower_bound.mT, + **( + {"levels": contour_set_of_mean.levels, "linestyles": "--"} + | (confidence_contour_kws or {}) + ), + ) + ax.contour( + bin_centers_x, + bin_centers_y, + smoothed_upper_bound.mT, + **( + {"levels": contour_set_of_mean.levels, "linestyles": "--"} + | (confidence_contour_kws or {}) + ), + ) + else: + raise ValueError("style must be either 'histogram' or 'contour'.") + + # Handle units ax.set_xlabel(f"{self.PRETTY_DIMENSION_LABELS[x_dimension]}") ax.set_ylabel(f"{self.PRETTY_DIMENSION_LABELS[y_dimension]}") - # Handle units if x_dimension in ("x", "y", "tau"): x_base_unit = "m" + format_axis_with_prefixed_unit(ax.xaxis, x_base_unit, bin_centers_x.numpy()) if y_dimension in ("x", "y", "tau"): y_base_unit = "m" - - if x_dimension in ("x", "y", "tau"): - format_axis_with_prefixed_unit(ax.xaxis, x_base_unit, x_centers) - - if y_dimension in ("x", "y", "tau"): - format_axis_with_prefixed_unit(ax.yaxis, y_base_unit, y_centers) + format_axis_with_prefixed_unit(ax.yaxis, y_base_unit, bin_centers_y.numpy()) return ax @@ -1414,30 +1465,34 @@ def plot_distribution( self, dimensions: tuple[str, ...] = ("x", "px", "y", "py", "tau", "p"), bins: int = 100, - bin_ranges: Literal["same"] | tuple[float] | list[tuple[float]] | None = None, + bin_ranges: ( + Literal["unit_same"] | tuple[float] | list[tuple[float]] | None + ) = None, + errorbar: tuple[str, int | float] | str = ("pi", 95), plot_1d_kws: dict | None = None, plot_2d_kws: dict | None = None, axs: list[plt.Axes] | None = None, ) -> tuple[plt.Figure, np.ndarray]: """ - Plot of coordinates projected into 2D planes. + Create a matrix plot of 1-dimensional and 2-dimensional projections for the + requested phase space dimensions. :param dimensions: Tuple of dimensions to plot. Should be a subset of `('x', 'px', 'y', 'py', 'tau', 'p')`. - :param contour: If `True`, overlay contour lines on the 2D histogram plots. :param bins: Number of bins to use for the histograms. :param bin_ranges: Ranges of the bins to use for the histograms. If set to `"unit_same"`, the same range is used for all dimensions that share the same unit. If set to `None`, ranges are determined automatically. - :param smoothing: Standard deviation of the Gaussian kernel used to smooth the - histograms. + :param errorbar: Method to compute uncertainty bands over vectorised beams. Pass + either a method string or a tuple `(method, level)`. Available methods + are "sd", "se" and "pi". :param plot_1d_kws: Additional keyword arguments to be passed to - `ParticleBeam.plot_1d_distribution` for plotting 1D histograms. + `ParticleBeam.plot_1d_distribution` for plotting 1-dimensional histograms. :param plot_2d_kws: Additional keyword arguments to be passed to - `ParticleBeam.plot_2d_distribution` for plotting 2D histograms. + `ParticleBeam.plot_2d_distribution` for plotting 2-dimensional histograms. :param axs: List of Matplotlib axes objects to use for plotting. If set to - `None`, a new figure is created. Must have the shape `(len(dimensions), - len(dimensions))`. + `None`, a new figure is created. Must have the shape + `(len(dimensions), len(dimensions))`. :return: Matplotlib figure and axes objects with the plot. """ if axs is None: @@ -1531,6 +1586,7 @@ def plot_distribution( dimension=dimension, bins=bins, bin_range=bin_range, + errorbar=errorbar, ax=ax, **(plot_1d_kws or {}), ) @@ -1540,8 +1596,9 @@ def plot_distribution( self.plot_2d_distribution( x_dimension=dimensions[i], y_dimension=dimensions[j], - bins=bins, + bins=(bins, bins), bin_ranges=(bin_ranges[i], bin_ranges[j]), + errorbar=errorbar, ax=axs[j, i], **(plot_2d_kws or {}), ) diff --git a/cheetah/utils/__init__.py b/cheetah/utils/__init__.py index 9f8059855..ebcb6b876 100644 --- a/cheetah/utils/__init__.py +++ b/cheetah/utils/__init__.py @@ -9,11 +9,16 @@ format_axis_with_prefixed_unit, ) from .statistics import ( # noqa: F401 + distribution_histogram_and_confidence_1d, + distribution_histogram_and_confidence_2d, + histograms_mean_and_confidence, match_distribution_moments, unbiased_weighted_covariance, unbiased_weighted_covariance_matrix, unbiased_weighted_std, unbiased_weighted_variance, + vectorized_histogram_1d, + vectorized_histogram_2d, ) from .unique_name_generator import UniqueNameGenerator # noqa: F401 from .vector import squash_index_for_unavailable_dims # noqa: F401 diff --git a/cheetah/utils/statistics.py b/cheetah/utils/statistics.py index c20e75527..feaa8d84e 100644 --- a/cheetah/utils/statistics.py +++ b/cheetah/utils/statistics.py @@ -1,3 +1,5 @@ +import math + import torch @@ -141,3 +143,272 @@ def match_distribution_moments( ).mT + mu return transformed_samples + + +def distribution_histogram_and_confidence_1d( + a: torch.Tensor, + bins: int = 100, + bin_range: tuple[float] | None = None, + errorbar: tuple[str, int | float] | str = ("pi", 95), +) -> tuple[torch.Tensor]: + """ + Compute the mean histogram and confidence interval over vectorised samples of a + 1-dimensional distribution. + + Also works for non-vectorised inputs, in which case the histogram is computed and + `None` is returned for the confidence bounds. + + :param a: Input distribution. Can be a single distribution of shape (num_samples,) + or a vectorisation of multiple distributions of shape (..., num_samples). + :param bins: Number of histogram bins. + :param bin_range: Tuple (min, max) specifying the histogram range, or `None` to + infer from the data. + :param errorbar: Method to compute uncertainty over vectorised beams. Pass either a + method string or a tuple `(method, level)`. Available methods are "sd", "se" and + "pi". + :return: Tuple (bin_centers, mean_histogram, lower_bound, upper_bound) with vector + dimensions reduced. + """ + histogram, bin_edges = vectorized_histogram_1d(a, bins=bins, bin_range=bin_range) + + bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2 + + if len(a.shape) == 1: + return (bin_centers, histogram, None, None) + else: + mean_histogram, lower_bound, upper_bound = histograms_mean_and_confidence( + histogram.to(a.dtype).flatten(start_dim=0, end_dim=-2), errorbar=errorbar + ) + + return (bin_centers, mean_histogram, lower_bound, upper_bound) + + +def distribution_histogram_and_confidence_2d( + x: torch.Tensor, + y: torch.Tensor, + bins: tuple[int, int] = (100, 100), + bin_ranges: tuple[tuple[float, float], tuple[float, float]] | None = None, + errorbar: tuple[str, int | float] | str = ("pi", 95), +) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]: + """ + Compute the mean histogram and confidence interval over vectorised samples of a + 2-dimensional distribution. + + Also works for non-vectorised inputs, in which case the histogram is computed and + `None` is returned for the confidence bounds. + + :param x: x coordinates of the distribution to be histogrammed. Can be a single + distribution of shape (num_samples,) or a vectorisation of multiple + distributions of shape (..., num_samples). + :param y: y coordinates of the distribution to be histogrammed. Can be a single + distribution of shape (num_samples,) or a vectorisation of multiple + distributions of shape (..., num_samples). + :param bins: Tuple (nx, ny) specifying the number of histogram bins for x and y. + :param bin_ranges: Tuple ((x_min, x_max), (y_min, y_max)) specifying the histogram + ranges for x and y, or `None` to infer from the data. + :param errorbar: Method to compute uncertainty over vectorised beams. Pass either a + method string or a tuple `(method, level)`. Available methods are "sd", "se" and + "pi". + :returns: Tuple (bin_centers_x, bin_centers_y, mean_histogram, lower_bound, + upper_bound) with vector dimensions reduced. + """ + histogram, x_edges, y_edges = vectorized_histogram_2d( + x, y, bins=bins, bin_ranges=bin_ranges + ) + + x_centers = (x_edges[:-1] + x_edges[1:]) / 2 + y_centers = (y_edges[:-1] + y_edges[1:]) / 2 + + if len(x.shape) == 1: + return x_centers, y_centers, histogram, None, None + else: + mean_histogram, lower_bound, upper_bound = histograms_mean_and_confidence( + histogram.to(x.dtype).flatten(start_dim=0, end_dim=-3), errorbar=errorbar + ) + return x_centers, y_centers, mean_histogram, lower_bound, upper_bound + + +def vectorized_histogram_1d( + a: torch.Tensor, bins: int = 100, bin_range: tuple[float] | None = None +) -> tuple[torch.Tensor]: + """ + Compute a histogram for a 1-dimensional distribution or multiple vectorised + histograms for vectorised distributions. + + :param a: Input distribution. Can be a single distribution of shape (num_samples,) + or a vectorisation of multiple distributions of shape (..., num_samples). + :param bins: Number of histogram bins. + :param bin_range: Tuple (min, max) specifying the histogram range, or `None` to + infer from the data. + :return: Tuple (histogram, bin_edges) with `histogram` the bin counts of shape + (..., bins) and `bin_edges` a 1-dimensional tensor of shape (bins + 1,). + """ + factory_kwargs = {"device": a.device, "dtype": a.dtype} + + if bin_range is None: + bin_range = (a.min(), a.max()) + + # If the input is not vectorised, make it vectorised with vector size 1 + was_input_vectorized = a.dim() > 1 + if not was_input_vectorized: + a = a.unsqueeze(0) # (1, num_samples) + + # Flatten the vector dimensions for the following computations + original_vector_shape = a.shape[:-1] + a = a.flatten(start_dim=0, end_dim=-2) # (num_vector_elements, num_samples) + num_vector_elements = a.shape[0] + + bin_edges = torch.linspace(*bin_range, bins + 1, **factory_kwargs) + boundaries = bin_edges[1:-1] + bin_indicies = torch.bucketize(a.contiguous(), boundaries) + + # Flatten batch with offsets + vector_offsets = ( + torch.arange(num_vector_elements, device=a.device) * bins + ) # (num_vector_elements,) + bin_indicies_flat = ( + bin_indicies + vector_offsets.unsqueeze(-1) + ).flatten() # (num_vector_elements * num_bins,) + + # Count occurrences + histogram_flat = bin_indicies_flat.bincount( + minlength=num_vector_elements * bins + ) # (num_vector_elements * bins,) + histogram = histogram_flat.reshape(*original_vector_shape, bins) + + # Remove the vector dimension if the input was not vectorised + if not was_input_vectorized: + histogram = histogram.squeeze(0) + + return histogram, bin_edges + + +def vectorized_histogram_2d( + x: torch.Tensor, + y: torch.Tensor, + bins: tuple[int, int] = (100, 100), + bin_ranges: tuple[tuple[float, float], tuple[float, float]] | None = None, +) -> tuple[torch.Tensor]: + """ + Compute a histogram for a 2-dimensional distribution or multiple vectorised + histograms for vectorised distributions. + + :param x: x coordinates of the distribution to be histogrammed. Can be a single + distribution of shape (num_samples,) or a vectorisation of multiple + distributions of shape (..., num_samples). + :param y: y coordinates of the distribution to be histogrammed. Can be a single + distribution of shape (num_samples,) or a vectorisation of multiple + distributions of shape (..., num_samples). + :param bins: Tuple (nx, ny) specifying the number of histogram bins for x and y. + :param bin_ranges: Tuple ((x_min, x_max), (y_min, y_max)) specifying the histogram + ranges for x and y, or `None` to infer from the data. + :return: Tuple (histogram, bin_edges_x, bin_edges_y) with `histogram` the bin counts + of shape (..., nx, ny) or (nx, ny) and `bin_edges_x`, `bin_edges_y` + 1-dimensional tensors of shape (nx + 1,) and (ny + 1,), respectively. + """ + factory_kwargs = {"device": x.device, "dtype": x.dtype} + + if bin_ranges is None: + bin_ranges = ( + (float(x.min()), float(x.max())), + (float(y.min()), float(y.max())), + ) + + # If the inputs are not vectorised, make them vectorised with vector size 1 + was_input_vectorized = x.dim() > 1 + if not was_input_vectorized: + x = x.unsqueeze(0) # (1, N) + y = y.unsqueeze(0) # (1, N) + + # Flatten the vector dimensions for the following computations + original_vector_shape = x.shape[:-1] + x_flat = x.flatten(start_dim=0, end_dim=-2) # (num_vector_elements, num_samples) + y_flat = y.flatten(start_dim=0, end_dim=-2) # (num_vector_elements, num_samples) + num_vector_elements = x_flat.shape[0] + + bin_edges_x = torch.linspace( + bin_ranges[0][0], bin_ranges[0][1], bins[0] + 1, **factory_kwargs + ) + bin_edges_y = torch.linspace( + bin_ranges[1][0], bin_ranges[1][1], bins[1] + 1, **factory_kwargs + ) + boundaries_x = bin_edges_x[1:-1] + boundaries_y = bin_edges_y[1:-1] + bin_indicies_x = torch.bucketize(x_flat.contiguous(), boundaries_x) + bin_indicies_y = torch.bucketize(y_flat.contiguous(), boundaries_y) + + # Flatten 2-dimensional bin indices to 1 dimension + bin_indicies_flat = bin_indicies_x * bins[1] + bin_indicies_y + + # Flatten batch with offsets + vector_offsets = torch.arange(num_vector_elements, device=x.device) * ( + bins[0] * bins[1] + ) + bin_indicies_flat = (bin_indicies_flat + vector_offsets.unsqueeze(1)).flatten() + + # Count occurrences + histogram_flat = torch.bincount( + bin_indicies_flat, minlength=num_vector_elements * bins[0] * bins[1] + ) + histogram = histogram_flat.reshape(*original_vector_shape, *bins) + + # Remove the vector dimension if the input was not vectorised + if not was_input_vectorized: + histogram = histogram.squeeze(0) + + return histogram, bin_edges_x, bin_edges_y + + +def histograms_mean_and_confidence( + histograms: torch.Tensor, errorbar: tuple[str, int | float] | str = ("pi", 95) +): + """ + Compute elementwise mean and two-sided confidence bounds over an ensemble of + histograms. + + NOTE: This function assumes exactly one vector dimension. If you have multiple + vector dimensions, you must flatten them before passing to this function. + + :param histograms: Tensor of multiple histograms with shape + (vector_size, *single_histogram_shape). + :param errorbar: Method to compute uncertainty over vectorised beams. Pass either a + method string or a tuple `(method, level)`. Available methods are "sd", "se" and + "pi". + :return: Tuple of the mean histogram, lower bound and upper bound, with each the + vector dimensions reduced. + """ + if isinstance(errorbar, str): + error_method = errorbar + error_level = None + else: + error_method, error_level = errorbar + + mean = histograms.mean(dim=0) + + if error_method == "sd": + if error_level is None: + error_level = 3.0 + + std_dev = histograms.std(dim=0) + lower_bound = mean - error_level * std_dev + upper_bound = mean + error_level * std_dev + elif error_method == "se": + if error_level is None: + error_level = 3.0 + + std_error = histograms.std(dim=0) / math.sqrt(histograms.shape[0]) + lower_bound = mean - error_level * std_error + upper_bound = mean + error_level * std_error + elif error_method == "pi": + if error_level is None: + error_level = 95.0 + + alpha = 1 - error_level / 100 + lower_bound = histograms.quantile(alpha / 2, dim=0) + upper_bound = histograms.quantile(1 - alpha / 2, dim=0) + else: + raise ValueError( + f"Invalid error method: {error_method}. Must be 'sd', 'se', or 'pi'." + ) + + return mean, lower_bound, upper_bound diff --git a/docs/examples/ensemble_plot.ipynb b/docs/examples/ensemble_plot.ipynb new file mode 100644 index 000000000..15d14cc36 --- /dev/null +++ b/docs/examples/ensemble_plot.ipynb @@ -0,0 +1,372 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b03d0048", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import torch\n", + "\n", + "from cheetah import ParticleBeam" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c45870f4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([10, 10000, 7])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "num_runs = 10\n", + "num_samples = 10000\n", + "\n", + "mean = torch.zeros(6)\n", + "cov = torch.diag(torch.tensor((1.0, 1.0, 9.0, 9.0, 1.0, 1.0))) * 1e-6\n", + "normal_distribution = torch.distributions.MultivariateNormal(\n", + " mean, covariance_matrix=cov\n", + ")\n", + "coordinates_6d = normal_distribution.sample((num_runs, num_samples))\n", + "coordinates_7d = torch.concatenate(\n", + " (coordinates_6d, torch.ones(num_runs, num_samples, 1)), dim=-1\n", + ")\n", + "\n", + "coordinates_7d.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0e85ac55", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([10, 10000, 7])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vectorized_beam = ParticleBeam(particles=coordinates_7d, energy=torch.tensor(40.0e6))\n", + "vectorized_beam.particles.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "45afe9a6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([10000, 7])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "single_beam = vectorized_beam[0]\n", + "single_beam.particles.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1dfcbefc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([10, 10000, 7])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vectorized_beam.particles.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "91bb14c7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([10, 10000])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vectorized_beam.x.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "52ec312c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "single_beam.plot_1d_distribution(dimension=\"x\", bins=50, smoothing=1.0)\n", + "plt.show()\n", + "vectorized_beam.plot_1d_distribution(dimension=\"x\", bins=50, smoothing=1.0)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "8dd49538", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "single_beam.plot_2d_distribution(\n", + " x_dimension=\"x\",\n", + " y_dimension=\"y\",\n", + " bins=(50, 50),\n", + " errorbar=(\"pi\", 90),\n", + " smoothing=1.0,\n", + " style=\"histogram\",\n", + ")\n", + "plt.show()\n", + "vectorized_beam.plot_2d_distribution(\n", + " x_dimension=\"x\",\n", + " y_dimension=\"y\",\n", + " bins=(50, 50),\n", + " errorbar=(\"pi\", 90),\n", + " smoothing=1.0,\n", + " style=\"histogram\",\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "8a5feb31", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "single_beam.plot_2d_distribution(\n", + " x_dimension=\"x\",\n", + " y_dimension=\"y\",\n", + " bins=(50, 50),\n", + " errorbar=(\"pi\", 90),\n", + " smoothing=1.0,\n", + " style=\"contour\",\n", + ")\n", + "plt.show()\n", + "vectorized_beam.plot_2d_distribution(\n", + " x_dimension=\"x\",\n", + " y_dimension=\"y\",\n", + " bins=(50, 50),\n", + " errorbar=(\"pi\", 90),\n", + " smoothing=1.0,\n", + " style=\"contour\",\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "588b6d7a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "d0086d23", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "single_beam.plot_distribution(bins=50, plot_2d_kws={\"style\": \"contour\"})\n", + "plt.show()\n", + "vectorized_beam.plot_distribution(bins=50, plot_2d_kws={\"style\": \"contour\"})\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "df101356", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "single_beam.plot_distribution(bins=50, plot_2d_kws={\"style\": \"histogram\"})\n", + "plt.show()\n", + "vectorized_beam.plot_distribution(bins=50, plot_2d_kws={\"style\": \"histogram\"})\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f66c70e5", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "cheetah-dev", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/setup.py b/setup.py index e9c2e50db..a5db439c0 100644 --- a/setup.py +++ b/setup.py @@ -31,10 +31,10 @@ def get_version(): packages=[package for package in find_packages() if package.startswith("cheetah")], python_requires=">=3.11", install_requires=[ - "matplotlib>=3.5", - "numpy>=1.23.3", - "scipy>=1.10.1", - "torch[opt-einsum]>=2.3", + "matplotlib>=3.9.0", + "numpy>=2.0.0", + "scipy>=1.13.0", + "torch[opt-einsum]>=2.3.0", ], extras_require={ "3d-visualization": ["trimesh>=4.4.0", "requests>=2.32.2", "tqdm>=4.66.0"], diff --git a/test_minimum_requirements_constraints.txt b/test_minimum_requirements_constraints.txt index 3185719cb..cb1648e14 100644 --- a/test_minimum_requirements_constraints.txt +++ b/test_minimum_requirements_constraints.txt @@ -1,7 +1,7 @@ -matplotlib==3.5.0 -numpy==1.23.3 +matplotlib==3.9.0 +numpy==2.0.0 requests==2.32.2 -scipy==1.10.1 +scipy==1.13.0 torch==2.3.0 tqdm==4.66.0 trimesh==4.4.0 diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 484cce78b..42852c948 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -159,3 +159,31 @@ def test_plot_particle_beam_point_cloud(): # Run the plotting to see if it raises an exception _ = beam.plot_point_cloud() + + +@pytest.mark.parametrize("style", ["histogram", "contour"]) +def test_plot_vectorized_distribution(style): + """ + Test that plotting the distribution of a vectorised `ParticleBeam` does not raise an + exception. + """ + num_beams = 10 + num_particles = 10_000 + + mean = torch.zeros(6) + cov = torch.diag(torch.tensor([1e-6, 1e-6, 9e-6, 9e-6, 1e-6, 1e-6])) + distribution = torch.distributions.MultivariateNormal(mean, cov) + + coordinates_6d = distribution.sample((num_beams, num_particles)) + coordinates_7d = torch.cat( + (coordinates_6d, torch.ones(num_beams, num_particles, 1)), dim=-1 + ) + + beam_ensemble = cheetah.ParticleBeam( + particles=coordinates_7d, energy=torch.tensor(40.0e6) + ) + + # Run the plotting to see if it raises an exception + _ = beam_ensemble.plot_distribution( + bin_ranges="unit_same", plot_2d_kws={"style": style} + ) diff --git a/tests/test_statistics.py b/tests/test_statistics.py index 36bf870ef..d930939fb 100644 --- a/tests/test_statistics.py +++ b/tests/test_statistics.py @@ -1,10 +1,16 @@ +import pytest import torch from cheetah.utils import ( + distribution_histogram_and_confidence_1d, + distribution_histogram_and_confidence_2d, + histograms_mean_and_confidence, match_distribution_moments, unbiased_weighted_covariance, unbiased_weighted_covariance_matrix, unbiased_weighted_variance, + vectorized_histogram_1d, + vectorized_histogram_2d, ) @@ -156,3 +162,158 @@ def test_match_distribution_moments(): # Check if moments match assert torch.allclose(transformed_mu, target_mu) assert torch.allclose(transformed_cov, target_cov) + + +@pytest.mark.parametrize("errorbar", ["sd", "se", "pi"]) +@pytest.mark.parametrize("histogram_dimensions", [1, 2]) +def test_histogram_and_confidence_1d(errorbar, histogram_dimensions): + """ + Test that the output shapes of `histograms_mean_and_confidence` are correct, and + that lower and upper bounds are below and above the mean, respectively. + """ + num_histograms = 100 + histogram_shape = (20,) if histogram_dimensions == 1 else (20, 30) + histograms = torch.rand(num_histograms, *histogram_shape) + + mean_histogram, lower_bound, upper_bound = histograms_mean_and_confidence( + histograms, errorbar=errorbar + ) + + assert mean_histogram.shape == histogram_shape + assert lower_bound.shape == histogram_shape + assert upper_bound.shape == histogram_shape + + assert (lower_bound <= mean_histogram).all() + assert (upper_bound >= mean_histogram).all() + + +@pytest.mark.parametrize( + "vector_shape", [None, (4,), (3, 2)], ids=["(,)", "(4,)", "(3,2)"] +) +def test_vectorized_histogram_1d(vector_shape): + """Test that the output shape of `vectorized_histogram_1d` is correct.""" + num_distribution_samples = 100 + num_bins = 15 + + distribution_shape = ( + (vector_shape + (num_distribution_samples,)) + if vector_shape is not None + else (num_distribution_samples,) + ) + distribution = torch.rand(*distribution_shape) + + histogram, bin_edges = vectorized_histogram_1d(distribution, bins=num_bins) + + expected_histogram_shape = ( + (*vector_shape, num_bins) if vector_shape is not None else (num_bins,) + ) + + assert histogram.shape == expected_histogram_shape + assert bin_edges.shape == (num_bins + 1,) + + +@pytest.mark.parametrize( + "vector_shape", [None, (4,), (3, 2)], ids=["(,)", "(4,)", "(3,2)"] +) +def test_vectorized_histogram_2d(vector_shape): + """Test that the output shape of `vectorized_histogram_2d` is correct.""" + num_distribution_samples = 100 + num_bins = (15, 20) + + distribution_shape = ( + (vector_shape + (num_distribution_samples,)) + if vector_shape is not None + else (num_distribution_samples,) + ) + x_distribution = torch.rand(*distribution_shape) + y_distribution = torch.rand(*distribution_shape) + + histogram, bin_edges_x, bin_edges_y = vectorized_histogram_2d( + x_distribution, y_distribution, bins=num_bins + ) + + expected_histogram_shape = ( + (*vector_shape, num_bins[0], num_bins[1]) + if vector_shape is not None + else (num_bins[0], num_bins[1]) + ) + + assert histogram.shape == expected_histogram_shape + assert bin_edges_x.shape == (num_bins[0] + 1,) + assert bin_edges_y.shape == (num_bins[1] + 1,) + + +@pytest.mark.parametrize( + "vector_shape", [None, (4,), (3, 2)], ids=["(,)", "(4,)", "(3,2)"] +) +def test_distribution_histogram_and_confidence_1d(vector_shape): + """ + Test that the output shapes of `distribution_histogram_and_confidence_1d` are + correct, and that lower and upper bounds are below and above the mean, respectively. + """ + num_distribution_samples = 100 + num_bins = 20 + + distribution_shape = ( + (vector_shape + (num_distribution_samples,)) + if vector_shape is not None + else (num_distribution_samples,) + ) + distribution = torch.rand(*distribution_shape) + + bin_centers, mean_histogram, lower_bound, upper_bound = ( + distribution_histogram_and_confidence_1d( + distribution, bins=num_bins, errorbar="sd" + ) + ) + + assert bin_centers.shape == (num_bins,) + assert mean_histogram.shape == (num_bins,) + + if vector_shape is not None: + assert lower_bound.shape == (num_bins,) + assert upper_bound.shape == (num_bins,) + + assert (lower_bound <= mean_histogram).all() + assert (upper_bound >= mean_histogram).all() + + +@pytest.mark.parametrize( + "vector_shape", [None, (4,), (3, 2)], ids=["(,)", "(4,)", "(3,2)"] +) +def test_distribution_histogram_and_confidence_2d(vector_shape): + """ + Test that the output shapes of `distribution_histogram_and_confidence_2d` are + correct, and that lower and upper bounds are below and above the mean, respectively. + """ + num_distribution_samples = 100 + num_bins = (15, 20) + + distribution_shape = ( + (vector_shape + (num_distribution_samples,)) + if vector_shape is not None + else (num_distribution_samples,) + ) + x_distribution = torch.rand(*distribution_shape) + y_distribution = torch.rand(*distribution_shape) + + ( + bin_centers_x, + bin_centers_y, + mean_histogram, + lower_bound, + upper_bound, + ) = distribution_histogram_and_confidence_2d( + x_distribution, y_distribution, bins=num_bins, errorbar="sd" + ) + + assert bin_centers_x.shape == (num_bins[0],) + assert bin_centers_y.shape == (num_bins[1],) + assert mean_histogram.shape == (num_bins[0], num_bins[1]) + + if vector_shape is not None: + assert lower_bound.shape == (num_bins[0], num_bins[1]) + assert upper_bound.shape == (num_bins[0], num_bins[1]) + + assert (lower_bound <= mean_histogram).all() + assert (upper_bound >= mean_histogram).all()