档案库房空气净化与温湿度协同调控，避免局部环境超标的实现方案

┌─────────────────────────────────────────────────────────────────────┐
│ 独立运行时的典型冲突场景                                           │
│                                                                     │
│  场景1：新风机引入室外污染空气                                     │
│  ┌─────────┐     ┌─────────┐     ┌─────────┐                      │
│  │ 新风机  │────▶│ 库房    │────▶│ 净化设备│                      │
│  │ (引入   │     │ 环境    │     │ (后处理 │                      │
│  │  新风)  │     │ 被污染  │     │  污染)  │                      │
│  └─────────┘     └─────────┘     └─────────┘                      │
│  问题：新风未经净化直接送入，净化设备满负荷也处理不完               │
│                                                                     │
│  场景2：净化设备放热干扰温湿度                                     │
│  ┌─────────┐     ┌─────────┐                                      │
│  │ 净化机组│────▶│ 温度上升│────▶ 空调频繁启动                     │
│  │ (风机   │     │ 0.5~1℃ │     (互相抵消，能耗翻倍)              │
│  │  发热)  │     └─────────┘                                      │
│  └─────────┘                                                      │
│                                                                     │
│  场景3：除湿机与净化设备抢风道                                     │
│  ┌─────────┐     ┌─────────┐                                      │
│  │ 除湿机  │────▶│ 风道静  │────▶ 净化设备风量不足                 │
│  │ (大风量)│     │ 压不足  │                                      │
│  └─────────┘     └─────────┘                                      │
│                                                                     │
│  场景4：局部净化导致局部温湿度异常                                 │
│  ┌─────────┐     ┌─────────┐                                      │
│  │ FFU     │────▶│ 密集架  │────▶ 局部风速过大→蒸发效应→湿度下降  │
│  │ (正上方 │     │ 上层    │     同时风机热量→温度上升             │
│  │  直吹)  │     │ 超标    │                                      │
│  └─────────┘     └─────────┘                                      │
└─────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────┐
│ 空气净化与温湿度协同调控系统架构                                   │
│                                                                     │
│  ┌───────────────────────────────────────────────────────────────┐ │
│  │ 感知层（多参数融合采集）                                       │ │
│  │  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐            │ │
│  │  │温湿度   │ │PM2.5/   │ │VOCs/    │ │CO₂/     │            │ │
│  │  │传感器   │ │颗粒物   │ │甲醛    │ │臭氧     │            │ │
│  │  └────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘            │ │
│  └───────┼───────────┼───────────┼───────────┼──────────────────┘ │
│          │           │           │           │                     │
│  ┌───────▼───────────▼───────────▼───────────▼──────────────────┐ │
│  │ 协同决策引擎（核心）                                           │ │
│  │  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐        │ │
│  │  │冲突检测模块  │  │优先级仲裁    │  │补偿计算模块  │        │ │
│  │  │·净化→发热   │  │·安全>环境   │  │·净化放热补偿│        │ │
│  │  │·新风→湿度   │  │·温湿度>净化 │  │·新风负荷补偿│        │ │
│  │  │·除湿→扬尘   │  │·净化>舒适   │  │·局部风速修正│        │ │
│  │  └──────┬───────┘  └──────┬───────┘  └──────┬───────┘        │ │
│  └─────────┼──────────────────┼──────────────────┼───────────────┘ │
│            │                  │                  │                   │
│  ┌─────────▼──────────────────▼──────────────────▼───────────────┐ │
│  │ 执行层（统一调度）                                             │ │
│  │  ┌────────────┐ ┌────────────┐ ┌────────────┐ ┌────────────┐ │ │
│  │  │空调/除湿  │ │净化机组   │ │新风机     │ │风阀/风口  │ │ │
│  │  │(温湿度)   │ │(空气净化) │ │(新风量)   │ │(气流组织) │ │ │
│  │  └────────────┘ └────────────┘ └────────────┘ └────────────┘ │ │
│  └───────────────────────────────────────────────────────────────┘ │
│                                                                     │
│  ┌───────────────────────────────────────────────────────────────┐ │
│  │ 约束条件库                                                     │ │
│  │  · 设备物理约束（最大功率、最小启停间隔、风量范围）            │ │
│  │  · 环境标准约束（温度/湿度/污染物浓度上下限）                  │ │
│  │  · 互锁规则（净化设备臭氧浓度>阈值→自动停机）                 │ │
│  │  · 能耗约束（峰电时段限制大功率设备同时启动）                  │ │
│  └───────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────┘

# conflict_detector.py
from dataclasses import dataclass
from typing import Dict, List, Optional
import time

@dataclass
class ConflictEvent:
    """冲突事件"""
    conflict_type: str
    severity: str          # low / medium / high / critical
    description: str
    affected_devices: List[str]
    compensation_available: bool
    compensation_action: Optional[str] = None

class ConflictDetector:
    """净化与温湿度冲突检测器"""

    def __init__(self):
        self.conflicts: List[ConflictEvent] = []

    def check_purifier_heat_conflict(self,
                                    purifier_running: bool,
                                    purifier_power: float,
                                    current_temp: float,
                                    temp_setpoint: float,
                                    ac_available: bool) -> Optional[ConflictEvent]:
        """
        检测净化设备发热与温度控制的冲突

        净化设备（尤其是带UV灯的光催化净化器）运行时产生热量，
        可能导致局部或整体温度上升，与空调制冷形成对抗。
        """
        if not purifier_running:
            return None

        # 估算净化设备发热量对温度的影响
        # 简化模型：每100W热量在200㎡库房中约升温0.1℃/h
        estimated_temp_rise = (purifier_power / 100) * 0.1  # ℃/h

        # 如果当前温度已经接近上限，净化发热可能导致超标
        margin = temp_setpoint + 0.5 - current_temp  # 距上限的余量

        if estimated_temp_rise > margin and not ac_available:
            return ConflictEvent(
                conflict_type="purifier_heat",
                severity="high",
                description=f"净化设备发热({estimated_temp_rise:.1f}℃/h)可能导致温度超标，且无可用空调",
                affected_devices=["purifier", "ac"],
                compensation_available=False
            )
        elif estimated_temp_rise > margin * 0.5:
            return ConflictEvent(
                conflict_type="purifier_heat",
                severity="medium",
                description=f"净化设备发热({estimated_temp_rise:.1f}℃/h)将增加空调负荷",
                affected_devices=["purifier", "ac"],
                compensation_available=True,
                compensation_action="precool_before_purifier"
            )

        return None

    def check_fresh_air_humidity_conflict(self,
                                         outdoor_humi: float,
                                         outdoor_temp: float,
                                         current_indoor_humi: float,
                                         humi_upper: float,
                                         dehumidifier_available: bool) -> Optional[ConflictEvent]:
        """
        检测新风机引入室外空气对湿度的影响

        梅雨季或高湿天气，室外湿度可能>80%RH，引入新风会显著增加除湿负荷。
        """
        if outdoor_humi <= 60:
            return None  # 室外湿度可接受

        # 估算新风引入后的湿度增量
        # 简化：假设新风比30%，室外湿度80%RH，室内50%RH
        fresh_air_ratio = 0.3
        estimated_humi_increase = (outdoor_humi - current_indoor_humi) * fresh_air_ratio

        if current_indoor_humi + estimated_humi_increase > humi_upper:
            if not dehumidifier_available:
                return ConflictEvent(
                    conflict_type="fresh_air_humidity",
                    severity="high",
                    description=f"室外湿度{outdoor_humi:.0f}%RH，引入新风将导致室内湿度超标",
                    affected_devices=["fresh_air_unit", "dehumidifier"],
                    compensation_available=False,
                    compensation_action="reduce_fresh_air_or_wait"
                )
            else:
                return ConflictEvent(
                    conflict_type="fresh_air_humidity",
                    severity="medium",
                    description=f"室外湿度偏高，新风引入将增加除湿负荷",
                    affected_devices=["fresh_air_unit", "dehumidifier"],
                    compensation_available=True,
                    compensation_action="pre_dehumidify_before_fresh_air"
                )

        return None

    def check_ffu_local_disturbance(self,
                                   ffu_locations: List[dict],
                                   zone_temp: float,
                                   zone_humi: float) -> List[ConflictEvent]:
        """
        检测FFU（风机过滤单元）局部直吹导致的微环境异常

        FFU安装在密集架上方时，高速气流直吹档案表面，
        产生蒸发效应导致局部湿度下降，同时风机热量导致局部温度上升。
        """
        conflicts = []

        for ffu in ffu_locations:
            if not ffu.get('running', False):
                continue

            airflow_speed = ffu.get('airflow_speed', 0)  # m/s
            distance_to_archives = ffu.get('distance_to_archives', 1.0)  # m

            # 风速过大且距离档案太近
            if airflow_speed > 1.5 and distance_to_archives < 0.5:
                conflicts.append(ConflictEvent(
                    conflict_type="ffu_local_disturbance",
                    severity="medium",
                    description=f"FFU风速过大({airflow_speed}m/s)且距档案过近({distance_to_archives}m)，可能导致局部湿度下降",
                    affected_devices=[ffu['id']],
                    compensation_available=True,
                    compensation_action="reduce_ffu_speed_or_adjust_angle"
                ))

        return conflicts

    def check_dehumidifier_dust_resuspension(self,
                                           dehumidifier_running: bool,
                                           air_quality_index: float) -> Optional[ConflictEvent]:
        """
        检测除湿机运行导致扬尘的问题

        除湿机内部风机搅动空气，可能将沉降的颗粒物重新扬起。
        在净化设备未运行时尤其明显。
        """
        if not dehumidifier_running:
            return None

        if air_quality_index > 75:  # 空气质量较差时
            return ConflictEvent(
                conflict_type="dehumidifier_dust",
                severity="low",
                description="除湿机运行可能重新扬起已沉降颗粒物",
                affected_devices=["dehumidifier", "purifier"],
                compensation_available=True,
                compensation_action="start_purifier_with_dehumidifier"
            )

        return None

    def detect_all_conflicts(self, system_state: dict) -> List[ConflictEvent]:
        """检测所有冲突"""
        conflicts = []

        # 1. 净化发热冲突
        c = self.check_purifier_heat_conflict(
            system_state.get('purifier_running', False),
            system_state.get('purifier_power', 0),
            system_state.get('current_temp', 22),
            system_state.get('temp_setpoint', 22),
            system_state.get('ac_available', True)
        )
        if c:
            conflicts.append(c)

        # 2. 新风湿度冲突
        c = self.check_fresh_air_humidity_conflict(
            system_state.get('outdoor_humi', 50),
            system_state.get('outdoor_temp', 25),
            system_state.get('current_humi', 50),
            system_state.get('humi_upper', 60),
            system_state.get('dehumidifier_available', True)
        )
        if c:
            conflicts.append(c)

        # 3. FFU局部扰动
        conflicts.extend(self.check_ffu_local_disturbance(
            system_state.get('ffu_locations', []),
            system_state.get('zone_temp', 22),
            system_state.get('zone_humi', 50)
        ))

        # 4. 除湿扬尘
        c = self.check_dehumidifier_dust_resuspension(
            system_state.get('dehumidifier_running', False),
            system_state.get('air_quality_index', 50)
        )
        if c:
            conflicts.append(c)

        self.conflicts = conflicts
        return conflicts

#协同控制引擎
#协同控制引擎
# synergy_controller.py
from enum import Enum
from dataclasses import dataclass, field
from typing import Dict, List, Optional
import time

class SynergyMode(Enum):
    INDEPENDENT = "independent"       # 独立模式（无协同）
    COMPENSATED = "compensated"       # 补偿模式（净化前预调节）
    COUPLED = "coupled"               # 耦合模式（联合优化）
    EMERGENCY = "emergency"           # 紧急模式（优先安全）

@dataclass
class SynergyCommand:
    """协同控制指令"""
    command_id: str
    mode: SynergyMode
    steps: List[dict]  # 有序执行步骤
    estimated_duration: float
    priority: int
    reason: str

class SynergyController:
    """净化与温湿度协同控制器"""

    def __init__(self):
        self.current_mode = SynergyMode.INDEPENDENT
        self.active_commands: List[SynergyCommand] = []
        self.conflict_detector = ConflictDetector()
        self.lock = threading.RLock()

        # 补偿参数
        self.purifier_heat_compensation = 0.3   # ℃，净化前预冷量
        self.fresh_air_humi_margin = 5.0       # %RH，新风前预除湿余量
        self.ffu_speed_limit = 1.2             # m/s，FFU最大推荐风速
        self.dehumidifier_purifier_delay = 30   # 秒，除湿机与净化机联动延时

    def evaluate_and_decide(self, system_state: dict) -> Optional[SynergyCommand]:
        """
        评估当前状态并生成协同控制指令

        这是协同调控的核心决策函数。
        """
        # Step 1: 检测冲突
        conflicts = self.conflict_detector.detect_all_conflicts(system_state)

        if not conflicts:
            # 无冲突，可独立运行
            return None

        # Step 2: 按严重程度排序
        high_conflicts = [c for c in conflicts if c.severity in ("high", "critical")]
        medium_conflicts = [c for c in conflicts if c.severity == "medium"]

        # Step 3: 生成协同指令
        if high_conflicts:
            # 高严重度冲突 → 耦合模式
            command = self._generate_coupled_command(high_conflicts, system_state)
        elif medium_conflicts:
            # 中严重度冲突 → 补偿模式
            command = self._generate_compensated_command(medium_conflicts, system_state)
        else:
            return None

        with self.lock:
            self.active_commands.append(command)

        return command

    def _generate_compensated_command(self, conflicts: List[ConflictEvent],
                                     state: dict) -> SynergyCommand:
        """生成补偿模式指令（净化前预调节）"""
        steps = []

        for conflict in conflicts:
            if conflict.conflict_type == "purifier_heat":
                # 净化前预冷
                steps.append({
                    'order': 1,
                    'action': 'precool',
                    'device': 'ac',
                    'parameter': {
                        'target_temp': state.get('temp_setpoint', 22) - self.purifier_heat_compensation
                    },
                    'duration': 300,  # 预冷5分钟
                    'wait_for': 'temp_reached'
                })
                steps.append({
                    'order': 2,
                    'action': 'start_purifier',
                    'device': 'purifier',
                    'parameter': {'power': 'normal'},
                    'duration': 0,
                    'wait_for': None
                })
                steps.append({
                    'order': 3,
                    'action': 'restore_temp_setpoint',
                    'device': 'ac',
                    'parameter': {'target_temp': state.get('temp_setpoint', 22)},
                    'duration': 0,
                    'wait_for': None
                })

            elif conflict.conflict_type == "fresh_air_humidity":
                # 新风前预除湿
                steps.append({
                    'order': 1,
                    'action': 'pre_dehumidify',
                    'device': 'dehumidifier',
                    'parameter': {'target_humi': state.get('humi_setpoint', 50) - self.fresh_air_humi_margin},
                    'duration': 600,  # 预除湿10分钟
                    'wait_for': 'humi_reached'
                })
                steps.append({
                    'order': 2,
                    'action': 'increase_fresh_air',
                    'device': 'fresh_air_unit',
                    'parameter': {'airflow': 'high'},
                    'duration': 0,
                    'wait_for': None
                })

            elif conflict.conflict_type == "ffu_local_disturbance":
                # 调整FFU参数
                steps.append({
                    'order': 1,
                    'action': 'adjust_ffu',
                    'device': 'ffu',
                    'parameter': {
                        'speed': min(self.ffu_speed_limit, state.get('ffu_current_speed', 2.0) * 0.7),
                        'angle': 'redirect_away_from_archives'
                    },
                    'duration': 0,
                    'wait_for': None
                })

            elif conflict.conflict_type == "dehumidifier_dust":
                # 联动启动净化
                steps.append({
                    'order': 1,
                    'action': 'start_purifier',
                    'device': 'purifier',
                    'parameter': {'mode': 'high'},
                    'duration': 0,
                    'wait_for': None
                })
                steps.append({
                    'order': 2,
                    'action': 'start_dehumidifier',
                    'device': 'dehumidifier',
                    'parameter': {'mode': 'normal'},
                    'duration': self.dehumidifier_purifier_delay,
                    'wait_for': 'delay_elapsed'
                })

        return SynergyCommand(
            command_id=f"comp_{int(time.time())}",
            mode=SynergyMode.COMPENSATED,
            steps=sorted(steps, key=lambda x: x['order']),
            estimated_duration=max(s.get('duration', 0) for s in steps) + 300,
            priority=2,
            reason=f"补偿模式：{len(conflicts)}个中等级别冲突"
        )

    def _generate_coupled_command(self, conflicts: List[ConflictEvent],
                                 state: dict) -> SynergyCommand:
        """生成耦合模式指令（联合优化）"""
        steps = []

        # 高严重度冲突需要联合优化
        for conflict in conflicts:
            if conflict.conflict_type == "purifier_heat" and not conflict.compensation_available:
                # 净化发热且无空调可用 → 必须限制净化功率
                steps.append({
                    'order': 1,
                    'action': 'limit_purifier_power',
                    'device': 'purifier',
                    'parameter': {'power_limit': '50%'},
                    'duration': 0,
                    'wait_for': None
                })
                steps.append({
                    'order': 2,
                    'action': 'increase_ventilation',
                    'device': 'exhaust_fan',
                    'parameter': {'speed': 'high'},
                    'duration': 0,
                    'wait_for': None
                })

            elif conflict.conflict_type == "fresh_air_humidity" and not conflict.compensation_available:
                # 新风湿度高且无除湿机可用 → 必须减少新风
                steps.append({
                    'order': 1,
                    'action': 'reduce_fresh_air',
                    'device': 'fresh_air_unit',
                    'parameter': {'airflow': 'minimum'},
                    'duration': 0,
                    'wait_for': None
                })
                steps.append({
                    'order': 2,
                    'action': 'activate_recirculation_purifier',
                    'device': 'purifier',
                    'parameter': {'mode': 'recirculation_only'},
                    'duration': 0,
                    'wait_for': None
                })

        return SynergyCommand(
            command_id=f"coup_{int(time.time())}",
            mode=SynergyMode.COUPLED,
            steps=sorted(steps, key=lambda x: x['order']),
            estimated_duration=600,
            priority=1,
            reason=f"耦合模式：{len(conflicts)}个高严重度冲突，需联合优化"
        )

    def execute_command(self, command: SynergyCommand) -> dict:
        """执行协同指令（返回执行状态）"""
        execution_log = {
            'command_id': command.command_id,
            'mode': command.mode.value,
            'steps_executed': [],
            'status': 'in_progress',
            'start_time': time.time()
        }

        for step in command.steps:
            # 实际项目中这里会调用设备驱动接口
            log_entry = {
                'step': step['order'],
                'action': step['action'],
                'device': step['device'],
                'parameter': step['parameter'],
                'executed_at': time.time(),
                'status': 'executed'
            }
            execution_log['steps_executed'].append(log_entry)

            # 如果有等待条件，模拟等待
            if step['wait_for'] and step['duration'] > 0:
                time.sleep(min(step['duration'], 5))  # 模拟等待（实际不会sleep）

        execution_log['status'] = 'completed'
        execution_log['end_time'] = time.time()

        return execution_log

    def get_current_mode(self) -> SynergyMode:
        """获取当前协同模式"""
        return self.current_mode

┌─────────────────────────────────────────────────────────────────────┐
│ 局部环境超标成因树                                                 │
│                                                                     │
│  局部温湿度超标                                                     │
│  ├── 气流组织不合理                                                │
│  │   ├── FFU直吹密集架 → 蒸发效应 → 局部干燥                      │
│  │   ├── 送风口正对档案 → 局部低温/高湿                            │
│  │   ├── 回风口位置不当 → 局部空气滞留                             │
│  │   └── 风阀开度不均 → 区域风量分配失衡                           │
│  ├── 设备布局不合理                                                │
│  │   ├── 净化设备靠近密集架 → 热量/气流直接影响                    │
│  │   ├── 除湿机出风口朝向档案 → 局部过干                           │
│  │   └── 空调回风口吸入净化排风 → 短路循环                         │
│  ├── 建筑结构因素                                                  │
│  │   ├── 外墙传热 → 西墙区域高温                                   │
│  │   ├── 屋顶日照 → 上层高温                                       │
│  │   ├── 地面冷辐射 → 下层低温                                     │
│  │   └── 管道穿墙缝隙 → 局部渗风                                   │
│  └── 运维操作因素                                                  │
│      ├── 密集架合拢 → 内部空气不流通                               │
│      ├── 临时堆放档案 → 堵塞风道                                   │
│      └── 净化设备滤网堵塞 → 风量下降 → 局部净化不足                 │
│                                                                     │
│  局部污染物超标                                                     │
│  ├── 新风入口位置不当 → 吸入室外高污染空气                         │
│  ├── 净化设备覆盖死角 → 角落污染物堆积                             │
│  ├── 人员活动区域 → 扬尘、CO₂集中                                 │
│  └── 新档案入库 → 集中释放VOCs/甲醛                               │
└─────────────────────────────────────────────────────────────────────┘

# local_micro_env.py
from dataclasses import dataclass
from typing import Dict, List, Optional
import numpy as np

@dataclass
class MicroZone:
    """微环境区域"""
    zone_id: str
    location: str           # 物理位置描述
    sensors: List[str]      # 该区域的传感器
    temp_setpoint: float
    humi_setpoint: float
    pollutant_limits: dict  # 污染物限值
    local_devices: List[str]  # 可独立控制的局部设备（FFU、局部风口等）

class MicroEnvironmentController:
    """微环境控制器"""

    def __init__(self):
        self.micro_zones: Dict[str, MicroZone] = {}
        self.zone_readings: Dict[str, dict] = {}
        self.lock = threading.RLock()

    def register_zone(self, zone: MicroZone):
        """注册微环境区域"""
        self.micro_zones[zone.zone_id] = zone

    def update_readings(self, zone_id: str, readings: dict):
        """更新区域读数"""
        with self.lock:
            self.zone_readings[zone_id] = readings

    def check_local_exceed(self, zone_id: str) -> dict:
        """检查局部是否超标"""
        if zone_id not in self.micro_zones:
            return {"status": "unknown_zone"}

        zone = self.micro_zones[zone_id]
        readings = self.zone_readings.get(zone_id, {})

        if not readings:
            return {"status": "no_readings"}

        issues = []

        # 温湿度检查
        temp = readings.get('temperature', 22)
        humi = readings.get('humidity', 50)

        if temp > zone.temp_setpoint + 0.5:
            issues.append({
                'type': 'temperature_high',
                'current': temp,
                'limit': zone.temp_setpoint + 0.5,
                'severity': 'high' if temp > zone.temp_setpoint + 1.0 else 'medium'
            })

        if humi > zone.humi_setpoint + 5:
            issues.append({
                'type': 'humidity_high',
                'current': humi,
                'limit': zone.humi_setpoint + 5,
                'severity': 'high' if humi > zone.humi_setpoint + 10 else 'medium'
            })

        if humi < zone.humi_setpoint - 5:
            issues.append({
                'type': 'humidity_low',
                'current': humi,
                'limit': zone.humi_setpoint - 5,
                'severity': 'medium'
            })

        # 污染物检查
        for pollutant, limit in zone.pollutant_limits.items():
            value = readings.get(pollutant, 0)
            if value > limit:
                issues.append({
                    'type': f'{pollutant}_high',
                    'current': value,
                    'limit': limit,
                    'severity': 'high'
                })

        return {
            'status': 'exceed' if issues else 'normal',
            'zone_id': zone_id,
            'issues': issues,
            'recommendation': self._generate_local_recommendation(zone, issues)
        }

    def _generate_local_recommendation(self, zone: MicroZone, issues: List[dict]) -> List[str]:
        """生成局部调控建议"""
        recommendations = []

        for issue in issues:
            if issue['type'] == 'temperature_high':
                # 局部温度偏高
                if 'ffu' in ' '.join(zone.local_devices).lower():
                    recommendations.append("降低FFU风速（减少风机发热）")
                if 'damper' in ' '.join(zone.local_devices).lower():
                    recommendations.append("开大该区域风阀（增加冷风供应）")
                recommendations.append("检查是否有净化设备热源靠近该区域")

            elif issue['type'] == 'humidity_low':
                # 局部湿度偏低
                if 'ffu' in ' '.join(zone.local_devices).lower():
                    recommendations.append("降低FFU风速或调整送风角度（减少蒸发效应）")
                recommendations.append("考虑在该区域增加局部加湿或调整送风湿度")

            elif issue['type'] == 'humidity_high':
                # 局部湿度偏高
                if 'ffu' in ' '.join(zone.local_devices).lower():
                    recommendations.append("增大FFU风量（促进空气循环，辅助除湿）")
                recommendations.append("检查是否有渗水或室外湿空气渗入")

            elif 'pm25' in issue['type'] or 'voc' in issue['type'] or 'formaldehyde' in issue['type']:
                # 污染物偏高
                if 'purifier' in ' '.join(zone.local_devices).lower():
                    recommendations.append("增大该区域净化设备功率")
                recommendations.append("检查新风入口是否吸入室外污染")
                recommendations.append("检查是否有新档案入库释放污染物")

        return list(set(recommendations))  # 去重

┌─────────────────────────────────────────────────────────────────────┐
│ 执行时序                                                             │
│                                                                     │
│  T-30min: 预除湿阶段                                                │
│  ├── 启动除湿机，将库房湿度从50%RH降至42%RH（预留余量）             │
│  └── 关闭新风机，切换为内循环模式                                   │
│                                                                     │
│  T-10min: 净化预热                                                  │
│  ├── 启动净化机组（不带UV灯，避免发热）                             │
│  └── 开启密集架通道FFU，低速运行（0.8m/s）                         │
│                                                                     │
│  T=0: 新档案入库                                                    │
│  ├── 入库区域密集架暂时打开                                         │
│  ├── 净化机组切换为"高风量+活性炭"模式                              │
│  └── 空调设定温度下调0.3℃（补偿净化发热）                          │
│                                                                     │
│  T+2h: 稳定阶段                                                     │
│  ├── 监测入库区域微环境（温湿度+TVOC）                              │
│  ├── 如湿度回升至>55%RH，增加除湿机功率                            │
│  └── 如VOCs>0.3mg/m³，维持净化高功率                               │
│                                                                     │
│  T+24h: 恢复阶段                                                    │
│  ├── 新档案VOCs释放量下降                                           │
│  ├── 逐步降低净化功率                                               │
│  ├── 恢复新风量（室外湿度<70%RH时）                                 │
│  └── 恢复空调设定温度                                               │
└─────────────────────────────────────────────────────────────────────┘