#!/usr/bin/env python3 """ Range Safety System for Launch Operations Comprehensive range safety protocols, zone monitoring, and automated checks. Skills: general engineering Type: implementation Version: 1.0 Author: Starlight Launch Systems """ import json import math import datetime import hashlib from typing import Dict, List, Optional, Any, Union, Tuple from dataclasses import dataclass, asdict from enum import Enum class SafetyZoneType(Enum): LAUNCH_ZONE = "LAUNCH_ZONE" DANGER_ZONE = "DANGER_ZONE" EXCLUSION_ZONE = "EXCLUSION_ZONE" DOWNRANGE_AREA = "DOWNRANGE_AREA" class SafetySystemStatus(Enum): ACTIVE = "ACTIVE" INACTIVE = "INACTIVE" DEGRADED = "DEGRADED" FAILURE = "FAILURE" class AlertLevel(Enum): INFO = "INFO" WARNING = "WARNING" CRITICAL = "CRITICAL" @dataclass class SafetyZone: zone_id: str zone_type: SafetyZoneType center_lat: float center_lon: float radius_km: float clearance_time_min: int is_clear: bool = False cleared_time: Optional[str] = None unauthorized_vehicles: List[str] = None @dataclass class TrackingSystem: system_id: str name: str status: SafetySystemStatus coverage_area: Tuple[float, float, float, float] # lat_min, lon_min, lat_max, lon_max tracking_accuracy: float # meters last_update: str tracked_objects: List[Dict] = None @dataclass class SafetyAlert: alert_id: str level: AlertLevel system: str message: str timestamp: str resolved: bool = False resolution_time: Optional[str] = None @dataclass class DestructCommand: command_id: str system_name: str status: SafetySystemStatus last_test: str confidence: float # 0-100% arming_status: str class RangeSafetySystem: def __init__(self): self.safety_zones = self._initialize_safety_zones() self.tracking_systems = self._initialize_tracking_systems() self.destruct_systems = self._initialize_destruct_systems() self.safety_alerts = [] self.range_clearance_status = False self.monitoring_active = False self.last_full_check = None def _initialize_safety_zones(self) -> Dict[str, SafetyZone]: """Initialize all safety zones for the launch range.""" zones = { "launch_pad": SafetyZone( zone_id="launch_pad", zone_type=SafetyZoneType.LAUNCH_ZONE, center_lat=28.5721, # Kennedy Space Center area center_lon=-80.6480, radius_km=1.5, clearance_time_min=60 ), "danger_area": SafetyZone( zone_id="danger_area", zone_type=SafetyZoneType.DANGER_ZONE, center_lat=28.5721, center_lon=-80.6480, radius_km=5.0, clearance_time_min=45 ), "exclusion_zone": SafetyZone( zone_id="exclusion_zone", zone_type=SafetyZoneType.EXCLUSION_ZONE, center_lat=28.5721, center_lon=-80.6480, radius_km=25.0, clearance_time_min=30 ), "downrange_1": SafetyZone( zone_id="downrange_1", zone_type=SafetyZoneType.DOWNRANGE_AREA, center_lat=29.0, center_lon=-78.0, radius_km=10.0, clearance_time_min=15 ), "downrange_2": SafetyZone( zone_id="downrange_2", zone_type=SafetyZoneType.DOWNRANGE_AREA, center_lat=30.0, center_lon=-75.0, radius_km=15.0, clearance_time_min=10 ) } return zones def _initialize_tracking_systems(self) -> Dict[str, TrackingSystem]: """Initialize all tracking and monitoring systems.""" systems = { "radar_primary": TrackingSystem( system_id="radar_primary", name="Primary Tracking Radar", status=SafetySystemStatus.ACTIVE, coverage_area=(27.0, -82.0, 30.0, -77.0), tracking_accuracy=10.0, last_update=datetime.datetime.now().isoformat() ), "radar_secondary": TrackingSystem( system_id="radar_secondary", name="Secondary Tracking Radar", status=SafetySystemStatus.ACTIVE, coverage_area=(27.5, -81.0, 29.5, -78.0), tracking_accuracy=15.0, last_update=datetime.datetime.now().isoformat() ), "telemetry_main": TrackingSystem( system_id="telemetry_main", name="Main Telemetry System", status=SafetySystemStatus.ACTIVE, coverage_area=(27.0, -82.0, 35.0, -70.0), tracking_accuracy=5.0, last_update=datetime.datetime.now().isoformat() ), "optical_tracking": TrackingSystem( system_id="optical_tracking", name="Optical Tracking System", status=SafetySystemStatus.ACTIVE, coverage_area=(28.0, -81.0, 29.0, -79.0), tracking_accuracy=2.0, last_update=datetime.datetime.now().isoformat() ), "weather_radar": TrackingSystem( system_id="weather_radar", name="Weather Monitoring Radar", status=SafetySystemStatus.ACTIVE, coverage_area=(25.0, -85.0, 32.0, -75.0), tracking_accuracy=100.0, last_update=datetime.datetime.now().isoformat() ) } return systems def _initialize_destruct_systems(self) -> Dict[str, DestructCommand]: """Initialize flight termination and destruct systems.""" systems = { "flight_termination": DestructCommand( command_id="ft_system", system_name="Flight Termination System", status=SafetySystemStatus.ACTIVE, last_test=datetime.datetime.now().isoformat(), confidence=98.5, arming_status="STANDBY" ), "range_safety_destruct": DestructCommand( command_id="rs_destruct", system_name="Range Safety Destruct", status=SafetySystemStatus.ACTIVE, last_test=datetime.datetime.now().isoformat(), confidence=96.2, arming_status="SAFE" ), "explosive_ordnance": DestructCommand( command_id="eo_system", system_name="Explosive Ordnance System", status=SafetySystemStatus.ACTIVE, last_test=datetime.datetime.now().isoformat(), confidence=99.1, arming_status="DISARMED" ) } return systems def start_range_monitoring(self) -> Dict[str, Any]: """Start comprehensive range safety monitoring.""" self.monitoring_active = True # Perform initial systems check check_result = self.perform_full_systems_check() return { "monitoring_started": True, "timestamp": datetime.datetime.now().isoformat(), "initial_check": check_result } def stop_range_monitoring(self) -> Dict[str, Any]: """Stop range safety monitoring.""" self.monitoring_active = False return { "monitoring_stopped": True, "timestamp": datetime.datetime.now().isoformat() } def clear_safety_zone(self, zone_id: str) -> Dict[str, Any]: """Clear a specific safety zone for launch.""" if zone_id not in self.safety_zones: return {"error": f"Zone {zone_id} not found"} zone = self.safety_zones[zone_id] # Simulate zone clearance verification unauthorized_count = len(zone.unauthorized_vehicles) if zone.unauthorized_vehicles else 0 if unauthorized_count == 0: zone.is_clear = True zone.cleared_time = datetime.datetime.now().isoformat() zone.unauthorized_vehicles = [] return { "zone_cleared": True, "zone_id": zone_id, "cleared_time": zone.cleared_time } else: return { "zone_cleared": False, "zone_id": zone_id, "unauthorized_count": unauthorized_count, "message": f"Zone contains {unauthorized_count} unauthorized vehicles" } def update_tracking_system_status(self, system_id: str, status: SafetySystemStatus, tracked_objects: List[Dict] = None) -> Dict[str, Any]: """Update tracking system status and object data.""" if system_id not in self.tracking_systems: return {"error": f"Tracking system {system_id} not found"} system = self.tracking_systems[system_id] system.status = status system.last_update = datetime.datetime.now().isoformat() if tracked_objects: system.tracked_objects = tracked_objects return { "system_updated": True, "system_id": system_id, "new_status": status.value, "tracked_objects_count": len(tracked_objects) if tracked_objects else 0 } def arm_destruct_system(self, system_id: str, confidence_threshold: float = 95.0) -> Dict[str, Any]: """Arm a destruct system for launch operations.""" if system_id not in self.destruct_systems: return {"error": f"Destruct system {system_id} not found"} system = self.destruct_systems[system_id] if system.confidence < confidence_threshold: alert_id = hashlib.md5(f"destruct_confidence{system_id}{datetime.datetime.now().isoformat()}".encode()).hexdigest()[:8] self.safety_alerts.append(SafetyAlert( alert_id=alert_id, level=AlertLevel.WARNING, system=system_id, message=f"Destruct system confidence {system.confidence}% below threshold {confidence_threshold}%", timestamp=datetime.datetime.now().isoformat() )) return { "system_armed": False, "system_id": system_id, "reason": "Confidence below threshold", "confidence": system.confidence } system.arming_status = "ARMED" return { "system_armed": True, "system_id": system_id, "arming_status": system.arming_status, "confidence": system.confidence } def perform_full_systems_check(self) -> Dict[str, Any]: """Perform comprehensive range safety systems check.""" check_time = datetime.datetime.now() # Check safety zones zones_status = {} all_zones_clear = True for zone_id, zone in self.safety_zones.items(): zones_status[zone_id] = { "clear": zone.is_clear, "cleared_time": zone.cleared_time, "unauthorized_vehicles": len(zone.unauthorized_vehicles) if zone.unauthorized_vehicles else 0 } if not zone.is_clear: all_zones_clear = False # Check tracking systems tracking_status = {} all_tracking_active = True for system_id, system in self.tracking_systems.items(): tracking_status[system_id] = { "status": system.status.value, "last_update": system.last_update, "tracking_accuracy": system.tracking_accuracy } if system.status != SafetySystemStatus.ACTIVE: all_tracking_active = False # Check destruct systems destruct_status = {} all_destruct_ready = True for system_id, system in self.destruct_systems.items(): destruct_status[system_id] = { "status": system.status.value, "confidence": system.confidence, "arming_status": system.arming_status, "last_test": system.last_test } if system.status != SafetySystemStatus.ACTIVE or system.confidence < 95.0: all_destruct_ready = False # Overall range readiness range_ready = all_zones_clear and all_tracking_active and all_destruct_ready self.last_full_check = { "timestamp": check_time.isoformat(), "zones_clear": all_zones_clear, "tracking_active": all_tracking_active, "destruct_ready": all_destruct_ready, "range_ready": range_ready, "zones_status": zones_status, "tracking_status": tracking_status, "destruct_status": destruct_status, "active_alerts": len([a for a in self.safety_alerts if not a.resolved]) } return self.last_full_check def create_safety_alert(self, level: AlertLevel, system: str, message: str) -> str: """Create a new safety alert.""" alert_id = hashlib.md5(f"{system}{message}{datetime.datetime.now().isoformat()}".encode()).hexdigest()[:8] alert = SafetyAlert( alert_id=alert_id, level=level, system=system, message=message, timestamp=datetime.datetime.now().isoformat() ) self.safety_alerts.append(alert) return alert_id def resolve_safety_alert(self, alert_id: str) -> bool: """Resolve a safety alert.""" for alert in self.safety_alerts: if alert.alert_id == alert_id: alert.resolved = True alert.resolution_time = datetime.datetime.now().isoformat() return True return False def get_range_safety_summary(self) -> Dict[str, Any]: """Get comprehensive range safety status summary.""" active_alerts = [a for a in self.safety_alerts if not a.resolved] summary = { "monitoring_active": self.monitoring_active, "range_clearance_status": self.range_clearance_status, "safety_zones": { "total": len(self.safety_zones), "cleared": len([z for z in self.safety_zones.values() if z.is_clear]) }, "tracking_systems": { "total": len(self.tracking_systems), "active": len([s for s in self.tracking_systems.values() if s.status == SafetySystemStatus.ACTIVE]) }, "destruct_systems": { "total": len(self.destruct_systems), "armed": len([s for s in self.destruct_systems.values() if s.arming_status == "ARMED"]) }, "safety_alerts": { "total": len(self.safety_alerts), "active": len(active_alerts), "critical": len([a for a in active_alerts if a.level == AlertLevel.CRITICAL]), "warning": len([a for a in active_alerts if a.level == AlertLevel.WARNING]) }, "last_full_check": self.last_full_check } return summary def main(): """Main execution function for range safety system.""" print("🛡️ Initializing Starlight Range Safety System") # Initialize range safety range_safety = RangeSafetySystem() # Start monitoring monitoring_result = range_safety.start_range_monitoring() print("✅ Range safety monitoring started") # Clear safety zones clear_zones = ["launch_pad", "danger_area", "exclusion_zone"] for zone in clear_zones: result = range_safety.clear_safety_zone(zone) if result.get("zone_cleared"): print(f"🟢 Zone {zone}: CLEARED") else: print(f"🔴 Zone {zone}: NOT CLEARED - {result.get('message', 'Unknown issue')}") # Update tracking systems with simulated data tracked_objects = [ {"id": "launch_vehicle", "type": "rocket", "lat": 28.5721, "lon": -80.6480, "altitude": 0}, {"id": "chase_plane_1", "type": "aircraft", "lat": 28.6000, "lon": -80.7000, "altitude": 10000} ] for system_id in ["radar_primary", "telemetry_main"]: result = range_safety.update_tracking_system_status( system_id, SafetySystemStatus.ACTIVE, tracked_objects ) print(f"📡 Tracking {system_id}: {result['new_status']} ({result['tracked_objects_count']} objects)") # Arm destruct systems for system_id in ["flight_termination", "range_safety_destruct"]: result = range_safety.arm_destruct_system(system_id) if result.get("system_armed"): print(f"⚠️ Destruct {system_id}: ARMED") else: print(f"❌ Destruct {system_id}: FAILED - {result.get('reason', 'Unknown')}") # Perform full systems check full_check = range_safety.perform_full_systems_check() print(f"🔍 Full Systems Check: {'✅ RANGE READY' if full_check['range_ready'] else '❌ RANGE NOT READY'}") # Get summary summary = range_safety.get_range_safety_summary() print(f"📊 Safety Zones Clear: {summary['safety_zones']['cleared']}/{summary['safety_zones']['total']}") print(f"📡 Tracking Systems Active: {summary['tracking_systems']['active']}/{summary['tracking_systems']['total']}") print(f"⚠️ Destruct Systems Armed: {summary['destruct_systems']['armed']}/{summary['destruct_systems']['total']}") print(f"🚨 Active Safety Alerts: {summary['safety_alerts']['active']}") # Save range safety data safety_data = { "summary": summary, "full_check": full_check, "timestamp": datetime.datetime.now().isoformat() } with open("range_safety_data.json", "w") as f: json.dump(safety_data, f, indent=2) print("💾 Range safety data saved to range_safety_data.json") print("🎯 Range Safety System Complete!") if __name__ == "__main__": main()