Energy Management AI: Build Smart Grid Systems with Ollama for Real-Time Consumption Analysis

# Download and install Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# Verify installation
ollama --version

# Pull the recommended model for energy analysis
ollama pull llama2:13b

# Create project directory
mkdir energy-management-ai
cd energy-management-ai

# Install Python dependencies
pip install pandas numpy matplotlib requests json

# Set Ollama API endpoint
export OLLAMA_HOST=localhost:11434

# Configure data processing parameters
export ENERGY_SAMPLE_RATE=900  # 15-minute intervals
export MAX_DEVICES=50
export PREDICTION_WINDOW=24    # 24-hour forecasts

import requests
import json

def test_ollama_connection():
    """Test Ollama API connectivity for energy management"""
    try:
        response = requests.post('http://localhost:11434/api/generate',
                                json={
                                    'model': 'llama2:13b',
                                    'prompt': 'Analyze energy consumption data',
                                    'stream': False
                                })
        
        if response.status_code == 200:
            print("✅ Ollama connection successful")
            return True
        else:
            print(f"❌ Connection failed: {response.status_code}")
            return False
            
    except Exception as e:
        print(f"❌ Connection error: {e}")
        return False

# Run connection test
test_ollama_connection()

import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import json

class EnergyDataCollector:
    """Collect and preprocess energy consumption data"""
    
    def __init__(self, sample_rate=900):
        self.sample_rate = sample_rate  # seconds between readings
        self.devices = {}
        self.readings = []
        
    def add_device(self, device_id, device_type, rated_power):
        """Register new device for monitoring"""
        self.devices[device_id] = {
            'type': device_type,
            'rated_power': rated_power,
            'last_reading': None,
            'total_consumption': 0.0
        }
        print(f"📱 Added device: {device_id} ({device_type})")
        
    def collect_reading(self, device_id, current_power, timestamp=None):
        """Record power consumption reading"""
        if timestamp is None:
            timestamp = datetime.now()
            
        reading = {
            'device_id': device_id,
            'timestamp': timestamp,
            'power_watts': current_power,
            'cumulative_kwh': self.calculate_cumulative_consumption(device_id, current_power)
        }
        
        self.readings.append(reading)
        self.devices[device_id]['last_reading'] = reading
        
        return reading
        
    def calculate_cumulative_consumption(self, device_id, current_power):
        """Calculate total energy consumption for device"""
        if device_id not in self.devices:
            return 0.0
            
        last_reading = self.devices[device_id]['last_reading']
        if last_reading is None:
            return 0.0
            
        # Calculate time difference in hours
        time_diff = (datetime.now() - last_reading['timestamp']).seconds / 3600
        
        # Add consumption (power * time = energy)
        energy_kwh = (current_power * time_diff) / 1000
        self.devices[device_id]['total_consumption'] += energy_kwh
        
        return self.devices[device_id]['total_consumption']
        
    def get_consumption_dataframe(self):
        """Convert readings to pandas DataFrame for analysis"""
        return pd.DataFrame(self.readings)

# Initialize data collector
collector = EnergyDataCollector()

# Add sample devices
collector.add_device('hvac_001', 'HVAC System', 3500)
collector.add_device('lighting_main', 'LED Lighting', 450)
collector.add_device('server_rack', 'IT Equipment', 2200)
collector.add_device('refrigeration', 'Cooling', 800)

import requests
import json

class EnergyPatternAnalyzer:
    """Use Ollama to analyze energy consumption patterns"""
    
    def __init__(self, ollama_host='localhost:11434', model='llama2:13b'):
        self.ollama_host = ollama_host
        self.model = model
        
    def analyze_consumption_pattern(self, consumption_data):
        """Analyze energy usage patterns using AI"""
        
        # Prepare data summary for Ollama
        summary = self.prepare_data_summary(consumption_data)
        
        prompt = f"""
        Analyze this energy consumption data and identify patterns:
        
        {summary}
        
        Please identify:
        1. Peak usage times and devices
        2. Unusual consumption spikes
        3. Energy waste opportunities
        4. Optimization recommendations
        
        Provide specific, actionable insights in JSON format.
        """
        
        try:
            response = requests.post(f'http://{self.ollama_host}/api/generate',
                                   json={
                                       'model': self.model,
                                       'prompt': prompt,
                                       'stream': False
                                   })
            
            if response.status_code == 200:
                result = response.json()
                return self.parse_analysis_result(result['response'])
            else:
                print(f"❌ Analysis failed: {response.status_code}")
                return None
                
        except Exception as e:
            print(f"❌ Analysis error: {e}")
            return None
            
    def prepare_data_summary(self, consumption_data):
        """Create concise data summary for AI analysis"""
        df = consumption_data
        
        if df.empty:
            return "No consumption data available"
            
        summary = {
            'total_devices': df['device_id'].nunique(),
            'time_range': f"{df['timestamp'].min()} to {df['timestamp'].max()}",
            'peak_power': df['power_watts'].max(),
            'average_power': df['power_watts'].mean(),
            'total_energy_kwh': df['cumulative_kwh'].sum(),
            'device_breakdown': df.groupby('device_id')['power_watts'].agg(['mean', 'max']).to_dict()
        }
        
        return json.dumps(summary, indent=2, default=str)
        
    def parse_analysis_result(self, ai_response):
        """Extract structured insights from AI response"""
        try:
            # Try to extract JSON from response
            start_idx = ai_response.find('{')
            end_idx = ai_response.rfind('}') + 1
            
            if start_idx != -1 and end_idx != -1:
                json_str = ai_response[start_idx:end_idx]
                return json.loads(json_str)
            else:
                # Return raw response if JSON parsing fails
                return {'raw_analysis': ai_response}
                
        except json.JSONDecodeError:
            return {'raw_analysis': ai_response}

# Initialize pattern analyzer
analyzer = EnergyPatternAnalyzer()

import matplotlib.pyplot as plt
import matplotlib.dates as mdates
from datetime import datetime, timedelta

class EnergyMonitoringDashboard:
    """Real-time energy consumption visualization"""
    
    def __init__(self, collector, analyzer):
        self.collector = collector
        self.analyzer = analyzer
        self.fig, self.axes = plt.subplots(2, 2, figsize=(15, 10))
        self.fig.suptitle('Energy Management AI Dashboard', fontsize=16)
        
    def update_dashboard(self):
        """Refresh dashboard with latest data"""
        df = self.collector.get_consumption_dataframe()
        
        if df.empty:
            print("⚠️ No data available for dashboard")
            return
            
        # Clear previous plots
        for ax in self.axes.flat:
            ax.clear()
            
        # Plot 1: Real-time power consumption
        self.plot_realtime_consumption(df)
        
        # Plot 2: Device comparison
        self.plot_device_comparison(df)
        
        # Plot 3: Cumulative energy usage
        self.plot_cumulative_energy(df)
        
        # Plot 4: AI insights summary
        self.plot_ai_insights(df)
        
        plt.tight_layout()
        plt.pause(0.1)  # Allow plot to update
        
    def plot_realtime_consumption(self, df):
        """Plot real-time power consumption by device"""
        ax = self.axes[0, 0]
        
        for device_id in df['device_id'].unique():
            device_data = df[df['device_id'] == device_id]
            ax.plot(device_data['timestamp'], device_data['power_watts'], 
                   label=device_id, marker='o', markersize=3)
            
        ax.set_title('Real-Time Power Consumption')
        ax.set_xlabel('Time')
        ax.set_ylabel('Power (Watts)')
        ax.legend()
        ax.grid(True, alpha=0.3)
        
        # Format x-axis for better readability
        ax.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
        
    def plot_device_comparison(self, df):
        """Compare average consumption by device"""
        ax = self.axes[0, 1]
        
        device_avg = df.groupby('device_id')['power_watts'].mean()
        bars = ax.bar(device_avg.index, device_avg.values)
        
        # Color bars based on consumption level
        max_consumption = device_avg.max()
        for bar, consumption in zip(bars, device_avg.values):
            if consumption > max_consumption * 0.7:
                bar.set_color('red')
            elif consumption > max_consumption * 0.4:
                bar.set_color('orange')
            else:
                bar.set_color('green')
                
        ax.set_title('Average Power by Device')
        ax.set_xlabel('Device')
        ax.set_ylabel('Average Power (Watts)')
        ax.tick_params(axis='x', rotation=45)
        
    def plot_cumulative_energy(self, df):
        """Plot cumulative energy consumption"""
        ax = self.axes[1, 0]
        
        total_energy = df.groupby('timestamp')['cumulative_kwh'].sum()
        ax.plot(total_energy.index, total_energy.values, 
               color='blue', linewidth=2, marker='o', markersize=4)
               
        ax.set_title('Cumulative Energy Consumption')
        ax.set_xlabel('Time')
        ax.set_ylabel('Energy (kWh)')
        ax.grid(True, alpha=0.3)
        
        # Format x-axis
        ax.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
        
    def plot_ai_insights(self, df):
        """Display AI analysis insights"""
        ax = self.axes[1, 1]
        ax.axis('off')  # Turn off axis for text display
        
        # Get AI analysis
        analysis = self.analyzer.analyze_consumption_pattern(df)
        
        if analysis:
            insights_text = "🤖 AI Insights:\n\n"
            
            if 'raw_analysis' in analysis:
                # Display raw analysis if structured data unavailable
                insights_text += analysis['raw_analysis'][:300] + "..."
            else:
                # Display structured insights
                for key, value in analysis.items():
                    insights_text += f"• {key}: {value}\n"
                    
            ax.text(0.05, 0.95, insights_text, transform=ax.transAxes,
                   fontsize=10, verticalalignment='top',
                   bbox=dict(boxstyle="round,pad=0.3", facecolor="lightblue"))
        else:
            ax.text(0.5, 0.5, "AI Analysis Unavailable", 
                   transform=ax.transAxes, ha='center', va='center',
                   fontsize=12, color='red')

# Initialize dashboard
dashboard = EnergyMonitoringDashboard(collector, analyzer)

import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler
import joblib

class EnergyDemandPredictor:
    """Predict future energy demand using historical patterns"""
    
    def __init__(self, prediction_window=24):
        self.prediction_window = prediction_window  # hours
        self.model = LinearRegression()
        self.scaler = StandardScaler()
        self.is_trained = False
        
    def prepare_features(self, consumption_data):
        """Extract features for demand prediction"""
        df = consumption_data.copy()
        
        if df.empty:
            return None, None
            
        # Convert timestamp to datetime if needed
        df['timestamp'] = pd.to_datetime(df['timestamp'])
        
        # Extract time-based features
        df['hour'] = df['timestamp'].dt.hour
        df['day_of_week'] = df['timestamp'].dt.dayofweek
        df['month'] = df['timestamp'].dt.month
        
        # Calculate rolling averages
        df = df.sort_values('timestamp')
        df['power_1h_avg'] = df['power_watts'].rolling(window=4, min_periods=1).mean()
        df['power_3h_avg'] = df['power_watts'].rolling(window=12, min_periods=1).mean()
        df['power_24h_avg'] = df['power_watts'].rolling(window=96, min_periods=1).mean()
        
        # Features for model
        feature_columns = ['hour', 'day_of_week', 'month', 
                          'power_1h_avg', 'power_3h_avg', 'power_24h_avg']
        
        X = df[feature_columns].fillna(method='forward').fillna(0)
        y = df['power_watts']
        
        return X, y
        
    def train_model(self, consumption_data):
        """Train demand prediction model"""
        X, y = self.prepare_features(consumption_data)
        
        if X is None or len(X) < 10:
            print("❌ Insufficient data for training")
            return False
            
        try:
            # Scale features
            X_scaled = self.scaler.fit_transform(X)
            
            # Train model
            self.model.fit(X_scaled, y)
            self.is_trained = True
            
            # Calculate training accuracy
            train_score = self.model.score(X_scaled, y)
            print(f"✅ Model trained successfully (R² = {train_score:.3f})")
            
            return True
            
        except Exception as e:
            print(f"❌ Training failed: {e}")
            return False
            
    def predict_demand(self, hours_ahead=24):
        """Predict energy demand for specified hours ahead"""
        if not self.is_trained:
            print("❌ Model not trained yet")
            return None
            
        # Generate future time points
        current_time = datetime.now()
        future_times = [current_time + timedelta(hours=i) for i in range(1, hours_ahead + 1)]
        
        predictions = []
        
        for future_time in future_times:
            # Create feature vector for future time
            features = [
                future_time.hour,
                future_time.weekday(),
                future_time.month,
                0,  # Placeholder for power averages
                0,
                0
            ]
            
            # Scale features
            features_scaled = self.scaler.transform([features])
            
            # Make prediction
            predicted_power = self.model.predict(features_scaled)[0]
            
            predictions.append({
                'timestamp': future_time,
                'predicted_power': max(0, predicted_power)  # Ensure non-negative
            })
            
        return predictions
        
    def save_model(self, filepath):
        """Save trained model and scaler"""
        if self.is_trained:
            joblib.dump({
                'model': self.model,
                'scaler': self.scaler,
                'prediction_window': self.prediction_window
            }, filepath)
            print(f"💾 Model saved to {filepath}")
        else:
            print("❌ No trained model to save")
            
    def load_model(self, filepath):
        """Load previously trained model"""
        try:
            saved_data = joblib.load(filepath)
            self.model = saved_data['model']
            self.scaler = saved_data['scaler']
            self.prediction_window = saved_data['prediction_window']
            self.is_trained = True
            print(f"📁 Model loaded from {filepath}")
            return True
        except Exception as e:
            print(f"❌ Failed to load model: {e}")
            return False

# Initialize demand predictor
predictor = EnergyDemandPredictor()

import requests
import json
from datetime import datetime

class SmartGridController:
    """Automated energy optimization using AI predictions"""
    
    def __init__(self, predictor, analyzer, cost_per_kwh=0.12):
        self.predictor = predictor
        self.analyzer = analyzer
        self.cost_per_kwh = cost_per_kwh
        self.control_devices = {}
        self.optimization_rules = []
        
    def register_controllable_device(self, device_id, device_type, control_endpoint):
        """Register device that can be controlled automatically"""
        self.control_devices[device_id] = {
            'type': device_type,
            'endpoint': control_endpoint,
            'status': 'online',
            'last_command': None
        }
        print(f"🎛️ Registered controllable device: {device_id}")
        
    def add_optimization_rule(self, rule_name, condition, action):
        """Add automated optimization rule"""
        rule = {
            'name': rule_name,
            'condition': condition,
            'action': action,
            'enabled': True
        }
        self.optimization_rules.append(rule)
        print(f"📋 Added optimization rule: {rule_name}")
        
    def execute_optimization_cycle(self, consumption_data):
        """Run complete optimization cycle"""
        print("🔄 Starting optimization cycle...")
        
        # Step 1: Get AI analysis of current consumption
        current_analysis = self.analyzer.analyze_consumption_pattern(consumption_data)
        
        # Step 2: Get demand predictions
        demand_forecast = self.predictor.predict_demand(hours_ahead=24)
        
        # Step 3: Calculate optimization opportunities
        optimization_plan = self.calculate_optimization_plan(
            current_analysis, demand_forecast, consumption_data)
        
        # Step 4: Execute control commands
        results = self.execute_control_commands(optimization_plan)
        
        # Step 5: Log results
        self.log_optimization_results(optimization_plan, results)
        
        return optimization_plan, results
        
    def calculate_optimization_plan(self, current_analysis, demand_forecast, consumption_data):
        """Calculate optimal control actions"""
        plan = {
            'timestamp': datetime.now(),
            'actions': [],
            'estimated_savings': 0.0,
            'priority_level': 'normal'
        }
        
        if not demand_forecast:
            print("⚠️ No demand forecast available")
            return plan
            
        # Analyze predicted peak demand periods
        peak_hours = self.identify_peak_demand_hours(demand_forecast)
        current_hour = datetime.now().hour
        
        # Check if we're approaching peak demand
        if any(abs(hour - current_hour) <= 2 for hour in peak_hours):
            plan['priority_level'] = 'high'
            
            # Add load reduction actions
            plan['actions'].extend(self.generate_load_reduction_actions())
            
        # Check for overnight optimization opportunities
        if 22 <= current_hour or current_hour <= 6:
            plan['actions'].extend(self.generate_overnight_optimization_actions())
            
        # Apply custom optimization rules
        for rule in self.optimization_rules:
            if rule['enabled'] and self.evaluate_rule_condition(rule, consumption_data):
                plan['actions'].append(rule['action'])
                
        # Calculate estimated cost savings
        plan['estimated_savings'] = self.calculate_estimated_savings(plan['actions'])
        
        return plan
        
    def identify_peak_demand_hours(self, demand_forecast):
        """Identify hours with highest predicted demand"""
        if not demand_forecast:
            return []
            
        # Sort by predicted power and take top 20%
        sorted_forecast = sorted(demand_forecast, 
                               key=lambda x: x['predicted_power'], reverse=True)
        num_peak_hours = max(1, len(sorted_forecast) // 5)
        
        peak_hours = [prediction['timestamp'].hour 
                     for prediction in sorted_forecast[:num_peak_hours]]
        
        return peak_hours
        
    def generate_load_reduction_actions(self):
        """Generate actions to reduce load during peak demand"""
        actions = []
        
        # Reduce HVAC load
        actions.append({
            'device_id': 'hvac_001',
            'action': 'adjust_temperature',
            'parameters': {'target_temp': 76, 'reason': 'peak_demand_reduction'}
        })
        
        # Dim non-essential lighting
        actions.append({
            'device_id': 'lighting_main',
            'action': 'dim_lights',
            'parameters': {'brightness_percent': 70, 'reason': 'peak_demand_reduction'}
        })
        
        # Defer non-critical equipment
        actions.append({
            'device_id': 'server_rack',
            'action': 'enable_power_save',
            'parameters': {'mode': 'aggressive', 'reason': 'peak_demand_reduction'}
        })
        
        return actions
        
    def generate_overnight_optimization_actions(self):
        """Generate actions for overnight energy optimization"""
        actions = []
        
        # Pre-cool buildings for next day
        actions.append({
            'device_id': 'hvac_001',
            'action': 'precool',
            'parameters': {'target_temp': 72, 'duration_hours': 4}
        })
        
        # Charge battery systems during off-peak rates
        actions.append({
            'device_id': 'battery_system',
            'action': 'charge',
            'parameters': {'target_soc': 90, 'rate': 'slow'}
        })
        
        return actions
        
    def execute_control_commands(self, optimization_plan):
        """Send control commands to devices"""
        results = []
        
        for action in optimization_plan['actions']:
            device_id = action['device_id']
            
            if device_id not in self.control_devices:
                results.append({
                    'device_id': device_id,
                    'status': 'failed',
                    'error': 'Device not registered'
                })
                continue
                
            try:
                # Send command to device
                success = self.send_device_command(device_id, action)
                
                results.append({
                    'device_id': device_id,
                    'action': action['action'],
                    'status': 'success' if success else 'failed',
                    'timestamp': datetime.now()
                })
                
            except Exception as e:
                results.append({
                    'device_id': device_id,
                    'status': 'failed',
                    'error': str(e)
                })
                
        return results
        
    def send_device_command(self, device_id, action):
        """Send command to individual device"""
        device = self.control_devices[device_id]
        endpoint = device['endpoint']
        
        # Simulate device control (replace with actual API calls)
        print(f"📡 Sending command to {device_id}: {action['action']}")
        
        # In real implementation, send HTTP request to device endpoint
        # response = requests.post(endpoint, json=action)
        # return response.status_code == 200
        
        # Simulate successful command for demo
        return True
        
    def calculate_estimated_savings(self, actions):
        """Calculate estimated cost savings from optimization actions"""
        total_savings = 0.0
        
        for action in actions:
            # Estimate power reduction for each action type
            if action['action'] == 'adjust_temperature':
                estimated_reduction_kw = 2.5  # Typical HVAC reduction
            elif action['action'] == 'dim_lights':
                estimated_reduction_kw = 0.5  # Lighting reduction
            elif action['action'] == 'enable_power_save':
                estimated_reduction_kw = 1.2  # Server power save
            else:
                estimated_reduction_kw = 0.0
                
            # Calculate daily savings (assuming 8-hour effectiveness)
            daily_savings = estimated_reduction_kw * 8 * self.cost_per_kwh
            total_savings += daily_savings
            
        return total_savings
        
    def log_optimization_results(self, optimization_plan, results):
        """Log optimization cycle results"""
        success_count = sum(1 for r in results if r['status'] == 'success')
        total_actions = len(results)
        
        print(f"✅ Optimization cycle complete:")
        print(f"   • Actions executed: {success_count}/{total_actions}")
        print(f"   • Estimated daily savings: ${optimization_plan['estimated_savings']:.2f}")
        print(f"   • Priority level: {optimization_plan['priority_level']}")

# Initialize smart grid controller
controller = SmartGridController(predictor, analyzer)

# Register sample controllable devices
controller.register_controllable_device('hvac_001', 'HVAC', 'http://192.168.1.100/api/control')
controller.register_controllable_device('lighting_main', 'Lighting', 'http://192.168.1.101/api/control')
controller.register_controllable_device('server_rack', 'IT', 'http://192.168.1.102/api/control')

# Add optimization rules
controller.add_optimization_rule(
    'High Consumption Alert',
    lambda data: data['power_watts'].mean() > 5000,
    {'device_id': 'hvac_001', 'action': 'reduce_load', 'parameters': {'reduction_percent': 15}}
)

import time
import threading
from datetime import datetime, timedelta
import random

class EnergyManagementAI:
    """Complete energy management AI system"""
    
    def __init__(self):
        self.collector = EnergyDataCollector()
        self.analyzer = EnergyPatternAnalyzer()
        self.predictor = EnergyDemandPredictor()
        self.controller = SmartGridController(self.predictor, self.analyzer)
        self.dashboard = EnergyMonitoringDashboard(self.collector, self.analyzer)
        
        self.running = False
        self.monitoring_thread = None
        self.optimization_thread = None
        
    def setup_system(self):
        """Initialize complete energy management system"""
        print("🚀 Setting up Energy Management AI System...")
        
        # Setup devices
        self.setup_monitoring_devices()
        self.setup_controllable_devices()
        
        # Load or create prediction model
        self.initialize_prediction_model()
        
        print("✅ Energy Management AI System ready!")
        
    def setup_monitoring_devices(self):
        """Register all devices for monitoring"""
        devices = [
            ('hvac_001', 'HVAC System', 3500),
            ('lighting_main', 'LED Lighting', 450),
            ('lighting_emergency', 'Emergency Lighting', 120),
            ('server_rack_001', 'Primary Servers', 2200),
            ('server_rack_002', 'Backup Servers', 1800),
            ('refrigeration_001', 'Main Cooling', 800),
            ('refrigeration_002', 'Backup Cooling', 600),
            ('elevators', 'Elevator Systems', 1200),
            ('security_systems', 'Security & Cameras', 300),
            ('misc_office', 'Office Equipment', 400)
        ]
        
        for device_id, device_type, rated_power in devices:
            self.collector.add_device(device_id, device_type, rated_power)
            
    def setup_controllable_devices(self):
        """Register devices that can be controlled automatically"""
        controllable_devices = [
            ('hvac_001', 'HVAC', 'http://192.168.1.100/api/control'),
            ('lighting_main', 'Lighting', 'http://192.168.1.101/api/control'),
            ('server_rack_002', 'IT', 'http://192.168.1.102/api/control')
        ]
        
        for device_id, device_type, endpoint in controllable_devices:
            self.controller.register_controllable_device(device_id, device_type, endpoint)
            
    def initialize_prediction_model(self):
        """Setup demand prediction model"""
        model_path = 'energy_prediction_model.joblib'
        
        # Try to load existing model
        if not self.predictor.load_model(model_path):
            print("📊 Training new prediction model...")
            
            # Generate sample historical data for training
            sample_data = self.generate_sample_historical_data()
            
            if self.predictor.train_model(sample_data):
                self.predictor.save_model(model_path)
            else:
                print("⚠️ Prediction model training failed")
                
    def generate_sample_historical_data(self):
        """Generate sample data for model training (replace with real data)"""
        print("📈 Generating sample historical data...")
        
        # Create 30 days of sample readings
        start_date = datetime.now() - timedelta(days=30)
        sample_readings = []
        
        for day in range(30):
            for hour in range(24):
                for quarter in range(4):  # 15-minute intervals
                    timestamp = start_date + timedelta(days=day, hours=hour, minutes=quarter*15)
                    
                    # Simulate realistic consumption patterns
                    base_consumption = self.simulate_consumption_pattern(hour, day % 7)
                    
                    for device_id in self.collector.devices.keys():
                        # Add device-specific variation
                        device_power = base_consumption * self.get_device_factor(device_id, hour)
                        
                        self.collector.collect_reading(device_id, device_power, timestamp)
                        
        return self.collector.get_consumption_dataframe()
        
    def simulate_consumption_pattern(self, hour, day_of_week):
        """Simulate realistic consumption patterns"""
        # Business hours pattern
        if 8 <= hour <= 18 and day_of_week < 5:  # Weekday business hours
            base_load = 8000 + random.randint(-500, 500)
        elif 19 <= hour <= 22:  # Evening
            base_load = 6000 + random.randint(-300, 300)
        else:  # Night/early morning
            base_load = 3000 + random.randint(-200, 200)
            
        # Add seasonal variation (higher in summer/winter)
        seasonal_factor = 1.2 if datetime.now().month in [6, 7, 8, 12, 1, 2] else 1.0
        
        return int(base_load * seasonal_factor)
        
    def get_device_factor(self, device_id, hour):
        """Get device-specific consumption factor"""
        factors = {
            'hvac_001': 0.4 if 22 <= hour or hour <= 6 else 0.6,
            'lighting_main': 0.1 if 22 <= hour or hour <= 6 else 0.3,
            'server_rack_001': 0.25,  # Constant load
            'server_rack_002': 0.2,   # Slightly lower
            'refrigeration_001': 0.1,  # Constant refrigeration
            'elevators': 0.05 if 22 <= hour or hour <= 6 else 0.15,
            'security_systems': 0.03,  # Constant
            'misc_office': 0.02 if 22 <= hour or hour <= 6 else 0.08
        }
        
        return factors.get(device_id, 0.1)
        
    def start_monitoring(self):
        """Start continuous monitoring and optimization"""
        if self.running:
            print("⚠️ System already running")
            return
            
        self.running = True
        
        # Start monitoring thread
        self.monitoring_thread = threading.Thread(target=self.monitoring_loop)
        self.monitoring_thread.daemon = True
        self.monitoring_thread.start()
        
        # Start optimization thread
        self.optimization_thread = threading.Thread(target=self.optimization_loop)
        self.optimization_thread.daemon = True
        self.optimization_thread.start()
        
        print("🔄 Energy monitoring and optimization started")
        
    def stop_monitoring(self):
        """Stop monitoring system"""
        self.running = False
        print("🛑 Energy monitoring stopped")
        
    def monitoring_loop(self):
        """Continuous monitoring loop"""
        while self.running:
            try:
                # Collect readings from all devices
                current_time = datetime.now()
                
                for device_id in self.collector.devices.keys():
                    # Simulate real device reading (replace with actual sensor data)
                    simulated_power = self.simulate_device_reading(device_id)
                    self.collector.collect_reading(device_id, simulated_power, current_time)
                    
                # Update dashboard every minute
                if current_time.second == 0:
                    self.dashboard.update_dashboard()
                    
                time.sleep(60)  # Wait 1 minute between readings
                
            except Exception as e:
                print(f"❌ Monitoring error: {e}")
                time.sleep(5)
                
    def optimization_loop(self):
        """Continuous optimization loop"""
        while self.running:
            try:
                # Run optimization every 15 minutes
                consumption_data = self.collector.get_consumption_dataframe()
                
                if not consumption_data.empty:
                    plan, results = self.controller.execute_optimization_cycle(consumption_data)
                    
                time.sleep(900)  # Wait 15 minutes
                
            except Exception as e:
                print(f"❌ Optimization error: {e}")
                time.sleep(60)
                
    def simulate_device_reading(self, device_id):
        """Simulate device power reading (replace with actual sensor integration)"""
        current_hour = datetime.now().hour
        base_power = self.collector.devices[device_id]['rated_power']
        utilization_factor = self.get_device_factor(device_id, current_hour)
        
        # Add realistic variation
        variation = random.uniform(0.8, 1.2)
        
        return int(base_power * utilization_factor * variation)
        
    def generate_daily_report(self):
        """Generate comprehensive daily energy report"""
        df = self.collector.get_consumption_dataframe()
        
        if df.empty:
            print("❌ No data available for report")
            return
            
        # Calculate daily statistics
        today = datetime.now().date()
        today_data = df[df['timestamp'].dt.date == today]
        
        if today_data.empty:
            print("❌ No data available for today")
            return
            
        report = {
            'date': today,
            'total_energy_kwh': today_data['cumulative_kwh'].sum(),
            'peak_demand_kw': today_data['power_watts'].max() / 1000,
            'average_demand_kw': today_data['power_watts'].mean() / 1000,
            'cost_estimate': today_data['cumulative_kwh'].sum() * 0.12,
            'top_consumers': today_data.groupby('device_id')['cumulative_kwh'].sum().nlargest(5),
            'efficiency_score': self.calculate_efficiency_score(today_data)
        }
        
        print("\n" + "="*50)
        print(f"📊 DAILY ENERGY REPORT - {report['date']}")
        print("="*50)
        print(f"Total Energy Consumption: {report['total_energy_kwh']:.2f} kWh")
        print(f"Peak Demand: {report['peak_demand_kw']:.2f} kW")
        print(f"Average Demand: {report['average_demand_kw']:.2f} kW")
        print(f"Estimated Cost: ${report['cost_estimate']:.2f}")
        print(f"Efficiency Score: {report['efficiency_score']:.1f}/100")
        print("\nTop Energy Consumers:")
        for device, consumption in report['top_consumers'].items():
            print(f"  • {device}: {consumption:.2f} kWh")
        print("="*50)
        
        return report
        
    def calculate_efficiency_score(self, consumption_data):
        """Calculate energy efficiency score (0-100)"""
        # Simple efficiency calculation based on consumption patterns
        df = consumption_data
        
        if df.empty:
            return 0
            
        # Factors for efficiency calculation
        peak_hours = df[(df['timestamp'].dt.hour >= 9) & (df['timestamp'].dt.hour <= 17)]
        off_peak_hours = df[(df['timestamp'].dt.hour <= 6) | (df['timestamp'].dt.hour >= 22)]
        
        if peak_hours.empty or off_peak_hours.empty:
            return 50  # Default score
            
        # Calculate load factor (efficiency indicator)
        avg_demand = df['power_watts'].mean()
        peak_demand = df['power_watts'].max()
        
        if peak_demand == 0:
            return 0
            
        load_factor = avg_demand / peak_demand
        
        # Calculate peak vs off-peak ratio
        peak_avg = peak_hours['power_watts'].mean()
        off_peak_avg = off_peak_hours['power_watts'].mean()
        
        if off_peak_avg == 0:
            peak_ratio_score = 50
        else:
            peak_ratio = peak_avg / off_peak_avg
            peak_ratio_score = max(0, 100 - (peak_ratio - 1) * 20)
            
        # Combined efficiency score
        efficiency_score = (load_factor * 50) + (peak_ratio_score * 0.5)
        
        return min(100, max(0, efficiency_score))

# Initialize and run the complete system
def main():
    """Main function to run Energy Management AI system"""
    print("🌟 Energy Management AI System Starting...")
    
    # Initialize system
    energy_ai = EnergyManagementAI()
    energy_ai.setup_system()
    
    # Start monitoring
    energy_ai.start_monitoring()
    
    try:
        # Run for demonstration (replace with continuous operation)
        print("⏱️ Running system for 5 minutes (demo mode)...")
        time.sleep(300)  # Run for 5 minutes
        
        # Generate report
        energy_ai.generate_daily_report()
        
    except KeyboardInterrupt:
        print("\n🛑 Shutting down system...")
    finally:
        energy_ai.stop_monitoring()
        
    print("✅ Energy Management AI System stopped")

if __name__ == "__main__":
    main()

# Dockerfile for Energy Management AI
FROM python:3.9-slim

WORKDIR /app

# Install system dependencies
RUN apt-get update && apt-get install -y \
    curl \
    build-essential \
    && rm -rf /var/lib/apt/lists/*

# Install Ollama
RUN curl -fsSL https://ollama.ai/install.sh | sh

# Copy requirements and install Python dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application code
COPY . .

# Expose ports
EXPOSE 8080 11434

# Start script
CMD ["python", "energy_management_main.py"]

# docker-compose.yml
version: '3.8'

services:
  energy-ai:
    build: .
    ports:
      - "8080:8080"
      - "11434:11434"
    volumes:
      - energy_data:/app/data
      - ./models:/app/models
    environment:
      - OLLAMA_HOST=localhost:11434
      - DATABASE_URL=postgresql://user:pass@postgres:5432/energy_db
    depends_on:
      - postgres
      - redis
    
  postgres:
    image: postgres:13
    environment:
      - POSTGRES_DB=energy_db
      - POSTGRES_USER=energy_user
      - POSTGRES_PASSWORD=secure_password
    volumes:
      - postgres_data:/var/lib/postgresql/data
      
  redis:
    image: redis:6-alpine
    volumes:
      - redis_data:/data

volumes:
  energy_data:
  postgres_data:
  redis_data:

def calculate_energy_management_roi(implementation_cost, monthly_savings, 
                                  system_lifetime_years=10):
    """Calculate ROI for energy management AI system"""
    
    annual_savings = monthly_savings * 12
    total_lifetime_savings = annual_savings * system_lifetime_years
    
    roi_percentage = ((total_lifetime_savings - implementation_cost) / 
                     implementation_cost) * 100
    
    payback_period_months = implementation_cost / monthly_savings
    
    return {
        'roi_percentage': roi_percentage,
        'payback_period_months': payback_period_months,
        'annual_savings': annual_savings,
        'total_lifetime_savings': total_lifetime_savings
    }

# Example ROI calculation
implementation_cost = 50000  # $50,000 system cost
monthly_savings = 2500       # $2,500 monthly savings

roi_results = calculate_energy_management_roi(implementation_cost, monthly_savings)
print(f"ROI: {roi_results['roi_percentage']:.1f}%")
print(f"Payback Period: {roi_results['payback_period_months']:.1f} months")