sierra-research 1.3.11__py3-none-any.whl → 1.5.0__py3-none-any.whl

sierra/core/graphs/stacked_line_graph.py

@@ -1,251 +0,0 @@
-# Copyright 2018 John Harwell, All rights reserved.
-#
-#  SPDX-License-Identifier: MIT
-#
-
-# Core packages
-import typing as tp
-import copy
-import logging
-import pathlib
-
-# 3rd party packages
-import pandas as pd
-import matplotlib.pyplot as plt
-
-# Project packages
-from sierra.core import config, utils, storage
-
-
-class StackedLineGraph:
-    """Generates a line graph from a set of columns in a CSV file.
-
-    If the necessary data file does not exist, the graph is not generated.
-
-    If the .stddev file that goes with the .mean does not exist, then no error
-    bars are plotted.
-
-    If the .model file that goes with the .mean does not exist, then no model
-    predictions are plotted.
-
-    Ideally, model predictions/stddev calculations would be in derived classes,
-    but I can't figure out a good way to easily pull that stuff out of here.
-
-    """
-
-    def __init__(self,
-                 stats_root: pathlib.Path,
-                 input_stem: str,
-                 output_fpath: pathlib.Path,
-                 title: str,
-                 xlabel: tp.Optional[str] = None,
-                 ylabel: tp.Optional[str] = None,
-                 large_text: bool = False,
-                 legend: tp.Optional[tp.List[str]] = None,
-                 cols: tp.Optional[tp.List[str]] = None,
-                 linestyles: tp.Optional[tp.List[str]] = None,
-                 dashstyles: tp.Optional[tp.List[str]] = None,
-                 logyscale: bool = False,
-                 stddev_fpath:  tp.Optional[pathlib.Path] = None,
-                 stats: str = 'none',
-                 model_root: tp.Optional[pathlib.Path] = None) -> None:
-
-        # Required arguments
-        self.stats_root = stats_root
-        self.input_stem = input_stem
-        self.output_fpath = output_fpath
-        self.title = title
-
-        # Optional arguments
-        if large_text:
-            self.text_size = config.kGraphTextSizeLarge
-        else:
-            self.text_size = config.kGraphTextSizeSmall
-
-        self.xlabel = xlabel
-        self.ylabel = ylabel
-        self.legend = legend
-        self.cols = cols
-        self.logyscale = logyscale
-        self.linestyles = linestyles
-        self.dashstyles = dashstyles
-        self.stats = stats
-        self.model_root = model_root
-        self.stddev_fpath = stddev_fpath
-        self.logger = logging.getLogger(__name__)
-
-    def generate(self) -> None:
-        ext = config.kStats['mean'].exts['mean']
-        input_fpath = self.stats_root / (self.input_stem + ext)
-        if not utils.path_exists(input_fpath):
-            self.logger.debug("Not generating %s: %s does not exist",
-                              self.output_fpath,
-                              input_fpath)
-            return
-
-        data_df = storage.DataFrameReader('storage.csv')(input_fpath)
-
-        model = self._read_models()
-        stat_dfs = self._read_stats()
-
-        # Plot specified columns from dataframe.
-        if self.cols is None:
-            ncols = max(1, int(len(data_df.columns) / 2.0))
-            ax = self._plot_selected_cols(
-                data_df, stat_dfs, data_df.columns, model)
-        else:
-            ncols = max(1, int(len(self.cols) / 2.0))
-            ax = self._plot_selected_cols(data_df, stat_dfs, self.cols, model)
-
-        self._plot_ticks(ax)
-
-        self._plot_legend(ax, model[1], ncols)
-
-        # Add title
-        ax.set_title(self.title, fontsize=self.text_size['title'])
-
-        # Add X,Y labels
-        if self.xlabel is not None:
-            ax.set_xlabel(self.xlabel, fontsize=self.text_size['xyz_label'])
-
-        if self.ylabel is not None:
-            ax.set_ylabel(self.ylabel, fontsize=self.text_size['xyz_label'])
-
-        # Output figure
-        fig = ax.get_figure()
-        fig.set_size_inches(config.kGraphBaseSize,
-                            config.kGraphBaseSize)
-        fig.savefig(self.output_fpath,
-                    bbox_inches='tight',
-                    dpi=config.kGraphDPI)
-        # Prevent memory accumulation (fig.clf() does not close everything)
-        plt.close(fig)
-
-    def _plot_ticks(self, ax) -> None:
-        if self.logyscale:
-            plt.yscale('symlog')
-
-        ax.tick_params(labelsize=self.text_size['tick_label'])
-
-    def _plot_selected_cols(self,
-                            data_df: pd.DataFrame,
-                            stat_dfs: tp.Dict[str, pd.DataFrame],
-                            cols: tp.List[str],
-                            model: tp.Tuple[pd.DataFrame, tp.List[str]]):
-        """
-        Plot the  selected columns in a dataframe.
-
-        This may include:
-
-        - Errorbars
-        - Models
-        - Custom line styles
-        - Custom dash styles
-        """
-        # Always plot the data
-        if self.linestyles is None and self.dashstyles is None:
-            ax = data_df[cols].plot()
-        elif self.dashstyles is None and self.linestyles is not None:
-            for c, s in zip(cols, self.linestyles):
-                ax = data_df[c].plot(linestyle=s)
-        elif self.dashstyles is not None and self.linestyles is not None:
-            for c, s, d in zip(cols, self.linestyles, self.dashstyles):
-                ax = data_df[c].plot(linestyle=s, dashes=d)
-
-        # Plot models if they have been computed
-        if model[0] is not None:
-            model[0][model[0].columns].plot(ax=ax)
-
-        # Plot stddev if it has been computed
-        if 'stddev' in stat_dfs.keys():
-            for c in cols:
-                self._plot_col_errorbars(data_df, stat_dfs['stddev'], c)
-        return ax
-
-    def _plot_col_errorbars(self,
-                            data_df: pd.DataFrame,
-                            stddev_df: pd.DataFrame,
-                            col: str) -> None:
-        """
-        Plot the errorbars for a specific column in a dataframe.
-        """
-        plt.fill_between(data_df.index,
-                         data_df[col] - 2 * stddev_df[col].abs(),
-                         data_df[col] + 2 * stddev_df[col].abs(),
-                         alpha=0.50)
-
-    def _plot_legend(self, ax, model_legend: tp.List[str], ncols: int) -> None:
-        # Should always use one column: If a small number of lines are plotted,
-        # then 1 vs. > 1 column makes no difference. If a large number of lines
-        # are plotted, this will make the figures more portrait than landscape,
-        # which is more amenable to inclusion in academic papers.
-
-        # If the legend is not specified, then we assume this is not a graph
-        # that will contain any models and/or no legend is desired.
-        legend = self.legend
-
-        if self.legend is not None:
-            legend = copy.deepcopy(self.legend)
-            if model_legend:
-                legend.extend(model_legend)
-
-            lines, _ = ax.get_legend_handles_labels()
-            ax.legend(lines,
-                      legend,
-                      loc='lower center',
-                      bbox_to_anchor=(0.5, -0.5),
-                      ncol=1,
-                      fontsize=self.text_size['legend_label'])
-        else:
-            ax.legend().remove()
-        #     ax.legend(loc='lower center',
-        #               bbox_to_anchor=(0.5, -0.5),
-        #               ncol=1,
-        #               fontsize=self.text_size['legend_label'])
-
-    def _read_stats(self) -> tp.Dict[str, pd.DataFrame]:
-        dfs = {}
-
-        reader = storage.DataFrameReader('storage.csv')
-        if self.stats in ['conf95', 'all']:
-            exts = config.kStats['conf95'].exts
-
-            for k in exts:
-                ipath = self.stats_root / (self.input_stem + exts[k])
-
-                if utils.path_exists(ipath):
-                    dfs[k] = reader(ipath)
-                else:
-                    self.logger.warning("%sfile not found for '%s'",
-                                        exts[k],
-                                        self.input_stem)
-
-        return dfs
-
-    # 2024/09/13 [JRH]: The union is for compatability with type checkers in
-    # python {3.8,3.11}.
-    def _read_models(self) -> tp.Tuple[pd.DataFrame, tp.Union[tp.List[str], tp.List[bytes]]]:
-        if self.model_root is not None:
-            model_fpath = self.model_root / \
-                (self.input_stem + config.kModelsExt['model'])
-            legend_fpath = self.model_root / \
-                (self.input_stem + config.kModelsExt['legend'])
-
-            if utils.path_exists(model_fpath):
-                model = storage.DataFrameReader('storage.csv')(model_fpath)
-                if utils.path_exists(legend_fpath):
-                    with utils.utf8open(legend_fpath, 'r') as f:
-                        model_legend = f.read().splitlines()
-                else:
-                    self.logger.warning("No legend file for model '%s' found",
-                                        model_fpath)
-                    model_legend = ['Model Prediction']
-
-                return (model, model_legend)
-
-        return (None, [])
-
-
-__api__ = [
-    'StackedLineGraph'
-]

sierra/core/graphs/stacked_surface_graph.py

@@ -1,220 +0,0 @@
-# Copyright 2018 John Harwell, All rights reserved.
-#
-#  SPDX-License-Identifier: MIT
-#
-
-# Core packages
-import typing as tp
-import logging
-import pathlib
-
-# 3rd party packages
-import numpy as np
-import matplotlib as mpl
-import matplotlib.pyplot as plt
-from mpl_toolkits.mplot3d import Axes3D
-
-# Project packages
-from sierra.core import config, storage, types
-
-
-class StackedSurfaceGraph:
-    """Generates a plot of a set of 3D surface graphs from a set of CSVs.
-
-    ``.mean`` files must be named as``<input_stem_fpath>_X.mean``, where `X` is
-    non-negative integer. Input CSV files must be 2D grids of the same
-    cardinality.
-
-    This graph does not plot standard deviation.
-
-    If no ``.mean`` files matching the pattern are found, the graph is not
-    generated.
-
-    """
-    kMaxSurfaces = 4
-
-    def __init__(self,
-                 ipaths: types.PathList,
-                 output_fpath: pathlib.Path,
-                 title: str,
-                 legend: tp.List[str],
-                 xlabel: str,
-                 ylabel: str,
-                 zlabel: str,
-                 xtick_labels: tp.List[str],
-                 ytick_labels: tp.List[str],
-                 comp_type: str,
-                 large_text: bool = False) -> None:
-
-        self.ipaths = ipaths
-        self.output_fpath = output_fpath
-        self.title = title
-        self.legend = legend
-        self.xlabel = xlabel
-        self.ylabel = ylabel
-        self.zlabel = zlabel
-        self.xtick_labels = xtick_labels
-        self.ytick_labels = ytick_labels
-        self.comp_type = comp_type
-
-        if large_text:
-            self.text_size = config.kGraphTextSizeLarge
-        else:
-            self.text_size = config.kGraphTextSizeSmall
-
-        self.logger = logging.getLogger(__name__)
-
-    def generate(self) -> None:
-        reader = storage.DataFrameReader('storage.csv')
-        dfs = [reader(f) for f in self.ipaths]
-
-        if not dfs or len(dfs) > StackedSurfaceGraph.kMaxSurfaces:
-            self.logger.debug(("Not generating stacked surface graph: wrong # "
-                               "files (must be > 0, <= %s)"),
-                              StackedSurfaceGraph.kMaxSurfaces)
-            return
-
-        assert len(dfs) <= StackedSurfaceGraph.kMaxSurfaces,\
-            f"Too many surfaces to plot: {len(dfs)} > {StackedSurfaceGraph.kMaxSurfaces}"
-
-        # Scaffold graph
-        plt.figure(figsize=(config.kGraphBaseSize, config.kGraphBaseSize))
-        ax = plt.axes(projection='3d')
-        x = np.arange(len(dfs[0].columns))
-        y = dfs[0].index
-        X, Y = np.meshgrid(x, y)
-
-        # Use non-quantitative colormaps in order to get really nice looking
-        # surfaces that change color with Z value. From
-        # https://stackoverflow.com/questions/55501860/how-to-put-multiple-colormap-patches-in-a-matplotlib-legend
-        colors = [plt.cm.Greens, plt.cm.Reds, plt.cm.Purples, plt.cm.Oranges]
-        legend_cmap_handles = [mpl.patches.Rectangle(
-            (0, 0), 1, 1) for _ in colors]
-        legend_handler_map = dict(zip(legend_cmap_handles,
-                                      [HandlerColormap(c, num_stripes=8) for c in colors]))
-
-        # Plot surfaces
-        self._plot_surfaces(X, Y, ax, colors, dfs)
-
-        # Add title
-        ax.set_title(self.title, fontsize=24)
-
-        # Add X,Y,Z labels
-        self._plot_labels(ax)
-
-        # Add X,Y ticks
-        self._plot_ticks(ax, x, y)
-
-        # Add legend
-        self._plot_legend(ax, legend_cmap_handles, legend_handler_map)
-
-        # Output figures
-        fig = ax.get_figure()
-        fig.set_size_inches(10, 10)
-        self._save_figs(fig, ax)
-
-    def _plot_surfaces(self, X, Y, ax, colors, dfs):
-        ax.plot_surface(X, Y, dfs[0], cmap=colors[0])
-
-        # We do the calculations between dataframes in here rather than in the
-        # comparator, because we can be comparing more than 2.
-        for i in range(1, len(dfs)):
-            if self.comp_type == 'SUraw':
-                plot_df = dfs[i]
-            elif self.comp_type == 'SUscale':
-                plot_df = dfs[i] / dfs[0]
-            elif self.comp_type == 'SUdiff':
-                plot_df = dfs[i] - dfs[0]
-            ax.plot_surface(X, Y, plot_df, cmap=colors[i], alpha=0.5)
-
-    def _plot_ticks(self, ax, xvals, yvals):
-        """Plot ticks and tick labels.
-
-        If the labels are numerical and the numbers are too large, force
-        scientific notation (the ``rcParam`` way of doing this does not seem to
-        work...)
-
-        """
-        ax.tick_params(labelsize=self.text_size['tick_label'])
-        ax.set_xticks(xvals)
-        ax.set_xticklabels(self.xtick_labels, rotation='vertical')
-
-        ax.set_yticks(yvals)
-        ax.set_yticklabels(self.ytick_labels, rotation='vertical')
-
-    def _plot_legend(self, ax, cmap_handles, handler_map):
-        # Legend should have ~3 entries per column, in order to maximize real
-        # estate on tightly constrained papers.
-        ax.legend(handles=cmap_handles,
-                  handler_map=handler_map,
-                  labels=self.legend,
-                  loc=9,
-                  bbox_to_anchor=(0.5, -0.1),
-                  ncol=len(self.legend),
-                  fontsize=self.text_size['legend_label'])
-
-    def _plot_labels(self, ax):
-        max_xlen = max([len(str(l)) for l in self.xtick_labels])
-        max_ylen = max([len(str(l)) for l in self.ytick_labels])
-        ax.set_xlabel('\n' * max_xlen + self.xlabel,
-                      fontsize=self.text_size['xyz_label'])
-        ax.set_ylabel('\n' * max_ylen + self.ylabel,
-                      fontsize=self.text_size['xyz_label'])
-        ax.set_zlabel('\n' + self.zlabel, fontsize=self.text_size['xyz_label'])
-
-    def _save_figs(self, fig, ax):
-        """Save multiple rotated copies of the same figure.
-
-        Necessary for automation of 3D figure generation, because you can't
-        really know a priori what views are going to give the best results. MPL
-        doesn't have a true 3D plot generator yet.
-
-        """
-        for angle in range(0, 360, 30):
-            ax.view_init(elev=None, azim=angle)
-            # The path we are passed may contain dots from the controller same,
-            # so we extract the leaf of that for manipulation to add the angle
-            # of the view right before the file extension.
-            path = self.output_fpath.parent
-            leaf = self.output_fpath.name
-            components = leaf.split('.')
-            fname = ''.join(leaf[0:-2]) + '_' + \
-                str(angle) + '.' + components[-1]
-            fig.savefig(path / fname,
-                        bbox_inches='tight',
-                        dpi=config.kGraphDPI,
-                        pad_inches=0)
-            # Prevent memory accumulation (fig.clf() does not close everything)
-            plt.close(fig)
-
-
-class HandlerColormap(mpl.legend_handler.HandlerBase):
-    def __init__(self, cmap, num_stripes=8, **kw) -> None:
-        super().__init__(**kw)
-        self.cmap = cmap
-        self.num_stripes = num_stripes
-
-    def create_artists(self,
-                       legend,
-                       orig_handle,
-                       xdescent,
-                       ydescent,
-                       width,
-                       height,
-                       fontsize,
-                       trans):
-        stripes = []
-        for i in range(self.num_stripes):
-            s = mpl.patches.Rectangle([xdescent + i * width / self.num_stripes, ydescent],
-                                      width / self.num_stripes,
-                                      height,
-                                      fc=self.cmap(
-                                          (2 * i + 1) / (2 * self.num_stripes)),
-                                      transform=trans)
-            stripes.append(s)
-        return stripes
-
-
-__api__ = [
-    'StackedSurfaceGraph'
-]