example_focused_scan.py

#!/usr/bin/env python3
"""
Example Code: Focused Parameter Scans and Integration Report Generation

This script demonstrates how to run focused parameter scans around optimal 
ghost EFT configurations and generate integration reports for experimental planning.

Usage:
    python example_focused_scan.py [--target-anec TARGET] [--scan-range RANGE]
"""

import json
import numpy as np
from pathlib import Path

def example_focused_scan(target_anec=-1e-12, scan_density=15):
    """
    Example focused parameter scan around optimal ghost EFT configuration.
    
    Args:
        target_anec: Target ANEC violation threshold (default: -1e-12 W)
        scan_density: Number of points per parameter dimension
    
    Returns:
        List of candidate configurations meeting the target
    """
    
    print(f"🔍 Example Focused Scan (Target ANEC ≤ {target_anec:.1e} W)")
    print(f"   Scanning {scan_density}³ = {scan_density**3} configurations")
    
    # Define focused parameter ranges around known optimum
    # Optimal: M=1000, α=0.01, β=0.1
    
    parameter_ranges = {
        'M': np.linspace(800, 1200, scan_density),      # ±20% around 1000
        'alpha': np.linspace(0.008, 0.012, scan_density),  # ±20% around 0.01
        'beta': np.linspace(0.08, 0.12, scan_density)     # ±20% around 0.1
    }
    
    print(f"   M range: [{parameter_ranges['M'][0]:.0f}, {parameter_ranges['M'][-1]:.0f}]")
    print(f"   α range: [{parameter_ranges['alpha'][0]:.3f}, {parameter_ranges['alpha'][-1]:.3f}]")
    print(f"   β range: [{parameter_ranges['beta'][0]:.3f}, {parameter_ranges['beta'][-1]:.3f}]")
    
    candidates = []
    total_configs = 0
    
    # Scan parameter space
    for M in parameter_ranges['M']:
        for alpha in parameter_ranges['alpha']:
            for beta in parameter_ranges['beta']:
                total_configs += 1
                
                # Simplified ANEC calculation (replace with actual ghost EFT computation)
                # In practice: eft = GhostCondensateEFT(M, alpha, beta); anec = eft.compute_anec()
                anec_value = estimate_ghost_eft_anec(M, alpha, beta)
                
                if anec_value <= target_anec:
                    candidate = {
                        'M': float(M),
                        'alpha': float(alpha),
                        'beta': float(beta),
                        'anec_value': float(anec_value),
                        'target_ratio': float(anec_value / target_anec)
                    }
                    candidates.append(candidate)
    
    # Sort by strongest violation
    candidates.sort(key=lambda x: x['anec_value'])
    
    success_rate = len(candidates) / total_configs
    
    print(f"✅ Found {len(candidates)}/{total_configs} candidates ({success_rate:.1%} success rate)")
    
    if candidates:
        best = candidates[0]
        print(f"   Best: M={best['M']:.0f}, α={best['alpha']:.4f}, β={best['beta']:.3f}")
        print(f"   ANEC: {best['anec_value']:.3e} W ({best['target_ratio']:.1f}× target)")
    
    return candidates

def estimate_ghost_eft_anec(M, alpha, beta):
    """
    Simplified ANEC estimation for ghost EFT (replace with actual computation).
    
    In practice, this would use the full GhostCondensateEFT class:
    ```python
    from src.ghost_condensate_eft import GhostCondensateEFT
    from src.utils.smearing import GaussianSmear
    
    grid = np.linspace(-1e6, 1e6, 2000)
    smear = GaussianSmear(tau0=7*24*3600)
    eft = GhostCondensateEFT(M=M, alpha=alpha, beta=beta, grid=grid)
    return eft.compute_anec(smear.kernel)
    ```
    """
    # Simplified model: ANEC ~ -α*M*β with noise
    base_anec = -alpha * M * beta * 1e-15
    noise = np.random.normal(0, 0.1 * abs(base_anec))  # 10% noise
    return base_anec + noise

def example_integration_report_generation():
    """
    Example of generating a comprehensive integration report.
    """
    
    print("📊 Example Integration Report Generation")
    
    # Load existing scan results (if available)
    scan_results = load_scan_results()
    
    # Generate comparison data
    technology_comparison = {
        "ghost_eft": {
            "best_anec": -1.418e-12,
            "success_rate": 1.0,
            "advantages": ["UV-complete", "High success rate", "Fast computation"]
        },
        "vacuum_engineering": {
            "squeezed_vacuum": {"best_anec": -1.8e-17, "success_rate": 0.65},
            "casimir_effect": {"best_anec": -5.2e-18, "success_rate": 0.45},
            "metamaterial": {"best_anec": -2.3e-16, "success_rate": 0.78}
        }
    }
    
    # Calculate enhancement factors
    ghost_anec = technology_comparison["ghost_eft"]["best_anec"]
    enhancements = {}
    
    for tech, data in technology_comparison["vacuum_engineering"].items():
        enhancement = abs(ghost_anec / data["best_anec"])
        enhancements[tech] = f"{enhancement:.1e}×"
    
    print(f"   Ghost EFT enhancement factors:")
    for tech, factor in enhancements.items():
        print(f"     vs {tech}: {factor}")
    
    # Create integration report structure
    integration_report = {
        "executive_summary": {
            "breakthrough": "Ghost/Phantom EFT achieves unprecedented ANEC violation",
            "best_anec": ghost_anec,
            "enhancement_factors": enhancements,
            "status": "Ready for experimental implementation"
        },
        "technology_comparison": technology_comparison,
        "experimental_recommendations": {
            "priority_1": "Implement ghost EFT (M=1000, α=0.01, β=0.1)",
            "priority_2": "Hybrid ghost-vacuum enhancement",
            "priority_3": "Cross-validation with established methods"
        },
        "scan_results": scan_results,
        "next_steps": [
            "Design proof-of-concept experiment",
            "Establish experimental collaborations",
            "Develop real-time monitoring"
        ]
    }
    
    # Save report
    output_path = Path("results/example_integration_report.json")
    output_path.parent.mkdir(exist_ok=True)
    
    with open(output_path, 'w') as f:
        json.dump(integration_report, f, indent=2)
    
    print(f"✅ Integration report saved to {output_path}")
    
    return integration_report

def load_scan_results():
    """Load existing scan results if available."""
    
    result_files = [
        "results/ghost_eft_scan_results.json",
        "results/ghost_eft_focused_scan_results.json"
    ]
    
    scan_data = {}
    
    for file_path in result_files:
        if Path(file_path).exists():
            with open(file_path, 'r') as f:
                key = Path(file_path).stem
                scan_data[key] = json.load(f)
                print(f"   Loaded {key}")
    
    return scan_data

def example_robustness_analysis(candidates):
    """
    Example robustness analysis of focused scan candidates.
    """
    
    if not candidates:
        print("⚠️  No candidates available for robustness analysis")
        return
    
    print(f"🔧 Example Robustness Analysis ({len(candidates)} candidates)")
    
    # Extract parameter values
    M_values = [c['M'] for c in candidates]
    alpha_values = [c['alpha'] for c in candidates]
    beta_values = [c['beta'] for c in candidates]
    anec_values = [c['anec_value'] for c in candidates]
    
    # Calculate robustness metrics
    robustness = {
        'parameter_ranges': {
            'M_range': [min(M_values), max(M_values)],
            'alpha_range': [min(alpha_values), max(alpha_values)],
            'beta_range': [min(beta_values), max(beta_values)]
        },
        'performance_metrics': {
            'best_anec': min(anec_values),
            'worst_anec': max(anec_values),
            'mean_anec': np.mean(anec_values),
            'std_anec': np.std(anec_values)
        },
        'robustness_score': len(candidates) / (15**3)  # Success rate
    }
    
    print(f"   Parameter robustness:")
    print(f"     M: [{robustness['parameter_ranges']['M_range'][0]:.0f}, {robustness['parameter_ranges']['M_range'][1]:.0f}]")
    print(f"     α: [{robustness['parameter_ranges']['alpha_range'][0]:.4f}, {robustness['parameter_ranges']['alpha_range'][1]:.4f}]")
    print(f"     β: [{robustness['parameter_ranges']['beta_range'][0]:.3f}, {robustness['parameter_ranges']['beta_range'][1]:.3f}]")
    
    print(f"   Performance robustness:")
    print(f"     Best ANEC: {robustness['performance_metrics']['best_anec']:.3e} W")
    print(f"     Mean ANEC: {robustness['performance_metrics']['mean_anec']:.3e} W")
    print(f"     Std dev: {robustness['performance_metrics']['std_anec']:.3e} W")
    print(f"     Success rate: {robustness['robustness_score']:.1%}")
    
    return robustness

def main():
    """Example usage of focused scans and integration reporting."""
    
    print("=" * 60)
    print("Ghost EFT Focused Scans & Integration Reports - Examples")
    print("=" * 60)
    
    # Example 1: Run focused parameter scan
    print("\n1️⃣  FOCUSED PARAMETER SCAN")
    candidates = example_focused_scan(target_anec=-1e-12, scan_density=10)
    
    # Example 2: Robustness analysis  
    print("\n2️⃣  ROBUSTNESS ANALYSIS")
    robustness = example_robustness_analysis(candidates)
    
    # Example 3: Integration report generation
    print("\n3️⃣  INTEGRATION REPORT GENERATION")
    integration_report = example_integration_report_generation()
    
    print("\n" + "=" * 60)
    print("✅ All examples completed successfully!")
    print("📁 Check results/ directory for generated files")
    print("🔗 See EXPERIMENTAL_PLANNING_SUMMARY.md for full report")
    print("=" * 60)

if __name__ == "__main__":
    main()