steer-core 0.1.27__tar.gz → 0.1.30__tar.gz

{steer_core-0.1.27 → steer_core-0.1.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steer-core
-Version: 0.1.27
+Version: 0.1.30
 Summary: Modelling energy storage from cell to site - STEER OpenCell Design
 Author-email: Nicholas Siemons <nsiemons@stanford.edu>
 Maintainer-email: Nicholas Siemons <nsiemons@stanford.edu>

{steer_core-0.1.27 → steer_core-0.1.30}/steer_core/DataManager.py

@@ -281,6 +281,26 @@ class DataManager:
 
         return data
 
+    def get_prismatic_container_materials(self, most_recent: bool = True) -> pd.DataFrame:
+        """
+        Retrieves prismatic container materials from the database.
+
+        :param most_recent: If True, returns only the most recent entry.
+        :return: DataFrame with prismatic container materials.
+        """
+        data = (
+            self.get_data(table_name="prismatic_container_materials")
+            .groupby("name", group_keys=False)
+            .apply(
+                lambda x: x.sort_values("date", ascending=False).head(1)
+                if most_recent
+                else x
+            )
+            .reset_index(drop=True)
+        )
+
+        return data
+
     @staticmethod
     def read_half_cell_curve(half_cell_path) -> pd.DataFrame:
         """

{steer_core-0.1.27 → steer_core-0.1.30}/steer_core/Mixins/Coordinates.py

@@ -130,28 +130,45 @@ class CoordinateMixin:
 
     @staticmethod
     def rotate_coordinates(
-        coords: np.ndarray, axis: str, angle: float, center: tuple = None
+        coords: np.ndarray, 
+        axis: str, 
+        angle: float, 
+        center: tuple = None
     ) -> np.ndarray:
         """
-        Rotate a (N, 3) NumPy array of 3D coordinates around the specified axis.
+        Rotate a NumPy array of coordinates around the specified axis.
+        Can handle 2D coordinates (N, 2) for x, y or 3D coordinates (N, 3) for x, y, z.
         Can handle coordinates with None values (preserves None positions).
 
-        :param coords: NumPy array of shape (N, 3), where columns are x, y, z
-        :param axis: Axis to rotate around ('x', 'y', or 'z')
+        :param coords: NumPy array of shape (N, 2) for 2D or (N, 3) for 3D coordinates
+        :param axis: Axis to rotate around ('x', 'y', or 'z'). For 2D arrays, only 'z' is valid.
         :param angle: Angle in degrees
-        :param center: Point to rotate around as (x, y, z) tuple. If None, rotates around origin.
-        :return: Rotated NumPy array of shape (N, 3)
+        :param center: Point to rotate around. For 2D: (x, y) tuple. For 3D: (x, y, z) tuple. 
+                      If None, rotates around origin.
+        :return: Rotated NumPy array with same shape as input
         """
-        if coords.shape[1] != 3:
+        # Check if 2D or 3D coordinates
+        is_2d = coords.shape[1] == 2
+        is_3d = coords.shape[1] == 3
+        
+        if not (is_2d or is_3d):
+            raise ValueError(
+                "Input array must have shape (N, 2) for 2D or (N, 3) for 3D coordinates"
+            )
+        
+        # For 2D arrays, only z-axis rotation is valid
+        if is_2d and axis != 'z':
             raise ValueError(
-                "Input array must have shape (N, 3) for x, y, z coordinates"
+                "For 2D coordinates (x, y), only 'z' axis rotation is supported"
             )
 
         # Validate center parameter
         if center is not None:
-            if not isinstance(center, (tuple, list)) or len(center) != 3:
+            expected_len = 2 if is_2d else 3
+            if not isinstance(center, (tuple, list)) or len(center) != expected_len:
+                coord_type = "(x, y)" if is_2d else "(x, y, z)"
                 raise ValueError(
-                    "Center must be a tuple or list of 3 coordinates (x, y, z)"
+                    f"Center must be a tuple or list of {expected_len} coordinates {coord_type}"
                 )
             if not all(isinstance(coord, (int, float)) for coord in center):
                 raise TypeError("All center coordinates must be numbers")
@@ -201,10 +218,11 @@ class CoordinateMixin:
         """
         Rotate coordinates around a specified center point.
 
-        :param coords: NumPy array of shape (N, 3) with valid coordinates
+        :param coords: NumPy array of shape (N, 2) or (N, 3) with valid coordinates
         :param axis: Axis to rotate around ('x', 'y', or 'z')
         :param angle: Angle in degrees
-        :param center: Center point as np.array of shape (3,). If None, rotates around origin.
+        :param center: Center point as np.array. Shape (2,) for 2D or (3,) for 3D. 
+                      If None, rotates around origin.
         :return: Rotated coordinates
         """
         if center is None:
@@ -240,21 +258,88 @@ class CoordinateMixin:
             The width of the square.
         y_width : float
             The height of the square.
+
+        Returns
+        -------
+        Tuple[np.ndarray, np.ndarray]
+            Tuple containing x and y coordinate arrays defining the square/rectangle
+        """
+        x_coords = np.array([x, x, x + x_width, x + x_width, x])
+        y_coords = np.array([y, y + y_width, y + y_width, y, y])
+        return x_coords, y_coords
+
+    @staticmethod
+    def build_circle_array(
+        center_x: float, center_y: float, radius: float, num_points: int = 64, anticlockwise: bool = True
+    ) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Build a NumPy array representing a circle defined by its center and radius.
+
+        Parameters
+        ----------
+        center_x : float
+            The x-coordinate of the circle center.
+        center_y : float
+            The y-coordinate of the circle center.
+        radius : float
+            The radius of the circle.
+        num_points : int, optional
+            Number of points to use for the circle approximation, by default 64
+        anticlockwise : bool, optional
+            If True, points are ordered anticlockwise; if False, clockwise, by default True
+
+        Returns
+        -------
+        Tuple[np.ndarray, np.ndarray]
+            Tuple containing x and y coordinate arrays defining the circle
         """
-        x_coords = [x, x, x + x_width, x + x_width, x]
-        y_coords = [y, y + y_width, y + y_width, y, y]
+        # Generate angles from 0 to 2π
+        angles = np.linspace(0, 2 * np.pi, num_points + 1)
+        
+        # Reverse angles for clockwise direction
+        if not anticlockwise:
+            angles = angles[::-1]
+        
+        # Calculate x and y coordinates
+        x_coords = center_x + radius * np.cos(angles)
+        y_coords = center_y + radius * np.sin(angles)
+        
         return x_coords, y_coords
 
     @staticmethod
     def order_coordinates_clockwise(df: pd.DataFrame, plane="xy") -> pd.DataFrame:
 
+        df = df.copy()
+
         axis_1 = plane[0]
         axis_2 = plane[1]
 
-        cx = df[axis_1].mean()
-        cy = df[axis_2].mean()
-
-        angles = np.arctan2(df[axis_2] - cy, df[axis_1] - cx)
+        # Find column names that match the axis (case-insensitive, with or without units)
+        def find_column(axis_char: str) -> str:
+            axis_char_lower = axis_char.lower()
+            # First try exact match
+            if axis_char in df.columns:
+                return axis_char
+            # Try lowercase
+            if axis_char_lower in df.columns:
+                return axis_char_lower
+            # Try uppercase
+            if axis_char.upper() in df.columns:
+                return axis_char.upper()
+            # Try with units pattern like "X (mm)", "x (mm)", etc.
+            for col in df.columns:
+                col_stripped = col.split()[0].lower() if ' ' in col else col.lower()
+                if col_stripped == axis_char_lower:
+                    return col
+            raise KeyError(f"Could not find column for axis '{axis_char}' in dataframe columns: {list(df.columns)}")
+        
+        axis_1_col = find_column(axis_1)
+        axis_2_col = find_column(axis_2)
+
+        cx = df[axis_1_col].mean()
+        cy = df[axis_2_col].mean()
+
+        angles = np.arctan2(df[axis_2_col] - cy, df[axis_1_col] - cx)
 
         df["angle"] = angles
 
@@ -487,19 +572,35 @@ class CoordinateMixin:
     ) -> np.ndarray:
         """
         Rotate coordinates without None values using rotation matrices.
+        Handles both 2D (N, 2) and 3D (N, 3) coordinate arrays.
+        
+        :param coords: NumPy array of shape (N, 2) or (N, 3)
+        :param axis: Axis to rotate around ('x', 'y', or 'z')
+        :param angle: Angle in degrees
+        :return: Rotated coordinates with same shape as input
         """
         angle_rad = np.radians(angle)
         cos_a = np.cos(angle_rad)
         sin_a = np.sin(angle_rad)
+        
+        is_2d = coords.shape[1] == 2
 
-        if axis == "x":
-            R = np.array([[1, 0, 0], [0, cos_a, -sin_a], [0, sin_a, cos_a]])
-        elif axis == "y":
-            R = np.array([[cos_a, 0, sin_a], [0, 1, 0], [-sin_a, 0, cos_a]])
-        elif axis == "z":
-            R = np.array([[cos_a, -sin_a, 0], [sin_a, cos_a, 0], [0, 0, 1]])
+        if is_2d:
+            # For 2D coordinates, only z-axis rotation applies (rotation in xy plane)
+            if axis != 'z':
+                raise ValueError("For 2D coordinates, only 'z' axis rotation is supported")
+            # 2D rotation matrix
+            R = np.array([[cos_a, -sin_a], [sin_a, cos_a]])
         else:
-            raise ValueError("Axis must be 'x', 'y', or 'z'.")
+            # 3D rotation matrices
+            if axis == "x":
+                R = np.array([[1, 0, 0], [0, cos_a, -sin_a], [0, sin_a, cos_a]])
+            elif axis == "y":
+                R = np.array([[cos_a, 0, sin_a], [0, 1, 0], [-sin_a, 0, cos_a]])
+            elif axis == "z":
+                R = np.array([[cos_a, -sin_a, 0], [sin_a, cos_a, 0], [0, 0, 1]])
+            else:
+                raise ValueError("Axis must be 'x', 'y', or 'z'.")
 
         return coords @ R.T
 

{steer_core-0.1.27 → steer_core-0.1.30}/steer_core/Mixins/Plotter.py

@@ -36,6 +36,7 @@ class PlotterMixin:
 
     SCHEMATIC_Z_AXIS = dict(
         zeroline=False,
+        scaleanchor="x",
         title="Z (mm)"
     )
 
@@ -55,7 +56,8 @@ class PlotterMixin:
             line_width, 
             color_func, 
             unit_conversion_factor,
-            order_clockwise: str = None
+            order_clockwise: str = None,
+            gl: bool = False
             ):
         """
         Create a single trace for a component or group of components with NaN separators.
@@ -115,17 +117,30 @@ class PlotterMixin:
         z_coords = combined_coords[:, 2] * unit_conversion_factor
         
         # Create trace
-        return go.Scatter(
-            x=y_coords,
-            y=z_coords,
-            mode="lines",
-            name=name,
-            line={'width': line_width, 'color': "black"},
-            fill="toself",
-            fillcolor=color_func(components[0]),
-            legendgroup=name,
-            showlegend=True,
-        )
+        if gl:
+            return go.Scattergl(
+                x=y_coords,
+                y=z_coords,
+                mode="lines",
+                name=name,
+                line={'width': line_width, 'color': "black"},
+                fill="toself",
+                fillcolor=color_func(components[0]),
+                legendgroup=name,
+                showlegend=True,
+            )
+        else:
+            return go.Scatter(
+                x=y_coords,
+                y=z_coords,
+                mode="lines",
+                name=name,
+                line={'width': line_width, 'color': "black"},
+                fill="toself",
+                fillcolor=color_func(components[0]),
+                legendgroup=name,
+                showlegend=True,
+            )
 
     @staticmethod
     def plot_breakdown_sunburst(
@@ -133,6 +148,7 @@ class PlotterMixin:
         title: str = "Breakdown",
         root_label: str = "Total",
         unit: str = "",
+        colorway: List[str] = None,
         **kwargs,
     ) -> go.Figure:
         """
@@ -149,12 +165,22 @@ class PlotterMixin:
             Label for the root node. Defaults to "Total".
         unit : str, optional
             Unit string to display in hover text (e.g., "g", "kg", "%"). Defaults to "".
+        colorway : List[str], optional
+            List of colors to use for the inner ring. If None, uses Plotly's default colorway.
+            Defaults to None.
 
         Returns
         -------
         go.Figure
             Plotly sunburst figure
         """
+        
+        # Default Plotly colorway if none provided
+        if colorway is None:
+            colorway = [
+                '#636EFA', '#EF553B', '#00CC96', '#AB63FA', '#FFA15A',
+                '#19D3F3', '#FF6692', '#B6E880', '#FF97FF', '#FECB52'
+            ]
 
         def _flatten_breakdown_values(data: Dict[str, Any]) -> List[float]:
             """Recursively flatten all numeric values from nested breakdown dictionary"""
@@ -177,13 +203,14 @@ class PlotterMixin:
             return total
 
         def _prepare_sunburst_data(
-            data: Dict[str, Any], parent_id: str = "", current_path: str = ""
-        ) -> Tuple[List[str], List[str], List[str], List[float]]:
+            data: Dict[str, Any], parent_id: str = "", current_path: str = "", depth: int = 1
+        ) -> Tuple[List[str], List[str], List[str], List[float], List[int]]:
             """Recursively prepare data for sunburst plot with proper hierarchy"""
             ids = []
             labels = []
             parents = []
             values = []
+            depths = []
 
             for key, value in data.items():
                 # Create unique ID for this node
@@ -192,6 +219,7 @@ class PlotterMixin:
                 ids.append(node_id)
                 labels.append(key)
                 parents.append(parent_id)
+                depths.append(depth)
 
                 if isinstance(value, dict):
                     # This is a nested dictionary - calculate its total value
@@ -204,8 +232,9 @@ class PlotterMixin:
                         nested_labels,
                         nested_parents,
                         nested_values,
+                        nested_depths,
                     ) = _prepare_sunburst_data(
-                        value, parent_id=node_id, current_path=node_id
+                        value, parent_id=node_id, current_path=node_id, depth=depth + 1
                     )
 
                     # Add nested data to our lists
@@ -213,18 +242,19 @@ class PlotterMixin:
                     labels.extend(nested_labels)
                     parents.extend(nested_parents)
                     values.extend(nested_values)
+                    depths.extend(nested_depths)
 
                 elif isinstance(value, (int, float)):
                     # This is a leaf node with a numeric value
                     values.append(float(value))
 
-            return ids, labels, parents, values
+            return ids, labels, parents, values, depths
 
         # Calculate total value for root node
         total_value = _calculate_subtotal(breakdown_dict)
 
         # Prepare hierarchical data starting with root
-        ids, labels, parents, values = _prepare_sunburst_data(
+        ids, labels, parents, values, depths = _prepare_sunburst_data(
             breakdown_dict, parent_id=""
         )
 
@@ -233,12 +263,74 @@ class PlotterMixin:
         labels.insert(0, root_label)
         parents.insert(0, "")
         values.insert(0, total_value)
+        depths.insert(0, 0)
 
         # Update parent references to point to root
         for i in range(1, len(parents)):
             if parents[i] == "":
                 parents[i] = root_label
 
+        # Generate colors based on alphabetical ordering and depth
+        def _hex_to_rgb(hex_color: str) -> Tuple[int, int, int]:
+            """Convert hex color to RGB tuple"""
+            hex_color = hex_color.lstrip('#')
+            return tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
+        
+        def _rgb_to_hex(rgb: Tuple[int, int, int]) -> str:
+            """Convert RGB tuple to hex color"""
+            return '#{:02x}{:02x}{:02x}'.format(int(rgb[0]), int(rgb[1]), int(rgb[2]))
+        
+        def _lighten_color(hex_color: str, factor: float) -> str:
+            """Lighten a color by blending with white. Factor 0=original, 1=white"""
+            r, g, b = _hex_to_rgb(hex_color)
+            # Blend with white (255, 255, 255)
+            r = r + (255 - r) * factor
+            g = g + (255 - g) * factor
+            b = b + (255 - b) * factor
+            return _rgb_to_hex((r, g, b))
+        
+        # Get first-level keys (children of root) and sort alphabetically
+        first_level_keys = sorted([key for key in breakdown_dict.keys()])
+        
+        # Assign base colors to first-level keys
+        key_to_base_color = {}
+        for i, key in enumerate(first_level_keys):
+            key_to_base_color[key] = colorway[i % len(colorway)]
+        
+        # Assign colors to all nodes
+        marker_colors = []
+        max_depth = max(depths) if depths else 0
+        
+        for i, (node_id, label, parent, depth) in enumerate(zip(ids, labels, parents, depths)):
+            if depth == 0:
+                # Root node - use neutral color
+                marker_colors.append('#CCCCCC')
+            elif depth == 1:
+                # First level - use assigned base color
+                marker_colors.append(key_to_base_color[label])
+            else:
+                # Deeper levels - find the first-level ancestor and lighten its color
+                # Trace back through parents to find first-level ancestor
+                current_parent = parent
+                ancestor_label = None
+                
+                for j, (check_id, check_label, check_depth) in enumerate(zip(ids, labels, depths)):
+                    if check_id == current_parent:
+                        if check_depth == 1:
+                            ancestor_label = check_label
+                            break
+                        current_parent = parents[j]
+                
+                if ancestor_label and ancestor_label in key_to_base_color:
+                    base_color = key_to_base_color[ancestor_label]
+                    # Lighten based on depth (depth 2 gets 0.3, depth 3 gets 0.5, depth 4 gets 0.7, etc.)
+                    lighten_factor = 0.2 + (depth - 1) * 0.25
+                    lighten_factor = min(lighten_factor, 0.85)  # Cap at 0.85 to avoid too pale
+                    marker_colors.append(_lighten_color(base_color, lighten_factor))
+                else:
+                    # Fallback to neutral color
+                    marker_colors.append('#DDDDDD')
+
         # Create custom hover text with percentages
         hover_text = []
         for i, (label, value) in enumerate(zip(labels, values)):
@@ -262,6 +354,7 @@ class PlotterMixin:
                 branchvalues="total",
                 hovertemplate="%{customdata}<extra></extra>",
                 customdata=hover_text,
+                marker=dict(colors=marker_colors),
             )
         )
 

{steer_core-0.1.27 → steer_core-0.1.30}/steer_core/Mixins/Serializer.py

@@ -5,6 +5,7 @@ from copy import deepcopy
 
 
 class SerializerMixin:
+    
     def serialize(self) -> str:
         """
         Serialize an object to a string representation.

{steer_core-0.1.27 → steer_core-0.1.30}/steer_core/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.1.27"
+__version__ = "0.1.30"
 
 # datamanager import
 from .DataManager import DataManager

{steer_core-0.1.27 → steer_core-0.1.30}/steer_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steer-core
-Version: 0.1.27
+Version: 0.1.30
 Summary: Modelling energy storage from cell to site - STEER OpenCell Design
 Author-email: Nicholas Siemons <nsiemons@stanford.edu>
 Maintainer-email: Nicholas Siemons <nsiemons@stanford.edu>

{steer_core-0.1.27 → steer_core-0.1.30}/steer_core.egg-info/SOURCES.txt

@@ -15,7 +15,6 @@ steer_core/ContextManagers/__init__.py
 steer_core/Data/__init__.py
 steer_core/Data/database.db
 steer_core/Decorators/Coordinates.py
-steer_core/Decorators/Electrochemical.py
 steer_core/Decorators/General.py
 steer_core/Decorators/Objects.py
 steer_core/Decorators/__init__.py

steer_core-0.1.27/steer_core/Decorators/Electrochemical.py

@@ -1,29 +0,0 @@
-from functools import wraps
-
-def calculate_half_cell_curve(func):
-    """
-    Decorator to recalculate half-cell curve properties after a method call.
-    This is useful for methods that modify the half-cell curve data.
-    """
-    @wraps(func)
-    def wrapper(self, *args, **kwargs):
-        result = func(self, *args, **kwargs)
-        if hasattr(self, '_update_properties') and self._update_properties:
-            self._calculate_half_cell_curve()
-        return result
-    return wrapper
-
-
-def calculate_half_cell_curves_properties(func):
-    """
-    Decorator to recalculate half-cell curves properties after a method call.
-    This is useful for methods that modify the half-cell curves data.
-    """
-    @wraps(func)
-    def wrapper(self, *args, **kwargs):
-        result = func(self, *args, **kwargs)
-        if hasattr(self, '_update_properties') and self._update_properties:
-            self._calculate_half_cell_curves_properties()
-        return result
-    return wrapper
-