空调续命之外的清凉：这是我们的夏日降温「新」方案

# 简化模拟：循环扇对室内温度分布的影响
import numpy as np

def simulate_air_distribution(room_size, ac_temp, fan_power, time_steps):
    """
    room_size: (x, y, z) 单位米
    ac_temp: 空调设定温度
    fan_power: 0-1 循环扇功率系数
    """
    # 初始化温度场：空调冷风从顶部进入
    grid = np.ones((20, 20, 10)) * 35  # 初始室温35℃
    
    for t in range(time_steps):
        # 空调制冷层（顶部）
        grid[:, :, -1] = ac_temp
        
        # 循环扇扰动：增强垂直方向热交换
        mixing = fan_power * 0.3
        for z in range(1, grid.shape[2]):
            grid[:, :, z] += mixing * (grid[:, :, z-1] - grid[:, :, z])
        
        # 热空气上升（简化对流）
        grid += 0.01 * (grid.mean() - grid)
    
    return grid

# 对比：无循环扇 vs 有循环扇
no_fan = simulate_air_distribution((5,5,3), 26, 0, 100).std()
with_fan = simulate_air_distribution((5,5,3), 26, 0.8, 100).std()
print(f"温度标准差降低: {(no_fan - with_fan)/no_fan*100:.1f}%")

// PCM状态机简化模型
type PCMState int

const (
    Solid PCMState = iota
    Transitioning
    Liquid
)

type PhaseChangeMaterial struct {
    phaseChangeTemp float64 // °C, e.g., 30.0
    latentHeat      float64 // J/kg, 相变潜热，石蜡类约200kJ/kg
    currentTemp     float64
    state           PCMState
}

func (pcm *PhaseChangeMaterial) AbsorbHeat(heatFlux float64, duration float64) {
    pcm.currentTemp += heatFlux * duration / pcm.HeatCapacity()
    
    if pcm.currentTemp >= pcm.phaseChangeTemp && pcm.state == Solid {
        pcm.state = Transitioning
        // 潜热吸收：温度平台期
        absorbed := heatFlux * duration
        if absorbed >= pcm.latentHeat {
            pcm.state = Liquid
        }
    }
}

func (pcm *PhaseChangeMaterial) HeatCapacity() float64 {
    // 固/液态比热容 + 相变潜热的等效热容
    if pcm.state == Transitioning {
        return pcm.latentHeat / 0.5 // 假设相变温宽0.5℃
    }
    return 2000 // J/(kg·K)，近似值
}

// 半导体制冷片的性能计算
interface PeltierModule {
    maxVoltage: number;      // V
    maxCurrent: number;      // A
    maxTempDifference: number; // ΔT max, K
    resistance: number;       // Ω
}

function calculateCoolingPerformance(
    module: PeltierModule,
    inputCurrent: number,
    hotSideTemp: number
): { coolingPower: number; cop: number } {
    // 帕尔帖系数（近似：α ≈ 2.0e-4 * T_avg, V/K 量级)
    const alpha = 0.12; // 典型值，V/K
    
    // 吸热端: Qc = α * I * Tc - 0.5 * I² * R - K * ΔT
    // 为简化，使用厂商提供的性能曲线拟合
    const currentRatio = inputCurrent / module.maxCurrent;
    const actualDeltaT = module.maxTempDifference * (1 - currentRatio * 0.3);
    const coldSideTemp = hotSideTemp - actualDeltaT;
    
    // 总输入功率
    const inputPower = inputCurrent * module.maxVoltage * 0.8; // 简化
    
    // 有效制冷量（经验估算）
    const coolingPower = alpha * inputCurrent * coldSideTemp - 
                         0.5 * Math.pow(inputCurrent, 2) * module.resistance;
    
    const cop = Math.max(0, coolingPower / inputPower);
    
    return { coolingPower, cop };
}

// 典型场景：户外35℃，目标降温至28℃
const typicalModule: PeltierModule = {
    maxVoltage: 12,
    maxCurrent: 6,
    maxTempDifference: 70,
    resistance: 1.8
};

const result = calculateCoolingPerformance(typicalModule, 4, 35);
console.log(`COP: ${result.cop.toFixed(2)}, 制冷量: ${result.coolingPower.toFixed(1)}W`);
// 输出: COP约0.4-0.5，远低于空调压缩机的3-4

import math

def calculate_dew_point(temperature_c: float, relative_humidity: float) -> float:
    """
    Magnus公式计算露点温度
    """
    a, b = 17.62, 243.12
    alpha = math.log(relative_humidity / 100.0) + (a * temperature_c) / (b + temperature_c)
    dew_point = (b * alpha) / (a - alpha)
    return dew_point

def safe_water_temperature(room_temp: float, humidity: float, safety_margin: float = 1.5) -> float:
    """
    返回安全的水循环温度（高于露点+safety_margin）
    """
    dp = calculate_dew_point(room_temp, humidity)
    return max(dp + safety_margin, 18.0)  # 不低于18℃避免过冷

# 场景：空调房26℃，湿度60%
print(f"露点: {calculate_dew_point(26, 60):.1f}℃")  # ≈17.8℃
print(f"安全水温: {safe_water_temperature(26, 60):.1f}℃")  # ≈19.3℃