Gekko: Code performance decreases after using if3 function - python-3.x

Question

I have two questions about the Gekko library in Python.
Is there any way to increase the below code's performance (Input1, Input2)? The code was solved fast, and the results were correct when lines 170~195 were excluded (commented). However, when I executed the entire code (including lines 170-195), the performance decreased dramatically, and I didn't obtain the results after waiting more than 30 mins. I presumed it was because of the if3 functions in lines 170 and 171 because as soon as I included these lines, the code couldn't be solved.
Even though I defined the days_to_consider variable in lines 61 to 1, I will increase the variable value to 365 days after the code can be executed successfully, which means it is essential for me to solve this code performance problem.
import numpy as np
from gekko import GEKKO
np.set_printoptions(linewidth=2000)
np.set_printoptions(formatter={'float': '{: 0.2f}'.format})
# Given parameters (Please ignore, this is just given input parameters)
left_numeric = np.zeros((14,1))
tempo = [3738.0, 8.5, 1, 1, 1, 2.25, 3.28, 0, 0.6, 1, 0.5, 4, 285000, 0]
for i in range(14):
left_numeric[i,0] = tempo[i]
left_string = ['Urban / City', 'Light : 110,000 * Af', 'Yes', '23. Variable air volume / Water or Water&Air / Air / Yes', '1. Mechanical system only; no provision for natural ventilation', 'Slowly rotating or intermittent heat exchangers (0.7)', 'No exhaust air recirculation', 'Automatic control more than 50%', 'Automatic control more than 50%', 'Taps More Than 3m from Heat Generation', 'Co-Generation (0.9)', '20', '', 'Electricity', 'Electricity', 'Electricity']
weatherData = np.load("Atlanta_TMY3_climate.npy")
weatherData = np.insert(weatherData, 0, np.zeros((1,15)), 0)
Info_Array = np.load("Info_Array.npy")
vsite = 0.8
totalAppliance = 12.0
totalOccupants = 8.39748075577327
hs_unoccupied = 16.0
Cm = 30.55555555
Htr_ms = 22.75
Htr_w = 1.5824055209225467
Htr_is = 15.525
Htr_em = 1.0723552727080168
f_BAC_hc = 0.7
f_BAC_e = 0.87
fcntrl_heat = 0.5
fcntrl_cool = 0.5
dist_heat = 0.9259259
dist_cool = 1.00
totalArea = 877.4
total_DHW_system = 76.40691666666666
effi_gen_DHW = 0.9
occu_equi_hours = 3093.5
Prs = 0.40580206298113436
Prm = 0.5555555555555556
HR_efficiency = 0.7
T_supply_h = 28.0
T_supply_c = 17.0
ventSupply = 2.519244226731981
ventRecirculation = 1
ventilation_cooling_type = 1
dist_heat = 0.9259259
dist_cool = 1.00000
# Create GEKKO model
m = GEKKO(remote=False)
#m.open_folder()
print(m.path)
days_to_consider = 1
m.time = np.linspace(0, 24*days_to_consider, 24*days_to_consider+1)
# Define MVs
fDim = m.MV(lb=1, ub=1, name="fDim") # dummy MV just for testing. In the future more MVs will be added and the interval will also be modified.
fDim.STATUS = 1
f_VT = 1 # this will be an MV, but for now, it is just a constant
# 2D numppy array manipulation (add zero row in the first row of the "Info_Array" and "weatherData")
T_heating_set = m.Param(value = Info_Array[0:24*days_to_consider+1,9], name="T_heating_set")
T_cooling_set = m.Param(value = Info_Array[0:24*days_to_consider+1,10], name="T_cooling_set")
# Define parameters
Te = m.Param(value = weatherData[0:24*days_to_consider+1,0], name="Te")
Wind_speed = m.Param(value = weatherData[0:24*days_to_consider+1,1], name="Wind_speed")
fapp = m.Param(value = Info_Array[0:24*days_to_consider+1,6], name="fapp")
Qapp = totalAppliance
focc = m.Param(value = Info_Array[0:24*days_to_consider+1,5], name="focc")
Qocc = totalOccupants
Qlight = m.Param(value = Info_Array[0:24*days_to_consider+1,8], name="Qlight")
Qsol = m.Param(value = Info_Array[0:24*days_to_consider+1,11], name="Qsol")
qv_infil_wind = m.Param(value = 0.0769*left_numeric[8,0]*(0.75*vsite*weatherData[0:24*days_to_consider+1,1]**2)**0.667, name="qv_infil_wind")
# Define variables
qv_infil_stack = m.Var(0, name="qv_infil_stack")
T_m0_t = m.Var(name="T_m0_t")
T_m10_t = m.Var(name="T_m10_t")
T_m0 = m.Var(name="T_m0")
T_m10 = m.Var(name="T_m10")
T_s0 = m.Var(name="T_s0")
T_s10 = m.Var(name="T_s10")
T_air0 = m.Var(value=hs_unoccupied, name="T_air0")
T_air10 = m.Var(name="T_air10")
T_m_ac_t = m.Var(value=hs_unoccupied, name="T_m_ac_t")
T_m_ac = m.Var(value=hs_unoccupied, name="T_m_ac")
T_s_ac = m.Var(name="T_s_ac")
T_air_ac = m.Var(name="T_air_ac")
T_air_set = m.Var(name="T_air_set")
T_air_set_prev = m.Var(name="T_air_set_prev")
m.delay(T_m_ac_t, T_air_set_prev, 1)
Q_HC_nd = m.Var(value=0, name="Q_HC_nd")
# Define delivered energy
E_heating = m.Var(name="E_heating")
E_cooling = m.Var(name="E_cooling")
E_lighting = m.Var(name="E_lighting")
E_fan = m.Var(name="E_fan")
E_pump = m.Var(name="E_pump")
E_equip = m.Var(name="E_equip")
E_dhw = m.Var(name="E_dhw")
V_heating_sup_air = m.Var(name="V_heating_sup_air")
V_cooling_sup_air = m.Var(name="V_cooling_sup_air")
q_v_sup = m.Var(name="q_v_sup")
# Build building Equations
# 0) Internal heat gains
Qint = m.Intermediate(fapp*Qapp + focc*Qocc + fDim*Qlight, name="Qint")
Qia = m.Intermediate(0.5*Qint, name="Qia")
Qst = m.Intermediate(Prs*(Qia + Qsol), name="Qst")
Qm = m.Intermediate(Prm*(Qia + Qsol), name="Qm")
# 1) Airflow
qv_mech_sup = m.Intermediate(ventSupply*ventRecirculation*focc, name="qv_mech_sup")
m.Equation(qv_infil_stack == 0.0146*left_numeric[8,0]*(0.7*left_numeric[1,0]*m.abs(Te-T_air_set))**0.667)
##qv_infil_stack = m.Intermediate(0.0146*left_numeric[8,0]*(0.7*left_numeric[1,0]*m.abs(Te-T_air_set))**0.667, name="qv_infil_stack")
qv_infil_sw = m.Intermediate(m.max3(qv_infil_stack,qv_infil_wind) + 0.14*qv_infil_stack*qv_infil_wind/left_numeric[8,0], name="qv_infil_sw")
Hve = m.Intermediate((qv_mech_sup*(1-HR_efficiency) + qv_infil_sw)*0.3333, name="Hve")
Htr_1 = m.Intermediate(Hve*Htr_is/(Hve + Htr_is), name="Htr_1")
# 2) Temperature
Tm_denom = m.Intermediate(Htr_ms + Htr_w + Htr_1, name="Tm_denom")
T_m_intermediate = m.Intermediate(0.5*((Htr_1+Htr_w)*Htr_ms/Tm_denom+Htr_em), name="T_m_intermediate")
m.Equations([\
T_m0_t == (1/(Cm+T_m_intermediate))*((Cm-T_m_intermediate)*T_air_set_prev+(Htr_ms*(Htr_w+Htr_1)/Tm_denom+Htr_em)*Te+(Htr_ms/Tm_denom)*Qst+(Htr_ms*Htr_1)/Hve/Tm_denom*(Qia)+Qm),\
T_m10_t == (1/(Cm+T_m_intermediate))*((Cm-T_m_intermediate)*T_air_set_prev+(Htr_ms*(Htr_w+Htr_1)/Tm_denom+Htr_em)*Te+(Htr_ms/Tm_denom)*Qst+(Htr_ms*Htr_1)/Hve/Tm_denom*(Qia+10)+Qm),\
T_m0 == 0.5*(T_air_set_prev+T_m0_t),\
T_m10 == 0.5*(T_air_set_prev+T_m10_t),\
T_s0 == (Htr_ms*T_m0 +(Htr_w+Htr_1)*Te+Qst+Htr_1*Qia/Hve)/Tm_denom,\
T_s10 == (Htr_ms*T_m10+(Htr_w+Htr_1)*Te+Htr_1*10/Hve+Qst+Htr_1*Qia/Hve)/Tm_denom,\
T_air0 == (Htr_is*T_s0 +Hve*Te+Qia)/(Htr_is+Hve),\
T_air10 == (Htr_is*T_s10+Hve*Te+10+Qia)/(Htr_is+Hve)])
# 3. Heating/Cooling need
# Tair set & Q_HC_nd
m.Equations([T_air_set == m.if3(T_air0-T_heating_set, T_heating_set, m.if3(T_cooling_set-T_air0, T_cooling_set, T_air0)),\
Q_HC_nd == 10*(T_air_set-T_air0)/(T_air10-T_air0)])
# 4. Tac & Q_nd
m.Equations([\
T_m_ac_t == (1/(Cm+T_m_intermediate))*((Cm-T_m_intermediate)*T_air_set_prev+(Htr_ms*(Htr_w+Htr_1)/Tm_denom+Htr_em)*Te+(Htr_ms/Tm_denom)*Qst+(Htr_ms*Htr_1)/Hve/Tm_denom*(Qia+Q_HC_nd)+Qm),\
T_m_ac == 0.5*(T_air_set_prev+T_m_ac_t),\
T_s_ac == (Htr_ms*T_m_ac+(Htr_w+Htr_1)*Te+Htr_1*Q_HC_nd/Hve+Qst+Htr_1*Qia/Hve)/Tm_denom,\
T_air_ac == (Htr_is*T_s_ac+Hve*Te+Q_HC_nd+Qia)/(Htr_is+Hve)])
m.Minimize(Q_HC_nd) # please use (uncomment) this line when the upper part of the code (line 1-163) is executed.
#_________________________When below code is included, the solver couldn't solve________________________#
##Q_heat_nd = m.Intermediate(m.if3(Q_HC_nd, 0, Q_HC_nd), name="Q_heat_nd") # suspect that this line slows down the code performance
##Q_cool_nd = m.Intermediate(m.if3(Q_HC_nd, -Q_HC_nd, 0), name="Q_cool_nd")
##
### 5. System delivered energy use (Unit: kW)
##m.Equations([E_heating == Q_heat_nd*f_BAC_hc/(dist_heat*left_numeric[5,0])*totalArea/1000,\
## E_cooling == f_VT*Q_cool_nd*f_BAC_hc/(dist_cool*left_numeric[6,0])*totalArea/1000,\
## E_lighting == fDim*Qlight*totalArea/1000,\
## E_equip == fapp*Qapp*totalArea/1000,\
## E_pump == 8*(fcntrl_heat+fcntrl_cool)/3.6/occu_equi_hours*totalArea,\
## E_dhw == total_DHW_system/effi_gen_DHW/occu_equi_hours*totalArea/1000,\
## V_heating_sup_air == Q_heat_nd*0.0036/(T_supply_h-T_air_ac)/0.001239913,\
## V_cooling_sup_air == Q_cool_nd*0.0036/(T_air_ac-T_supply_c)/0.001239913])
##
##
##if ventilation_cooling_type == 3 and left_numeric[7,0] == 0:
## m.Equation(E_fan == (m.max3(V_heating_sup_air, V_cooling_sup_air))*left_numeric[9,0]*left_numeric[10,0]*f_BAC_e*totalArea/1000)
##
##elif ventilation_cooling_type == 3 and left_numeric[7,0] != 0:
## m.Equation(E_fan == (m.max3(V_heating_sup_air, V_cooling_sup_air)+left_numeric[7,0]*3.6/totalArea*focc)*left_numeric[9,0]*left_numeric[10,0]*f_BAC_e)
##
##elif ventilation_cooling_type != 3 and left_numeric[7,0] == 0:
## m.Equation(E_fan == (m.max3(m.max3(V_heating_sup_air, V_cooling_sup_air),qv_mech_sup*(1-HR_efficiency)))*left_numeric[9,0]*left_numeric[10,0]*f_BAC_e*totalArea/1000)
##
##elif ventilation_cooling_type != 3 and left_numeric[7,0] != 0:
## m.Equation(E_fan == (m.max3(m.max3(V_heating_sup_air, V_cooling_sup_air),qv_mech_sup*(1-HR_efficiency))+left_numeric[7,0]*3.6/totalArea*focc)*left_numeric[9,0]*left_numeric[10,0]*f_BAC_e)
##m.Minimize(E_heating + E_cooling + E_lighting + E_fan + E_equip + E_pump + E_dhw) # please use (uncomment) this line when the entire code is executed.
#_______________________________________________________________________________________________________#
m.options.IMODE = 6
m.options.DIAGLEVEL = 4
m.options.SOLVER = 1
m.options.MAX_ITER = 1000000
m.solve(disp=True, GUI=False, debug=False)
I plan to conduct dynamic optimal control problems, which will be comprised of a total of ~45 MVs from ~10 buildings (the code is shown above, each building has 4-5 MVs) and 1 community PV (1 MV, the model is shown here) for 8,760-time steps(= 365 days x 24 hrs). Do you think this size of the problem is solvable from the IPOPT solver within a few hours on a normal personal laptop (or if the complexity of the IPOPT solver algorithm is available, I would appreciate it)? I think this would be challenging to solve because the number of the MVs becomes about ~400,000 (=~45 MVs x 8,760 hours), and I wonder if the IPOPT solver can handle this size of the optimization problem.

Answer 1

The commented code has 6 max3() functions and 2 if3() functions. Those add one binary variable for each time point so a total of 25 x 8 = 200 binary variables for 1 day and (24*365 + 1) x 8 = 70,088 binary variables for 365 days. The year-long solution would likely take too much time. Here are some suggestions to improve the solution time:
Use m.options.DIAGLEVEL=0 instead of 4. The additional diagnostics take longer with pre-processing.
Try m.options.REDUCE=3 to perform pre-processing to reduce the number of equations, if possible.
Initialize with m.options.SOLVER=3 (IPOPT) and then switch to m.options.SOLVER=1 (APOPT) with to obtain an integer solution. Use m.options.TIME_SHIFT=0 when solving again to keep the initial conditions from changing on the second solve.
Try if2() and max2() as MPCC forms that can solve faster than if3() and max3(), especially for large problems. They sometimes have problems if the solution is at the switch conditions.
Turn off degrees of freedom with .STATUS=0 to first solve without decision variables to obtain an initial feasible solution.
The augmented problem with the lines uncommented appear to be infeasible. Both APOPT and IPOPT reported that the problem is infeasible.
EXIT: Converged to a point of local infeasibility. Problem may be infeasible.
An error occured.
The error code is 2
---------------------------------------------------
Solver : IPOPT (v3.12)
Solution time : 86.0874 sec
Objective : 165.28211287911208
Unsuccessful with error code 0
---------------------------------------------------
The file infeasibilities.txt will have additional insights.