aerospace-expert

name	aerospace-expert
version	1.0.0
description	Expert-level aerospace systems, flight management, maintenance tracking, aviation safety, and aerospace software
category	domains
tags	["aerospace","aviation","flight","maintenance","safety","atc"]
allowed-tools	["Read","Write","Edit"]

Aerospace Expert

Expert guidance for aerospace systems, flight management, maintenance tracking, aviation safety, air traffic control systems, and aerospace software development.

Core Concepts

Aerospace Systems

• Flight Management Systems (FMS)
• Maintenance, Repair, and Overhaul (MRO)
• Air Traffic Control (ATC) systems
• Aircraft Health Monitoring
• Flight Operations Quality Assurance (FOQA)
• Crew resource management
• Ground handling systems

Aviation Technologies

• Avionics systems
• ACARS (Aircraft Communications Addressing and Reporting System)
• ADS-B (Automatic Dependent Surveillance-Broadcast)
• Flight data recorders (black boxes)
• Weather radar systems
• Autopilot and fly-by-wire
• Satellite communications

Standards and Regulations

• FAA regulations (Federal Aviation Administration)
• EASA standards (European Union Aviation Safety Agency)
• ICAO standards (International Civil Aviation Organization)
• DO-178C (software airworthiness)
• DO-254 (hardware airworthiness)
• SPEC-42 (maintenance tracking)
• ATA chapters (maintenance organization)

Flight Management System

from dataclasses import dataclass
from datetime import datetime, timedelta
from typing import List, Optional, Tuple
from decimal import Decimal
from enum import Enum
import numpy as np

class FlightPhase(Enum):
    PRE_FLIGHT = "pre_flight"
    TAXI = "taxi"
    TAKEOFF = "takeoff"
    CLIMB = "climb"
    CRUISE = "cruise"
    DESCENT = "descent"
    APPROACH = "approach"
    LANDING = "landing"
    COMPLETED = "completed"

class FlightStatus(Enum):
    SCHEDULED = "scheduled"
    BOARDING = "boarding"
    DEPARTED = "departed"
    EN_ROUTE = "en_route"
    DELAYED = "delayed"
    ARRIVED = "arrived"
    CANCELLED = "cancelled"

@dataclass
class Waypoint:
    """Navigation waypoint"""
    name: str
    latitude: float
    longitude: float
    altitude_ft: int
    estimated_time: datetime

@dataclass
class Flight:
    
    flight_number: 
    aircraft_id: 
    aircraft_type: 
    departure_airport: 
    arrival_airport: 
    scheduled_departure: datetime
    scheduled_arrival: datetime
    actual_departure: [datetime]
    actual_arrival: [datetime]
    status: FlightStatus
    route: [Waypoint]
    crew_members: []
    passenger_count: 
    cargo_weight_kg: 


 :
    
    flight_plan_id: 
    flight_number: 
    aircraft_id: 
    departure: 
    destination: 
    alternate_airports: []
    route_string: 
    cruise_altitude_ft: 
    cruise_speed_kts: 
    estimated_flight_time: timedelta
    fuel_required_kg: 
    filed_at: datetime

 :
    

     ():
        .flights = {}
        .flight_plans = {}
        .aircraft_positions = {}

     () -> FlightPlan:
        
        flight_plan_id = ._generate_flight_plan_id()

        
        route = ._calculate_optimal_route(
            flight_data[],
            flight_data[],
            flight_data[]
        )

        
        fuel_required = ._calculate_fuel_requirements(
            route[],
            flight_data[],
            flight_data.get(, ),
            flight_data.get(, )
        )

        flight_plan = FlightPlan(
            flight_plan_id=flight_plan_id,
            flight_number=flight_data[],
            aircraft_id=flight_data[],
            departure=flight_data[],
            destination=flight_data[],
            alternate_airports=flight_data.get(, []),
            route_string=route[],
            cruise_altitude_ft=route[],
            cruise_speed_kts=route[],
            estimated_flight_time=route[],
            fuel_required_kg=fuel_required,
            filed_at=datetime.now()
        )

        .flight_plans[flight_plan_id] = flight_plan

        
        ._file_with_atc(flight_plan)

         flight_plan

     () -> :
        
        
        dep_coords = ._get_airport_coordinates(departure)
        dest_coords = ._get_airport_coordinates(destination)

        
        distance_nm = ._calculate_distance(dep_coords, dest_coords)

        
         distance_nm < :
            cruise_altitude =   
         distance_nm < :
            cruise_altitude =   
        :
            cruise_altitude =   

        
        cruise_speeds = {
            : ,   
            : ,
            : ,
            : 
        }
        cruise_speed = cruise_speeds.get(aircraft_type, )

        
        flight_time_hours = distance_nm / cruise_speed
        estimated_time = timedelta(hours=flight_time_hours)

        
        route_string = 

         {
            : distance_nm,
            : cruise_altitude,
            : cruise_speed,
            : estimated_time,
            : route_string
        }

     () -> :
        
        
        fuel_rates = {
            : ,
            : ,
            : ,
            : 
        }

        base_rate = fuel_rates.get(aircraft_type, )

        
        trip_fuel = distance_nm * base_rate

        
        weight_penalty = (passengers *  + cargo_kg) /  * trip_fuel * 

        
        reserve_fuel = base_rate *  *   

        
        contingency_fuel = trip_fuel * 

        
        alternate_fuel =  * base_rate  

        total_fuel = trip_fuel + weight_penalty + reserve_fuel + contingency_fuel + alternate_fuel

         total_fuel

     () -> :
        
        flight = .flights.get(flight_number)
          flight:
             {: }

        
        current_position = .aircraft_positions.get(flight.aircraft_id)

          current_position:
             {
                : flight_number,
                : flight.status.value,
                : 
            }

        
        total_distance = ._calculate_distance(
            ._get_airport_coordinates(flight.departure_airport),
            ._get_airport_coordinates(flight.arrival_airport)
        )

        distance_from_origin = ._calculate_distance(
            ._get_airport_coordinates(flight.departure_airport),
            (current_position[], current_position[])
        )

        progress_percent = (distance_from_origin / total_distance) * 

        
         current_position.get(, ) > :
            distance_remaining = total_distance - distance_from_origin
            time_remaining_hours = distance_remaining / current_position[]
            eta = datetime.now() + timedelta(hours=time_remaining_hours)
        :
            eta = flight.scheduled_arrival

         {
            : flight_number,
            : flight.status.value,
            : {
                : current_position[],
                : current_position[],
                : current_position[],
                : current_position[]
            },
            : progress_percent,
            : total_distance - distance_from_origin,
            : eta.isoformat(),
            : eta <= flight.scheduled_arrival
        }

     () -> :
        
        
        base_distances = {
            : ,  
            : ,
            : ,
            : 
        }

        base_distance = base_distances.get(aircraft_type, )

        
        wind_angle = (wind_direction - runway_heading)
        headwind = wind_speed_kts * np.cos(np.radians(wind_angle))
        crosswind = wind_speed_kts * np.sin(np.radians(wind_angle))

        
        
        
         headwind > :  
            distance_adjustment = - * (headwind / )
        :  
            distance_adjustment =  * ((headwind) / )

        
        isa_temp =  - (altitude_ft /  * )  
        temp_deviation = temperature_c - isa_temp
        temp_adjustment = temp_deviation *   

        
        adjustments =  + distance_adjustment + temp_adjustment
        required_distance = base_distance * adjustments

        
        safety_factor = 
        required_distance_with_margin = required_distance * safety_factor

        
        runway_adequate = runway_length_ft >= required_distance_with_margin

         {
            : aircraft_type,
            : (required_distance_with_margin),
            : runway_length_ft,
            : runway_adequate,
            : runway_length_ft - required_distance_with_margin,
            : {
                : headwind,
                : crosswind,
                : temperature_c,
                : altitude_ft
            }
        }

     () -> :
        
         math  radians, sin, cos, sqrt, atan2

        lat1, lon1 = radians(point1[]), radians(point1[])
        lat2, lon2 = radians(point2[]), radians(point2[])

        dlat = lat2 - lat1
        dlon = lon2 - lon1

        a = sin(dlat/)** + cos(lat1) * cos(lat2) * sin(dlon/)**
        c =  * atan2(sqrt(a), sqrt(-a))

        distance_km =  * c  
        distance_nm = distance_km *   

         distance_nm

     () -> [, ]:
        
        
        airports = {
            : (, -),  
            : (, -),  
            : (, -),    
            : (, )      
        }
         airports.get(icao_code, (, ))

     ():
        
        
        

     () -> :
         uuid
         

Aircraft Maintenance System

from enum import Enum

class MaintenanceType(Enum):
    A_CHECK = "a_check"  # Every 400-600 flight hours
    B_CHECK = "b_check"  # Every 6-8 months
    C_CHECK = "c_check"  # Every 18-24 months
    D_CHECK = "d_check"  # Every 6-10 years
    LINE_MAINTENANCE = "line_maintenance"
    UNSCHEDULED = "unscheduled"

@dataclass
class Aircraft:
    """Aircraft information"""
    aircraft_id: str
    registration: str
    aircraft_type: str
    manufacturer: str
    model: str
    serial_number: str
    manufacture_date: datetime
    total_flight_hours: float
    total_cycles: int  # Takeoff/landing cycles
    last_a_check: datetime
    last_c_check: datetime
    airworthiness_certificate: str
    next_major_inspection: datetime

@dataclass
class MaintenanceRecord:
    """Maintenance work record"""
    record_id: str
    aircraft_id: str
    maintenance_type: MaintenanceType
    work_performed: str
    components_replaced: List[str]
    performed_by: str
    performed_at: datetime
    flight_hours_at_maintenance: float
    cycles_at_maintenance: int
    next_due_hours: Optional[float]
    next_due_date: [datetime]

 :
    

     ():
        .aircraft = {}
        .maintenance_records = []
        .component_tracking = {}

     () -> :
        
        aircraft = .aircraft.get(aircraft_id)
          aircraft:
             {: }

        due_items = []

        
        hours_since_a_check = aircraft.total_flight_hours - ._get_last_check_hours(
            aircraft_id, MaintenanceType.A_CHECK
        )

         hours_since_a_check >= :
            due_items.append({
                : ,
                :   hours_since_a_check >=   ,
                : (, hours_since_a_check - )
            })

        
        days_since_c_check = (datetime.now() - aircraft.last_c_check).days

         days_since_c_check >= :  
            due_items.append({
                : ,
                :   days_since_c_check >=   ,
                : (, days_since_c_check - )
            })

        
        component_items = ._check_component_life_limits(aircraft_id)
        due_items.extend(component_items)

         {
            : aircraft_id,
            : aircraft.registration,
            : (due_items) > ,
            : due_items,
            : ([item  item  due_items  item[] == ]) == 
        }

     () -> :
        
        records = [
            r  r  .maintenance_records
             r.aircraft_id == aircraft_id  r.maintenance_type == check_type
        ]

         records:
            latest = (records, key= r: r.performed_at)
             latest.flight_hours_at_maintenance

         

     () -> []:
        
        due_items = []

        components = .component_tracking.get(aircraft_id, {})

         component_name, component_data  components.items():
             component_data[]:
                hours_used = component_data[]
                life_limit = component_data[]

                 hours_used >= life_limit * :  
                    due_items.append({
                        : ,
                        : component_name,
                        :   hours_used >= life_limit  ,
                        : (, life_limit - hours_used)
                    })

         due_items

     () -> MaintenanceRecord:
        
        aircraft = .aircraft.get(aircraft_id)
          aircraft:
             ValueError()

        record = MaintenanceRecord(
            record_id=._generate_record_id(),
            aircraft_id=aircraft_id,
            maintenance_type=MaintenanceType(maintenance_data[]),
            work_performed=maintenance_data[],
            components_replaced=maintenance_data.get(, []),
            performed_by=maintenance_data[],
            performed_at=datetime.now(),
            flight_hours_at_maintenance=aircraft.total_flight_hours,
            cycles_at_maintenance=aircraft.total_cycles,
            next_due_hours=maintenance_data.get(),
            next_due_date=maintenance_data.get()
        )

        .maintenance_records.append(record)

        
         record.maintenance_type == MaintenanceType.A_CHECK:
            aircraft.last_a_check = datetime.now()
         record.maintenance_type == MaintenanceType.C_CHECK:
            aircraft.last_c_check = datetime.now()

         record

     () -> :
        
        
        base_costs = {
            : {
                : ,  
                : ,
                : ,
                : 
            },
            : {
                : ,
                : ,
                : ,
                : 
            }
        }

        costs = base_costs.get(aircraft_type, base_costs[])

        
        hourly_maintenance = flight_hours_per_year * costs[]

        
        a_checks_per_year = flight_hours_per_year / 
        a_check_costs = a_checks_per_year * costs[]

        
        c_check_annual = costs[] / 

        
        d_check_annual = costs[] / 

        total_annual = hourly_maintenance + a_check_costs + c_check_annual + d_check_annual

         {
            : aircraft_type,
            : flight_hours_per_year,
            : {
                : hourly_maintenance,
                : a_check_costs,
                : c_check_annual,
                : d_check_annual,
                : total_annual
            },
            : total_annual / flight_hours_per_year
        }

     () -> :
         uuid
         

Aviation Safety Analysis

class AviationSafetySystem:
    """Flight safety and FOQA analysis"""

    def __init__(self):
        self.safety_reports = []
        self.foqa_events = []

    def analyze_flight_data(self, flight_data: dict) -> dict:
        """Analyze flight data for safety events (FOQA)"""
        events_detected = []

        # Check for hard landings
        if flight_data.get('landing_vertical_speed_fpm', 0) < -600:
            events_detected.append({
                'event_type': 'hard_landing',
                'severity': 'medium',
                'value': flight_data['landing_vertical_speed_fpm'],
                'threshold': -600
            })

        # Check for unstabilized approaches
        if flight_data.get('approach_speed_deviation_kts', 0) > 10:
            events_detected.append({
                'event_type': 'unstabilized_approach',
                'severity': 'high',
                'value': flight_data['approach_speed_deviation_kts'],
                'threshold': 10
            })

        # Check for altitude deviations
        if flight_data.get('altitude_deviation_ft', ) > :
            events_detected.append({
                : ,
                : ,
                : flight_data[],
                : 
            })

        
         flight_data.get(, ) > :
            events_detected.append({
                : ,
                : ,
                : flight_data[],
                : 
            })

        
        safety_score =  - ((events_detected) * )

         {
            : flight_data[],
            : events_detected,
            : (, safety_score),
            : (events_detected) > 
        }

     () -> :
        
        total_flights = (flights_data)
        total_hours = (f.get(, )  f  flights_data)

        
        safety_events = (
            (.analyze_flight_data(f)[])
             f  flights_data
        )

        
        event_rate = (safety_events / total_flights * )  total_flights >   

         {
            : total_flights,
            : total_hours,
            : safety_events,
            : event_rate,
            :   event_rate <  
                             event_rate <  
                           
        }

Best Practices

Flight Operations

• File complete and accurate flight plans
• Conduct thorough pre-flight checks
• Monitor fuel continuously
• Maintain communication with ATC
• Follow standard operating procedures (SOPs)
• Implement crew resource management
• Use automation appropriately

Maintenance Management

• Follow manufacturer maintenance schedules
• Track all component life limits
• Maintain detailed maintenance logs
• Use certified parts and technicians
• Implement predictive maintenance
• Conduct regular inspections
• Ensure airworthiness compliance

Safety Management

• Implement Safety Management System (SMS)
• Encourage safety reporting culture
• Analyze FOQA data regularly
• Conduct regular safety audits
• Maintain emergency procedures
• Train crew on CRM principles
• Track safety KPIs

Regulatory Compliance

• Maintain current certifications
• Follow DO-178C for software
• Implement quality management systems
• Conduct regular audits
• Maintain proper documentation
• Follow ATA chapter organization
• Ensure ETOPS compliance (if applicable)

Anti-Patterns

❌ Delaying required maintenance ❌ Poor flight planning ❌ Inadequate fuel reserves ❌ Ignoring weather conditions ❌ Poor crew communication ❌ No safety management system ❌ Inadequate record keeping ❌ Using uncertified parts ❌ Skipping pre-flight checks

Resources

• FAA: https://www.faa.gov/
• ICAO: https://www.icao.int/
• EASA: https://www.easa.europa.eu/
• IATA: https://www.iata.org/
• Flight Safety Foundation: https://flightsafety.org/
• FAA Airworthiness Directives: https://www.faa.gov/regulations_policies/airworthiness_directives/
• DO-178C Standard: https://www.rtca.org/