AirTerminalDevice/components/wheel.py

import numpy as np
try:
    import pymc as pm
except:
    pass

from ._base_components import BaseComponents
from ..tools.enthalpy import get_RH_from_Tdb_and_Hr
from ..tools.enthalpy import get_Dew_from_HumRatio

class WheelS2(BaseComponents):
    
    def __init__(self):
        super().__init__()
    
    @classmethod
    def model(
        cls,
        TinP,HinP,FP,
        TinR,HinR,FR,
        engine  : str,
        param   : dict,
    ):
        FUNC = cls.get_func_by_engine(engine)
        EXP  = FUNC['EXP']
        RinP = get_RH_from_Tdb_and_Hr(TinP,HinP,engine)
        
        beta_Q1 = param['beta_Q1']
        beta_H1 = param['beta_H1']
        beta_H2 = param['beta_H2']
        beta_H3 = param['beta_H3']
        beta_H4 = param['beta_H4']
        
        # 转轮的温度
        T_avg = TinR * (1 - beta_H4) + TinP * beta_H4
        
        # 出风露点（除湿量）
        ## 处理侧
        Hdiff_mu = beta_H1 * RinP ** beta_H2 * EXP(-beta_H3 / T_avg) / 1000 # kg水蒸气/kg干空气
        HoutP_mu = HinP - Hdiff_mu
        DoutP_mu = get_Dew_from_HumRatio(HoutP_mu,engine)
        ## 再生侧
        HoutR_mu = HinR + Hdiff_mu * (FP / FR)
        DoutR_mu = get_Dew_from_HumRatio(HoutR_mu,engine)
        
        # 出风温度
        # 处理侧
        Q_latent   = Hdiff_mu * cls.CONSTANT['h_ads'] # Kj/kg 潜热
        Q_sensible = beta_Q1 * (TinR - TinP)          # Kj/kg 显热（影响升焓的部分）
        Q          = (Q_latent + Q_sensible) * FP     # Kj
        ToutP_mu   = TinP + Q / (FP * cls.CONSTANT['c_p_air'])
        # 再生侧
        ToutR_mu   = TinR - Q / (FR * cls.CONSTANT['c_p_air'])
        
        return {
            'ToutP':ToutP_mu,'HoutP':HoutP_mu,'DoutP':DoutP_mu,
            'ToutR':ToutR_mu,'HoutR':HoutR_mu,'DoutR':DoutR_mu,
        }
    
    @classmethod
    def prior(cls,name):
        param = {
            'beta_Q1': pm.HalfNormal(f'{name}_beta_Q1',sigma=10),
            'beta_H1': pm.HalfNormal(f'{name}_beta_H1',sigma=10),
            'beta_H2': pm.HalfNormal(f'{name}_beta_H2',sigma=10),
            'beta_H3': pm.HalfNormal(f'{name}_beta_H3',sigma=10),
            'beta_H4': pm.Uniform(f'{name}_beta_H4',lower=0,upper=1),
        }
        return param


class WheelS3(BaseComponents):
    def __init__(self):
        super().__init__()
    
    @classmethod
    def model(
        cls,
        TinP,HinP,FP,
        TinR,HinR,FR,
        TinC,HinC,FC,
        engine  : str,
        param   : dict,
    ):
        FUNC = cls.get_func_by_engine(engine)
        EXP  = FUNC['EXP']
        
        beta_P1 = param['beta_P1']
        beta_P2 = param['beta_P2']
        beta_P3 = param['beta_P3']
        beta_P4 = param['beta_P4']
        beta_P5 = param['beta_P5']
        beta_C1 = param['beta_C1']
        beta_C2 = param['beta_C2']
        beta_C3 = param['beta_C3']
        beta_C4 = param['beta_C4']
        
        RinP = get_RH_from_Tdb_and_Hr(TinP,HinP,engine)
        RinC = get_RH_from_Tdb_and_Hr(TinC,HinC,engine)
        
        # 处理侧
        HdiffP  = (beta_P1 * RinP**beta_P4 * HinP * TinR * EXP(-beta_P5 * FP) + beta_P2)/1000
        WdiffP  = HdiffP * FP
        HoutP   = HinP - HdiffP
        DoutP   = get_Dew_from_HumRatio(HoutP,engine)
        Q_lat_P = WdiffP * cls.CONSTANT['h_ads']
        Q_sen_P = beta_P3 * (TinR - TinP) * FP #TODO
        TdiffP  = (Q_lat_P + Q_sen_P) / (FP * cls.CONSTANT['c_p_air'])
        ToutP   = TinP + TdiffP
        
        # 冷却侧
        TdiffC    = beta_C1 * EXP(-beta_C2 * EXP(-beta_C3 * (TinR - TinC))) * EXP(-beta_C4 * FC)
        ToutC     = TinC + TdiffC
        HdiffC    = (beta_P1 * RinC**beta_P4 * HinC * TinR * EXP(-beta_P5 * FC) + beta_P2)/1000
        WdiffC    = HdiffC * FC
        HoutC     = HinC - HdiffC
        DoutC     = get_Dew_from_HumRatio(HoutC,engine)
        Q_total_C = TdiffC * FC * cls.CONSTANT['c_p_air']
        
        # 再生侧
        WdiffR    = WdiffP + WdiffC
        HoutR     = (HinR * FR + WdiffR) / FR
        DoutR     = get_Dew_from_HumRatio(HoutR,engine)
        Q_total_R = Q_lat_P + Q_sen_P + Q_total_C
        TdiffR    = Q_total_R / (FR * cls.CONSTANT['c_p_air'])
        ToutR     = TinR - TdiffR
        
        return {
            'ToutP':ToutP,'HoutP':HoutP,'DoutP':DoutP,'FP':FP,
            'ToutR':ToutR,'HoutR':HoutR,'DoutR':DoutR,'FR':FR,
            'ToutC':ToutC,'HoutC':HoutC,'DoutC':DoutC,'FC':FC,
        } 
        
    @classmethod
    def prior(cls,name):
        param = {
            'beta_P1': pm.TruncatedNormal(f'{name}_beta_P1',mu=5,sigma=10,initval=5,lower=0),
            'beta_P2': pm.TruncatedNormal(f'{name}_beta_P2',mu=0.5,sigma=1,initval=0.02,lower=0),
            'beta_P3': pm.TruncatedNormal(f'{name}_beta_P3',mu=1,sigma=2,initval=1.5,lower=0),
            'beta_P4': pm.TruncatedNormal(f'{name}_beta_P4',mu=1,sigma=0.3,initval=1,lower=0),
            'beta_P5': pm.TruncatedNormal(f'{name}_beta_P5',mu=5,sigma=2,initval=5,lower=0),
            'beta_C1': pm.TruncatedNormal(f'{name}_beta_C1',mu=60,sigma=10,initval=60,lower=10),
            'beta_C2': pm.TruncatedNormal(f'{name}_beta_C2',mu=30,sigma=10,initval=30,lower=1),
            'beta_C3': pm.TruncatedNormal(f'{name}_beta_C3',mu=0.05,sigma=0.1,initval=0.05,lower=0),
            'beta_C4': pm.TruncatedNormal(f'{name}_beta_C4',mu=1,sigma=1,initval=1,lower=0),
        }
        return param



# class WheelS3(BaseComponents):
#     # 需要校准的输出 ToutP DoutP ToutR/ToutC
    
#     def __init__(self):
#         super().__init__()
    
#     @classmethod
#     def model(
#         cls,
#         TinP,HinP,FP,
#         TinR,HinR,FR,
#         TinC,HinC,FC,
#         engine  : str,
#         param   : dict,
#     ):
#         FUNC = cls.get_func_by_engine(engine)
#         EXP  = FUNC['EXP']
#         RinP = get_RH_from_Tdb_and_Hr(TinP,HinP,engine)
#         RinC = get_RH_from_Tdb_and_Hr(TinC,HinC,engine)
        
#         beta_Q1 = param['beta_Q1']
#         beta_Q2 = param['beta_Q2']
#         # beta_Q3 = param['beta_Q3']
#         beta_H1 = param['beta_H1']
#         beta_H2 = param['beta_H2']
#         beta_H3 = param['beta_H3']
#         beta_H4 = param['beta_H4']
#         beta_H5 = param['beta_H5']
        
#         # 转轮的温度
#         T_avg = TinR * beta_H4 + TinC * (1 - beta_H4)
        
#         # 除湿量
#         ## 处理侧
#         H_diff_P = beta_H1 * RinP ** beta_H2 * EXP(-beta_H3 / T_avg)   # 描述吸附  kg水蒸气/kg干空气
#         W_diff_P = H_diff_P * FP                                       # kg水蒸气
#         HoutP    = HinP - H_diff_P
#         # 冷却测
#         # !转轮的处理侧和冷却侧都在除湿，由于冷却侧出来的空气的温度非常高，所以湿度很难测准
#         # !因此冷却侧的除湿量需要假定，这里假定和处理侧参数一致
#         H_diff_C = beta_H1 * RinC ** beta_H2 * EXP(-beta_H3 / T_avg) * beta_H5
#         W_diff_C = H_diff_C * FC
#         HoutC    = HinC - H_diff_C
#         ## 再生侧
#         HoutR = (HinR * FR + W_diff_P + W_diff_C) / FR # kg水蒸气/kg干空气
        
#         # 露点
#         DoutP = get_Dew_from_HumRatio(HoutP,engine)
#         DoutC = get_Dew_from_HumRatio(HoutC,engine)
#         DoutR = get_Dew_from_HumRatio(HoutR,engine)
        
#         # 热量
#         Q_lat_C     = W_diff_C * cls.CONSTANT['h_ads']                   # Kj 冷却侧潜热
#         Q_lat_P     = W_diff_P * cls.CONSTANT['h_ads']                   # Kj 处理侧潜热
#         Q_lat_total = Q_lat_C + Q_lat_P                                  # Kj 总潜热
#         Q_sen_C     = beta_Q1 * (TinR - TinC)                            # Kj 冷却侧显热
#         # Q_sen_P     = beta_Q1 * (TinR - beta_Q2 * (TinR - TinC) - TinP)  # Kj 处理侧显热
#         Q_sen_P     = beta_Q1 * (TinR - TinP) * beta_Q2
#         Q_sen_Total = Q_sen_C + Q_sen_P                                  # Kj 总显热
        
#         # 温度变化
#         ToutP = TinP + (Q_lat_P + Q_sen_P) / (FP * cls.CONSTANT['c_p_air'])
#         ToutC = TinC + (Q_lat_C + Q_sen_C) / (FC * cls.CONSTANT['c_p_air']) 
#         ToutR = TinR - (Q_lat_total + Q_sen_Total) / (FR * cls.CONSTANT['c_p_air'])
        
#         return {
#             'ToutP':ToutP,'HoutP':HoutP,'DoutP':DoutP,
#             'ToutR':ToutR,'HoutR':HoutR,'DoutR':DoutR,
#             'ToutC':ToutC,'HoutC':HoutC,'DoutC':DoutC,
#         } 
    
#     @classmethod
#     def prior(cls,name):
#         param = {
#             'beta_Q1': pm.HalfNormal(f'{name}_beta_Q1',sigma=1,initval=1),
#             'beta_Q2': pm.HalfNormal(f'{name}_beta_Q2',sigma=0.1,initval=0.01),
#             'beta_H1': pm.HalfNormal(f'{name}_beta_H1',sigma=1,initval=0.01),
#             'beta_H2': pm.HalfNormal(f'{name}_beta_H2',sigma=1,initval=0.01),
#             'beta_H3': pm.HalfNormal(f'{name}_beta_H3',sigma=20,initval=100),
#             'beta_H4': pm.Uniform(f'{name}_beta_H4',lower=0,upper=1,initval=0.7),
#             # 'beta_H5': pm.TruncatedNormal(f'{name}_beta_H5',mu=5,sigma=2,lower=1,initval=5),
#             'beta_H5':pm.HalfNormal(f'{name}_beta_H5',sigma=1,initval=0.01)
#         }
#         return param