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, Tuple, Optional
 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,277 @@ def openai_summary(text: str, verbosity: str = 'brief', model: str = 'meta-llama
     except Exception:
         return None
 
+def calculate_outage_duration_minutes(df: pd.DataFrame) -> pd.Series:
+    """
+    คำนวณระยะเวลาการขัดข้องเป็นนาที
+    """
+    durations = pd.Series(index=df.index, dtype='float64')
+    
+    # ลองใช้คอลัมน์ต่างๆ สำหรับคำนวณระยะเวลา
+    if 'OutageDateTime' in df.columns and 'FirstRestoDateTime' in df.columns:
+        outage_time = pd.to_datetime(df['OutageDateTime'], dayfirst=True, errors='coerce')
+        restore_time = pd.to_datetime(df['FirstRestoDateTime'], dayfirst=True, errors='coerce')
+        durations = (restore_time - outage_time).dt.total_seconds() / 60
+    elif 'OutageDateTime' in df.columns and 'LastRestoDateTime' in df.columns:
+        outage_time = pd.to_datetime(df['OutageDateTime'], dayfirst=True, errors='coerce')
+        restore_time = pd.to_datetime(df['LastRestoDateTime'], dayfirst=True, errors='coerce')
+        durations = (restore_time - outage_time).dt.total_seconds() / 60
+    elif 'CreateEventDateTime' in df.columns and 'CloseEventDateTime' in df.columns:
+        create_time = pd.to_datetime(df['CreateEventDateTime'], dayfirst=True, errors='coerce')
+        close_time = pd.to_datetime(df['CloseEventDateTime'], dayfirst=True, errors='coerce')
+        durations = (close_time - create_time).dt.total_seconds() / 60
+    
+    # แทนที่ค่าลบหรือ NaN ด้วย 0
+    durations = durations.fillna(0)
+    durations = durations.where(durations >= 0, 0)
+    
+    return durations
+
+def compute_reliability_metrics(df: pd.DataFrame, total_customers: float) -> Dict:
+    """
+    คำนวณตัวชี้วัดความน่าเชื่อถือของระบบไฟฟ้า
+    
+    สูตรการคำนวณ:
+    SAIFI = Σ(λᵢ × Nᵢ) / Nₜ
+    SAIDI = Σ(Uᵢ × Nᵢ) / Nₜ  
+    CAIDI = SAIDI / SAIFI
+    MAIFI = Σ(λₘᵢ × Nᵢ) / Nₜ
+    CTAIDI = Σ(rᵢ × Nᵢ × λᵢ) / Σ(Nᵢ × λᵢ)
+    ASAI = (Nₜ × T - Σ(rᵢ × Nᵢ)) / (Nₜ × T)
+    
+    โดยที่:
+    λᵢ = ความถี่การขัดข้องของจุดโหลด i
+    Nᵢ = จำนวนลูกค้าที่ได้รับผลกระทบในจุดโหลด i
+    Nₜ = จำนวนลูกค้าทั้งหมดในระบบ
+    Uᵢ = ระยะเวลาขัดข้องรายปีของจุดโหลด i (นาที)
+    rᵢ = ระยะเวลาขัดข้องเฉลี่ยต่อครั้งของจุดโหลด i (นาที)
+    λₘᵢ = ความถี่การขัดข้องชั่วคราว (< 1 นาที)
+    T = ระยะเวลารวม (8760 ชั่วโมง = 525,600 นาที)
+    """
+    
+    # เตรียมข้อมูล
+    df_clean = df.copy()
+    
+    # คำนวณระยะเวลาขัดข้อง
+    df_clean['duration_minutes'] = calculate_outage_duration_minutes(df_clean)
+    
+    # จำนวนลูกค้าที่ได้รับผลกระทบ
+    if 'AffectedCustomer' in df_clean.columns:
+        df_clean['affected_customers'] = pd.to_numeric(df_clean['AffectedCustomer'], errors='coerce').fillna(0)
+    else:
+        df_clean['affected_customers'] = 0
+    
+    # แยกประเภทการขัดข้อง
+    df_clean['is_momentary'] = df_clean['duration_minutes'] < 1  # ขัดข้องชั่วคราว < 1 นาที
+    df_clean['is_sustained'] = df_clean['duration_minutes'] >= 1  # ขัดข้องยาวนาน >= 1 นาที
+    
+    # คำนวณตัวชี้วัด
+    
+    # 1. SAIFI - System Average Interruption Frequency Index
+    # SAIFI = Σ(λᵢ × Nᵢ) / Nₜ
+    sustained_interruptions = df_clean[df_clean['is_sustained']]
+    total_customer_interruptions = sustained_interruptions['affected_customers'].sum()
+    saifi = total_customer_interruptions / total_customers if total_customers > 0 else 0
+    
+    # 2. SAIDI - System Average Interruption Duration Index  
+    # SAIDI = Σ(Uᵢ × Nᵢ) / Nₜ
+    customer_minutes = (sustained_interruptions['duration_minutes'] * sustained_interruptions['affected_customers']).sum()
+    saidi = customer_minutes / total_customers if total_customers > 0 else 0
+    
+    # 3. CAIDI - Customer Average Interruption Duration Index
+    # CAIDI = SAIDI / SAIFI
+    caidi = saidi / saifi if saifi > 0 else 0
+    
+    # 4. MAIFI - Momentary Average Interruption Frequency Index
+    # MAIFI = Σ(λₘᵢ × Nᵢ) / Nₜ
+    momentary_interruptions = df_clean[df_clean['is_momentary']]
+    total_momentary_customer_interruptions = momentary_interruptions['affected_customers'].sum()
+    maifi = total_momentary_customer_interruptions / total_customers if total_customers > 0 else 0
+    
+    # 5. CTAIDI - Customer Total Average Interruption Duration Index
+    # CTAIDI = Σ(rᵢ × Nᵢ × λᵢ) / Σ(Nᵢ × λᵢ)
+    total_customer_duration = (df_clean['duration_minutes'] * df_clean['affected_customers']).sum()
+    total_customer_events = df_clean['affected_customers'].sum()
+    ctaidi = total_customer_duration / total_customer_events if total_customer_events > 0 else 0
+    
+    # 6. ASAI - Average Service Availability Index
+    # ASAI = (Nₜ × T - Σ(rᵢ × Nᵢ)) / (Nₜ × T)
+    total_minutes_per_year = 525600  # 365 × 24 × 60
+    total_available_customer_minutes = total_customers * total_minutes_per_year
+    total_unavailable_customer_minutes = customer_minutes
+    asai = (total_available_customer_minutes - total_unavailable_customer_minutes) / total_available_customer_minutes if total_available_customer_minutes > 0 else 0
+    asai_percent = asai * 100
+    
+    # 7. ASUI - Average Service Unavailability Index
+    asui = (1 - asai) * 100
+    
+    # 8. ENS - Energy Not Supplied (ประมาณการ)
+    # สมมติว่าลูกค้าแต่ละรายใช้ไฟฟ้าเฉลี่ย 3 kW
+    average_demand_kw = 3.0
+    ens_kwh = (total_unavailable_customer_minutes / 60) * average_demand_kw
+    
+    # 9. AENS - Average Energy Not Supplied per Customer
+    aens = ens_kwh / total_customers if total_customers > 0 else 0
+    
+    # สถิติเพิ่มเติม
+    total_events = len(df_clean)
+    total_sustained_events = len(sustained_interruptions)
+    total_momentary_events = len(momentary_interruptions)
+    avg_duration_per_event = df_clean['duration_minutes'].mean()
+    max_duration = df_clean['duration_minutes'].max()
+    total_affected = df_clean['affected_customers'].sum()
+    
+    return {
+        # Primary Reliability Indices
+        'SAIFI': round(saifi, 4),
+        'SAIDI': round(saidi, 2),
+        'CAIDI': round(caidi, 2),
+        'MAIFI': round(maifi, 4),
+        
+        # Additional Indices
+        'CTAIDI': round(ctaidi, 2),
+        'ASAI': round(asai, 6),
+        'ASAI_percent': round(asai_percent, 4),
+        'ASUI_percent': round(asui, 4),
+        'ENS_kWh': round(ens_kwh, 2),
+        'AENS_kWh_per_customer': round(aens, 4),
+        
+        # Supporting Statistics
+        'total_events': total_events,
+        'sustained_events': total_sustained_events,
+        'momentary_events': total_momentary_events,
+        'total_customer_interruptions': int(total_customer_interruptions),
+        'total_customer_minutes': round(customer_minutes, 2),
+        'avg_duration_per_event_minutes': round(avg_duration_per_event, 2),
+        'max_duration_minutes': round(max_duration, 2),
+        'total_affected_customers': int(total_affected)
+    }
+
+def create_reliability_dataframe(metrics: Dict) -> pd.DataFrame:
+    """
+    สร้าง DataFrame สำหรับแสดงตัวชี้วัดความน่าเชื่อถือ
+    """
+    reliability_data = [
+        {
+            'Metric': 'SAIFI',
+            'Full Name': 'System Average Interruption Frequency Index',
+            'Value': metrics['SAIFI'],
+            'Unit': 'ครั้ง/ลูกค้า/ปี',
+            'Formula': 'Σ(λᵢ × Nᵢ) / Nₜ',
+            'Description': 'ความถี่เฉลี่ยของการขัดข้องต่อลูกค้าต่อปี',
+            'Good_Value': '< 1.0'
+        },
+        {
+            'Metric': 'SAIDI',
+            'Full Name': 'System Average Interruption Duration Index',
+            'Value': metrics['SAIDI'],
+            'Unit': 'นาที/ลูกค้า/ปี',
+            'Formula': 'Σ(Uᵢ × Nᵢ) / Nₜ',
+            'Description': 'ระยะเวลาขัดข้องเฉลี่ยต่อลูกค้าต่อปี',
+            'Good_Value': '< 200'
+        },
+        {
+            'Metric': 'CAIDI',
+            'Full Name': 'Customer Average Interruption Duration Index',
+            'Value': metrics['CAIDI'],
+            'Unit': 'นาที/ครั้ง',
+            'Formula': 'SAIDI / SAIFI',
+            'Description': 'ระยะเวลาขัดข้องเฉลี่ยต่อครั้งที่เกิดขัดข้อง',
+            'Good_Value': '< 120'
+        },
+        {
+            'Metric': 'MAIFI',
+            'Full Name': 'Momentary Average Interruption Frequency Index',
+            'Value': metrics['MAIFI'],
+            'Unit': 'ครั้ง/ลูกค้า/ปี',
+            'Formula': 'Σ(λₘᵢ × Nᵢ) / Nₜ',
+            'Description': 'ความถี่เฉลี่ยของการขัดข้องชั่วคราว (< 1 นาที)',
+            'Good_Value': '< 5.0'
+        },
+        {
+            'Metric': 'CTAIDI',
+            'Full Name': 'Customer Total Average Interruption Duration Index',
+            'Value': metrics['CTAIDI'],
+            'Unit': 'นาที/ครั้ง',
+            'Formula': 'Σ(rᵢ × Nᵢ × λᵢ) / Σ(Nᵢ × λᵢ)',
+            'Description': 'ระยะเวลาขัดข้องเฉลี่ยรวมทั้งชั่วคราวและยาวนาน',
+            'Good_Value': '< 100'
+        },
+        {
+            'Metric': 'ASAI',
+            'Full Name': 'Average Service Availability Index',
+            'Value': metrics['ASAI_percent'],
+            'Unit': '%',
+            'Formula': '(Nₜ×T - Σ(rᵢ×Nᵢ)) / (Nₜ×T) × 100',
+            'Description': 'ดัชนีความพร้อมใช้งานเฉลี่ยของระบบ',
+            'Good_Value': '> 99.95%'
+        },
+        {
+            'Metric': 'ASUI',
+            'Full Name': 'Average Service Unavailability Index',
+            'Value': metrics['ASUI_percent'],
+            'Unit': '%',
+            'Formula': '100 - ASAI',
+            'Description': 'ดัชนีความไม่พร้อมใช้งานเฉลี่ยของระบบ',
+            'Good_Value': '< 0.05%'
+        },
+        {
+            'Metric': 'AENS',
+            'Full Name': 'Average Energy Not Supplied per Customer',
+            'Value': metrics['AENS_kWh_per_customer'],
+            'Unit': 'kWh/ลูกค้า/ปี',
+            'Formula': 'ENS / Nₜ',
+            'Description': 'พลังงานไฟฟ้าเฉลี่ยที่ไม่สามารถจ่ายให้ลูกค้าได้',
+            'Good_Value': '< 10'
+        }
+    ]
+    
+    return pd.DataFrame(reliability_data)
+
+def interpret_reliability_metrics(metrics: Dict) -> str:
+    """
+    ตีความผลตัวชี้วัดความน่าเชื่อถือ
+    """
+    interpretations = []
+    
+    # SAIFI interpretation
+    saifi = metrics['SAIFI']
+    if saifi < 1.0:
+        interpretations.append("SAIFI: ดีมาก - ลูกค้าขัดข้องน้อยกว่า 1 ครั้งต่อปี")
+    elif saifi < 2.0:
+        interpretations.append("SAIFI: ดี - ลูกค้าขัดข้องประมาณ 1-2 ครั้งต่อปี")
+    elif saifi < 5.0:
+        interpretations.append("SAIFI: พอใช้ - ลูกค้าขัดข้อง 2-5 ครั้งต่อปี")
+    else:
+        interpretations.append("SAIFI: ต้องปรับปรุง - ลูกค้าขัดข้องบ่อยเกิน 5 ครั้งต่อปี")
+    
+    # SAIDI interpretation  
+    saidi = metrics['SAIDI']
+    if saidi < 100:
+        interpretations.append("SAIDI: ดีมาก - ขัดข้องน้อยกว่า 100 นาทีต่อปี")
+    elif saidi < 200:
+        interpretations.append("SAIDI: ดี - ขัดข้อง 100-200 นาทีต่อปี")
+    elif saidi < 500:
+        interpretations.append("SAIDI: พอใช้ - ขัดข้อง 200-500 นาทีต่อปี")
+    else:
+        interpretations.append("SAIDI: ต้องปรับปรุง - ขัดข้องเกิน 500 นาทีต่อปี")
+    
+    # ASAI interpretation
+    asai = metrics['ASAI_percent']
+    if asai > 99.98:
+        interpretations.append("ASAI: ดีเยี่ยม - ระบบพร้อมใช้งานเกิน 99.98%")
+    elif asai > 99.95:
+        interpretations.append("ASAI: ดีมาก - ระบบพร้อมใช้งาน 99.95-99.98%")
+    elif asai > 99.90:
+        interpretations.append("ASAI: ดี - ระบบพร้อมใช้งาน 99.90-99.95%")
+    else:
+        interpretations.append("ASAI: ต้องปรับปรุง - ระบบพร้อมใช้งานต่ำกว่า 99.90%")
+    
+    return " | ".join(interpretations)
 
 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 reliability metrics and GenAI analysis."""
+    
     # Basic statistics
     total_events = len(df)
     date_cols = ['OutageDateTime', 'FirstRestoDateTime', 'LastRestoDateTime', 'CreateEventDateTime', 'CloseEventDateTime']
@@ -61,8 +331,8 @@ 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"""
+    # Create basic summary text
+    basic_summary = f"""
 ข้อมูลไฟฟ้าล้มทั้งหมด:
 - จำนวนเหตุการณ์ทั้งหมด: {total_events}
 - ช่วงเวลาที่เกิดเหตุการณ์: {date_range}
@@ -70,79 +340,55 @@ def summarize_overall(df: pd.DataFrame, use_hf: bool = False, model: str = 'meta
 - จำนวนลูกค้าที่ได้รับผลกระทบทั้งหมด: {int(total_affected) if not pd.isna(total_affected) else 'ไม่ระบุ'}
 """
 
-    # Reliability metrics DataFrame
+    # Compute reliability metrics
+    reliability_metrics = {}
     reliability_df = pd.DataFrame()
     reliability_summary = ""
+    reliability_interpretation = ""
 
     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 = compute_reliability_metrics(df_copy, total_customers)
+            reliability_df = create_reliability_dataframe(reliability_metrics)
+            reliability_interpretation = interpret_reliability_metrics(reliability_metrics)
+
+            reliability_summary = f"""
+ดัชนีความน่าเชื่อถือของระบบไฟฟ้า:
+
+ตัวชี้วัดหลัก:
+- SAIFI: {reliability_metrics['SAIFI']:.4f} ครั้ง/ลูกค้า/ปี (ความถี่การขัดข้อง)
+- SAIDI: {reliability_metrics['SAIDI']:.2f} นาที/ลูกค้า/ปี (ระยะเวลาขัดข้อง)
+- CAIDI: {reliability_metrics['CAIDI']:.2f} นาที/ครั้ง (ระยะเวลาเฉลี่ยต่อครั้ง)
+- MAIFI: {reliability_metrics['MAIFI']:.4f} ครั้ง/ลูกค้า/ปี (ขัดข้องชั่วคราว)
+
+ตัวชี้วัดเพิ่มเติม:
+- ASAI: {reliability_metrics['ASAI_percent']:.4f}% (ความพร้อมใช้งาน)
+- ASUI: {reliability_metrics['ASUI_percent']:.4f}% (ความไม่พร้อมใช้งาน)
+- AENS: {reliability_metrics['AENS_kWh_per_customer']:.4f} kWh/ลูกค้า/ปี (พลังงานที่สูญเสีย)
+
+การตีความ: {reliability_interpretation}
+
+สถิติสนับสนุน:
+- เหตุการณ์ยาวนาน: {reliability_metrics['sustained_events']} ครั้ง
+- เหตุการณ์ชั่วคราว: {reliability_metrics['momentary_events']} ครั้ง
+- ระยะเวลาเฉลี่ยต่อเหตุการณ์: {reliability_metrics['avg_duration_per_event_minutes']:.2f} นาที
+- ระยะเวลาสูงสุด: {reliability_metrics['max_duration_minutes']:.2f} นาที
 """
-                    summary_text += reliability_summary
-            finally:
-                os.unlink(temp_path)
+            basic_summary += reliability_summary
+            
         except Exception as e:
             reliability_summary = f"ไม่สามารถคำนวณดัชนีความน่าเชื่อถือได้: {str(e)}"
 
-    # Use GenAI for overall summary
+    # Use GenAI for overall summary with enhanced context
     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. การวิเคราะห์ตัวชี้วัด SAIFI, SAIDI, ASAI และการตีความ
+3. ข้อเสนอแนะในการปรับปรุงประสิทธิภาพและความน่าเชื่อถือของระบบ:"""
+            
+            prompt = f"{instruction}\n\n{basic_summary}\n\nสรุปภาพรวมและการวิเคราะห์:"
             ai_summary = openai_summary(prompt, verbosity='recommend', model=model)
         except Exception as e:
             ai_summary = f"ไม่สามารถสร้างสรุปด้วย AI ได้: {str(e)}"
@@ -152,8 +398,18 @@ def summarize_overall(df: pd.DataFrame, use_hf: bool = False, model: str = 'meta
         'date_range': date_range,
         'event_types': event_types,
         'total_affected_customers': int(total_affected) if not pd.isna(total_affected) else None,
-        'basic_summary': summary_text.strip(),
+        'basic_summary': basic_summary.strip(),
         'reliability_summary': reliability_summary.strip() if reliability_summary else None,
+        'reliability_metrics': reliability_metrics,
         'reliability_df': reliability_df,
+        'reliability_interpretation': reliability_interpretation,
         'ai_summary': ai_summary,
+        'formulas': {
+            'SAIFI': 'Σ(λᵢ × Nᵢ) / Nₜ',
+            'SAIDI': 'Σ(Uᵢ × Nᵢ) / Nₜ',
+            'CAIDI': 'SAIDI / SAIFI',
+            'MAIFI': 'Σ(λₘᵢ × Nᵢ) / Nₜ',
+            'ASAI': '(Nₜ×T - Σ(rᵢ×Nᵢ)) / (Nₜ×T) × 100',
+            'AENS': 'ENS / Nₜ'
+        }
     }