AirTerminalDevice/components/wheel2.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,get_HumRatio_from_Tdb_and_RH


class WheelS2(BaseComponents):
    
    def __init__(self, name):
        super().__init__(name)
    
    @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,
            'EFF'  :Q_latent / (Q_sensible + Q_latent),
            'Qsen' :Q_sensible,'Qlat':Q_latent
        }
    
    def prior(self):
        param = {
            'beta_Q1': pm.HalfNormal(f'{self.name}_beta_Q1',sigma=10),
            'beta_H1': pm.HalfNormal(f'{self.name}_beta_H1',sigma=10),
            'beta_H2': pm.HalfNormal(f'{self.name}_beta_H2',sigma=10),
            'beta_H3': pm.HalfNormal(f'{self.name}_beta_H3',sigma=10),
            'beta_H4': pm.Uniform(f'{self.name}_beta_H4',lower=0,upper=1),
        }
        return param

class WheelS2V2(BaseComponents):
    def __init__(self, name):
        super().__init__(name)
    
    @classmethod
    def model(
        cls,
        TinP,HinP,FP,
        TinR,HinR,FR,
        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_P6 = param['beta_P6']
        beta_P7 = param['beta_P7']
        
        RinP = get_RH_from_Tdb_and_Hr(TinP,HinP,engine)
        
        # 处理侧
        HdiffP  = (
            beta_P1 * RinP**beta_P4 
            * HinP 
            * (
                TinR * (1 - EXP(-beta_P5 * FR)) 
                + beta_P6 * TinP * (1 - 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'] * beta_P7
        Q_sen_P = beta_P3 * (TinR - TinP) * FP
        TdiffP  = (Q_lat_P + Q_sen_P) / (FP * cls.CONSTANT['c_p_air'])
        ToutP   = TinP + TdiffP
        
        # 再生侧
        HoutR     = (HinR * FR + WdiffP) / FR
        DoutR     = get_Dew_from_HumRatio(HoutR,engine)
        Q_total_R = Q_lat_P + Q_sen_P
        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,
            'EFF'  :Q_lat_P / (Q_sen_P + Q_lat_P),
            'Qsen' :Q_sen_P,'Qlat':Q_lat_P
        } 
        
    def prior(self):
        param = {
            'beta_P1': pm.TruncatedNormal(f'{self.name}_beta_P1',mu=5,sigma=10,initval=5,lower=0),
            'beta_P2': pm.TruncatedNormal(f'{self.name}_beta_P2',mu=0.5,sigma=1,initval=0.02,lower=0),
            'beta_P3': pm.TruncatedNormal(f'{self.name}_beta_P3',mu=1,sigma=2,initval=1.5,lower=0),
            'beta_P4': pm.TruncatedNormal(f'{self.name}_beta_P4',mu=1,sigma=0.3,initval=1,lower=0),
            'beta_P5': pm.TruncatedNormal(f'{self.name}_beta_P5',mu=5,sigma=2,initval=5,lower=0),
            'beta_P6': pm.Normal(f'{self.name}_beta_P6',mu=0,sigma=1,initval=0),
            'beta_P7': pm.TruncatedNormal(f'{self.name}_beta_P7',mu=1.3,sigma=0.1,initval=1.3,lower=1),
        }
        return param

class WheelS2V3(BaseComponents):
    def __init__(self, name):
        super().__init__(name)
    
    @classmethod
    def model(
        cls,
        TinP,HinP,FP,
        TinR,HinR,FR,
        engine  : str,
        param   : dict,
    ):
        FUNC = cls.get_func_by_engine(engine)
        EXP  = FUNC['EXP']
        
        beta_P1 = param['beta_P1'] # km
        beta_P2 = param['beta_P2'] # eta_max
        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']
        
        # 处理侧 
        # 湿度
        alpha   = FR / (FR + FP)
        T_wheel = TinR * alpha + TinP * (1 - alpha) + beta_P3
        Hr_eq   = get_HumRatio_from_Tdb_and_RH(T_wheel,1,engine)
        eta     = beta_P2 * (1-EXP(-beta_P1 * (HinP-Hr_eq)/Hr_eq))
        HdiffP  = eta * (HinP - Hr_eq)
        HoutP   = HinP - HdiffP
        DoutP   = get_Dew_from_HumRatio(HoutP,engine)
        # 温度
        TdiffP_sen = beta_P4 * (T_wheel - TinP)
        TdiffP_lat = cls.CONSTANT['h_ads'] / cls.CONSTANT['c_p_air'] * HdiffP * beta_P5
        ToutP      = TinP + TdiffP_sen + TdiffP_lat
        
        # 再生侧
        # 湿度
        HdiffR = HdiffP * FP / FR
        HoutR  = HinR + HdiffR
        DoutR  = get_Dew_from_HumRatio(HoutR,engine)
        # 温度
        TdiffR_lat = cls.CONSTANT['h_ads'] / cls.CONSTANT['c_p_air'] * HdiffR * beta_C2
        TdiffR_sen = beta_C1 * (TinR - T_wheel)
        ToutR      = TinR - TdiffR_sen - TdiffR_lat
        
        return {
            'ToutP':ToutP,'HoutP':HoutP,'DoutP':DoutP,'FP':FP,
            'ToutR':ToutR,'HoutR':HoutR,'DoutR':DoutR,'FR':FR,
            'T_wheel':T_wheel,
        } 
        
    def prior(self):
        param = {
            'beta_P1': pm.HalfNormal(f'{self.name}_beta_P1',sigma=10,initval=5),
            'beta_P2': pm.Uniform(f'{self.name}_beta_P2',lower=0,upper=1,initval=0.6),
            'beta_P3': pm.Normal(f'{self.name}_beta_P3',mu=0,sigma=2,initval=0),
            'beta_P4': pm.HalfNormal(f'{self.name}_beta_P4', sigma=10,initval=1),
            'beta_P5': pm.TruncatedNormal(f'{self.name}_beta_P5', mu=1, sigma=1,initval=1,lower=0),
            'beta_C1': pm.HalfNormal(f'{self.name}_beta_C1', sigma=10,initval=1),
            'beta_C2': pm.HalfNormal(f'{self.name}_beta_C2', sigma=1,initval=1),
        }
        return param