コード例 #1
0
def dist_col_Rodrigo_ss(init0, bnd_set):
    # collocation polynomial parameters

    # polynomial roots (Radau)

    m = ConcreteModel()
    m.i_flag = init0
    # set of finite elements and collocation points
    m.fe = Set(initialize=[1])
    m.cp = Set(initialize=[1])

    m.bnd_set = bnd_set

    if bnd_set:
        print("Bounds_set")

    Ntray = 42

    m.Ntray = Ntray

    m.tray = Set(initialize=[i for i in range(1, Ntray + 1)])

    def __init_feed(m, t):
        if t == 21:
            return 57.5294
        else:
            return 0

    m.feed = Param(m.tray, initialize=__init_feed)
    m.xf = Param(initialize=0.32)  # feed mole fraction
    m.hf = Param(initialize=9081.3)  # feed enthalpy

    m.hlm0 = Param(initialize=2.6786e-04)
    m.hlma = Param(initialize=-0.14779)
    m.hlmb = Param(initialize=97.4289)
    m.hlmc = Param(initialize=-2.1045e04)

    m.hln0 = Param(initialize=4.0449e-04)
    m.hlna = Param(initialize=-0.1435)
    m.hlnb = Param(initialize=121.7981)
    m.hlnc = Param(initialize=-3.0718e04)

    m.r = Param(initialize=8.3147)
    m.a = Param(initialize=6.09648)
    m.b = Param(initialize=1.28862)
    m.c1 = Param(initialize=1.016)
    m.d = Param(initialize=15.6875)
    m.l = Param(initialize=13.4721)
    m.f = Param(initialize=2.615)

    m.gm = Param(initialize=0.557)
    m.Tkm = Param(initialize=512.6)
    m.Pkm = Param(initialize=8.096e06)

    m.gn = Param(initialize=0.612)
    m.Tkn = Param(initialize=536.7)
    m.Pkn = Param(initialize=5.166e06)

    m.CapAm = Param(initialize=23.48)
    m.CapBm = Param(initialize=3626.6)
    m.CapCm = Param(initialize=-34.29)

    m.CapAn = Param(initialize=22.437)
    m.CapBn = Param(initialize=3166.64)
    m.CapCn = Param(initialize=-80.15)

    m.pstrip = Param(initialize=250)
    m.prect = Param(initialize=190)

    def _p_init(m, t):
        ptray = 9.39e04
        if t <= 20:
            return _p_init(m, 21) + m.pstrip * (21 - t)
        elif 20 < t < m.Ntray:
            return ptray + m.prect * (m.Ntray - t)
        elif t == m.Ntray:
            return 9.39e04

    m.p = Param(m.tray, initialize=_p_init)

    m.T29_des = Param(initialize=343.15)
    m.T15_des = Param(initialize=361.15)
    m.Dset = Param(initialize=1.83728)
    m.Qcset = Param(initialize=1.618890)
    m.Qrset = Param(initialize=1.786050)
    m.Recset = Param()

    m.alpha_T29 = Param(initialize=1)
    m.alpha_T15 = Param(initialize=1)
    m.alpha_D = Param(initialize=1)
    m.alpha_Qc = Param(initialize=1)
    m.alpha_Qr = Param(initialize=1)
    m.alpha_Rec = Param(initialize=1)

    def _alpha_init(m, i):
        if i <= 21:
            return 0.62
        else:
            return 0.35

    m.alpha = Param(m.tray, initialize=_alpha_init)

    ME0 = {}
    ME0[1] = 123790.826443232
    ME0[2] = 3898.34923206106
    ME0[3] = 3932.11766868415
    ME0[4] = 3950.13107445914
    ME0[5] = 3960.01212104318
    ME0[6] = 3965.37146944881
    ME0[7] = 3968.25340380767
    ME0[8] = 3969.78910997468
    ME0[9] = 3970.5965548502
    ME0[10] = 3971.0110096803
    ME0[11] = 3971.21368740283
    ME0[12] = 3971.30232788932
    ME0[13] = 3971.32958547037
    ME0[14] = 3971.32380573089
    ME0[15] = 3971.30024105555
    ME0[16] = 3971.26709591428
    ME0[17] = 3971.22878249852
    ME0[18] = 3971.187673073
    ME0[19] = 3971.14504284211
    ME0[20] = 3971.10157713182
    ME0[21] = 3971.05764415189
    ME0[22] = 3611.00216267141
    ME0[23] = 3766.84741932423
    ME0[24] = 3896.87907072814
    ME0[25] = 4004.98630195624
    ME0[26] = 4092.49383654928
    ME0[27] = 4161.86560059956
    ME0[28] = 4215.98509169956
    ME0[29] = 4257.69470716792
    ME0[30] = 4289.54901779038
    ME0[31] = 4313.71557755738
    ME0[32] = 4331.9642075775
    ME0[33] = 4345.70190802884
    ME0[34] = 4356.02621744716
    ME0[35] = 4363.78165047072
    ME0[36] = 4369.61159802674
    ME0[37] = 4374.00266939603
    ME0[38] = 4377.32093116489
    ME0[39] = 4379.84068162411
    ME0[40] = 4381.76685527968
    ME0[41] = 4383.25223100374
    ME0[42] = 4736.04924276762

    m.M_pred = Param(m.tray, initialize=ME0)

    XE0 = {}
    XE0[1] = 0.306547877605746
    XE0[2] = 0.398184778678485
    XE0[3] = 0.416675004386508
    XE0[4] = 0.42676332128531
    XE0[5] = 0.432244548463899
    XE0[6] = 0.435193762178033
    XE0[7] = 0.436764699693985
    XE0[8] = 0.437589297877498
    XE0[9] = 0.438010896454752
    XE0[10] = 0.43821522113022
    XE0[11] = 0.438302495819782
    XE0[12] = 0.438326730875504
    XE0[13] = 0.438317008813347
    XE0[14] = 0.438288981487008
    XE0[15] = 0.438251069561153
    XE0[16] = 0.438207802087721
    XE0[17] = 0.438161614415035
    XE0[18] = 0.438113815737636
    XE0[19] = 0.438065109638753
    XE0[20] = 0.438015874079915
    XE0[21] = 0.437966311972983
    XE0[22] = 0.724835538043496
    XE0[23] = 0.788208485334881
    XE0[24] = 0.838605564838572
    XE0[25] = 0.87793558673077
    XE0[26] = 0.908189470853012
    XE0[27] = 0.931224584141055
    XE0[28] = 0.948635083197147
    XE0[29] = 0.961724712952285
    XE0[30] = 0.971527857048483
    XE0[31] = 0.978848914860811
    XE0[32] = 0.984304939392599
    XE0[33] = 0.98836476845163
    XE0[34] = 0.991382214572503
    XE0[35] = 0.993622983870866
    XE0[36] = 0.995285909293636
    XE0[37] = 0.996519395295701
    XE0[38] = 0.997433995899531
    XE0[39] = 0.998111951760656
    XE0[40] = 0.998614376770054
    XE0[41] = 0.998986649363
    XE0[42] = 0.999262443919619

    m.x_pred = Param(m.tray, initialize=XE0)

    # hold in each tray

    def __m_init(m, i, j, t):
        if m.i_flag:
            if t < m.Ntray:
                return 4000.
            elif t == 1:
                return 104340.
            elif t == m.Ntray:
                return 5000.
        else:
            return 0.

    m.M = Var(m.fe, m.cp, m.tray, initialize=__m_init)

    # m.M_0 = Var(m.fe, m.tray, initialize=1e07)

    # temperatures

    def __t_init(m, i, j, t):
        if m.i_flag:
            return ((370.781 - 335.753) / m.Ntray) * t + 370.781
        else:
            return 10.

    m.T = Var(m.fe, m.cp, m.tray, initialize=__t_init)

    # saturation pressures
    m.pm = Var(m.fe, m.cp, m.tray, initialize=1e4)
    m.pn = Var(m.fe, m.cp, m.tray, initialize=1e4)

    # define l-v flowrate

    def _v_init(m, i, j, t):
        if m.i_flag:
            return 44.
        else:
            return 0.

    m.V = Var(m.fe, m.cp, m.tray, initialize=_v_init)

    def _l_init(m, i, j, t):
        if m.i_flag:
            if 2 <= t <= 21:
                return 83.
            elif 22 <= t <= 42:
                return 23
            elif t == 1:
                return 40
        else:
            return 0.

    m.L = Var(m.fe, m.cp, m.tray, initialize=_l_init)

    # mol frac l-v

    def __x_init(m, i, j, t):
        if m.i_flag:
            return (0.999 / m.Ntray) * t
        else:
            return 1

    m.x = Var(m.fe, m.cp, m.tray, initialize=__x_init)

    #m.x_0 = Var(m.fe, m.tray)

    # av

    def __y_init(m, i, j, t):
        if m.i_flag:
            return ((0.99 - 0.005) / m.Ntray) * t + 0.005
        else:
            return 1

    m.y = Var(m.fe, m.cp, m.tray, initialize=__y_init)
    # enthalpy
    m.hl = Var(m.fe, m.cp, m.tray, initialize=10000.)

    def __hv_init(m, i, j, t):
        if m.i_flag:
            if t < m.Ntray:
                return 5e4
        else:
            return 0.0

    m.hv = Var(m.fe, m.cp, m.tray, initialize=__hv_init)
    # reboiler & condenser heat
    m.Qc = Var(m.fe, m.cp, initialize=1.6e06)
    m.D = Var(m.fe, m.cp, initialize=18.33)
    # vol holdups
    m.Vm = Var(m.fe, m.cp, m.tray, initialize=6e-05)

    def __mv_init(m, i, j, t):
        if m.i_flag:
            if 1 < t < m.Ntray:
                return 0.23
        else:
            return 0.0

    m.Mv = Var(m.fe, m.cp, m.tray, initialize=__mv_init)

    m.Mv1 = Var(m.fe, m.cp, initialize=8.57)
    m.Mvn = Var(m.fe, m.cp, initialize=0.203)

    def _bound_set(m):
        if m.bnd_set:
            for key, value in m.M.iteritems():
                value.setlb(1.0)
                value.setub(1e7)
            for key, value in m.Vm.iteritems():
                value.setlb(-1.0)
                value.setub(1e4)
            for key, value in m.Mv.iteritems():
                value.setlb(0.155 + 1e-06)
                value.setub(1e4)
            for key, value in m.Mv1.iteritems():
                value.setlb(8.5 + 1e-06)
                value.setub(1e4)
            for key, value in m.Mvn.iteritems():
                value.setlb(0.17 + 1e-06)
                value.setub(1e4)
            for key, value in m.y.iteritems():
                value.setlb(0.0)
                value.setub(1.0)
            for key, value in m.x.iteritems():
                value.setlb(0.0)
                value.setub(1.0)
            for key, value in m.L.iteritems():
                value.setlb(0.0)
            for key, value in m.V.iteritems():
                value.setlb(0.0)

    _bound_set(m)

    m.Rec = Param(m.fe, initialize=7.72700925775773761472464684629813e-01)
    # m.Rec = Param(m.fe, initialize=0.05)
    m.Qr = Param(m.fe, initialize=1.78604740940007800236344337463379E+06)

    # m.Qr = Param(m.fe, initialize=1.5e+02)

    # mass balances
    def _MODEtr(m, i, j, k):
        if j > 0 and 1 < k < Ntray:
            return 0.0 == (m.V[i, j, k - 1] - m.V[i, j, k] + m.L[i, j, k + 1] -
                           m.L[i, j, k] + m.feed[k])
        else:
            return Constraint.Skip

    m.MODEtr = Constraint(m.fe, m.cp, m.tray, rule=_MODEtr)

    # m.L[i, j, 1] = B
    def _MODEr(m, i, j):
        if j > 0:
            return 0.0 == (m.L[i, j, 2] - m.L[i, j, 1] - m.V[i, j, 1])
        else:
            return Constraint.Skip

    m.MODEr = Constraint(m.fe, m.cp, rule=_MODEr)

    def _MODEc(m, i, j):
        if j > 0:
            return 0.0 == (m.V[i, j, Ntray - 1] - m.L[i, j, Ntray] - m.D[i, j])
        else:
            return Constraint.Skip

    m.MODEc = Constraint(m.fe, m.cp, rule=_MODEc)

    def _XODEtr(m, i, j, t):
        if j > 0 and 1 < t < Ntray:
            return 0.0 == (m.V[i, j, t - 1] * (m.y[i, j, t - 1] - m.x[i, j, t]) + \
                                                     m.L[i, j, t + 1] * (m.x[i, j, t + 1] - m.x[i, j, t]) - \
                                                     m.V[i, j, t] * (m.y[i, j, t] - m.x[i, j, t]) + \
                                                     m.feed[t] * (m.xf - m.x[i, j, t]))
        else:
            return Constraint.Skip

    m.XODEtr = Constraint(m.fe, m.cp, m.tray, rule=_XODEtr)

    def _xoder(m, i, j):
        if j > 0:
            return 0.0 == (m.L[i, j, 2] * (m.x[i, j, 2] - m.x[i, j, 1]) - \
                                                     m.V[i, j, 1] * (m.y[i, j, 1] - m.x[i, j, 1]))
        else:
            return Constraint.Skip

    m.xoder = Constraint(m.fe, m.cp, rule=_xoder)

    def _xodec(m, i, j):
        if j > 0:
            return 0.0 == \
                   (m.V[i, j, Ntray - 1] * (m.y[i, j, Ntray - 1] - m.x[i, j, Ntray]))
        else:
            return Constraint.Skip

    m.xodec = Constraint(m.fe, m.cp, rule=_xodec)

    def _hrc(m, i, j):
        if j > 0:
            return m.D[i, j] - m.Rec[i] * m.L[i, j, Ntray] == 0
        else:
            return Constraint.Skip

    m.hrc = Constraint(m.fe, m.cp, rule=_hrc)

    # Energy balance
    def _gh(m, i, j, t):
        if j > 0 and 1 < t < Ntray:
            return 0.0 \
                   == (m.V[i, j, t-1] * (m.hv[i, j, t-1] - m.hl[i, j, t]) + m.L[i, j, t+1] * (m.hl[i, j, t+1] - m.hl[i, j, t]) - m.V[i, j, t] * (m.hv[i, j, t] - m.hl[i, j, t]) + m.feed[t] * (m.hf - m.hl[i, j, t]))
            # return m.M[i, j, t] * (m.xdot[i, j, t] * ((m.hlm0 - m.hln0) * m.T[i, j, t]**3 + (m.hlma - m.hlna) * m.T[i, j, t]**2 + (m.hlmb - m.hlnb) * m.T[i, j, t] + m.hlmc - m.hlnc) + m.Tdot[i, j, t]*(3*m.hln0*m.T[i, j, t]**2 + 2*m.hlna * m.T[i, j, t] + m.hlnb + m.x[i, j, t]*(3*(m.hlm0 - m.hln0) * m.T[i, j, t]**2 + 2 * (m.hlma - m.hlna) * m.T[i, j, t] + m.hlmb - m.hlnb))) \
            #        M[i, q, c] * (  xdot[i, q, c] * ((  hlm0 -   hln0) *   T[i, q, c] ^ 3 +  (  hlma -   hlna) *   T[i, q, c] ^ 2 +  (  hlmb -   hlnb) *   T[i, q, c] +   hlmc -   hlnc) +   Tdot[i, q, c]*(3*  hln0 * T[i, q, c] ^ 2 +2 * hlna *   T[i, q, c] +   hlnb +   x[i, q, c]*(3*(  hlm0 -   hln0) *   T[i, q, c] ^ 2 +    2 * (  hlma -   hlna) *   T[i, q, c] +   hlmb -   hlnb))) =
            #            V[i - 1, q, c]*(hv[i - 1, q, c] -   hl[i, q, c]) +   L[i + 1, q, c]*(hl[i + 1, q, c] -   hl[i, q, c]) -   V[i, q, c] * (  hv[i, q, c] -   hl[i, q, c]) +   feed[i] * (  hf -   hl[i, q, c]);

        else:
            return Constraint.Skip
        # M[i,q,c]    *(  xdot[i,q,c]*      ((hlm0 -     hln0) *   T[i,q,c]^3 +    (  hlma - hlna)     * T[i,q,c]^2 +    (  hlmb -   hlnb) *   T[i,q,c]   +   hlmc -   hlnc) +   Tdot[i,q,c]  *(3*  hln0*  T[i,q,c]^2    + 2*  hlna*    T[i,q,c] +     hlnb +   x[i,q,c]*  (3*(  hlm0 -   hln0)    *T[i,q,c]^2    + 2*   (hlma  -   hlna)    *T[i,q,c]+      hlmb -   hlnb)))
        # V[i-1,q,c]    *(  hv[i-1,q,c] -     hl[i,q,c]  ) +   L[i+1,q,c]*    (  hl[i+1,q,c] -     hl[i,q,c]  ) -   V[i,q,c]   * (  hv[i,q,c]   -   hl[i,q,c])   +   feed[i] * (hf   -   hl[i,q,c])

    m.gh = Constraint(m.fe, m.cp, m.tray, rule=_gh)

    def _ghb(m, i, j):
        if j > 0:
            return 0.0 == \
                   (m.L[i, j, 2] * (m.hl[i, j, 2] - m.hl[i, j, 1]) - m.V[i, j, 1] * (m.hv[i, j, 1] - m.hl[i, j, 1]) + m.Qr[i])
            #    M[1,q,c]*  (  xdot[1,q,c]  * ((  hlm0 -   hln0)   *T[1,q,c]^3 +    (hlma     - hlna)*  T[1,q,c]^2 +    (  hlmb -   hlnb)  *T[1,q,c]     + hlmc -   hlnc) +   Tdot[1,q,c]*    (3*    hln0 *   T[1,q,c]^2 +   2 *   hlna *   T[1,q,c]   +   hlnb +   x[1,q,c]    * (3 * (  hlm0 -   hln0) *   T[1,q,c]^2    + 2*(  hlma -   hlna)    *T[1,q,c]     + hlmb - hlnb))) =
            #        L[2,q,c]*    (  hl[2,q,c]   -   hl[1,q,c]  ) -   V[1,q,c]   * (  hv[1,q,c]   -   hl[1,q,c]  ) +   Qr[q] ;
        else:
            return Constraint.Skip

    m.ghb = Constraint(m.fe, m.cp, rule=_ghb)

    def _ghc(m, i, j):
        if j > 0:
            return 0.0 == \
                   (m.V[i, j, Ntray - 1] * (m.hv[i, j, Ntray - 1] - m.hl[i, j, Ntray]) - m.Qc[i, j])
            #M[Ntray, q, c] * (xdot[Ntray, q, c]   * ((hlm0 -     hln0) *   T[Ntray, q, c] ^ 3 + (hlma - hlna) * T[Ntray, q, c] ^ 2 +     (hlmb - hlnb) *       T[Ntray, q, c] + hlmc - hlnc) +       Tdot[Ntray, q, c] * (3 * hln0 * T[Ntray, q, c] ^ 2 +    2 * hlna *    T[Ntray, q, c] +   hlnb +   x[Ntray, q, c] * (3 * (  hlm0 -   hln0) * T[Ntray, q, c] ^ 2 + 2 *    (hlma -   hlna) *   T[Ntray, q, c] +   hlmb -   hlnb))) =
            # V[Ntray - 1, q, c] * (hv[Ntray - 1, q, c]     - hl[Ntray, q, c]) -  Qc[q, c];
        else:
            return Constraint.Skip
            #M[Ntray, q, c] * (  xdot[Ntray, q, c] * ((  hlm0 -   hln0) *   T[Ntray, q, c] ^ 3 + (  hlma -   hlna) *  T[Ntray, q, c] ^ 2 +(hlmb   - hlnb) *     T[Ntray, q, c] +   hlmc - hlnc) +     Tdot[Ntray, q, c] * (3 * hln0 * T[Ntray, q, c] ^ 2 + 2 * hlna * T[Ntray, q, c] +         hlnb + x[Ntray, q, c] *   (3 * (  hlm0 -   hln0) * T[Ntray, q, c] ^ 2 + 2 * (hlma - hlna)      *   T[Ntray, q, c] + hlmb     - hlnb))) =
            # V[Ntray - 1, q, c] * (hv[Ntray - 1, q, c] - hl[Ntray, q, c]) - Qc[q, c];

    m.ghc = Constraint(m.fe, m.cp, rule=_ghc)

    def _hkl(m, i, j, t):
        if j > 0:
            return m.hl[i, j, t] == m.x[i, j, t] * (
                m.hlm0 * m.T[i, j, t]**3 + m.hlma * m.T[i, j, t]**2 +
                m.hlmb * m.T[i, j, t] + m.hlmc) + (1 - m.x[i, j, t]) * (
                    m.hln0 * m.T[i, j, t]**3 + m.hlna * m.T[i, j, t]**2 +
                    m.hlnb * m.T[i, j, t] + m.hlnc)


#                    hl[i, q, c] =    x[i, q, c]*(  hlm0 * T[i, q, c] ^ 3 +  hlma * T[i, q, c] ^ 2 + hlmb * T[i, q, c] + hlmc       ) + (1 - x[i, q, c]  )*(  hln0 * T[i, q, c] ^ 3 +    hlna*  T[i, q, c] ^ 2  + hlnb *   T[i, q, c] +   hlnc);
        else:
            return Constraint.Skip
            #    hl[i,q,c]    =   x[i,q,c]*  (  hlm0*  T[i,q,c]^3 +      hlma *   T[i,q,c]^2 +      hlmb*   T[i,q,c] +      hlmc) + (1 - x[i,q,c])*    (  hln0    *T[i,q,c] ^  3 +   hlna*  T[i,q,c]^2 + hlnb         *T[i,q,c]   +   hlnc) ;

    m.hkl = Constraint(m.fe, m.cp, m.tray, rule=_hkl)

    def _hkv(m, i, j, t):
        if j > 0 and t < Ntray:
            return m.hv[i, j, t] == m.y[i, j, t] * (
                m.hlm0 * m.T[i, j, t]**3 + m.hlma * m.T[i, j, t]**2 +
                m.hlmb * m.T[i, j, t] + m.hlmc +
                m.r * m.Tkm * sqrt(1 - (m.p[t] / m.Pkm) *
                                   (m.Tkm / m.T[i, j, t])**3) *
                (m.a - m.b * m.T[i, j, t] / m.Tkm + m.c1 *
                 (m.T[i, j, t] / m.Tkm)**7 + m.gm *
                 (m.d - m.l * m.T[i, j, t] / m.Tkm + m.f *
                  (m.T[i, j, t] / m.Tkm)**7))) + (1 - m.y[i, j, t]) * (
                      m.hln0 * m.T[i, j, t]**3 + m.hlna * m.T[i, j, t]**2 +
                      m.hlnb * m.T[i, j, t] + m.hlnc +
                      m.r * m.Tkn * sqrt(1 - (m.p[t] / m.Pkn) *
                                         (m.Tkn / m.T[i, j, t])**3) *
                      (m.a - m.b * m.T[i, j, t] / m.Tkn + m.c1 *
                       (m.T[i, j, t] / m.Tkn)**7 + m.gn *
                       (m.d - m.l * m.T[i, j, t] / m.Tkn + m.f *
                        (m.T[i, j, t] / m.Tkn)**7)))
        else:
            return Constraint.Skip

    #            hv[i,q,c] =      y[i,q,c]   *     (hlm0 *   T[i,q,c]^3    +   hlma*    T[i,q,c]^2    +   hlmb *   T[i,q,c] +     hlmc +   r*    Tkm*    sqrt(1 - (  p[i]/  Pkm)*  ( Tkm/  T[i,q,c]) ^ 3  )*(a   -   b*    T[i,q,c]/    Tkm +   c1*  (  T[i,q,c]   /  Tkm) ^7 +   gm*  (  d -   l *   T[i,q,c]  /Tkm +     f*(  T[i,q,c] /   Tkm)^7  ))) + (1 - y[i,q,c]    )*  (  hln0 *   T[i,q,c]  ^3 +    hlna*    T[i,q,c]^   2 +   hlnb*    T[i,q,c]  +    hlnc +   r *   Tkn*  sqrt(1 - (  p[i]/Pkn  )*(  Tkn/  T[i,q,c]  )^3 )*(  a -   b *   T[i,q,c]  /  Tkn   + c1 * (  T[i,q,c]  /  Tkn)^7 +    gn*(  d -   l*    T[i,q,c]/    Tkn +    f*(  T[i,q,c]  / Tkn) ^7 ))) ;

    m.hkv = Constraint(m.fe, m.cp, m.tray, rule=_hkv)

    def _lpm(m, i, j, t):
        if j > 0:
            return m.pm[i, j,
                        t] == exp(m.CapAm - m.CapBm / (m.T[i, j, t] + m.CapCm))
        else:
            return Constraint.Skip

    m.lpm = Constraint(m.fe, m.cp, m.tray, rule=_lpm)

    def _lpn(m, i, j, t):
        if j > 0:
            return m.pn[i, j,
                        t] == exp(m.CapAn - m.CapBn / (m.T[i, j, t] + m.CapCn))
        else:
            return Constraint.Skip

    m.lpn = Constraint(m.fe, m.cp, m.tray, rule=_lpn)

    def _dp(m, i, j, t):
        if j > 0:
            return m.p[t] == m.pm[i, j, t] * m.x[i, j, t] + (
                1 - m.x[i, j, t]) * m.pn[i, j, t]
        else:
            return Constraint.Skip

    m.dp = Constraint(m.fe, m.cp, m.tray, rule=_dp)

    def _gy0(m, i, j):
        if j > 0:
            return m.y[i, j, 1] == m.x[i, j, 1] * m.pm[i, j, 1] / m.p[1]
        else:
            return Constraint.Skip

    m.gy0 = Constraint(m.fe, m.cp, rule=_gy0)

    def _gy(m, i, j, t):
        if j > 0 and 1 < t < Ntray:
            return m.y[i, j, t] == m.alpha[t] * m.x[i, j, t] * m.pm[
                i, j, t] / m.p[t] + (1 - m.alpha[t]) * m.y[i, j, t - 1]
            #y[i, q, c] =    alpha[i] *   x[i, q, c] *   pm[i, q, c] /   p[i] + (1 -  alpha[i]) *   y[i - 1, q, c];
        else:
            return Constraint.Skip

    m.gy = Constraint(m.fe, m.cp, m.tray, rule=_gy)

    def _dMV(m, i, j, t):
        if j > 0 and 1 < t < Ntray:
            return m.Mv[i, j, t] == m.Vm[i, j, t] * m.M[i, j, t]
        else:
            return Constraint.Skip

    m.dMV = Constraint(m.fe, m.cp, m.tray, rule=_dMV)

    def _dMv1(m, i, j):
        if j > 0:
            return m.Mv1[i, j] == m.Vm[i, j, 1] * m.M[i, j, 1]
        else:
            return Constraint.Skip

    m.dMv1 = Constraint(m.fe, m.cp, rule=_dMv1)

    def _dMvn(m, i, j):
        if j > 0:
            return m.Mvn[i, j] == m.Vm[i, j, Ntray] * m.M[i, j, Ntray]
        else:
            return Constraint.Skip

    m.dMvn = Constraint(m.fe, m.cp, rule=_dMvn)

    def _hyd(m, i, j, t):
        if j > 0 and 1 < t < Ntray:
            return m.L[i, j, t] * m.Vm[i, j, t] == 0.166 * (m.Mv[i, j, t] -
                                                            0.155)**1.5
            #        L[i,q,c]*      Vm[i,q,c] =    0.166 * (  Mv[i,q,c]   - 0.155)^1.5 ;
        else:
            return Constraint.Skip

    m.hyd = Constraint(m.fe, m.cp, m.tray, rule=_hyd)

    def _hyd1(m, i, j):
        if j > 0:
            return m.L[i, j, 1] * m.Vm[i, j,
                                       1] == 0.166 * (m.Mv1[i, j] - 8.5)**1.5
        else:
            return Constraint.Skip
            #  L[i,q,c]*Vm[i,q,c] = 0.166*(Mv[i,q,c] - 0.155)^1.5 ;

    m.hyd1 = Constraint(m.fe, m.cp, rule=_hyd1)

    def _hydN(m, i, j):
        if j > 0:
            return m.L[i, j, Ntray] * m.Vm[i, j, Ntray] == 0.166 * (
                m.Mvn[i, j] - 0.17)**1.5
        else:
            return Constraint.Skip
            #  L[i,q,c]*Vm[i,q,c] = 0.166*(Mv[i,q,c] - 0.155)^1.5 ;

    m.hydN = Constraint(m.fe, m.cp, rule=_hydN)

    def _dvm(m, i, j, t):
        if j > 0:
            return m.Vm[i, j, t] == m.x[i, j, t] * (
                (1 / 2288) * 0.2685**
                (1 +
                 (1 - m.T[i, j, t] / 512.4)**0.2453)) + (1 - m.x[i, j, t]) * (
                     (1 / 1235) * 0.27136**(1 +
                                            (1 - m.T[i, j, t] / 536.4)**0.24))
        else:
            return Constraint.Skip
            #   Vm[i,q,c] =          x[i,q,c]   * ( 1/2288 *  0.2685^ (1 + (1 -   T[i,q,c]  /512.4)^0.2453)) +   (1 -   x[i,q,c])   * (1/1235 * 0.27136^ (1 + (1 - T[i,q,c]    /536.4)^ 0.24)) ;

    m.dvm = Constraint(m.fe, m.cp, m.tray, rule=_dvm)

    return m
コード例 #2
0
ファイル: distcpydaemod.py プロジェクト: joycezyu/cappresse
mod.pm = Var(mod.t, mod.tray, initialize=1e4)
mod.pn = Var(mod.t, mod.tray, initialize=1e4)

# Vapor mole flowrate
mod.V = Var(mod.t, mod.tray, initialize=44.0)

def _l_init(m, i, k):
    if 2 <= k <= 21:
        return 83.
    elif 22 <= k <= 42:
        return 23
    elif k == 1:
        return 40

# Liquid mole flowrate
mod.L = Var(mod.t, mod.tray, initialize=_l_init)

# Vapor mole frac & diff var
mod.y = Var(mod.t, mod.tray,
             initialize=lambda m, i, k: ((0.99 - 0.005) / m.Ntray) * k + 0.005)

# Liquid enthalpy # enthalpy
mod.hl = Var(mod.t, mod.tray, initialize=10000.)

# Liquid enthalpy # enthalpy
mod.hv = Var(mod.t, mod.tray, initialize=5e+04)
# Re-boiler & condenser heat
mod.Qc = Var(mod.t, initialize=1.6e06)
mod.D = Var(mod.t, initialize=18.33)
# vol holdups
mod.Vm = Var(mod.t, mod.tray, initialize=6e-05)
コード例 #3
0
    def create_model(self):
        """
        Create and return the mathematical model.
        """

        if options.DEBUG:
            logging.info("Creating model for day %d" % self.day_id)

        # Obtain the orders book
        book = self.orders
        complexOrders = self.complexOrders

        # Create the optimization model
        model = ConcreteModel()
        model.periods = Set(initialize=book.periods)
        maxPeriod = max(book.periods)
        model.bids = Set(initialize=range(len(book.bids)))
        model.L = Set(initialize=book.locations)
        model.sBids = Set(initialize=[
            i for i in range(len(book.bids)) if book.bids[i].type == 'SB'
        ])
        model.bBids = Set(initialize=[
            i for i in range(len(book.bids)) if book.bids[i].type == 'BB'
        ])
        model.cBids = RangeSet(len(complexOrders))  # Complex orders
        model.C = RangeSet(len(self.connections))
        model.directions = RangeSet(2)  # 1 == up, 2 = down TODO: clean

        # Variables
        model.xs = Var(model.sBids, domain=Reals,
                       bounds=(0.0, 1.0))  # Single period bids acceptance
        model.xb = Var(model.bBids, domain=Binary)  # Block bids acceptance
        model.xc = Var(model.cBids, domain=Binary)  # Complex orders acceptance
        model.pi = Var(model.L * model.periods,
                       domain=Reals,
                       bounds=self.priceCap)  # Market prices
        model.s = Var(model.bids, domain=NonNegativeReals)  # Bids
        model.sc = Var(model.cBids, domain=NonNegativeReals)  # complex orders
        model.complexVolume = Var(model.cBids, model.periods,
                                  domain=Reals)  # Bids
        model.pi_lg_up = Var(model.cBids * model.periods,
                             domain=NonNegativeReals)  # Market prices
        model.pi_lg_down = Var(model.cBids * model.periods,
                               domain=NonNegativeReals)  # Market prices
        model.pi_lg = Var(model.cBids * model.periods,
                          domain=Reals)  # Market prices

        def flowBounds(m, c, d, t):
            capacity = self.connections[c - 1].capacity_up[t] if d == 1 else \
                self.connections[c - 1].capacity_down[t]
            return (0, capacity)

        model.f = Var(model.C * model.directions * model.periods,
                      domain=NonNegativeReals,
                      bounds=flowBounds)
        model.u = Var(model.C * model.directions * model.periods,
                      domain=NonNegativeReals)

        # Objective
        def primalObj(m):
            # Single period bids cost
            expr = summation(
                {i: book.bids[i].price * book.bids[i].volume
                 for i in m.sBids}, m.xs)
            # Block bids cost
            expr += summation(
                {
                    i: book.bids[i].price * sum(book.bids[i].volumes.values())
                    for i in m.bBids
                }, m.xb)
            return -expr

        if options.PRIMAL and not options.DUAL:
            model.obj = Objective(rule=primalObj, sense=maximize)

        def primalDualObj(m):
            return primalObj(m) + sum(1e-5 * m.xc[i] for i in model.cBids)

        if options.PRIMAL and options.DUAL:
            model.obj = Objective(rule=primalDualObj, sense=maximize)

        # Complex order constraint
        if options.PRIMAL and options.DUAL:
            model.deactivate_suborders = ConstraintList()
            for o in model.cBids:
                sub_ids = complexOrders[o - 1].ids
                curves = complexOrders[o - 1].curves
                for id in sub_ids:
                    bid = book.bids[id]
                    if bid.period <= complexOrders[o - 1].SSperiods and bid.price == \
                            curves[bid.period].bids[0].price:
                        pass  # This bid, first step of the cruve in the scheduled stop periods, is not automatically deactivated when MIC constraint is not satisfied
                    else:
                        model.deactivate_suborders.add(
                            model.xs[id] <= model.xc[o])

        # Ramping constraints for complex orders
        def complex_volume_def_rule(m, o, p):
            sub_ids = complexOrders[o - 1].ids
            return m.complexVolume[o, p] == sum(m.xs[i] * book.bids[i].volume
                                                for i in sub_ids
                                                if book.bids[i].period == p)

        if options.PRIMAL:
            model.complex_volume_def = Constraint(model.cBids,
                                                  model.periods,
                                                  rule=complex_volume_def_rule)

        def complex_lg_down_rule(m, o, p):
            if p + 1 > maxPeriod or complexOrders[o - 1].ramp_down == None:
                return Constraint.Skip
            else:
                return m.complexVolume[o, p] - m.complexVolume[o, p + 1] <= complexOrders[
                                                                                o - 1].ramp_down * \
                                                                            m.xc[o]

        if options.PRIMAL and options.APPLY_LOAD_GRADIENT:
            model.complex_lg_down = Constraint(model.cBids,
                                               model.periods,
                                               rule=complex_lg_down_rule)

        def complex_lg_up_rule(m, o, p):
            if p + 1 > maxPeriod or complexOrders[o - 1].ramp_up == None:
                return Constraint.Skip
            else:
                return m.complexVolume[o, p + 1] - m.complexVolume[
                    o, p] <= complexOrders[o - 1].ramp_up

        if options.PRIMAL and options.APPLY_LOAD_GRADIENT:
            model.complex_lg_up = Constraint(
                model.cBids, model.periods,
                rule=complex_lg_up_rule)  # Balance constraint

        # Energy balance constraints
        balanceExpr = {l: {t: 0.0 for t in model.periods} for l in model.L}
        for i in model.sBids:  # Simple bids
            bid = book.bids[i]
            balanceExpr[bid.location][bid.period] += bid.volume * model.xs[i]
        for i in model.bBids:  # Block bids
            bid = book.bids[i]
            for t, v in bid.volumes.items():
                balanceExpr[bid.location][t] += v * model.xb[i]

        def balanceCstr(m, l, t):
            export = 0.0
            for c in model.C:
                if self.connections[c - 1].from_id == l:
                    export += m.f[c, 1, t] - m.f[c, 2, t]
                elif self.connections[c - 1].to_id == l:
                    export += m.f[c, 2, t] - m.f[c, 1, t]
            return balanceExpr[l][t] == export

        if options.PRIMAL:
            model.balance = Constraint(model.L * book.periods,
                                       rule=balanceCstr)

        # Surplus of single period bids
        def sBidSurplus(m, i):  # For the "usual" step orders
            bid = book.bids[i]
            if i in self.plain_single_orders:
                return m.s[i] >= (m.pi[bid.location, bid.period] -
                                  bid.price) * bid.volume
            else:
                return Constraint.Skip

        if options.DUAL:
            model.sBidSurplus = Constraint(model.sBids, rule=sBidSurplus)

        # Surplus definition for complex suborders accounting for impact of load gradient condition
        if options.DUAL:
            model.complex_sBidSurplus = ConstraintList()
            for o in model.cBids:
                sub_ids = complexOrders[o - 1].ids
                l = complexOrders[o - 1].location
                for i in sub_ids:
                    bid = book.bids[i]
                    model.complex_sBidSurplus.add(
                        model.s[i] >=
                        (model.pi[l, bid.period] + model.pi_lg[o, bid.period] -
                         bid.price) * bid.volume)

        def LG_price_def_rule(m, o, p):
            l = complexOrders[o - 1].location

            exp = 0
            if options.APPLY_LOAD_GRADIENT:
                D = complexOrders[o - 1].ramp_down
                U = complexOrders[o - 1].ramp_up
                if D is not None:
                    exp += (m.pi_lg_down[o, p - 1] if p > 1 else
                            0) - (m.pi_lg_down[o, p] if p < maxPeriod else 0)
                if U is not None:
                    exp -= (m.pi_lg_up[o, p - 1] if p > 1 else
                            0) - (m.pi_lg_up[o, p] if p < maxPeriod else 0)

            return m.pi_lg[o, p] == exp

        if options.DUAL:
            model.LG_price_def = Constraint(model.cBids,
                                            model.periods,
                                            rule=LG_price_def_rule)

        # Surplus of block bids
        def bBidSurplus(m, i):
            bid = book.bids[i]
            bidVolume = -sum(bid.volumes.values())
            bigM = (self.priceCap[1] -
                    self.priceCap[0]) * bidVolume  # FIXME tighten BIGM
            return m.s[i] + sum([
                m.pi[bid.location, t] * -v for t, v in bid.volumes.items()
            ]) >= bid.cost * bidVolume + bigM * (1 - m.xb[i])

        if options.DUAL:
            model.bBidSurplus = Constraint(model.bBids, rule=bBidSurplus)

        # Surplus of complex orders
        def cBidSurplus(m, o):
            complexOrder = complexOrders[o - 1]
            sub_ids = complexOrder.ids
            if book.bids[sub_ids[0]].volume > 0:  # supply
                bigM = sum((self.priceCap[1] - book.bids[i].price) *
                           book.bids[i].volume for i in sub_ids)
            else:
                bigM = sum((book.bids[i].price - self.priceCap[0]) *
                           book.bids[i].volume for i in sub_ids)
            return m.sc[o] + bigM * (1 - m.xc[o]) >= sum(m.s[i]
                                                         for i in sub_ids)

        if options.DUAL:
            model.cBidSurplus = Constraint(model.cBids, rule=cBidSurplus)

        # Surplus of complex orders
        def cBidSurplus_2(m, o):
            complexOrder = complexOrders[o - 1]
            expr = 0
            for i in complexOrder.ids:
                bid = book.bids[i]
                if (bid.period <= complexOrder.SSperiods) and (
                        bid.price
                        == complexOrder.curves[bid.period].bids[0].price):
                    expr += m.s[i]
            return m.sc[o] >= expr

        if options.DUAL:
            model.cBidSurplus_2 = Constraint(
                model.cBids, rule=cBidSurplus_2)  # MIC constraint

        def cMIC(m, o):
            complexOrder = complexOrders[o - 1]

            if complexOrder.FT == 0 and complexOrder.VT == 0:
                return Constraint.Skip

            expr = 0
            bigM = complexOrder.FT
            for i in complexOrder.ids:
                bid = book.bids[i]
                if (bid.period <= complexOrder.SSperiods) and (
                        bid.price
                        == complexOrder.curves[bid.period].bids[0].price):
                    bigM += (bid.volume * (self.priceCap[1] - bid.price)
                             )  # FIXME assumes order is supply
                expr += bid.volume * m.xs[i] * (bid.price - complexOrder.VT)

            return m.sc[o] + expr + bigM * (1 - m.xc[o]) >= complexOrder.FT

        if options.DUAL and options.PRIMAL:
            model.cMIC = Constraint(model.cBids, rule=cMIC)

        # Dual connections capacity
        def dualCapacity(m, c, t):
            exportPrices = 0.0
            for l in m.L:
                if l == self.connections[c - 1].from_id:
                    exportPrices += m.pi[l, t]
                elif l == self.connections[c - 1].to_id:
                    exportPrices -= m.pi[l, t]
            return m.u[c, 1, t] - m.u[c, 2, t] + exportPrices == 0.0

        if options.DUAL:
            model.dualCapacity = Constraint(model.C * model.periods,
                                            rule=dualCapacity)

        # Dual optimality
        def dualObj(m):
            dualObj = summation(m.s) + summation(m.sc)

            for o in m.cBids:
                sub_ids = complexOrders[o - 1].ids
                for id in sub_ids:
                    dualObj -= m.s[
                        id]  # Remove contribution of complex suborders which were accounted for in prevous summation over single bids

                if options.APPLY_LOAD_GRADIENT:
                    ramp_down = complexOrders[o - 1].ramp_down
                    ramp_up = complexOrders[o - 1].ramp_up
                    for p in m.periods:
                        if p == maxPeriod:
                            continue
                        if ramp_down is not None:
                            dualObj += ramp_down * m.pi_lg_down[
                                o, p]  # Add contribution of load gradient
                        if ramp_up is not None:
                            dualObj += ramp_up * m.pi_lg_up[
                                o, p]  # Add contribution of load gradient

            for c in model.C:
                for t in m.periods:
                    dualObj += self.connections[c - 1].capacity_up[t] * m.u[c,
                                                                            1,
                                                                            t]
                    dualObj += self.connections[c -
                                                1].capacity_down[t] * m.u[c, 2,
                                                                          t]

            return dualObj

        if not options.PRIMAL:
            model.obj = Objective(rule=dualObj, sense=minimize)

        def primalEqualsDual(m):
            return primalObj(m) >= dualObj(m)

        if options.DUAL and options.PRIMAL:
            model.primalEqualsDual = Constraint(rule=primalEqualsDual)

        self.model = model