Update scripts/summary.py

scripts/summary.py

@@ -1,7 +1,9 @@
 import os
 import pandas as pd
-from typing import Dict
+import numpy as np
+from typing import Dict, Optional, Tuple
 from pathlib import Path
+from datetime import datetime, timedelta
 
 # Prefer HF router via OpenAI-compatible client. Use env `HF_TOKEN`.
 # HF_TOKEN loaded lazily to allow dotenv loading after import
@@ -34,9 +36,252 @@ def openai_summary(text: str, verbosity: str = 'brief', model: str = 'meta-llama
     except Exception:
         return None
 
+def calculate_outage_duration(outage_time: pd.Series, restore_time: pd.Series) -> pd.Series:
+    """Calculate outage duration in minutes."""
+    try:
+        outage_dt = pd.to_datetime(outage_time, dayfirst=True, errors='coerce')
+        restore_dt = pd.to_datetime(restore_time, dayfirst=True, errors='coerce')
+        
+        # Calculate duration in minutes
+        duration = (restore_dt - outage_dt).dt.total_seconds() / 60
+        return duration.fillna(0)
+    except:
+        return pd.Series([0] * len(outage_time))
+
+def calculate_reliability_indices(df: pd.DataFrame, total_customers: float) -> Dict:
+    """
+    Calculate power system reliability indices with proper formulas.
+    
+    Formulas:
+    - SAIFI = Σ(Ni) / NT
+    - SAIDI = Σ(Ni × Ti) / NT  
+    - CAIDI = SAIDI / SAIFI = Σ(Ni × Ti) / Σ(Ni)
+    - MAIFI = Σ(Ni_momentary) / NT
+    - ASAI = (NT × T - Σ(Ni × Ti)) / (NT × T)
+    - ASUI = Σ(Ni × Ti) / (NT × T)
+    
+    Where:
+    - Ni = Number of customers affected by interruption i
+    - Ti = Duration of interruption i (minutes)
+    - NT = Total number of customers served
+    - T = Time period (typically 1 year = 525,600 minutes)
+    """
+    
+    # Parse datetime columns
+    df_calc = df.copy()
+    
+    # Calculate outage duration
+    if 'OutageDateTime' in df_calc.columns and ('FirstRestoDateTime' in df_calc.columns or 'LastRestoDateTime' in df_calc.columns):
+        restore_col = 'LastRestoDateTime' if 'LastRestoDateTime' in df_calc.columns else 'FirstRestoDateTime'
+        df_calc['Duration_Minutes'] = calculate_outage_duration(df_calc['OutageDateTime'], df_calc[restore_col])
+    else:
+        df_calc['Duration_Minutes'] = 0
+    
+    # Handle affected customers
+    if 'AffectedCustomer' in df_calc.columns:
+        df_calc['Customers_Affected'] = pd.to_numeric(df_calc['AffectedCustomer'], errors='coerce').fillna(0)
+    else:
+        df_calc['Customers_Affected'] = 0
+    
+    # Filter out invalid data
+    valid_data = df_calc[
+        (df_calc['Duration_Minutes'] >= 0) & 
+        (df_calc['Customers_Affected'] >= 0) &
+        (~pd.isna(df_calc['Duration_Minutes'])) &
+        (~pd.isna(df_calc['Customers_Affected']))
+    ].copy()
+    
+    # Separate planned and unplanned outages
+    if 'EventType' in valid_data.columns:
+        # Assume planned outages contain keywords like "planned", "maintenance", "scheduled"
+        planned_keywords = ['plan', 'maintenance', 'scheduled', 'แผน', 'บำรุงรักษา']
+        planned_mask = valid_data['EventType'].str.contains('|'.join(planned_keywords), case=False, na=False)
+        unplanned_data = valid_data[~planned_mask].copy()
+        planned_data = valid_data[planned_mask].copy()
+    else:
+        unplanned_data = valid_data.copy()
+        planned_data = pd.DataFrame()
+    
+    # Calculate customer-minutes for unplanned outages
+    unplanned_data['Customer_Minutes'] = unplanned_data['Customers_Affected'] * unplanned_data['Duration_Minutes']
+    
+    # Identify momentary interruptions (< 5 minutes)
+    momentary_data = unplanned_data[unplanned_data['Duration_Minutes'] < 5].copy()
+    sustained_data = unplanned_data[unplanned_data['Duration_Minutes'] >= 5].copy()
+    
+    # Calculate indices
+    total_interruptions = len(unplanned_data)
+    total_customer_interruptions = unplanned_data['Customers_Affected'].sum()
+    total_customer_minutes = unplanned_data['Customer_Minutes'].sum()
+    
+    # Momentary interruptions
+    momentary_customer_interruptions = momentary_data['Customers_Affected'].sum()
+    
+    # Time period (assume 1 year = 525,600 minutes)
+    time_period_minutes = 525600
+    
+    # Calculate SAIFI (System Average Interruption Frequency Index)
+    # SAIFI = Σ(Customer Interruptions) / Total Customers
+    saifi = total_customer_interruptions / total_customers if total_customers > 0 else 0
+    
+    # Calculate SAIDI (System Average Interruption Duration Index)  
+    # SAIDI = Σ(Customer Minutes) / Total Customers
+    saidi = total_customer_minutes / total_customers if total_customers > 0 else 0
+    
+    # Calculate CAIDI (Customer Average Interruption Duration Index)
+    # CAIDI = SAIDI / SAIFI = Σ(Customer Minutes) / Σ(Customer Interruptions)
+    caidi = total_customer_minutes / total_customer_interruptions if total_customer_interruptions > 0 else 0
+    
+    # Calculate MAIFI (Momentary Average Interruption Frequency Index)
+    # MAIFI = Σ(Momentary Customer Interruptions) / Total Customers
+    maifi = momentary_customer_interruptions / total_customers if total_customers > 0 else 0
+    
+    # Calculate ASAI (Average System Availability Index)
+    # ASAI = (Total Customer Hours - Customer Hours of Interruption) / Total Customer Hours
+    total_customer_hours = total_customers * time_period_minutes / 60
+    customer_hours_interrupted = total_customer_minutes / 60
+    asai = (total_customer_hours - customer_hours_interrupted) / total_customer_hours if total_customer_hours > 0 else 0
+    asai_percent = asai * 100
+    
+    # Calculate ASUI (Average System Unavailability Index)
+    # ASUI = Customer Hours of Interruption / Total Customer Hours
+    asui = customer_hours_interrupted / total_customer_hours if total_customer_hours > 0 else 0
+    asui_percent = asui * 100
+    
+    # Additional metrics
+    avg_outage_duration = unplanned_data['Duration_Minutes'].mean() if len(unplanned_data) > 0 else 0
+    max_outage_duration = unplanned_data['Duration_Minutes'].max() if len(unplanned_data) > 0 else 0
+    avg_customers_per_outage = unplanned_data['Customers_Affected'].mean() if len(unplanned_data) > 0 else 0
+    max_customers_affected = unplanned_data['Customers_Affected'].max() if len(unplanned_data) > 0 else 0
+    
+    # Calculate ENS (Energy Not Served) - approximate
+    # Assuming average load per customer (can be adjusted)
+    avg_load_per_customer_kw = 2.0  # Typical residential load
+    ens_kwh = (total_customer_minutes / 60) * avg_load_per_customer_kw
+    
+    return {
+        'SAIFI': saifi,
+        'SAIDI': saidi, 
+        'CAIDI': caidi,
+        'MAIFI': maifi,
+        'ASAI': asai_percent,
+        'ASUI': asui_percent,
+        'ENS_kWh': ens_kwh,
+        'Total_Interruptions': total_interruptions,
+        'Total_Customer_Interruptions': int(total_customer_interruptions),
+        'Total_Customer_Minutes': total_customer_minutes,
+        'Momentary_Interruptions': len(momentary_data),
+        'Sustained_Interruptions': len(sustained_data),
+        'Avg_Outage_Duration': avg_outage_duration,
+        'Max_Outage_Duration': max_outage_duration,
+        'Avg_Customers_Per_Outage': avg_customers_per_outage,
+        'Max_Customers_Affected': int(max_customers_affected),
+        'Planned_Outages': len(planned_data) if not planned_data.empty else 0
+    }
+
+def create_reliability_dataframe(metrics: Dict) -> pd.DataFrame:
+    """Create a formatted DataFrame for reliability metrics."""
+    reliability_data = [
+        {
+            'Metric': 'SAIFI',
+            'Full Name': 'System Average Interruption Frequency Index',
+            'Formula': 'Σ(Ni) / NT',
+            'Value': f"{metrics.get('SAIFI', 0):.4f}",
+            'Unit': 'ครั้ง/ลูกค้า/ปี',
+            'Description': 'ความถี่เฉลี่ยของการขัดข้องต่อลูกค้าต่อปี',
+            'Benchmark': '< 1.5 (ดีมาก), 1.5-3.0 (ดี), > 3.0 (ต้องปรับปรุง)'
+        },
+        {
+            'Metric': 'SAIDI',
+            'Full Name': 'System Average Interruption Duration Index',
+            'Formula': 'Σ(Ni × Ti) / NT',
+            'Value': f"{metrics.get('SAIDI', 0):.2f}",
+            'Unit': 'นาที/ลูกค้า/ปี',
+            'Description': 'ระยะเวลาขัดข้องเฉลี่ยต่อลูกค้าต่อปี',
+            'Benchmark': '< 100 (ดีมาก), 100-300 (ดี), > 300 (ต้องปรับปรุง)'
+        },
+        {
+            'Metric': 'CAIDI',
+            'Full Name': 'Customer Average Interruption Duration Index',
+            'Formula': 'SAIDI / SAIFI',
+            'Value': f"{metrics.get('CAIDI', 0):.2f}",
+            'Unit': 'นาที/ครั้ง',
+            'Description': 'ระยะเวลาขัดข้องเฉลี่ยต่อครั้งที่เกิดขึ้น',
+            'Benchmark': '< 120 (ดี), 120-240 (ปานกลาง), > 240 (ต้องปรับปรุง)'
+        },
+        {
+            'Metric': 'MAIFI',
+            'Full Name': 'Momentary Average Interruption Frequency Index',
+            'Formula': 'Σ(Ni_momentary) / NT',
+            'Value': f"{metrics.get('MAIFI', 0):.4f}",
+            'Unit': 'ครั้ง/ลูกค้า/ปี',
+            'Description': 'ความถี่เฉลี่ยของการขัดข้องชั่วคราว (<5 นาที)',
+            'Benchmark': '< 5 (ดี), 5-10 (ปานกลาง), > 10 (ต้องปรับปรุง)'
+        },
+        {
+            'Metric': 'ASAI',
+            'Full Name': 'Average System Availability Index',
+            'Formula': '(NT×T - Σ(Ni×Ti)) / (NT×T) × 100',
+            'Value': f"{metrics.get('ASAI', 0):.4f}",
+            'Unit': '%',
+            'Description': 'ดัชนีความพร้อมใช้งานเฉลี่ยของระบบ',
+            'Benchmark': '> 99.95% (ดีมาก), 99.9-99.95% (ดี), < 99.9% (ต้องปรับปรุง)'
+        },
+        {
+            'Metric': 'ASUI',
+            'Full Name': 'Average System Unavailability Index',
+            'Formula': 'Σ(Ni×Ti) / (NT×T) × 100',
+            'Value': f"{metrics.get('ASUI', 0):.4f}",
+            'Unit': '%',
+            'Description': 'ดัชนีความไม่พร้อมใช้งานเฉลี่ยของระบบ',
+            'Benchmark': '< 0.05% (ดีมาก), 0.05-0.1% (ดี), > 0.1% (ต้องปรับปรุง)'
+        },
+        {
+            'Metric': 'ENS',
+            'Full Name': 'Energy Not Served',
+            'Formula': 'Σ(Ni×Ti×Load_avg) / 60',
+            'Value': f"{metrics.get('ENS_kWh', 0):.0f}",
+            'Unit': 'kWh',
+            'Description': 'พลังงานที่ไม่สามารถจ่ายให้ลูกค้าได้',
+            'Benchmark': 'ยิ่งน้อยยิ่งดี (ขึ้นกับพื้นที่และประเภทลูกค้า)'
+        }
+    ]
+    
+    return pd.DataFrame(reliability_data)
+
+def generate_performance_summary(metrics: Dict, total_customers: float) -> str:
+    """Generate performance summary with benchmarking."""
+    saifi = metrics.get('SAIFI', 0)
+    saidi = metrics.get('SAIDI', 0)
+    asai = metrics.get('ASAI', 0)
+    
+    # Performance assessment
+    performance_level = "ดี"
+    if saifi > 3.0 or saidi > 300 or asai < 99.9:
+        performance_level = "ต้องปรับปรุง"
+    elif saifi < 1.5 and saidi < 100 and asai > 99.95:
+        performance_level = "ดีมาก"
+    
+    summary = f"""
+การประเมินประสิทธิภาพระบบไฟฟ้า: {performance_level}
+
+ดัชนีความน่าเชื่อถือหลัก:
+• SAIFI: {saifi:.4f} ครั้ง/ลูกค้า/ปี (เป้าหมาย < 1.5)
+• SAIDI: {saidi:.2f} นาที/ลูกค้า/ปี (เป้าหมาย < 100)
+• ความพร้อมใช้งาน (ASAI): {asai:.4f}% (เป้าหมาย > 99.95%)
+
+สถิติเหตุการณ์:
+• เหตุการณ์ขัดข้องทั้งหมด: {metrics.get('Total_Interruptions', 0):,} ครั้ง
+• ลูกค้าที่ได้รับผลกระทบ: {metrics.get('Total_Customer_Interruptions', 0):,} ครั้ง
+• เวลาขัดข้องเฉลี่ย: {metrics.get('Avg_Outage_Duration', 0):.1f} นาที
+• เวลาขัดข้องสูงสุด: {metrics.get('Max_Outage_Duration', 0):.1f} นาที
+"""
+    
+    return summary.strip()
 
 def summarize_overall(df: pd.DataFrame, use_hf: bool = False, model: str = 'meta-llama/Llama-3.1-8B-Instruct:novita', total_customers: float = None) -> Dict:
-    """Summarize overall outage data with GenAI and reliability metrics."""
+    """Summarize overall outage data with enhanced GenAI and reliability metrics."""
+    
     # Basic statistics
     total_events = len(df)
     date_cols = ['OutageDateTime', 'FirstRestoDateTime', 'LastRestoDateTime', 'CreateEventDateTime', 'CloseEventDateTime']
@@ -49,7 +294,7 @@ def summarize_overall(df: pd.DataFrame, use_hf: bool = False, model: str = 'meta
 
     # Calculate basic metrics
     if 'OutageDateTime' in df_copy.columns:
-        date_range = f"{df_copy['OutageDateTime'].min()} ถึง {df_copy['OutageDateTime'].max()}" if pd.notna(df_copy['OutageDateTime'].min()) else "ไม่ระบุ"
+        date_range = f"{df_copy['OutageDateTime'].min().strftime('%d/%m/%Y')} ถึง {df_copy['OutageDateTime'].max().strftime('%d/%m/%Y')}" if pd.notna(df_copy['OutageDateTime'].min()) else "ไม่ระบุ"
     else:
         date_range = "ไม่ระบุ"
 
@@ -61,99 +306,63 @@ def summarize_overall(df: pd.DataFrame, use_hf: bool = False, model: str = 'meta
     if 'AffectedCustomer' in df_copy.columns:
         total_affected = pd.to_numeric(df_copy['AffectedCustomer'], errors='coerce').sum()
 
-    # Create summary text for GenAI
-    summary_text = f"""
-ข้อมูลไฟฟ้าล้มทั้งหมด:
-- จำนวนเหตุการณ์ทั้งหมด: {total_events}
-- ช่วงเวลาที่เกิดเหตุการณ์: {date_range}
-- ประเภทเหตุการณ์หลัก: {', '.join([f'{k}: {v}' for k, v in event_types.items()])}
-- จำนวนลูกค้าที่ได้รับผลกระทบทั้งหมด: {int(total_affected) if not pd.isna(total_affected) else 'ไม่ระบุ'}
-"""
-
-    # Reliability metrics DataFrame
+    # Calculate reliability metrics if total_customers is provided
+    reliability_metrics = {}
     reliability_df = pd.DataFrame()
     reliability_summary = ""
-
+    performance_summary = ""
+    
     if total_customers and total_customers > 0:
         try:
-            from scripts.compute_reliability import compute_reliability
-            import tempfile
-            import os
-
-            # Save df to temp CSV for compute_reliability
-            with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False) as f:
-                df_copy.to_csv(f.name, index=False)
-                temp_path = f.name
-
-            try:
-                reliability_results = compute_reliability(temp_path, total_customers=total_customers, exclude_planned=True)
-                overall_metrics = reliability_results.get('overall', pd.DataFrame())
-                if not overall_metrics.empty:
-                    row = overall_metrics.iloc[0]
-
-                    # Create reliability DataFrame with proper metric names
-                    reliability_data = [
-                        {
-                            'Metric': 'SAIFI',
-                            'Full Name': 'System Average Interruption Frequency Index',
-                            'Value': f"{row.get('SAIFI', 'N/A'):.4f}",
-                            'Unit': 'ครั้ง/ลูกค้า',
-                            'Description': 'ความถี่เฉลี่ยของการขัดข้องต่อลูกค้า'
-                        },
-                        {
-                            'Metric': 'SAIDI',
-                            'Full Name': 'System Average Interruption Duration Index',
-                            'Value': f"{row.get('SAIDI', 'N/A'):.2f}",
-                            'Unit': 'นาที/ลูกค้า',
-                            'Description': 'ระยะเวลาขัดข้องเฉลี่ยต่อลูกค้า'
-                        },
-                        {
-                            'Metric': 'CAIDI',
-                            'Full Name': 'Customer Average Interruption Duration Index',
-                            'Value': f"{row.get('CAIDI', 'N/A'):.2f}",
-                            'Unit': 'นาที/ครั้ง',
-                            'Description': 'ระยะเวลาขัดข้องเฉลี่ยต่อครั้ง'
-                        },
-                        {
-                            'Metric': 'MAIFI',
-                            'Full Name': 'Momentary Average Interruption Frequency Index',
-                            'Value': f"{row.get('MAIFI', 'N/A'):.4f}",
-                            'Unit': 'ครั้ง/ลูกค้า',
-                            'Description': 'ความถี่เฉลี่ยของการขัดข้องชั่วคราวต่อลูกค้า'
-                        }
-                    ]
-                    reliability_df = pd.DataFrame(reliability_data)
-
-                    reliability_summary = f"""
-ดัชนีความน่าเชื่อถือ:
-- SAIFI (System Average Interruption Frequency Index): {row.get('SAIFI', 'N/A'):.4f} ครั้ง/ลูกค้า
-- SAIDI (System Average Interruption Duration Index): {row.get('SAIDI', 'N/A'):.2f} นาที/ลูกค้า
-- CAIDI (Customer Average Interruption Duration Index): {row.get('CAIDI', 'N/A'):.2f} นาที/ครั้ง
-- MAIFI (Momentary Average Interruption Frequency Index): {row.get('MAIFI', 'N/A'):.4f} ครั้ง/ลูกค้า
+            reliability_metrics = calculate_reliability_indices(df_copy, total_customers)
+            reliability_df = create_reliability_dataframe(reliability_metrics)
+            performance_summary = generate_performance_summary(reliability_metrics, total_customers)
+            
+            reliability_summary = f"""
+ดัชนีความน่าเชื่อถือของระบบไฟฟ้า:
+• SAIFI: {reliability_metrics.get('SAIFI', 0):.4f} ครั้ง/ลูกค้า/ปี
+• SAIDI: {reliability_metrics.get('SAIDI', 0):.2f} นาที/ลูกค้า/ปี  
+• CAIDI: {reliability_metrics.get('CAIDI', 0):.2f} นาที/ครั้ง
+• MAIFI: {reliability_metrics.get('MAIFI', 0):.4f} ครั้ง/ลูกค้า/ปี
+• ความพร้อมใช้งาน (ASAI): {reliability_metrics.get('ASAI', 0):.4f}%
+• พลังงานที่สูญเสีย (ENS): {reliability_metrics.get('ENS_kWh', 0):,.0f} kWh
 """
-                    summary_text += reliability_summary
-            finally:
-                os.unlink(temp_path)
         except Exception as e:
             reliability_summary = f"ไม่สามารถคำนวณดัชนีความน่าเชื่อถือได้: {str(e)}"
 
-    # Use GenAI for overall summary
+    # Create comprehensive summary text for GenAI
+    summary_text = f"""
+รายงานสรุปข้อมูลไฟฟ้าล้ม:
+• จำนวนเหตุการณ์ทั้งหมด: {total_events:,} ครั้ง
+• ช่วงเวลาที่เกิดเหต���การณ์: {date_range}
+• ประเภทเหตุการณ์หลัก: {', '.join([f'{k}: {v}' for k, v in event_types.items()])}
+• จำนวนลูกค้าที่ได้รับผลกระทบรวม: {int(total_affected) if not pd.isna(total_affected) else 'ไม่ระบุ':,}
+• จำนวนลูกค้าทั้งหมดในระบบ: {int(total_customers) if total_customers else 'ไม่ระบุ':,}
+
+{reliability_summary}
+{performance_summary}
+"""
+
+    # Use GenAI for comprehensive analysis
     ai_summary = None
     if use_hf and get_hf_token():
         try:
-            instruction = "สรุปภาพรวมข้อมูลไฟฟ้าล้มจากข้อมูลนี้ สรุปเป็นย่อหน้าเดียว (ไทย) ระบุจำนวนเหตุการณ์ สาเหตุหลัก ผลกระทบ และข้อเสนอแนะในการปรับปรุงระบบไฟฟ้า:"
-            prompt = f"{instruction}\n\n{summary_text}\n\nสรุปภาพรวม:"
+            instruction = "วิเคราะห์และสรุปข้อมูลความน่าเชื่อถือของระบบไฟฟ้าจากข้อมูลนี้ สรุป 2-3 ย่อหน้า (ไทย) ระบุ: 1) ประสิทธิภาพระบบโดยรวม 2) จุดที่ต้องปรับปรุง 3) ข้อเสนะแนะเชิงเทคนิค:"
+            prompt = f"{instruction}\n\n{summary_text}\n\nการวิเคราะห์และข้อเสนอแนะ:"
             ai_summary = openai_summary(prompt, verbosity='recommend', model=model)
         except Exception as e:
-            ai_summary = f"ไม่สามารถสร้างสรุปด้วย AI ได้: {str(e)}"
+            ai_summary = f"ไม่สามารถสร้างการวิเคราะห์ด้วย AI ได้: {str(e)}"
 
     return {
         'total_events': total_events,
         'date_range': date_range,
         'event_types': event_types,
         'total_affected_customers': int(total_affected) if not pd.isna(total_affected) else None,
+        'total_customers_served': int(total_customers) if total_customers else None,
         'basic_summary': summary_text.strip(),
         'reliability_summary': reliability_summary.strip() if reliability_summary else None,
+        'performance_summary': performance_summary.strip() if performance_summary else None,
+        'reliability_metrics': reliability_metrics,
         'reliability_df': reliability_df,
         'ai_summary': ai_summary,
     }