Create app.py

app.py

@@ -0,0 +1,614 @@
+# app.py
+import streamlit as st
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import requests
+import json
+import os
+from dotenv import load_dotenv
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime
+
+# Load environment variables
+load_dotenv()
+GROQ_API_KEY = os.getenv('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')
+
+# Page configuration
+st.set_page_config(
+    page_title="Hydrogen Production Optimizer",
+    page_icon="⚡",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS
+st.markdown("""
+<style>
+    .main {
+        padding: 1rem;
+    }
+    .stButton>button {
+        width: 100%;
+        background-color: #4CAF50;
+        color: white;
+    }
+    .stTabs [data-baseweb="tab-list"] {
+        gap: 10px;
+    }
+    .stTabs [data-baseweb="tab"] {
+        padding: 10px;
+        border-radius: 4px 4px 0px 0px;
+    }
+    h1, h2, h3 {
+        color: #1E88E5;
+    }
+    .highlight {
+        background-color: #f0f8ff;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        border-left: 5px solid #1E88E5;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Helper functions for calculations
+def calculate_h2_production(method, water_quantity, energy_input, current_density, voltage):
+    """Calculate hydrogen production based on input parameters"""
+    # Conversion factors and efficiencies for different methods
+    method_efficiencies = {
+        "Alkaline Electrolysis": 0.65,
+        "PEM Electrolysis": 0.75,
+        "SOEC": 0.85
+    }
+    
+    # Basic Faraday's law calculation (simplified)
+    # Assuming ideal conditions and standard molar volume
+    faraday_constant = 96485  # C/mol
+    molar_mass_h2 = 2.02  # g/mol
+    
+    # Adjusting efficiency based on method
+    efficiency = method_efficiencies[method]
+    
+    # Calculate total charge (Q = I * t)
+    # Assuming current_density is in A/cm² and we convert water_quantity to surface area
+    surface_area = water_quantity * 0.1  # Simplified conversion
+    current = current_density * surface_area  # Total current in A
+    
+    # Assuming energy_input helps determine operation time
+    time_hours = energy_input / (voltage * current)  # Time in hours
+    
+    # Calculate hydrogen production using Faraday's Law
+    moles_h2 = (current * time_hours * 3600 * efficiency) / (2 * faraday_constant)
+    mass_h2 = moles_h2 * molar_mass_h2  # grams
+    volume_h2 = moles_h2 * 22.4  # Standard liters
+    
+    return {
+        "production_rate_g_per_hour": mass_h2 / time_hours,
+        "total_production_g": mass_h2,
+        "total_production_L": volume_h2,
+        "efficiency": efficiency,
+        "operation_time_hours": time_hours
+    }
+
+def calculate_cost(method, water_cost, water_purification_cost, energy_source, energy_input, h2_production):
+    """Calculate the cost of hydrogen production"""
+    # Energy costs by source ($/kWh)
+    energy_costs = {
+        "Grid Electricity": 0.12,
+        "Solar": 0.08,
+        "Wind": 0.06,
+        "Nuclear": 0.10,
+        "Hydroelectric": 0.07
+    }
+    
+    # Operational costs by method ($/kg H2)
+    operational_costs = {
+        "Alkaline Electrolysis": 1.2,
+        "PEM Electrolysis": 1.5,
+        "SOEC": 1.8
+    }
+    
+    # Calculate water cost
+    total_water_cost = water_cost * (h2_production["total_production_g"] / 1000)  # $/kg
+    
+    # Calculate purification cost
+    total_purification_cost = water_purification_cost * (h2_production["total_production_g"] / 1000)  # $/kg
+    
+    # Calculate energy cost
+    energy_cost_rate = energy_costs[energy_source]
+    total_energy_cost = energy_cost_rate * energy_input  # $
+    
+    # Calculate operational cost
+    operational_cost_rate = operational_costs[method]
+    total_operational_cost = operational_cost_rate * (h2_production["total_production_g"] / 1000)  # $
+    
+    # Calculate total cost
+    total_cost = total_water_cost + total_purification_cost + total_energy_cost + total_operational_cost
+    
+    # Calculate cost per kg of H2
+    cost_per_kg = total_cost / (h2_production["total_production_g"] / 1000) if h2_production["total_production_g"] > 0 else 0
+    
+    return {
+        "water_cost": total_water_cost,
+        "purification_cost": total_purification_cost,
+        "energy_cost": total_energy_cost,
+        "operational_cost": total_operational_cost,
+        "total_cost": total_cost,
+        "cost_per_kg": cost_per_kg
+    }
+
+def call_groq_api(user_inputs, production_data, cost_data):
+    """Call Groq API with Llama 3 to analyze production parameters and provide recommendations"""
+    
+    if not GROQ_API_KEY:
+        return {"error": "Groq API key not found. Please set the GROQ_API_KEY environment variable."}
+    
+    # Format inputs for the API
+    prompt = f"""
+    As a hydrogen production expert, analyze the following electrolysis parameters and provide recommendations for optimization:
+    
+    Input Parameters:
+    - Water Source: {user_inputs['water_source']}
+    - Production Method: {user_inputs['production_method']}
+    - Energy Source: {user_inputs['energy_source']}
+    - Current Density: {user_inputs['current_density']} A/cm²
+    - Voltage: {user_inputs['voltage']} V
+    - Membrane Material: {user_inputs['membrane']}
+    - Electrode Materials: {user_inputs['electrodes']}
+    
+    Production Results:
+    - Production Rate: {production_data['production_rate_g_per_hour']:.2f} g/hour
+    - Total Production: {production_data['total_production_g']:.2f} g
+    - Efficiency: {production_data['efficiency'] * 100:.1f}%
+    - Operation Time: {production_data['operation_time_hours']:.2f} hours
+    
+    Cost Analysis:
+    - Water Cost: ${cost_data['water_cost']:.2f}
+    - Purification Cost: ${cost_data['purification_cost']:.2f}
+    - Energy Cost: ${cost_data['energy_cost']:.2f}
+    - Operational Cost: ${cost_data['operational_cost']:.2f}
+    - Total Cost: ${cost_data['total_cost']:.2f}
+    - Cost per kg H₂: ${cost_data['cost_per_kg']:.2f}
+    
+    Please provide:
+    1. An efficiency assessment of the current setup
+    2. Three specific recommendations to improve efficiency
+    3. Three specific recommendations to reduce costs
+    4. An ideal parameter configuration based on the provided inputs
+    
+    Format your response as a structured JSON with the following fields:
+    {
+        "efficiency_assessment": "text analysis",
+        "efficiency_recommendations": ["recommendation1", "recommendation2", "recommendation3"],
+        "cost_recommendations": ["recommendation1", "recommendation2", "recommendation3"],
+        "ideal_parameters": {
+            "current_density": value,
+            "voltage": value,
+            "membrane": "recommendation",
+            "electrodes": "recommendation",
+            "energy_source": "recommendation"
+        },
+        "estimated_improvement": {
+            "efficiency_increase": "percentage",
+            "cost_reduction": "percentage"
+        }
+    }
+    """
+    
+    try:
+        # API call to Groq
+        headers = {
+            "Authorization": f"Bearer {GROQ_API_KEY}",
+            "Content-Type": "application/json"
+        }
+        
+        payload = {
+            "messages": [
+                {"role": "user", "content": prompt}
+            ],
+            "model": "llama3-70b-8192",
+            "temperature": 0.5,
+            "max_tokens": 1024,
+            "response_format": {"type": "json_object"}
+        }
+        
+        response = requests.post(
+            "https://api.groq.com/openai/v1/chat/completions",
+            headers=headers,
+            json=payload
+        )
+        
+        if response.status_code == 200:
+            response_data = response.json()
+            # Extract JSON from the response
+            try:
+                recommendations_json = json.loads(response_data["choices"][0]["message"]["content"])
+                return recommendations_json
+            except json.JSONDecodeError:
+                return {"error": "Failed to parse API response as JSON"}
+        else:
+            return {"error": f"API call failed with status code {response.status_code}: {response.text}"}
+            
+    except Exception as e:
+        return {"error": f"Error calling Groq API: {str(e)}"}
+
+# Main application
+def main():
+    # Sidebar for inputs
+    st.sidebar.image("https://upload.wikimedia.org/wikipedia/commons/thumb/1/18/Creative-Tail-Objects-flask.svg/256px-Creative-Tail-Objects-flask.svg.png", width=100)
+    st.sidebar.title("H₂ Production Parameters")
+    
+    # Water parameters
+    st.sidebar.subheader("Water Parameters")
+    water_source = st.sidebar.selectbox("Water Source", ["Tap Water", "Deionized Water", "Seawater", "Wastewater", "Ultrapure Water"])
+    water_cost = st.sidebar.number_input("Water Cost ($/m³)", min_value=0.1, max_value=50.0, value=2.0, step=0.1)
+    water_purification_cost = st.sidebar.number_input("Water Purification Cost ($/m³)", min_value=0.0, max_value=100.0, value=5.0, step=0.5)
+    water_quantity = st.sidebar.number_input("Water Quantity (L)", min_value=1.0, max_value=10000.0, value=100.0, step=10.0)
+    
+    # Electrolysis parameters
+    st.sidebar.subheader("Electrolysis Parameters")
+    production_method = st.sidebar.selectbox("Production Method", ["Alkaline Electrolysis", "PEM Electrolysis", "SOEC"])
+    current_density = st.sidebar.slider("Current Density (A/cm²)", min_value=0.1, max_value=2.0, value=0.5, step=0.1)
+    voltage = st.sidebar.slider("Voltage (V)", min_value=1.4, max_value=5.0, value=2.0, step=0.1)
+    
+    # Materials
+    membrane = st.sidebar.selectbox("Membrane Material", ["Nafion", "Zirfon", "Ceramic", "PBI", "SPEEK"])
+    electrodes = st.sidebar.selectbox("Electrode Materials", ["Platinum", "Nickel", "Iridium Oxide", "Stainless Steel", "Carbon-based"])
+    
+    # Energy parameters
+    st.sidebar.subheader("Energy Parameters")
+    energy_source = st.sidebar.selectbox("Energy Source", ["Grid Electricity", "Solar", "Wind", "Nuclear", "Hydroelectric"])
+    energy_input = st.sidebar.number_input("Energy Input (kWh)", min_value=1.0, max_value=10000.0, value=100.0, step=10.0)
+    
+    # Collect user inputs
+    user_inputs = {
+        "water_source": water_source,
+        "water_cost": water_cost,
+        "water_purification_cost": water_purification_cost,
+        "water_quantity": water_quantity,
+        "production_method": production_method,
+        "current_density": current_density,
+        "voltage": voltage,
+        "membrane": membrane,
+        "electrodes": electrodes,
+        "energy_source": energy_source,
+        "energy_input": energy_input
+    }
+    
+    # Main content area
+    st.title("Hydrogen Production Analysis & Optimization")
+    st.markdown("Analyze and optimize your hydrogen production process with AI-driven recommendations")
+    
+    # Process button
+    analyze_button = st.button("Analyze Production Parameters")
+    
+    if analyze_button:
+        with st.spinner("Calculating production parameters and generating AI recommendations..."):
+            # Calculate production
+            production_data = calculate_h2_production(
+                production_method, 
+                water_quantity, 
+                energy_input, 
+                current_density, 
+                voltage
+            )
+            
+            # Calculate cost
+            cost_data = calculate_cost(
+                production_method,
+                water_cost,
+                water_purification_cost,
+                energy_source,
+                energy_input,
+                production_data
+            )
+            
+            # Get AI recommendations
+            ai_recommendations = call_groq_api(user_inputs, production_data, cost_data)
+            
+            # Display results in tabs
+            tabs = st.tabs(["Production Analysis", "Cost Analysis", "AI Recommendations", "Visualization"])
+            
+            # Tab 1: Production Analysis
+            with tabs[0]:
+                st.header("Hydrogen Production Analysis")
+                
+                # Key metrics in columns
+                col1, col2, col3 = st.columns(3)
+                with col1:
+                    st.metric("Production Rate", f"{production_data['production_rate_g_per_hour']:.2f} g/hour")
+                    st.metric("Total H₂ Produced", f"{production_data['total_production_g']:.2f} g")
+                
+                with col2:
+                    st.metric("Volume of H₂", f"{production_data['total_production_L']:.2f} L")
+                    st.metric("Operation Time", f"{production_data['operation_time_hours']:.2f} hours")
+                
+                with col3:
+                    st.metric("System Efficiency", f"{production_data['efficiency']*100:.1f}%")
+                    energy_consumption = energy_input / (production_data['total_production_g']/1000)
+                    st.metric("Energy Consumption", f"{energy_consumption:.2f} kWh/kg H₂")
+                
+                # Detailed production information
+                st.subheader("Process Details")
+                process_df = pd.DataFrame({
+                    "Parameter": ["Production Method", "Current Density", "Voltage", "Membrane", "Electrodes", 
+                                 "Water Source", "Water Quantity", "Energy Source", "Energy Input"],
+                    "Value": [production_method, f"{current_density} A/cm²", f"{voltage} V", membrane, electrodes,
+                             water_source, f"{water_quantity} L", energy_source, f"{energy_input} kWh"]
+                })
+                st.table(process_df)
+            
+            # Tab 2: Cost Analysis
+            with tabs[1]:
+                st.header("Cost Analysis")
+                
+                # Key metrics
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.metric("Total Production Cost", f"${cost_data['total_cost']:.2f}")
+                    st.metric("Cost per kg H₂", f"${cost_data['cost_per_kg']:.2f}")
+                
+                # Cost breakdown
+                st.subheader("Cost Breakdown")
+                cost_data_viz = {
+                    "Category": ["Water", "Purification", "Energy", "Operation"],
+                    "Cost ($)": [
+                        cost_data["water_cost"],
+                        cost_data["purification_cost"],
+                        cost_data["energy_cost"],
+                        cost_data["operational_cost"]
+                    ]
+                }
+                cost_df = pd.DataFrame(cost_data_viz)
+                
+                # Create cost breakdown chart
+                fig = px.pie(
+                    cost_df, 
+                    values="Cost ($)", 
+                    names="Category",
+                    title="Cost Distribution",
+                    color_discrete_sequence=px.colors.sequential.Blues_r
+                )
+                st.plotly_chart(fig, use_container_width=True)
+                
+                # Detailed cost table
+                st.subheader("Detailed Cost Breakdown")
+                detailed_cost_df = pd.DataFrame({
+                    "Cost Component": ["Water Cost", "Water Purification", "Energy Cost", "Operational Cost", "Total Cost"],
+                    "Amount ($)": [
+                        f"${cost_data['water_cost']:.2f}",
+                        f"${cost_data['purification_cost']:.2f}",
+                        f"${cost_data['energy_cost']:.2f}",
+                        f"${cost_data['operational_cost']:.2f}",
+                        f"${cost_data['total_cost']:.2f}"
+                    ],
+                    "Percentage": [
+                        f"{cost_data['water_cost']/cost_data['total_cost']*100:.1f}%",
+                        f"{cost_data['purification_cost']/cost_data['total_cost']*100:.1f}%",
+                        f"{cost_data['energy_cost']/cost_data['total_cost']*100:.1f}%",
+                        f"{cost_data['operational_cost']/cost_data['total_cost']*100:.1f}%",
+                        "100%"
+                    ]
+                })
+                st.table(detailed_cost_df)
+            
+            # Tab 3: AI Recommendations
+            with tabs[2]:
+                st.header("AI-Driven Recommendations")
+                
+                if "error" in ai_recommendations:
+                    st.error(f"Error getting AI recommendations: {ai_recommendations['error']}")
+                else:
+                    # Efficiency Assessment
+                    st.subheader("Efficiency Assessment")
+                    st.markdown(f"<div class='highlight'>{ai_recommendations['efficiency_assessment']}</div>", unsafe_allow_html=True)
+                    
+                    # Recommendations
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        st.subheader("Efficiency Recommendations")
+                        for i, rec in enumerate(ai_recommendations['efficiency_recommendations'], 1):
+                            st.markdown(f"**{i}.** {rec}")
+                    
+                    with col2:
+                        st.subheader("Cost Reduction Recommendations")
+                        for i, rec in enumerate(ai_recommendations['cost_recommendations'], 1):
+                            st.markdown(f"**{i}.** {rec}")
+                    
+                    # Ideal parameters
+                    st.subheader("Ideal Parameter Configuration")
+                    ideal_params = ai_recommendations['ideal_parameters']
+                    
+                    param_comparison = pd.DataFrame({
+                        "Parameter": ["Current Density (A/cm²)", "Voltage (V)", "Membrane", "Electrodes", "Energy Source"],
+                        "Current Value": [
+                            current_density,
+                            voltage,
+                            membrane,
+                            electrodes,
+                            energy_source
+                        ],
+                        "Recommended Value": [
+                            ideal_params['current_density'],
+                            ideal_params['voltage'],
+                            ideal_params['membrane'],
+                            ideal_params['electrodes'],
+                            ideal_params['energy_source']
+                        ]
+                    })
+                    st.table(param_comparison)
+                    
+                    # Estimated improvements
+                    st.subheader("Estimated Improvements")
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        st.metric("Efficiency Increase", ai_recommendations['estimated_improvement']['efficiency_increase'])
+                    with col2:
+                        st.metric("Cost Reduction", ai_recommendations['estimated_improvement']['cost_reduction'])
+            
+            # Tab 4: Visualization
+            with tabs[3]:
+                st.header("Production Visualization")
+                
+                # Create comparison data
+                methods = ["Alkaline Electrolysis", "PEM Electrolysis", "SOEC"]
+                production_rates = []
+                costs_per_kg = []
+                
+                for method in methods:
+                    # Calculate for each method
+                    prod_data = calculate_h2_production(
+                        method, 
+                        water_quantity, 
+                        energy_input, 
+                        current_density, 
+                        voltage
+                    )
+                    
+                    cost_result = calculate_cost(
+                        method,
+                        water_cost,
+                        water_purification_cost,
+                        energy_source,
+                        energy_input,
+                        prod_data
+                    )
+                    
+                    production_rates.append(prod_data['production_rate_g_per_hour'])
+                    costs_per_kg.append(cost_result['cost_per_kg'])
+                
+                # Create comparison charts
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    # Production rate comparison
+                    fig1 = px.bar(
+                        x=methods,
+                        y=production_rates,
+                        title="Production Rate Comparison",
+                        labels={"x": "Production Method", "y": "Production Rate (g/hour)"},
+                        color=production_rates,
+                        color_continuous_scale="Blues"
+                    )
+                    st.plotly_chart(fig1, use_container_width=True)
+                
+                with col2:
+                    # Cost comparison
+                    fig2 = px.bar(
+                        x=methods,
+                        y=costs_per_kg,
+                        title="Cost per kg Comparison",
+                        labels={"x": "Production Method", "y": "Cost ($/kg)"},
+                        color=costs_per_kg,
+                        color_continuous_scale="Reds_r"
+                    )
+                    st.plotly_chart(fig2, use_container_width=True)
+                
+                # Efficiency vs Cost scatter plot
+                efficiencies = [0.65, 0.75, 0.85]  # Method efficiencies
+                
+                fig3 = px.scatter(
+                    x=efficiencies,
+                    y=costs_per_kg,
+                    size=production_rates,
+                    text=methods,
+                    title="Efficiency vs Cost Trade-off",
+                    labels={"x": "Efficiency", "y": "Cost ($/kg)"},
+                    color=methods
+                )
+                
+                # Add a vertical line for current efficiency
+                current_efficiency = production_data['efficiency']
+                fig3.add_shape(
+                    type="line",
+                    x0=current_efficiency,
+                    y0=0,
+                    x1=current_efficiency,
+                    y1=max(costs_per_kg) * 1.1,
+                    line=dict(color="red", width=2, dash="dash")
+                )
+                
+                # Add annotation for current efficiency
+                fig3.add_annotation(
+                    x=current_efficiency,
+                    y=max(costs_per_kg) * 0.9,
+                    text="Current Efficiency",
+                    showarrow=True,
+                    arrowhead=1
+                )
+                
+                st.plotly_chart(fig3, use_container_width=True)
+                
+                # Current density vs production rate
+                current_densities = np.linspace(0.1, 2.0, 10)
+                production_results = []
+                
+                for cd in current_densities:
+                    prod_data = calculate_h2_production(
+                        production_method, 
+                        water_quantity, 
+                        energy_input, 
+                        cd, 
+                        voltage
+                    )
+                    production_results.append(prod_data['production_rate_g_per_hour'])
+                
+                fig4 = px.line(
+                    x=current_densities,
+                    y=production_results,
+                    title=f"Impact of Current Density on {production_method} Production Rate",
+                    labels={"x": "Current Density (A/cm²)", "y": "Production Rate (g/hour)"},
+                    markers=True
+                )
+                
+                # Add a vertical line for current current density
+                fig4.add_shape(
+                    type="line",
+                    x0=current_density,
+                    y0=0,
+                    x1=current_density,
+                    y1=max(production_results) * 1.1,
+                    line=dict(color="green", width=2, dash="dash")
+                )
+                
+                st.plotly_chart(fig4, use_container_width=True)
+                
+                # Add a simulation over time
+                st.subheader("Production Simulation Over Time")
+                
+                # Create time series data
+                hours = list(range(0, int(production_data['operation_time_hours']) + 1))
+                if len(hours) > 1:
+                    production_over_time = [h * production_data['production_rate_g_per_hour'] for h in hours]
+                    
+                    fig5 = px.line(
+                        x=hours,
+                        y=production_over_time,
+                        title="Cumulative Hydrogen Production Over Time",
+                        labels={"x": "Time (hours)", "y": "Cumulative Production (g)"},
+                        markers=True
+                    )
+                    st.plotly_chart(fig5, use_container_width=True)
+                else:
+                    st.info("Operation time too short for meaningful time series visualization.")
+                
+                # Export results button
+                st.download_button(
+                    label="Export Results as CSV",
+                    data=pd.DataFrame({
+                        "Parameter": ["Production Method", "Water Source", "Current Density (A/cm²)", "Voltage (V)",
+                                    "Production Rate (g/h)", "Total Production (g)", "Efficiency (%)", 
+                                    "Total Cost ($)", "Cost per kg ($/kg)"],
+                        "Value": [production_method, water_source, current_density, voltage,
+                                production_data['production_rate_g_per_hour'], production_data['total_production_g'],
+                                production_data['efficiency']*100, cost_data['total_cost'], cost_data['cost_per_kg']]
+                    }).to_csv(index=False),
+                    file_name=f"hydrogen_production_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
+                    mime="text/csv"
+                )
+
+# Run the app
+if __name__ == "__main__":
+    main()