demo_feedback_control.py

"""
Closed-Loop Feedback Control Demonstration
=========================================

Complete demonstration of real-time feedback control for negative energy systems.

This script demonstrates:
1. Integration of control system with instrumentation
2. Sensor-controller-actuator feedback loop
3. Real-time maintenance of ⟨T₀₀⟩ < 0
4. Performance comparison of control strategies
5. Disturbance rejection and constraint handling

Control Loop Architecture:
Sensors → State Estimation → Controller → Actuators → Plant → Sensors

Mathematical Pipeline:
1. y(t) = Cx(t) + v(t)           [Sensor measurements]
2. x̂(t) = observer(y(t))        [State estimation]  
3. u(t) = controller(x̂(t))      [Control computation]
4. actuator_out = G_act(s) u(t)  [Actuator dynamics]
5. x(t+1) = Ax(t) + B u(t) + w(t) [Plant dynamics]

Performance Metrics:
- Energy constraint satisfaction rate
- Control effort and actuator utilization
- Disturbance rejection capability
- Stability margins and robustness
"""

import numpy as np
import matplotlib.pyplot as plt
import sys
import os

# Add src directory to path
sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))

from control import (
    StateSpaceModel, RealTimeFeedbackController, 
    run_closed_loop_simulation, demonstrate_control_strategies
)
from actuators import ActuatorNetwork, demonstrate_actuator_system
from hardware_instrumentation import (
    InterferometricProbe, CalorimetricSensor, PhaseShiftInterferometer,
    RealTimeDAQ, generate_T00_pulse
)

def create_integrated_control_loop():
    """Create complete sensor-controller-actuator loop."""
    
    print("🔄 INTEGRATED CONTROL LOOP INITIALIZATION")
    print("=" * 50)
    
    # 1. Create system model
    print("   🔧 Initializing state-space model...")
    system = StateSpaceModel(n_modes=4, n_actuators=5, n_sensors=2)
    
    print(f"      • States: {system.n_states} (position + velocity modes)")
    print(f"      • Actuators: {system.n_actuators} (boundary field control)")
    print(f"      • Sensors: {system.n_sensors} (interferometric + calorimetric)")
    print(f"      • Controllable: {system.is_controllable}")
    print(f"      • Observable: {system.is_observable}")
    print(f"      • Stable: {system.is_stable}")
    
    # 2. Create measurement system
    print("   📡 Initializing measurement system...")
    probe = InterferometricProbe(
        wavelength=1.55e-6,  # 1550 nm
        path_length=0.12,    # 12 cm
        n0=1.48,            # Optical fiber core
        r_coeff=1.5e-12,    # Enhanced electro-optic coefficient
        material="LiIO3"
    )
    
    calorimeter = CalorimetricSensor(
        volume=2e-19,        # 0.2 femtoliter (high sensitivity)
        density=2330,        # Silicon
        Cp=700,             # Silicon heat capacity
        material="Silicon"
    )
    
    interferometer = PhaseShiftInterferometer(probe, sampling_rate=2e11)  # 200 GHz
    daq = RealTimeDAQ(25000, 5e10, 1e-6, "rising")  # 50 GHz DAQ
    
    print(f"      • Probe sensitivity: {probe.sensitivity:.2e} rad/(J/m³)")
    print(f"      • Thermal sensitivity: {calorimeter.sensitivity:.2e} K/(J/m³)")
    print(f"      • Sampling rate: {interferometer.fs/1e9:.0f} GHz")
    print(f"      • DAQ buffer: {daq.buffer_size:,} samples")
    
    # 3. Create controller
    print("   🎯 Initializing feedback controller...")
    controller = RealTimeFeedbackController(
        system, 
        hinf_gamma=0.8,      # Aggressive disturbance rejection
        mpc_horizon=25,      # 25-step prediction horizon
        control_mode="hybrid" # Combine H∞ and MPC
    )
    
    print(f"      • Control mode: {controller.control_mode}")
    print(f"      • H∞ gamma: {controller.hinf_controller.gamma}")
    print(f"      • MPC horizon: {controller.mpc_controller.N}")
    
    # 4. Create actuator network
    print("   ⚡ Initializing actuator network...")
    actuator_network = ActuatorNetwork()
    
    print(f"      • Network actuators: {len(actuator_network.actuators)}")
    for name, actuator in actuator_network.actuators.items():
        print(f"        - {name}: {actuator.max_output:.1e} max, {actuator.bandwidth/1e9:.1f} GHz BW")
    
    return {
        'system': system,
        'controller': controller,
        'actuator_network': actuator_network,
        'sensors': {
            'probe': probe,
            'calorimeter': calorimeter,
            'interferometer': interferometer,
            'daq': daq
        }
    }

def run_integrated_simulation(components: dict, duration: float = 2e-6,
                             disturbance_scenario: str = "burst") -> dict:
    """
    Run integrated simulation with realistic sensor-actuator loop.
    
    Args:
        components: Dictionary with system components
        duration: Simulation duration (seconds)
        disturbance_scenario: Type of disturbance ("burst", "continuous", "step")
        
    Returns:
        Complete simulation results
    """
    print(f"\n🔄 INTEGRATED SIMULATION ({disturbance_scenario} disturbance)")
    print("=" * 55)
    
    system = components['system']
    controller = components['controller']
    actuator_network = components['actuator_network']
    sensors = components['sensors']
    
    # Simulation parameters
    dt = 1e-9  # 1 ns time step
    times = np.arange(0, duration, dt)
    n_steps = len(times)
    
    print(f"   • Duration: {duration*1e6:.1f} μs ({n_steps:,} time steps)")
    print(f"   • Time step: {dt*1e9:.1f} ns")
    print(f"   • Disturbance scenario: {disturbance_scenario}")
    
    # Generate disturbance sequence
    if disturbance_scenario == "burst":
        # Multiple burst disturbances
        T00_disturbance = np.zeros(n_steps)
        for burst_time in [0.5e-6, 1.0e-6, 1.5e-6]:
            burst_mask = np.abs(times - burst_time) < 0.1e-6
            amplitude = 2e7 * np.random.uniform(0.8, 1.2)  # Positive energy bursts
            T00_disturbance[burst_mask] += amplitude * np.exp(
                -((times[burst_mask] - burst_time) / 0.03e-6)**2
            )
    elif disturbance_scenario == "continuous":
        # Continuous colored noise
        frequency_content = 1e6  # 1 MHz noise
        T00_disturbance = 1e7 * np.random.randn(n_steps)
        # Apply low-pass filter to create colored noise
        from scipy.signal import butter, filtfilt
        b, a = butter(3, frequency_content/(0.5/dt), 'low')
        T00_disturbance = filtfilt(b, a, T00_disturbance)
    elif disturbance_scenario == "step":
        # Step disturbance at midpoint
        step_time = duration / 2
        step_mask = times >= step_time
        T00_disturbance = np.zeros(n_steps)
        T00_disturbance[step_mask] = 5e6  # Constant positive energy
    else:
        T00_disturbance = np.zeros(n_steps)
    
    # Initialize state
    x0 = np.zeros(system.n_states)
    x0[0] = 0.05   # Small initial positive energy in first mode
    x0[2] = -0.02  # Small initial negative energy in second mode
    
    # Preallocate arrays
    state_trajectory = np.zeros((system.n_states, n_steps))
    control_trajectory = np.zeros((system.n_actuators, n_steps))
    actuator_trajectory = np.zeros((len(actuator_network.actuators), n_steps))
    sensor_trajectory = np.zeros((system.n_sensors, n_steps))
    energy_trajectory = np.zeros(n_steps)
    phase_trajectory = np.zeros(n_steps)
    temp_trajectory = np.zeros(n_steps)
    
    # Initialize
    x = x0.copy()
    state_trajectory[:, 0] = x
    
    print("   🔄 Running simulation loop...")
    
    # Main simulation loop
    for t in range(n_steps - 1):
        # 1. SENSOR MEASUREMENTS
        # Extract energy density from first mode (primary observable)
        current_energy_density = system.C[0, :] @ x
        
        # Add disturbance to create measurement scenario
        total_energy_density = current_energy_density + T00_disturbance[t]
        
        # Simulate interferometric measurement
        phase_shift = sensors['probe'].phase_shift(total_energy_density)
        phase_noise = 1e-8 * np.random.randn()  # Measurement noise
        measured_phase = phase_shift + phase_noise
        phase_trajectory[t] = measured_phase
        
        # Simulate calorimetric measurement  
        temp_rise = sensors['calorimeter'].temp_rise(total_energy_density)
        temp_noise = 1e-9 * np.random.randn()  # Thermal noise
        measured_temp = temp_rise + temp_noise
        temp_trajectory[t] = measured_temp
        
        # Create sensor vector (simplified state estimation)
        y_sensor = np.array([measured_phase * 1e6, measured_temp * 1e6])  # Scale for numerics
        sensor_trajectory[:, t] = y_sensor
        
        # 2. STATE ESTIMATION (simplified - direct measurement)
        # In practice, would use Kalman filter or observer
        # For now, use scaled sensor measurements as state estimate
        x_estimated = x.copy()
        x_estimated[0] = measured_phase * 1e8  # Scale phase to energy units
        x_estimated[2] = measured_temp * 1e9   # Scale temperature to energy units
        
        # 3. CONTROL COMPUTATION
        # Estimate disturbance level from sensor measurements
        disturbance_level = np.linalg.norm(y_sensor) / 1e6
        
        # Compute control input
        u_control = controller.apply_control(x_estimated, disturbance_level)
        control_trajectory[:, t] = u_control
        
        # 4. ACTUATOR DYNAMICS
        # Map control vector to actuator network (may have different sizes)
        actuator_commands = np.zeros(len(actuator_network.actuators))
        for i in range(min(len(u_control), len(actuator_commands))):
            actuator_commands[i] = u_control[i]
        
        # Apply commands through actuator network
        actuator_outputs = actuator_network.apply_command_vector(actuator_commands, dt)
        actuator_trajectory[:, t] = actuator_outputs
        
        # 5. PLANT DYNAMICS UPDATE
        # Map actuator outputs back to control inputs (simplified)
        u_effective = np.zeros(system.n_actuators)
        for i in range(min(len(actuator_outputs), len(u_effective))):
            # Simple scaling from actuator output to plant input
            actuator = list(actuator_network.actuators.values())[i]
            u_effective[i] = actuator_outputs[i] / actuator.safe_max * 1e-6
        
        # Add process noise
        w_process = 1e-8 * np.random.randn(system.n_states)
        
        # State update
        x_next = system.Ad @ x + system.Bd @ u_effective + w_process
        
        # Store results
        state_trajectory[:, t+1] = x_next
        energy_trajectory[t] = current_energy_density
        
        # Update for next iteration
        x = x_next
    
    # Final energy measurement
    energy_trajectory[-1] = system.C[0, :] @ x
    
    # Performance analysis
    controller_performance = controller.get_performance_metrics()
    actuator_status = actuator_network.get_network_status()
    
    # Energy constraint analysis
    energy_violations = np.sum(energy_trajectory > 0)
    energy_satisfaction_rate = 1 - (energy_violations / n_steps)
    
    # Disturbance rejection analysis
    disturbance_magnitude = np.max(np.abs(T00_disturbance))
    final_energy_error = abs(energy_trajectory[-1])
    disturbance_rejection_db = 20 * np.log10(disturbance_magnitude / max(final_energy_error, 1e-15))
    
    print(f"   ✅ Simulation complete!")
    print(f"   📊 Energy constraint satisfaction: {energy_satisfaction_rate:.1%}")
    print(f"   🎯 Final energy density: {energy_trajectory[-1]:.2e}")
    print(f"   📡 Disturbance rejection: {disturbance_rejection_db:.1f} dB")
    print(f"   ⚡ Average control effort: {controller_performance['average_control_effort']:.2e}")
    print(f"   🔧 Actuator utilization: {np.mean([s.get('utilization_rate', 0) for s in actuator_status['actuator_status'].values()]):.1%}")
    
    return {
        'times': times,
        'states': state_trajectory,
        'controls': control_trajectory,
        'actuator_outputs': actuator_trajectory,
        'sensors': sensor_trajectory,
        'energy_density': energy_trajectory,
        'phase_measurements': phase_trajectory,
        'temperature_measurements': temp_trajectory,
        'disturbance': T00_disturbance,
        'performance': {
            'controller': controller_performance,
            'actuator_network': actuator_status,
            'energy_satisfaction_rate': energy_satisfaction_rate,
            'disturbance_rejection_db': disturbance_rejection_db,
            'final_energy': energy_trajectory[-1]
        }
    }

def create_comprehensive_visualization(results: dict):
    """Create comprehensive visualization of integrated control performance."""
    
    print("\n📊 CREATING COMPREHENSIVE VISUALIZATION")
    print("=" * 45)
    
    times_us = results['times'] * 1e6  # Convert to microseconds
    
    # Create figure with subplots
    fig = plt.figure(figsize=(16, 12))
    
    # Plot 1: Energy Density Control
    ax1 = plt.subplot(3, 3, 1)
    plt.plot(times_us, results['energy_density'], 'b-', linewidth=2, label='Controlled Energy')
    plt.plot(times_us, results['disturbance'], 'r--', alpha=0.7, linewidth=1, label='Disturbance')
    plt.axhline(y=0, color='k', linestyle=':', alpha=0.8, label='⟨T₀₀⟩ = 0')
    plt.xlabel('Time (μs)')
    plt.ylabel('Energy Density (J/m³)')
    plt.title('Negative Energy Density Control')
    plt.legend()
    plt.grid(True, alpha=0.3)
    
    # Plot 2: Sensor Measurements
    ax2 = plt.subplot(3, 3, 2)
    plt.plot(times_us[:-1], results['phase_measurements'][:-1]*1e6, 'g-', linewidth=2, label='Phase (μrad)')
    plt.plot(times_us[:-1], results['temperature_measurements'][:-1]*1e6, 'orange', linewidth=2, label='Temp (μK)')
    plt.xlabel('Time (μs)')
    plt.ylabel('Sensor Response')
    plt.title('Real-Time Sensor Measurements')
    plt.legend()
    plt.grid(True, alpha=0.3)
    
    # Plot 3: Control Signals
    ax3 = plt.subplot(3, 3, 3)
    for i in range(min(3, results['controls'].shape[0])):  # Show first 3 control signals
        plt.plot(times_us[:-1], results['controls'][i, :-1]/1e6, linewidth=2, 
                label=f'Control {i+1}', alpha=0.8)
    plt.xlabel('Time (μs)')
    plt.ylabel('Control Signal (MV equivalent)')
    plt.title('Control Signal Generation')
    plt.legend()
    plt.grid(True, alpha=0.3)
    
    # Plot 4: Actuator Outputs
    ax4 = plt.subplot(3, 3, 4)
    actuator_names = ['V1', 'V2', 'I1', 'Laser', 'Field']
    for i, name in enumerate(actuator_names):
        if i < results['actuator_outputs'].shape[0]:
            # Normalize by actuator max for comparison
            normalized_output = results['actuator_outputs'][i, :-1]
            plt.plot(times_us[:-1], normalized_output/1e6, linewidth=1.5, 
                    label=name, alpha=0.8)
    plt.xlabel('Time (μs)')
    plt.ylabel('Actuator Output (Normalized)')
    plt.title('Actuator Response')
    plt.legend()
    plt.grid(True, alpha=0.3)
    
    # Plot 5: State Evolution (first 4 modes)
    ax5 = plt.subplot(3, 3, 5)
    for i in range(min(4, results['states'].shape[0])):
        plt.plot(times_us, results['states'][i, :], linewidth=1.5, 
                label=f'Mode {i+1}', alpha=0.8)
    plt.xlabel('Time (μs)')
    plt.ylabel('State Amplitude')
    plt.title('System State Evolution')
    plt.legend()
    plt.grid(True, alpha=0.3)
    
    # Plot 6: Performance Metrics
    ax6 = plt.subplot(3, 3, 6)
    metrics = ['Energy Satisfaction', 'Disturbance Rejection', 'Control Efficiency']
    values = [
        results['performance']['energy_satisfaction_rate'],
        min(results['performance']['disturbance_rejection_db'] / 60, 1.0),  # Normalize to 60 dB
        1 - min(results['performance']['controller']['average_control_effort'] / 1e6, 1.0)
    ]
    colors = ['green', 'blue', 'orange']
    
    bars = plt.bar(metrics, values, color=colors, alpha=0.7)
    plt.ylabel('Performance Score')
    plt.title('Control Performance Metrics')
    plt.ylim(0, 1.1)
    
    # Add value labels on bars
    for bar, value in zip(bars, values):
        plt.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.02,
                f'{value:.2f}', ha='center', va='bottom', fontweight='bold')
    
    plt.xticks(rotation=45, ha='right')
    plt.grid(True, alpha=0.3)
    
    # Plot 7: Energy Constraint Violation Analysis
    ax7 = plt.subplot(3, 3, 7)
    violation_mask = results['energy_density'] > 0
    violation_times = times_us[violation_mask]
    violation_magnitudes = results['energy_density'][violation_mask]
    
    if len(violation_times) > 0:
        plt.scatter(violation_times, violation_magnitudes, c='red', alpha=0.6, s=20)
        plt.xlabel('Time (μs)')
        plt.ylabel('Violation Magnitude (J/m³)')
        plt.title('Energy Constraint Violations')
    else:
        plt.text(0.5, 0.5, 'No Violations\nDetected', ha='center', va='center',
                transform=ax7.transAxes, fontsize=12, fontweight='bold', color='green')
        plt.title('Energy Constraint Violations')
    
    plt.grid(True, alpha=0.3)
    
    # Plot 8: Frequency Domain Analysis
    ax8 = plt.subplot(3, 3, 8)
    # FFT of energy density signal
    fft_energy = np.fft.fft(results['energy_density'] - np.mean(results['energy_density']))
    freqs = np.fft.fftfreq(len(fft_energy), results['times'][1] - results['times'][0])
    
    # Only plot positive frequencies up to Nyquist
    pos_mask = freqs > 0
    plt.loglog(freqs[pos_mask]/1e6, np.abs(fft_energy[pos_mask]), 'b-', linewidth=2)
    plt.xlabel('Frequency (MHz)')
    plt.ylabel('Energy Density Spectrum')
    plt.title('Frequency Domain Response')
    plt.grid(True, alpha=0.3)
    
    # Plot 9: System Summary
    ax9 = plt.subplot(3, 3, 9)
    
    # Create summary text
    summary_text = f"""CONTROL SYSTEM SUMMARY
    
    🎯 Final Energy: {results['performance']['final_energy']:.2e} J/m³
    📊 Constraint Satisfaction: {results['performance']['energy_satisfaction_rate']:.1%}
    🔄 Disturbance Rejection: {results['performance']['disturbance_rejection_db']:.1f} dB
    ⚡ Avg Control Effort: {results['performance']['controller']['average_control_effort']:.1e}
    🔧 Actuator Utilization: {np.mean([s.get('utilization_rate', 0) for s in results['performance']['actuator_network']['actuator_status'].values()]):.1%}
    
    ✅ System Status: {'OPTIMAL' if results['performance']['energy_satisfaction_rate'] > 0.95 else 'GOOD' if results['performance']['energy_satisfaction_rate'] > 0.8 else 'NEEDS_TUNING'}
    """
    
    ax9.text(0.05, 0.95, summary_text, transform=ax9.transAxes, fontsize=10,
             verticalalignment='top', fontfamily='monospace',
             bbox=dict(boxstyle='round', facecolor='lightblue', alpha=0.8))
    ax9.set_xlim(0, 1)
    ax9.set_ylim(0, 1)
    ax9.axis('off')
    
    plt.tight_layout()
    plt.savefig('integrated_control_demonstration.png', dpi=300, bbox_inches='tight')
    plt.show()
    
    print("   📊 Visualization saved to 'integrated_control_demonstration.png'")

def run_comprehensive_demonstration():
    """Run complete demonstration of integrated control system."""
    
    print("🚀 COMPREHENSIVE CLOSED-LOOP CONTROL DEMONSTRATION")
    print("=" * 60)
    print("Demonstrating sensor-controller-actuator integration for negative energy control")
    
    # 1. Initialize integrated system
    components = create_integrated_control_loop()
    
    # 2. Run multiple disturbance scenarios
    scenarios = ["burst", "continuous", "step"]
    results = {}
    
    for scenario in scenarios:
        print(f"\n{len(results)+1}️⃣  Running {scenario} disturbance scenario...")
        results[scenario] = run_integrated_simulation(
            components, 
            duration=3e-6,  # 3 microseconds
            disturbance_scenario=scenario
        )
    
    # 3. Compare scenarios
    print(f"\n📊 SCENARIO COMPARISON")
    print("=" * 25)
    
    best_scenario = None
    best_satisfaction = 0
    
    for scenario, result in results.items():
        satisfaction = result['performance']['energy_satisfaction_rate']
        rejection = result['performance']['disturbance_rejection_db']
        final_energy = result['performance']['final_energy']
        
        print(f"\n{scenario.upper()} Scenario:")
        print(f"   • Energy satisfaction: {satisfaction:.1%}")
        print(f"   • Disturbance rejection: {rejection:.1f} dB")
        print(f"   • Final energy: {final_energy:.2e}")
        
        if satisfaction > best_satisfaction:
            best_satisfaction = satisfaction
            best_scenario = scenario
    
    # 4. Create detailed visualization for best scenario
    print(f"\n📊 Creating detailed visualization for {best_scenario} scenario...")
    create_comprehensive_visualization(results[best_scenario])
    
    # 5. Performance summary
    print(f"\n🎯 FINAL PERFORMANCE SUMMARY")
    print("=" * 35)
    
    best_result = results[best_scenario]
    controller_perf = best_result['performance']['controller']
    
    print(f"🏆 Best performing scenario: {best_scenario.upper()}")
    print(f"   • Energy constraint satisfaction: {best_result['performance']['energy_satisfaction_rate']:.1%}")
    print(f"   • Disturbance rejection capability: {best_result['performance']['disturbance_rejection_db']:.1f} dB")
    print(f"   • Control effort efficiency: {controller_perf['average_control_effort']:.2e}")
    print(f"   • Final energy state: {best_result['performance']['final_energy']:.2e} J/m³")
    
    print(f"\n🔧 System Integration Status:")
    print(f"   ✅ State-space model: {components['system'].n_states} states, controllable & observable")
    print(f"   ✅ Sensor system: μrad phase + mK temperature resolution")
    print(f"   ✅ Control system: Hybrid H∞/MPC with {controller_perf['total_control_calls']} commands")
    print(f"   ✅ Actuator network: {len(components['actuator_network'].actuators)} actuators operational")
    
    violations = controller_perf.get('energy_violation_rate', 0)
    saturation = controller_perf.get('control_saturation_rate', 0)
    
    if violations < 0.05 and saturation < 0.1:
        status = "🚀 DEPLOYMENT READY"
    elif violations < 0.15 and saturation < 0.25:
        status = "✅ OPERATIONAL WITH MONITORING"
    else:
        status = "⚠️  REQUIRES TUNING"
    
    print(f"\n{status}")
    print(f"   • Energy violation rate: {violations:.1%}")
    print(f"   • Control saturation rate: {saturation:.1%}")
    
    return {
        'components': components,
        'results': results,
        'best_scenario': best_scenario,
        'summary': {
            'deployment_ready': violations < 0.05 and saturation < 0.1,
            'energy_satisfaction': best_result['performance']['energy_satisfaction_rate'],
            'disturbance_rejection_db': best_result['performance']['disturbance_rejection_db'],
            'final_energy': best_result['performance']['final_energy']
        }
    }

if __name__ == "__main__":
    print("🔄 Closed-Loop Feedback Control Demonstration")
    print("=" * 55)
    print("Complete sensor-controller-actuator integration for negative energy control")
    print()
    
    try:
        # Run comprehensive demonstration
        demo_results = run_comprehensive_demonstration()
        
        print(f"\n🎉 DEMONSTRATION COMPLETE!")
        print("=" * 30)
        
        if demo_results['summary']['deployment_ready']:
            print("🚀 System ready for hardware deployment!")
        else:
            print("✅ System operational - monitoring recommended")
        
        print(f"\n📄 Files Generated:")
        print("   📊 integrated_control_demonstration.png - Complete analysis")
        
        print(f"\n🔬 Technical Achievement:")
        print(f"   • Real-time feedback control at GHz frequencies")
        print(f"   • Negative energy constraint maintenance: {demo_results['summary']['energy_satisfaction']:.1%}")
        print(f"   • Disturbance rejection: {demo_results['summary']['disturbance_rejection_db']:.1f} dB")
        print(f"   • Final energy state: {demo_results['summary']['final_energy']:.2e} J/m³")
        
    except Exception as e:
        print(f"❌ Demonstration failed: {e}")
        import traceback
        traceback.print_exc()