kishorkukreja/awesome-supply-chain/aerospace-supply-chain

Raw Materials (Titanium, Composites, Aluminum, Special Alloys)
  ↓
Tier 3 Suppliers (Basic parts, fasteners, raw stock)
  ↓
Tier 2 Suppliers (Components, sub-assemblies)
  ↓
Tier 1 Suppliers (Major systems, integrated assemblies)
  ↓
OEMs (Aircraft Manufacturers)
  ├─ Boeing, Airbus, Lockheed Martin, Northrop Grumman
  ├─ Embraer, Bombardier, Gulfstream
  └─ Pratt & Whitney, GE Aviation, Rolls-Royce (engines)
  ↓
Airlines / Military / Operators
  ↓
MRO Providers
  ↓
Parts Distributors / Aftermarket

import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import networkx as nx
class AerospaceProgramPlanner:
    """
    Manage long lead-time aerospace program planning
    """
    def __init__(self, aircraft_program):
        """
        Initialize program planner
        Parameters:
        - aircraft_program: program details (platform, rate, start date)
        """
        self.program = aircraft_program
    def analyze_critical_path(self, bom_df, supplier_lead_times):
        """
        Analyze critical path for aircraft production
        Parameters:
        - bom_df: Bill of Materials with assembly tree
        - supplier_lead_times: lead times by part number
        Returns:
        - critical path analysis with longest lead time items
        """
        # Build assembly dependency graph
        G = nx.DiGraph()
        for idx, part in bom_df.iterrows():
            part_number = part['part_number']
            parent = part.get('parent_assembly', 'FINAL_ASSEMBLY')
            # Get lead time
            lead_time_weeks = supplier_lead_times.get(part_number, 52)
            G.add_node(part_number, lead_time=lead_time_weeks)
            G.add_edge(parent, part_number)
        # Calculate critical path
        critical_items = []
        for part in bom_df['part_number']:
            # Find longest path from this part to final assembly
            try:
                path_length = nx.shortest_path_length(
                    G, source=part, target='FINAL_ASSEMBLY'
                )
                # Cumulative lead time
                path = nx.shortest_path(G, source=part, target='FINAL_ASSEMBLY')
                cumulative_lt = sum(G.nodes[p].get('lead_time', 0) for p in path)
                critical_items.append({
                    'part_number': part,
                    'lead_time_weeks': G.nodes[part].get('lead_time', 0),
                    'levels_to_assembly': path_length,
                    'cumulative_lead_time_weeks': cumulative_lt,
                    'is_critical_path': cumulative_lt > 52  # >1 year
                })
            except:
                pass
        critical_analysis = pd.DataFrame(critical_items).sort_values(
            'cumulative_lead_time_weeks', ascending=False
        )
        return critical_analysis
    def calculate_procurement_schedule(self, production_schedule, critical_items):
        """
        Calculate when to order long lead-time components
        Parameters:
        - production_schedule: aircraft delivery schedule
        - critical_items: parts with cumulative lead times
        Returns:
        - procurement schedule by part
        """
        procurement_schedule = []
        for idx, aircraft in production_schedule.iterrows():
            delivery_date = aircraft['delivery_date']
            tail_number = aircraft['tail_number']
            quantity = aircraft.get('quantity', 1)
            for _, item in critical_items.iterrows():
                part_number = item['part_number']
                cumulative_lt_weeks = item['cumulative_lead_time_weeks']
                # Add safety buffer (typically 4-8 weeks)
                safety_buffer_weeks = 8
                total_lt_weeks = cumulative_lt_weeks + safety_buffer_weeks
                # Calculate order date
                order_date = delivery_date - timedelta(weeks=total_lt_weeks)
                procurement_schedule.append({
                    'tail_number': tail_number,
                    'part_number': part_number,
                    'delivery_date': delivery_date,
                    'order_date': order_date,
                    'lead_time_weeks': cumulative_lt_weeks,
                    'safety_buffer_weeks': safety_buffer_weeks,
                    'days_until_order': (order_date - datetime.now()).days,
                    'urgency': self._classify_urgency(
                        (order_date - datetime.now()).days
                    )
                })
        return pd.DataFrame(procurement_schedule).sort_values('order_date')
    def _classify_urgency(self, days_until_order):
        """Classify procurement urgency"""
        if days_until_order < 0:
            return 'overdue'
        elif days_until_order < 30:
            return 'urgent'
        elif days_until_order < 90:
            return 'normal'
        else:
            return 'future'
    def manage_production_rate_change(self, current_rate, target_rate,
                                     inventory_position, lead_times):
        """
        Manage supply chain through production rate changes
        Parameters:
        - current_rate: current aircraft per month
        - target_rate: target aircraft per month
        - inventory_position: current inventory levels
        - lead_times: component lead times
        Returns:
        - transition plan with inventory adjustments
        """
        rate_change_pct = (target_rate - current_rate) / current_rate
        transition_plan = {
            'current_rate_per_month': current_rate,
            'target_rate_per_month': target_rate,
            'rate_change_pct': rate_change_pct * 100,
            'transition_duration_months': abs(rate_change_pct) * 12,  # Longer for bigger changes
            'inventory_actions': []
        }
        # Determine inventory actions
        if rate_change_pct > 0:
            # Rate increase - need more inventory
            transition_plan['inventory_actions'] = [
                'increase_safety_stock_by_25pct',
                'advance_long_lead_orders_by_4_weeks',
                'negotiate_supplier_capacity_increases',
                'pre_build_inventory_for_critical_parts',
                'dual_source_bottleneck_components'
            ]
            # Calculate inventory investment needed
            avg_part_value = 50000  # Placeholder
            parts_per_aircraft = 500000
            months_of_buffer = 2
            additional_inventory_value = (
                (target_rate - current_rate) * months_of_buffer *
                parts_per_aircraft * avg_part_value / parts_per_aircraft
            )
            transition_plan['inventory_investment_usd'] = additional_inventory_value
        else:
            # Rate decrease - reduce inventory
            transition_plan['inventory_actions'] = [
                'reduce_safety_stock_gradually',
                'defer_non_critical_orders',
                'negotiate_supplier_volume_reductions',
                'assess_excess_and_obsolete_risk',
                'slow_down_receipts_timing'
            ]
            # Calculate potential excess
            months_of_excess = abs(rate_change_pct) * 6
            excess_inventory_risk = (
                (current_rate - target_rate) * months_of_excess * 100000
            )
            transition_plan['excess_inventory_risk_usd'] = excess_inventory_risk
        return transition_plan
# Example usage
program = {'name': 'Narrow_Body_Program', 'platform': 'A320', 'rate_per_month': 50}
bom = pd.DataFrame({
    'part_number': ['WING_ASSY', 'FUSELAGE', 'ENGINE_1', 'LANDING_GEAR'],
    'parent_assembly': ['FINAL_ASSEMBLY', 'FINAL_ASSEMBLY', 'FINAL_ASSEMBLY', 'FINAL_ASSEMBLY']
})
lead_times = {
    'WING_ASSY': 78,  # 18 months
    'FUSELAGE': 52,   # 12 months
    'ENGINE_1': 104,  # 24 months
    'LANDING_GEAR': 65  # 15 months
}
planner = AerospaceProgramPlanner(program)
critical_path = planner.analyze_critical_path(bom, lead_times)
print("Critical Path Analysis:")
print(critical_path[['part_number', 'lead_time_weeks', 'cumulative_lead_time_weeks', 'is_critical_path']])

class AerospaceQualityManager:
    """
    Manage AS9100 quality and aerospace certification requirements
    """
    def __init__(self):
        self.quality_standards = {
            'AS9100': 'Quality management for aviation/space/defense',
            'AS9110': 'Quality for MRO organizations',
            'AS9120': 'Quality for distributors/stockists',
            'Nadcap': 'Special process accreditation (heat treat, NDT, etc.)'
        }
    def assess_supplier_quality(self, supplier_details):
        """
        Assess supplier quality capabilities and certifications
        Parameters:
        - supplier_details: supplier info and certifications
        Returns:
        - quality assessment and approval status
        """
        required_certs = supplier_details.get('required_certifications', [])
        actual_certs = supplier_details.get('current_certifications', [])
        assessment = {
            'supplier': supplier_details['name'],
            'supplier_type': supplier_details.get('type', 'component'),
            'certifications_required': required_certs,
            'certifications_held': actual_certs,
            'gaps': list(set(required_certs) - set(actual_certs)),
            'quality_score': 0,
            'approved': False
        }
        # Check certifications
        if 'AS9100' in required_certs:
            if 'AS9100' in actual_certs:
                assessment['quality_score'] += 40
            else:
                assessment['gaps'].append('AS9100_required')