是否可以为 Pyomo 优化（Python）设置不断变化的参数？

Question

I am trying to do an optimization of an energy system which is constituted of 2 batteries that are supposed to supply energy when a signal (a request of energy) is sent. I have created an abstract model in Pyomo to represent my problem and so far I manage to make it work, however my problem is that my data will continuously change depending on the results of my optimization. For example if a signal is received and the batteries provide some energy then the State of Charge (SoC) will decrease (as there is less charge). I want to be able to update this value such that at the next optimization (when a successive signal comes in) my problem is solved using the real SoC. Another way to formulate this would be: is there a way to use dataframes as input parameters to my Pyomo optimization?

This is my code. My set is called ASSETS because technically I would have multiple assets of different sorts (ie a classic lithium battery and maybe an hydrogen storage).

# iterative1.py
from pyomo.environ import *
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt


## CREATING MODEL, SET AND PARAM
model = AbstractModel()

# Sets of PTU for which the model is being created for 

# model.PTU = Set() 
model.ASSETS = Set()

# Set up the param 
model.MinPower = Param(model.ASSETS)
model.MaxPower = Param(model.ASSETS)
model.Capacity = Param(model.ASSETS)
model.SoC = Param(model.ASSETS)
model.P_rated = Param(model.ASSETS)


    # DATA FROM the EMS csv

FR = 20 #requet of power
# model.SoC = 0.9 
P_rated = 1 #how much the asset is already in use during the request of power

    # Decision variable

# model.Psh = Var(model.PTU, within=Reals)
model.Psh = Var(model.ASSETS, within=Reals)

# Objective Function

def objective_rule(model):
        return FR - sum(model.Psh[i] for i in model.ASSETS)
    
model.PowerProvided = Objective(rule=objective_rule, sense=minimize)


# Constraints

        # defining the rules
        
def MinPowerRated_rule(model,i): # Min rated power limit
    return  - model.MaxPower[i] <= model.Psh[i] 

def MaxPowerRated_rule(model,i): # Max rated power limit
    return  model.Psh[i] <= model.MaxPower[i]

# def PowerRated_rule(model,i):
#     return  model.MinPower[i] <= model.Psh[i] <= model.MaxPower[i]

def MaxCapacityLimits_rule(model,i):  #Checks that the power flex is within the limits of the storage (discharge limit)
    return model.Psh[i] <= model.Capacity[i]*model.SoC[i]/4

def MinCapacityLimits_rule(model,i):  #Checks that the power flex is within the limits of the storage (charge limit)
    return model.Psh[i] >= - model.Capacity[i]*model.SoC[i]/4    

def MaxPowerAvailable_rule(model,i): 
    return model.Psh[i] <= model.MaxPower[i] - P_rated

    # return model.Psh[i] <= model.MaxPower[i] - model.P_rated[i]

def MinPowerAvailable_rule(model,i): 
    return model.Psh[i] >= - (model.MaxPower[i] - P_rated)

    # return model.Psh[i] >= - (model.MaxPower[i] - model.P_rated[i])

        # activating the constraints

model.MaxPowerRated = Constraint(model.ASSETS, rule=MaxPowerRated_rule)
model.MinPowerRated = Constraint(model.ASSETS, rule=MinPowerRated_rule)
model.MaxCapacityLimits = Constraint(model.ASSETS, rule=MaxCapacityLimits_rule)
model.MinCapacityLimits = Constraint(model.ASSETS, rule=MinCapacityLimits_rule)
model.MaxPowerAvailable = Constraint(model.ASSETS, rule=MaxPowerAvailable_rule)
model.MinPowerAvailable = Constraint(model.ASSETS, rule=MinPowerAvailable_rule)

        #create model instance


data = DataPortal() #DataPortal handles the .dat file 
data.load(filename="abstract.dat", model=model)
instance = model.create_instance(data)
opt = SolverFactory('glpk')
opt.solve(instance) 

and I am using the following.dat file to get the parameters for the constraints and objective function.

ASSETS := 1 2; 

param MinPower := 
1 0
2 0;

param MaxPower := 
1 15
2 15;

param Capacity := 
1 30
2 30; 

param SoC :=
1 0.9
2 0.9;

I have tried to change SoC with a dataframe that I would update after every optimization but unfortunately I get an error.

Answer 1

I'd advise a couple of things...

1. Switch over to a ConcreteModel in pyomo . They are easier to deal with and you can use basic python to read data of different types (if needed) or just encode the data into the program. It is easier to deal with and it will be more adaptable than trying to change something in an AbstractModel that you have loaded.

2. You model is "instantaneous" or static right now. It does not represent the passage of time, which is fine. So if I understand you right, some part of the input data will change and you want to re-solve with no dependency on prior solutions. So, as a proof-of-concept, you could (a) make a concrete model, (b) get it running and QA it, (c) put it inside of a loop to solve and outside of the loop, change the input to the parameter and re-solve.

Answer 2

I have been looking around and the best way to do it is using a Dictionary. Pyomo has some examples that can be used as a template. Inside the dictionary values of a dataframe can be directly inserted so that it creates this dynamic aspect (in the sense that the parameters will be changing according to the dataframe). Someone else has advise to use a ConcreteModel but then you will have a very static (and very long to write) model which is not ideal (in the majority of the cases).