⚡

膜系统设计Skill membrane-system-design

膜系统设计技能提供全面的膜处理系统设计能力，涵盖工艺选择、通量计算、污染分析、预处理要求评估、浓水管理规划等关键领域。

水和废水处理 0 次安装 5 次浏览 更新于 2/25/2026

name: membrane-system-design description: 专家技能，涵盖膜过滤和分离系统设计，包括工艺选择、通量计算、污染分析和浓水管理。 allowed-tools: 阅读，搜索，写入，Bash，编辑，全局 category: 水和废水处理 backlog-id: SK-003 metadata: author: babysitter-sdk version: “1.0.0”

膜系统设计技能

水和废水处理应用中的膜过滤和分离系统设计。

目的

这项技能提供了全面的设计膜处理系统的能力，包括工艺选择、通量和回收率计算、污染分析、预处理要求和浓水管理规划。

能力

膜工艺选择

  • 微滤（MF）应用
  • 超滤（UF）应用
  • 纳滤（NF）应用
  • 反渗透（RO）应用
  • 工艺选择标准和决策矩阵
  • 混合系统配置

通量和回收率计算

  • 设计通量确定
  • 温度校正因子
  • 回收率优化
  • 浓度极化效应
  • 渗透压计算
  • 渗透液质量估算

预处理要求评估

  • 给水特性
  • 泥沙密度指数（SDI）分析
  • 改良污染指数（MFI）计算
  • 预处理技术选择
  • 化学调节要求

污染分析和缓解

  • 污染机制识别
  • 生物污染评估
  • 结垢潜力分析
  • 胶体污染评估
  • 有机污染特性
  • 缓解策略开发

浓水管理规划

  • 浓水特性
  • 处置选项评估
  • 零液体排放（ZLD）考虑
  • 盐水浓缩技术
  • 处置的法规合规性

CIP系统设计

  • 就地清洁系统配置
  • 化学清洗协议
  • 清洗频率优化
  • 化学兼容性评估
  • 清洗效果监测

能量回收装置选择

  • 压力交换器尺寸
  • 涡轮充电器系统
  • 能量回收效率
  • 经济分析
  • 系统集成

膜试验测试协议

  • 试验系统设计
  • 测试协议开发
  • 数据收集要求
  • 性能指标
  • 放大考虑

先决条件

安装

pip install numpy scipy pandas matplotlib

可选依赖

# 用于优化
pip install scipy pymoo

# 用于可视化
pip install plotly seaborn

使用模式

膜系统尺寸

import numpy as np
from dataclasses import dataclass
from typing import Dict, List, Optional

@dataclass
class FeedWaterQuality:
    """给水质量参数"""
    tds_mg_l: float
    temperature_c: float
    ph: float
    tss_mg_l: float
    toc_mg_l: float
    hardness_mg_l: float = 0  # 作为CaCO3
    silica_mg_l: float = 0
    sdi: float = 0  # 泥沙密度指数

@dataclass
class MembraneElement:
    """膜元件规格"""
    manufacturer: str
    model: str
    area_m2: float
    permeability_lmh_bar: float  # L/m2/hr/bar
    salt_rejection: float  # 小数
    max_recovery: float  # 小数
    min_concentrate_flow_m3_hr: float

class ROSystemDesign:
    """反渗透系统设计"""

    def __init__(self, feed: FeedWaterQuality, element: MembraneElement):
        self.feed = feed
        self.element = element

    def osmotic_pressure(self, tds_mg_l: float) -> float:
        """计算渗透压，单位为bar"""
        # 简化的van't Hoff方程
        # pi = i * C * R * T
        # 对于典型水：pi（bar）≈ 0.0385 * TDS（g/L）
        return 0.0385 * (tds_mg_l / 1000) * (273.15 + self.feed.temperature_c) / 298.15

    def temperature_correction_factor(self) -> float:
        """通量的温度校正因子"""
        # TCF = exp(2640 * (1/298 - 1/T))
        T_kelvin = 273.15 + self.feed.temperature_c
        return np.exp(2640 * (1/298.15 - 1/T_kelvin))

    def calculate_flux(self, feed_pressure_bar: float, recovery: float) -> float:
        """计算渗透液通量，单位为LMH"""
        # 平均渗透压（考虑浓度极化）
        avg_concentration_factor = 1 / (1 - recovery/2)
        avg_tds = self.feed.tds_mg_l * avg_concentration_factor
        pi_avg = self.osmotic_pressure(avg_tds)

        # 净驱动压力
        ndp = feed_pressure_bar - pi_avg - 1  # 1 bar背压

        # 校正温度后的通量
        tcf = self.temperature_correction_factor()
        flux = self.element.permeability_lmh_bar * ndp * tcf

        return flux

    def design_system(self, feed_flow_m3_hr: float, target_recovery: float,
                      feed_pressure_bar: float) -> Dict:
        """为给定要求设计RO系统"""

        # 计算通量
        flux = self.calculate_flux(feed_pressure_bar, target_recovery)

        # 渗透液流量
        permeate_flow = feed_flow_m3_hr * target_recovery

        # 所需膜面积
        required_area = (permeate_flow * 1000) / flux  # m2

        # 元件数量
        num_elements = np.ceil(required_area / self.element.area_m2)

        # 每个容器的元件数（典型6-8）
        elements_per_vessel = 6
        num_vessels = np.ceil(num_elements / elements_per_vessel)
        actual_elements = num_vessels * elements_per_vessel

        # 浓水流量和质量
        concentrate_flow = feed_flow_m3_hr * (1 - target_recovery)
        concentrate_tds = self.feed.tds_mg_l / (1 - target_recovery)

        # 渗透液质量
        avg_passage = 1 - self.element.salt_rejection
        permeate_tds = self.feed.tds_mg_l * avg_passage * (1 + target_recovery)

        # 特定能耗估算
        pump_efficiency = 0.80
        sec_kwh_m3 = (feed_pressure_bar * 100) / (36 * pump_efficiency * target_recovery)

        return {
            'design_flux_lmh': flux,
            'required_area_m2': required_area,
            'num_vessels': int(num_vessels),
            'elements_per_vessel': elements_per_vessel,
            'total_elements': int(actual_elements),
            'permeate_flow_m3_hr': permeate_flow,
            'concentrate_flow_m3_hr': concentrate_flow,
            'permeate_tds_mg_l': permeate_tds,
            'concentrate_tds_mg_l': concentrate_tds,
            'specific_energy_kwh_m3': sec_kwh_m3
        }

# 示例用法
feed = FeedWaterQuality(
    tds_mg_l=2000,
    temperature_c=25,
    ph=7.5,
    tss_mg_l=5,
    toc_mg_l=3,
    sdi=3
)

element = MembraneElement(
    manufacturer='Example',
    model='BW30-400',
    area_m2=37.2,
    permeability_lmh_bar=3.5,
    salt_rejection=0.995,
    max_recovery=0.15,
    min_concentrate_flow_m3_hr=3.6
)

ro_system = ROSystemDesign(feed, element)
design = ro_system.design_system(
    feed_flow_m3_hr=100,
    target_recovery=0.75,
    feed_pressure_bar=15
)

print(f"设计通量: {design['design_flux_lmh']:.1f} LMH")
print(f"容器数量: {design['num_vessels']}")
print(f"总元件数: {design['total_elements']}")
print(f"渗透液TDS: {design['permeate_tds_mg_l']:.0f} mg/L")
print(f"特定能耗: {design['specific_energy_kwh_m3']:.2f} kWh/m3")

结垢潜力分析

class ScalingAnalysis:
    """膜结垢潜力分析"""

    # 25C时的溶解积常数
    Ksp = {
        'CaCO3': 3.3e-9,
        'CaSO4': 4.9e-5,
        'BaSO4': 1.1e-10,
        'SrSO4': 3.4e-7,
        'SiO2': 120  # mg/L饱和度
    }

    def __init__(self, water_quality: Dict):
        self.wq = water_quality

    def langelier_saturation_index(self, temperature_c: float,
                                   tds_mg_l: float) -> float:
        """计算CaCO3的Langelier饱和指数"""
        pH = self.wq.get('pH', 7.5)
        Ca = self.wq.get('Ca_mg_l', 100)
        alkalinity = self.wq.get('alkalinity_mg_l', 100)

        # pHs计算（简化）
        pCa = -np.log10(Ca / 40080)  # 转换为mol/L
        pAlk = -np.log10(alkalinity / 50040)

        # 温度和TDS校正
        A = (np.log10(tds_mg_l) - 1) / 10
        B = -13.12 * np.log10(temperature_c + 273) + 34.55
        C = np.log10(Ca / 40.08) - 0.4
        D = np.log10(alkalinity / 50.04)

        pHs = (9.3 + A + B) - C - D
        lsi = pH - pHs

        return lsi

    def stiff_davis_index(self, ionic_strength: float) -> float:
        """计算高TDS水的Stiff-Davis稳定性指数"""
        pH = self.wq.get('pH', 7.5)
        Ca = self.wq.get('Ca_mg_l', 100)
        alkalinity = self.wq.get('alkalinity_mg_l', 100)

        # 活度系数校正
        K = 2.22e-14  # CaCO3平衡常数

        pCa = -np.log10(Ca / 40080 * 0.4)  # 带活度校正
        pAlk = -np.log10(alkalinity / 50040 * 0.4)
        pK = -np.log10(K)

        pHs = pK + pCa + pAlk
        sdi = pH - pHs

        return sdi

    def calcium_sulfate_saturation(self, recovery: float) -> float:
        """计算给定回收率下的CaSO4饱和比"""
        Ca = self.wq.get('Ca_mg_l', 100)
        SO4 = self.wq.get('SO4_mg_l', 200)

        # 浓缩因子
        cf = 1 / (1 - recovery)

        # 浓水中的离子产物
        Ca_conc = (Ca / 40080) * cf  # mol/L
        SO4_conc = (SO4 / 96060) * cf  # mol/L
        ip = Ca_conc * SO4_conc

        # 饱和比
        sr = ip / self.Ksp['CaSO4']

        return sr

    def silica_saturation(self, recovery: float, temperature_c: float) -> float:
        """计算硅饱和比"""
        SiO2 = self.wq.get('SiO2_mg_l', 20)

        # 浓缩因子
        cf = 1 / (1 - recovery)
        SiO2_conc = SiO2 * cf

        # 温度依赖的饱和度（简化）
        saturation_limit = self.Ksp['SiO2'] + (temperature_c - 25) * 2

        return SiO2_conc / saturation_limit

    def analyze_scaling_potential(self, recovery: float,
                                  temperature_c: float = 25) -> Dict:
        """完整的结垢潜力分析"""
        tds_concentrate = self.wq.get('tds_mg_l', 1000) / (1 - recovery)

        results = {
            'recovery': recovery,
            'concentration_factor': 1 / (1 - recovery),
            'concentrate_tds_mg_l': tds_concentrate,
            'lsi': self.langelier_saturation_index(temperature_c, tds_concentrate),
            'caso4_saturation': self.calcium_sulfate_saturation(recovery),
            'silica_saturation': self.silica_saturation(recovery, temperature_c)
        }

        # 风险评估
        results['caco3_risk'] = 'HIGH' if results['lsi'] > 0.5 else \
                               'MODERATE' if results['lsi'] > 0 else 'LOW'
        results['caso4_risk'] = 'HIGH' if results['caso4_saturation'] > 0.8 else \
                               'MODERATE' if results['caso4_saturation'] > 0.5 else 'LOW'
        results['silica_risk'] = 'HIGH' if results['silica_saturation'] > 0.8 else \
                                'MODERATE' if results['silica_saturation'] > 0.5 else 'LOW'

        return results

# 示例用法
water_quality = {
    'pH': 7.8,
    'tds_mg_l': 2000,
    'Ca_mg_l': 150,
    'SO4_mg_l': 300,
    'alkalinity_mg_l': 180,
    'SiO2_mg_l': 25
}

scaling = ScalingAnalysis(water_quality)
results = scaling.analyze_scaling_potential(recovery=0.75, temperature_c=25)

print(f"浓缩因子: {results['concentration_factor']:.2f}x")
print(f"LSI: {results['lsi']:.2f} - CaCO3风险: {results['caco3_risk']}")
print(f"CaSO4饱和度: {results['caso4_saturation']:.2f} - 风险: {results['caso4_risk']}")
print(f"硅饱和度: {results['silica_saturation']:.2f} - 风险: {results['silica_risk']}")

CIP协议开发

class CIPProtocol:
    """就地清洁协议开发"""

    def __init__(self, membrane_type: str = 'polyamide'):
        self.membrane_type = membrane_type

        # 化学兼容性
        self.ph_limits = {
            'polyamide': (2, 11),
            'cellulose_acetate': (4, 7),
            'polysulfone': (1, 13)
        }

        self.temperature_limit = {
            'polyamide': 45,
            'cellulose_acetate': 35,
            'polysulfone': 50
        }

    def recommend_cleaning_chemicals(self, fouling_type: str) -> List[Dict]:
        """基于污染类型推荐清洁化学品"""
        recommendations = {
            'biofouling': [
                {'chemical': 'NaOH', 'concentration': '0.1%', 'ph': 12, 'temperature_c': 35},
                {'chemical': 'Biocide', 'concentration': 'Per manufacturer', 'ph': 7, 'temperature_c': 25}
            ],
            'organic': [
                {'chemical': 'NaOH', 'concentration': '0.1%', 'ph': 12, 'temperature_c': 35},
                {'chemical': 'Surfactant', 'concentration': '0.1%', 'ph': 10, 'temperature_c': 30}
            ],
            'colloidal': [
                {'chemical': 'NaOH', 'concentration': '0.1%', 'ph': 11, 'temperature_c': 30},
                {'chemical': 'EDTA', 'concentration': '1%', 'ph': 10, 'temperature_c': 30}
            ],
            'scale_calcium': [
                {'chemical': 'HCl', 'concentration': '0.2%', 'ph': 2, 'temperature_c': 25},
                {'chemical': 'Citric acid', 'concentration': '2%', 'ph': 3, 'temperature_c': 30}
            ],
            'scale_silica': [
                {'chemical': 'NaOH', 'concentration': '0.1%', 'ph': 11, 'temperature_c': 35}
            ]
        }

        return recommendations.get(fouling_type, [])

    def generate_cip_procedure(self, fouling_types: List[str],
                              system_volume_m3: float) -> Dict:
        """生成完整的CIP程序"""
        ph_min, ph_max = self.ph_limits.get(self.membrane_type, (2, 12))
        temp_max = self.temperature_limit.get(self.membrane_type, 40)

        procedure = {
            'membrane_type': self.membrane_type,
            'ph_operating_range': f'{ph_min} - {ph_max}',
            'max_temperature_c': temp_max,
            'system_volume_m3': system_volume_m3,
            'steps': []
        }

        # 初始冲洗
        procedure['steps'].append({
            'step': 1,
            'action': '低压冲洗',
            'duration_min': 10,
            'flow_rate': 'High',
            'description': '用渗透水冲洗以去除松动的沉积物'
        })

        # 基于污染类型的清洁步骤
        step_num = 2
        for fouling in fouling_types:
            chemicals = self.recommend_cleaning_chemicals(fouling)
            for chem in chemicals:
                if chem['temperature_c'] <= temp_max and ph_min <= chem['ph'] <= ph_max:
                    procedure['steps'].append({
                        'step': step_num,
                        'action': f'化学清洗 - {chem["chemical"]}',
                        'concentration': chem['concentration'],
                        'ph': chem['ph'],
                        'temperature_c': chem['temperature_c'],
                        'duration_min': 30,
                        'recirculation_time_min': 60,
                        'soak_time_min': 30,
                        'description': f'目标: {fouling} 污染去除'
                    })
                    step_num += 1

        # 最终冲洗
        procedure['steps'].append({
            'step': step_num,
            'action': '最终冲洗',
            'duration_min': 20,
            'description': '冲洗直到pH和电导率与给水匹配'
        })

        return procedure

# 示例用法
cip = CIPProtocol(membrane_type='polyamide')
procedure = cip.generate_cip_procedure(
    fouling_types=['biofouling', 'scale_calcium'],
    system_volume_m3=5
)

print("CIP程序:")
for step in procedure['steps']:
    print(f"  步骤 {step['step']}: {step['action']}")

使用指南

何时使用这项技能

  • 膜系统设计和规范
  • 试验测试协议开发
  • 污染诊断和缓解
  • 系统优化和故障排除
  • 预处理系统设计

最佳实践

  1. 在设计前彻底对给水进行表征
  2. 对关键应用使用试验测试
  3. 为可维护性设计，包括CIP接入
  4. 定期监控膜性能趋势
  5. 维护化学剂量记录以便于故障排除
  6. 在设计初期规划浓水管理

流程集成

  • WW-003: 膜处理系统设计（所有阶段）
  • WW-005: 水再利用系统实施（膜阶段）

依赖关系

  • numpy: 数值计算
  • scipy: 优化程序

参考资料

  • AWWA M46 ‘反渗透和纳滤’
  • Dow Water & Process Solutions 技术手册
  • Hydranautics 技术应用公告