corrosim 1.0.0__py3-none-any.whl

corrosim/__init__.py

@@ -0,0 +1,19 @@
+"""
+CorroSim - Professional Corrosion Analysis Platform
+
+A comprehensive tool for electrochemical corrosion analysis including:
+- Tafel polarization analysis
+- Lifetime prediction
+- Multi-sample comparison
+- Data import/export
+"""
+
+__version__ = "1.0.0"
+__author__ = "Your Name"
+__description__ = "Professional Corrosion Analysis Platform"
+
+from .tafel_engine import TafelEngine
+from .database import Database
+from .theme import Theme
+
+__all__ = ['TafelEngine', 'Database', 'Theme']

corrosim/app.py

@@ -0,0 +1,206 @@
+"""Main Application Window"""
+
+from PyQt6.QtWidgets import *
+from PyQt6.QtCore import *
+from PyQt6.QtGui import *
+
+from .theme import Theme, GLOBAL_STYLE, SIDEBAR_STYLE
+from .database import Database
+from .tabs import ImportTab, TafelTab, PredictionTab, ComparisonTab
+
+
+class MainWindow(QMainWindow):
+    """Main application window for CorroSim"""
+    
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("CorroSim Analysis Platform")
+        self.setMinimumSize(1200, 800)
+        self.resize(1400, 900)
+        
+        # Initialize components
+        self.db = Database()
+        self.nav_buttons = []
+        
+        self.setStyleSheet(GLOBAL_STYLE)
+        self._setup_ui()
+        self._setup_menu()
+        self.statusBar().showMessage("Ready - Import data to begin")
+    
+    def _setup_ui(self):
+        """Setup the user interface"""
+        central = QWidget()
+        self.setCentralWidget(central)
+        main_layout = QHBoxLayout(central)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        main_layout.setSpacing(0)
+        
+        self._create_sidebar()
+        self._create_tabs()
+        
+        main_layout.addWidget(self.sidebar)
+        main_layout.addWidget(self.tabs, 1)
+        
+        self.switch_tab(0)
+    
+    def _create_sidebar(self):
+        """Create navigation sidebar"""
+        self.sidebar = QWidget()
+        self.sidebar.setObjectName("sidebar")
+        self.sidebar.setFixedWidth(200)
+        self.sidebar.setStyleSheet(SIDEBAR_STYLE)
+        
+        layout = QVBoxLayout(self.sidebar)
+        layout.setContentsMargins(12, 20, 12, 20)
+        layout.setSpacing(6)
+        
+        # Logo
+        logo = QLabel("⚡ CorroSim")
+        logo.setStyleSheet("font-size: 18px; font-weight: 700; color: white; background: transparent;")
+        layout.addWidget(logo)
+        layout.addSpacing(20)
+        
+        # Navigation label
+        nav_label = QLabel("NAVIGATION")
+        nav_label.setStyleSheet("color: #94A3B8; font-size: 10px; font-weight: 600; background: transparent;")
+        layout.addWidget(nav_label)
+        
+        # Navigation buttons
+        tabs = [
+            ("📁", "Import", 0),
+            ("⚡", "Tafel", 1),
+            ("🔮", "Prediction", 2),
+            ("📊", "Compare", 3)
+        ]
+        
+        for icon, text, idx in tabs:
+            btn = QPushButton(f"  {icon}  {text}")
+            btn.setProperty("active", "false")
+            btn.clicked.connect(lambda checked, i=idx: self.switch_tab(i))
+            self.nav_buttons.append(btn)
+            layout.addWidget(btn)
+        
+        layout.addStretch()
+        
+        # Status indicator
+        sep = QFrame()
+        sep.setFrameShape(QFrame.Shape.HLine)
+        sep.setStyleSheet("background-color: #334155; max-height: 1px;")
+        layout.addWidget(sep)
+        
+        status = QLabel("● Database Connected")
+        status.setStyleSheet("color: #10B981; font-size: 10px; background: transparent; padding: 8px;")
+        layout.addWidget(status)
+    
+    def _create_tabs(self):
+        """Create and setup all tabs"""
+        self.tabs = QTabWidget()
+        self.tabs.tabBar().setVisible(False)
+        
+        # Create tab widgets
+        self.import_widget = QWidget()
+        self.tafel_widget = QWidget()
+        self.prediction_widget = QWidget()
+        self.comparison_widget = QWidget()
+        
+        self.tabs.addTab(self.import_widget, "Import")
+        self.tabs.addTab(self.tafel_widget, "Tafel")
+        self.tabs.addTab(self.prediction_widget, "Prediction")
+        self.tabs.addTab(self.comparison_widget, "Compare")
+        
+        # Setup Import Tab
+        self.import_tab = ImportTab()
+        self.import_tab.setup(
+            parent=self.import_widget,
+            db=self.db,
+            switch_tab_callback=self.switch_tab,
+            load_tafel_callback=self._load_tafel_data
+        )
+        
+        # Setup Tafel Tab
+        self.tafel_tab = TafelTab()
+        self.tafel_tab.setup(
+            parent=self.tafel_widget,
+            db=self.db
+        )
+        
+        # Setup Prediction Tab
+        self.prediction_tab = PredictionTab()
+        self.prediction_tab.setup(
+            parent=self.prediction_widget
+        )
+        
+        # Setup Comparison Tab
+        self.comparison_tab = ComparisonTab()
+        self.comparison_tab.setup(
+            parent=self.comparison_widget,
+            db=self.db
+        )
+    
+    def switch_tab(self, index):
+        """Switch active tab"""
+        self.tabs.setCurrentIndex(index)
+        for i, btn in enumerate(self.nav_buttons):
+            btn.setProperty("active", "true" if i == index else "false")
+            btn.style().unpolish(btn)
+            btn.style().polish(btn)
+    
+    def _load_tafel_data(self):
+        """Load latest data into Tafel tab"""
+        if hasattr(self, 'tafel_tab'):
+            self.tafel_tab._load_data()
+    
+    def _setup_menu(self):
+        """Setup menu bar"""
+        menubar = self.menuBar()
+        menubar.setStyleSheet(f"""
+            QMenuBar {{
+                background-color: {Theme.BG_WHITE};
+                border-bottom: 1px solid {Theme.BORDER};
+                padding: 2px;
+            }}
+            QMenuBar::item {{
+                padding: 6px 12px;
+                border-radius: 4px;
+            }}
+            QMenuBar::item:selected {{
+                background-color: {Theme.PRIMARY_LIGHT};
+            }}
+        """)
+        
+        file_menu = menubar.addMenu("File")
+        
+        exit_action = QAction("Exit", self)
+        exit_action.setShortcut("Ctrl+Q")
+        exit_action.triggered.connect(self.close)
+        file_menu.addAction(exit_action)
+        
+        help_menu = menubar.addMenu("Help")
+        
+        about_action = QAction("About", self)
+        about_action.triggered.connect(self._show_about)
+        help_menu.addAction(about_action)
+    
+    def _show_about(self):
+        """Show about dialog"""
+        QMessageBox.about(
+            self,
+            "About CorroSim",
+            "<h3>⚡ CorroSim Analysis Platform</h3>"
+            "<p>Version 1.0.0</p>"
+            "<p>Professional Corrosion Analysis Tool</p>"
+            "<hr>"
+            "<p><b>Features:</b></p>"
+            "<ul>"
+            "<li>Tafel Polarization Analysis</li>"
+            "<li>Lifetime Prediction Models</li>"
+            "<li>Multi-Sample Comparison</li>"
+            "<li>Data Export (PNG, PDF, Excel)</li>"
+            "</ul>"
+            "<p>© 2026 CorroSim By NanoStack-Lab</p>"
+        )
+    
+    def closeEvent(self, event):
+        """Handle window close event"""
+        self.db.close()
+        event.accept()

corrosim/database.py

@@ -0,0 +1,85 @@
+"""Database module for CorroSim"""
+
+import sqlite3
+import uuid
+import datetime
+import pandas as pd
+from io import StringIO
+
+
+class Database:
+    """SQLite database for storing corrosion analysis samples"""
+    
+    def __init__(self, db_path='corrosion.db'):
+        self.db_path = db_path
+        self.conn = sqlite3.connect(db_path)
+        self.cursor = self.conn.cursor()
+        self._create_tables()
+    
+    def _create_tables(self):
+        """Create database tables if they don't exist"""
+        self.cursor.execute('''
+            CREATE TABLE IF NOT EXISTS samples (
+                id TEXT PRIMARY KEY,
+                name TEXT,
+                test_type TEXT,
+                date TEXT,
+                data TEXT,
+                ecorr REAL,
+                icorr REAL,
+                cr REAL,
+                ba REAL,
+                bc REAL
+            )
+        ''')
+        self.conn.commit()
+    
+    def save(self, name, test_type, data):
+        """Save a new sample to the database"""
+        sid = str(uuid.uuid4())[:8]
+        data_csv = data.to_csv(index=False)
+        date = datetime.datetime.now().strftime('%Y-%m-%d %H:%M')
+        
+        self.cursor.execute(
+            "INSERT INTO samples VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+            (sid, name, test_type, date, data_csv, None, None, None, None, None)
+        )
+        self.conn.commit()
+        return sid
+    
+    def update(self, sid, ecorr, icorr, cr, ba, bc):
+        """Update analysis results for a sample"""
+        self.cursor.execute(
+            "UPDATE samples SET ecorr=?, icorr=?, cr=?, ba=?, bc=? WHERE id=?",
+            (ecorr, icorr, cr, ba, bc, sid)
+        )
+        self.conn.commit()
+    
+    def get_all(self):
+        """Get all samples ordered by date"""
+        self.cursor.execute("SELECT * FROM samples ORDER BY date DESC")
+        return self.cursor.fetchall()
+    
+    def get_latest(self):
+        """Get the most recent sample"""
+        self.cursor.execute("SELECT * FROM samples ORDER BY date DESC LIMIT 1")
+        return self.cursor.fetchone()
+    
+    def get_by_id(self, sid):
+        """Get a specific sample by ID"""
+        self.cursor.execute("SELECT * FROM samples WHERE id=?", (sid,))
+        return self.cursor.fetchone()
+    
+    def delete(self, sid):
+        """Delete a sample by ID"""
+        self.cursor.execute("DELETE FROM samples WHERE id=?", (sid,))
+        self.conn.commit()
+    
+    def get_count(self):
+        """Get total number of samples"""
+        self.cursor.execute("SELECT COUNT(*) FROM samples")
+        return self.cursor.fetchone()[0]
+    
+    def close(self):
+        """Close database connection"""
+        self.conn.close()

corrosim/main.py

@@ -0,0 +1,37 @@
+"""Main entry point for CorroSim"""
+
+import sys
+import time
+from PyQt6.QtWidgets import QApplication
+
+from .splash_screen import SplashScreen
+from .app import MainWindow
+
+
+def main():
+    """Application entry point"""
+    app = QApplication(sys.argv)
+    app.setStyle('Fusion')
+    
+    # Show splash screen with loading sequence
+    messages = [
+        "Initializing database...",
+        "Loading analysis modules...",
+        "Setting up user interface...",
+        "Preparing Tafel engine...",
+        "Starting application..."
+    ]
+    delays = [0.3, 0.3, 0.3, 0.3, 0.2]
+    
+    splash = SplashScreen.show_loading_sequence(messages, delays)
+    
+    # Create and show main window
+    window = MainWindow()
+    splash.close()
+    window.show()
+    
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    main()

corrosim/splash_screen.py

@@ -0,0 +1,234 @@
+"""Professional Splash Screen for CorroSim"""
+
+import time
+from PyQt6.QtWidgets import QSplashScreen, QApplication
+from PyQt6.QtCore import Qt, QRect, QRectF
+from PyQt6.QtGui import QPixmap, QPainter, QColor, QFont, QLinearGradient, QPen, QBrush
+
+
+class SplashScreen(QSplashScreen):
+    """Professional splash screen with gradient design and progress bar"""
+    
+    # Configuration
+    WIDTH = 600
+    HEIGHT = 400
+    BRAND_NAME = "CorroSim"
+    TAGLINE = "Advanced Corrosion Analysis Platform"
+    VERSION = "Version 1.0.0"
+    COPYRIGHT = "© 2026 CorroSim • NanoStack-Lab"
+    WEBSITE = "github.com/khadev/corrosim"
+    
+    def __init__(self):
+        pixmap = self._create_pixmap(0, "Initializing...")
+        super().__init__(pixmap)
+        self.setWindowFlags(
+            Qt.WindowType.WindowStaysOnTopHint | 
+            Qt.WindowType.FramelessWindowHint |
+            Qt.WindowType.SplashScreen
+        )
+        self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground, False)
+        self._center_on_screen()
+        self.show()
+        QApplication.processEvents()
+    
+    def _draw_gradient_background(self, painter, pixmap):
+        """Draw professional gradient background"""
+        gradient = QLinearGradient(0, 0, self.WIDTH, self.HEIGHT)
+        gradient.setColorAt(0.0, QColor("#0F172A"))    # Dark navy top
+        gradient.setColorAt(0.4, QColor("#1E293B"))    # Slate middle
+        gradient.setColorAt(0.7, QColor("#1E3A5F"))    # Blue-tinted
+        gradient.setColorAt(1.0, QColor("#0F172A"))    # Dark navy bottom
+        
+        painter.setBrush(QBrush(gradient))
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.drawRect(pixmap.rect())
+    
+    def _draw_decorative_circles(self, painter):
+        """Draw decorative background circles"""
+        # Large subtle circle top-right
+        painter.setBrush(QColor(37, 99, 235, 15))  # Theme blue, very transparent
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.drawEllipse(QRect(self.WIDTH - 150, -80, 300, 300))
+        
+        # Small circle bottom-left
+        painter.setBrush(QColor(5, 150, 105, 10))  # Theme green, very transparent
+        painter.drawEllipse(QRect(-60, self.HEIGHT - 120, 200, 200))
+        
+        # Medium circle center accent
+        painter.setBrush(QColor(124, 58, 237, 8))  # Purple accent
+        painter.drawEllipse(QRect(self.WIDTH//2 - 100, 50, 250, 250))
+    
+    def _draw_logo_icon(self, painter):
+        """Draw modern logo icon"""
+        # Outer circle
+        painter.setBrush(QColor(37, 99, 235, 30))
+        painter.setPen(QPen(QColor("#2563EB"), 2))
+        painter.drawEllipse(QRect(self.WIDTH//2 - 35, 70, 70, 70))
+        
+        # Lightning bolt symbol
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.setBrush(QColor("#3B82F6"))
+        
+        # Draw a simple lightning bolt using polygons
+        bolt = [
+            (self.WIDTH//2 + 8, 78),
+            (self.WIDTH//2 - 8, 102),
+            (self.WIDTH//2 + 2, 102),
+            (self.WIDTH//2 - 5, 120),
+            (self.WIDTH//2 + 12, 96),
+            (self.WIDTH//2, 96),
+            (self.WIDTH//2 + 10, 78)
+        ]
+        
+        from PyQt6.QtGui import QPolygon
+        from PyQt6.QtCore import QPoint
+        
+        points = [QPoint(x, y) for x, y in bolt]
+        polygon = QPolygon(points)
+        painter.drawPolygon(polygon)
+    
+    def _draw_brand_text(self, painter):
+        """Draw brand name and tagline"""
+        # Brand name
+        painter.setPen(QColor("#F8FAFC"))
+        font_title = QFont("Segoe UI", 36, QFont.Weight.Bold)
+        font_title.setLetterSpacing(QFont.SpacingType.AbsoluteSpacing, 2)
+        painter.setFont(font_title)
+        painter.drawText(
+            QRect(0, 145, self.WIDTH, 50), 
+            Qt.AlignmentFlag.AlignCenter, 
+            self.BRAND_NAME
+        )
+        
+        # Tagline
+        painter.setPen(QColor("#94A3B8"))
+        font_tag = QFont("Segoe UI", 13, QFont.Weight.Normal)
+        painter.setFont(font_tag)
+        painter.drawText(
+            QRect(0, 200, self.WIDTH, 25), 
+            Qt.AlignmentFlag.AlignCenter, 
+            self.TAGLINE
+        )
+        
+        # Version badge
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.setBrush(QColor(37, 99, 235, 40))
+        badge_rect = QRect(self.WIDTH//2 - 50, 232, 100, 24)
+        painter.drawRoundedRect(QRectF(badge_rect), 12, 12)
+        
+        painter.setPen(QColor("#60A5FA"))
+        font_ver = QFont("Segoe UI", 10, QFont.Weight.Medium)
+        painter.setFont(font_ver)
+        painter.drawText(badge_rect, Qt.AlignmentFlag.AlignCenter, self.VERSION)
+    
+    def _draw_progress_section(self, painter, progress, text):
+        """Draw modern progress bar and status text"""
+        # Section separator line
+        painter.setPen(QPen(QColor("#334155"), 1))
+        painter.drawLine(80, 285, self.WIDTH - 80, 285)
+        
+        # Status text
+        painter.setPen(QColor("#10B981"))
+        font_status = QFont("Segoe UI", 10, QFont.Weight.Normal)
+        painter.setFont(font_status)
+        painter.drawText(
+            QRect(0, 290, self.WIDTH, 25), 
+            Qt.AlignmentFlag.AlignCenter, 
+            text
+        )
+        
+        # Progress bar background
+        bar_x = 80
+        bar_y = 322
+        bar_width = self.WIDTH - 160
+        bar_height = 5
+        
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.setBrush(QColor("#1E293B"))
+        painter.drawRoundedRect(QRectF(bar_x, bar_y, bar_width, bar_height), 3, 3)
+        
+        # Progress bar fill with gradient
+        if progress > 0:
+            fill_width = int(bar_width * progress / 100)
+            fill_gradient = QLinearGradient(bar_x, 0, bar_x + fill_width, 0)
+            fill_gradient.setColorAt(0.0, QColor("#2563EB"))
+            fill_gradient.setColorAt(1.0, QColor("#059669"))
+            
+            painter.setBrush(QBrush(fill_gradient))
+            painter.drawRoundedRect(QRectF(bar_x, bar_y, fill_width, bar_height), 3, 3)
+            
+            # Glow dot at progress end
+            if fill_width > 5:
+                painter.setBrush(QColor("#F8FAFC"))
+                painter.drawEllipse(QRect(bar_x + fill_width - 5, bar_y - 3, 10, 10))
+    
+    def _draw_footer(self, painter):
+        """Draw footer with copyright and website"""
+        # Copyright
+        painter.setPen(QColor("#64748B"))
+        font_footer = QFont("Segoe UI", 9, QFont.Weight.Normal)
+        painter.setFont(font_footer)
+        painter.drawText(
+            QRect(0, self.HEIGHT - 35, self.WIDTH, 20), 
+            Qt.AlignmentFlag.AlignCenter, 
+            self.COPYRIGHT
+        )
+        
+        # Website
+        painter.setPen(QColor("#475569"))
+        font_web = QFont("Segoe UI", 8, QFont.Weight.Light)
+        painter.setFont(font_web)
+        painter.drawText(
+            QRect(0, self.HEIGHT - 18, self.WIDTH, 15), 
+            Qt.AlignmentFlag.AlignCenter, 
+            self.WEBSITE
+        )
+    
+    def _create_pixmap(self, progress, text):
+        """Create complete splash screen pixmap"""
+        pixmap = QPixmap(self.WIDTH, self.HEIGHT)
+        
+        painter = QPainter(pixmap)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+        
+        # Draw all layers
+        self._draw_gradient_background(painter, pixmap)
+        self._draw_decorative_circles(painter)
+        self._draw_logo_icon(painter)
+        self._draw_brand_text(painter)
+        self._draw_progress_section(painter, progress, text)
+        self._draw_footer(painter)
+        
+        painter.end()
+        return pixmap
+    
+    def _center_on_screen(self):
+        """Center splash on screen"""
+        screen = QApplication.primaryScreen().geometry()
+        x = (screen.width() - self.WIDTH) // 2
+        y = (screen.height() - self.HEIGHT) // 2
+        self.move(x, y)
+    
+    def update_progress(self, value, text):
+        """Update progress bar and status text"""
+        pixmap = self._create_pixmap(value, text)
+        self.setPixmap(pixmap)
+        QApplication.processEvents()
+    
+    @staticmethod
+    def show_loading_sequence(messages, delays):
+        """
+        Show animated loading sequence.
+        
+        Parameters:
+        - messages: List of status messages
+        - delays: List of delays (seconds) between messages
+        """
+        splash = SplashScreen()
+        
+        for i, (msg, delay) in enumerate(zip(messages, delays)):
+            progress = int((i + 1) / len(messages) * 100)
+            splash.update_progress(progress, msg)
+            time.sleep(delay)
+        
+        return splash

corrosim/tabs/__init__.py

@@ -0,0 +1,8 @@
+"""Tab modules for CorroSim"""
+
+from .import_tab import ImportTab
+from .tafel_tab import TafelTab
+from .prediction_tab import PredictionTab
+from .comparison_tab import ComparisonTab
+
+__all__ = ['ImportTab', 'TafelTab', 'PredictionTab', 'ComparisonTab']