python - Pyomo 问题：使用规则定义约束会产生“builtin_function_or_method”对象没有属性“is_expression_type””

Question

我正在设计一个基于无信号（简单时间序列）、驾驶行为（由“A_matrix”指定，其中一个用于停车，0s 用于驾驶）和一个显示每辆车消耗的消耗向量“E_cons”的电动汽车充电优化模型旅行（为简单起见，此向量仅在旅行开始时具有消耗值。

我的 3 个约束是最小/最大 SOC，我将所有充电事件和所有消耗（直到某个周期步骤“t”）加到初始 SOC 中，并为其提供上限（SOC_max）和下限（SOC_min） . 在定义这些时，我得到了提到的错误；我不知道如何定义从 0 到每一步的总和，t，有什么线索吗？

import pyomo.environ as pe
import numpy as np
import pandas as pd
import os
import datetime


def EV_charging_A_strict(signal, df, A_matrix, E_cons):

    eff  = 0.9; grid_losses = 0.09 # Grid losses at 9 % and charger eff
    f_hour = 60 # Number of timesteps per hour 
    mu = 100000 # Lagrange constant
    signal = signal.resample('T').ffill(); signal = signal.loc[df.start_stamp - datetime.timedelta(hours = 2): df.end_stamp]
    P_ch = 7.25 # Charging power equal to 7.25kW for each EV
    SOC_0 = 0.5 # SOC at start of the simulation
    B = 59.6 # Battery of EVs
    SOC_max = 0.9 # Maximum SOC of 0.9
    SOC_min = 0.1 # Minimum SOC of 0.1

    # Model definition and sets
    t_n = np.arange(len(signal))
    model = pe.ConcreteModel()
    model.t_n = set(range(len(signal)))


    # Defining parameters
    model.E_cons = pe.Param(initialize = E_cons)
    model.A = pe.Param(initialize = A_matrix)

    # model.EVs = range(1) # One EV for now

    # Variable definition
    model.P = pe.Var(model.t_n, within = pe.NonNegativeReals, initialize = 0, bounds = (0, P_ch)) # Charging rate

    # Objective function
    model.obj = pe.Objective(
    expr = sum (model.P[t]*signal.values[t]/(eff*f_hour*(1 - grid_losses)) for t in model.t_n),
    sense = pe.minimize) #+ mu*(P_ch*eff - model.P[t]) 

    #  f_hour
    def minSOC_rule(m, t):
        return SOC_0*B + (sum(m.P.values()) - m.E_cons.value[:t].sum) >= SOC_min*B
    model.minSOC = pe.Constraint(t_n, rule = minSOC_rule)

    def maxSOC_rule(m, t):
        return SOC_0*B + (sum(m.P.values()) - m.E_cons.value[:t].sum) <= SOC_max*B
    model.maxSOC = pe.Constraint(t_n, rule = maxSOC_rule)

    def chargingTime_rule(m,t):
        return m.P[t] - model.P[t]*model.A[t] == 0 # Equivalent to P*(1-A)

    model.chargingTime = pe.Constraint(t_n, rule = chargingTime_rule)

    # Select solver and solve
    sol = pe.SolverFactory('glpk')

    out = sol.solve(model, tee = True)

    return out

标签： pythonoptimizationpyomo