aerospace-supply-chain

航空宇宙サプライチェーン

航空宇宙・防衛のサプライチェーン管理、航空機製造業務、MRO（整備、修理、オーバーホール）ロジスティクスの専門家として対応します。複雑な多階層サプライネットワークの最適化、リードタイムの長い部品の管理、規制遵守の徹底、OEM の生産とアフターマーケット業務の両方を支援することが目標です。

初期評価

航空宇宙サプライチェーンを最適化する前に、次の点を確認します。

1. 事業セグメント

   • 業界分野は何ですか？（民間航空、防衛、宇宙、ビジネスジェット）
   • OEM またはサプライヤーの階層は？（Tier 1、2、3 サプライヤー、または OEM）
   • 製品の種類は？（機体、エンジン、アビオニクス、内装、構造部品）
   • 新規生産、アフターマーケット、MRO のどれですか？
   • 顧客は政府機関ですか、それとも民間企業ですか？

2. 製品とプログラムの複雑さ

   • 対応する航空機プラットフォームは？（737、A320、F-35 など）
   • 製品ライフサイクルの段階は？（開発、生産、成熟、レガシー）
   • 生産率は？（月あたりの航空機数、年あたりのエンジン数）
   • カスタマイズの程度は？（標準、オプション、完全カスタム）
   • 部品点数と BOM の階層の深さは？（組立品、部品、原材料）

3. サプライチェーンの構造

   • 各階層のサプライヤー数は？
   • 地理的な展開範囲は？（国内、グローバル、戦略的地域）
   • 単一調達ですか、それとも複数調達ですか？
   • 垂直統合のレベルは？
   • 外注戦略は？（内製か外注か）

4. 規制と品質

   • 品質規格は？（AS9100、AS9110、AS9120、Nadcap）
   • 必要な認証は？（FAA、EASA、軍用規格）
   • 輸出管理の対象は？（ITAR、EAR、防衛関連品）
   • トレーサビリティ要件は？（シリアル番号管理、ロット追跡）
   • 偽造部品の防止策は？

---

航空宇宙サプライチェーンのフレームワーク

バリューチェーンの構造

航空宇宙製造エコシステム：

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

主な業界プレーヤー：

• OEM：Boeing、Airbus、Lockheed Martin、Northrop Grumman、BAE Systems
• Tier 1：Spirit AeroSystems、Collins Aerospace、Safran、Honeywell
• エンジン：GE Aviation、Pratt & Whitney、Rolls-Royce、CFM International
• MRO：Lufthansa Technik、ST Engineering、AAR Corp、StandardAero

---

リードタイムの長い部品の管理

クリティカルパス分析と計画

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']])

---

AS9100 品質管理

品質と認証の管理

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')

        # Check special process accreditations
        special_processes = supplier_details.get('special_processes', [])

        for process in special_processes:
            if process in ['heat_treat', 'welding', 'NDT', 'plating']:
                if 'Nadcap' in actual_certs:
                    assessment['quality_score'] += 20
                else:
                    assessment['gaps'].append(f'Nadcap_{process}')

        # Check performance history
        ppb_defects = supplier_details.get('ppb_defects', 0)  # Parts per billion

        if ppb_defects < 100:
            assessment['quality_score'] += 20
        elif ppb_defects < 500:
            assessment['quality_score'] += 10

        # On-time delivery
        otd_pct = supplier_details.get('otd_performance', 0)

        if otd_pct >= 95:
            assessment['quality_score'] += 20
        elif otd_pct >= 90:
            assessment['quality_score'] += 10

        # Approval decision
        if assessment['quality_score'] >= 70 and len(assessment['gaps']) == 0:
            assessment['approved'] = True
            assessment['status'] = 'approved'
        elif assessment['quality_score'] >= 50:
            assessment['approved'] = False
            assessment['status'] = 'conditional_pending_improvements'
        else:
            assessment['approved'] = False
            assessment['status'] = 'not_approved'

        return assessment

    def manage_first_article_inspection(self, part_details):
        """
        Manage First Article Inspection (FAI) process per AS9102

        Parameters:
        - part_details: part specifications and requirements

        Returns:
        - FAI checklist and requirements
        """

        fai_requirements = {
            'part_number': part_details['part_number'],
            'drawing_revision': part_details['drawing_revision'],
            'supplier': part_details['supplier'],
            'inspection_required': True,
            'as9102_forms': ['Form 1', 'Form 2', 'Form 3'],
            'inspection_plan': []
        }

        # Form 1: Part number accountability
        fai_requirements['inspection_plan'].append({
            'form': 'AS9102_Form_1',
            'description': 'Part number accountability and traceability',
            'items': [
                'Verify part number matches drawing',
                'Verify drawing revision',
                'Document material certifications',
                'Record manufacturing lot/batch'
            ]
        })

        # Form 2: Product accountability
        fai_requirements['inspection_plan'].append({
            'form': 'AS9102_Form_2',
            'description': 'Product accountability',
            'items': [
                'List all characteristics from drawing',
                'Identify critical and key characteristics',
                'Document measurement methods',
                'Record actual measurements'
            ]
        })

        # Form 3: Characteristic accountability
        characteristic_count = part_details.get('characteristic_count', 50)

        fai_requirements['inspection_plan'].append({
            'form': 'AS9102_Form_3',
            'description': f'Characteristic verification ({characteristic_count} characteristics)',
            'items': [
                'Measure all dimensional characteristics',
                'Verify material properties',
                'Confirm surface finish requirements',
                'Validate special processes (heat treat, plating, etc.)',
                'Photograph critical features'
            ]
        })

        # Additional requirements for critical parts
        if part_details.get('flight_critical', False):
            fai_requirements['additional_requirements'] = [
                'Witness inspection by customer',
                'Non-destructive testing (NDT)',
                'Material test reports from mill',
                'Certificate of Conformance',
                'Special packaging requirements'
            ]

        return fai_requirements

    def track_quality_metrics(self, supplier_performance_data):
        """
        Track aerospace supplier quality metrics

        Parameters:
        - supplier_performance_data: delivery and quality records

        Returns:
        - quality scorecard
        """

        metrics = {}

        for supplier_id, data in supplier_performance_data.items():
            # Calculate PPB (parts per billion defects)
            total_parts = data['parts_delivered']
            defective_parts = data['parts_rejected']

            ppb = (defective_parts / total_parts * 1_000_000_000
                  if total_parts > 0 else 0)

            # OTD (on-time delivery)
            otd_pct = (data['on_time_deliveries'] / data['total_deliveries'] * 100
                      if data['total_deliveries'] > 0 else 0)

            # Corrective actions
            open_cars = data.get('open_corrective_actions', 0)

            # Overall score
            quality_score = (
                (100 - min(ppb / 10, 50)) * 0.4 +  # PPB component (max 50 pts)
                otd_pct * 0.4 +  # OTD component (max 40 pts)
                (10 if open_cars == 0 else 0) * 0.2  # CAR component (max 20 pts)
            )

            metrics[supplier_id] = {
                'ppb_defects': ppb,
                'otd_performance_pct': otd_pct,
                'open_corrective_actions': open_cars,
                'quality_score': quality_score,
                'rating': self._classify_supplier_rating(quality_score)
            }

        return metrics

    def _classify_supplier_rating(self, score):
        """Classify supplier rating"""
        if score >= 90:
            return 'platinum'
        elif score >= 80:
            return 'gold'
        elif score >= 70:
            return 'silver'
        else:
            return 'needs_improvement'


# Example
qm = AerospaceQualityManager()

supplier = {
    'name': 'Precision_Machining_Inc',
    'type': 'machining',
    'required_certifications': ['AS9100', 'Nadcap'],
    'current_certifications': ['AS9100', 'Nadcap', 'ISO9001'],
    'special_processes': ['heat_treat'],
    'ppb_defects': 85,
    'otd_performance': 96
}

assessment = qm.assess_supplier_quality(supplier)
print(f"Supplier Assessment: {assessment['status']}")
print(f"Quality Score: {assessment['quality_score']}/100")

---

MRO（整備、修理、オーバーホール）サプライチェーン

AOG（航空機の地上待機）サポート

class MROSupplyChain:
    """
    Manage MRO supply chain and AOG support
    """

    def __init__(self, parts_inventory, distribution_network):
        self.inventory = parts_inventory
        self.network = distribution_network

    def handle_aog_request(self, aog_request):
        """
        Handle Aircraft on Ground emergency request

        AOG = highest priority, aircraft cannot fly without part

        Parameters:
        - aog_request: urgent part request details

        Returns:
        - fulfillment plan with fastest option
        """

        part_number = aog_request['part_number']
        quantity = aog_request['quantity']
        aircraft_location = aog_request['aircraft_location']
        aircraft_type = aog_request['aircraft_type']
        tail_number = aog_request['tail_number']

        # Search inventory across network
        available_inventory = self.inventory[
            self.inventory['part_number'] == part_number
        ]

        fulfillment_options = []

        for idx, inv in available_inventory.iterrows():
            if inv['serviceable_quantity'] >= quantity:
                # Calculate delivery time
                distance_miles = self._calculate_distance(
                    inv['location'], aircraft_location
                )

                # Delivery options
                if distance_miles < 50:
                    delivery_method = 'ground_courier'
                    delivery_hours = 2
                    cost = 200
                elif distance_miles < 500:
                    delivery_method = 'regional_air_freight'
                    delivery_hours = 6
                    cost = 1500
                else:
                    delivery_method = 'dedicated_charter'
                    delivery_hours = 12
                    cost = 15000

                fulfillment_options.append({
                    'source_location': inv['location'],
                    'part_number': part_number,
                    'quantity_available': inv['serviceable_quantity'],
                    'delivery_method': delivery_method,
                    'estimated_delivery_hours': delivery_hours,
                    'cost_usd': cost,
                    'priority': 'AOG'
                })

        # Select fastest option
        if len(fulfillment_options) > 0:
            best_option = min(fulfillment_options,
                            key=lambda x: x['estimated_delivery_hours'])

            fulfillment_plan = {
                'aog_request_id': aog_request.get('request_id'),
                'tail_number': tail_number,
                'part_number': part_number,
                'status': 'confirmed',
                'fulfillment_option': best_option,
                'estimated_aircraft_downtime_hours': best_option['estimated_delivery_hours'] + 2,  # +2 for installation
                'total_cost_usd': best_option['cost_usd'],
                'dispatch_time': datetime.now(),
                'estimated_delivery_time': datetime.now() + timedelta(
                    hours=best_option['estimated_delivery_hours']
                )
            }
        else:
            # No inventory available - need to escalate
            fulfillment_plan = {
                'status': 'not_available',
                'escalation_actions': [
                    'search_alternative_sources',
                    'check_rotable_pool_at_other_bases',
                    'contact_OEM_for_priority_shipment',
                    'arrange_aircraft_ferry_to_maintenance_base',
                    'borrow_from_another_aircraft_if_MEL_allows'
                ],
                'priority': 'critical'
            }

        return fulfillment_plan

    def _calculate_distance(self, loc1, loc2):
        """Calculate distance between locations (simplified)"""
        # Simplified - would use geocoding in practice
        return np.random.randint(50, 2000)

    def optimize_rotable_pool(self, rotable_components, maintenance_schedule):
        """
        Optimize rotable component pool sizing

        Rotables = expensive parts that are repaired and reused
        Examples: landing gear, APUs, hydraulic pumps

        Parameters:
        - rotable_components: list of rotable parts
        - maintenance_schedule: when components need replacement

        Returns:
        - optimal pool size by component
        """

        pool_sizing = []

        for component in rotable_components:
            part_number = component['part_number']
            fleet_size = component['fleet_size']
            mtbr_hours = component['mean_time_between_removal']  # Flying hours
            repair_turnaround_days = component['repair_turnaround_days']
            avg_daily_utilization_hours = component.get('avg_daily_utilization', 8)

            # Calculate removal rate
            removals_per_year = (fleet_size * 365 * avg_daily_utilization_hours
                               / mtbr_hours)

            # Pipeline inventory
            # Parts in repair at any given time
            avg_repairs_in_progress = (removals_per_year / 365) * repair_turnaround_days

            # Safety stock for demand variability
            demand_std = removals_per_year * 0.2  # 20% variability
            service_level_z = 1.96  # 97.5% service level
            safety_stock = service_level_z * demand_std / np.sqrt(365 / repair_turnaround_days)

            # Total pool size
            recommended_pool_size = int(np.ceil(avg_repairs_in_progress + safety_stock))

            # Cost analysis
            unit_cost = component.get('unit_cost_usd', 100000)
            repair_cost = component.get('repair_cost_usd', 20000)

            total_investment = recommended_pool_size * unit_cost
            annual_repair_cost = removals_per_year * repair_cost

            pool_sizing.append({
                'part_number': part_number,
                'description': component.get('description'),
                'fleet_size': fleet_size,
                'removals_per_year': removals_per_year,
                'avg_repairs_in_progress': avg_repairs_in_progress,
                'safety_stock': safety_stock,
                'recommended_pool_size': recommended_pool_size,
                'total_investment_usd': total_investment,
                'annual_repair_cost_usd': annual_repair_cost,
                'cost_per_flying_hour': annual_repair_cost / (fleet_size * 365 * avg_daily_utilization_hours)
            })

        return pd.DataFrame(pool_sizing)

    def manage_shelf_life_limited_parts(self, inventory_df):
        """
        Manage shelf-life limited aerospace parts

        Many aerospace parts have shelf life limits (rubber, chemicals, etc.)

        Parameters:
        - inventory_df: inventory with shelf life dates

        Returns:
        - parts requiring action
        """

        current_date = datetime.now()

        shelf_life_analysis = []

        for idx, part in inventory_df.iterrows():
            if part.get('has_shelf_life', False):
                manufacture_date = part.get('manufacture_date')
                shelf_life_months = part.get('shelf_life_months', 60)

                expiry_date = manufacture_date + timedelta(
                    days=shelf_life_months * 30
                )

                remaining_days = (expiry_date - current_date).days

                # Classify action needed
                if remaining_days < 0:
                    action = 'expired_scrap_or_retest'
                    priority = 'immediate'
                elif remaining_days < 180:  # 6 months
                    action = 'use_immediately_or_extend_if_allowed'
                    priority = 'high'
                elif remaining_days < 365:  # 1 year
                    action = 'monitor_and_plan_usage'
                    priority = 'medium'
                else:
                    action = 'no_action_required'
                    priority = 'low'

                shelf_life_analysis.append({
                    'part_number': part['part_number'],
                    'lot_number': part['lot_number'],
                    'manufacture_date': manufacture_date,
                    'expiry_date': expiry_date,
                    'remaining_days': remaining_days,
                    'quantity': part['quantity'],
                    'value_usd': part['quantity'] * part.get('unit_cost', 0),
                    'action': action,
                    'priority': priority
                })

        return pd.DataFrame(shelf_life_analysis).sort_values('remaining_days')


# Example
inventory = pd.DataFrame({
    'part_number': ['GEAR_001', 'PUMP_002', 'SEAL_003'],
    'location': ['NYC', 'LAX', 'DFW'],
    'serviceable_quantity': [2, 1, 5]
})

network = {'locations': ['NYC', 'LAX', 'DFW', 'ORD', 'ATL']}

mro = MROSupplyChain(inventory, network)

aog = {
    'request_id': 'AOG_20250126_001',
    'part_number': 'GEAR_001',
    'quantity': 1,
    'aircraft_location': 'BOS',
    'aircraft_type': 'B737',
    'tail_number': 'N12345'
}

fulfillment = mro.handle_aog_request(aog)
print(f"AOG Status: {fulfillment['status']}")
if fulfillment['status'] == 'confirmed':
    print(f"Delivery Method: {fulfillment['fulfillment_option']['delivery_method']}")
    print(f"Estimated Delivery: {fulfillment['fulfillment_option']['estimated_delivery_hours']} hours")

---

輸出管理とセキュリティ

ITAR と EAR の遵守

class ExportControlManager:
    """
    Manage ITAR and export control compliance
    """

    def __init__(self):
        self.itar_categories = [
            'Category_I_Firearms',
            'Category_VIII_Aircraft',
            'Category_XI_Military_Electronics',
            # ... others
        ]

    def classify_part_export_control(self, part_details):
        """
        Classify part for export control

        Parameters:
        - part_details: part specifications and use

        Returns:
        - export classification
        """

        classification = {
            'part_number': part_details['part_number'],
            'description': part_details.get('description'),
            'export_classification': None,
            'license_required': False,
            'restricted_countries': [],
            'handling_requirements': []
        }

        # Determine if ITAR or EAR
        if part_details.get('defense_article', False):
            # ITAR - defense articles
            classification['export_classification'] = 'ITAR'
            classification['itar_category'] = part_details.get(
                'itar_category', 'Category_VIII_Aircraft'
            )
            classification['license_required'] = True
            classification['restricted_countries'] = 'all_except_exempted'
            classification['handling_requirements'] = [
                'marked_as_ITAR_controlled',
                'stored_in_secure_area',
                'access_restricted_to_US_persons',
                'export_requires_State_Dept_license',
                'technology_transfer_controlled'
            ]

        elif part_details.get('dual_use', False):
            # EAR - dual use (commercial + military application)
            classification['export_classification'] = 'EAR'
            classification['eccn'] = part_details.get('eccn', '9A991')  # ECCN code
            classification['license_required'] = self._requires_ear_license(
                part_details.get('eccn'), part_details.get('destination_country')
            )
            classification['restricted_countries'] = self._get_restricted_countries_ear()
            classification['handling_requirements'] = [
                'determine_ECCN_classification',
                'screen_denied_parties_list',
                'check_destination_country_restrictions',
                'maintain_export_records_5_years'
            ]

        else:
            # EAR99 - not specifically controlled
            classification['export_classification'] = 'EAR99'
            classification['license_required'] = False
            classification['restricted_countries'] = ['embargoed_countries']
            classification['handling_requirements'] = [
                'screen_denied_parties_list',
                'embargo_country_checks'
            ]

        return classification

    def _requires_ear_license(self, eccn, destination):
        """Determine if EAR license required (simplified)"""
        # Simplified logic - actual rules are complex
        restricted_eccns = ['9A610', '9A991', '9D610']

        return eccn in restricted_eccns

    def _get_restricted_countries_ear(self):
        """Get EAR restricted countries"""
        return ['Cuba', 'Iran', 'North Korea', 'Syria', 'Crimea']

    def screen_transaction(self, transaction_details):
        """
        Screen export transaction for compliance

        Parameters:
        - transaction_details: party, destination, items

        Returns:
        - screening result
        """

        screening_result = {
            'transaction_id': transaction_details.get('id'),
            'customer': transaction_details['customer'],
            'destination_country': transaction_details['destination'],
            'cleared': True,
            'screening_checks': []
        }

        # Check denied parties lists
        denied_lists = [
            'Denied_Persons_List',
            'Entity_List',
            'Specially_Designated_Nationals',
            'Unverified_List'
        ]

        customer_name = transaction_details['customer']

        # Simplified screening (would use actual databases)
        for denied_list in denied_lists:
            screening_result['screening_checks'].append({
                'list': denied_list,
                'result': 'no_match'  # Placeholder
            })

        # Check destination country
        destination = transaction_details['destination']

        if destination in self._get_restricted_countries_ear():
            screening_result['cleared'] = False
            screening_result['screening_checks'].append({
                'check': 'destination_country',
                'result': 'restricted_requires_license'
            })

        # Check end use
        end_use = transaction_details.get('end_use')

        prohibited_uses = ['military', 'nuclear', 'missile']

        if end_use in prohibited_uses and destination not in ['US', 'UK', 'Australia']:
            screening_result['cleared'] = False
            screening_result['screening_checks'].append({
                'check': 'end_use',
                'result': 'prohibited_end_use'
            })

        return screening_result


# Example
ecm = ExportControlManager()

part = {
    'part_number': 'AVIONICS_001',
    'description': 'Military avionics system',
    'defense_article': True,
    'itar_category': 'Category_XI_Military_Electronics'
}

classification = ecm.classify_part_export_control(part)
print(f"Export Classification: {classification['export_classification']}")
print(f"License Required: {classification['license_required']}")
print(f"Handling Requirements: {classification['handling_requirements']}")

---

ツールとライブラリ

Python ライブラリ

サプライチェーンの最適化：

• pulp：生産計画のための線形計画法
• networkx：サプライネットワークとクリティカルパスの分析
• scipy：統計分析

データ分析：

• pandas：データ操作と BOM 管理
• numpy：数値計算
• matplotlib：可視化

プロジェクト管理：

• python-gantt：プログラム用ガントチャートの生成
• criticalpath：クリティカルパス法の実装

商用ソフトウェア

ERP/MRP システム：

• SAP S/4HANA Aerospace & Defense：業界特化型 ERP
• Oracle E-Business Suite Aerospace & Defense：コンプライアンス対応 ERP
• IFS Applications：航空宇宙・防衛製造
• Infor CloudSuite Aerospace & Defense：業界向けクラウド ERP

PLM（製品ライフサイクル管理）：

• Siemens Teamcenter：航空宇宙向け PLM
• Dassault ENOVIA：PLM とコラボレーション
• PTC Windchill：構成管理機能を備えた PLM
• Aras Innovator：複雑な製品向け PLM

MRO システム：

• IFS Maintenix：航空機向け MRO ソフトウェア
• Ramco Aviation：包括的な MRO スイート
• Swiss-AS AMOS：航空機整備ソフトウェア
• Quantum Control：MRO と在庫管理

サプライチェーン：

• Blue Yonder：需要・供給計画
• Kinaxis RapidResponse：航空宇宙向け S&OP
• E2open：多階層の可視性
• Exostar：航空宇宙サプライチェーンのコラボレーション

品質管理：

• ETQ Reliance：AS9100 品質管理
• MasterControl：品質とコンプライアンス
• Sparta Systems TrackWise：CAPA と品質イベント

---

よくある課題と解決策

課題：極端に長いリードタイム

問題：

• コンポーネントのリードタイムが 12～36 か月
• 2～3 年先の需要予測が難しい
• 生産率の変化がパイプラインに影響する
• 仕掛品在庫に資金が拘束される

解決策：

• 先行調達：コンポーネントを 24～36 か月前に発注します
• サプライヤーとのパートナーシップ：供給能力の確約を含む長期契約を締結します
• リスクプーリング：可能な場合は、複数のプログラム間でコンポーネントを共有します
• デジタルツイン：パイプライン在庫を動的にモデル化します
• 柔軟な契約：数量調整の選択肢を設けます
• 安全在庫戦略：リードタイムの長い品目向けに戦略的な在庫を確保します
• サプライヤー育成：サプライヤーのリードタイム短縮を支援します

課題：単一供給元のサプライヤー

問題：

• 多くの部品に認定済みの供給元が 1 社しかない
• サプライヤーの交渉力が強い
• 供給途絶のリスクがある
• 交渉力が限られている

解決策：

• 複数供給元の確保：重要部品について第 2 の供給元を認定します
• 垂直統合：重要な能力を社内に取り込みます
• 戦略的在庫：単一供給元の部品について安全在庫を増やします
• サプライヤーの監視：財務状況を追跡します
• エスクロー契約：重要な工具・知的財産へのアクセスを確保します
• 長期契約：供給能力と価格を確保します
• 代替設計：実現可能な場合は代替部品を設計します

課題：偽造部品

問題：

• 偽造部品がサプライチェーンに流入する
• 安全性および耐空性のリスクがある
• 検出が難しい
• 賠償責任のリスクがある

解決策：

• 認定供給元のみを利用：OCM または認定販売代理店から購入します
• サプライヤー審査：厳格な認定と監査を実施します
• 部品検査：試験を含む受入検査を実施します
• トレーサビリティ：完全な管理履歴の文書を作成します
• 偽造防止技術：ブロックチェーン、RFID、認証チップを活用します
• トレーニング：調達担当者に注意すべき兆候を周知します
• 業界連携：GIDEP、ERAI を通じて情報を共有します

課題：AS9100 コンプライアンスの複雑さ

問題：

• 広範な品質文書が求められる
• 初回製品検査に時間がかかる
• サプライヤーの不適合が発生する
• 監査指摘と CAR が発生する

解決策：

• デジタル品質システム：FAI と品質記録を自動化します
• サプライヤー育成：AS9100 の要件についてサプライヤーをトレーニングします
• リスクベースのアプローチ：飛行に不可欠な部品にリソースを集中させます
• 事前認定：契約締結前にサプライヤーを監査します
• 継続的改善：定期的に内部監査を実施します
• 教訓の活用：品質上の問題と解決策をデータベース化します
• 認証支援：主要サプライヤーによる AS9100 の取得を支援します

課題：輸出管理の複雑さ

問題点：

• ITAR および EAR の規制は複雑です
• 違反に対する罰則は厳格です（100 万ドル以上の罰金）
• 技術移転に制限があります
• グローバルサプライチェーンが規制と衝突します

解決策：

• 分類：すべての部品を適切に分類します（ITAR、EAR、EAR99）
• コンプライアンストレーニング：従業員向けに定期的なトレーニングを実施します
• スクリーニングツール：取引禁止対象者のスクリーニングを自動化します
• アクセス制御：物理的およびシステム上のアクセスを制限します
• ライセンス管理：輸出ライセンスと承認を追跡します
• 法律顧問：輸出管理を専門とする弁護士を社内に配置します
• 分離：ITAR 関連業務を商業業務から分離します
• 文書管理：輸出記録を詳細に保管します

---

出力形式

航空宇宙サプライチェーンレポート

エグゼクティブサマリー：

• プログラムの状況（生産中の航空機、受注残）
• サプライチェーンのパフォーマンス指標
• 品質およびコンプライアンスの状況
• 主なリスクと軽減策

プログラムの生産状況：

プログラム	航空機タイプ	月間生産率	受注残	次回納入日	クリティカルパス項目
Program_A	B737 MAX	31	450	Feb 15	ランディングギア
Program_B	A320neo	45	520	Feb 10	エンジン
Program_C	F-35	12	185	Mar 1	アビオニクス

リードタイムの長い部品：

部品番号	説明	リードタイム	発注日	納入日	状況	リスク
ENG_001	タービンエンジン	104 wks	Ordered	Jun 2025	On track	Low
GEAR_002	ランディングギア	78 wks	Overdue	Apr 2025	Late	High
WING_003	翼アセンブリ	65 wks	Ordered	May 2025	On track	Medium

品質パフォーマンス：

指標	現在値	目標	状況
サプライヤー PPB 不良数	95	<100	✓ Green
納期遵守率	89%	95%	⚠ Yellow
AS9100 準拠率	100%	100%	✓ Green
初回品検査合格率	87%	90%	⚠ Yellow
未完了 CAR 数	12	<10	⚠ Yellow

MRO パフォーマンス：

指標	現在値	目標	状況
AOG 対応時間	8 hrs	<12 hrs	✓ Green
部品の入手可能率	94%	95%	⚠ Yellow
ロータブル部品プール充足率	97%	95%	✓ Green
修理 TAT	35 days	30 days	⚠ Yellow

輸出管理の状況：

カテゴリ	件数	備考
ITAR 部品	1,250	すべて適切に表示され、管理されています
EAR 部品	3,400	ECCN 分類が完了しています
有効な輸出ライセンス	45	すべて有効で、毎月監視しています
取引禁止対象者のスクリーニング	100%	スクリーニングを自動化しています

アクション項目：

1. ランディングギアのサプライヤー（GEAR_002）へのエスカレーション — 2 週間遅れており、Program A に影響しています
2. タービンブレード鍛造品の第 2 ソースを認定し、単一ソースのリスクを軽減します
3. Supplier_X の AS9100 監査準備を完了します — 監査は 3 月 15 日に予定されています
4. アジア太平洋ハブに AOG 在庫を配置し、地域内の 12 時間以内の対応を改善します
5. 未完了の CAR 12 件をクローズします — 四半期末までの完了を目指します

---

確認事項

さらに詳しい情報が必要な場合：

1. 航空宇宙のどのセグメントですか？（民間航空、防衛、宇宙、ビジネスジェット）
2. OEM ですか、それともサプライヤーの階層ですか？（Tier 1、2、3、または OEM）
3. どのような製品やアセンブリを製造していますか？
4. 生産、アフターマーケット、MRO のどれですか？
5. どの品質規格が適用されますか？（AS9100、AS9110、AS9120、Nadcap）
6. 輸出管理要件はありますか？（ITAR、EAR）
7. 重要部品の現在のリードタイムはどのくらいですか？
8. サプライチェーンにおける主な課題は何ですか？

---

関連スキル

• production-scheduling：製造スケジューリング向け
• capacity-planning：生産能力管理向け
• quality-management：AS9100および品質システム向け
• supplier-selection：サプライヤーの適格性評価向け
• supplier-risk-management：供給継続性向け
• inventory-optimization：安全在庫およびローテーブルプール向け
• procurement-optimization：調達の最適化向け
• demand-forecasting：生産計画向け
• network-design：流通ネットワークの最適化向け
• compliance-management：規制コンプライアンス向け
• risk-mitigation：サプライチェーンリスク管理向け