Transmission Constraints

Transmission Capacity Rule: The constraint transmission capacity rule defines the variable total transmission capacity \(\kappa_{yaf}\). The variable total transmission capacity is defined by the constraint as the sum of the variable transmission capacity installed \(K_{yaf}\) and the variable new transmission capacity \(\hat{\kappa}_{yaf}\). The mathematical explanation of this rule is given in Multinode optimization model.

In script transmission.py the constraint transmission capacity rule is defined and calculated by the following code fragment:

m.def_transmission_capacity = pyomo.Constraint(
    m.tra_tuples,
    rule=def_transmission_capacity_rule,
    doc='total transmission capacity = inst-cap + new capacity')

def def_transmission_capacity_rule(m, stf, sin, sout, tra, com):
    if m.mode['int']:
        if (sin, sout, tra, com, stf) in m.inst_tra_tuples:
            if (min(m.stf), sin, sout, tra, com) in m.tra_const_cap_dict:
                cap_tra = m.transmission_dict['inst-cap'][
                    (stf, sin, sout, tra, com)]
            else:
                cap_tra = (
                    sum(m.cap_tra_new[stf_built, sin, sout, tra, com]
                        for stf_built in m.stf
                        if (sin, sout, tra, com, stf_built, stf) in
                        m.operational_tra_tuples) +
                    m.transmission_dict['inst-cap']
                    [(min(m.stf), sin, sout, tra, com)])
        else:
            cap_tra = (
                sum(m.cap_tra_new[stf_built, sin, sout, tra, com]
                    for stf_built in m.stf
                    if (sin, sout, tra, com, stf_built, stf) in
                    m.operational_tra_tuples))
    else:
        if (stf, sin, sout, tra, com) in m.tra_const_cap_dict:
            cap_tra = \
                m.transmission_dict['inst-cap'][(stf, sin, sout, tra, com)]
        else:
            cap_tra = (m.cap_tra_new[stf, sin, sout, tra, com] +
                       m.transmission_dict['inst-cap'][
                           (stf, sin, sout, tra, com)])

    return cap_tra

Transmission Output Rule: The constraint transmission output rule defines the variable transmission output commodity flow \(\pi_{yaft}^\text{out}\). The variable transmission output commodity flow is defined by the constraint as the product of the variable transmission input commodity flow \(\pi_{yaft}^\text{in}\) and the parameter transmission efficiency \(e_{yaf}\). The mathematical explanation of this rule is given in Multinode optimization model.

In script transmission.py the constraint transmission output rule is defined and calculated by the following code fragment:

m.def_transmission_output = pyomo.Constraint(
    m.tm, m.tra_tuples,
    rule=def_transmission_output_rule,
    doc='transmission output = transmission input * efficiency')

def def_transmission_output_rule(m, tm, stf, sin, sout, tra, com):
    return (m.e_tra_out[tm, stf, sin, sout, tra, com] ==
            m.e_tra_in[tm, stf, sin, sout, tra, com] *
            m.transmission_dict['eff'][(stf, sin, sout, tra, com)])

Transmission Input By Capacity Rule: The constraint transmission input by capacity rule limits the variable transmission input commodity flow \(\pi_{yaft}^\text{in}\). This constraint prevents the transmission power from exceeding the possible power input capacity of the line. The constraint states that the variable transmission input commodity flow \(\pi_{yaft}^\text{in}\) must be less than or equal to the variable total transmission capacity \(\kappa_{yaf}\), scaled by the size of the time steps :math: Delta t. The mathematical explanation of this rule is given in Multinode optimization model.

In script transmission.py the constraint transmission input by capacity rule is defined and calculated by the following code fragment:

m.res_transmission_input_by_capacity = pyomo.Constraint(
    m.tm, m.tra_tuples,
    rule=res_transmission_input_by_capacity_rule,
    doc='transmission input <= total transmission capacity')

def res_transmission_input_by_capacity_rule(m, tm, stf, sin, sout, tra, com):
    return (m.e_tra_in[tm, stf, sin, sout, tra, com] <=
            m.dt * m.cap_tra[stf, sin, sout, tra, com])

Transmission Capacity Limit Rule: The constraint transmission capacity limit rule limits the variable total transmission capacity \(\kappa_{yaf}\). This constraint restricts a transmission \(f\) through an arc \(a\) in support timeframe \(y\) from having more total power output capacity than an upper bound and having less than a lower bound. The constraint states that the variable total transmission capacity \(\kappa_{yaf}\) must be greater than or equal to the parameter transmission capacity lower bound \(\underline{K}_{yaf}\) and less than or equal to the parameter transmission capacity upper bound \(\overline{K}_{yaf}\). The mathematical explanation of this rule is given in Multinode optimization model.

In script transmission.py the constraint transmission capacity limit rule is defined and calculated by the following code fragment:

m.res_transmission_capacity = pyomo.Constraint(
    m.tra_tuples,
    rule=res_transmission_capacity_rule,
    doc='transmission.cap-lo <= total transmission capacity <= '
        'transmission.cap-up')

def res_transmission_capacity_rule(m, stf, sin, sout, tra, com):
    return (m.transmission_dict['cap-lo'][(stf, sin, sout, tra, com)],
            m.cap_tra[stf, sin, sout, tra, com],
            m.transmission_dict['cap-up'][(stf, sin, sout, tra, com)])

Transmission Symmetry Rule: The constraint transmission symmetry rule defines the power capacities of incoming and outgoing arcs \(a , a'\) of a transmission \(f\) in support timeframe \(y\). The constraint states that the power capacities \(\kappa_{af}\) of the incoming arc \(a\) and the complementary outgoing arc \(a'\) between two sites must be equal. The mathematical explanation of this rule is given in Multinode optimization model.

In script transmission.py the constraint transmission symmetry rule is defined and calculated by the following code fragment:

m.res_transmission_symmetry = pyomo.Constraint(
    m.tra_tuples,
    rule=res_transmission_symmetry_rule,
    doc='total transmission capacity must be symmetric in both directions')

def res_transmission_symmetry_rule(m, stf, sin, sout, tra, com):
    return m.cap_tra[stf, sin, sout, tra, com] == (m.cap_tra
                                                   [stf, sout, sin, tra, com])