AirTerminalDevice/components/coil.py

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

from ._base_components import BaseComponents
from ..tools.enthalpy import get_Dew_from_HumRatio,get_Enthalpy_from_Tdb_and_HumRatio
from ..tools.enthalpy import get_HumRatio_from_Dew


class CoolingCoil(BaseComponents):
    
    def __init__(self, engine):
        super().__init__(engine)
    
    @classmethod
    def model(
        cls,
        TinA,HinA,FA,
        TinW,FW,
        engine,
        param
    ):
        FUNC  = cls.get_func_by_engine(engine)
        WHERE = FUNC['WHERE']
        GT    = FUNC['GT']
        EXP   = FUNC['EXP']
        
        DinA = get_Dew_from_HumRatio(HinA,engine)
        mode = WHERE(GT(DinA-TinW,0),1,0) #1湿工况
        
        UA_dry       = param['UA_dry']
        UA_wet_ratio = param['UA_wet_ratio']
        Ts_adj       = param['Ts_adj']
        eta          = param['eta']
        UA_wet       = UA_dry * UA_wet_ratio
        
        C_min   = FA * cls.CONSTANT['c_p_air']
        C_max   = FW * cls.CONSTANT['c_p_water']
        Cr      = C_min / C_max
        NTU_wet = UA_wet / C_min
        NTU_dry = UA_dry / C_min
        NTU     = WHERE(mode,NTU_wet,NTU_dry)
        epsilon = (1-EXP(-NTU*(1-Cr))) / (1-Cr*EXP(-NTU*(1-Cr)))
        
        # 出风干球温度
        Ts    = TinW + Ts_adj * (HinA) * (TinA - TinW) # 湿工况盘管表面温度
        Q_wet = epsilon * C_min * (TinA - Ts)
        Q_dry = epsilon * C_min * (TinA - TinW)
        Q     = WHERE(mode,Q_wet,Q_dry)
        ToutA = TinA - Q / (FA * cls.CONSTANT['c_p_air'])
        
        # 出风湿度+露点
        HoutA = WHERE(
            mode,
            HinA - eta * (HinA - get_HumRatio_from_Dew(TinW,engine)),
            HinA
        )
        DoutA = get_Dew_from_HumRatio(HoutA,engine)
        
        return {'ToutA':ToutA,'HoutA':HoutA,'DoutA':DoutA} 

    @classmethod
    def prior(cls,name) -> dict:
        param = {
            'UA_dry'      : pm.HalfNormal(f'{name}_UA_dry',5,initval=10),
            'UA_wet_ratio': pm.TruncatedNormal(f'{name}_UA_wet_ratio',mu=4,sigma=0.2,lower=1,upper=10,initval=4),
            'Ts_adj'      : pm.HalfNormal(f'{name}_Ts_adj',5,initval=5),
            'eta'         : pm.HalfNormal(f'{name}_eta',0.5,initval=0.5),
        }
        return param


class CoolingCoil2(BaseComponents):
    
    def __init__(self, engine):
        super().__init__(engine)
    
    @classmethod
    def model(
        cls,
        TinA,HinA,FA,
        TinW,FW,
        engine,
        param
    ):
        FUNC  = cls.get_func_by_engine(engine)
        WHERE = FUNC['WHERE']
        EXP   = FUNC['EXP']
        
        DinA = get_Dew_from_HumRatio(HinA,engine)
        
        beta1_T     = param['beta1_T']
        beta2_T     = param['beta2_T']
        beta3_T     = param['beta3_T']
        beta1_D_adj = param['beta1_D_adj']
        beta2_D_adj = param['beta2_D_adj']
        beta3_D_adj = param['beta3_D_adj']
        beta4_D     = param['beta4_D']
        
        beta1_D = beta1_T * beta1_D_adj
        beta2_D = beta2_T * beta2_D_adj
        beta3_D = beta3_T * beta3_D_adj
        
        EFF_T_FW = 1 - EXP(-beta2_T * FW)
        EFF_T_FA = EXP(-beta3_T * FA)
        EFF_D_FW = 1 - EXP(-beta2_D * FW)
        EFF_D_FA = EXP(-beta3_D * FA)
        mode     = WHERE(DinA > TinW,1,0)
        ToutA    = TinA - beta1_T * (TinA - TinW) * EFF_T_FA * EFF_T_FW
        DoutA    = DinA - (beta1_D - beta4_D * (TinA - DinA)) * (DinA - TinW) * mode * EFF_D_FW * EFF_D_FA
        HoutA    = get_HumRatio_from_Dew(DoutA,engine)
        
        return {'ToutA':ToutA,'HoutA':HoutA,'DoutA':DoutA,'FA':FA} 
    
    @classmethod
    def prior(cls,name) -> dict:
        param = {
            'beta1_T'    : pm.TruncatedNormal(f'{name}_beta1_T',mu=1,sigma=0.2,lower=0),
            'beta2_T'    : pm.TruncatedNormal(f'{name}_beta2_T',mu=5,sigma=3,lower=0),
            'beta3_T'    : pm.TruncatedNormal(f'{name}_beta3_T',mu=5,sigma=0.3,lower=0),
            'beta1_D_adj': pm.TruncatedNormal(f'{name}_beta1_D_adj',mu=1,sigma=0.1,lower=0.1),
            'beta2_D_adj': pm.TruncatedNormal(f'{name}_beta2_D_adj',mu=1,sigma=0.1,lower=0.1),
            'beta3_D_adj': pm.TruncatedNormal(f'{name}_beta3_D_adj',mu=1,sigma=0.1,lower=0.1),
            'beta4_D'    : pm.TruncatedNormal(f'{name}_beta4_D',mu=0.01,sigma=0.01,lower=0)
        }
        return param


class SteamCoilFs(BaseComponents):
    def __init__(self):
        super().__init__()
    
    @classmethod
    def model(
        cls,
        TinA,ToutA,FA,
        param,
        engine
    ):
        b1 = param['b1']
        b2 = param['b2']
        b3 = param['b3']
        Fs = b1 * (ToutA - TinA) * FA + b2 * TinA + b3
        return {'Fs':Fs}
    
    @classmethod
    def prior(cls,name):
        param = {
            'b1': pm.HalfNormal(f'{name}_b1',sigma=10),
            'b2': pm.Normal(f'{name}_b2',sigma=10),
            'b3': pm.Normal(f'{name}_b3',sigma=10),
        }
        return param


class SteamCoilFs2(BaseComponents):
    def __init__(self):
        super().__init__()
    
    @classmethod
    def model(cls,TinA,ToutA,FA,param,engine):
        b1 = param['b1']
        b2 = param['b2']
        FP = np.exp(b1 * (ToutA - TinA)*FA + b2)
        
        FUNC  = cls.get_func_by_engine(engine)
        WHERE = FUNC['WHERE']
        LT    = FUNC['LT']
        
        param_change_point    = param['change_point']
        param_b1              = param['a1']
        param_b2              = param['a2']
        param_b3              = param['a3']
        param_Ps_change_point = param_b1 + param_b2 * param_change_point
        Fs = WHERE(
            LT(FP,param_Ps_change_point * param_change_point),
            get_root(param_b1,param_b2,FP),
            get_root(param_b1+(param_b2-param_b3)*param_change_point,param_b3,FP)
        )
        return {'FP':FP,'Fs':Fs}

    @classmethod
    def prior(cls,name):
        param = {
            'b1'          : pm.Normal(f'{name}_b1',mu=0.08,sigma=0.1,initval=0.08),
            'b2'          : pm.Normal(f'{name}_b2',mu=3.65,sigma=0.02,initval=3.65),
            'change_point': pm.Normal(f'{name}_change_point',mu=104,sigma=1,initval=104),
            'a1'          : pm.Normal(f'{name}_a1',mu=17.5,sigma=1,initval=17.5),
            'a2'          : pm.Normal(f'{name}_a2',mu=0.2,sigma=0.1,initval=0.2),
            'a3'          : pm.Normal(f'{name}_a3',mu=1.5,sigma=0.1,initval=1.5),
        }
        return param

class SteamCoilFs3(BaseComponents):
    def __init__(self):
        super().__init__()
    
    @classmethod
    def model(
        cls,
        TinA,ToutA,FA,
        HinA,HoutA,
        param,
        engine
    ):
        b1   = param['b1']
        b2   = param['b2']
        b3   = param['b3']
        Fs   = b1 * (ToutA - TinA) + b2 * ToutA + b3
        return {'Fs':Fs}
    
    @classmethod
    def prior(cls,name):
        param = {
            'b1': pm.HalfNormal(f'{name}_b1',sigma=10,initval=1),
            'b2': pm.HalfNormal(f'{name}_b2',sigma=10,initval=1),
            'b3': pm.Normal(f'{name}_b3',sigma=10,initval=0),
        }
        return param


def get_root(b0,b1,FP):
    return (np.sqrt(b0**2+4*b1*FP)-b0)/(2*b1)