steer-core 0.1.1__tar.gz

steer_core-0.1.1/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: steer-core
+Version: 0.1.1
+Summary: Modelling energy storage from cell to site - STEER OpenCell Design
+Home-page: https://github.com/nicholas9182/steer-core/
+Author: Nicholas Siemons
+Author-email: nsiemons@stanford.edu
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Requires-Dist: pandas
+Requires-Dist: numpy
+Requires-Dist: datetime
+Requires-Dist: scipy
+Requires-Dist: shapely
+Requires-Dist: plotly
+Requires-Dist: dash
+Requires-Dist: dash_bootstrap_components
+Requires-Dist: flask_caching
+Requires-Dist: nbformat
+Requires-Dist: scipy
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

steer_core-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

steer_core-0.1.1/setup.py

@@ -0,0 +1,40 @@
+from distutils.core import setup
+from setuptools import find_packages
+import pathlib
+import re
+
+root = pathlib.Path(__file__).parent
+init = root / "steer_core" / "__init__.py"
+version = re.search(r'__version__\s*=\s*"([^"]+)"', init.read_text()).group(1)
+
+setup(
+    name='steer-core',
+    version=version, 
+    description='Modelling energy storage from cell to site - STEER OpenCell Design',
+    author='Nicholas Siemons',
+    author_email='nsiemons@stanford.edu',
+    url="https://github.com/nicholas9182/steer-core/",
+    packages=find_packages(),
+    install_requires=[
+        "pandas",
+        "numpy",
+        "datetime",
+        "scipy",
+        "shapely",
+        "plotly",
+        "dash",
+        "dash_bootstrap_components",
+        "flask_caching",
+        "nbformat",
+        "scipy"
+    ],
+    scripts=[],
+    classifiers=[ 
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.10",
+)
+
+

steer_core-0.1.1/steer_core/Constants/Units.py

@@ -0,0 +1,36 @@
+## Unit conversions
+# Length units
+KG_TO_G = 1e3
+G_TO_KG = 1e-3
+M_TO_CM = 1e2
+CM_TO_M = 1e-2
+M_TO_MM = 1e3
+MM_TO_M = 1e-3
+M_TO_DM = 1e1
+DM_TO_M = 1e-1
+MG_TO_KG = 1e-6
+KG_TO_MG = 1e6
+M_TO_UM = 1e6
+UM_TO_M = 1e-6
+MM_TO_CM = 1e-1
+CM_TO_MM = 1e1
+UM_TO_MM = 1e-3
+mG_TO_G = 1e-3
+G_TO_mG = 1e3
+CM_TO_UM = 1e4
+UM_TO_CM = 1e-4
+
+# Current units
+A_TO_mA = 1e3
+mA_TO_A = 1e-3
+
+# Time units
+S_TO_H = 1/3600
+H_TO_S = 3600
+
+# Energy units
+W_TO_KW = 1e-3
+
+# Angle units
+DEG_TO_RAD = 0.017453292519943295
+

steer_core-0.1.1/steer_core/Constants/Universal.py

@@ -0,0 +1,2 @@
+## Constants
+PI = 3.14159265358979323846

steer_core-0.1.1/steer_core/DataManager.py

@@ -0,0 +1,316 @@
+import sqlite3 as sql
+from pathlib import Path
+import pandas as pd
+
+from steer_core.Constants.Units import *
+
+
+class DataManager:
+    
+    def __init__(self):
+
+        self._db_path = (Path(__file__).parent / '../steer_core/Data/database.db').resolve()
+        self._connection = sql.connect(self._db_path)
+        self._cursor = self._connection.cursor()
+
+    def create_table(self, table_name: str, columns: dict):
+        """
+        Function to create a table in the database.
+
+        :param table_name: Name of the table.
+        :param columns: Dictionary of columns and their types.
+        """
+        columns_str = ', '.join([f'{k} {v}' for k, v in columns.items()])
+        self._cursor.execute(f'CREATE TABLE IF NOT EXISTS {table_name} ({columns_str})')
+        self._connection.commit()
+
+    def drop_table(self, table_name: str):
+        """
+        Function to drop a table from the database.
+
+        :param table_name: Name of the table.
+        """
+        self._cursor.execute(f'DROP TABLE IF EXISTS {table_name}')
+        self._connection.commit()
+
+    def get_table_names(self):
+        """
+        Function to get the names of all tables in the database.
+
+        :return: List of table names.
+        """
+        self._cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
+        return [row[0] for row in self._cursor.fetchall()]
+
+    def insert_data(self, table_name: str, data: pd.DataFrame):
+        """
+        Inserts data into the database only if it doesn’t already exist.
+
+        :param table_name: Name of the table.
+        :param data: DataFrame containing the data to insert.
+        """
+        for _, row in data.iterrows():
+            conditions = ' AND '.join([f"{col} = ?" for col in data.columns])
+            check_query = f"SELECT COUNT(*) FROM {table_name} WHERE {conditions}"
+            
+            self._cursor.execute(check_query, tuple(row))
+            if self._cursor.fetchone()[0] == 0:  # If the row does not exist, insert it
+                insert_query = f"INSERT INTO {table_name} ({', '.join(data.columns)}) VALUES ({', '.join(['?'] * len(row))})"
+                self._cursor.execute(insert_query, tuple(row))
+
+        self._connection.commit()
+
+    def get_data(self, 
+                 table_name: str, 
+                 columns: list = None, 
+                 condition: str | list[str] = None, 
+                 latest_column: str = None):
+        """
+        Retrieve data from the database.
+
+        :param table_name: Name of the table.
+        :param columns: List of columns to retrieve. If None, retrieves all columns.
+        :param condition: Optional condition (single string or list of conditions).
+        :param latest_column: Column name to find the most recent row.
+        """
+        # If columns is not provided, get all columns from the table
+        if columns is None:
+            self._cursor.execute(f"PRAGMA table_info({table_name})")
+            columns_info = self._cursor.fetchall()
+            columns = [col[1] for col in columns_info]  # Extract column names
+            if not columns:
+                raise ValueError(f"Table '{table_name}' does not exist or has no columns.")
+
+        columns_str = ', '.join(columns)
+        query = f"SELECT {columns_str} FROM {table_name}"
+
+        # Add condition if specified
+        if condition:
+            if isinstance(condition, list):
+                condition_str = ' AND '.join(condition)
+            else:
+                condition_str = condition
+            query += f" WHERE {condition_str}"
+
+        # If latest_column is provided, get the most recent entry
+        if latest_column:
+            query += f" ORDER BY {latest_column} DESC LIMIT 1"
+
+        # Execute and return the result
+        self._cursor.execute(query)
+        data = self._cursor.fetchall()
+        
+        return pd.DataFrame(data, columns=columns)
+    
+    def get_unique_values(self, table_name: str, column_name: str):
+        """
+        Retrieves all unique values from a specified column.
+        
+        :param table_name: The name of the table.
+        :param column_name: The column to retrieve unique values from.
+        :return: A list of unique values.
+        """
+        query = f"SELECT DISTINCT {column_name} FROM {table_name}"
+        self._cursor.execute(query)
+        return [row[0] for row in self._cursor.fetchall()]
+    
+    def get_current_collector_materials(self, most_recent: bool = True) -> pd.DataFrame:
+        """
+        Retrieves current collector materials from the database.
+
+        :param most_recent: If True, returns only the most recent entry.
+        :return: DataFrame with current collector materials.
+        """
+        data = (self
+                .get_data(table_name='current_collector_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
+    
+    def get_insulation_materials(self, most_recent: bool = True) -> pd.DataFrame:
+        """
+        Retrieves insulation materials from the database.
+
+        :param most_recent: If True, returns only the most recent entry.
+        :return: DataFrame with insulation materials.
+        """
+        data = (
+            self
+            .get_data(
+                table_name='insulation_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
+
+    def get_cathode_materials(self, most_recent: bool = True) -> pd.DataFrame:
+        """
+        Retrieves cathode materials from the database.
+
+        :param most_recent: If True, returns only the most recent entry.
+        :return: DataFrame with cathode materials.
+        """
+        data = (
+            self
+            .get_data(
+                table_name='cathode_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
+    
+    def get_anode_materials(self, most_recent: bool = True) -> pd.DataFrame:
+        """
+        Retrieves anode materials from the database.
+
+        :param most_recent: If True, returns only the most recent entry.
+        :return: DataFrame with anode materials.
+        """
+        data = (
+            self
+            .get_data(
+                table_name='anode_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
+    
+    def get_binder_materials(self, most_recent: bool = True) -> pd.DataFrame:
+        """
+        Retrieves binder materials from the database.
+
+        :param most_recent: If True, returns only the most recent entry.
+        :return: DataFrame with binder materials.
+        """
+        data = (
+            self
+            .get_data(
+                table_name='binder_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
+    
+    def get_conductive_additive_materials(self, most_recent: bool = True) -> pd.DataFrame:
+        """
+        Retrieves conductive additives from the database.
+
+        :param most_recent: If True, returns only the most recent entry.
+        :return: DataFrame with conductive additives.
+        """
+        data = (
+            self
+            .get_data(
+                table_name='conductive_additive_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
+
+    def get_separator_materials(self, most_recent: bool = True) -> pd.DataFrame:
+        """
+        Retrieves separator materials from the database.
+
+        :param most_recent: If True, returns only the most recent entry.
+        :return: DataFrame with separator materials.
+        """
+        data = (
+            self
+            .get_data(
+                table_name='separator_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:
+        """
+        Function to read in a half cell curve for this active material
+
+        :param half_cell_path: Path to the half cell data file.
+        :return: DataFrame with the specific capacity and voltage.
+        """
+        try:
+            data = pd.read_csv(half_cell_path)
+        except:
+            raise FileNotFoundError(f"Could not find the file at {half_cell_path}")
+        
+        if 'Specific Capacity (mAh/g)' not in data.columns:
+            raise ValueError("The file must have a column named 'Specific Capacity (mAh/g)'")
+        
+        if 'Voltage (V)' not in data.columns:
+            raise ValueError("The file must have a column named 'Voltage (V)'")
+        
+        if 'Step_ID' not in data.columns:
+            raise ValueError("The file must have a column named 'Step_ID'")
+        
+        data = (data
+                .rename(columns={'Specific Capacity (mAh/g)': 'specific_capacity', 'Voltage (V)': 'voltage', 'Step_ID': 'step_id'})
+                .assign(specific_capacity=lambda x: x['specific_capacity'] * (H_TO_S * mA_TO_A / G_TO_KG))
+                .filter(['specific_capacity', 'voltage', 'step_id'])
+                .groupby(['specific_capacity', 'step_id'], group_keys=False)['voltage'].max()
+                .reset_index()
+                .sort_values(['step_id', 'specific_capacity'])
+                )
+
+        return data
+    
+    def remove_data(self, table_name: str, condition: str):
+        """
+        Function to remove data from the database.
+
+        :param table_name: Name of the table.
+        :param condition: Condition to remove rows.
+        """
+        self._cursor.execute(f"DELETE FROM {table_name} WHERE {condition}")
+        self._connection.commit()
+        
+    def __del__(self):
+        self._connection.close()
+
+

steer_core-0.1.1/steer_core/Decorators/Coordinates.py

@@ -0,0 +1,46 @@
+from functools import wraps
+
+
+def calculate_coordinates(func):
+    """
+    Decorator to recalculate spatial properties after a method call.
+    This is useful for methods that modify the geometry of a component.
+    """
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        result = func(self, *args, **kwargs)
+        if hasattr(self, '_update_properties') and self._update_properties:
+            self._calculate_coordinates()
+        return result
+    return wrapper
+
+
+def calculate_areas(func):
+    """
+    Decorator to recalculate areas after a method call.
+    This is useful for methods that modify the geometry of a component.
+    """
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        result = func(self, *args, **kwargs)
+        if hasattr(self, '_update_properties') and self._update_properties:
+            self._calculate_coordinates()
+            self._calculate_areas()
+        return result
+    return wrapper
+
+
+def calculate_volumes(func):
+    """
+    Decorator to recalculate volumes after a method call.
+    This is useful for methods that modify the geometry of a component.
+    """
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        result = func(self, *args, **kwargs)
+        if hasattr(self, '_update_properties') and self._update_properties:
+            self._calculate_bulk_properties()
+            self._calculate_coordinates()
+        return result
+    return wrapper
+

steer_core-0.1.1/steer_core/Decorators/Electrochemical.py

@@ -0,0 +1,28 @@
+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

steer_core-0.1.1/steer_core/Decorators/General.py

@@ -0,0 +1,30 @@
+from functools import wraps
+
+def calculate_bulk_properties(func):
+    """
+    Decorator to recalculate bulk properties after a method call.
+    This is useful for methods that modify the material properties.
+    """
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        result = func(self, *args, **kwargs)
+        if hasattr(self, '_update_properties') and self._update_properties:
+            self._calculate_bulk_properties()
+        return result
+    return wrapper
+
+
+def calculate_all_properties(func):
+    """
+    Decorator to recalculate both spatial and bulk properties after a method call.
+    This is useful for methods that modify both geometry and material properties.
+    """
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        result = func(self, *args, **kwargs)
+        if hasattr(self, '_update_properties') and self._update_properties:
+            self._calculate_all_properties()
+        return result
+    return wrapper
+
+

steer_core-0.1.1/steer_core/Decorators/Objects.py

@@ -0,0 +1,14 @@
+from functools import wraps
+
+def calculate_weld_tab_properties(func):
+    """
+    Decorator to recalculate weld tab properties after a method call.
+    This is useful for methods that modify the weld tab geometry or material.
+    """
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        result = func(self, *args, **kwargs)
+        if hasattr(self, '_update_properties') and self._update_properties:
+            self._calculate_weld_tab_properties()
+        return result
+    return wrapper

steer_core-0.1.1/steer_core/Mixins/Colors.py

@@ -0,0 +1,41 @@
+import numpy as np
+import plotly.colors as pc
+
+import pandas as pd
+import numpy as np
+
+class ColorMixin:
+    """
+    A class to manage colors, including conversion between hex and RGB formats,
+    and generating color gradients.
+    """
+    @staticmethod
+    def rgb_tuple_to_hex(rgb):
+        return '#{:02x}{:02x}{:02x}'.format(*rgb)
+
+    @staticmethod
+    def get_colorway(color1, color2, n):
+        """
+        Generate a list of n hex colors interpolated between two HTML hex colors.
+
+        Parameters
+        ----------
+        color1 : str
+            The first color in HTML hex format (e.g., '#ff0000').
+        color2 : str
+            The second color in HTML hex format (e.g., '#0000ff').
+        n : int
+            The number of colors to generate in the gradient.
+        """
+        # Convert hex to RGB (0–255)
+        rgb1 = np.array(pc.hex_to_rgb(color1))
+        rgb2 = np.array(pc.hex_to_rgb(color2))
+
+        # Interpolate and convert to hex
+        colors = [
+            ColorMixin.rgb_tuple_to_hex(tuple(((1 - t) * rgb1 + t * rgb2).astype(int)))
+            for t in np.linspace(0, 1, n)
+        ]
+
+        return colors
+