104天闪电过会！宇树科技IPO深度解析：420亿估值的"具身智能第一股"如何炼成，人形机器人产业化拐点已至

"""
unitree_analysis.py
宇树科技IPO与运动控制算法深度分析
"""
import numpy as np
from typing import List, Tuple, Dict
from dataclasses import dataclass
from enum import Enum

# ==================== 运动控制算法 ====================

class GaitType(Enum):
    """步态类型"""
    WALK = "walk"          # 行走
    TROT = "trot"          # 小跑
    RUN = "run"            # 奔跑
    SPRINT = "sprint"      # 冲刺

@dataclass
class JointConfig:
    """关节配置"""
    name: str
    max_torque: float      # 最大扭矩 (N·m)
    max_speed: float       # 最大转速 (rad/s)
    reduction_ratio: float # 减速比

@dataclass
class BodyState:
    """机器人本体状态"""
    position: np.ndarray   # 位置 [x, y, z]
    orientation: np.ndarray  # 姿态 [roll, pitch, yaw]
    velocity: np.ndarray   # 线速度 [vx, vy, vz]
    angular_vel: np.ndarray  # 角速度 [wx, wy, wz]
    joint_angles: np.ndarray  # 关节角度
    joint_velocities: np.ndarray  # 关节速度

class MPCController:
    """模型预测控制器（核心运动控制）"""
    
    def __init__(self, dt: float = 0.001, horizon: int = 20):
        self.dt = dt
        self.horizon = horizon
        self.mass = 47.0          # H1本体质量 (kg)
        self.height = 1.8         # H1身高 (m)
        self.gravity = 9.81
        
        # H1关节配置（12个自由度）
        self.joints = [
            JointConfig("左髋_roll", 180, 12.0, 6.0),
            JointConfig("左髋_pitch", 180, 12.0, 6.0),
            JointConfig("左膝", 360, 8.0, 8.0),
            JointConfig("左踝", 120, 15.0, 4.0),
            JointConfig("右髋_roll", 180, 12.0, 6.0),
            JointConfig("右髋_pitch", 180, 12.0, 6.0),
            JointConfig("右膝", 360, 8.0, 8.0),
            JointConfig("右踝", 120, 15.0, 4.0),
            JointConfig("左肩", 90, 10.0, 4.0),
            JointConfig("左肘", 60, 12.0, 3.0),
            JointConfig("右肩", 90, 10.0, 4.0),
            JointConfig("右肘", 60, 12.0, 3.0),
        ]
    
    def compute_ground_reaction_force(
        self, state: BodyState, target_speed: float
    ) -> np.ndarray:
        """计算足底反力（MPC核心）"""
        # 线性倒立摆模型简化
        com_height = 0.9  # 质心高度 (m)
        pendulum_length = com_height
        
        # 目标加速度（基于当前速度与目标速度的偏差）
        current_speed = np.linalg.norm(state.velocity[:2])
        accel_gain = 10.0
        target_accel = accel_gain * (target_speed - current_speed)
        
        # 足底反力计算
        f_vertical = self.mass * self.gravity
        f_horizontal = self.mass * target_accel
        
        # 力矩约束检查
        max_torque = min(j.max_torque for j in self.joints)
        required_torque = f_horizontal * pendulum_length
        
        if required_torque > max_torque:
            # 超出关节力矩能力，限制加速度
            f_horizontal = max_torque / pendulum_length
            target_accel = f_horizontal / self.mass
        
        return np.array([f_horizontal, 0, f_vertical])
    
    def compute_joint_torques(
        self, state: BodyState, target_state: BodyState
    ) -> np.ndarray:
        """计算关节力矩（逆动力学）"""
        n_joints = len(self.joints)
        torques = np.zeros(n_joints)
        
        for i in range(n_joints):
            joint = self.joints[i]
            
            # PD控制
            pos_error = target_state.joint_angles[i] - state.joint_angles[i]
            vel_error = target_state.joint_velocities[i] - state.joint_velocities[i]
            
            kp = 50.0  # 位置增益
            kd = 5.0   # 速度增益
            
            torque = kp * pos_error + kd * vel_error
            
            # 力矩限制
            torque = np.clip(torque, -joint.max_torque, joint.max_torque)
            torques[i] = torque
        
        return torques
    
    def plan_trajectory(
        self, initial_state: BodyState, target_speed: float,
        duration: float
    ) -> List[BodyState]:
        """规划运动轨迹"""
        trajectory = []
        state = initial_state
        steps = int(duration / self.dt)
        
        for _ in range(steps):
            # 计算地面反力
            grf = self.compute_ground_reaction_force(state, target_speed)
            
            # 更新状态（简化动力学）
            accel = grf / self.mass
            state.velocity[:2] += accel[:2] * self.dt
            state.position[:2] += state.velocity[:2] * self.dt
            
            trajectory.append(state)
        
        return trajectory
    
    def simulate_10mps_sprint(self) -> Dict:
        """模拟H1 10m/s冲刺"""
        initial_state = BodyState(
            position=np.zeros(3),
            orientation=np.zeros(3),
            velocity=np.zeros(3),
            angular_vel=np.zeros(3),
            joint_angles=np.zeros(len(self.joints)),
            joint_velocities=np.zeros(len(self.joints))
        )
        
        target_speed = 10.0  # m/s
        duration = 5.0       # 模拟5秒
        
        # 分阶段加速
        phases = [
            ("加速阶段 0→5m/s", 0, 5.0, 1.0),
            ("加速阶段 5→8m/s", 5.0, 8.0, 1.5),
            ("冲刺阶段 8→10m/s", 8.0, 10.0, 2.0),
            ("峰值维持", 10.0, 10.0, 0.5),
        ]
        
        results = {}
        current_speed = 0.0
        total_time = 0.0
        
        for phase_name, v_start, v_end, t_duration in phases:
            trajectory = self.plan_trajectory(
                initial_state, v_end, t_duration
            )
            results[phase_name] = {
                "duration": t_duration,
                "final_speed": v_end,
                "steps": len(trajectory),
                "max_torque_required": max(
                    self.compute_joint_torques(initial_state, s).max()
                    for s in trajectory[-10:]
                )
            }
            current_speed = v_end
            total_time += t_duration
        
        results["total_time"] = total_time
        results["100m_estimated_time"] = 100.0 / 10.0  # 10秒
        results["world_record_comparison"] = {
            "human_100m": 9.58,    # 博尔特
            "robot_100m": 10.0,    # H1估计
            "gap": "仅差0.42秒！"
        }
        
        return results

# ==================== IPO财务分析 ====================

@dataclass
class FinancialData:
    """财务数据"""
    revenue: float          # 营收 (亿元)
    net_profit: float       # 净利润 (亿元)
    gross_margin: float     # 毛利率
    humanoid_revenue: float # 人形机器人收入 (亿元)
    humanoid_shipments: int # 人形机器人出货量
    rnd_expense: float      # 研发费用 (亿元)

class IPOAnalyzer:
    """IPO分析器"""
    
    def __init__(self):
        # 宇树科技财务数据
        self.financials = {
            2023: FinancialData(1.59, -0.111, 44.22, 0.03, 100, 0.45),
            2024: FinancialData(3.93, 0.955, 50.12, 1.07, 1200, 0.85),
            2025: FinancialData(16.99, 2.78, 60.27, 8.68, 5500, 4.87),
        }
        self.ipo_raise = 42.02   # 亿元
        self.ipo_valuation = 420.0  # 亿元
        
    def compute_growth_metrics(self) -> Dict:
        """计算增长指标"""
        metrics = {}
        years = sorted(self.financials.keys())
        
        for i in range(1, len(years)):
            prev = years[i-1]
            curr = years[i]
            
            p = self.financials[prev]
            c = self.financials[curr]
            
            rev_growth = (c.revenue - p.revenue) / p.revenue * 100
            profit_growth = float('inf') if p.net_profit <= 0 else \
                (c.net_profit - p.net_profit) / abs(p.net_profit) * 100
            
            humanoid_share = c.humanoid_revenue / c.revenue * 100
            
            metrics[f"{prev}→{curr}"] = {
                "revenue_growth_pct": round(rev_growth, 1),
                "profit_growth_pct": round(profit_growth, 1),
                "humanoid_share_pct": round(humanoid_share, 1),
                "gross_margin_pct": c.gross_margin
            }
        
        # 三年复合增长率
        rev_2023 = self.financials[2023].revenue
        rev_2025 = self.financials[2025].revenue
        cagr = (rev_2025 / rev_2023) ** (1/2) - 1
        
        metrics["三年CAGR"] = round(cagr * 100, 1)
        metrics["IPO市盈率"] = round(self.ipo_valuation / rev_2025, 1)
        return metrics
    
    def compute_market_valuation(self) -> Dict:
        """市场估值分析"""
        revenue_2025 = self.financials[2025].revenue
        profit_2025 = self.financials[2025].net_profit
        
        # 对比同行估值
        peers = {
            "特斯拉(机器人业务)": {"ps_ratio": 15.0, "revenue_b": 28.0},
            "优必选(未上市)": {"ps_ratio": 8.0, "revenue_b": 2.0},
            "智元机器人(未上市)": {"ps_ratio": 12.0, "revenue_b": 1.5},
        }
        
        analysis = {
            "宇树科技_PS_ratio": round(self.ipo_valuation / revenue_2025, 1),
            "宇树科技_PE_ratio": round(self.ipo_valuation / profit_2025, 1),
            "同行对比": peers,
            "估值合理性": (
                "偏高" if self.ipo_valuation / revenue_2025 > 25
                else "合理" if self.ipo_valuation / revenue_2025 > 15
                else "偏低"
            )
        }
        return analysis
    
    def compute_break_even_analysis(self) -> Dict:
        """盈亏平衡分析"""
        # 2026年Q1数据
        q1_revenue = 4.23
        q1_profit = 0.5
        q1_rnd = 1.2
        
        # 假设全年研发投入6亿
        annual_rnd = 6.0
        # 毛利率假设
        gross_margin = 0.58
        # 固定成本（销售+管理+研发）
        fixed_cost = annual_rnd + 2.0  # 销售+管理按2亿估算
        
        # 盈亏平衡营收
        break_even_revenue = fixed_cost / gross_margin
        
        # 2026年预估营收
        estimated_2026_revenue = 10.52  # 最低预估
        
        return {
            "盈亏平衡营收": f"{break_even_revenue:.1f}亿",
            "2026预估营收": f"{estimated_2026_revenue:.1f}亿",
            "是否盈利": "是" if estimated_2026_revenue > break_even_revenue else "否",
            "安全边际": f"{(estimated_2026_revenue - break_even_revenue) / estimated_2026_revenue * 100:.1f}%",
            "关键假设": {
                "毛利率": "58%",
                "年研发费用": "6亿",
                "销售+管理费用": "2亿"
            }
        }

class CompetitorAnalyzer:
    """竞争对手分析"""
    
    @staticmethod
    def tesla_threat_model() -> Dict:
        """特斯拉威胁评估"""
        # Optimus Gen3 数据
        optimus_bom = 2.8  # 万美元
        fremont_capacity = 70000  # 台/年
        austin_planned = 70000   # 2028年计划
        
        # 宇树产品数据
        unitree_avg_price = 16.76  # 万元
        unitree_target_price = 10.0  # 2026年目标
        
        # 竞争对比
        comparison = {
            "Optimus Gen3 BOM成本": f"${optimus_bom:.1f}万 (≈{optimus_bom*7.1:.1f}万元)",
            "宇树平均售价": f"{unitree_avg_price:.2f}万元",
            "特斯拉产能(2026)": f"{fremont_capacity:,}台/年",
            "特斯拉产能(2028)": f"{fremont_capacity + austin_planned:,}台/年",
            "宇树2026目标": f"10,000-20,000台",
            "成本差距": f"特斯拉BOM({optimus_bom*7.1:.0f}万) ≈ 宇树售价({unitree_avg_price:.0f}万)",
            "威胁等级": "⚠️ 高  - 特斯拉量产规模是宇树的7-10倍"
        }
        return comparison

if __name__ == "__main__":
    print("=" * 60)
    print("宇树科技IPO深度分析")
    print("=" * 60)
    
    # IPO分析
    analyzer = IPOAnalyzer()
    metrics = analyzer.compute_growth_metrics()
    valuation = analyzer.compute_market_valuation()
    
    print("\n📊 增长指标:")
    for period, data in metrics.items():
        if isinstance(data, dict):
            print(f"  {period}: 营收增速{data['revenue_growth_pct']}% | "
                  f"人形占比{data['humanoid_share_pct']}% | "
                  f"毛利率{data['gross_margin_pct']}%")
        else:
            print(f"  {period}: {data}")
    
    print("\n💰 估值分析:")
    print(f"  PS: {valuation['宇树科技_PS_ratio']}x | PE: {valuation['宇树科技_PE_ratio']}x")
    print(f"  估值合理性: {valuation['估值合理性']}")
    
    # 运动控制模拟
    print("\n🏃 H1 10m/s冲刺模拟:")
    mpc = MPCController()
    sprint_results = mpc.simulate_10mps_sprint()
    for phase, data in sprint_results.items():
        if isinstance(data, dict):
            print(f"  {phase}: 速度{data.get('final_speed', '')} 时间{data.get('duration', '')}s")
    
    print(f"\n  百米预估: {sprint_results.get('100m_estimated_time', 'N/A')}秒")
    print(f"  对比博尔特: {sprint_results.get('world_record_comparison', {}).get('gap', '')}")
    
    # 竞争分析
    print("\n⚔️ 特斯拉威胁评估:")
    threat = CompetitorAnalyzer.tesla_threat_model()
    for k, v in threat.items():
        print(f"  {k}: {v}")

// unitree_manufacturing.go
// 宇树科技智能制造产线调度系统

package main

import (
	"fmt"
	"math"
	"sort"
	"sync"
	"time"
)

// 产线核心参数
const (
	TargetAnnualOutput2026 = 15000  // 2026年目标产能
	TargetAnnualOutput2027 = 50000  // 2027年目标产能
	AssemblyLineCount      = 4      // 总装线数量
	SubAssemblyLineCount   = 12     // 子装配线数量
	WorkHoursPerDay        = 20     // 每天工作小时（两班倒）
	WorkDaysPerYear        = 300    // 年工作天数
)

// RobotModel 机器人型号
type RobotModel string

const (
	H1 RobotModel = "H1"  // 全尺寸人形机器人
	G1 RobotModel = "G1"  // 中尺寸人形机器人
	Go RobotModel = "Go"  // 四足机器人
)

// BillOfMaterials BOM物料清单
type BillOfMaterials struct {
	Model        RobotModel
	CostCNY      float64            // 总物料成本 (万元)
	SelfMadePct  float64            // 自研比例
	Components   map[string]float64 // 组件成本明细
	CycleTimeSec int                // 装配节拍 (秒)
}

var bomDatabase = map[RobotModel]*BillOfMaterials{
	H1: {
		Model:       H1,
		CostCNY:     6.5,
		SelfMadePct: 0.92,
		Components: map[string]float64{
			"关节电机":   1.8,
			"减速器":   1.2,
			"控制器":   0.8,
			"结构件":   0.5,
			"传感器":   0.7,
			"电池系统":  0.6,
			"AI计算模块": 0.5,
			"其他":    0.4,
		},
		CycleTimeSec: 1800, // 30分钟/台
	},
	G1: {
		Model:       G1,
		CostCNY:     3.2,
		SelfMadePct: 0.88,
		Components: map[string]float64{
			"关节电机":   1.0,
			"减速器":   0.6,
			"控制器":   0.4,
			"结构件":   0.3,
			"传感器":   0.4,
			"电池系统":  0.3,
			"AI计算模块": 0.2,
			"其他":   0.0,
		},
		CycleTimeSec: 1200, // 20分钟/台
	},
}

// ProductionLine 产线
type ProductionLine struct {
	ID            int
	Model         RobotModel
	DailyCapacity int       // 日产能
	CurrentLoad   float64   // 当前负载率 0.0-1.0
	Status        string    // "running", "idle", "maintenance"
	mu            sync.Mutex
}

// ProductionScheduler 产线调度器
type ProductionScheduler struct {
	lines          []*ProductionLine
	orders         []ProductionOrder
	warehouse      ComponentWarehouse
	throughputLog  []ThroughputRecord
}

type ProductionOrder struct {
	ID        string
	Model     RobotModel
	Quantity  int
	Deadline  time.Time
	Priority  int
	CreatedAt time.Time
}

type ComponentWarehouse struct {
	mu          sync.Mutex
	stock       map[string]int
	reorderPoint map[string]int
	leadTime    map[string]int // 采购前置天数
}

type ThroughputRecord struct {
	Date       time.Time
	Model      RobotModel
	Count      int
	DefectRate float64
	LineID     int
}

func NewScheduler() *ProductionScheduler {
	lines := make([]*ProductionLine, AssemblyLineCount)
	for i := 0; i < AssemblyLineCount; i++ {
		model := H1
		if i >= 2 {
			model = G1
		}
		bom := bomDatabase[model]
		dailyCapacity := int(float64(WorkHoursPerDay*3600) / float64(bom.CycleTimeSec))
		
		lines[i] = &ProductionLine{
			ID:            i + 1,
			Model:         model,
			DailyCapacity: dailyCapacity,
			CurrentLoad:   0.85,
			Status:        "running",
		}
	}
	
	return &ProductionScheduler{
		lines: lines,
		warehouse: ComponentWarehouse{
			stock: map[string]int{
				"M107电机":   500,
				"行星减速器":  400,
				"FOC控制器":   600,
				"碳纤维骨架":   200,
				"IMU传感器":   800,
				"激光雷达":    150,
			},
			reorderPoint: map[string]int{
				"M107电机":  200,
				"行星减速器": 150,
				"FOC控制器":  250,
				"碳纤维骨架":  80,
				"IMU传感器":  300,
				"激光雷达":   50,
			},
			leadTime: map[string]int{
				"M107电机":  14,
				"行星减速器": 21,
				"FOC控制器":  10,
				"碳纤维骨架":  30,
				"IMU传感器":  7,
				"激光雷达":   45,
			},
		},
	}
}

// ScheduleProduction 调度生产计划
func (s *ProductionScheduler) ScheduleProduction(
	orders []ProductionOrder,
) map[string]interface{} {
	// 按优先级排序
	sort.Slice(orders, func(i, j int) bool {
		return orders[i].Priority > orders[j].Priority
	})
	
	// 计算总产能需求
	totalH1Needed := 0
	totalG1Needed := 0
	for _, order := range orders {
		switch order.Model {
		case H1:
			totalH1Needed += order.Quantity
		case G1:
			totalG1Needed += order.Quantity
		}
	}
	
	// 计算可用产能
	availableH1Days := 0
	availableG1Days := 0
	for _, line := range s.lines {
		days := WorkDaysPerYear
		switch line.Model {
		case H1:
			availableH1Days += days * line.DailyCapacity
		case G1:
			availableG1Days += days * line.DailyCapacity
		}
	}
	
	// 负载率调整
	availableH1 := int(float64(availableH1Days) * 0.85)
	availableG1 := int(float64(availableG1Days) * 0.85)
	
	// 物料约束检查
	componentCheck := s.checkComponentAvailability(orders)
	
	feasible := totalH1Needed <= availableH1 && totalG1Needed <= availableG1
	if !feasible {
		// 产能不足，给出建议
		shortfallH1 := totalH1Needed - availableH1
		shortfallG1 := totalG1Needed - availableG1
		
		extraLinesNeeded := 0
		if shortfallH1 > 0 {
			extraLinesNeeded = shortfallH1 / (availableH1Days / WorkDaysPerYear / AssemblyLineCount)
		}
		
		return map[string]interface{}{
			"feasible":        false,
			"h1_shortfall":    shortfallH1,
			"g1_shortfall":    shortfallG1,
			"extra_lines_needed": extraLinesNeeded,
			"suggestion": fmt.Sprintf(
				"产能不足！建议新增%d条H1产线以覆盖缺口，或调整产品结构",
				extraLinesNeeded,
			),
		}
	}
	
	return map[string]interface{}{
		"feasible":          true,
		"h1_annual_capacity": availableH1,
		"g1_annual_capacity": availableG1,
		"h1_utilization_pct": roundFloat(float64(totalH1Needed)/float64(availableH1)*100, 1),
		"g1_utilization_pct": roundFloat(float64(totalG1Needed)/float64(availableG1)*100, 1),
		"component_status":  componentCheck,
	}
}

func (s *ProductionScheduler) checkComponentAvailability(
	orders []ProductionOrder,
) map[string]interface{} {
	s.warehouse.mu.Lock()
	defer s.warehouse.mu.Unlock()
	
	// 计算物料需求
	needed := map[string]int{
		"M107电机":  0,
		"行星减速器": 0,
		"FOC控制器":  0,
		"碳纤维骨架":  0,
		"IMU传感器":  0,
		"激光雷达":   0,
	}
	
	for _, order := range orders {
		bom := bomDatabase[order.Model]
		for comp := range needed {
			// 每台机器人需要
			quantity := order.Quantity
			switch comp {
			case "M107电机":
				quantity *= 2 // 双腿各1个
			case "行星减速器":
				quantity *= 2
			case "FOC控制器":
				quantity *= 1
			case "碳纤维骨架":
				quantity *= 1
			case "IMU传感器":
				quantity *= 2
			case "激光雷达":
				quantity *= 1
			}
			needed[comp] += quantity
		}
	}
	
	// 检查库存
	status := make(map[string]string)
	alerts := []string{}
	
	for comp, need := range needed {
		stock := s.warehouse.stock[comp]
		reorder := s.warehouse.reorderPoint[comp]
		leadTime := s.warehouse.leadTime[comp]
		
		if stock < need {
			shortfall := need - stock
			alerts = append(alerts, fmt.Sprintf(
				"%s 短缺%d件，需提前%d天下单采购",
				comp, shortfall, leadTime,
			))
			status[comp] = fmt.Sprintf("⚠️ 短缺%d件", shortfall)
		} else if stock-need < reorder {
			status[comp] = fmt.Sprintf("⚠️ 需补货(剩余%d)", stock-need)
		} else {
			status[comp] = "✅ 充足"
		}
	}
	
	return map[string]interface{}{
		"status": status,
		"alerts": alerts,
	}
}

// CostOptimizer 成本优化器
type CostOptimizer struct {
	historicalCosts []float64
	volumeDiscounts map[int]float64 // 采购量 -> 折扣率
}

func NewCostOptimizer() *CostOptimizer {
	return &CostOptimizer{
		volumeDiscounts: map[int]float64{
			1000:  0.95,  // 1000件 95折
			5000:  0.85,  // 5000件 85折
			10000: 0.75,  // 10000件 75折
			50000: 0.60,  // 50000件 6折
		},
	}
}

// OptimizeBOMCost 优化BOM成本
func (co *CostOptimizer) OptimizeBOMCost(
	model RobotModel,
	annualVolume int,
) map[string]float64 {
	bom := bomDatabase[model]
	
	// 找到适用的折扣率
	discount := 1.0
	volumes := make([]int, 0, len(co.volumeDiscounts))
	for v := range co.volumeDiscounts {
		volumes = append(volumes, v)
	}
	sort.Sort(sort.Reverse(sort.IntSlice(volumes)))
	
	for _, v := range volumes {
		if annualVolume >= v {
			discount = co.volumeDiscounts[v]
			break
		}
	}
	
	// 自研成本优势
	selfMadeDiscount := 1.0 / (1.0 + (1.0 - bom.SelfMadePct))
	
	optimizedCost := bom.CostCNY * discount * selfMadeDiscount
	
	return map[string]float64{
		"base_cost_cny":     bom.CostCNY,
		"volume_discount":   roundFloat((1-discount)*100, 1),
		"self_made_advantage": roundFloat((1-selfMadeDiscount)*100, 1),
		"optimized_cost_cny": roundFloat(optimizedCost, 2),
		"savings_pct":       roundFloat((1-optimizedCost/bom.CostCNY)*100, 1),
	}
}

// SimulateCostReduction 模拟降本路线
func (co *CostOptimizer) SimulateCostReduction() []map[string]interface{} {
	results := []map[string]interface{}{}
	
	volumes := []int{1000, 5000, 10000, 50000, 100000}
	
	for _, v := range volumes {
		h1Cost := co.OptimizeBOMCost(H1, v)
		g1Cost := co.OptimizeBOMCost(G1, v)
		
		results = append(results, map[string]interface{}{
			"annual_volume":    v,
			"h1_unit_cost":     h1Cost["optimized_cost_cny"],
			"g1_unit_cost":     g1Cost["optimized_cost_cny"],
			"h1_savings_pct":   h1Cost["savings_pct"],
			"g1_savings_pct":   g1Cost["savings_pct"],
		})
	}
	
	return results
}

func roundFloat(val float64, precision int) float64 {
	ratio := math.Pow(10, float64(precision))
	return math.Round(val*ratio) / ratio
}

func main() {
	fmt.Println("=" + " 宇树科技智能制造产线调度系统 v1.0 " + strings.Repeat("=", 30))
	
	scheduler := NewScheduler()
	
	// 2026年生产计划
	orders := []ProductionOrder{
		{ID: "ORD-2026-001", Model: H1, Quantity: 8000, Priority: 1},
		{ID: "ORD-2026-002", Model: G1, Quantity: 4000, Priority: 2},
		{ID: "ORD-2026-003", Model: H1, Quantity: 3000, Priority: 1},
	}
	
	fmt.Println("\n📋 2026年度生产计划调度:")
	fmt.Printf("  订单: H1 %d台 + G1 %d台\n", 11000, 4000)
	
	result := scheduler.ScheduleProduction(orders)
	
	if feasible, ok := result["feasible"].(bool); ok && feasible {
		fmt.Printf("  ✅ 产能可行\n")
		fmt.Printf("  H1产能利用率: %v%%\n", result["h1_utilization_pct"])
		fmt.Printf("  G1产能利用率: %v%%\n", result["g1_utilization_pct"])
	} else {
		fmt.Printf("  ❌ %v\n", result["suggestion"])
	}
	
	// 物料检查
	fmt.Println("\n📦 物料状态:")
	if compStatus, ok := result["component_status"].(map[string]interface{}); ok {
		if status, ok := compStatus["status"].(map[string]string); ok {
			for comp, st := range status {
				fmt.Printf("  %s: %s\n", comp, st)
			}
		}
		if alerts, ok := compStatus["alerts"].([]string); ok {
			for _, alert := range alerts {
				fmt.Printf("  ⚠️ %s\n", alert)
			}
		}
	}
	
	// 成本优化模拟
	fmt.Println("\n💰 降本路线模拟:")
	optimizer := NewCostOptimizer()
	costResults := optimizer.SimulateCostReduction()
	
	fmt.Printf("  %-15s %-12s %-12s %-12s\n", "年产量", "H1成本(万)", "G1成本(万)", "降幅")
	for _, r := range costResults {
		fmt.Printf("  %-15d %-12.2f %-12.2f %-12.1f%%\n",
			r["annual_volume"],
			r["h1_unit_cost"],
			r["g1_unit_cost"],
			r["h1_savings_pct"],
		)
	}
	
	fmt.Printf("\n📈 关键结论:\n")
	fmt.Printf("  年产量10万台时，H1单台成本可降至%.1f万元\n", costResults[4]["h1_unit_cost"].(float64))
	fmt.Printf("  2026年目标15,000台，H1成本约%.1f万元\n", costResults[0]["h1_unit_cost"].(float64))
	fmt.Printf("  自研优势 + 规模效应 = 价格竞争力持续增强\n")
}

// 需要此包
var _ = strings.Repeat